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

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

游戏引擎

开发平台：

C++ Builder

llfavoritesbar.cpp：源码内容
  1. /** 
  2.  * @file llfavoritesbar.cpp
  3.  * @brief LLFavoritesBarCtrl class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2009-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 "llfavoritesbar.h"
  37. #include "llfloaterreg.h"
  38. #include "llfocusmgr.h"
  39. #include "llinventory.h"
  40. #include "lllandmarkactions.h"
  41. #include "lltrans.h"
  42. #include "lluictrlfactory.h"
  43. #include "llmenugl.h"
  44. #include "lltooltip.h"
  46. #include "llagent.h"
  47. #include "llclipboard.h"
  48. #include "llinventoryclipboard.h"
  49. #include "llinventorybridge.h"
  50. #include "llfloaterworldmap.h"
  51. #include "lllandmarkactions.h"
  52. #include "llnotificationsutil.h"
  53. #include "llsidetray.h"
  54. #include "lltoggleablemenu.h"
  55. #include "llviewerinventory.h"
  56. #include "llviewermenu.h"
  57. #include "llviewermenu.h"
  58. #include "lltooldraganddrop.h"
  60. static LLDefaultChildRegistry::Register<LLFavoritesBarCtrl> r("favorites_bar");
  62. const S32 DROP_DOWN_MENU_WIDTH = 250;
  64. /**
  65.  * Helper for LLFavoriteLandmarkButton and LLFavoriteLandmarkMenuItem.
  66.  * Performing requests for SLURL for given Landmark ID
  67.  */
  68. class LLLandmarkInfoGetter
  69. {
  70. public:
  71. LLLandmarkInfoGetter()
  72. : mLandmarkID(LLUUID::null),
  73. mName("(Loading...)"),
  74. mPosX(0),
  75. mPosY(0),
  76. mPosZ(0),
  77. mLoaded(false) 
  78. {}
  80. void setLandmarkID(const LLUUID& id) { mLandmarkID = id; }
  81. const LLUUID& getLandmarkId() const { return mLandmarkID; }
  83. const std::string& getName()
  84. {
  85. if(!mLoaded)
  86. requestNameAndPos();
  88. return mName;
  89. }
  91. S32 getPosX()
  92. {
  93. if (!mLoaded)
  94. requestNameAndPos();
  95. return mPosX;
  96. }
  98. S32 getPosY()
  99. {
  100. if (!mLoaded)
  101. requestNameAndPos();
  102. return mPosY;
  103. }
  105. S32 getPosZ()
  106. {
  107. if (!mLoaded)
  108. requestNameAndPos();
  109. return mPosZ;
  110. }
  112. private:
  113. /**
  114.  * Requests landmark data from server.
  115.  */
  116. void requestNameAndPos()
  117. {
  118. if (mLandmarkID.isNull())
  119. return;
  121. LLVector3d g_pos;
  122. if(LLLandmarkActions::getLandmarkGlobalPos(mLandmarkID, g_pos))
  123. {
  124. LLLandmarkActions::getRegionNameAndCoordsFromPosGlobal(g_pos,
  125. boost::bind(&LLLandmarkInfoGetter::landmarkNameCallback, this, _1, _2, _3, _4));
  126. }
  127. }
  129. void landmarkNameCallback(const std::string& name, S32 x, S32 y, S32 z)
  130. {
  131. mPosX = x;
  132. mPosY = y;
  133. mPosZ = z;
  134. mName = name;
  135. mLoaded = true;
  136. }
  138. LLUUID mLandmarkID;
  139. std::string mName;
  140. S32 mPosX;
  141. S32 mPosY;
  142. S32 mPosZ;
  143. bool mLoaded;
  144. };
  146. /**
  147.  * This class is needed to override LLButton default handleToolTip function and
  148.  * show SLURL as button tooltip.
  149.  * *NOTE: dzaporozhan: This is a workaround. We could set tooltips for buttons
  150.  * in createButtons function but landmark data is not available when Favorites Bar is
  151.  * created. Thats why we are requesting landmark data after 
  152.  */
  153. class LLFavoriteLandmarkButton : public LLButton
  154. {
  155. public:
  157. BOOL handleToolTip(S32 x, S32 y, MASK mask)
  158. {
  159. std::string region_name = mLandmarkInfoGetter.getName();
  161. if (!region_name.empty())
  162. {
  163. LLToolTip::Params params;
  164. std::string extra_message = llformat("%s (%d, %d, %d)", region_name.c_str(), 
  165. mLandmarkInfoGetter.getPosX(), mLandmarkInfoGetter.getPosY(), mLandmarkInfoGetter.getPosZ());
  167. params.message = llformat("%sn%s", getLabelSelected().c_str(), extra_message.c_str());
  169. LLRect rect = calcScreenRect();
  170. LLFontGL* standart_font = LLFontGL::getFontSansSerif();
  171. if(standart_font)
  172. {
  173. S32 w = llmax((S32)(standart_font->getWidthF32(getLabelSelected())+0.5),(S32)(standart_font->getWidthF32(extra_message)+0.5));
  174. rect.mRight = rect.mLeft + w;
  175. params.max_width = w;
  176. }
  178. params.sticky_rect = rect; 
  180. LLToolTipMgr::instance().show(params);
  181. }
  182. return TRUE;
  183. }
  185. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask)
  186. {
  187. LLFavoritesBarCtrl* fb = dynamic_cast<LLFavoritesBarCtrl*>(getParent());
  189. if (fb)
  190. {
  191. fb->handleHover(x, y, mask);
  192. }
  194. return LLButton::handleHover(x, y, mask);
  195. }
  197. void setLandmarkID(const LLUUID& id){ mLandmarkInfoGetter.setLandmarkID(id); }
  198. const LLUUID& getLandmarkId() const { return mLandmarkInfoGetter.getLandmarkId(); }
  200. void onMouseEnter(S32 x, S32 y, MASK mask)
  201. {
  202. if (LLToolDragAndDrop::getInstance()->hasMouseCapture())
  203. {
  204. LLUICtrl::onMouseEnter(x, y, mask);
  205. }
  206. else
  207. {
  208. LLButton::onMouseEnter(x, y, mask);
  209. }
  210. }
  212. protected:
  213. LLFavoriteLandmarkButton(const LLButton::Params& p) : LLButton(p) {}
  214. friend class LLUICtrlFactory;
  216. private:
  217. LLLandmarkInfoGetter mLandmarkInfoGetter;
  218. };
  220. /**
  221.  * This class is needed to override LLMenuItemCallGL default handleToolTip function and
  222.  * show SLURL as button tooltip.
  223.  * *NOTE: dzaporozhan: This is a workaround. We could set tooltips for buttons
  224.  * in showDropDownMenu function but landmark data is not available when Favorites Bar is
  225.  * created. Thats why we are requesting landmark data after 
  226.  */
  227. class LLFavoriteLandmarkMenuItem : public LLMenuItemCallGL
  228. {
  229. public:
  230. BOOL handleToolTip(S32 x, S32 y, MASK mask)
  231. {
  232. std::string region_name = mLandmarkInfoGetter.getName();
  233. if (!region_name.empty())
  234. {
  235. LLToolTip::Params params;
  236. params.message = llformat("%sn%s (%d, %d)", getLabel().c_str(), region_name.c_str(), mLandmarkInfoGetter.getPosX(), mLandmarkInfoGetter.getPosY());
  237. params.sticky_rect = calcScreenRect();
  238. LLToolTipMgr::instance().show(params);
  239. }
  240. return TRUE;
  241. }
  243. void setLandmarkID(const LLUUID& id){ mLandmarkInfoGetter.setLandmarkID(id); }
  245. virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask)
  246. {
  247. if (mMouseDownSignal)
  248. (*mMouseDownSignal)(this, x, y, mask);
  249. return LLMenuItemCallGL::handleMouseDown(x, y, mask);
  250. }
  252. virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask)
  253. {
  254. if (mMouseUpSignal)
  255. (*mMouseUpSignal)(this, x, y, mask);
  256. return LLMenuItemCallGL::handleMouseUp(x, y, mask);
  257. }
  259. virtual BOOL handleHover(S32 x, S32 y, MASK mask)
  260. {
  261. if (fb)
  262. {
  263. fb->handleHover(x, y, mask);
  264. }
  266. return TRUE;
  267. }
  269. void initFavoritesBarPointer(LLFavoritesBarCtrl* fb) { this->fb = fb; }
  271. protected:
  273. LLFavoriteLandmarkMenuItem(const LLMenuItemCallGL::Params& p) : LLMenuItemCallGL(p) {}
  274. friend class LLUICtrlFactory;
  276. private:
  277. LLLandmarkInfoGetter mLandmarkInfoGetter;
  278. LLFavoritesBarCtrl* fb;
  279. };
  281. /**
  282.  * This class was introduced just for fixing the following issue:
  283.  * EXT-836 Nav bar: Favorites overflow menu passes left-mouse click through.
  284.  * We must explicitly handle drag and drop event by returning TRUE
  285.  * because otherwise LLToolDragAndDrop will initiate drag and drop operation
  286.  * with the world.
  287.  */
  288. class LLFavoriteLandmarkToggleableMenu : public LLToggleableMenu
  289. {
  290. public:
  291. virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  292.    EDragAndDropType cargo_type,
  293.    void* cargo_data,
  294.    EAcceptance* accept,
  295.    std::string& tooltip_msg)
  296. {
  297. *accept = ACCEPT_NO;
  298. return TRUE;
  299. }
  301. void setVisible(BOOL b)
  302. {
  303. // Overflow menu shouldn't hide when it still has focus. See EXT-4217.
  304. if (!b && hasFocus())
  305. return;
  306. LLToggleableMenu::setVisible(b);
  307. setFocus(b);
  308. }
  310. void onFocusLost()
  311. {
  312. setVisible(FALSE);
  313. }
  315. protected:
  316. LLFavoriteLandmarkToggleableMenu(const LLToggleableMenu::Params& p):
  317. LLToggleableMenu(p)
  318. {
  319. }
  321. friend class LLUICtrlFactory;
  322. };
  324. /**
  325.  * This class is needed to update an item being copied to the favorites folder
  326.  * with a sort field value (required to save favorites bar's tabs order).
  327.  * See method handleNewFavoriteDragAndDrop for more details on how this class is used.
  328.  */
  329. class LLItemCopiedCallback : public LLInventoryCallback
  330. {
  331. public:
  332. LLItemCopiedCallback(S32 sortField): mSortField(sortField) {}
  334. virtual void fire(const LLUUID& inv_item)
  335. {
  336. LLViewerInventoryItem* item = gInventory.getItem(inv_item);
  338. if (item)
  339. {
  340. item->setSortField(mSortField);
  341. item->setComplete(TRUE);
  342. item->updateServer(FALSE);
  344. gInventory.updateItem(item);
  345. gInventory.notifyObservers();
  346. }
  348. LLView::getWindow()->setCursor(UI_CURSOR_ARROW);
  349. }
  351. private:
  352. S32 mSortField;
  353. };
  355. // updateButtons's helper
  356. struct LLFavoritesSort
  357. {
  358. // Sorting by creation date and name
  359. // TODO - made it customizible using gSavedSettings
  360. bool operator()(const LLViewerInventoryItem* const& a, const LLViewerInventoryItem* const& b)
  361. {
  362. S32 sortField1 = a->getSortField();
  363. S32 sortField2 = b->getSortField();
  365. if (!(sortField1 < 0 && sortField2 < 0))
  366. {
  367. return sortField2 > sortField1;
  368. }
  370. time_t first_create = a->getCreationDate();
  371. time_t second_create = b->getCreationDate();
  372. if (first_create == second_create)
  373. {
  374. return (LLStringUtil::compareDict(a->getName(), b->getName()) < 0);
  375. }
  376. else
  377. {
  378. return (first_create > second_create);
  379. }
  380. }
  381. };
  383. LLFavoritesBarCtrl::Params::Params()
  384. : image_drag_indication("image_drag_indication"),
  385.   chevron_button("chevron_button"),
  386.   label("label")
  387. {
  388. }
  390. LLFavoritesBarCtrl::LLFavoritesBarCtrl(const LLFavoritesBarCtrl::Params& p)
  391. : LLUICtrl(p),
  392. mFont(p.font.isProvided() ? p.font() : LLFontGL::getFontSansSerifSmall()),
  393. mPopupMenuHandle(),
  394. mInventoryItemsPopupMenuHandle(),
  395. mImageDragIndication(p.image_drag_indication),
  396. mShowDragMarker(FALSE),
  397. mLandingTab(NULL),
  398. mLastTab(NULL),
  399. mTabsHighlightEnabled(TRUE)
  400.   , mUpdateDropDownItems(true)
  401. {
  402. // Register callback for menus with current registrar (will be parent panel's registrar)
  403. LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Favorites.DoToSelected",
  404. boost::bind(&LLFavoritesBarCtrl::doToSelected, this, _2));
  406. // Add this if we need to selectively enable items
  407. LLUICtrl::EnableCallbackRegistry::currentRegistrar().add("Favorites.EnableSelected",
  408. boost::bind(&LLFavoritesBarCtrl::enableSelected, this, _2));
  410. gInventory.addObserver(this);
  412. //make chevron button                                                                                                                               
  413. LLButton::Params chevron_button_params(p.chevron_button);                                         
  414. chevron_button_params.click_callback.function(boost::bind(&LLFavoritesBarCtrl::showDropDownMenu, this));     
  415. mChevronButton = LLUICtrlFactory::create<LLButton> (chevron_button_params);
  416. addChild(mChevronButton); 
  418. LLTextBox::Params label_param(p.label);
  419. mBarLabel = LLUICtrlFactory::create<LLTextBox> (label_param);
  420. addChild(mBarLabel);
  421. }
  423. LLFavoritesBarCtrl::~LLFavoritesBarCtrl()
  424. {
  425. gInventory.removeObserver(this);
  427. LLView::deleteViewByHandle(mPopupMenuHandle);
  428. LLView::deleteViewByHandle(mInventoryItemsPopupMenuHandle);
  429. }
  431. BOOL LLFavoritesBarCtrl::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
  432.    EDragAndDropType cargo_type,
  433.    void* cargo_data,
  434.    EAcceptance* accept,
  435.    std::string& tooltip_msg)
  436. {
  437. *accept = ACCEPT_NO;
  439. switch (cargo_type)
  440. {
  442. case DAD_LANDMARK:
  443. {
  444. /*
  445.  * add a callback to the end drag event.
  446.  * the callback will disconnet itself immediately after execution
  447.  * this is done because LLToolDragAndDrop is a common tool so it shouldn't
  448.  * be overloaded with redundant callbacks.
  449.  */
  450. if (!mEndDragConnection.connected())
  451. {
  452. mEndDragConnection = LLToolDragAndDrop::getInstance()->setEndDragCallback(boost::bind(&LLFavoritesBarCtrl::onEndDrag, this));
  453. }
  455. // Copy the item into the favorites folder (if it's not already there).
  456. LLInventoryItem *item = (LLInventoryItem *)cargo_data;
  458. if (LLFavoriteLandmarkButton* dest = dynamic_cast<LLFavoriteLandmarkButton*>(findChildByLocalCoords(x, y)))
  459. {
  460. setLandingTab(dest);
  461. }
  462. /*
  463.  * the condition dest == NULL can be satisfied not only in the case
  464.  * of dragging to the right from the last tab of the favbar. there is a
  465.  * small gap between each tab. if the user drags something exactly there
  466.  * then mLandingTab will be set to NULL and the dragged item will be pushed
  467.  * to the end of the favorites bar. this is incorrect behavior. that's why
  468.  * we need an additional check which excludes the case described previously
  469.  * making sure that the mouse pointer is beyond the last tab.
  470.  */
  471. else if (mLastTab && x >= mLastTab->getRect().mRight)
  472. {
  473. setLandingTab(NULL);
  474. }
  476. // check if we are dragging an existing item from the favorites bar
  477. if (item && mDragItemId == item->getUUID())
  478. {
  479. *accept = ACCEPT_YES_SINGLE;
  481. showDragMarker(TRUE);
  483. if (drop)
  484. {
  485. handleExistingFavoriteDragAndDrop(x, y);
  486. showDragMarker(FALSE);
  487. }
  488. }
  489. else
  490. {
  491. const LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
  492. if (item->getParentUUID() == favorites_id)
  493. {
  494. llwarns << "Attemt to copy a favorite item into the same folder." << llendl;
  495. break;
  496. }
  498. *accept = ACCEPT_YES_COPY_MULTI;
  500. showDragMarker(TRUE);
  502. if (drop)
  503. {
  504. if (mItems.empty())
  505. {
  506. setLandingTab(NULL);
  507. }
  508. handleNewFavoriteDragAndDrop(item, favorites_id, x, y);
  509. showDragMarker(FALSE);
  510. }
  511. }
  512. }
  513. break;
  514. default:
  515. break;
  516. }
  518. return TRUE;
  519. }
  521. void LLFavoritesBarCtrl::handleExistingFavoriteDragAndDrop(S32 x, S32 y)
  522. {
  523. LLFavoriteLandmarkButton* dest = dynamic_cast<LLFavoriteLandmarkButton*>(mLandingTab);
  525. // there is no need to handle if an item was dragged onto itself
  526. if (dest && dest->getLandmarkId() == mDragItemId)
  527. {
  528. return;
  529. }
  531. if (dest)
  532. {
  533. LLInventoryModel::updateItemsOrder(mItems, mDragItemId, dest->getLandmarkId());
  534. }
  535. else
  536. {
  537. mItems.push_back(gInventory.getItem(mDragItemId));
  538. }
  540. gInventory.saveItemsOrder(mItems);
  542. LLToggleableMenu* menu = (LLToggleableMenu*) mPopupMenuHandle.get();
  544. if (menu && menu->getVisible())
  545. {
  546. menu->setVisible(FALSE);
  547. showDropDownMenu();
  548. }
  549. }
  551. void LLFavoritesBarCtrl::handleNewFavoriteDragAndDrop(LLInventoryItem *item, const LLUUID& favorites_id, S32 x, S32 y)
  552. {
  553. LLFavoriteLandmarkButton* dest = dynamic_cast<LLFavoriteLandmarkButton*>(mLandingTab);
  555. // there is no need to handle if an item was dragged onto itself
  556. if (dest && dest->getLandmarkId() == mDragItemId)
  557. {
  558. return;
  559. }
  561. LLPointer<LLViewerInventoryItem> viewer_item = new LLViewerInventoryItem(item);
  563. if (dest)
  564. {
  565. insertBeforeItem(mItems, dest->getLandmarkId(), viewer_item);
  566. }
  567. else
  568. {
  569. mItems.push_back(viewer_item);
  570. }
  572. int sortField = 0;
  573. LLPointer<LLItemCopiedCallback> cb;
  575. // current order is saved by setting incremental values (1, 2, 3, ...) for the sort field
  576. for (LLInventoryModel::item_array_t::iterator i = mItems.begin(); i != mItems.end(); ++i)
  577. {
  578. LLViewerInventoryItem* currItem = *i;
  580. if (currItem->getUUID() == item->getUUID())
  581. {
  582. cb = new LLItemCopiedCallback(++sortField);
  583. }
  584. else
  585. {
  586. currItem->setSortField(++sortField);
  587. currItem->setComplete(TRUE);
  588. currItem->updateServer(FALSE);
  590. gInventory.updateItem(currItem);
  591. }
  592. }
  594. LLToolDragAndDrop* tool_dad = LLToolDragAndDrop::getInstance();
  595. if (tool_dad->getSource() == LLToolDragAndDrop::SOURCE_NOTECARD)
  596. {
  597. viewer_item->setType(LLAssetType::AT_LANDMARK);
  598. copy_inventory_from_notecard(tool_dad->getObjectID(), tool_dad->getSourceID(), viewer_item.get(), gInventoryCallbacks.registerCB(cb));
  599. }
  600. else
  601. {
  602. copy_inventory_item(
  603. gAgent.getID(),
  604. item->getPermissions().getOwner(),
  605. item->getUUID(),
  606. favorites_id,
  607. std::string(),
  608. cb);
  609. }
  611. llinfos << "Copied inventory item #" << item->getUUID() << " to favorites." << llendl;
  612. }
  614. //virtual
  615. void LLFavoritesBarCtrl::changed(U32 mask)
  616. {
  617. if (mFavoriteFolderId.isNull())
  618. {
  619. mFavoriteFolderId = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
  621. if (mFavoriteFolderId.notNull())
  622. {
  623. gInventory.fetchDescendentsOf(mFavoriteFolderId);
  624. }
  625. }
  626. else
  627. {
  628. updateButtons();
  629. }
  630. }
  632. //virtual
  633. void LLFavoritesBarCtrl::reshape(S32 width, S32 height, BOOL called_from_parent)
  634. {
  635. LLUICtrl::reshape(width, height, called_from_parent);
  636. updateButtons();
  637. }
  639. void LLFavoritesBarCtrl::draw()
  640. {
  641. LLUICtrl::draw();
  643. if (mShowDragMarker)
  644. {
  645. S32 w = mImageDragIndication->getWidth();
  646. S32 h = mImageDragIndication->getHeight();
  648. if (mLandingTab)
  649. {
  650. // mouse pointer hovers over an existing tab
  651. LLRect rect = mLandingTab->getRect();
  652. mImageDragIndication->draw(rect.mLeft - w/2, rect.getHeight(), w, h);
  653. }
  654. else if (mLastTab)
  655. {
  656. // mouse pointer hovers over the favbar empty space (right to the last tab)
  657. LLRect rect = mLastTab->getRect();
  658. mImageDragIndication->draw(rect.mRight, rect.getHeight(), w, h);
  659. }
  660. }
  661. }
  663. LLXMLNodePtr LLFavoritesBarCtrl::getButtonXMLNode()
  664. {
  665. LLXMLNodePtr buttonXMLNode = NULL;
  666. bool success = LLUICtrlFactory::getLayeredXMLNode("favorites_bar_button.xml", buttonXMLNode);
  667. if (!success)
  668. {
  669. llwarns << "Failed to create Favorites Bar button from favorites_bar_button.xml" << llendl;
  670. buttonXMLNode = NULL;
  671. }
  672. return buttonXMLNode;
  673. }
  675. void LLFavoritesBarCtrl::updateButtons()
  676. {
  677. mItems.clear();
  679. if (!collectFavoriteItems(mItems))
  680. {
  681. return;
  682. }
  684. static LLXMLNodePtr buttonXMLNode = getButtonXMLNode();
  685. if (buttonXMLNode.isNull())
  686. {
  687. return;
  688. }
  689. if(mItems.empty())
  690. {
  691. mBarLabel->setVisible(TRUE);
  692. }
  693. else
  694. {
  695. mBarLabel->setVisible(FALSE);
  696. }
  697. const child_list_t* childs = getChildList();
  698. child_list_const_iter_t child_it = childs->begin();
  699. int first_changed_item_index = 0;
  700. int rightest_point = getRect().mRight - mChevronButton->getRect().getWidth();
  701. //lets find first changed button
  702. while (child_it != childs->end() && first_changed_item_index < mItems.count())
  703. {
  704. LLFavoriteLandmarkButton* button = dynamic_cast<LLFavoriteLandmarkButton*> (*child_it);
  705. if (button)
  706. {
  707. const LLViewerInventoryItem *item = mItems[first_changed_item_index].get();
  708. if (item)
  709. {
  710. // an child's order  and mItems  should be same   
  711. if (button->getLandmarkId() != item->getUUID() // sort order has been changed
  712. || button->getLabelSelected() != item->getName() // favorite's name has been changed
  713. || button->getRect().mRight < rightest_point) // favbar's width has been changed
  714. {
  715. break;
  716. }
  717. }
  718. first_changed_item_index++;
  719. }
  720. child_it++;
  721. }
  722. // now first_changed_item_index should contains a number of button that need to change
  724. if (first_changed_item_index <= mItems.count())
  725. {
  726. // Rebuild the buttons only
  727. // child_list_t is a linked list, so safe to erase from the middle if we pre-incrament the iterator
  729. while (child_it != childs->end())
  730. {
  731. //lets remove other landmarks button and rebuild it
  732. child_list_const_iter_t cur_it = child_it++;
  733. LLFavoriteLandmarkButton* button =
  734. dynamic_cast<LLFavoriteLandmarkButton*> (*cur_it);
  735. if (button)
  736. {
  737. removeChild(button);
  738. delete button;
  739. }
  740. }
  741. // we have to remove ChevronButton to make sure that the last item will be LandmarkButton to get the right aligning
  742. // keep in mind that we are cutting all buttons in space between the last visible child of favbar and ChevronButton
  743. if (mChevronButton->getParent() == this)
  744. {
  745. removeChild(mChevronButton);
  746. }
  747. int last_right_edge = 0;
  748. //calculate new buttons offset
  749. if (getChildList()->size() > 0)
  750. {
  751. //find last visible child to get the rightest button offset
  752. child_list_const_reverse_iter_t last_visible_it = std::find_if(childs->rbegin(), childs->rend(), 
  753. std::mem_fun(&LLView::getVisible));
  754. if(last_visible_it != childs->rend())
  755. {
  756. last_right_edge = (*last_visible_it)->getRect().mRight;
  757. }
  758. }
  759. //last_right_edge is saving coordinates
  760. LLButton* last_new_button = NULL;
  761. int j = first_changed_item_index;
  762. for (; j < mItems.count(); j++)
  763. {
  764. last_new_button = createButton(mItems[j], buttonXMLNode, last_right_edge);
  765. if (!last_new_button)
  766. {
  767. break;
  768. }
  769. sendChildToBack(last_new_button);
  770. last_right_edge = last_new_button->getRect().mRight;
  772. mLastTab = last_new_button;
  773. }
  774. mFirstDropDownItem = j;
  775. // Chevron button
  776. if (mFirstDropDownItem < mItems.count())
  777. {
  778. // if updateButton had been called it means:
  779. //or there are some new favorites, or width had been changed
  780. // so if we need to display chevron button,  we must update dropdown items too. 
  781. mUpdateDropDownItems = true;
  782. S32 buttonHGap = 2; // default value
  783. buttonXMLNode->getAttributeS32("left", buttonHGap);
  784. LLRect rect;
  785. // Chevron button should stay right aligned
  786. rect.setOriginAndSize(getRect().mRight - mChevronButton->getRect().getWidth() - buttonHGap, 0,
  787. mChevronButton->getRect().getWidth(),
  788. mChevronButton->getRect().getHeight());
  790. addChild(mChevronButton);
  791. mChevronButton->setRect(rect);
  792. mChevronButton->setVisible(TRUE);
  793. }
  794. // Update overflow menu
  795. LLToggleableMenu* overflow_menu = static_cast <LLToggleableMenu*> (mPopupMenuHandle.get());
  796. if (overflow_menu && overflow_menu->getVisible())
  797. {
  798. overflow_menu->setFocus(FALSE);
  799. overflow_menu->setVisible(FALSE);
  800. if (mUpdateDropDownItems)
  801. showDropDownMenu();
  802. }
  803. }
  804. else
  805. {
  806. mUpdateDropDownItems = false;
  807. }
  808. }
  810. LLButton* LLFavoritesBarCtrl::createButton(const LLPointer<LLViewerInventoryItem> item, LLXMLNodePtr &buttonXMLNode, S32 x_offset)
  811. {
  812. S32 def_button_width = 120;
  813. buttonXMLNode->getAttributeS32("width", def_button_width);
  814. S32 button_x_delta = 2; // default value
  815. buttonXMLNode->getAttributeS32("left", button_x_delta);
  816. S32 curr_x = x_offset;
  818. /**
  819.  * WORKAROUND:
  820.  * there are some problem with displaying of fonts in buttons. 
  821.  * Empty space (or ...) is displaying instead of last symbols, even though the width of the button is enough.
  822.  * Problem will gone, if we  stretch out the button. For that reason I have to put additional  20 pixels.
  823.  */
  824. int required_width = mFont->getWidth(item->getName()) + 20;
  825. int width = required_width > def_button_width? def_button_width : required_width;
  826. LLFavoriteLandmarkButton* fav_btn = NULL;
  828. // do we have a place for next button + double buttonHGap + mChevronButton ? 
  829. if(curr_x + width + 2*button_x_delta +  mChevronButton->getRect().getWidth() > getRect().mRight )
  830. {
  831. return NULL;
  832. }
  833. fav_btn = LLUICtrlFactory::defaultBuilder<LLFavoriteLandmarkButton>(buttonXMLNode, this, NULL);
  834. if (NULL == fav_btn)
  835. {
  836. llwarns << "Unable to create LLFavoriteLandmarkButton widget: " << item->getName() << llendl;
  837. return NULL;
  838. }
  840. LLRect butt_rect (fav_btn->getRect());
  841. fav_btn->setLandmarkID(item->getUUID());
  842. butt_rect.setOriginAndSize(curr_x + button_x_delta, fav_btn->getRect().mBottom, width, fav_btn->getRect().getHeight());
  844. fav_btn->setRect(butt_rect);
  845. // change only left and save bottom
  846. fav_btn->setFont(mFont);
  847. fav_btn->setName(item->getName());
  848. fav_btn->setLabel(item->getName());
  849. fav_btn->setToolTip(item->getName());
  850. fav_btn->setCommitCallback(boost::bind(&LLFavoritesBarCtrl::onButtonClick, this, item->getUUID()));
  851. fav_btn->setRightMouseDownCallback(boost::bind(&LLFavoritesBarCtrl::onButtonRightClick, this, item->getUUID(), _1, _2, _3,_4 ));
  853. fav_btn->LLUICtrl::setMouseDownCallback(boost::bind(&LLFavoritesBarCtrl::onButtonMouseDown, this, item->getUUID(), _1, _2, _3, _4));
  854. fav_btn->LLUICtrl::setMouseUpCallback(boost::bind(&LLFavoritesBarCtrl::onButtonMouseUp, this, item->getUUID(), _1, _2, _3, _4));
  856. return fav_btn;
  857. }
  860. BOOL LLFavoritesBarCtrl::postBuild()
  861. {
  862. // make the popup menu available
  863. LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_favorites.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  864. if (!menu)
  865. {
  866. menu = LLUICtrlFactory::getDefaultWidget<LLMenuGL>("inventory_menu");
  867. }
  868. menu->setBackgroundColor(LLUIColorTable::instance().getColor("MenuPopupBgColor"));
  869. mInventoryItemsPopupMenuHandle = menu->getHandle();
  871. return TRUE;
  872. }
  874. BOOL LLFavoritesBarCtrl::collectFavoriteItems(LLInventoryModel::item_array_t &items)
  875. {
  876. if (mFavoriteFolderId.isNull())
  877. return FALSE;
  879. LLInventoryModel::cat_array_t cats;
  881. LLIsType is_type(LLAssetType::AT_LANDMARK);
  882. gInventory.collectDescendentsIf(mFavoriteFolderId, cats, items, LLInventoryModel::EXCLUDE_TRASH, is_type);
  884. std::sort(items.begin(), items.end(), LLFavoritesSort());
  886. if (needToSaveItemsOrder(items))
  887. {
  888. S32 sortField = 0;
  889. for (LLInventoryModel::item_array_t::iterator i = items.begin(); i != items.end(); ++i)
  890. {
  891. (*i)->setSortField(++sortField);
  892. }
  893. }
  895. return TRUE;
  896. }
  898. void LLFavoritesBarCtrl::showDropDownMenu()
  899. {
  900. if (mPopupMenuHandle.isDead())
  901. {
  902. LLToggleableMenu::Params menu_p;
  903. menu_p.name("favorites menu");
  904. menu_p.can_tear_off(false);
  905. menu_p.visible(false);
  906. menu_p.scrollable(true);
  907. menu_p.max_scrollable_items = 10;
  908. menu_p.preferred_width = DROP_DOWN_MENU_WIDTH;
  910. LLToggleableMenu* menu = LLUICtrlFactory::create<LLFavoriteLandmarkToggleableMenu>(menu_p);
  911. mPopupMenuHandle = menu->getHandle();
  912. }
  914. LLToggleableMenu* menu = (LLToggleableMenu*)mPopupMenuHandle.get();
  916. if (menu)
  917. {
  918. // Release focus to allow changing of visibility.
  919. menu->setFocus(FALSE);
  920. if (!menu->toggleVisibility())
  921. return;
  923. U32 max_width = llmin(DROP_DOWN_MENU_WIDTH, getRect().getWidth());
  924. if (mUpdateDropDownItems)
  925. {
  926. menu->empty();
  928. U32 widest_item = 0;
  930. for (S32 i = mFirstDropDownItem; i < mItems.count(); i++)
  931. {
  932. LLViewerInventoryItem* item = mItems.get(i);
  933. const std::string& item_name = item->getName();
  935. LLFavoriteLandmarkMenuItem::Params item_params;
  936. item_params.name(item_name);
  937. item_params.label(item_name);
  939. item_params.on_click.function(boost::bind(
  940. &LLFavoritesBarCtrl::onButtonClick, this,
  941. item->getUUID()));
  942. LLFavoriteLandmarkMenuItem *menu_item = LLUICtrlFactory::create<LLFavoriteLandmarkMenuItem>(item_params);
  943. menu_item->initFavoritesBarPointer(this);
  944. menu_item->setRightMouseDownCallback(boost::bind(&LLFavoritesBarCtrl::onButtonRightClick, this, item->getUUID(), _1, _2, _3, _4));
  945. menu_item->LLUICtrl::setMouseDownCallback(boost::bind(&LLFavoritesBarCtrl::onButtonMouseDown, this, item->getUUID(), _1, _2, _3, _4));
  946. menu_item->LLUICtrl::setMouseUpCallback(boost::bind(&LLFavoritesBarCtrl::onButtonMouseUp, this, item->getUUID(), _1, _2, _3, _4));
  947. menu_item->setLandmarkID(item->getUUID());
  949. // Check whether item name wider than menu
  950. if (menu_item->getNominalWidth() > max_width)
  951. {
  952. S32 chars_total = item_name.length();
  953. S32 chars_fitted = 1;
  954. menu_item->setLabel(LLStringExplicit(""));
  955. S32 label_space = max_width - menu_item->getFont()->getWidth("...") - 
  956. menu_item->getNominalWidth();// This returns width of menu item with empty label (pad pixels) 
  958. while (chars_fitted < chars_total
  959. && menu_item->getFont()->getWidth(item_name, 0, chars_fitted) < label_space)
  960. {
  961. chars_fitted++;
  962. }
  963. chars_fitted--; // Rolling back one char, that doesn't fit
  965. menu_item->setLabel(item_name.substr(0, chars_fitted)
  966. + "...");
  967. }
  968. widest_item = llmax(widest_item, menu_item->getNominalWidth());
  970. menu->addChild(menu_item);
  971. }
  972. mUpdateDropDownItems = false;
  973. }
  975. menu->buildDrawLabels();
  976. menu->updateParent(LLMenuGL::sMenuContainer);
  978. menu->setButtonRect(mChevronButton->getRect(), this);
  980. LLMenuGL::showPopup(this, menu, getRect().getWidth() - max_width, 0);
  981. }
  982. }
  984. void LLFavoritesBarCtrl::onButtonClick(LLUUID item_id)
  985. {
  986. // We only have one Inventory, gInventory. Some day this should be better abstracted.
  987. LLInvFVBridgeAction::doAction(item_id,&gInventory);
  988. }
  990. void LLFavoritesBarCtrl::onButtonRightClick( LLUUID item_id,LLView* fav_button,S32 x,S32 y,MASK mask)
  991. {
  992. mSelectedItemID = item_id;
  994. LLMenuGL* menu = (LLMenuGL*)mInventoryItemsPopupMenuHandle.get();
  995. if (!menu)
  996. {
  997. return;
  998. }
  1000. // Release mouse capture so hover events go to the popup menu
  1001. // because this is happening during a mouse down.
  1002. gFocusMgr.setMouseCapture(NULL);
  1004. menu->updateParent(LLMenuGL::sMenuContainer);
  1005. LLMenuGL::showPopup(fav_button, menu, x, y);
  1006. }
  1008. BOOL LLFavoritesBarCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
  1009. {
  1010. BOOL handled = childrenHandleRightMouseDown( x, y, mask) != NULL;
  1011. if(!handled && !gMenuHolder->hasVisibleMenu())
  1012. {
  1013. show_navbar_context_menu(this,x,y);
  1014. handled = true;
  1015. }
  1017. return handled;
  1018. }
  1019. void copy_slurl_to_clipboard_cb(std::string& slurl)
  1020. {
  1021. gClipboard.copyFromString(utf8str_to_wstring(slurl));
  1023. LLSD args;
  1024. args["SLURL"] = slurl;
  1025. LLNotificationsUtil::add("CopySLURL", args);
  1026. }
  1029. bool LLFavoritesBarCtrl::enableSelected(const LLSD& userdata)
  1030. {
  1031.     std::string param = userdata.asString();
  1033.     if (param == std::string("can_paste"))
  1034.     {
  1035.         return isClipboardPasteable();
  1036.     }
  1038.     return false;
  1039. }
  1041. void LLFavoritesBarCtrl::doToSelected(const LLSD& userdata)
  1042. {
  1043. std::string action = userdata.asString();
  1044. llinfos << "Action = " << action << " Item = " << mSelectedItemID.asString() << llendl;
  1046. LLViewerInventoryItem* item = gInventory.getItem(mSelectedItemID);
  1047. if (!item)
  1048. return;
  1050. if (action == "open")
  1051. {
  1052. onButtonClick(item->getUUID());
  1053. }
  1054. else if (action == "about")
  1055. {
  1056. LLSD key;
  1057. key["type"] = "landmark";
  1058. key["id"] = mSelectedItemID;
  1060. LLSideTray::getInstance()->showPanel("panel_places", key);
  1061. }
  1062. else if (action == "copy_slurl")
  1063. {
  1064. LLVector3d posGlobal;
  1065. LLLandmarkActions::getLandmarkGlobalPos(mSelectedItemID, posGlobal);
  1067. if (!posGlobal.isExactlyZero())
  1068. {
  1069. LLLandmarkActions::getSLURLfromPosGlobal(posGlobal, copy_slurl_to_clipboard_cb);
  1070. }
  1071. }
  1072. else if (action == "show_on_map")
  1073. {
  1074. LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
  1076. LLVector3d posGlobal;
  1077. LLLandmarkActions::getLandmarkGlobalPos(mSelectedItemID, posGlobal);
  1079. if (!posGlobal.isExactlyZero() && worldmap_instance)
  1080. {
  1081. worldmap_instance->trackLocation(posGlobal);
  1082. LLFloaterReg::showInstance("world_map", "center");
  1083. }
  1084. }
  1085. else if (action == "cut")
  1086. {
  1087. }
  1088. else if (action == "copy")
  1089. {
  1090. LLInventoryClipboard::instance().store(mSelectedItemID);
  1091. }
  1092. else if (action == "paste")
  1093. {
  1094. pastFromClipboard();
  1095. }
  1096. else if (action == "delete")
  1097. {
  1098. gInventory.removeItem(mSelectedItemID);
  1099. }
  1100. }
  1102. BOOL LLFavoritesBarCtrl::isClipboardPasteable() const
  1103. {
  1104. if (!LLInventoryClipboard::instance().hasContents())
  1105. {
  1106. return FALSE;
  1107. }
  1109. LLDynamicArray<LLUUID> objects;
  1110. LLInventoryClipboard::instance().retrieve(objects);
  1111. S32 count = objects.count();
  1112. for(S32 i = 0; i < count; i++)
  1113. {
  1114. const LLUUID &item_id = objects.get(i);
  1116. // Can't paste folders
  1117. const LLInventoryCategory *cat = gInventory.getCategory(item_id);
  1118. if (cat)
  1119. {
  1120. return FALSE;
  1121. }
  1123. const LLInventoryItem *item = gInventory.getItem(item_id);
  1124. if (item && LLAssetType::AT_LANDMARK != item->getType())
  1125. {
  1126. return FALSE;
  1127. }
  1128. }
  1129. return TRUE;
  1130. }
  1132. void LLFavoritesBarCtrl::pastFromClipboard() const
  1133. {
  1134. LLInventoryModel* model = &gInventory;
  1135. if(model && isClipboardPasteable())
  1136. {
  1137. LLInventoryItem* item = NULL;
  1138. LLDynamicArray<LLUUID> objects;
  1139. LLInventoryClipboard::instance().retrieve(objects);
  1140. S32 count = objects.count();
  1141. LLUUID parent_id(mFavoriteFolderId);
  1142. for(S32 i = 0; i < count; i++)
  1143. {
  1144. item = model->getItem(objects.get(i));
  1145. if (item)
  1146. {
  1147. copy_inventory_item(
  1148. gAgent.getID(),
  1149. item->getPermissions().getOwner(),
  1150. item->getUUID(),
  1151. parent_id,
  1152. std::string(),
  1153. LLPointer<LLInventoryCallback>(NULL));
  1154. }
  1155. }
  1156. }
  1157. }
  1159. void LLFavoritesBarCtrl::onButtonMouseDown(LLUUID id, LLUICtrl* ctrl, S32 x, S32 y, MASK mask)
  1160. {
  1161. mDragItemId = id;
  1162. mStartDrag = TRUE;
  1164. S32 screenX, screenY;
  1165. localPointToScreen(x, y, &screenX, &screenY);
  1167. LLToolDragAndDrop::getInstance()->setDragStart(screenX, screenY);
  1168. }
  1170. void LLFavoritesBarCtrl::onButtonMouseUp(LLUUID id, LLUICtrl* ctrl, S32 x, S32 y, MASK mask)
  1171. {
  1172. mStartDrag = FALSE;
  1173. mDragItemId = LLUUID::null;
  1174. }
  1176. void LLFavoritesBarCtrl::onEndDrag()
  1177. {
  1178. mEndDragConnection.disconnect();
  1180. showDragMarker(FALSE);
  1181. mDragItemId = LLUUID::null;
  1182. LLView::getWindow()->setCursor(UI_CURSOR_ARROW);
  1183. }
  1185. BOOL LLFavoritesBarCtrl::handleHover(S32 x, S32 y, MASK mask)
  1186. {
  1187. if (mDragItemId != LLUUID::null && mStartDrag)
  1188. {
  1189. S32 screenX, screenY;
  1190. localPointToScreen(x, y, &screenX, &screenY);
  1192. if(LLToolDragAndDrop::getInstance()->isOverThreshold(screenX, screenY))
  1193. {
  1194. LLToolDragAndDrop::getInstance()->beginDrag(
  1195. DAD_LANDMARK, mDragItemId,
  1196. LLToolDragAndDrop::SOURCE_LIBRARY);
  1198. mStartDrag = FALSE;
  1200. return LLToolDragAndDrop::getInstance()->handleHover(x, y, mask);
  1201. }
  1202. }
  1204. return TRUE;
  1205. }
  1207. LLUICtrl* LLFavoritesBarCtrl::findChildByLocalCoords(S32 x, S32 y)
  1208. {
  1209. LLUICtrl* ctrl = 0;
  1210. S32 screenX, screenY;
  1211. const child_list_t* list = getChildList();
  1213. localPointToScreen(x, y, &screenX, &screenY);
  1215. // look for a child which contains the point (screenX, screenY) in it's rectangle
  1216. for (child_list_const_iter_t i = list->begin(); i != list->end(); ++i)
  1217. {
  1218. LLRect rect;
  1219. localRectToScreen((*i)->getRect(), &rect);
  1221. if (rect.pointInRect(screenX, screenY))
  1222. {
  1223. ctrl = dynamic_cast<LLUICtrl*>(*i);
  1224. break;
  1225. }
  1226. }
  1228. return ctrl;
  1229. }
  1231. BOOL LLFavoritesBarCtrl::needToSaveItemsOrder(const LLInventoryModel::item_array_t& items)
  1232. {
  1233. BOOL result = FALSE;
  1235. // if there is an item without sort order field set, we need to save items order
  1236. for (LLInventoryModel::item_array_t::const_iterator i = items.begin(); i != items.end(); ++i)
  1237. {
  1238. if ((*i)->getSortField() < 0)
  1239. {
  1240. result = TRUE;
  1241. break;
  1242. }
  1243. }
  1245. return result;
  1246. }
  1248. LLInventoryModel::item_array_t::iterator LLFavoritesBarCtrl::findItemByUUID(LLInventoryModel::item_array_t& items, const LLUUID& id)
  1249. {
  1250. LLInventoryModel::item_array_t::iterator result = items.end();
  1252. for (LLInventoryModel::item_array_t::iterator i = items.begin(); i != items.end(); ++i)
  1253. {
  1254. if ((*i)->getUUID() == id)
  1255. {
  1256. result = i;
  1257. break;
  1258. }
  1259. }
  1261. return result;
  1262. }
  1264. void LLFavoritesBarCtrl::insertBeforeItem(LLInventoryModel::item_array_t& items, const LLUUID& beforeItemId, LLViewerInventoryItem* insertedItem)
  1265. {
  1266. LLViewerInventoryItem* beforeItem = gInventory.getItem(beforeItemId);
  1267. llassert(beforeItem);
  1268. if (beforeItem)
  1269. {
  1270. items.insert(findItemByUUID(items, beforeItem->getUUID()), insertedItem);
  1271. }
  1272. }
  1274. // EOF