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

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

游戏引擎

开发平台：

C++ Builder

llfolderviewitem.cpp：源码内容
  1. /** 
  2. * @file llfolderviewitem.cpp
  3. * @brief Items and folders that can appear in a hierarchical folder view
  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. */
  32. #include "llviewerprecompiledheaders.h"
  34. #include "llfolderviewitem.h"
  36. // viewer includes
  37. #include "llfolderview.h" // Items depend extensively on LLFolderViews
  38. #include "llfoldervieweventlistener.h"
  39. #include "llinventorybridge.h" // for LLItemBridge in LLInventorySort::operator()
  40. #include "llinventoryfilter.h"
  41. #include "llpanel.h"
  42. #include "llviewercontrol.h" // gSavedSettings
  43. #include "llviewerwindow.h" // Argh, only for setCursor()
  45. // linden library includes
  46. #include "llfocusmgr.h" // gFocusMgr
  47. #include "lltrans.h"
  49. ///----------------------------------------------------------------------------
  50. /// Class LLFolderViewItem
  51. ///----------------------------------------------------------------------------
  53. static LLDefaultChildRegistry::Register<LLFolderViewItem> r("folder_view_item");
  55. // statics 
  56. std::map<U8, LLFontGL*> LLFolderViewItem::sFonts; // map of styles to fonts
  58. // only integers can be initialized in header
  59. const F32 LLFolderViewItem::FOLDER_CLOSE_TIME_CONSTANT = 0.02f;
  60. const F32 LLFolderViewItem::FOLDER_OPEN_TIME_CONSTANT = 0.03f;
  62. const LLColor4U DEFAULT_WHITE(255, 255, 255);
  65. //static
  66. LLFontGL* LLFolderViewItem::getLabelFontForStyle(U8 style)
  67. {
  68. LLFontGL* rtn = sFonts[style];
  69. if (!rtn) // grab label font with this style, lazily
  70. {
  71. LLFontDescriptor labelfontdesc("SansSerif", "Small", style);
  72. rtn = LLFontGL::getFont(labelfontdesc);
  73. if (!rtn)
  74. {
  75. rtn = LLFontGL::getFontDefault();
  76. }
  77. sFonts[style] = rtn;
  78. }
  79. return rtn;
  80. }
  82. //static
  83. void LLFolderViewItem::initClass()
  84. {
  85. }
  87. //static
  88. void LLFolderViewItem::cleanupClass()
  89. {
  90. sFonts.clear();
  91. }
  94. // NOTE: Optimize this, we call it a *lot* when opening a large inventory
  95. LLFolderViewItem::Params::Params()
  96. : icon(),
  97. icon_open(),
  98. root(),
  99. listener(),
  100. folder_arrow_image("folder_arrow_image"),
  101. folder_indentation("folder_indentation"),
  102. selection_image("selection_image"),
  103. item_height("item_height"),
  104. item_top_pad("item_top_pad"),
  105. creation_date()
  106. {
  107. mouse_opaque(true);
  108. follows.flags(FOLLOWS_LEFT|FOLLOWS_TOP|FOLLOWS_RIGHT);
  109. }
  111. // Default constructor
  112. LLFolderViewItem::LLFolderViewItem(const LLFolderViewItem::Params& p)
  113. : LLView(p),
  114. mLabelWidth(0),
  115. mLabelWidthDirty(false),
  116. mParentFolder( NULL ),
  117. mIsSelected( FALSE ),
  118. mIsCurSelection( FALSE ),
  119. mSelectPending(FALSE),
  120. mLabelStyle( LLFontGL::NORMAL ),
  121. mHasVisibleChildren(FALSE),
  122. mIndentation(0),
  123. mItemHeight(p.item_height),
  124. mNumDescendantsSelected(0),
  125. mPassedFilter(FALSE),
  126. mLastFilterGeneration(-1),
  127. mStringMatchOffset(std::string::npos),
  128. mControlLabelRotation(0.f),
  129. mDragAndDropTarget(FALSE),
  130. mIsLoading(FALSE),
  131. mLabel(p.name),
  132. mRoot(p.root),
  133. mCreationDate(p.creation_date),
  134. mIcon(p.icon),
  135. mIconOpen(p.icon_open),
  136. mListener(p.listener),
  137. mHidden(false),
  138. mShowLoadStatus(false)
  139. {
  140. refresh();
  141. }
  143. // Destroys the object
  144. LLFolderViewItem::~LLFolderViewItem( void )
  145. {
  146. delete mListener;
  147. mListener = NULL;
  148. }
  150. LLFolderView* LLFolderViewItem::getRoot()
  151. {
  152. return mRoot;
  153. }
  155. // Returns true if this object is a child (or grandchild, etc.) of potential_ancestor.
  156. BOOL LLFolderViewItem::isDescendantOf( const LLFolderViewFolder* potential_ancestor )
  157. {
  158. LLFolderViewItem* root = this;
  159. while( root->mParentFolder )
  160. {
  161. if( root->mParentFolder == potential_ancestor )
  162. {
  163. return TRUE;
  164. }
  165. root = root->mParentFolder;
  166. }
  167. return FALSE;
  168. }
  170. LLFolderViewItem* LLFolderViewItem::getNextOpenNode(BOOL include_children)
  171. {
  172. if (!mParentFolder)
  173. {
  174. return NULL;
  175. }
  177. LLFolderViewItem* itemp = mParentFolder->getNextFromChild( this, include_children );
  178. while(itemp && !itemp->getVisible())
  179. {
  180. LLFolderViewItem* next_itemp = itemp->mParentFolder->getNextFromChild( itemp, include_children );
  181. if (itemp == next_itemp) 
  182. {
  183. // hit last item
  184. return itemp->getVisible() ? itemp : this;
  185. }
  186. itemp = next_itemp;
  187. }
  189. return itemp;
  190. }
  192. LLFolderViewItem* LLFolderViewItem::getPreviousOpenNode(BOOL include_children)
  193. {
  194. if (!mParentFolder)
  195. {
  196. return NULL;
  197. }
  199. LLFolderViewItem* itemp = mParentFolder->getPreviousFromChild( this, include_children );
  201. // Skip over items that are invisible or are hidden from the UI.
  202. while(itemp && (!itemp->getVisible() || itemp->getHidden()))
  203. {
  204. LLFolderViewItem* next_itemp = itemp->mParentFolder->getPreviousFromChild( itemp, include_children );
  205. if (itemp == next_itemp) 
  206. {
  207. // hit first item
  208. return itemp->getVisible() ? itemp : this;
  209. }
  210. itemp = next_itemp;
  211. }
  213. return itemp;
  214. }
  216. // is this item something we think we should be showing?
  217. // for example, if we haven't gotten around to filtering it yet, then the answer is yes
  218. // until we find out otherwise
  219. BOOL LLFolderViewItem::potentiallyVisible()
  220. {
  221. // we haven't been checked against min required filter
  222. // or we have and we passed
  223. return getLastFilterGeneration() < getRoot()->getFilter()->getMinRequiredGeneration() || getFiltered();
  224. }
  226. BOOL LLFolderViewItem::getFiltered() 
  227. { 
  228. return mPassedFilter && mLastFilterGeneration >= getRoot()->getFilter()->getMinRequiredGeneration(); 
  229. }
  231. BOOL LLFolderViewItem::getFiltered(S32 filter_generation) 
  232. {
  233. return mPassedFilter && mLastFilterGeneration >= filter_generation;
  234. }
  236. void LLFolderViewItem::setFiltered(BOOL filtered, S32 filter_generation)
  237. {
  238. mPassedFilter = filtered;
  239. mLastFilterGeneration = filter_generation;
  240. }
  242. void LLFolderViewItem::setIcon(LLUIImagePtr icon)
  243. {
  244. mIcon = icon;
  245. }
  247. // refresh information from the listener
  248. void LLFolderViewItem::refreshFromListener()
  249. {
  250. if(mListener)
  251. {
  252. mLabel = mListener->getDisplayName();
  253. LLFolderType::EType preferred_type = mListener->getPreferredType();
  255. // *TODO: to be removed when database supports multi language. This is a
  256. // temporary attempt to display the inventory folder in the user locale.
  257. // mantipov: *NOTE: be sure this code is synchronized with LLFriendCardsManager::findChildFolderUUID
  258. // it uses the same way to find localized string
  259. if (LLFolderType::lookupIsProtectedType(preferred_type))
  260. {
  261. LLTrans::findString(mLabel, "InvFolder " + mLabel);
  262. };
  264. setIcon(mListener->getIcon());
  265. time_t creation_date = mListener->getCreationDate();
  266. if (mCreationDate != creation_date)
  267. {
  268. mCreationDate = mListener->getCreationDate();
  269. dirtyFilter();
  270. }
  271. mLabelStyle = mListener->getLabelStyle();
  272. mLabelSuffix = mListener->getLabelSuffix();
  273. }
  274. }
  276. void LLFolderViewItem::refresh()
  277. {
  278. refreshFromListener();
  280. std::string searchable_label(mLabel);
  281. searchable_label.append(mLabelSuffix);
  282. LLStringUtil::toUpper(searchable_label);
  284. if (mSearchableLabel.compare(searchable_label))
  285. {
  286. mSearchableLabel.assign(searchable_label);
  287. dirtyFilter();
  288. // some part of label has changed, so overall width has potentially changed, and sort order too
  289. if (mParentFolder)
  290. {
  291. mParentFolder->requestSort();
  292. mParentFolder->requestArrange();
  293. }
  294. }
  296. mLabelWidthDirty = true;
  297. }
  299. void LLFolderViewItem::applyListenerFunctorRecursively(LLFolderViewListenerFunctor& functor)
  300. {
  301. functor(mListener);
  302. }
  304. // This function is called when items are added or view filters change. It's
  305. // implemented here but called by derived classes when folding the
  306. // views.
  307. void LLFolderViewItem::filterFromRoot( void )
  308. {
  309. LLFolderViewItem* root = getRoot();
  311. root->filter(*((LLFolderView*)root)->getFilter());
  312. }
  314. // This function is called when the folder view is dirty. It's
  315. // implemented here but called by derived classes when folding the
  316. // views.
  317. void LLFolderViewItem::arrangeFromRoot()
  318. {
  319. LLFolderViewItem* root = getRoot();
  321. S32 height = 0;
  322. S32 width = 0;
  323. S32 total_height = root->arrange( &width, &height, 0 );
  325. LLSD params;
  326. params["action"] = "size_changes";
  327. params["height"] = total_height;
  328. getParent()->notifyParent(params);
  329. }
  331. // Utility function for LLFolderView
  332. void LLFolderViewItem::arrangeAndSet(BOOL set_selection,
  333.  BOOL take_keyboard_focus)
  334. {
  335. LLFolderView* root = getRoot();
  336. getParentFolder()->requestArrange();
  337. if(set_selection)
  338. {
  339. setSelectionFromRoot(this, TRUE, take_keyboard_focus);
  340. if(root)
  341. {
  342. root->scrollToShowSelection();
  343. }
  344. }
  345. }
  347. // This function clears the currently selected item, and records the
  348. // specified selected item appropriately for display and use in the
  349. // UI. If open is TRUE, then folders are opened up along the way to
  350. // the selection.
  351. void LLFolderViewItem::setSelectionFromRoot(LLFolderViewItem* selection,
  352. BOOL openitem,
  353. BOOL take_keyboard_focus)
  354. {
  355. getRoot()->setSelection(selection, openitem, take_keyboard_focus);
  356. }
  358. // helper function to change the selection from the root.
  359. void LLFolderViewItem::changeSelectionFromRoot(LLFolderViewItem* selection, BOOL selected)
  360. {
  361. getRoot()->changeSelection(selection, selected);
  362. }
  364. void LLFolderViewItem::extendSelectionFromRoot(LLFolderViewItem* selection)
  365. {
  366. LLDynamicArray<LLFolderViewItem*> selected_items;
  368. getRoot()->extendSelection(selection, NULL, selected_items);
  369. }
  371. EInventorySortGroup LLFolderViewItem::getSortGroup()  const
  372. { 
  373. return SG_ITEM; 
  374. }
  376. // addToFolder() returns TRUE if it succeeds. FALSE otherwise
  377. BOOL LLFolderViewItem::addToFolder(LLFolderViewFolder* folder, LLFolderView* root)
  378. {
  379. if (!folder)
  380. {
  381. return FALSE;
  382. }
  383. mParentFolder = folder;
  384. root->addItemID(getListener()->getUUID(), this);
  385. return folder->addItem(this);
  386. }
  389. // Finds width and height of this object and it's children.  Also
  390. // makes sure that this view and it's children are the right size.
  391. S32 LLFolderViewItem::arrange( S32* width, S32* height, S32 filter_generation)
  392. {
  393. const Params& p = LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
  394. S32 indentation = p.folder_indentation();
  395. // Only indent deeper items in hierarchy
  396. mIndentation = (getParentFolder() 
  397. && getParentFolder()->getParentFolder() )
  398. ? mParentFolder->getIndentation() + indentation
  399. : 0;
  400. if (mLabelWidthDirty)
  401. {
  402. mLabelWidth = ARROW_SIZE + TEXT_PAD + ICON_WIDTH + ICON_PAD + getLabelFontForStyle(mLabelStyle)->getWidth(mSearchableLabel); 
  403. mLabelWidthDirty = false;
  404. }
  406. *width = llmax(*width, mLabelWidth + mIndentation); 
  408. // determine if we need to use ellipses to avoid horizontal scroll. EXT-719
  409. bool use_ellipses = getRoot()->getUseEllipses();
  410. if (use_ellipses)
  411. {
  412. // limit to set rect to avoid horizontal scrollbar
  413. *width = llmin(*width, getRoot()->getRect().getWidth());
  414. }
  415. *height = getItemHeight();
  416. return *height;
  417. }
  419. S32 LLFolderViewItem::getItemHeight()
  420. {
  421. if (mHidden) return 0;
  423. //S32 icon_height = mIcon->getHeight();
  424. //S32 label_height = llround(getLabelFontForStyle(mLabelStyle)->getLineHeight());
  425. //return llmax( icon_height, label_height ) + ICON_PAD;
  426. return mItemHeight;
  427. }
  429. void LLFolderViewItem::filter( LLInventoryFilter& filter)
  430. {
  431. const BOOL previous_passed_filter = mPassedFilter;
  432. const BOOL passed_filter = mListener && filter.check(this);
  434. // If our visibility will change as a result of this filter, then
  435. // we need to be rearranged in our parent folder
  436. if (mParentFolder)
  437. {
  438. if (getVisible() != passed_filter)
  439. mParentFolder->requestArrange();
  440. if (passed_filter != previous_passed_filter)
  441. mParentFolder->requestArrange();
  442. }
  444. setFiltered(passed_filter, filter.getCurrentGeneration());
  445. mStringMatchOffset = filter.getStringMatchOffset();
  446. filter.decrementFilterCount();
  448. if (getRoot()->getDebugFilters())
  449. {
  450. mStatusText = llformat("%d", mLastFilterGeneration);
  451. }
  452. }
  454. void LLFolderViewItem::dirtyFilter()
  455. {
  456. mLastFilterGeneration = -1;
  457. // bubble up dirty flag all the way to root
  458. if (getParentFolder())
  459. {
  460. getParentFolder()->setCompletedFilterGeneration(-1, TRUE);
  461. }
  462. }
  464. // *TODO: This can be optimized a lot by simply recording that it is
  465. // selected in the appropriate places, and assuming that set selection
  466. // means 'deselect' for a leaf item. Do this optimization after
  467. // multiple selection is implemented to make sure it all plays nice
  468. // together.
  469. BOOL LLFolderViewItem::setSelection(LLFolderViewItem* selection, BOOL openitem, BOOL take_keyboard_focus)
  470. {
  471. if( selection == this )
  472. {
  473. mIsSelected = TRUE;
  474. if(mListener)
  475. {
  476. mListener->selectItem();
  477. }
  478. }
  479. else
  480. {
  481. mIsSelected = FALSE;
  482. }
  483. return mIsSelected;
  484. }
  486. BOOL LLFolderViewItem::changeSelection(LLFolderViewItem* selection, BOOL selected)
  487. {
  488. if(selection == this && mIsSelected != selected)
  489. {
  490. mIsSelected = selected;
  491. if(mListener)
  492. {
  493. mListener->selectItem();
  494. }
  495. return TRUE;
  496. }
  497. return FALSE;
  498. }
  500. void LLFolderViewItem::recursiveDeselect(BOOL deselect_self)
  501. {
  502. if (mIsSelected && deselect_self)
  503. {
  504. mIsSelected = FALSE;
  506. // update ancestors' count of selected descendents
  507. LLFolderViewFolder* parent_folder = getParentFolder();
  508. while(parent_folder)
  509. {
  510. parent_folder->mNumDescendantsSelected--;
  511. parent_folder = parent_folder->getParentFolder();
  512. }
  513. }
  514. }
  517. BOOL LLFolderViewItem::isMovable()
  518. {
  519. if( mListener )
  520. {
  521. return mListener->isItemMovable();
  522. }
  523. else
  524. {
  525. return TRUE;
  526. }
  527. }
  529. BOOL LLFolderViewItem::isRemovable()
  530. {
  531. if( mListener )
  532. {
  533. return mListener->isItemRemovable();
  534. }
  535. else
  536. {
  537. return TRUE;
  538. }
  539. }
  541. void LLFolderViewItem::destroyView()
  542. {
  543. if (mParentFolder)
  544. {
  545. // removeView deletes me
  546. mParentFolder->removeView(this);
  547. }
  548. }
  550. // Call through to the viewed object and return true if it can be
  551. // removed.
  552. //BOOL LLFolderViewItem::removeRecursively(BOOL single_item)
  553. BOOL LLFolderViewItem::remove()
  554. {
  555. if(!isRemovable())
  556. {
  557. return FALSE;
  558. }
  559. if(mListener)
  560. {
  561. return mListener->removeItem();
  562. }
  563. return TRUE;
  564. }
  566. // Build an appropriate context menu for the item.
  567. void LLFolderViewItem::buildContextMenu(LLMenuGL& menu, U32 flags)
  568. {
  569. if(mListener)
  570. {
  571. mListener->buildContextMenu(menu, flags);
  572. }
  573. }
  575. void LLFolderViewItem::openItem( void )
  576. {
  577. if( mListener )
  578. {
  579. mListener->openItem();
  580. }
  581. }
  583. void LLFolderViewItem::preview( void )
  584. {
  585. if (mListener)
  586. {
  587. mListener->previewItem();
  588. }
  589. }
  591. void LLFolderViewItem::rename(const std::string& new_name)
  592. {
  593. if( !new_name.empty() )
  594. {
  595. if( mListener )
  596. {
  597. mListener->renameItem(new_name);
  599. if(mParentFolder)
  600. {
  601. mParentFolder->requestSort();
  602. }
  603. }
  604. }
  605. }
  607. const std::string& LLFolderViewItem::getSearchableLabel() const
  608. {
  609. return mSearchableLabel;
  610. }
  612. LLViewerInventoryItem * LLFolderViewItem::getInventoryItem(void)
  613. {
  614. return gInventory.getItem(getListener()->getUUID());
  615. }
  617. std::string LLFolderViewItem::getName( void ) const
  618. {
  619. if(mListener)
  620. {
  621. return mListener->getName();
  622. }
  623. return mLabel;
  624. }
  626. // LLView functionality
  627. BOOL LLFolderViewItem::handleRightMouseDown( S32 x, S32 y, MASK mask )
  628. {
  629. if(!mIsSelected)
  630. {
  631. setSelectionFromRoot(this, FALSE);
  632. }
  633. make_ui_sound("UISndClick");
  634. return TRUE;
  635. }
  637. BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
  638. {
  639. if (LLView::childrenHandleMouseDown(x, y, mask))
  640. {
  641. return TRUE;
  642. }
  644. // No handler needed for focus lost since this class has no
  645. // state that depends on it.
  646. gFocusMgr.setMouseCapture( this );
  648. if (!mIsSelected)
  649. {
  650. if(mask & MASK_CONTROL)
  651. {
  652. changeSelectionFromRoot(this, !mIsSelected);
  653. }
  654. else if (mask & MASK_SHIFT)
  655. {
  656. extendSelectionFromRoot(this);
  657. }
  658. else
  659. {
  660. setSelectionFromRoot(this, FALSE);
  661. }
  662. make_ui_sound("UISndClick");
  663. }
  664. else
  665. {
  666. mSelectPending = TRUE;
  667. }
  669. if( isMovable() )
  670. {
  671. S32 screen_x;
  672. S32 screen_y;
  673. localPointToScreen(x, y, &screen_x, &screen_y );
  674. LLToolDragAndDrop::getInstance()->setDragStart( screen_x, screen_y );
  675. }
  676. return TRUE;
  677. }
  679. BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
  680. {
  681. if( hasMouseCapture() && isMovable() )
  682. {
  683. S32 screen_x;
  684. S32 screen_y;
  685. localPointToScreen(x, y, &screen_x, &screen_y );
  686. BOOL can_drag = TRUE;
  687. if( LLToolDragAndDrop::getInstance()->isOverThreshold( screen_x, screen_y ) )
  688. {
  689. LLFolderView* root = getRoot();
  691. if(root->getCurSelectedItem())
  692. {
  693. LLToolDragAndDrop::ESource src = LLToolDragAndDrop::SOURCE_WORLD;
  695. // *TODO: push this into listener and remove
  696. // dependency on llagent
  697. if (mListener
  698. && gInventory.isObjectDescendentOf(mListener->getUUID(), gInventory.getRootFolderID()))
  699. {
  700. src = LLToolDragAndDrop::SOURCE_AGENT;
  701. }
  702. else if (mListener
  703. && gInventory.isObjectDescendentOf(mListener->getUUID(), gInventory.getLibraryRootFolderID()))
  704. {
  705. src = LLToolDragAndDrop::SOURCE_LIBRARY;
  706. }
  708. can_drag = root->startDrag(src);
  709. if (can_drag)
  710. {
  711. // if (mListener) mListener->startDrag();
  712. // RN: when starting drag and drop, clear out last auto-open
  713. root->autoOpenTest(NULL);
  714. root->setShowSelectionContext(TRUE);
  716. // Release keyboard focus, so that if stuff is dropped into the
  717. // world, pressing the delete key won't blow away the inventory
  718. // item.
  719. gFocusMgr.setKeyboardFocus(NULL);
  721. return LLToolDragAndDrop::getInstance()->handleHover( x, y, mask );
  722. }
  723. }
  724. }
  726. if (can_drag)
  727. {
  728. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  729. }
  730. else
  731. {
  732. gViewerWindow->setCursor(UI_CURSOR_NOLOCKED);
  733. }
  734. return TRUE;
  735. }
  736. else
  737. {
  738. getRoot()->setShowSelectionContext(FALSE);
  739. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  740. // let parent handle this then...
  741. return FALSE;
  742. }
  743. }
  746. BOOL LLFolderViewItem::handleDoubleClick( S32 x, S32 y, MASK mask )
  747. {
  748. preview();
  749. return TRUE;
  750. }
  752. BOOL LLFolderViewItem::handleMouseUp( S32 x, S32 y, MASK mask )
  753. {
  754. if (LLView::childrenHandleMouseUp(x, y, mask))
  755. {
  756. return TRUE;
  757. }
  759. // if mouse hasn't moved since mouse down...
  760. if ( pointInView(x, y) && mSelectPending )
  761. {
  762. //...then select
  763. if(mask & MASK_CONTROL)
  764. {
  765. changeSelectionFromRoot(this, !mIsSelected);
  766. }
  767. else if (mask & MASK_SHIFT)
  768. {
  769. extendSelectionFromRoot(this);
  770. }
  771. else
  772. {
  773. setSelectionFromRoot(this, FALSE);
  774. }
  775. }
  777. mSelectPending = FALSE;
  779. if( hasMouseCapture() )
  780. {
  781. getRoot()->setShowSelectionContext(FALSE);
  782. gFocusMgr.setMouseCapture( NULL );
  783. }
  784. return TRUE;
  785. }
  787. BOOL LLFolderViewItem::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  788.  EDragAndDropType cargo_type,
  789.  void* cargo_data,
  790.  EAcceptance* accept,
  791.  std::string& tooltip_msg)
  792. {
  793. BOOL accepted = FALSE;
  794. BOOL handled = FALSE;
  795. if(mListener)
  796. {
  797. accepted = mListener->dragOrDrop(mask,drop,cargo_type,cargo_data);
  798. handled = accepted;
  799. if (accepted)
  800. {
  801. mDragAndDropTarget = TRUE;
  802. *accept = ACCEPT_YES_MULTI;
  803. }
  804. else
  805. {
  806. *accept = ACCEPT_NO;
  807. }
  808. }
  809. if(mParentFolder && !handled)
  810. {
  811. // store this item to get it in LLFolderBridge::dragItemIntoFolder on drop event.
  812. mRoot->setDraggingOverItem(this);
  813. handled = mParentFolder->handleDragAndDropFromChild(mask,drop,cargo_type,cargo_data,accept,tooltip_msg);
  814. mRoot->setDraggingOverItem(NULL);
  815. }
  816. if (handled)
  817. {
  818. lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLFolderViewItem" << llendl;
  819. }
  821. return handled;
  822. }
  825. void LLFolderViewItem::draw()
  826. {
  827. if (mHidden) return;
  829. static LLUIColor sFgColor = LLUIColorTable::instance().getColor("MenuItemEnabledColor", DEFAULT_WHITE);
  830. static LLUIColor sHighlightBgColor = LLUIColorTable::instance().getColor("MenuItemHighlightBgColor", DEFAULT_WHITE);
  831. static LLUIColor sHighlightFgColor = LLUIColorTable::instance().getColor("MenuItemHighlightFgColor", DEFAULT_WHITE);
  832. static LLUIColor sFocusOutlineColor =
  833. LLUIColorTable::instance().getColor("InventoryFocusOutlineColor", DEFAULT_WHITE);
  834. static LLUIColor sFilterBGColor = LLUIColorTable::instance().getColor("FilterBackgroundColor", DEFAULT_WHITE);
  835. static LLUIColor sFilterTextColor = LLUIColorTable::instance().getColor("FilterTextColor", DEFAULT_WHITE);
  836. static LLUIColor sSuffixColor = LLUIColorTable::instance().getColor("InventoryItemSuffixColor", DEFAULT_WHITE);
  837. static LLUIColor sSearchStatusColor = LLUIColorTable::instance().getColor("InventorySearchStatusColor", DEFAULT_WHITE);
  839. const Params& default_params = LLUICtrlFactory::getDefaultParams<LLFolderViewItem>();
  840. const S32 TOP_PAD = default_params.item_top_pad;
  842. bool possibly_has_children = false;
  843. bool up_to_date = mListener && mListener->isUpToDate();
  844. if((up_to_date && hasVisibleChildren() ) || // we fetched our children and some of them have passed the filter...
  845. (!up_to_date && mListener && mListener->hasChildren())) // ...or we know we have children but haven't fetched them (doesn't obey filter)
  846. {
  847. possibly_has_children = true;
  848. }
  849. if(/*mControlLabel[0] != '' && */possibly_has_children)
  850. {
  851. LLUIImage* arrow_image = default_params.folder_arrow_image;
  852. gl_draw_scaled_rotated_image(
  853. mIndentation, getRect().getHeight() - ARROW_SIZE - TEXT_PAD - TOP_PAD,
  854. ARROW_SIZE, ARROW_SIZE, mControlLabelRotation, arrow_image->getImage(), sFgColor);
  855. }
  857. // See also LLFolderView::updateRenamerPosition()
  858. F32 text_left = (F32)(ARROW_SIZE + TEXT_PAD + ICON_WIDTH + ICON_PAD + mIndentation);
  860. LLFontGL* font = getLabelFontForStyle(mLabelStyle);
  862. // If we have keyboard focus, draw selection filled
  863. BOOL show_context = getRoot()->getShowSelectionContext();
  864. BOOL filled = show_context || (getRoot()->getParentPanel()->hasFocus());
  865. const S32 FOCUS_LEFT = 1;
  866. S32 focus_top = getRect().getHeight();
  867. S32 focus_bottom = getRect().getHeight() - mItemHeight;
  868. bool folder_open = (getRect().getHeight() > mItemHeight + 4);
  870. // always render "current" item, only render other selected items if
  871. // mShowSingleSelection is FALSE
  872. if( mIsSelected )
  873. {
  874. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  875. LLColor4 bg_color = sHighlightBgColor;
  876. if (!mIsCurSelection)
  877. {
  878. // do time-based fade of extra objects
  879. F32 fade_time = getRoot()->getSelectionFadeElapsedTime();
  880. if (getRoot()->getShowSingleSelection())
  881. {
  882. // fading out
  883. bg_color.mV[VALPHA] = clamp_rescale(fade_time, 0.f, 0.4f, bg_color.mV[VALPHA], 0.f);
  884. }
  885. else
  886. {
  887. // fading in
  888. bg_color.mV[VALPHA] = clamp_rescale(fade_time, 0.f, 0.4f, 0.f, bg_color.mV[VALPHA]);
  889. }
  890. }
  892. gl_rect_2d(
  893. FOCUS_LEFT,
  894. focus_top, 
  895. getRect().getWidth() - 2,
  896. focus_bottom,
  897. bg_color, filled);
  898. if (mIsCurSelection)
  899. {
  900. gl_rect_2d(
  901. FOCUS_LEFT, 
  902. focus_top, 
  903. getRect().getWidth() - 2,
  904. focus_bottom,
  905. sFocusOutlineColor, FALSE);
  906. }
  907. if (folder_open)
  908. {
  909. gl_rect_2d(
  910. FOCUS_LEFT,
  911. focus_bottom + 1, // overlap with bottom edge of above rect
  912. getRect().getWidth() - 2,
  913. 0,
  914. sFocusOutlineColor, FALSE);
  915. if (show_context)
  916. {
  917. gl_rect_2d(
  918. FOCUS_LEFT,
  919. focus_bottom + 1,
  920. getRect().getWidth() - 2,
  921. 0,
  922. sHighlightBgColor, TRUE);
  923. }
  924. }
  925. }
  926. if (mDragAndDropTarget)
  927. {
  928. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  929. gl_rect_2d(
  930. FOCUS_LEFT, 
  931. focus_top, 
  932. getRect().getWidth() - 2,
  933. focus_bottom,
  934. sHighlightBgColor, FALSE);
  935. if (folder_open)
  936. {
  937. gl_rect_2d(
  938. FOCUS_LEFT,
  939. focus_bottom + 1, // overlap with bottom edge of above rect
  940. getRect().getWidth() - 2,
  941. 0,
  942. sHighlightBgColor, FALSE);
  943. }
  944. mDragAndDropTarget = FALSE;
  945. }
  947. S32 icon_x = mIndentation + ARROW_SIZE + TEXT_PAD;
  948. // First case is used for open folders
  949. if (!mIconOpen.isNull() && (llabs(mControlLabelRotation) > 80))
  950.   {
  951. mIconOpen->draw(icon_x, getRect().getHeight() - mIconOpen->getHeight() - TOP_PAD + 1);
  952. }
  953. else if(mIcon)
  954. {
  955.   mIcon->draw(icon_x, getRect().getHeight() - mIcon->getHeight() - TOP_PAD + 1);
  956.   }
  958. if (!mLabel.empty())
  959. {
  960. // highlight filtered text
  961. BOOL debug_filters = getRoot()->getDebugFilters();
  962. LLColor4 color = ( (mIsSelected && filled) ? sHighlightFgColor : sFgColor );
  963. F32 right_x;
  964. F32 y = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD - (F32)TOP_PAD;
  966. if (debug_filters)
  967. {
  968. if (!getFiltered() && !possibly_has_children)
  969. {
  970. color.mV[VALPHA] *= 0.5f;
  971. }
  973. LLColor4 filter_color = mLastFilterGeneration >= getRoot()->getFilter()->getCurrentGeneration() ? LLColor4(0.5f, 0.8f, 0.5f, 1.f) : LLColor4(0.8f, 0.5f, 0.5f, 1.f);
  974. LLFontGL::getFontMonospace()->renderUTF8(
  975. mStatusText, 0, text_left, y, filter_color,
  976. LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
  977. S32_MAX, S32_MAX, &right_x, FALSE );
  978. text_left = right_x;
  979. }
  982. font->renderUTF8( mLabel, 0, text_left, y, color,
  983.   LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
  984.   S32_MAX, getRect().getWidth() - (S32) text_left, &right_x, TRUE);
  986. // LLViewerInventoryCategory *item = 0;
  987. // if (getListener())
  988. // item = gInventory.getCategory(getListener()->getUUID());
  989. bool root_is_loading = false;
  990. if (getListener() && gInventory.isObjectDescendentOf(getListener()->getUUID(),gInventory.getRootFolderID()))
  991. {
  992. // Descendent of my inventory.
  993. root_is_loading = gInventory.myInventoryFetchInProgress();
  994. }
  995. if (getListener() && gInventory.isObjectDescendentOf(getListener()->getUUID(),gInventory.getLibraryRootFolderID()))
  996. {
  997. // Descendent of library
  998. root_is_loading = gInventory.libraryFetchInProgress();
  999. }
  1001. if ( (mIsLoading && mTimeSinceRequestStart.getElapsedTimeF32() >= gSavedSettings.getF32("FolderLoadingMessageWaitTime"))
  1002. || (LLInventoryModel::backgroundFetchActive() && root_is_loading && mShowLoadStatus) )
  1003. {
  1004. std::string load_string = " ( " + LLTrans::getString("LoadingData") + " ) ";
  1005. font->renderUTF8(load_string, 0, right_x, y, sSearchStatusColor,
  1006.   LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, S32_MAX, S32_MAX, &right_x, FALSE);
  1007. }
  1009. if (!mLabelSuffix.empty())
  1010. {
  1011. font->renderUTF8( mLabelSuffix, 0, right_x, y, sSuffixColor,
  1012.    LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
  1013. S32_MAX, S32_MAX, &right_x, FALSE );
  1014. }
  1016. if (mStringMatchOffset != std::string::npos)
  1017. {
  1018. // don't draw backgrounds for zero-length strings
  1019. S32 filter_string_length = getRoot()->getFilterSubString().size();
  1020. if (filter_string_length > 0)
  1021. {
  1022. std::string combined_string = mLabel + mLabelSuffix;
  1023. S32 left = llround(text_left) + font->getWidth(combined_string, 0, mStringMatchOffset) - 1;
  1024. S32 right = left + font->getWidth(combined_string, mStringMatchOffset, filter_string_length) + 2;
  1025. S32 bottom = llfloor(getRect().getHeight() - font->getLineHeight() - 3 - TOP_PAD);
  1026. S32 top = getRect().getHeight() - TOP_PAD;
  1028. LLUIImage* box_image = default_params.selection_image;
  1029. LLRect box_rect(left, top, right, bottom);
  1030. box_image->draw(box_rect, sFilterBGColor);
  1031. F32 match_string_left = text_left + font->getWidthF32(combined_string, 0, mStringMatchOffset);
  1032. F32 yy = (F32)getRect().getHeight() - font->getLineHeight() - (F32)TEXT_PAD - (F32)TOP_PAD;
  1033. font->renderUTF8( combined_string, mStringMatchOffset, match_string_left, yy,
  1034.   sFilterTextColor, LLFontGL::LEFT, LLFontGL::BOTTOM, LLFontGL::NORMAL, LLFontGL::NO_SHADOW,
  1035.   filter_string_length, S32_MAX, &right_x, FALSE );
  1036. }
  1037. }
  1038. }
  1039. }
  1042. ///----------------------------------------------------------------------------
  1043. /// Class LLFolderViewFolder
  1044. ///----------------------------------------------------------------------------
  1046. LLFolderViewFolder::LLFolderViewFolder( const LLFolderViewItem::Params& p ): 
  1047. LLFolderViewItem( p ), // 0 = no create time
  1048. mIsOpen(FALSE),
  1049. mExpanderHighlighted(FALSE),
  1050. mCurHeight(0.f),
  1051. mTargetHeight(0.f),
  1052. mAutoOpenCountdown(0.f),
  1053. mSubtreeCreationDate(0),
  1054. mAmTrash(LLFolderViewFolder::UNKNOWN),
  1055. mLastArrangeGeneration( -1 ),
  1056. mLastCalculatedWidth(0),
  1057. mCompletedFilterGeneration(-1),
  1058. mMostFilteredDescendantGeneration(-1),
  1059. mNeedsSort(false)
  1060. {}
  1062. // Destroys the object
  1063. LLFolderViewFolder::~LLFolderViewFolder( void )
  1064. {
  1065. // The LLView base class takes care of object destruction. make sure that we
  1066. // don't have mouse or keyboard focus
  1067. gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit()
  1068. }
  1070. // addToFolder() returns TRUE if it succeeds. FALSE otherwise
  1071. BOOL LLFolderViewFolder::addToFolder(LLFolderViewFolder* folder, LLFolderView* root)
  1072. {
  1073. if (!folder)
  1074. {
  1075. return FALSE;
  1076. }
  1077. mParentFolder = folder;
  1078. root->addItemID(getListener()->getUUID(), this);
  1079. return folder->addFolder(this);
  1080. }
  1082. // Finds width and height of this object and it's children.  Also
  1083. // makes sure that this view and it's children are the right size.
  1084. S32 LLFolderViewFolder::arrange( S32* width, S32* height, S32 filter_generation)
  1085. {
  1086. // sort before laying out contents
  1087. if (mNeedsSort)
  1088. {
  1089. mFolders.sort(mSortFunction);
  1090. mItems.sort(mSortFunction);
  1091. mNeedsSort = false;
  1092. }
  1094. mHasVisibleChildren = hasFilteredDescendants(filter_generation);
  1096. LLInventoryFilter::EFolderShow show_folder_state = getRoot()->getFilter()->getShowFolderState();
  1098. // calculate height as a single item (without any children), and reshapes rectangle to match
  1099. LLFolderViewItem::arrange( width, height, filter_generation );
  1101. // clamp existing animated height so as to never get smaller than a single item
  1102. mCurHeight = llmax((F32)*height, mCurHeight);
  1104. // initialize running height value as height of single item in case we have no children
  1105. *height = getItemHeight();
  1106. F32 running_height = (F32)*height;
  1107. F32 target_height = (F32)*height;
  1109. // are my children visible?
  1110. if (needsArrange())
  1111. {
  1112. // set last arrange generation first, in case children are animating
  1113. // and need to be arranged again
  1114. mLastArrangeGeneration = getRoot()->getArrangeGeneration();
  1115. if (mIsOpen)
  1116. {
  1117. // Add sizes of children
  1118. S32 parent_item_height = getRect().getHeight();
  1120. for(folders_t::iterator fit = mFolders.begin(); fit != mFolders.end(); ++fit)
  1121. {
  1122. LLFolderViewFolder* folderp = (*fit);
  1123. if (getRoot()->getDebugFilters())
  1124. {
  1125. folderp->setVisible(TRUE);
  1126. }
  1127. else
  1128. {
  1129. folderp->setVisible(show_folder_state == LLInventoryFilter::SHOW_ALL_FOLDERS || // always show folders?
  1130. (folderp->getFiltered(filter_generation) || folderp->hasFilteredDescendants(filter_generation))); // passed filter or has descendants that passed filter
  1131. }
  1133. if (folderp->getVisible())
  1134. {
  1135. S32 child_width = *width;
  1136. S32 child_height = 0;
  1137. S32 child_top = parent_item_height - llround(running_height);
  1139. target_height += folderp->arrange( &child_width, &child_height, filter_generation );
  1141. running_height += (F32)child_height;
  1142. *width = llmax(*width, child_width);
  1143. folderp->setOrigin( 0, child_top - folderp->getRect().getHeight() );
  1144. }
  1145. }
  1146. for(items_t::iterator iit = mItems.begin();
  1147. iit != mItems.end(); ++iit)
  1148. {
  1149. LLFolderViewItem* itemp = (*iit);
  1150. if (getRoot()->getDebugFilters())
  1151. {
  1152. itemp->setVisible(TRUE);
  1153. }
  1154. else
  1155. {
  1156. itemp->setVisible(itemp->getFiltered(filter_generation));
  1157. }
  1159. if (itemp->getVisible())
  1160. {
  1161. S32 child_width = *width;
  1162. S32 child_height = 0;
  1163. S32 child_top = parent_item_height - llround(running_height);
  1165. target_height += itemp->arrange( &child_width, &child_height, filter_generation );
  1166. // don't change width, as this item is as wide as its parent folder by construction
  1167. itemp->reshape( itemp->getRect().getWidth(), child_height);
  1169. running_height += (F32)child_height;
  1170. *width = llmax(*width, child_width);
  1171. itemp->setOrigin( 0, child_top - itemp->getRect().getHeight() );
  1172. }
  1173. }
  1174. }
  1176. mTargetHeight = target_height;
  1177. // cache this width so next time we can just return it
  1178. mLastCalculatedWidth = *width;
  1179. }
  1180. else
  1181. {
  1182. // just use existing width
  1183. *width = mLastCalculatedWidth;
  1184. }
  1186. // animate current height towards target height
  1187. if (llabs(mCurHeight - mTargetHeight) > 1.f)
  1188. {
  1189. mCurHeight = lerp(mCurHeight, mTargetHeight, LLCriticalDamp::getInterpolant(mIsOpen ? FOLDER_OPEN_TIME_CONSTANT : FOLDER_CLOSE_TIME_CONSTANT));
  1191. requestArrange();
  1193. // hide child elements that fall out of current animated height
  1194. for (folders_t::iterator iter = mFolders.begin();
  1195. iter != mFolders.end();)
  1196. {
  1197. folders_t::iterator fit = iter++;
  1198. // number of pixels that bottom of folder label is from top of parent folder
  1199. if (getRect().getHeight() - (*fit)->getRect().mTop + (*fit)->getItemHeight() 
  1200. > llround(mCurHeight) + MAX_FOLDER_ITEM_OVERLAP)
  1201. {
  1202. // hide if beyond current folder height
  1203. (*fit)->setVisible(FALSE);
  1204. }
  1205. }
  1207. for (items_t::iterator iter = mItems.begin();
  1208. iter != mItems.end();)
  1209. {
  1210. items_t::iterator iit = iter++;
  1211. // number of pixels that bottom of item label is from top of parent folder
  1212. if (getRect().getHeight() - (*iit)->getRect().mBottom
  1213. > llround(mCurHeight) + MAX_FOLDER_ITEM_OVERLAP)
  1214. {
  1215. (*iit)->setVisible(FALSE);
  1216. }
  1217. }
  1218. }
  1219. else
  1220. {
  1221. mCurHeight = mTargetHeight;
  1222. }
  1224. // don't change width as this item is already as wide as its parent folder
  1225. reshape(getRect().getWidth(),llround(mCurHeight));
  1227. // pass current height value back to parent
  1228. *height = llround(mCurHeight);
  1230. return llround(mTargetHeight);
  1231. }
  1233. BOOL LLFolderViewFolder::needsArrange()
  1234. {
  1235. return mLastArrangeGeneration < getRoot()->getArrangeGeneration(); 
  1236. }
  1238. void LLFolderViewFolder::requestSort()
  1239. {
  1240. mNeedsSort = true;
  1241. // whenever item order changes, we need to lay things out again
  1242. requestArrange();
  1243. }
  1245. void LLFolderViewFolder::setCompletedFilterGeneration(S32 generation, BOOL recurse_up)
  1246. {
  1247. mMostFilteredDescendantGeneration = llmin(mMostFilteredDescendantGeneration, generation);
  1248. mCompletedFilterGeneration = generation;
  1249. // only aggregate up if we are a lower (older) value
  1250. if (recurse_up && mParentFolder && generation < mParentFolder->getCompletedFilterGeneration())
  1251. {
  1252. mParentFolder->setCompletedFilterGeneration(generation, TRUE);
  1253. }
  1254. }
  1256. void LLFolderViewFolder::filter( LLInventoryFilter& filter)
  1257. {
  1258. S32 filter_generation = filter.getCurrentGeneration();
  1259. // if failed to pass filter newer than must_pass_generation
  1260. // you will automatically fail this time, so we only
  1261. // check against items that have passed the filter
  1262. S32 must_pass_generation = filter.getMustPassGeneration();
  1264. bool autoopen_folders = (filter.hasFilterString());
  1266. // if we have already been filtered against this generation, skip out
  1267. if (getCompletedFilterGeneration() >= filter_generation)
  1268. {
  1269. return;
  1270. }
  1272. // filter folder itself
  1273. if (getLastFilterGeneration() < filter_generation)
  1274. {
  1275. if (getLastFilterGeneration() >= must_pass_generation && // folder has been compared to a valid precursor filter
  1276. !mPassedFilter) // and did not pass the filter
  1277. {
  1278. // go ahead and flag this folder as done
  1279. mLastFilterGeneration = filter_generation;
  1280. }
  1281. else
  1282. {
  1283. // filter self only on first pass through
  1284. LLFolderViewItem::filter( filter );
  1285. }
  1286. if (mHidden)
  1287. {
  1288. setOpen();
  1289. }
  1290. }
  1292. if (getRoot()->getDebugFilters())
  1293. {
  1294. mStatusText = llformat("%d", mLastFilterGeneration);
  1295. mStatusText += llformat("(%d)", mCompletedFilterGeneration);
  1296. mStatusText += llformat("+%d", mMostFilteredDescendantGeneration);
  1297. }
  1299. // all descendants have been filtered later than must pass generation
  1300. // but none passed
  1301. if(getCompletedFilterGeneration() >= must_pass_generation && !hasFilteredDescendants(must_pass_generation))
  1302. {
  1303. // don't traverse children if we've already filtered them since must_pass_generation
  1304. // and came back with nothing
  1305. return;
  1306. }
  1308. // we entered here with at least one filter iteration left
  1309. // check to see if we have any more before continuing on to children
  1310. if (filter.getFilterCount() < 0)
  1311. {
  1312. return;
  1313. }
  1315. // when applying a filter, matching folders get their contents downloaded first
  1316. if (filter.isNotDefault() && getFiltered(filter.getMinRequiredGeneration()) && (mListener && !gInventory.isCategoryComplete(mListener->getUUID())))
  1317. {
  1318. gInventory.startBackgroundFetch(mListener->getUUID());
  1319. }
  1321. // now query children
  1322. for (folders_t::iterator iter = mFolders.begin();
  1323.  iter != mFolders.end();
  1324.  ++iter)
  1325. {
  1326. LLFolderViewFolder* folder = (*iter);
  1327. // have we run out of iterations this frame?
  1328. if (filter.getFilterCount() < 0)
  1329. {
  1330. break;
  1331. }
  1333. // mMostFilteredDescendantGeneration might have been reset
  1334. // in which case we need to update it even for folders that
  1335. // don't need to be filtered anymore
  1336. if (folder->getCompletedFilterGeneration() >= filter_generation)
  1337. {
  1338. // track latest generation to pass any child items
  1339. if (folder->getFiltered() || folder->hasFilteredDescendants(filter.getMinRequiredGeneration()))
  1340. {
  1341. mMostFilteredDescendantGeneration = filter_generation;
  1342. }
  1343. // just skip it, it has already been filtered
  1344. continue;
  1345. }
  1347. // update this folders filter status (and children)
  1348. folder->filter( filter );
  1350. // track latest generation to pass any child items
  1351. if (folder->getFiltered() || folder->hasFilteredDescendants(filter_generation))
  1352. {
  1353. mMostFilteredDescendantGeneration = filter_generation;
  1354. if (getRoot()->needsAutoSelect() && autoopen_folders)
  1355. {
  1356. folder->setOpenArrangeRecursively(TRUE);
  1357. }
  1358. }
  1359. }
  1361. for (items_t::iterator iter = mItems.begin();
  1362.  iter != mItems.end();
  1363.  ++iter)
  1364. {
  1365. LLFolderViewItem* item = (*iter);
  1366. if (filter.getFilterCount() < 0)
  1367. {
  1368. break;
  1369. }
  1370. if (item->getLastFilterGeneration() >= filter_generation)
  1371. {
  1372. if (item->getFiltered())
  1373. {
  1374. mMostFilteredDescendantGeneration = filter_generation;
  1375. }
  1376. continue;
  1377. }
  1379. if (item->getLastFilterGeneration() >= must_pass_generation && 
  1380. !item->getFiltered(must_pass_generation))
  1381. {
  1382. // failed to pass an earlier filter that was a subset of the current one
  1383. // go ahead and flag this item as done
  1384. item->setFiltered(FALSE, filter_generation);
  1385. continue;
  1386. }
  1388. item->filter( filter );
  1390. if (item->getFiltered(filter.getMinRequiredGeneration()))
  1391. {
  1392. mMostFilteredDescendantGeneration = filter_generation;
  1393. }
  1394. }
  1396. // if we didn't use all filter iterations
  1397. // that means we filtered all of our descendants
  1398. // instead of exhausting the filter count for this frame
  1399. if (filter.getFilterCount() > 0)
  1400. {
  1401. // flag this folder as having completed filter pass for all descendants
  1402. setCompletedFilterGeneration(filter_generation, FALSE/*dont recurse up to root*/);
  1403. }
  1404. }
  1406. void LLFolderViewFolder::setFiltered(BOOL filtered, S32 filter_generation)
  1407. {
  1408. // if this folder is now filtered, but wasn't before
  1409. // (it just passed)
  1410. if (filtered && !mPassedFilter)
  1411. {
  1412. // reset current height, because last time we drew it
  1413. // it might have had more visible items than now
  1414. mCurHeight = 0.f;
  1415. }
  1417. LLFolderViewItem::setFiltered(filtered, filter_generation);
  1418. }
  1420. void LLFolderViewFolder::dirtyFilter()
  1421. {
  1422. // we're a folder, so invalidate our completed generation
  1423. setCompletedFilterGeneration(-1, FALSE);
  1424. LLFolderViewItem::dirtyFilter();
  1425. }
  1427. BOOL LLFolderViewFolder::hasFilteredDescendants()
  1428. {
  1429. return mMostFilteredDescendantGeneration >= getRoot()->getFilter()->getCurrentGeneration();
  1430. }
  1432. // Passes selection information on to children and record selection
  1433. // information if necessary.
  1434. BOOL LLFolderViewFolder::setSelection(LLFolderViewItem* selection, BOOL openitem,
  1435.   BOOL take_keyboard_focus)
  1436. {
  1437. BOOL rv = FALSE;
  1438. if( selection == this )
  1439. {
  1440. mIsSelected = TRUE;
  1441. if(mListener)
  1442. {
  1443. mListener->selectItem();
  1444. }
  1445. rv = TRUE;
  1446. }
  1447. else
  1448. {
  1449. mIsSelected = FALSE;
  1450. rv = FALSE;
  1451. }
  1452. BOOL child_selected = FALSE;
  1454. for (folders_t::iterator iter = mFolders.begin();
  1455. iter != mFolders.end();)
  1456. {
  1457. folders_t::iterator fit = iter++;
  1458. if((*fit)->setSelection(selection, openitem, take_keyboard_focus))
  1459. {
  1460. rv = TRUE;
  1461. child_selected = TRUE;
  1462. mNumDescendantsSelected++;
  1463. }
  1464. }
  1465. for (items_t::iterator iter = mItems.begin();
  1466. iter != mItems.end();)
  1467. {
  1468. items_t::iterator iit = iter++;
  1469. if((*iit)->setSelection(selection, openitem, take_keyboard_focus))
  1470. {
  1471. rv = TRUE;
  1472. child_selected = TRUE;
  1473. mNumDescendantsSelected++;
  1474. }
  1475. }
  1476. if(openitem && child_selected)
  1477. {
  1478. setOpenArrangeRecursively(TRUE);
  1479. }
  1480. return rv;
  1481. }
  1483. // This method is used to change the selection of an item. If
  1484. // selection is 'this', then note selection as true. Returns TRUE
  1485. // if this or a child is now selected.
  1486. BOOL LLFolderViewFolder::changeSelection(LLFolderViewItem* selection,
  1487.  BOOL selected)
  1488. {
  1489. BOOL rv = FALSE;
  1490. if(selection == this)
  1491. {
  1492. mIsSelected = selected;
  1493. if(mListener && selected)
  1494. {
  1495. mListener->selectItem();
  1496. }
  1497. rv = TRUE;
  1498. }
  1500. for (folders_t::iterator iter = mFolders.begin();
  1501. iter != mFolders.end();)
  1502. {
  1503. folders_t::iterator fit = iter++;
  1504. if((*fit)->changeSelection(selection, selected))
  1505. {
  1506. if (selected)
  1507. {
  1508. mNumDescendantsSelected++;
  1509. }
  1510. else
  1511. {
  1512. mNumDescendantsSelected--;
  1513. }
  1514. rv = TRUE;
  1515. }
  1516. }
  1517. for (items_t::iterator iter = mItems.begin();
  1518. iter != mItems.end();)
  1519. {
  1520. items_t::iterator iit = iter++;
  1521. if((*iit)->changeSelection(selection, selected))
  1522. {
  1523. if (selected)
  1524. {
  1525. mNumDescendantsSelected++;
  1526. }
  1527. else
  1528. {
  1529. mNumDescendantsSelected--;
  1530. }
  1531. rv = TRUE;
  1532. }
  1533. }
  1534. return rv;
  1535. }
  1537. S32 LLFolderViewFolder::extendSelection(LLFolderViewItem* selection, LLFolderViewItem* last_selected, LLDynamicArray<LLFolderViewItem*>& selected_items)
  1538. {
  1539. S32 num_selected = 0;
  1541. // pass on to child folders first
  1542. for (folders_t::iterator iter = mFolders.begin();
  1543. iter != mFolders.end();)
  1544. {
  1545. folders_t::iterator fit = iter++;
  1546. num_selected += (*fit)->extendSelection(selection, last_selected, selected_items);
  1547. mNumDescendantsSelected += num_selected;
  1548. }
  1550. // handle selection of our immediate children...
  1551. BOOL reverse_select = FALSE;
  1552. BOOL found_last_selected = FALSE;
  1553. BOOL found_selection = FALSE;
  1554. LLDynamicArray<LLFolderViewItem*> items_to_select;
  1555. LLFolderViewItem* item;
  1557. //...folders first...
  1558. for (folders_t::iterator iter = mFolders.begin();
  1559. iter != mFolders.end();)
  1560. {
  1561. folders_t::iterator fit = iter++;
  1562. item = (*fit);
  1563. if(item == selection)
  1564. {
  1565. found_selection = TRUE;
  1566. }
  1567. else if (item == last_selected)
  1568. {
  1569. found_last_selected = TRUE;
  1570. if (found_selection)
  1571. {
  1572. reverse_select = TRUE;
  1573. }
  1574. }
  1576. if (found_selection || found_last_selected)
  1577. {
  1578. // deselect currently selected items so they can be pushed back on queue
  1579. if (item->isSelected())
  1580. {
  1581. item->changeSelection(item, FALSE);
  1582. }
  1583. items_to_select.put(item);
  1584. }
  1586. if (found_selection && found_last_selected)
  1587. {
  1588. break;
  1589. }
  1590. }
  1592. if (!(found_selection && found_last_selected))
  1593. {
  1594. //,,,then items
  1595. for (items_t::iterator iter = mItems.begin();
  1596. iter != mItems.end();)
  1597. {
  1598. items_t::iterator iit = iter++;
  1599. item = (*iit);
  1600. if(item == selection)
  1601. {
  1602. found_selection = TRUE;
  1603. }
  1604. else if (item == last_selected)
  1605. {
  1606. found_last_selected = TRUE;
  1607. if (found_selection)
  1608. {
  1609. reverse_select = TRUE;
  1610. }
  1611. }
  1613. if (found_selection || found_last_selected)
  1614. {
  1615. // deselect currently selected items so they can be pushed back on queue
  1616. if (item->isSelected())
  1617. {
  1618. item->changeSelection(item, FALSE);
  1619. }
  1620. items_to_select.put(item);
  1621. }
  1623. if (found_selection && found_last_selected)
  1624. {
  1625. break;
  1626. }
  1627. }
  1628. }
  1630. if (found_last_selected && found_selection)
  1631. {
  1632. // we have a complete selection inside this folder
  1633. for (S32 index = reverse_select ? items_to_select.getLength() - 1 : 0; 
  1634. reverse_select ? index >= 0 : index < items_to_select.getLength(); reverse_select ? index-- : index++)
  1635. {
  1636. LLFolderViewItem* item = items_to_select[index];
  1637. if (item->changeSelection(item, TRUE))
  1638. {
  1639. selected_items.put(item);
  1640. mNumDescendantsSelected++;
  1641. num_selected++;
  1642. }
  1643. }
  1644. }
  1645. else if (found_selection)
  1646. {
  1647. // last selection was not in this folder....go ahead and select just the new item
  1648. if (selection->changeSelection(selection, TRUE))
  1649. {
  1650. selected_items.put(selection);
  1651. mNumDescendantsSelected++;
  1652. num_selected++;
  1653. }
  1654. }
  1656. return num_selected;
  1657. }
  1659. void LLFolderViewFolder::recursiveDeselect(BOOL deselect_self)
  1660. {
  1661. // make sure we don't have negative values
  1662. llassert(mNumDescendantsSelected >= 0);
  1664. if (mIsSelected && deselect_self)
  1665. {
  1666. mIsSelected = FALSE;
  1668. // update ancestors' count of selected descendents
  1669. LLFolderViewFolder* parent_folder = getParentFolder();
  1670. while(parent_folder)
  1671. {
  1672. parent_folder->mNumDescendantsSelected--;
  1673. parent_folder = parent_folder->getParentFolder();
  1674. }
  1675. }
  1677. if (0 == mNumDescendantsSelected)
  1678. {
  1679. return;
  1680. }
  1682. for (items_t::iterator iter = mItems.begin();
  1683. iter != mItems.end();)
  1684. {
  1685. items_t::iterator iit = iter++;
  1686. LLFolderViewItem* item = (*iit);
  1687. item->recursiveDeselect(TRUE);
  1688. }
  1690. for (folders_t::iterator iter = mFolders.begin();
  1691. iter != mFolders.end();)
  1692. {
  1693. folders_t::iterator fit = iter++;
  1694. LLFolderViewFolder* folder = (*fit);
  1695. folder->recursiveDeselect(TRUE);
  1696. }
  1698. }
  1700. void LLFolderViewFolder::destroyView()
  1701. {
  1702. for (items_t::iterator iter = mItems.begin();
  1703. iter != mItems.end();)
  1704. {
  1705. items_t::iterator iit = iter++;
  1706. LLFolderViewItem* item = (*iit);
  1707. getRoot()->removeItemID(item->getListener()->getUUID());
  1708. }
  1710. std::for_each(mItems.begin(), mItems.end(), DeletePointer());
  1711. mItems.clear();
  1713. while (!mFolders.empty())
  1714. {
  1715. LLFolderViewFolder *folderp = mFolders.back();
  1716. folderp->destroyView(); // removes entry from mFolders
  1717. }
  1719. deleteAllChildren();
  1721. if (mParentFolder)
  1722. {
  1723. mParentFolder->removeView(this);
  1724. }
  1725. }
  1727. // remove the specified item (and any children) if possible. Return
  1728. // TRUE if the item was deleted.
  1729. BOOL LLFolderViewFolder::removeItem(LLFolderViewItem* item)
  1730. {
  1731. if(item->remove())
  1732. {
  1733. //RN: this seem unneccessary as remove() moves to trash
  1734. //removeView(item);
  1735. return TRUE;
  1736. }
  1737. return FALSE;
  1738. }
  1740. // simply remove the view (and any children) Don't bother telling the
  1741. // listeners.
  1742. void LLFolderViewFolder::removeView(LLFolderViewItem* item)
  1743. {
  1744. if (!item || item->getParentFolder() != this)
  1745. {
  1746. return;
  1747. }
  1748. // deselect without traversing hierarchy
  1749. item->recursiveDeselect(TRUE);
  1750. getRoot()->removeFromSelectionList(item);
  1751. extractItem(item);
  1752. delete item;
  1753. }
  1755. // extractItem() removes the specified item from the folder, but
  1756. // doesn't delete it.
  1757. void LLFolderViewFolder::extractItem( LLFolderViewItem* item )
  1758. {
  1759. items_t::iterator it = std::find(mItems.begin(), mItems.end(), item);
  1760. if(it == mItems.end())
  1761. {
  1762. // This is an evil downcast. However, it's only doing
  1763. // pointer comparison to find if (which it should be ) the
  1764. // item is in the container, so it's pretty safe.
  1765. LLFolderViewFolder* f = reinterpret_cast<LLFolderViewFolder*>(item);
  1766. folders_t::iterator ft;
  1767. ft = std::find(mFolders.begin(), mFolders.end(), f);
  1768. if(ft != mFolders.end())
  1769. {
  1770. mFolders.erase(ft);
  1771. }
  1772. }
  1773. else
  1774. {
  1775. mItems.erase(it);
  1776. }
  1777. //item has been removed, need to update filter
  1778. dirtyFilter();
  1779. //because an item is going away regardless of filter status, force rearrange
  1780. requestArrange();
  1781. getRoot()->removeItemID(item->getListener()->getUUID());
  1782. removeChild(item);
  1783. }
  1785. bool LLFolderViewFolder::isTrash() const
  1786. {
  1787. if (mAmTrash == LLFolderViewFolder::UNKNOWN)
  1788. {
  1789. mAmTrash = mListener->getUUID() == gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH, false) ? LLFolderViewFolder::TRASH : LLFolderViewFolder::NOT_TRASH;
  1790. }
  1791. return mAmTrash == LLFolderViewFolder::TRASH;
  1792. }
  1794. void LLFolderViewFolder::sortBy(U32 order)
  1795. {
  1796. if (!mSortFunction.updateSort(order))
  1797. {
  1798. // No changes.
  1799. return;
  1800. }
  1802. // Propegate this change to sub folders
  1803. for (folders_t::iterator iter = mFolders.begin();
  1804. iter != mFolders.end();)
  1805. {
  1806. folders_t::iterator fit = iter++;
  1807. (*fit)->sortBy(order);
  1808. }
  1810. mFolders.sort(mSortFunction);
  1811. mItems.sort(mSortFunction);
  1813. if (order & LLInventoryFilter::SO_DATE)
  1814. {
  1815. time_t latest = 0;
  1817. if (!mItems.empty())
  1818. {
  1819. LLFolderViewItem* item = *(mItems.begin());
  1820. latest = item->getCreationDate();
  1821. }
  1823. if (!mFolders.empty())
  1824. {
  1825. LLFolderViewFolder* folder = *(mFolders.begin());
  1826. if (folder->getCreationDate() > latest)
  1827. {
  1828. latest = folder->getCreationDate();
  1829. }
  1830. }
  1831. mSubtreeCreationDate = latest;
  1832. }
  1833. }
  1835. void LLFolderViewFolder::setItemSortOrder(U32 ordering)
  1836. {
  1837. if (mSortFunction.updateSort(ordering))
  1838. {
  1839. for (folders_t::iterator iter = mFolders.begin();
  1840. iter != mFolders.end();)
  1841. {
  1842. folders_t::iterator fit = iter++;
  1843. (*fit)->setItemSortOrder(ordering);
  1844. }
  1846. mFolders.sort(mSortFunction);
  1847. mItems.sort(mSortFunction);
  1848. }
  1849. }
  1851. EInventorySortGroup LLFolderViewFolder::getSortGroup() const
  1852. {
  1853. if (isTrash())
  1854. {
  1855. return SG_TRASH_FOLDER;
  1856. }
  1858. if( mListener )
  1859. {
  1860. if(LLFolderType::lookupIsProtectedType(mListener->getPreferredType()))
  1861. {
  1862. return SG_SYSTEM_FOLDER;
  1863. }
  1864. }
  1866. return SG_NORMAL_FOLDER;
  1867. }
  1869. BOOL LLFolderViewFolder::isMovable()
  1870. {
  1871. if( mListener )
  1872. {
  1873. if( !(mListener->isItemMovable()) )
  1874. {
  1875. return FALSE;
  1876. }
  1878. for (items_t::iterator iter = mItems.begin();
  1879. iter != mItems.end();)
  1880. {
  1881. items_t::iterator iit = iter++;
  1882. if(!(*iit)->isMovable())
  1883. {
  1884. return FALSE;
  1885. }
  1886. }
  1888. for (folders_t::iterator iter = mFolders.begin();
  1889. iter != mFolders.end();)
  1890. {
  1891. folders_t::iterator fit = iter++;
  1892. if(!(*fit)->isMovable())
  1893. {
  1894. return FALSE;
  1895. }
  1896. }
  1897. }
  1898. return TRUE;
  1899. }
  1902. BOOL LLFolderViewFolder::isRemovable()
  1903. {
  1904. if( mListener )
  1905. {
  1906. if( !(mListener->isItemRemovable()) )
  1907. {
  1908. return FALSE;
  1909. }
  1911. for (items_t::iterator iter = mItems.begin();
  1912. iter != mItems.end();)
  1913. {
  1914. items_t::iterator iit = iter++;
  1915. if(!(*iit)->isRemovable())
  1916. {
  1917. return FALSE;
  1918. }
  1919. }
  1921. for (folders_t::iterator iter = mFolders.begin();
  1922. iter != mFolders.end();)
  1923. {
  1924. folders_t::iterator fit = iter++;
  1925. if(!(*fit)->isRemovable())
  1926. {
  1927. return FALSE;
  1928. }
  1929. }
  1930. }
  1931. return TRUE;
  1932. }
  1934. // this is an internal method used for adding items to folders. 
  1935. BOOL LLFolderViewFolder::addItem(LLFolderViewItem* item)
  1936. {
  1937. mItems.push_back(item);
  1938. item->setRect(LLRect(0, 0, getRect().getWidth(), 0));
  1939. item->setVisible(FALSE);
  1940. addChild( item );
  1941. item->dirtyFilter();
  1942. requestArrange();
  1943. requestSort();
  1944. return TRUE;
  1945. }
  1947. // this is an internal method used for adding items to folders. 
  1948. BOOL LLFolderViewFolder::addFolder(LLFolderViewFolder* folder)
  1949. {
  1950. mFolders.push_back(folder);
  1951. folder->setOrigin(0, 0);
  1952. folder->reshape(getRect().getWidth(), 0);
  1953. folder->setVisible(FALSE);
  1954. addChild( folder );
  1955. folder->dirtyFilter();
  1956. // rearrange all descendants too, as our indentation level might have changed
  1957. folder->requestArrange(TRUE);
  1958. requestSort();
  1959. return TRUE;
  1960. }
  1962. void LLFolderViewFolder::requestArrange(BOOL include_descendants)
  1963. { 
  1964. mLastArrangeGeneration = -1; 
  1965. // flag all items up to root
  1966. if (mParentFolder)
  1967. {
  1968. mParentFolder->requestArrange();
  1969. }
  1971. if (include_descendants)
  1972. {
  1973. for (folders_t::iterator iter = mFolders.begin();
  1974. iter != mFolders.end();
  1975. ++iter)
  1976. {
  1977. (*iter)->requestArrange(TRUE);
  1978. }
  1979. }
  1980. }
  1982. void LLFolderViewFolder::toggleOpen()
  1983. {
  1984. setOpen(!mIsOpen);
  1985. }
  1987. // Force a folder open or closed
  1988. void LLFolderViewFolder::setOpen(BOOL openitem)
  1989. {
  1990. setOpenArrangeRecursively(openitem);
  1991. }
  1993. void LLFolderViewFolder::setOpenArrangeRecursively(BOOL openitem, ERecurseType recurse)
  1994. {
  1995. BOOL was_open = mIsOpen;
  1996. mIsOpen = openitem;
  1997. if (mListener)
  1998. {
  1999. if(!was_open && openitem)
  2000. {
  2001. mListener->openItem();
  2002. }
  2003. else if(was_open && !openitem)
  2004. {
  2005. mListener->closeItem();
  2006. }
  2007. }
  2009. if (recurse == RECURSE_DOWN || recurse == RECURSE_UP_DOWN)
  2010. {
  2011. for (folders_t::iterator iter = mFolders.begin();
  2012. iter != mFolders.end();)
  2013. {
  2014. folders_t::iterator fit = iter++;
  2015. (*fit)->setOpenArrangeRecursively(openitem, RECURSE_DOWN); /* Flawfinder: ignore */
  2016. }
  2017. }
  2018. if (mParentFolder && (recurse == RECURSE_UP || recurse == RECURSE_UP_DOWN))
  2019. {
  2020. mParentFolder->setOpenArrangeRecursively(openitem, RECURSE_UP);
  2021. }
  2023. if (was_open != mIsOpen)
  2024. {
  2025. requestArrange();
  2026. }
  2027. }
  2029. BOOL LLFolderViewFolder::handleDragAndDropFromChild(MASK mask,
  2030. BOOL drop,
  2031. EDragAndDropType c_type,
  2032. void* cargo_data,
  2033. EAcceptance* accept,
  2034. std::string& tooltip_msg)
  2035. {
  2036. BOOL accepted = mListener && mListener->dragOrDrop(mask,drop,c_type,cargo_data);
  2037. if (accepted) 
  2038. {
  2039. mDragAndDropTarget = TRUE;
  2040. *accept = ACCEPT_YES_MULTI;
  2041. }
  2042. else 
  2043. {
  2044. *accept = ACCEPT_NO;
  2045. }
  2047. // drag and drop to child item, so clear pending auto-opens
  2048. getRoot()->autoOpenTest(NULL);
  2050. return TRUE;
  2051. }
  2053. void LLFolderViewFolder::openItem( void )
  2054. {
  2055. toggleOpen();
  2056. }
  2058. void LLFolderViewFolder::applyFunctorToChildren(LLFolderViewFunctor& functor)
  2059. {
  2060. for (folders_t::iterator iter = mFolders.begin();
  2061. iter != mFolders.end();)
  2062. {
  2063. folders_t::iterator fit = iter++;
  2064. functor.doItem((*fit));
  2065. }
  2066. for (items_t::iterator iter = mItems.begin();
  2067. iter != mItems.end();)
  2068. {
  2069. items_t::iterator iit = iter++;
  2070. functor.doItem((*iit));
  2071. }
  2072. }
  2074. void LLFolderViewFolder::applyFunctorRecursively(LLFolderViewFunctor& functor)
  2075. {
  2076. functor.doFolder(this);
  2078. for (folders_t::iterator iter = mFolders.begin();
  2079. iter != mFolders.end();)
  2080. {
  2081. folders_t::iterator fit = iter++;
  2082. (*fit)->applyFunctorRecursively(functor);
  2083. }
  2084. for (items_t::iterator iter = mItems.begin();
  2085. iter != mItems.end();)
  2086. {
  2087. items_t::iterator iit = iter++;
  2088. functor.doItem((*iit));
  2089. }
  2090. }
  2092. void LLFolderViewFolder::applyListenerFunctorRecursively(LLFolderViewListenerFunctor& functor)
  2093. {
  2094. functor(mListener);
  2095. for (folders_t::iterator iter = mFolders.begin();
  2096. iter != mFolders.end();)
  2097. {
  2098. folders_t::iterator fit = iter++;
  2099. (*fit)->applyListenerFunctorRecursively(functor);
  2100. }
  2101. for (items_t::iterator iter = mItems.begin();
  2102. iter != mItems.end();)
  2103. {
  2104. items_t::iterator iit = iter++;
  2105. (*iit)->applyListenerFunctorRecursively(functor);
  2106. }
  2107. }
  2109. // LLView functionality
  2110. BOOL LLFolderViewFolder::handleDragAndDrop(S32 x, S32 y, MASK mask,
  2111.    BOOL drop,
  2112.    EDragAndDropType cargo_type,
  2113.    void* cargo_data,
  2114.    EAcceptance* accept,
  2115.    std::string& tooltip_msg)
  2116. {
  2117. LLFolderView* root_view = getRoot();
  2119. BOOL handled = FALSE;
  2120. if(mIsOpen)
  2121. {
  2122. handled = childrenHandleDragAndDrop(x, y, mask, drop, cargo_type,
  2123. cargo_data, accept, tooltip_msg) != NULL;
  2124. }
  2126. if (!handled)
  2127. {
  2128. BOOL accepted = mListener && mListener->dragOrDrop(mask, drop,cargo_type,cargo_data);
  2130. if (accepted) 
  2131. {
  2132. mDragAndDropTarget = TRUE;
  2133. *accept = ACCEPT_YES_MULTI;
  2134. }
  2135. else 
  2136. {
  2137. *accept = ACCEPT_NO;
  2138. }
  2140. if (!drop && accepted)
  2141. {
  2142. root_view->autoOpenTest(this);
  2143. }
  2145. lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLFolderViewFolder" << llendl;
  2146. }
  2148. return TRUE;
  2149. }
  2152. BOOL LLFolderViewFolder::handleRightMouseDown( S32 x, S32 y, MASK mask )
  2153. {
  2154. BOOL handled = FALSE;
  2155. // fetch contents of this folder, as context menu can depend on contents
  2156. // still, user would have to open context menu again to see the changes
  2157. gInventory.fetchDescendentsOf(mListener->getUUID());
  2159. if( mIsOpen )
  2160. {
  2161. handled = childrenHandleRightMouseDown( x, y, mask ) != NULL;
  2162. }
  2163. if (!handled)
  2164. {
  2165. handled = LLFolderViewItem::handleRightMouseDown( x, y, mask );
  2166. }
  2167. return handled;
  2168. }
  2171. BOOL LLFolderViewFolder::handleHover(S32 x, S32 y, MASK mask)
  2172. {
  2173. BOOL handled = LLView::handleHover(x, y, mask);
  2175. if (!handled)
  2176. {
  2177. // this doesn't do child processing
  2178. handled = LLFolderViewItem::handleHover(x, y, mask);
  2179. }
  2181. return handled;
  2182. }
  2184. BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
  2185. {
  2186. BOOL handled = FALSE;
  2187. if( mIsOpen )
  2188. {
  2189. handled = childrenHandleMouseDown(x,y,mask) != NULL;
  2190. }
  2191. if( !handled )
  2192. {
  2193. if(mIndentation < x && x < mIndentation + ARROW_SIZE + TEXT_PAD)
  2194. {
  2195. toggleOpen();
  2196. handled = TRUE;
  2197. }
  2198. else
  2199. {
  2200. // do normal selection logic
  2201. handled = LLFolderViewItem::handleMouseDown(x, y, mask);
  2202. }
  2203. }
  2205. return handled;
  2206. }
  2208. BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
  2209. {
  2210. /* Disable outfit double click to wear
  2211. const LLUUID &cat_uuid = getListener()->getUUID();
  2212. const LLViewerInventoryCategory *cat = gInventory.getCategory(cat_uuid);
  2213. if (cat && cat->getPreferredType() == LLFolderType::FT_OUTFIT)
  2214. {
  2215. getListener()->performAction(NULL, NULL,"replaceoutfit");
  2216. return TRUE;
  2217. }
  2218. */
  2220. BOOL handled = FALSE;
  2221. if( mIsOpen )
  2222. {
  2223. handled = childrenHandleDoubleClick( x, y, mask ) != NULL;
  2224. }
  2225. if( !handled )
  2226. {
  2227. if(mIndentation < x && x < mIndentation + ARROW_SIZE + TEXT_PAD)
  2228. {
  2229. // don't select when user double-clicks plus sign
  2230. // so as not to contradict single-click behavior
  2231. toggleOpen();
  2232. }
  2233. else
  2234. {
  2235. setSelectionFromRoot(this, FALSE);
  2236. toggleOpen();
  2237. }
  2238. handled = TRUE;
  2239. }
  2240. return handled;
  2241. }
  2243. void LLFolderViewFolder::draw()
  2244. {
  2245. if (mAutoOpenCountdown != 0.f)
  2246. {
  2247. mControlLabelRotation = mAutoOpenCountdown * -90.f;
  2248. }
  2249. else if (mIsOpen)
  2250. {
  2251. mControlLabelRotation = lerp(mControlLabelRotation, -90.f, LLCriticalDamp::getInterpolant(0.04f));
  2252. }
  2253. else
  2254. {
  2255. mControlLabelRotation = lerp(mControlLabelRotation, 0.f, LLCriticalDamp::getInterpolant(0.025f));
  2256. }
  2258. bool possibly_has_children = false;
  2259. bool up_to_date = mListener && mListener->isUpToDate();
  2260. if(!up_to_date && mListener && mListener->hasChildren()) // we know we have children but haven't fetched them (doesn't obey filter)
  2261. {
  2262. possibly_has_children = true;
  2263. }
  2266. BOOL loading = ( mIsOpen && possibly_has_children && !up_to_date );
  2268. if ( loading && !mIsLoading )
  2269. {
  2270. // Measure how long we've been in the loading state
  2271. mTimeSinceRequestStart.reset();
  2272. }
  2274. mIsLoading = loading;
  2276. LLFolderViewItem::draw();
  2278. // draw children if root folder, or any other folder that is open or animating to closed state
  2279. if( getRoot() == this || (mIsOpen || mCurHeight != mTargetHeight ))
  2280. {
  2281. LLView::draw();
  2282. }
  2284. mExpanderHighlighted = FALSE;
  2285. }
  2287. time_t LLFolderViewFolder::getCreationDate() const
  2288. {
  2289. return llmax<time_t>(mCreationDate, mSubtreeCreationDate);
  2290. }
  2293. BOOL LLFolderViewFolder::potentiallyVisible()
  2294. {
  2295. // folder should be visible by it's own filter status
  2296. return LLFolderViewItem::potentiallyVisible() 
  2297. // or one or more of its descendants have passed the minimum filter requirement
  2298. || hasFilteredDescendants(getRoot()->getFilter()->getMinRequiredGeneration())
  2299. // or not all of its descendants have been checked against minimum filter requirement
  2300. || getCompletedFilterGeneration() < getRoot()->getFilter()->getMinRequiredGeneration(); 
  2301. }
  2303. // this does prefix traversal, as folders are listed above their contents
  2304. LLFolderViewItem* LLFolderViewFolder::getNextFromChild( LLFolderViewItem* item, BOOL include_children )
  2305. {
  2306. BOOL found_item = FALSE;
  2308. LLFolderViewItem* result = NULL;
  2309. // when not starting from a given item, start at beginning
  2310. if(item == NULL)
  2311. {
  2312. found_item = TRUE;
  2313. }
  2315. // find current item among children
  2316. folders_t::iterator fit = mFolders.begin();
  2317. folders_t::iterator fend = mFolders.end();
  2319. items_t::iterator iit = mItems.begin();
  2320. items_t::iterator iend = mItems.end();
  2322. // if not trivially starting at the beginning, we have to find the current item
  2323. if (!found_item)
  2324. {
  2325. // first, look among folders, since they are always above items
  2326. for(; fit != fend; ++fit)
  2327. {
  2328. if(item == (*fit))
  2329. {
  2330. found_item = TRUE;
  2331. // if we are on downwards traversal
  2332. if (include_children && (*fit)->isOpen())
  2333. {
  2334. // look for first descendant
  2335. return (*fit)->getNextFromChild(NULL, TRUE);
  2336. }
  2337. // otherwise advance to next folder
  2338. ++fit;
  2339. include_children = TRUE;
  2340. break;
  2341. }
  2342. }
  2344. // didn't find in folders?  Check items...
  2345. if (!found_item)
  2346. {
  2347. for(; iit != iend; ++iit)
  2348. {
  2349. if(item == (*iit))
  2350. {
  2351. found_item = TRUE;
  2352. // point to next item
  2353. ++iit;
  2354. break;
  2355. }
  2356. }
  2357. }
  2358. }
  2360. if (!found_item)
  2361. {
  2362. // you should never call this method with an item that isn't a child
  2363. // so we should always find something
  2364. llassert(FALSE);
  2365. return NULL;
  2366. }
  2368. // at this point, either iit or fit point to a candidate "next" item
  2369. // if both are out of range, we need to punt up to our parent
  2371. // now, starting from found folder, continue through folders
  2372. // searching for next visible folder
  2373. while(fit != fend && !(*fit)->getVisible())
  2374. {
  2375. // turn on downwards traversal for next folder
  2376. ++fit;
  2377. } 
  2379. if (fit != fend)
  2380. {
  2381. result = (*fit);
  2382. }
  2383. else
  2384. {
  2385. // otherwise, scan for next visible item
  2386. while(iit != iend && !(*iit)->getVisible())
  2387. {
  2388. ++iit;
  2389. } 
  2391. // check to see if we have a valid item
  2392. if (iit != iend)
  2393. {
  2394. result = (*iit);
  2395. }
  2396. }
  2398. if( !result && mParentFolder )
  2399. {
  2400. // If there are no siblings or children to go to, recurse up one level in the tree
  2401. // and skip children for this folder, as we've already discounted them
  2402. result = mParentFolder->getNextFromChild(this, FALSE);
  2403. }
  2405. return result;
  2406. }
  2408. // this does postfix traversal, as folders are listed above their contents
  2409. LLFolderViewItem* LLFolderViewFolder::getPreviousFromChild( LLFolderViewItem* item, BOOL include_children )
  2410. {
  2411. BOOL found_item = FALSE;
  2413. LLFolderViewItem* result = NULL;
  2414. // when not starting from a given item, start at end
  2415. if(item == NULL)
  2416. {
  2417. found_item = TRUE;
  2418. }
  2420. // find current item among children
  2421. folders_t::reverse_iterator fit = mFolders.rbegin();
  2422. folders_t::reverse_iterator fend = mFolders.rend();
  2424. items_t::reverse_iterator iit = mItems.rbegin();
  2425. items_t::reverse_iterator iend = mItems.rend();
  2427. // if not trivially starting at the end, we have to find the current item
  2428. if (!found_item)
  2429. {
  2430. // first, look among items, since they are always below the folders
  2431. for(; iit != iend; ++iit)
  2432. {
  2433. if(item == (*iit))
  2434. {
  2435. found_item = TRUE;
  2436. // point to next item
  2437. ++iit;
  2438. break;
  2439. }
  2440. }
  2442. // didn't find in items?  Check folders...
  2443. if (!found_item)
  2444. {
  2445. for(; fit != fend; ++fit)
  2446. {
  2447. if(item == (*fit))
  2448. {
  2449. found_item = TRUE;
  2450. // point to next folder
  2451. ++fit;
  2452. break;
  2453. }
  2454. }
  2455. }
  2456. }
  2458. if (!found_item)
  2459. {
  2460. // you should never call this method with an item that isn't a child
  2461. // so we should always find something
  2462. llassert(FALSE);
  2463. return NULL;
  2464. }
  2466. // at this point, either iit or fit point to a candidate "next" item
  2467. // if both are out of range, we need to punt up to our parent
  2469. // now, starting from found item, continue through items
  2470. // searching for next visible item
  2471. while(iit != iend && !(*iit)->getVisible())
  2472. {
  2473. ++iit;
  2474. } 
  2476. if (iit != iend)
  2477. {
  2478. // we found an appropriate item
  2479. result = (*iit);
  2480. }
  2481. else
  2482. {
  2483. // otherwise, scan for next visible folder
  2484. while(fit != fend && !(*fit)->getVisible())
  2485. {
  2486. ++fit;
  2487. } 
  2489. // check to see if we have a valid folder
  2490. if (fit != fend)
  2491. {
  2492. // try selecting child element of this folder
  2493. if ((*fit)->isOpen())
  2494. {
  2495. result = (*fit)->getPreviousFromChild(NULL);
  2496. }
  2497. else
  2498. {
  2499. result = (*fit);
  2500. }
  2501. }
  2502. }
  2504. if( !result )
  2505. {
  2506. // If there are no siblings or children to go to, recurse up one level in the tree
  2507. // which gets back to this folder, which will only be visited if it is a valid, visible item
  2508. result = this;
  2509. }
  2511. return result;
  2512. }
  2515. bool LLInventorySort::updateSort(U32 order)
  2516. {
  2517. if (order != mSortOrder)
  2518. {
  2519. mSortOrder = order;
  2520. mByDate = (order & LLInventoryFilter::SO_DATE);
  2521. mSystemToTop = (order & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP);
  2522. mFoldersByName = (order & LLInventoryFilter::SO_FOLDERS_BY_NAME);
  2523. return true;
  2524. }
  2525. return false;
  2526. }
  2528. bool LLInventorySort::operator()(const LLFolderViewItem* const& a, const LLFolderViewItem* const& b)
  2529. {
  2530. // ignore sort order for landmarks in the Favorites folder.
  2531. // they should be always sorted as in Favorites bar. See EXT-719
  2532. if (a->getSortGroup() == SG_ITEM && b->getSortGroup() == SG_ITEM
  2533. && a->getListener()->getInventoryType() == LLInventoryType::IT_LANDMARK
  2534. && b->getListener()->getInventoryType() == LLInventoryType::IT_LANDMARK)
  2535. {
  2537. static const LLUUID& favorites_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
  2539. LLUUID a_uuid = a->getParentFolder()->getListener()->getUUID();
  2540. LLUUID b_uuid = b->getParentFolder()->getListener()->getUUID();
  2542. if ((a_uuid == favorites_folder_id && b_uuid == favorites_folder_id))
  2543. {
  2544. // *TODO: mantipov: probably it is better to add an appropriate method to LLFolderViewItem
  2545. // or to LLInvFVBridge
  2546. LLViewerInventoryItem* aitem = (static_cast<const LLItemBridge*>(a->getListener()))->getItem();
  2547. LLViewerInventoryItem* bitem = (static_cast<const LLItemBridge*>(b->getListener()))->getItem();
  2548. if (!aitem || !bitem)
  2549. return false;
  2550. S32 a_sort = aitem->getSortField();
  2551. S32 b_sort = bitem->getSortField();
  2552. return a_sort < b_sort;
  2553. }
  2554. }
  2556. // We sort by name if we aren't sorting by date
  2557. // OR if these are folders and we are sorting folders by name.
  2558. bool by_name = (!mByDate 
  2559. || (mFoldersByName 
  2560. && (a->getSortGroup() != SG_ITEM)));
  2562. if (a->getSortGroup() != b->getSortGroup())
  2563. {
  2564. if (mSystemToTop)
  2565. {
  2566. // Group order is System Folders, Trash, Normal Folders, Items
  2567. return (a->getSortGroup() < b->getSortGroup());
  2568. }
  2569. else if (mByDate)
  2570. {
  2571. // Trash needs to go to the bottom if we are sorting by date
  2572. if ( (a->getSortGroup() == SG_TRASH_FOLDER)
  2573. || (b->getSortGroup() == SG_TRASH_FOLDER))
  2574. {
  2575. return (b->getSortGroup() == SG_TRASH_FOLDER);
  2576. }
  2577. }
  2578. }
  2580. if (by_name)
  2581. {
  2582. S32 compare = LLStringUtil::compareDict(a->getLabel(), b->getLabel());
  2583. if (0 == compare)
  2584. {
  2585. return (a->getCreationDate() > b->getCreationDate());
  2586. }
  2587. else
  2588. {
  2589. return (compare < 0);
  2590. }
  2591. }
  2592. else
  2593. {
  2594. // BUG: This is very very slow.  The getCreationDate() is log n in number
  2595. // of inventory items.
  2596. time_t first_create = a->getCreationDate();
  2597. time_t second_create = b->getCreationDate();
  2598. if (first_create == second_create)
  2599. {
  2600. return (LLStringUtil::compareDict(a->getLabel(), b->getLabel()) < 0);
  2601. }
  2602. else
  2603. {
  2604. return (first_create > second_create);
  2605. }
  2606. }
  2607. }