开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llfolderview.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：62k
源码类别：

游戏引擎

开发平台：

C++ Builder

llfolderview.cpp：源码内容
  1. /** 
  2.  * @file llfolderview.cpp
  3.  * @brief Implementation of the folder view collection of classes.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llfolderview.h"
  37. #include "llcallbacklist.h"
  38. #include "llinventorybridge.h"
  39. #include "llinventoryclipboard.h" // *TODO: remove this once hack below gone.
  40. #include "llinventoryfilter.h"
  41. #include "llinventoryfunctions.h"
  42. #include "llinventorypanel.h"
  43. #include "llfoldertype.h"
  44. #include "llfloaterinventory.h"// hacked in for the bonus context menu items.
  45. #include "llkeyboard.h"
  46. #include "lllineeditor.h"
  47. #include "llmenugl.h"
  48. #include "llpanel.h"
  49. #include "llpreview.h"
  50. #include "llscrollcontainer.h" // hack to allow scrolling
  51. #include "lltooldraganddrop.h"
  52. #include "lltrans.h"
  53. #include "llui.h"
  54. #include "llviewertexture.h"
  55. #include "llviewertexturelist.h"
  56. #include "llviewerjointattachment.h"
  57. #include "llviewermenu.h"
  58. #include "lluictrlfactory.h"
  59. #include "llviewercontrol.h"
  60. #include "llviewerfoldertype.h"
  61. #include "llviewerwindow.h"
  62. #include "llvoavatar.h"
  63. #include "llfloaterproperties.h"
  65. // Linden library includes
  66. #include "lldbstrings.h"
  67. #include "llfocusmgr.h"
  68. #include "llfontgl.h"
  69. #include "llgl.h" 
  70. #include "llrender.h"
  71. #include "llinventory.h"
  73. // Third-party library includes
  74. #include <algorithm>
  76. ///----------------------------------------------------------------------------
  77. /// Local function declarations, constants, enums, and typedefs
  78. ///----------------------------------------------------------------------------
  80. const S32 RENAME_WIDTH_PAD = 4;
  81. const S32 RENAME_HEIGHT_PAD = 1;
  82. const S32 AUTO_OPEN_STACK_DEPTH = 16;
  83. const S32 MIN_ITEM_WIDTH_VISIBLE = LLFolderViewItem::ICON_WIDTH
  84. + LLFolderViewItem::ICON_PAD 
  85. + LLFolderViewItem::ARROW_SIZE 
  86. + LLFolderViewItem::TEXT_PAD 
  87. + /*first few characters*/ 40;
  88. const S32 MINIMUM_RENAMER_WIDTH = 80;
  90. enum {
  91. SIGNAL_NO_KEYBOARD_FOCUS = 1,
  92. SIGNAL_KEYBOARD_FOCUS = 2
  93. };
  95. F32 LLFolderView::sAutoOpenTime = 1.f;
  97. void delete_selected_item(void* user_data);
  98. void copy_selected_item(void* user_data);
  99. void open_selected_items(void* user_data);
  100. void properties_selected_items(void* user_data);
  101. void paste_items(void* user_data);
  102. void renamer_focus_lost( LLFocusableElement* handler, void* user_data );
  105. //---------------------------------------------------------------------------
  107. // Tells all folders in a folderview to sort their items
  108. // (and only their items, not folders) by a certain function.
  109. class LLSetItemSortFunction : public LLFolderViewFunctor
  110. {
  111. public:
  112. LLSetItemSortFunction(U32 ordering)
  113. : mSortOrder(ordering) {}
  114. virtual ~LLSetItemSortFunction() {}
  115. virtual void doFolder(LLFolderViewFolder* folder);
  116. virtual void doItem(LLFolderViewItem* item);
  118. U32 mSortOrder;
  119. };
  122. // Set the sort order.
  123. void LLSetItemSortFunction::doFolder(LLFolderViewFolder* folder)
  124. {
  125. folder->setItemSortOrder(mSortOrder);
  126. }
  128. // Do nothing.
  129. void LLSetItemSortFunction::doItem(LLFolderViewItem* item)
  130. {
  131. return;
  132. }
  134. //---------------------------------------------------------------------------
  136. // Tells all folders in a folderview to close themselves
  137. // For efficiency, calls setOpenArrangeRecursively().
  138. // The calling function must then call:
  139. // LLFolderView* root = getRoot();
  140. // if( root )
  141. // {
  142. // root->arrange( NULL, NULL );
  143. // root->scrollToShowSelection();
  144. // }
  145. // to patch things up.
  146. class LLCloseAllFoldersFunctor : public LLFolderViewFunctor
  147. {
  148. public:
  149. LLCloseAllFoldersFunctor(BOOL close) { mOpen = !close; }
  150. virtual ~LLCloseAllFoldersFunctor() {}
  151. virtual void doFolder(LLFolderViewFolder* folder);
  152. virtual void doItem(LLFolderViewItem* item);
  154. BOOL mOpen;
  155. };
  158. // Set the sort order.
  159. void LLCloseAllFoldersFunctor::doFolder(LLFolderViewFolder* folder)
  160. {
  161. folder->setOpenArrangeRecursively(mOpen);
  162. }
  164. // Do nothing.
  165. void LLCloseAllFoldersFunctor::doItem(LLFolderViewItem* item)
  166. { }
  168. ///----------------------------------------------------------------------------
  169. /// Class LLFolderView
  170. ///----------------------------------------------------------------------------
  172. // Default constructor
  173. LLFolderView::LLFolderView(const Params& p)
  174. : LLFolderViewFolder(p),
  175. mScrollContainer( NULL ),
  176. mPopupMenuHandle(),
  177. mAllowMultiSelect(TRUE),
  178. mShowFolderHierarchy(FALSE),
  179. mSourceID(p.task_id),
  180. mRenameItem( NULL ),
  181. mNeedsScroll( FALSE ),
  182. mPinningSelectedItem(FALSE),
  183. mNeedsAutoSelect( FALSE ),
  184. mAutoSelectOverride(FALSE),
  185. mNeedsAutoRename(FALSE),
  186. mDebugFilters(FALSE),
  187. mSortOrder(LLInventoryFilter::SO_FOLDERS_BY_NAME), // This gets overridden by a pref immediately
  188. mFilter( new LLInventoryFilter(p.name) ),
  189. mShowSelectionContext(FALSE),
  190. mShowSingleSelection(FALSE),
  191. mArrangeGeneration(0),
  192. mSignalSelectCallback(0),
  193. mMinWidth(0),
  194. mDragAndDropThisFrame(FALSE),
  195. mCallbackRegistrar(NULL),
  196. mParentPanel(p.parent_panel),
  197. mUseEllipses(false),
  198. mDraggingOverItem(NULL),
  199. mStatusTextBox(NULL)
  200. {
  201. LLRect rect = p.rect;
  202. LLRect new_rect(rect.mLeft, rect.mBottom + getRect().getHeight(), rect.mLeft + getRect().getWidth(), rect.mBottom);
  203. setRect( rect );
  204. reshape(rect.getWidth(), rect.getHeight());
  205. mIsOpen = TRUE; // this view is always open.
  206. mAutoOpenItems.setDepth(AUTO_OPEN_STACK_DEPTH);
  207. mAutoOpenCandidate = NULL;
  208. mAutoOpenTimer.stop();
  209. mKeyboardSelection = FALSE;
  210. const LLFolderViewItem::Params& item_params =
  211. LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
  212. S32 indentation = item_params.folder_indentation();
  213. mIndentation = -indentation; // children start at indentation 0
  214. gIdleCallbacks.addFunction(idle, this);
  216. //clear label
  217. // go ahead and render root folder as usual
  218. // just make sure the label ("Inventory Folder") never shows up
  219. mLabel = LLStringUtil::null;
  221. //mRenamer->setWriteableBgColor(LLColor4::white);
  222. // Escape is handled by reverting the rename, not commiting it (default behavior)
  223. LLLineEditor::Params params;
  224. params.name("ren");
  225. params.rect(rect);
  226. params.font(getLabelFontForStyle(LLFontGL::NORMAL));
  227. params.max_length_bytes(DB_INV_ITEM_NAME_STR_LEN);
  228. params.commit_callback.function(boost::bind(&LLFolderView::commitRename, this, _2));
  229. params.prevalidate_callback(&LLTextValidate::validateASCIIPrintableNoPipe);
  230. params.commit_on_focus_lost(true);
  231. params.visible(false);
  232. mRenamer = LLUICtrlFactory::create<LLLineEditor> (params);
  233. addChild(mRenamer);
  235. // Textbox
  236. LLTextBox::Params text_p;
  237. LLFontGL* font = getLabelFontForStyle(mLabelStyle);
  238. LLRect new_r = LLRect(rect.mLeft + ICON_PAD,
  239.       rect.mTop - TEXT_PAD,
  240.       rect.mRight,
  241.       rect.mTop - TEXT_PAD - llfloor(font->getLineHeight()));
  242. text_p.rect(new_r);
  243. text_p.name(std::string(p.name));
  244. text_p.font(font);
  245. text_p.visible(false);
  246. text_p.allow_html(true);
  247. mStatusTextBox = LLUICtrlFactory::create<LLTextBox> (text_p);
  248. mStatusTextBox->setFollowsLeft();
  249. mStatusTextBox->setFollowsTop();
  250. //addChild(mStatusTextBox);
  253. // make the popup menu available
  254. LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_inventory.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  255. if (!menu)
  256. {
  257. menu = LLUICtrlFactory::getDefaultWidget<LLMenuGL>("inventory_menu");
  258. }
  259. menu->setBackgroundColor(LLUIColorTable::instance().getColor("MenuPopupBgColor"));
  260. mPopupMenuHandle = menu->getHandle();
  262. }
  264. // Destroys the object
  265. LLFolderView::~LLFolderView( void )
  266. {
  267. // The release focus call can potentially call the
  268. // scrollcontainer, which can potentially be called with a partly
  269. // destroyed scollcontainer. Just null it out here, and no worries
  270. // about calling into the invalid scroll container.
  271. // Same with the renamer.
  272. mScrollContainer = NULL;
  273. mRenameItem = NULL;
  274. mRenamer = NULL;
  275. mStatusTextBox = NULL;
  277. if( gEditMenuHandler == this )
  278. {
  279. gEditMenuHandler = NULL;
  280. }
  282. mAutoOpenItems.removeAllNodes();
  283. gIdleCallbacks.deleteFunction(idle, this);
  285. LLView::deleteViewByHandle(mPopupMenuHandle);
  287. if(mRenamer == gFocusMgr.getTopCtrl())
  288. {
  289. gFocusMgr.setTopCtrl(NULL);
  290. }
  292. mAutoOpenItems.removeAllNodes();
  293. clearSelection();
  294. mItems.clear();
  295. mFolders.clear();
  297. mItemMap.clear();
  299. delete mFilter;
  300. mFilter = NULL;
  301. }
  303. BOOL LLFolderView::canFocusChildren() const
  304. {
  305. return FALSE;
  306. }
  308. void LLFolderView::checkTreeResortForModelChanged()
  309. {
  310. if (mSortOrder & LLInventoryFilter::SO_DATE && !(mSortOrder & LLInventoryFilter::SO_FOLDERS_BY_NAME))
  311. {
  312. // This is the case where something got added or removed.  If we are date sorting
  313. // everything including folders, then we need to rebuild the whole tree.
  314. // Just set to something not SO_DATE to force the folder most resent date resort.
  315. mSortOrder = mSortOrder & ~LLInventoryFilter::SO_DATE;
  316. setSortOrder(mSortOrder | LLInventoryFilter::SO_DATE);
  317. }
  318. }
  320. static LLFastTimer::DeclareTimer FTM_SORT("Sort Inventory");
  322. void LLFolderView::setSortOrder(U32 order)
  323. {
  324. if (order != mSortOrder)
  325. {
  326. LLFastTimer t(FTM_SORT);
  327. mSortOrder = order;
  329. for (folders_t::iterator iter = mFolders.begin();
  330.  iter != mFolders.end();)
  331. {
  332. folders_t::iterator fit = iter++;
  333. (*fit)->sortBy(order);
  334. }
  336. arrangeAll();
  337. }
  338. }
  341. U32 LLFolderView::getSortOrder() const
  342. {
  343. return mSortOrder;
  344. }
  346. BOOL LLFolderView::addFolder( LLFolderViewFolder* folder)
  347. {
  348. // enforce sort order of My Inventory followed by Library
  349. if (folder->getListener()->getUUID() == gInventory.getLibraryRootFolderID())
  350. {
  351. mFolders.push_back(folder);
  352. }
  353. else
  354. {
  355. mFolders.insert(mFolders.begin(), folder);
  356. }
  357. folder->setShowLoadStatus(true);
  358. folder->setOrigin(0, 0);
  359. folder->reshape(getRect().getWidth(), 0);
  360. folder->setVisible(FALSE);
  361. addChild( folder );
  362. folder->dirtyFilter();
  363. folder->requestArrange();
  364. return TRUE;
  365. }
  367. void LLFolderView::closeAllFolders()
  368. {
  369. // Close all the folders
  370. setOpenArrangeRecursively(FALSE, LLFolderViewFolder::RECURSE_DOWN);
  371. arrangeAll();
  372. }
  374. void LLFolderView::openFolder(const std::string& foldername)
  375. {
  376. LLFolderViewFolder* inv = findChild<LLFolderViewFolder>(foldername);
  377. if (inv)
  378. {
  379. setSelection(inv, FALSE, FALSE);
  380. inv->setOpen(TRUE);
  381. }
  382. }
  384. void LLFolderView::openTopLevelFolders()
  385. {
  386. for (folders_t::iterator iter = mFolders.begin();
  387.  iter != mFolders.end();)
  388. {
  389. folders_t::iterator fit = iter++;
  390. (*fit)->setOpen(TRUE);
  391. }
  392. }
  394. void LLFolderView::setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse)
  395. {
  396. // call base class to do proper recursion
  397. LLFolderViewFolder::setOpenArrangeRecursively(openitem, recurse);
  398. // make sure root folder is always open
  399. mIsOpen = TRUE;
  400. }
  402. static LLFastTimer::DeclareTimer FTM_ARRANGE("Arrange");
  404. // This view grows and shinks to enclose all of its children items and folders.
  405. S32 LLFolderView::arrange( S32* unused_width, S32* unused_height, S32 filter_generation )
  406. {
  407. LLFastTimer t2(FTM_ARRANGE);
  409. filter_generation = mFilter->getMinRequiredGeneration();
  410. mMinWidth = 0;
  412. mHasVisibleChildren = hasFilteredDescendants(filter_generation);
  413. // arrange always finishes, so optimistically set the arrange generation to the most current
  414. mLastArrangeGeneration = getRoot()->getArrangeGeneration();
  416. LLInventoryFilter::EFolderShow show_folder_state =
  417. getRoot()->getFilter()->getShowFolderState();
  419. S32 total_width = LEFT_PAD;
  420. S32 running_height = mDebugFilters ? llceil(LLFontGL::getFontMonospace()->getLineHeight()) : 0;
  421. S32 target_height = running_height;
  422. S32 parent_item_height = getRect().getHeight();
  424. for (folders_t::iterator iter = mFolders.begin();
  425.  iter != mFolders.end();)
  426. {
  427. folders_t::iterator fit = iter++;
  428. LLFolderViewFolder* folderp = (*fit);
  429. if (getDebugFilters())
  430. {
  431. folderp->setVisible(TRUE);
  432. }
  433. else
  434. {
  435. folderp->setVisible(show_folder_state == LLInventoryFilter::SHOW_ALL_FOLDERS || // always show folders?
  436. (folderp->getFiltered(filter_generation) || folderp->hasFilteredDescendants(filter_generation))); // passed filter or has descendants that passed filter
  437. }
  439. // Need to call arrange regardless of visibility, since children's visibility
  440. // might need to be changed too (e.g. even though a folder is invisible, its
  441. // children also need to be set invisible for state-tracking purposes, e.g.
  442. // llfolderviewitem::filter).
  443. // if (folderp->getVisible())
  444. {
  445. S32 child_height = 0;
  446. S32 child_width = 0;
  447. S32 child_top = parent_item_height - running_height;
  449. target_height += folderp->arrange( &child_width, &child_height, filter_generation );
  451. mMinWidth = llmax(mMinWidth, child_width);
  452. total_width = llmax( total_width, child_width );
  453. running_height += child_height;
  454. folderp->setOrigin( ICON_PAD, child_top - (*fit)->getRect().getHeight() );
  455. }
  456. }
  458. for (items_t::iterator iter = mItems.begin();
  459.  iter != mItems.end();)
  460. {
  461. items_t::iterator iit = iter++;
  462. LLFolderViewItem* itemp = (*iit);
  463. itemp->setVisible(itemp->getFiltered(filter_generation));
  465. if (itemp->getVisible())
  466. {
  467. S32 child_width = 0;
  468. S32 child_height = 0;
  469. S32 child_top = parent_item_height - running_height;
  471. target_height += itemp->arrange( &child_width, &child_height, filter_generation );
  472. itemp->reshape(itemp->getRect().getWidth(), child_height);
  474. mMinWidth = llmax(mMinWidth, child_width);
  475. total_width = llmax( total_width, child_width );
  476. running_height += child_height;
  477. itemp->setOrigin( ICON_PAD, child_top - itemp->getRect().getHeight() );
  478. }
  479. }
  481. LLRect scroll_rect = mScrollContainer->getContentWindowRect();
  482. reshape( llmax(scroll_rect.getWidth(), total_width), running_height );
  484. LLRect new_scroll_rect = mScrollContainer->getContentWindowRect();
  485. if (new_scroll_rect.getWidth() != scroll_rect.getWidth())
  486. {
  487. reshape( llmax(scroll_rect.getWidth(), total_width), running_height );
  488. }
  490. // move item renamer text field to item's new position
  491. updateRenamerPosition();
  493. mTargetHeight = (F32)target_height;
  494. return llround(mTargetHeight);
  495. }
  497. const std::string LLFolderView::getFilterSubString(BOOL trim)
  498. {
  499. return mFilter->getFilterSubString(trim);
  500. }
  502. static LLFastTimer::DeclareTimer FTM_FILTER("Filter Inventory");
  504. void LLFolderView::filter( LLInventoryFilter& filter )
  505. {
  506. LLFastTimer t2(FTM_FILTER);
  507. filter.setFilterCount(llclamp(gSavedSettings.getS32("FilterItemsPerFrame"), 1, 5000));
  509. if (getCompletedFilterGeneration() < filter.getCurrentGeneration())
  510. {
  511. mPassedFilter = FALSE;
  512. mMinWidth = 0;
  513. LLFolderViewFolder::filter(filter);
  514. }
  515. else
  516. {
  517. mPassedFilter = TRUE;
  518. }
  519. }
  521. void LLFolderView::reshape(S32 width, S32 height, BOOL called_from_parent)
  522. {
  523. LLRect scroll_rect;
  524. if (mScrollContainer)
  525. {
  526. scroll_rect = mScrollContainer->getContentWindowRect();
  527. }
  528. width = llmax(mMinWidth, scroll_rect.getWidth());
  530. // restrict width with scroll container's width
  531. if (mUseEllipses)
  532. width = scroll_rect.getWidth();
  534. LLView::reshape(width, height, called_from_parent);
  536. mReshapeSignal(mSelectedItems, FALSE);
  537. }
  539. void LLFolderView::addToSelectionList(LLFolderViewItem* item)
  540. {
  541. if (item->isSelected())
  542. {
  543. removeFromSelectionList(item);
  544. }
  545. if (mSelectedItems.size())
  546. {
  547. mSelectedItems.back()->setIsCurSelection(FALSE);
  548. }
  549. item->setIsCurSelection(TRUE);
  550. mSelectedItems.push_back(item);
  551. }
  553. void LLFolderView::removeFromSelectionList(LLFolderViewItem* item)
  554. {
  555. if (mSelectedItems.size())
  556. {
  557. mSelectedItems.back()->setIsCurSelection(FALSE);
  558. }
  560. selected_items_t::iterator item_iter;
  561. for (item_iter = mSelectedItems.begin(); item_iter != mSelectedItems.end();)
  562. {
  563. if (*item_iter == item)
  564. {
  565. item_iter = mSelectedItems.erase(item_iter);
  566. }
  567. else
  568. {
  569. ++item_iter;
  570. }
  571. }
  572. if (mSelectedItems.size())
  573. {
  574. mSelectedItems.back()->setIsCurSelection(TRUE);
  575. }
  576. }
  578. LLFolderViewItem* LLFolderView::getCurSelectedItem( void )
  579. {
  580. if(mSelectedItems.size())
  581. {
  582. LLFolderViewItem* itemp = mSelectedItems.back();
  583. llassert(itemp->getIsCurSelection());
  584. return itemp;
  585. }
  586. return NULL;
  587. }
  590. // Record the selected item and pass it down the hierachy.
  591. BOOL LLFolderView::setSelection(LLFolderViewItem* selection, BOOL openitem,
  592. BOOL take_keyboard_focus)
  593. {
  594. mSignalSelectCallback = take_keyboard_focus ? SIGNAL_KEYBOARD_FOCUS : SIGNAL_NO_KEYBOARD_FOCUS;
  596. if( selection == this )
  597. {
  598. return FALSE;
  599. }
  601. if( selection && take_keyboard_focus)
  602. {
  603. mParentPanel->setFocus(TRUE);
  604. }
  606. // clear selection down here because change of keyboard focus can potentially
  607. // affect selection
  608. clearSelection();
  610. if(selection)
  611. {
  612. addToSelectionList(selection);
  613. }
  615. BOOL rv = LLFolderViewFolder::setSelection(selection, openitem, take_keyboard_focus);
  616. if(openitem && selection)
  617. {
  618. selection->getParentFolder()->requestArrange();
  619. }
  621. llassert(mSelectedItems.size() <= 1);
  623. return rv;
  624. }
  626. void LLFolderView::setSelectionByID(const LLUUID& obj_id, BOOL take_keyboard_focus)
  627. {
  628. LLFolderViewItem* itemp = getItemByID(obj_id);
  629. if(itemp && itemp->getListener())
  630. {
  631. itemp->arrangeAndSet(TRUE, take_keyboard_focus);
  632. mSelectThisID.setNull();
  633. return;
  634. }
  635. else
  636. {
  637. // save the desired item to be selected later (if/when ready)
  638. mSelectThisID = obj_id;
  639. }
  640. }
  642. void LLFolderView::updateSelection()
  643. {
  644. if (mSelectThisID.notNull())
  645. {
  646. setSelectionByID(mSelectThisID, false);
  647. }
  648. }
  650. BOOL LLFolderView::changeSelection(LLFolderViewItem* selection, BOOL selected)
  651. {
  652. BOOL rv = FALSE;
  654. // can't select root folder
  655. if(!selection || selection == this)
  656. {
  657. return FALSE;
  658. }
  660. if (!mAllowMultiSelect)
  661. {
  662. clearSelection();
  663. }
  665. selected_items_t::iterator item_iter;
  666. for (item_iter = mSelectedItems.begin(); item_iter != mSelectedItems.end(); ++item_iter)
  667. {
  668. if (*item_iter == selection)
  669. {
  670. break;
  671. }
  672. }
  674. BOOL on_list = (item_iter != mSelectedItems.end());
  676. if(selected && !on_list)
  677. {
  678. addToSelectionList(selection);
  679. }
  680. if(!selected && on_list)
  681. {
  682. removeFromSelectionList(selection);
  683. }
  685. rv = LLFolderViewFolder::changeSelection(selection, selected);
  687. mSignalSelectCallback = SIGNAL_KEYBOARD_FOCUS;
  689. return rv;
  690. }
  692. S32 LLFolderView::extendSelection(LLFolderViewItem* selection, LLFolderViewItem* last_selected, LLDynamicArray<LLFolderViewItem*>& items)
  693. {
  694. S32 rv = 0;
  696. // now store resulting selection
  697. if (mAllowMultiSelect)
  698. {
  699. LLFolderViewItem *cur_selection = getCurSelectedItem();
  700. rv = LLFolderViewFolder::extendSelection(selection, cur_selection, items);
  701. for (S32 i = 0; i < items.count(); i++)
  702. {
  703. addToSelectionList(items[i]);
  704. rv++;
  705. }
  706. }
  707. else
  708. {
  709. setSelection(selection, FALSE, FALSE);
  710. rv++;
  711. }
  713. mSignalSelectCallback = SIGNAL_KEYBOARD_FOCUS;
  714. return rv;
  715. }
  717. void LLFolderView::sanitizeSelection()
  718. {
  719. // store off current item in case it is automatically deselected
  720. // and we want to preserve context
  721. LLFolderViewItem* original_selected_item = getCurSelectedItem();
  723. // Cache "Show all folders" filter setting
  724. BOOL show_all_folders = (getRoot()->getFilter()->getShowFolderState() == LLInventoryFilter::SHOW_ALL_FOLDERS);
  726. std::vector<LLFolderViewItem*> items_to_remove;
  727. selected_items_t::iterator item_iter;
  728. for (item_iter = mSelectedItems.begin(); item_iter != mSelectedItems.end(); ++item_iter)
  729. {
  730. LLFolderViewItem* item = *item_iter;
  732. // ensure that each ancestor is open and potentially passes filtering
  733. BOOL visible = item->potentiallyVisible(); // initialize from filter state for this item
  734. // modify with parent open and filters states
  735. LLFolderViewFolder* parent_folder = item->getParentFolder();
  736. if ( parent_folder )
  737. {
  738. if ( show_all_folders )
  739. { // "Show all folders" is on, so this folder is visible
  740. visible = TRUE;
  741. }
  742. else
  743. { // Move up through parent folders and see what's visible
  744. while(parent_folder)
  745. {
  746. visible = visible && parent_folder->isOpen() && parent_folder->potentiallyVisible();
  747. parent_folder = parent_folder->getParentFolder();
  748. }
  749. }
  750. }
  752. //  deselect item if any ancestor is closed or didn't pass filter requirements.
  753. if (!visible)
  754. {
  755. items_to_remove.push_back(item);
  756. }
  758. // disallow nested selections (i.e. folder items plus one or more ancestors)
  759. // could check cached mum selections count and only iterate if there are any
  760. // but that may be a premature optimization.
  761. selected_items_t::iterator other_item_iter;
  762. for (other_item_iter = mSelectedItems.begin(); other_item_iter != mSelectedItems.end(); ++other_item_iter)
  763. {
  764. LLFolderViewItem* other_item = *other_item_iter;
  765. for( parent_folder = other_item->getParentFolder(); parent_folder; parent_folder = parent_folder->getParentFolder())
  766. {
  767. if (parent_folder == item)
  768. {
  769. // this is a descendent of the current folder, remove from list
  770. items_to_remove.push_back(other_item);
  771. break;
  772. }
  773. }
  774. }
  776. // Don't allow invisible items (such as root folders) to be selected.
  777. if (item->getHidden())
  778. {
  779. items_to_remove.push_back(item);
  780. }
  781. }
  783. std::vector<LLFolderViewItem*>::iterator item_it;
  784. for (item_it = items_to_remove.begin(); item_it != items_to_remove.end(); ++item_it )
  785. {
  786. changeSelection(*item_it, FALSE); // toggle selection (also removes from list)
  787. }
  789. // if nothing selected after prior constraints...
  790. if (mSelectedItems.empty())
  791. {
  792. // ...select first available parent of original selection, or "My Inventory" otherwise
  793. LLFolderViewItem* new_selection = NULL;
  794. if (original_selected_item)
  795. {
  796. for(LLFolderViewFolder* parent_folder = original_selected_item->getParentFolder();
  797. parent_folder;
  798. parent_folder = parent_folder->getParentFolder())
  799. {
  800. if (parent_folder->potentiallyVisible() && !parent_folder->getHidden())
  801. {
  802. // give initial selection to first ancestor folder that potentially passes the filter
  803. if (!new_selection)
  804. {
  805. new_selection = parent_folder;
  806. }
  808. // if any ancestor folder of original item is closed, move the selection up 
  809. // to the highest closed
  810. if (!parent_folder->isOpen())
  811. {
  812. new_selection = parent_folder;
  813. }
  814. }
  815. }
  816. }
  817. else
  818. {
  819. // nothing selected to start with, so pick "My Inventory" as best guess
  820. new_selection = getItemByID(gInventory.getRootFolderID());
  821. // ... except if it's hidden from the UI.
  822. if (new_selection && new_selection->getHidden())
  823. {
  824. new_selection = NULL;
  825. }
  826. }
  828. if (new_selection)
  829. {
  830. setSelection(new_selection, FALSE, FALSE);
  831. }
  832. }
  833. }
  835. void LLFolderView::clearSelection()
  836. {
  837. if (mSelectedItems.size() > 0)
  838. {
  839. recursiveDeselect(FALSE);
  840. mSelectedItems.clear();
  841. }
  842. mSelectThisID.setNull();
  843. }
  845. BOOL LLFolderView::getSelectionList(std::set<LLUUID> &selection) const
  846. {
  847. for (selected_items_t::const_iterator item_it = mSelectedItems.begin(); 
  848.  item_it != mSelectedItems.end(); 
  849.  ++item_it)
  850. {
  851. selection.insert((*item_it)->getListener()->getUUID());
  852. }
  854. return (selection.size() != 0);
  855. }
  857. BOOL LLFolderView::startDrag(LLToolDragAndDrop::ESource source)
  858. {
  859. std::vector<EDragAndDropType> types;
  860. std::vector<LLUUID> cargo_ids;
  861. selected_items_t::iterator item_it;
  862. BOOL can_drag = TRUE;
  863. if (!mSelectedItems.empty())
  864. {
  865. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  866. {
  867. EDragAndDropType type = DAD_NONE;
  868. LLUUID id = LLUUID::null;
  869. can_drag = can_drag && (*item_it)->getListener()->startDrag(&type, &id);
  871. types.push_back(type);
  872. cargo_ids.push_back(id);
  873. }
  875. LLToolDragAndDrop::getInstance()->beginMultiDrag(types, cargo_ids, source, mSourceID); 
  876. }
  877. return can_drag;
  878. }
  880. void LLFolderView::commitRename( const LLSD& data )
  881. {
  882. finishRenamingItem();
  883. }
  885. void LLFolderView::draw()
  886. {
  887. static LLUIColor sSearchStatusColor = LLUIColorTable::instance().getColor("InventorySearchStatusColor", LLColor4::white);
  888. if (mDebugFilters)
  889. {
  890. std::string current_filter_string = llformat("Current Filter: %d, Least Filter: %d, Auto-accept Filter: %d",
  891. mFilter->getCurrentGeneration(), mFilter->getMinRequiredGeneration(), mFilter->getMustPassGeneration());
  892. LLFontGL::getFontMonospace()->renderUTF8(current_filter_string, 0, 2, 
  893. getRect().getHeight() - LLFontGL::getFontMonospace()->getLineHeight(), LLColor4(0.5f, 0.5f, 0.8f, 1.f), 
  894. LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE );
  895. }
  897. //LLFontGL* font = getLabelFontForStyle(mLabelStyle);
  899. // if cursor has moved off of me during drag and drop
  900. // close all auto opened folders
  901. if (!mDragAndDropThisFrame)
  902. {
  903. closeAutoOpenedFolders();
  904. }
  906. // while dragging, update selection rendering to reflect single/multi drag status
  907. if (LLToolDragAndDrop::getInstance()->hasMouseCapture())
  908. {
  909. EAcceptance last_accept = LLToolDragAndDrop::getInstance()->getLastAccept();
  910. if (last_accept == ACCEPT_YES_SINGLE || last_accept == ACCEPT_YES_COPY_SINGLE)
  911. {
  912. setShowSingleSelection(TRUE);
  913. }
  914. else
  915. {
  916. setShowSingleSelection(FALSE);
  917. }
  918. }
  919. else
  920. {
  921. setShowSingleSelection(FALSE);
  922. }
  925. if (mSearchTimer.getElapsedTimeF32() > gSavedSettings.getF32("TypeAheadTimeout") || !mSearchString.size())
  926. {
  927. mSearchString.clear();
  928. }
  930. if (hasVisibleChildren()
  931. || mFilter->getShowFolderState() == LLInventoryFilter::SHOW_ALL_FOLDERS)
  932. {
  933. mStatusText.clear();
  934. mStatusTextBox->setVisible( FALSE );
  935. }
  936. else
  937. {
  938. if (gInventory.backgroundFetchActive() || mCompletedFilterGeneration < mFilter->getMinRequiredGeneration())
  939. {
  940. mStatusText = LLTrans::getString("Searching");
  941. //font->renderUTF8(mStatusText, 0, 2, 1, sSearchStatusColor, LLFontGL::LEFT, LLFontGL::TOP, LLFontGL::NORMAL,  LLFontGL::NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE );
  942. }
  943. else
  944. {
  945. mStatusText = LLTrans::getString(getFilter()->getEmptyLookupMessage());
  946. //font->renderUTF8(mStatusText, 0, 2, 1, sSearchStatusColor, LLFontGL::LEFT, LLFontGL::TOP, LLFontGL::NORMAL,  LLFontGL::NO_SHADOW, S32_MAX, S32_MAX, NULL, FALSE );
  947. }
  948. mStatusTextBox->setValue(mStatusText);
  949. mStatusTextBox->setVisible( TRUE );
  951. }
  953. LLFolderViewFolder::draw();
  955. mDragAndDropThisFrame = FALSE;
  956. }
  958. void LLFolderView::finishRenamingItem( void )
  959. {
  960. if(!mRenamer)
  961. {
  962. return;
  963. }
  964. if( mRenameItem )
  965. {
  966. mRenameItem->rename( mRenamer->getText() );
  967. }
  969. gFocusMgr.setTopCtrl( NULL );
  971. if( mRenameItem )
  972. {
  973. setSelectionFromRoot( mRenameItem, TRUE );
  974. mRenameItem = NULL;
  975. }
  977. // List is re-sorted alphabeticly, so scroll to make sure the selected item is visible.
  978. scrollToShowSelection();
  979. }
  981. void LLFolderView::closeRenamer( void )
  982. {
  983. // will commit current name (which could be same as original name)
  984. mRenamer->setFocus( FALSE );
  985. mRenamer->setVisible( FALSE );
  986. gFocusMgr.setTopCtrl( NULL );
  988. if( mRenameItem )
  989. {
  990. setSelectionFromRoot( mRenameItem, TRUE );
  991. mRenameItem = NULL;
  992. }
  993. }
  995. void LLFolderView::removeSelectedItems( void )
  996. {
  997. if(getVisible() && getEnabled())
  998. {
  999. // just in case we're removing the renaming item.
  1000. mRenameItem = NULL;
  1002. // create a temporary structure which we will use to remove
  1003. // items, since the removal will futz with internal data
  1004. // structures.
  1005. std::vector<LLFolderViewItem*> items;
  1006. S32 count = mSelectedItems.size();
  1007. if(count == 0) return;
  1008. LLFolderViewItem* item = NULL;
  1009. selected_items_t::iterator item_it;
  1010. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1011. {
  1012. item = *item_it;
  1013. if(item->isRemovable())
  1014. {
  1015. items.push_back(item);
  1016. }
  1017. else
  1018. {
  1019. llinfos << "Cannot delete " << item->getName() << llendl;
  1020. return;
  1021. }
  1022. }
  1024. // iterate through the new container.
  1025. count = items.size();
  1026. LLUUID new_selection_id;
  1027. if(count == 1)
  1028. {
  1029. LLFolderViewItem* item_to_delete = items[0];
  1030. LLFolderViewFolder* parent = item_to_delete->getParentFolder();
  1031. LLFolderViewItem* new_selection = item_to_delete->getNextOpenNode(FALSE);
  1032. if (!new_selection)
  1033. {
  1034. new_selection = item_to_delete->getPreviousOpenNode(FALSE);
  1035. }
  1036. if(parent)
  1037. {
  1038. if (parent->removeItem(item_to_delete))
  1039. {
  1040. // change selection on successful delete
  1041. if (new_selection)
  1042. {
  1043. setSelectionFromRoot(new_selection, new_selection->isOpen(), mParentPanel->hasFocus());
  1044. }
  1045. else
  1046. {
  1047. setSelectionFromRoot(NULL, mParentPanel->hasFocus());
  1048. }
  1049. }
  1050. }
  1051. arrangeAll();
  1052. }
  1053. else if (count > 1)
  1054. {
  1055. LLDynamicArray<LLFolderViewEventListener*> listeners;
  1056. LLFolderViewEventListener* listener;
  1057. LLFolderViewItem* last_item = items[count - 1];
  1058. LLFolderViewItem* new_selection = last_item->getNextOpenNode(FALSE);
  1059. while(new_selection && new_selection->isSelected())
  1060. {
  1061. new_selection = new_selection->getNextOpenNode(FALSE);
  1062. }
  1063. if (!new_selection)
  1064. {
  1065. new_selection = last_item->getPreviousOpenNode(FALSE);
  1066. while (new_selection && new_selection->isSelected())
  1067. {
  1068. new_selection = new_selection->getPreviousOpenNode(FALSE);
  1069. }
  1070. }
  1071. if (new_selection)
  1072. {
  1073. setSelectionFromRoot(new_selection, new_selection->isOpen(), mParentPanel->hasFocus());
  1074. }
  1075. else
  1076. {
  1077. setSelectionFromRoot(NULL, mParentPanel->hasFocus());
  1078. }
  1080. for(S32 i = 0; i < count; ++i)
  1081. {
  1082. listener = items[i]->getListener();
  1083. if(listener && (listeners.find(listener) == LLDynamicArray<LLFolderViewEventListener*>::FAIL))
  1084. {
  1085. listeners.put(listener);
  1086. }
  1087. }
  1088. listener = listeners.get(0);
  1089. if(listener)
  1090. {
  1091. listener->removeBatch(listeners);
  1092. }
  1093. }
  1094. arrangeAll();
  1095. scrollToShowSelection();
  1096. }
  1097. }
  1099. // open the selected item.
  1100. void LLFolderView::openSelectedItems( void )
  1101. {
  1102. if(getVisible() && getEnabled())
  1103. {
  1104. if (mSelectedItems.size() == 1)
  1105. {
  1106. mSelectedItems.front()->openItem();
  1107. }
  1108. else
  1109. {
  1110. LLMultiPreview* multi_previewp = new LLMultiPreview();
  1111. LLMultiProperties* multi_propertiesp = new LLMultiProperties();
  1113. selected_items_t::iterator item_it;
  1114. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1115. {
  1116. // IT_{OBJECT,ATTACHMENT} creates LLProperties
  1117. // floaters; others create LLPreviews.  Put
  1118. // each one in the right type of container.
  1119. LLFolderViewEventListener* listener = (*item_it)->getListener();
  1120. bool is_prop = listener && (listener->getInventoryType() == LLInventoryType::IT_OBJECT || listener->getInventoryType() == LLInventoryType::IT_ATTACHMENT);
  1121. if (is_prop)
  1122. LLFloater::setFloaterHost(multi_propertiesp);
  1123. else
  1124. LLFloater::setFloaterHost(multi_previewp);
  1125. (*item_it)->openItem();
  1126. }
  1128. LLFloater::setFloaterHost(NULL);
  1129. // *NOTE: LLMulti* will safely auto-delete when open'd
  1130. // without any children.
  1131. multi_previewp->openFloater(LLSD());
  1132. multi_propertiesp->openFloater(LLSD());
  1133. }
  1134. }
  1135. }
  1137. void LLFolderView::propertiesSelectedItems( void )
  1138. {
  1139. if(getVisible() && getEnabled())
  1140. {
  1141. if (mSelectedItems.size() == 1)
  1142. {
  1143. LLFolderViewItem* folder_item = mSelectedItems.front();
  1144. if(!folder_item) return;
  1145. folder_item->getListener()->showProperties();
  1146. }
  1147. else
  1148. {
  1149. LLMultiProperties* multi_propertiesp = new LLMultiProperties();
  1151. LLFloater::setFloaterHost(multi_propertiesp);
  1153. selected_items_t::iterator item_it;
  1154. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1155. {
  1156. (*item_it)->getListener()->showProperties();
  1157. }
  1159. LLFloater::setFloaterHost(NULL);
  1160. multi_propertiesp->openFloater(LLSD());
  1161. }
  1162. }
  1163. }
  1165. void LLFolderView::changeType(LLInventoryModel *model, LLFolderType::EType new_folder_type)
  1166. {
  1167. LLFolderBridge *folder_bridge = LLFolderBridge::sSelf;
  1169. if (!folder_bridge) return;
  1170. LLViewerInventoryCategory *cat = folder_bridge->getCategory();
  1171. if (!cat) return;
  1172. cat->changeType(new_folder_type);
  1173. }
  1175. void LLFolderView::autoOpenItem( LLFolderViewFolder* item )
  1176. {
  1177. if (mAutoOpenItems.check() == item || mAutoOpenItems.getDepth() >= (U32)AUTO_OPEN_STACK_DEPTH)
  1178. {
  1179. return;
  1180. }
  1182. // close auto-opened folders
  1183. LLFolderViewFolder* close_item = mAutoOpenItems.check();
  1184. while (close_item && close_item != item->getParentFolder())
  1185. {
  1186. mAutoOpenItems.pop();
  1187. close_item->setOpenArrangeRecursively(FALSE);
  1188. close_item = mAutoOpenItems.check();
  1189. }
  1191. item->requestArrange();
  1193. mAutoOpenItems.push(item);
  1195. item->setOpen(TRUE);
  1196. LLRect content_rect = mScrollContainer->getContentWindowRect();
  1197. LLRect constraint_rect(0,content_rect.getHeight(), content_rect.getWidth(), 0);
  1198. scrollToShowItem(item, constraint_rect);
  1199. }
  1201. void LLFolderView::closeAutoOpenedFolders()
  1202. {
  1203. while (mAutoOpenItems.check())
  1204. {
  1205. LLFolderViewFolder* close_item = mAutoOpenItems.pop();
  1206. close_item->setOpen(FALSE);
  1207. }
  1209. if (mAutoOpenCandidate)
  1210. {
  1211. mAutoOpenCandidate->setAutoOpenCountdown(0.f);
  1212. }
  1213. mAutoOpenCandidate = NULL;
  1214. mAutoOpenTimer.stop();
  1215. }
  1217. BOOL LLFolderView::autoOpenTest(LLFolderViewFolder* folder)
  1218. {
  1219. if (folder && mAutoOpenCandidate == folder)
  1220. {
  1221. if (mAutoOpenTimer.getStarted())
  1222. {
  1223. if (!mAutoOpenCandidate->isOpen())
  1224. {
  1225. mAutoOpenCandidate->setAutoOpenCountdown(clamp_rescale(mAutoOpenTimer.getElapsedTimeF32(), 0.f, sAutoOpenTime, 0.f, 1.f));
  1226. }
  1227. if (mAutoOpenTimer.getElapsedTimeF32() > sAutoOpenTime)
  1228. {
  1229. autoOpenItem(folder);
  1230. mAutoOpenTimer.stop();
  1231. return TRUE;
  1232. }
  1233. }
  1234. return FALSE;
  1235. }
  1237. // otherwise new candidate, restart timer
  1238. if (mAutoOpenCandidate)
  1239. {
  1240. mAutoOpenCandidate->setAutoOpenCountdown(0.f);
  1241. }
  1242. mAutoOpenCandidate = folder;
  1243. mAutoOpenTimer.start();
  1244. return FALSE;
  1245. }
  1247. BOOL LLFolderView::canCopy() const
  1248. {
  1249. if (!(getVisible() && getEnabled() && (mSelectedItems.size() > 0)))
  1250. {
  1251. return FALSE;
  1252. }
  1254. for (selected_items_t::const_iterator selected_it = mSelectedItems.begin(); selected_it != mSelectedItems.end(); ++selected_it)
  1255. {
  1256. const LLFolderViewItem* item = *selected_it;
  1257. if (!item->getListener()->isItemCopyable())
  1258. {
  1259. return FALSE;
  1260. }
  1261. }
  1262. return TRUE;
  1263. }
  1265. // copy selected item
  1266. void LLFolderView::copy()
  1267. {
  1268. // *NOTE: total hack to clear the inventory clipboard
  1269. LLInventoryClipboard::instance().reset();
  1270. S32 count = mSelectedItems.size();
  1271. if(getVisible() && getEnabled() && (count > 0))
  1272. {
  1273. LLFolderViewEventListener* listener = NULL;
  1274. selected_items_t::iterator item_it;
  1275. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1276. {
  1277. listener = (*item_it)->getListener();
  1278. if(listener)
  1279. {
  1280. listener->copyToClipboard();
  1281. }
  1282. }
  1283. }
  1284. mSearchString.clear();
  1285. }
  1287. BOOL LLFolderView::canCut() const
  1288. {
  1289. if (!(getVisible() && getEnabled() && (mSelectedItems.size() > 0)))
  1290. {
  1291. return FALSE;
  1292. }
  1294. for (selected_items_t::const_iterator selected_it = mSelectedItems.begin(); selected_it != mSelectedItems.end(); ++selected_it)
  1295. {
  1296. const LLFolderViewItem* item = *selected_it;
  1297. const LLFolderViewEventListener* listener = item->getListener();
  1299. if (!listener || !listener->isItemRemovable())
  1300. {
  1301. return FALSE;
  1302. }
  1303. }
  1304. return TRUE;
  1305. }
  1307. void LLFolderView::cut()
  1308. {
  1309. // clear the inventory clipboard
  1310. LLInventoryClipboard::instance().reset();
  1311. S32 count = mSelectedItems.size();
  1312. if(getVisible() && getEnabled() && (count > 0))
  1313. {
  1314. LLFolderViewEventListener* listener = NULL;
  1315. selected_items_t::iterator item_it;
  1316. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1317. {
  1318. listener = (*item_it)->getListener();
  1319. if(listener)
  1320. {
  1321. listener->cutToClipboard();
  1322. }
  1323. }
  1324. }
  1325. mSearchString.clear();
  1326. }
  1328. BOOL LLFolderView::canPaste() const
  1329. {
  1330. if (mSelectedItems.empty())
  1331. {
  1332. return FALSE;
  1333. }
  1335. if(getVisible() && getEnabled())
  1336. {
  1337. for (selected_items_t::const_iterator item_it = mSelectedItems.begin();
  1338.  item_it != mSelectedItems.end(); ++item_it)
  1339. {
  1340. // *TODO: only check folders and parent folders of items
  1341. const LLFolderViewItem* item = (*item_it);
  1342. const LLFolderViewEventListener* listener = item->getListener();
  1343. if(!listener || !listener->isClipboardPasteable())
  1344. {
  1345. const LLFolderViewFolder* folderp = item->getParentFolder();
  1346. listener = folderp->getListener();
  1347. if (!listener || !listener->isClipboardPasteable())
  1348. {
  1349. return FALSE;
  1350. }
  1351. }
  1352. }
  1353. return TRUE;
  1354. }
  1355. return FALSE;
  1356. }
  1358. // paste selected item
  1359. void LLFolderView::paste()
  1360. {
  1361. if(getVisible() && getEnabled())
  1362. {
  1363. // find set of unique folders to paste into
  1364. std::set<LLFolderViewItem*> folder_set;
  1366. selected_items_t::iterator selected_it;
  1367. for (selected_it = mSelectedItems.begin(); selected_it != mSelectedItems.end(); ++selected_it)
  1368. {
  1369. LLFolderViewItem* item = *selected_it;
  1370. LLFolderViewEventListener* listener = item->getListener();
  1371. if (listener->getInventoryType() != LLInventoryType::IT_CATEGORY)
  1372. {
  1373. item = item->getParentFolder();
  1374. }
  1375. folder_set.insert(item);
  1376. }
  1378. std::set<LLFolderViewItem*>::iterator set_iter;
  1379. for(set_iter = folder_set.begin(); set_iter != folder_set.end(); ++set_iter)
  1380. {
  1381. LLFolderViewEventListener* listener = (*set_iter)->getListener();
  1382. if(listener && listener->isClipboardPasteable())
  1383. {
  1384. listener->pasteFromClipboard();
  1385. }
  1386. }
  1387. }
  1388. mSearchString.clear();
  1389. }
  1391. // public rename functionality - can only start the process
  1392. void LLFolderView::startRenamingSelectedItem( void )
  1393. {
  1394. // make sure selection is visible
  1395. scrollToShowSelection();
  1397. S32 count = mSelectedItems.size();
  1398. LLFolderViewItem* item = NULL;
  1399. if(count > 0)
  1400. {
  1401. item = mSelectedItems.front();
  1402. }
  1403. if(getVisible() && getEnabled() && (count == 1) && item && item->getListener() &&
  1404.    item->getListener()->isItemRenameable())
  1405. {
  1406. mRenameItem = item;
  1408. updateRenamerPosition();
  1411. mRenamer->setText(item->getName());
  1412. mRenamer->selectAll();
  1413. mRenamer->setVisible( TRUE );
  1414. // set focus will fail unless item is visible
  1415. mRenamer->setFocus( TRUE );
  1416. mRenamer->setTopLostCallback(boost::bind(onRenamerLost, _1));
  1417. mRenamer->setFocusLostCallback(boost::bind(onRenamerLost, _1));
  1418. gFocusMgr.setTopCtrl( mRenamer );
  1419. }
  1420. }
  1422. BOOL LLFolderView::handleKeyHere( KEY key, MASK mask )
  1423. {
  1424. BOOL handled = FALSE;
  1426. // SL-51858: Key presses are not being passed to the Popup menu.
  1427. // A proper fix is non-trivial so instead just close the menu.
  1428. LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
  1429. if (menu && menu->isOpen())
  1430. {
  1431. LLMenuGL::sMenuContainer->hideMenus();
  1432. }
  1434. LLView *item = NULL;
  1435. if (getChildCount() > 0)
  1436. {
  1437. item = *(getChildList()->begin());
  1438. }
  1440. switch( key )
  1441. {
  1442. case KEY_F2:
  1443. mSearchString.clear();
  1444. startRenamingSelectedItem();
  1445. handled = TRUE;
  1446. break;
  1448. case KEY_RETURN:
  1449. if (mask == MASK_NONE)
  1450. {
  1451. if( mRenameItem && mRenamer->getVisible() )
  1452. {
  1453. finishRenamingItem();
  1454. mSearchString.clear();
  1455. handled = TRUE;
  1456. }
  1457. else
  1458. {
  1459. LLFolderView::openSelectedItems();
  1460. handled = TRUE;
  1461. }
  1462. }
  1463. break;
  1465. case KEY_ESCAPE:
  1466. if( mRenameItem && mRenamer->getVisible() )
  1467. {
  1468. closeRenamer();
  1469. handled = TRUE;
  1470. }
  1471. mSearchString.clear();
  1472. break;
  1474. case KEY_PAGE_UP:
  1475. mSearchString.clear();
  1476. mScrollContainer->pageUp(30);
  1477. handled = TRUE;
  1478. break;
  1480. case KEY_PAGE_DOWN:
  1481. mSearchString.clear();
  1482. mScrollContainer->pageDown(30);
  1483. handled = TRUE;
  1484. break;
  1486. case KEY_HOME:
  1487. mSearchString.clear();
  1488. mScrollContainer->goToTop();
  1489. handled = TRUE;
  1490. break;
  1492. case KEY_END:
  1493. mSearchString.clear();
  1494. mScrollContainer->goToBottom();
  1495. break;
  1497. case KEY_DOWN:
  1498. if((mSelectedItems.size() > 0) && mScrollContainer)
  1499. {
  1500. LLFolderViewItem* last_selected = getCurSelectedItem();
  1502. if (!mKeyboardSelection)
  1503. {
  1504. setSelection(last_selected, FALSE, TRUE);
  1505. mKeyboardSelection = TRUE;
  1506. }
  1508. LLFolderViewItem* next = NULL;
  1509. if (mask & MASK_SHIFT)
  1510. {
  1511. // don't shift select down to children of folders (they are implicitly selected through parent)
  1512. next = last_selected->getNextOpenNode(FALSE);
  1513. if (next)
  1514. {
  1515. if (next->isSelected())
  1516. {
  1517. // shrink selection
  1518. changeSelectionFromRoot(last_selected, FALSE);
  1519. }
  1520. else if (last_selected->getParentFolder() == next->getParentFolder())
  1521. {
  1522. // grow selection
  1523. changeSelectionFromRoot(next, TRUE);
  1524. }
  1525. }
  1526. }
  1527. else
  1528. {
  1529. next = last_selected->getNextOpenNode();
  1530. if( next )
  1531. {
  1532. if (next == last_selected)
  1533. {
  1534. //special case for LLAccordionCtrl
  1535. if(notifyParent(LLSD().with("action","select_next")) > 0 )//message was processed
  1536. {
  1537. clearSelection();
  1538. return TRUE;
  1539. }
  1540. return FALSE;
  1541. }
  1542. setSelection( next, FALSE, TRUE );
  1543. }
  1544. else
  1545. {
  1546. //special case for LLAccordionCtrl
  1547. if(notifyParent(LLSD().with("action","select_next")) > 0 )//message was processed
  1548. {
  1549. clearSelection();
  1550. return TRUE;
  1551. }
  1552. return FALSE;
  1553. }
  1554. }
  1555. scrollToShowSelection();
  1556. mSearchString.clear();
  1557. handled = TRUE;
  1558. }
  1559. break;
  1561. case KEY_UP:
  1562. if((mSelectedItems.size() > 0) && mScrollContainer)
  1563. {
  1564. LLFolderViewItem* last_selected = mSelectedItems.back();
  1566. if (!mKeyboardSelection)
  1567. {
  1568. setSelection(last_selected, FALSE, TRUE);
  1569. mKeyboardSelection = TRUE;
  1570. }
  1572. LLFolderViewItem* prev = NULL;
  1573. if (mask & MASK_SHIFT)
  1574. {
  1575. // don't shift select down to children of folders (they are implicitly selected through parent)
  1576. prev = last_selected->getPreviousOpenNode(FALSE);
  1577. if (prev)
  1578. {
  1579. if (prev->isSelected())
  1580. {
  1581. // shrink selection
  1582. changeSelectionFromRoot(last_selected, FALSE);
  1583. }
  1584. else if (last_selected->getParentFolder() == prev->getParentFolder())
  1585. {
  1586. // grow selection
  1587. changeSelectionFromRoot(prev, TRUE);
  1588. }
  1589. }
  1590. }
  1591. else
  1592. {
  1593. prev = last_selected->getPreviousOpenNode();
  1594. if( prev )
  1595. {
  1596. if (prev == this)
  1597. {
  1598. // If case we are in accordion tab notify parent to go to the previous accordion
  1599. if(notifyParent(LLSD().with("action","select_prev")) > 0 )//message was processed
  1600. {
  1601. clearSelection();
  1602. return TRUE;
  1603. }
  1605. return FALSE;
  1606. }
  1607. setSelection( prev, FALSE, TRUE );
  1608. }
  1609. }
  1610. scrollToShowSelection();
  1611. mSearchString.clear();
  1613. handled = TRUE;
  1614. }
  1615. break;
  1617. case KEY_RIGHT:
  1618. if(mSelectedItems.size())
  1619. {
  1620. LLFolderViewItem* last_selected = getCurSelectedItem();
  1621. last_selected->setOpen( TRUE );
  1622. mSearchString.clear();
  1623. handled = TRUE;
  1624. }
  1625. break;
  1627. case KEY_LEFT:
  1628. if(mSelectedItems.size())
  1629. {
  1630. LLFolderViewItem* last_selected = getCurSelectedItem();
  1631. LLFolderViewItem* parent_folder = last_selected->getParentFolder();
  1632. if (!last_selected->isOpen() && parent_folder && parent_folder->getParentFolder())
  1633. {
  1634. // Don't change selectin to hidden folder. See EXT-5328.
  1635. if (!parent_folder->getHidden())
  1636. {
  1637. setSelection(parent_folder, FALSE, TRUE);
  1638. }
  1639. }
  1640. else
  1641. {
  1642. last_selected->setOpen( FALSE );
  1643. }
  1644. mSearchString.clear();
  1645. scrollToShowSelection();
  1646. handled = TRUE;
  1647. }
  1648. break;
  1649. }
  1651. if (!handled && mParentPanel->hasFocus())
  1652. {
  1653. if (key == KEY_BACKSPACE)
  1654. {
  1655. mSearchTimer.reset();
  1656. if (mSearchString.size())
  1657. {
  1658. mSearchString.erase(mSearchString.size() - 1, 1);
  1659. }
  1660. search(getCurSelectedItem(), mSearchString, FALSE);
  1661. handled = TRUE;
  1662. }
  1663. }
  1665. return handled;
  1666. }
  1669. BOOL LLFolderView::handleUnicodeCharHere(llwchar uni_char)
  1670. {
  1671. if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
  1672. {
  1673. return FALSE;
  1674. }
  1676. if (uni_char > 0x7f)
  1677. {
  1678. llwarns << "LLFolderView::handleUnicodeCharHere - Don't handle non-ascii yet, aborting" << llendl;
  1679. return FALSE;
  1680. }
  1682. BOOL handled = FALSE;
  1683. if (gFocusMgr.childHasKeyboardFocus(getRoot()))
  1684. {
  1685. // SL-51858: Key presses are not being passed to the Popup menu.
  1686. // A proper fix is non-trivial so instead just close the menu.
  1687. LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
  1688. if (menu && menu->isOpen())
  1689. {
  1690. LLMenuGL::sMenuContainer->hideMenus();
  1691. }
  1693. //do text search
  1694. if (mSearchTimer.getElapsedTimeF32() > gSavedSettings.getF32("TypeAheadTimeout"))
  1695. {
  1696. mSearchString.clear();
  1697. }
  1698. mSearchTimer.reset();
  1699. if (mSearchString.size() < 128)
  1700. {
  1701. mSearchString += uni_char;
  1702. }
  1703. search(getCurSelectedItem(), mSearchString, FALSE);
  1705. handled = TRUE;
  1706. }
  1708. return handled;
  1709. }
  1712. BOOL LLFolderView::canDoDelete() const
  1713. {
  1714. if (mSelectedItems.size() == 0) return FALSE;
  1716. for (selected_items_t::const_iterator item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  1717. {
  1718. if (!(*item_it)->getListener()->isItemRemovable())
  1719. {
  1720. return FALSE;
  1721. }
  1722. }
  1723. return TRUE;
  1724. }
  1726. void LLFolderView::doDelete()
  1727. {
  1728. if(mSelectedItems.size() > 0)
  1729. {
  1730. removeSelectedItems();
  1731. }
  1732. }
  1735. BOOL LLFolderView::handleMouseDown( S32 x, S32 y, MASK mask )
  1736. {
  1737. mKeyboardSelection = FALSE;
  1738. mSearchString.clear();
  1740. mParentPanel->setFocus(TRUE);
  1742. return LLView::handleMouseDown( x, y, mask );
  1743. }
  1745. BOOL LLFolderView::search(LLFolderViewItem* first_item, const std::string &search_string, BOOL backward)
  1746. {
  1747. // get first selected item
  1748. LLFolderViewItem* search_item = first_item;
  1750. // make sure search string is upper case
  1751. std::string upper_case_string = search_string;
  1752. LLStringUtil::toUpper(upper_case_string);
  1754. // if nothing selected, select first item in folder
  1755. if (!search_item)
  1756. {
  1757. // start from first item
  1758. search_item = getNextFromChild(NULL);
  1759. }
  1761. // search over all open nodes for first substring match (with wrapping)
  1762. BOOL found = FALSE;
  1763. LLFolderViewItem* original_search_item = search_item;
  1764. do
  1765. {
  1766. // wrap at end
  1767. if (!search_item)
  1768. {
  1769. if (backward)
  1770. {
  1771. search_item = getPreviousFromChild(NULL);
  1772. }
  1773. else
  1774. {
  1775. search_item = getNextFromChild(NULL);
  1776. }
  1777. if (!search_item || search_item == original_search_item)
  1778. {
  1779. break;
  1780. }
  1781. }
  1783. const std::string current_item_label(search_item->getSearchableLabel());
  1784. S32 search_string_length = llmin(upper_case_string.size(), current_item_label.size());
  1785. if (!current_item_label.compare(0, search_string_length, upper_case_string))
  1786. {
  1787. found = TRUE;
  1788. break;
  1789. }
  1790. if (backward)
  1791. {
  1792. search_item = search_item->getPreviousOpenNode();
  1793. }
  1794. else
  1795. {
  1796. search_item = search_item->getNextOpenNode();
  1797. }
  1799. } while(search_item != original_search_item);
  1802. if (found)
  1803. {
  1804. setSelection(search_item, FALSE, TRUE);
  1805. scrollToShowSelection();
  1806. }
  1808. return found;
  1809. }
  1811. BOOL LLFolderView::handleDoubleClick( S32 x, S32 y, MASK mask )
  1812. {
  1813. // skip LLFolderViewFolder::handleDoubleClick()
  1814. return LLView::handleDoubleClick( x, y, mask );
  1815. }
  1817. BOOL LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
  1818. {
  1819. // all user operations move keyboard focus to inventory
  1820. // this way, we know when to stop auto-updating a search
  1821. mParentPanel->setFocus(TRUE);
  1823. BOOL handled = childrenHandleRightMouseDown(x, y, mask) != NULL;
  1824. S32 count = mSelectedItems.size();
  1825. LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
  1826. if(handled && (count > 0) && menu)
  1827. {
  1828. if (mCallbackRegistrar)
  1829. mCallbackRegistrar->pushScope();
  1830. //menu->empty();
  1831. const LLView::child_list_t *list = menu->getChildList();
  1833. LLView::child_list_t::const_iterator menu_itor;
  1834. for (menu_itor = list->begin(); menu_itor != list->end(); ++menu_itor)
  1835. {
  1836. (*menu_itor)->setVisible(TRUE);
  1837. (*menu_itor)->setEnabled(TRUE);
  1838. }
  1840. // Successively filter out invalid options
  1841. selected_items_t::iterator item_itor;
  1842. U32 flags = FIRST_SELECTED_ITEM;
  1843. for (item_itor = mSelectedItems.begin(); item_itor != mSelectedItems.end(); ++item_itor)
  1844. {
  1845. (*item_itor)->buildContextMenu(*menu, flags);
  1846. flags = 0x0;
  1847. }
  1849. menu->updateParent(LLMenuGL::sMenuContainer);
  1850. LLMenuGL::showPopup(this, menu, x, y);
  1851. if (mCallbackRegistrar)
  1852. mCallbackRegistrar->popScope();
  1853. }
  1854. else
  1855. {
  1856. if(menu && menu->getVisible())
  1857. {
  1858. menu->setVisible(FALSE);
  1859. }
  1860. setSelection(NULL, FALSE, TRUE);
  1861. }
  1862. return handled;
  1863. }
  1865. BOOL LLFolderView::handleHover( S32 x, S32 y, MASK mask )
  1866. {
  1867. return LLView::handleHover( x, y, mask );
  1868. }
  1870. BOOL LLFolderView::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  1871.  EDragAndDropType cargo_type,
  1872.  void* cargo_data, 
  1873.  EAcceptance* accept,
  1874.  std::string& tooltip_msg)
  1875. {
  1876. mDragAndDropThisFrame = TRUE;
  1877. BOOL handled = LLView::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data,
  1878.  accept, tooltip_msg);
  1880. // When there are no visible children drag and drop is handled
  1881. // by the folder which is the hierarchy root.
  1882. if (!handled && !hasVisibleChildren())
  1883. {
  1884. handled = mFolders.front()->handleDragAndDropFromChild(mask,drop,cargo_type,cargo_data,accept,tooltip_msg);
  1885. }
  1887. if (handled)
  1888. {
  1889. lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLFolderView" << llendl;
  1890. }
  1892. return handled;
  1893. }
  1895. void LLFolderView::deleteAllChildren()
  1896. {
  1897. if(mRenamer == gFocusMgr.getTopCtrl())
  1898. {
  1899. gFocusMgr.setTopCtrl(NULL);
  1900. }
  1901. LLView::deleteViewByHandle(mPopupMenuHandle);
  1902. mPopupMenuHandle = LLHandle<LLView>();
  1903. mRenamer = NULL;
  1904. mRenameItem = NULL;
  1905. clearSelection();
  1906. LLView::deleteAllChildren();
  1907. }
  1909. void LLFolderView::scrollToShowSelection()
  1910. {
  1911. if (mSelectedItems.size())
  1912. {
  1913. mNeedsScroll = TRUE;
  1914. }
  1915. }
  1917. // If the parent is scroll containter, scroll it to make the selection
  1918. // is maximally visible.
  1919. void LLFolderView::scrollToShowItem(LLFolderViewItem* item, const LLRect& constraint_rect)
  1920. {
  1921. if (!mScrollContainer) return;
  1923. // don't scroll to items when mouse is being used to scroll/drag and drop
  1924. if (gFocusMgr.childHasMouseCapture(mScrollContainer))
  1925. {
  1926. mNeedsScroll = FALSE;
  1927. return;
  1928. }
  1930. // if item exists and is in visible portion of parent folder...
  1931. if(item)
  1932. {
  1933. LLRect local_rect = item->getLocalRect();
  1934. LLRect item_scrolled_rect; // item position relative to display area of scroller
  1935. LLRect visible_doc_rect = mScrollContainer->getVisibleContentRect();
  1937. S32 icon_height = mIcon.isNull() ? 0 : mIcon->getHeight(); 
  1938. S32 label_height = llround(getLabelFontForStyle(mLabelStyle)->getLineHeight()); 
  1939. // when navigating with keyboard, only move top of opened folder on screen, otherwise show whole folder
  1940. S32 max_height_to_show = item->isOpen() && mScrollContainer->hasFocus() ? (llmax( icon_height, label_height ) + ICON_PAD) : local_rect.getHeight(); 
  1942. // get portion of item that we want to see...
  1943. LLRect item_local_rect = LLRect(item->getIndentation(), 
  1944. local_rect.getHeight(), 
  1945. llmin(MIN_ITEM_WIDTH_VISIBLE, local_rect.getWidth()), 
  1946. llmax(0, local_rect.getHeight() - max_height_to_show));
  1948. LLRect item_doc_rect;
  1950. item->localRectToOtherView(item_local_rect, &item_doc_rect, this); 
  1952. mScrollContainer->scrollToShowRect( item_doc_rect, constraint_rect );
  1954. }
  1955. }
  1957. LLRect LLFolderView::getVisibleRect()
  1958. {
  1959. S32 visible_height = mScrollContainer->getRect().getHeight();
  1960. S32 visible_width = mScrollContainer->getRect().getWidth();
  1961. LLRect visible_rect;
  1962. visible_rect.setLeftTopAndSize(-getRect().mLeft, visible_height - getRect().mBottom, visible_width, visible_height);
  1963. return visible_rect;
  1964. }
  1966. BOOL LLFolderView::getShowSelectionContext()
  1967. {
  1968. if (mShowSelectionContext)
  1969. {
  1970. return TRUE;
  1971. }
  1972. LLMenuGL* menu = (LLMenuGL*)mPopupMenuHandle.get();
  1973. if (menu && menu->getVisible())
  1974. {
  1975. return TRUE;
  1976. }
  1977. return FALSE;
  1978. }
  1980. void LLFolderView::setShowSingleSelection(BOOL show)
  1981. {
  1982. if (show != mShowSingleSelection)
  1983. {
  1984. mMultiSelectionFadeTimer.reset();
  1985. mShowSingleSelection = show;
  1986. }
  1987. }
  1989. void LLFolderView::addItemID(const LLUUID& id, LLFolderViewItem* itemp)
  1990. {
  1991. mItemMap[id] = itemp;
  1992. }
  1994. void LLFolderView::removeItemID(const LLUUID& id)
  1995. {
  1996. mItemMap.erase(id);
  1997. }
  1999. LLFolderViewItem* LLFolderView::getItemByID(const LLUUID& id)
  2000. {
  2001. if (id.isNull())
  2002. {
  2003. return this;
  2004. }
  2006. std::map<LLUUID, LLFolderViewItem*>::iterator map_it;
  2007. map_it = mItemMap.find(id);
  2008. if (map_it != mItemMap.end())
  2009. {
  2010. return map_it->second;
  2011. }
  2013. return NULL;
  2014. }
  2016. LLFolderViewFolder* LLFolderView::getFolderByID(const LLUUID& id)
  2017. {
  2018. if (id.isNull())
  2019. {
  2020. return this;
  2021. }
  2023. for (folders_t::iterator iter = mFolders.begin();
  2024.  iter != mFolders.end();
  2025.  ++iter)
  2026. {
  2027. LLFolderViewFolder *folder = (*iter);
  2028. if (folder->getListener()->getUUID() == id)
  2029. {
  2030. return folder;
  2031. }
  2032. }
  2033. return NULL;
  2034. }
  2036. bool LLFolderView::doToSelected(LLInventoryModel* model, const LLSD& userdata)
  2037. {
  2038. std::string action = userdata.asString();
  2040. if ("rename" == action)
  2041. {
  2042. startRenamingSelectedItem();
  2043. return true;
  2044. }
  2045. if ("delete" == action)
  2046. {
  2047. removeSelectedItems();
  2048. return true;
  2049. }
  2051. if ("copy" == action)
  2052. {
  2053. LLInventoryClipboard::instance().reset();
  2054. }
  2056. static const std::string change_folder_string = "change_folder_type_";
  2057. if (action.length() > change_folder_string.length() && 
  2058. (action.compare(0,change_folder_string.length(),"change_folder_type_") == 0))
  2059. {
  2060. LLFolderType::EType new_folder_type = LLViewerFolderType::lookupTypeFromXUIName(action.substr(change_folder_string.length()));
  2061. changeType(model, new_folder_type);
  2062. return true;
  2063. }
  2066. std::set<LLUUID> selected_items;
  2067. getSelectionList(selected_items);
  2069. LLMultiPreview* multi_previewp = NULL;
  2070. LLMultiProperties* multi_propertiesp = NULL;
  2072. if (("task_open" == action  || "open" == action) && selected_items.size() > 1)
  2073. {
  2074. multi_previewp = new LLMultiPreview();
  2075. gFloaterView->addChild(multi_previewp);
  2077. LLFloater::setFloaterHost(multi_previewp);
  2079. }
  2080. else if (("task_properties" == action || "properties" == action) && selected_items.size() > 1)
  2081. {
  2082. multi_propertiesp = new LLMultiProperties();
  2083. gFloaterView->addChild(multi_propertiesp);
  2085. LLFloater::setFloaterHost(multi_propertiesp);
  2086. }
  2088. std::set<LLUUID>::iterator set_iter;
  2090. for (set_iter = selected_items.begin(); set_iter != selected_items.end(); ++set_iter)
  2091. {
  2092. LLFolderViewItem* folder_item = getItemByID(*set_iter);
  2093. if(!folder_item) continue;
  2094. LLInvFVBridge* bridge = (LLInvFVBridge*)folder_item->getListener();
  2095. if(!bridge) continue;
  2097. bridge->performAction(this, model, action);
  2098. }
  2100. LLFloater::setFloaterHost(NULL);
  2101. if (multi_previewp)
  2102. {
  2103. multi_previewp->openFloater(LLSD());
  2104. }
  2105. else if (multi_propertiesp)
  2106. {
  2107. multi_propertiesp->openFloater(LLSD());
  2108. }
  2110. return true;
  2111. }
  2113. static LLFastTimer::DeclareTimer FTM_AUTO_SELECT("Open and Select");
  2114. static LLFastTimer::DeclareTimer FTM_INVENTORY("Inventory");
  2116. // Main idle routine
  2117. void LLFolderView::doIdle()
  2118. {
  2119. // If this is associated with the user's inventory, don't do anything
  2120. // until that inventory is loaded up.
  2121. const LLInventoryPanel *inventory_panel = dynamic_cast<LLInventoryPanel*>(mParentPanel);
  2122. if (inventory_panel && !inventory_panel->getIsViewsInitialized())
  2123. {
  2124. return;
  2125. }
  2127. LLFastTimer t2(FTM_INVENTORY);
  2129. BOOL debug_filters = gSavedSettings.getBOOL("DebugInventoryFilters");
  2130. if (debug_filters != getDebugFilters())
  2131. {
  2132. mDebugFilters = debug_filters;
  2133. arrangeAll();
  2134. }
  2136. mFilter->clearModified();
  2137. BOOL filter_modified_and_active = mCompletedFilterGeneration < mFilter->getCurrentGeneration() && 
  2138. mFilter->isNotDefault();
  2139. mNeedsAutoSelect = filter_modified_and_active &&
  2140. !(gFocusMgr.childHasKeyboardFocus(this) || gFocusMgr.getMouseCapture());
  2142. // filter to determine visiblity before arranging
  2143. filterFromRoot();
  2145. // automatically show matching items, and select first one
  2146. // do this every frame until user puts keyboard focus into the inventory window
  2147. // signaling the end of the automatic update
  2148. // only do this when mNeedsFilter is set, meaning filtered items have
  2149. // potentially changed
  2150. if (mNeedsAutoSelect)
  2151. {
  2152. LLFastTimer t3(FTM_AUTO_SELECT);
  2153. // select new item only if a filtered item not currently selected
  2154. LLFolderViewItem* selected_itemp = mSelectedItems.empty() ? NULL : mSelectedItems.back();
  2155. if ((!selected_itemp || !selected_itemp->getFiltered()) && !mAutoSelectOverride)
  2156. {
  2157. // select first filtered item
  2158. LLSelectFirstFilteredItem filter;
  2159. applyFunctorRecursively(filter);
  2160. }
  2161. scrollToShowSelection();
  2162. }
  2164. // during filtering process, try to pin selected item's location on screen
  2165. // this will happen when searching your inventory and when new items arrive
  2166. if (filter_modified_and_active)
  2167. {
  2168. // calculate rectangle to pin item to at start of animated rearrange
  2169. if (!mPinningSelectedItem && !mSelectedItems.empty())
  2170. {
  2171. // lets pin it!
  2172. mPinningSelectedItem = TRUE;
  2174. LLRect visible_content_rect = mScrollContainer->getVisibleContentRect();
  2175. LLFolderViewItem* selected_item = mSelectedItems.back();
  2177. LLRect item_rect;
  2178. selected_item->localRectToOtherView(selected_item->getLocalRect(), &item_rect, this);
  2179. // if item is visible in scrolled region
  2180. if (visible_content_rect.overlaps(item_rect))
  2181. {
  2182. // then attempt to keep it in same place on screen
  2183. mScrollConstraintRect = item_rect;
  2184. mScrollConstraintRect.translate(-visible_content_rect.mLeft, -visible_content_rect.mBottom);
  2185. }
  2186. else
  2187. {
  2188. // otherwise we just want it onscreen somewhere
  2189. LLRect content_rect = mScrollContainer->getContentWindowRect();
  2190. mScrollConstraintRect.setOriginAndSize(0, 0, content_rect.getWidth(), content_rect.getHeight());
  2191. }
  2192. }
  2193. }
  2194. else
  2195. {
  2196. // stop pinning selected item after folders stop rearranging
  2197. if (!needsArrange())
  2198. {
  2199. mPinningSelectedItem = FALSE;
  2200. }
  2201. }
  2203. LLRect constraint_rect;
  2204. if (mPinningSelectedItem)
  2205. {
  2206. // use last known constraint rect for pinned item
  2207. constraint_rect = mScrollConstraintRect;
  2208. }
  2209. else
  2210. {
  2211. // during normal use (page up/page down, etc), just try to fit item on screen
  2212. LLRect content_rect = mScrollContainer->getContentWindowRect();
  2213. constraint_rect.setOriginAndSize(0, 0, content_rect.getWidth(), content_rect.getHeight());
  2214. }
  2217. BOOL is_visible = isInVisibleChain();
  2219. if ( is_visible )
  2220. {
  2221. sanitizeSelection();
  2222. if( needsArrange() )
  2223. {
  2224. arrangeFromRoot();
  2225. }
  2226. }
  2228. if (mSelectedItems.size() && mNeedsScroll)
  2229. {
  2230. scrollToShowItem(mSelectedItems.back(), constraint_rect);
  2231. // continue scrolling until animated layout change is done
  2232. if (!filter_modified_and_active 
  2233. && (!needsArrange() || !is_visible))
  2234. {
  2235. mNeedsScroll = FALSE;
  2236. }
  2237. }
  2239. if (mSignalSelectCallback)
  2240. {
  2241. //RN: we use keyboard focus as a proxy for user-explicit actions
  2242. BOOL take_keyboard_focus = (mSignalSelectCallback == SIGNAL_KEYBOARD_FOCUS);
  2243. mSelectSignal(mSelectedItems, take_keyboard_focus);
  2244. }
  2245. mSignalSelectCallback = FALSE;
  2246. }
  2249. //static
  2250. void LLFolderView::idle(void* user_data)
  2251. {
  2252. LLFolderView* self = (LLFolderView*)user_data;
  2253. if ( self )
  2254. { // Do the real idle 
  2255. self->doIdle();
  2256. }
  2257. }
  2259. void LLFolderView::dumpSelectionInformation()
  2260. {
  2261. llinfos << "LLFolderView::dumpSelectionInformation()" << llendl;
  2262. llinfos << "****************************************" << llendl;
  2263. selected_items_t::iterator item_it;
  2264. for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
  2265. {
  2266. llinfos << "  " << (*item_it)->getName() << llendl;
  2267. }
  2268. llinfos << "****************************************" << llendl;
  2269. }
  2271. void LLFolderView::updateRenamerPosition()
  2272. {
  2273. if(mRenameItem)
  2274. {
  2275. // See also LLFolderViewItem::draw()
  2276. S32 x = ARROW_SIZE + TEXT_PAD + ICON_WIDTH + ICON_PAD + mRenameItem->getIndentation();
  2277. S32 y = mRenameItem->getRect().getHeight() - mRenameItem->getItemHeight() - RENAME_HEIGHT_PAD;
  2278. mRenameItem->localPointToScreen( x, y, &x, &y );
  2279. screenPointToLocal( x, y, &x, &y );
  2280. mRenamer->setOrigin( x, y );
  2282. LLRect scroller_rect(0, 0, gViewerWindow->getWindowWidthScaled(), 0);
  2283. if (mScrollContainer)
  2284. {
  2285. scroller_rect = mScrollContainer->getContentWindowRect();
  2286. }
  2288. S32 width = llmax(llmin(mRenameItem->getRect().getWidth() - x, scroller_rect.getWidth() - x - getRect().mLeft), MINIMUM_RENAMER_WIDTH);
  2289. S32 height = mRenameItem->getItemHeight() - RENAME_HEIGHT_PAD;
  2290. mRenamer->reshape( width, height, TRUE );
  2291. }
  2292. }
  2294. bool LLFolderView::selectFirstItem()
  2295. {
  2296. for (folders_t::iterator iter = mFolders.begin();
  2297.  iter != mFolders.end();)
  2298. {
  2299. LLFolderViewFolder* folder = (*iter );
  2300. if (folder->getVisible())
  2301. {
  2302. LLFolderViewItem* itemp = folder->getNextFromChild(0,true);
  2303. if(itemp)
  2304. setSelection(itemp,FALSE,TRUE);
  2305. return true;
  2306. }
  2308. }
  2309. for(items_t::iterator iit = mItems.begin();
  2310. iit != mItems.end(); ++iit)
  2311. {
  2312. LLFolderViewItem* itemp = (*iit);
  2313. if (itemp->getVisible())
  2314. {
  2315. setSelection(itemp,FALSE,TRUE);
  2316. return true;
  2317. }
  2318. }
  2319. return false;
  2320. }
  2321. bool LLFolderView::selectLastItem()
  2322. {
  2323. for(items_t::reverse_iterator iit = mItems.rbegin();
  2324. iit != mItems.rend(); ++iit)
  2325. {
  2326. LLFolderViewItem* itemp = (*iit);
  2327. if (itemp->getVisible())
  2328. {
  2329. setSelection(itemp,FALSE,TRUE);
  2330. return true;
  2331. }
  2332. }
  2333. for (folders_t::reverse_iterator iter = mFolders.rbegin();
  2334.  iter != mFolders.rend();)
  2335. {
  2336. LLFolderViewFolder* folder = (*iter);
  2337. if (folder->getVisible())
  2338. {
  2339. LLFolderViewItem* itemp = folder->getPreviousFromChild(0,true);
  2340. if(itemp)
  2341. setSelection(itemp,FALSE,TRUE);
  2342. return true;
  2343. }
  2344. }
  2345. return false;
  2346. }
  2349. S32 LLFolderView::notify(const LLSD& info) 
  2350. {
  2351. if(info.has("action"))
  2352. {
  2353. std::string str_action = info["action"];
  2354. if(str_action == "select_first")
  2355. {
  2356. setFocus(true);
  2357. selectFirstItem();
  2358. return 1;
  2360. }
  2361. else if(str_action == "select_last")
  2362. {
  2363. setFocus(true);
  2364. selectLastItem();
  2365. return 1;
  2366. }
  2367. }
  2368. return 0;
  2369. }
  2372. ///----------------------------------------------------------------------------
  2373. /// Local function definitions
  2374. ///----------------------------------------------------------------------------
  2376. //static 
  2377. void LLFolderView::onRenamerLost( LLFocusableElement* renamer)
  2378. {
  2379. LLUICtrl* uictrl = dynamic_cast<LLUICtrl*>(renamer);
  2380. if (uictrl)
  2381. {
  2382. uictrl->setVisible(FALSE);
  2383. }
  2384. }
  2386. LLInventoryFilter* LLFolderView::getFilter()
  2387. {
  2388. return mFilter;
  2389. }
  2391. void LLFolderView::setFilterPermMask( PermissionMask filter_perm_mask )
  2392. {
  2393. mFilter->setFilterPermissions(filter_perm_mask);
  2394. }
  2396. U32 LLFolderView::getFilterObjectTypes() const
  2397. {
  2398. return mFilter->getFilterObjectTypes();
  2399. }
  2401. PermissionMask LLFolderView::getFilterPermissions() const
  2402. {
  2403. return mFilter->getFilterPermissions();
  2404. }
  2406. BOOL LLFolderView::isFilterModified()
  2407. {
  2408. return mFilter->isNotDefault();
  2409. }
  2411. BOOL LLFolderView::getAllowMultiSelect()
  2412. {
  2413. return mAllowMultiSelect;
  2414. }
  2416. void delete_selected_item(void* user_data)
  2417. {
  2418. if(user_data)
  2419. {
  2420. LLFolderView* fv = reinterpret_cast<LLFolderView*>(user_data);
  2421. fv->removeSelectedItems();
  2422. }
  2423. }
  2425. void copy_selected_item(void* user_data)
  2426. {
  2427. if(user_data)
  2428. {
  2429. LLFolderView* fv = reinterpret_cast<LLFolderView*>(user_data);
  2430. fv->copy();
  2431. }
  2432. }
  2434. void paste_items(void* user_data)
  2435. {
  2436. if(user_data)
  2437. {
  2438. LLFolderView* fv = reinterpret_cast<LLFolderView*>(user_data);
  2439. fv->paste();
  2440. }
  2441. }
  2443. void open_selected_items(void* user_data)
  2444. {
  2445. if(user_data)
  2446. {
  2447. LLFolderView* fv = reinterpret_cast<LLFolderView*>(user_data);
  2448. fv->openSelectedItems();
  2449. }
  2450. }
  2452. void properties_selected_items(void* user_data)
  2453. {
  2454. if(user_data)
  2455. {
  2456. LLFolderView* fv = reinterpret_cast<LLFolderView*>(user_data);
  2457. fv->propertiesSelectedItems();
  2458. }
  2459. }