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

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

游戏引擎

开发平台：

C++ Builder

llpanelteleporthistory.cpp：源码内容
  1. /** 
  2.  * @file llpanelteleporthistory.cpp
  3.  * @brief Teleport history represented by a scrolling list
  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 "llfloaterreg.h"
  37. #include "llfloaterworldmap.h"
  38. #include "llpanelteleporthistory.h"
  39. #include "llsidetray.h"
  40. #include "llworldmap.h"
  41. #include "llteleporthistorystorage.h"
  42. #include "lltextutil.h"
  44. #include "llaccordionctrl.h"
  45. #include "llaccordionctrltab.h"
  46. #include "llflatlistview.h"
  47. #include "llnotificationsutil.h"
  48. #include "lltextbox.h"
  49. #include "llviewermenu.h"
  50. #include "lllandmarkactions.h"
  51. #include "llclipboard.h"
  53. // Maximum number of items that can be added to a list in one pass.
  54. // Used to limit time spent for items list update per frame.
  55. static const U32 ADD_LIMIT = 50;
  57. static const std::string COLLAPSED_BY_USER = "collapsed_by_user";
  59. class LLTeleportHistoryFlatItem : public LLPanel
  60. {
  61. public:
  62. LLTeleportHistoryFlatItem(S32 index, LLTeleportHistoryPanel::ContextMenu *context_menu, const std::string &region_name, const std::string &hl);
  63. virtual ~LLTeleportHistoryFlatItem();
  65. virtual BOOL postBuild();
  67. /*virtual*/ S32 notify(const LLSD& info);
  69. S32 getIndex() { return mIndex; }
  70. void setIndex(S32 index) { mIndex = index; }
  71. const std::string& getRegionName() { return mRegionName;}
  72. void setRegionName(const std::string& name);
  73. void setHighlightedText(const std::string& text);
  74. void updateTitle();
  76. /*virtual*/ void setValue(const LLSD& value);
  78. void onMouseEnter(S32 x, S32 y, MASK mask);
  79. void onMouseLeave(S32 x, S32 y, MASK mask);
  80. virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  82. static void showPlaceInfoPanel(S32 index);
  84. LLHandle<LLTeleportHistoryFlatItem> getItemHandle() { mItemHandle.bind(this); return mItemHandle; }
  86. private:
  87. void onProfileBtnClick();
  89. LLButton* mProfileBtn;
  90. LLTextBox* mTitle;
  92. LLTeleportHistoryPanel::ContextMenu *mContextMenu;
  94. S32 mIndex;
  95. std::string mRegionName;
  96. std::string mHighlight;
  97. LLRootHandle<LLTeleportHistoryFlatItem> mItemHandle;
  98. };
  100. ////////////////////////////////////////////////////////////////////////////////
  101. ////////////////////////////////////////////////////////////////////////////////
  102. ////////////////////////////////////////////////////////////////////////////////
  104. class LLTeleportHistoryFlatItemStorage: public LLSingleton<LLTeleportHistoryFlatItemStorage> {
  105. protected:
  106. typedef std::vector< LLHandle<LLTeleportHistoryFlatItem> > flat_item_list_t;
  108. public:
  109. LLTeleportHistoryFlatItem* getFlatItemForPersistentItem (
  110. LLTeleportHistoryPanel::ContextMenu *context_menu,
  111. const LLTeleportHistoryPersistentItem& persistent_item,
  112. const S32 cur_item_index,
  113. const std::string &hl);
  115. void removeItem(LLTeleportHistoryFlatItem* item);
  117. void purge();
  119. private:
  121. flat_item_list_t mItems;
  122. };
  124. ////////////////////////////////////////////////////////////////////////////////
  125. ////////////////////////////////////////////////////////////////////////////////
  126. ////////////////////////////////////////////////////////////////////////////////
  128. LLTeleportHistoryFlatItem::LLTeleportHistoryFlatItem(S32 index, LLTeleportHistoryPanel::ContextMenu *context_menu, const std::string &region_name, const std::string &hl)
  129. : LLPanel(),
  130. mIndex(index),
  131. mContextMenu(context_menu),
  132. mRegionName(region_name),
  133. mHighlight(hl)
  134. {
  135. LLUICtrlFactory::getInstance()->buildPanel(this, "panel_teleport_history_item.xml");
  136. }
  138. LLTeleportHistoryFlatItem::~LLTeleportHistoryFlatItem()
  139. {
  140. }
  142. //virtual
  143. BOOL LLTeleportHistoryFlatItem::postBuild()
  144. {
  145. mTitle = getChild<LLTextBox>("region");
  147. mProfileBtn = getChild<LLButton>("profile_btn");
  148.         
  149. mProfileBtn->setClickedCallback(boost::bind(&LLTeleportHistoryFlatItem::onProfileBtnClick, this));
  151. updateTitle();
  153. return true;
  154. }
  156. S32 LLTeleportHistoryFlatItem::notify(const LLSD& info)
  157. {
  158. if(info.has("detach"))
  159. {
  160. delete mMouseDownSignal;
  161. mMouseDownSignal = NULL;
  162. delete mRightMouseDownSignal;
  163. mRightMouseDownSignal = NULL;
  164. return 1;
  165. }
  166. return 0;
  167. }
  169. void LLTeleportHistoryFlatItem::setValue(const LLSD& value)
  170. {
  171. if (!value.isMap()) return;;
  172. if (!value.has("selected")) return;
  173. childSetVisible("selected_icon", value["selected"]);
  174. }
  176. void LLTeleportHistoryFlatItem::setHighlightedText(const std::string& text)
  177. {
  178. mHighlight = text;
  179. }
  181. void LLTeleportHistoryFlatItem::setRegionName(const std::string& name)
  182. {
  183. mRegionName = name;
  184. }
  186. void LLTeleportHistoryFlatItem::updateTitle()
  187. {
  188. LLTextUtil::textboxSetHighlightedVal(
  189. mTitle,
  190. LLStyle::Params(),
  191. mRegionName,
  192. mHighlight);
  193. }
  195. void LLTeleportHistoryFlatItem::onMouseEnter(S32 x, S32 y, MASK mask)
  196. {
  197. childSetVisible("hovered_icon", true);
  198. mProfileBtn->setVisible(true);
  200. LLPanel::onMouseEnter(x, y, mask);
  201. }
  203. void LLTeleportHistoryFlatItem::onMouseLeave(S32 x, S32 y, MASK mask)
  204. {
  205. childSetVisible("hovered_icon", false);
  206. mProfileBtn->setVisible(false);
  208. LLPanel::onMouseLeave(x, y, mask);
  209. }
  211. // virtual
  212. BOOL LLTeleportHistoryFlatItem::handleRightMouseDown(S32 x, S32 y, MASK mask)
  213. {
  214. if (mContextMenu)
  215. mContextMenu->show(this, mIndex, x, y);
  217. return LLPanel::handleRightMouseDown(x, y, mask);
  218. }
  220. void LLTeleportHistoryFlatItem::showPlaceInfoPanel(S32 index)
  221. {
  222. LLSD params;
  223. params["id"] = index;
  224. params["type"] = "teleport_history";
  226. LLSideTray::getInstance()->showPanel("panel_places", params);
  227. }
  229. void LLTeleportHistoryFlatItem::onProfileBtnClick()
  230. {
  231. LLTeleportHistoryFlatItem::showPlaceInfoPanel(mIndex);
  232. }
  234. ////////////////////////////////////////////////////////////////////////////////
  235. ////////////////////////////////////////////////////////////////////////////////
  236. ////////////////////////////////////////////////////////////////////////////////
  238. LLTeleportHistoryFlatItem*
  239. LLTeleportHistoryFlatItemStorage::getFlatItemForPersistentItem (
  240. LLTeleportHistoryPanel::ContextMenu *context_menu,
  241. const LLTeleportHistoryPersistentItem& persistent_item,
  242. const S32 cur_item_index,
  243. const std::string &hl)
  244. {
  245. LLTeleportHistoryFlatItem* item = NULL;
  246. if ( cur_item_index < (S32) mItems.size() )
  247. {
  248. item = mItems[cur_item_index].get();
  249. if (item->getParent() == NULL)
  250. {
  251. item->setIndex(cur_item_index);
  252. item->setRegionName(persistent_item.mTitle);
  253. item->setHighlightedText(hl);
  254. item->setVisible(TRUE);
  255. item->updateTitle();
  256. }
  257. else
  258. {
  259. // Item already added to parent
  260. item = NULL;
  261. }
  262. }
  264. if ( !item )
  265. {
  266. item = new LLTeleportHistoryFlatItem(cur_item_index,
  267.  context_menu,
  268.  persistent_item.mTitle,
  269.  hl);
  270. mItems.push_back(item->getItemHandle());
  271. }
  273. return item;
  274. }
  276. void LLTeleportHistoryFlatItemStorage::removeItem(LLTeleportHistoryFlatItem* item)
  277. {
  278. if (item)
  279. {
  280. flat_item_list_t::iterator item_iter = std::find(mItems.begin(),
  281.  mItems.end(),
  282.  item->getItemHandle());
  283. if (item_iter != mItems.end())
  284. {
  285. mItems.erase(item_iter);
  286. }
  287. }
  288. }
  290. void LLTeleportHistoryFlatItemStorage::purge()
  291. {
  292. for ( flat_item_list_t::iterator
  293.   it = mItems.begin(),
  294.   it_end = mItems.end();
  295.   it != it_end; ++it )
  296. {
  297. LLHandle <LLTeleportHistoryFlatItem> item_handle = *it;
  298. if ( !item_handle.isDead() && item_handle.get()->getParent() == NULL )
  299. {
  300. item_handle.get()->die();
  301. }
  302. }
  303. mItems.clear();
  304. }
  306. ////////////////////////////////////////////////////////////////////////////////
  307. ////////////////////////////////////////////////////////////////////////////////
  308. ////////////////////////////////////////////////////////////////////////////////
  310. LLTeleportHistoryPanel::ContextMenu::ContextMenu() :
  311. mMenu(NULL), mIndex(0)
  312. {
  313. }
  315. void LLTeleportHistoryPanel::ContextMenu::show(LLView* spawning_view, S32 index, S32 x, S32 y)
  316. {
  317. if (mMenu)
  318. {
  319. //preventing parent (menu holder) from deleting already "dead" context menus on exit
  320. LLView* parent = mMenu->getParent();
  321. if (parent)
  322. {
  323. parent->removeChild(mMenu);
  324. }
  325. delete mMenu;
  326. }
  328. mIndex = index;
  329. mMenu = createMenu();
  331. mMenu->show(x, y);
  332. LLMenuGL::showPopup(spawning_view, mMenu, x, y);
  333. }
  335. LLContextMenu* LLTeleportHistoryPanel::ContextMenu::createMenu()
  336. {
  337. // set up the callbacks for all of the avatar menu items
  338. // (N.B. callbacks don't take const refs as mID is local scope)
  339. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  341. registrar.add("TeleportHistory.Teleport", boost::bind(&LLTeleportHistoryPanel::ContextMenu::onTeleport, this));
  342. registrar.add("TeleportHistory.MoreInformation",boost::bind(&LLTeleportHistoryPanel::ContextMenu::onInfo, this));
  343. registrar.add("TeleportHistory.CopyToClipboard",boost::bind(&LLTeleportHistoryPanel::ContextMenu::onCopyToClipboard, this));
  345. // create the context menu from the XUI
  346. return LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(
  347. "menu_teleport_history_item.xml", LLMenuGL::sMenuContainer, LLViewerMenuHolderGL::child_registry_t::instance());
  348. }
  350. void LLTeleportHistoryPanel::ContextMenu::onTeleport()
  351. {
  352. LLTeleportHistoryStorage::getInstance()->goToItem(mIndex);
  353. }
  355. void LLTeleportHistoryPanel::ContextMenu::onInfo()
  356. {
  357. LLTeleportHistoryFlatItem::showPlaceInfoPanel(mIndex);
  358. }
  360. //static
  361. void LLTeleportHistoryPanel::ContextMenu::gotSLURLCallback(const std::string& slurl)
  362. {
  363. gClipboard.copyFromString(utf8str_to_wstring(slurl));
  364. }
  366. void LLTeleportHistoryPanel::ContextMenu::onCopyToClipboard()
  367. {
  368. LLVector3d globalPos = LLTeleportHistoryStorage::getInstance()->getItems()[mIndex].mGlobalPos;
  369. LLLandmarkActions::getSLURLfromPosGlobal(globalPos,
  370. boost::bind(&LLTeleportHistoryPanel::ContextMenu::gotSLURLCallback, _1));
  371. }
  373. // Not yet implemented; need to remove buildPanel() from constructor when we switch
  374. //static LLRegisterPanelClassWrapper<LLTeleportHistoryPanel> t_teleport_history("panel_teleport_history");
  376. LLTeleportHistoryPanel::LLTeleportHistoryPanel()
  377. : LLPanelPlacesTab(),
  378. mDirty(true),
  379. mCurrentItem(0),
  380. mTeleportHistory(NULL),
  381. mHistoryAccordion(NULL),
  382. mAccordionTabMenu(NULL),
  383. mLastSelectedFlatlList(NULL),
  384. mLastSelectedItemIndex(-1)
  385. {
  386. LLUICtrlFactory::getInstance()->buildPanel(this, "panel_teleport_history.xml");
  387. }
  389. LLTeleportHistoryPanel::~LLTeleportHistoryPanel()
  390. {
  391. LLTeleportHistoryFlatItemStorage::instance().purge();
  392. LLView::deleteViewByHandle(mGearMenuHandle);
  393. }
  395. BOOL LLTeleportHistoryPanel::postBuild()
  396. {
  397. mTeleportHistory = LLTeleportHistoryStorage::getInstance();
  398. if (mTeleportHistory)
  399. {
  400. mTeleportHistory->setHistoryChangedCallback(boost::bind(&LLTeleportHistoryPanel::onTeleportHistoryChange, this, _1));
  401. }
  403. mHistoryAccordion = getChild<LLAccordionCtrl>("history_accordion");
  405. if (mHistoryAccordion)
  406. {
  407. for (child_list_const_iter_t iter = mHistoryAccordion->beginChild(); iter != mHistoryAccordion->endChild(); iter++)
  408. {
  409. if (dynamic_cast<LLAccordionCtrlTab*>(*iter))
  410. {
  411. LLAccordionCtrlTab* tab = (LLAccordionCtrlTab*)*iter;
  412. tab->setRightMouseDownCallback(boost::bind(&LLTeleportHistoryPanel::onAccordionTabRightClick, this, _1, _2, _3, _4));
  413. tab->setDisplayChildren(false);
  414. tab->setDropDownStateChangedCallback(boost::bind(&LLTeleportHistoryPanel::onAccordionExpand, this, _1, _2));
  416. // All accordion tabs are collapsed initially
  417. setAccordionCollapsedByUser(tab, true);
  419. mItemContainers.put(tab);
  421. LLFlatListView* fl = getFlatListViewFromTab(tab);
  422. if (fl)
  423. {
  424. fl->setCommitOnSelectionChange(true);
  425. fl->setDoubleClickCallback(boost::bind(&LLTeleportHistoryPanel::onDoubleClickItem, this));
  426. fl->setCommitCallback(boost::bind(&LLTeleportHistoryPanel::handleItemSelect, this, fl));
  427. fl->setReturnCallback(boost::bind(&LLTeleportHistoryPanel::onReturnKeyPressed, this));
  428. }
  429. }
  430. }
  432. // Open first 2 accordion tabs
  433. if (mItemContainers.size() > 1)
  434. {
  435. LLAccordionCtrlTab* tab = mItemContainers.get(mItemContainers.size() - 1);
  436. tab->setDisplayChildren(true);
  437. setAccordionCollapsedByUser(tab, false);
  438. }
  440. if (mItemContainers.size() > 2)
  441. {
  442. LLAccordionCtrlTab* tab = mItemContainers.get(mItemContainers.size() - 2);
  443. tab->setDisplayChildren(true);
  444. setAccordionCollapsedByUser(tab, false);
  445. }
  446. }
  448. getChild<LLPanel>("bottom_panel")->childSetAction("gear_btn",boost::bind(&LLTeleportHistoryPanel::onGearButtonClicked, this));
  450. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  452. registrar.add("TeleportHistory.ExpandAllFolders",  boost::bind(&LLTeleportHistoryPanel::onExpandAllFolders,  this));
  453. registrar.add("TeleportHistory.CollapseAllFolders",  boost::bind(&LLTeleportHistoryPanel::onCollapseAllFolders,  this));
  454. registrar.add("TeleportHistory.ClearTeleportHistory",  boost::bind(&LLTeleportHistoryPanel::onClearTeleportHistory,  this));
  455. mEnableCallbackRegistrar.add("TeleportHistory.GearMenu.Enable", boost::bind(&LLTeleportHistoryPanel::isActionEnabled, this, _2));
  457. LLMenuGL* gear_menu  = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_teleport_history_gear.xml",  gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  458. if(gear_menu)
  459. mGearMenuHandle  = gear_menu->getHandle();
  461. return TRUE;
  462. }
  464. // virtual
  465. void LLTeleportHistoryPanel::draw()
  466. {
  467. if (mDirty)
  468. refresh();
  470. LLPanelPlacesTab::draw();
  471. }
  473. // virtual
  474. void LLTeleportHistoryPanel::onSearchEdit(const std::string& string)
  475. {
  476. sFilterSubString = string;
  477. showTeleportHistory();
  478. }
  480. // virtual
  481. void LLTeleportHistoryPanel::onShowOnMap()
  482. {
  483. if (!mLastSelectedFlatlList)
  484. return;
  486. LLTeleportHistoryFlatItem* itemp = dynamic_cast<LLTeleportHistoryFlatItem *> (mLastSelectedFlatlList->getSelectedItem());
  488. if(!itemp)
  489. return;
  491. LLVector3d global_pos = mTeleportHistory->getItems()[itemp->getIndex()].mGlobalPos;
  493. if (!global_pos.isExactlyZero())
  494. {
  495. LLFloaterWorldMap::getInstance()->trackLocation(global_pos);
  496. LLFloaterReg::showInstance("world_map", "center");
  497. }
  498. }
  500. // virtual
  501. void LLTeleportHistoryPanel::onTeleport()
  502. {
  503. if (!mLastSelectedFlatlList)
  504. return;
  506. LLTeleportHistoryFlatItem* itemp = dynamic_cast<LLTeleportHistoryFlatItem *> (mLastSelectedFlatlList->getSelectedItem());
  507. if(!itemp)
  508. return;
  510. // teleport to existing item in history, so we don't add it again
  511. mTeleportHistory->goToItem(itemp->getIndex());
  512. }
  514. /*
  515. // virtual
  516. void LLTeleportHistoryPanel::onCopySLURL()
  517. {
  518. LLScrollListItem* itemp = mHistoryItems->getFirstSelected();
  519. if(!itemp)
  520. return;
  522. S32 index = itemp->getColumn(LIST_INDEX)->getValue().asInteger();
  524. const LLTeleportHistory::slurl_list_t& hist_items = mTeleportHistory->getItems();
  526. LLVector3d global_pos = hist_items[index].mGlobalPos;
  528. U64 new_region_handle = to_region_handle(global_pos);
  530. LLWorldMapMessage::url_callback_t cb = boost::bind(
  531. &LLPanelPlacesTab::onRegionResponse, this,
  532. global_pos, _1, _2, _3, _4);
  534. LLWorldMap::getInstance()->sendHandleRegionRequest(new_region_handle, cb, std::string("unused"), false);
  535. }
  536. */
  538. // virtual
  539. void LLTeleportHistoryPanel::updateVerbs()
  540. {
  541. if (!isTabVisible())
  542. return;
  544. if (!mLastSelectedFlatlList)
  545. {
  546. mTeleportBtn->setEnabled(false);
  547. mShowOnMapBtn->setEnabled(false);
  548. return;
  549. }
  551. LLTeleportHistoryFlatItem* itemp = dynamic_cast<LLTeleportHistoryFlatItem *> (mLastSelectedFlatlList->getSelectedItem());
  553. mTeleportBtn->setEnabled(NULL != itemp);
  554. mShowOnMapBtn->setEnabled(NULL != itemp);
  555. }
  557. void LLTeleportHistoryPanel::getNextTab(const LLDate& item_date, S32& tab_idx, LLDate& tab_date)
  558. {
  559. const U32 seconds_in_day = 24 * 60 * 60;
  561. S32 tabs_cnt = mItemContainers.size();
  562. S32 curr_year = 0, curr_month = 0, curr_day = 0;
  564. tab_date = LLDate::now();
  565. tab_date.split(&curr_year, &curr_month, &curr_day);
  566. tab_date.fromYMDHMS(curr_year, curr_month, curr_day); // Set hour, min, and sec to 0
  567. tab_date.secondsSinceEpoch(tab_date.secondsSinceEpoch() + seconds_in_day);
  569. tab_idx = -1;
  571. while (tab_idx < tabs_cnt - 1 && item_date < tab_date)
  572. {
  573. tab_idx++;
  575. if (tab_idx <= tabs_cnt - 4)
  576. {
  577. // All tabs, except last three, are tabs for one day, so just push tab_date back by one day
  578. tab_date.secondsSinceEpoch(tab_date.secondsSinceEpoch() - seconds_in_day);
  579. }
  580. else if (tab_idx == tabs_cnt - 3) // 6 day and older, low boundary is 1 month
  581. {
  582. tab_date =  LLDate::now();
  583. tab_date.split(&curr_year, &curr_month, &curr_day);
  584. curr_month--;
  585. if (0 == curr_month)
  586. {
  587. curr_month = 12;
  588. curr_year--;
  589. }
  590. tab_date.fromYMDHMS(curr_year, curr_month, curr_day);
  591. }
  592. else if (tab_idx == tabs_cnt - 2) // 1 month and older, low boundary is 6 months
  593. {
  594. tab_date =  LLDate::now();
  595. tab_date.split(&curr_year, &curr_month, &curr_day);
  596. if (curr_month > 6)
  597. {
  598. curr_month -= 6;
  599. }
  600. else
  601. {
  602. curr_month += 6;
  603. curr_year--;
  604. }
  605. tab_date.fromYMDHMS(curr_year, curr_month, curr_day);
  606. }
  607. else // 6 months and older
  608. {
  609. tab_date.secondsSinceEpoch(0);
  610. }
  611. }
  612. }
  614. // Called to add items, no more, than ADD_LIMIT at time
  615. void LLTeleportHistoryPanel::refresh()
  616. {
  617. if (!mHistoryAccordion)
  618. {
  619. mDirty = false;
  620. return;
  621. }
  623. const LLTeleportHistoryStorage::slurl_list_t& items = mTeleportHistory->getItems();
  625. // Setting tab_boundary_date to "now", so date from any item would be earlier, than boundary.
  626. // That leads to call to getNextTab to get right tab_idx in first pass
  627. LLDate tab_boundary_date =  LLDate::now();
  629. LLFlatListView* curr_flat_view = NULL;
  631. U32 added_items = 0;
  632. while (mCurrentItem >= 0)
  633. {
  634. // Filtering
  635. if (!sFilterSubString.empty())
  636. {
  637. std::string landmark_title(items[mCurrentItem].mTitle);
  638. LLStringUtil::toUpper(landmark_title);
  639. if( std::string::npos == landmark_title.find(sFilterSubString) )
  640. {
  641. mCurrentItem--;
  642. continue;
  643. }
  644. }
  646. // Checking whether date of item is earlier, than tab_boundary_date.
  647. // In that case, item should be added to another tab
  648. const LLDate &date = items[mCurrentItem].mDate;
  650. if (date < tab_boundary_date)
  651. {
  652. // Getting apropriate tab_idx for this and subsequent items,
  653. // tab_boundary_date would be earliest possible date for this tab
  654. S32 tab_idx = 0;
  655. getNextTab(date, tab_idx, tab_boundary_date);
  657. LLAccordionCtrlTab* tab = mItemContainers.get(mItemContainers.size() - 1 - tab_idx);
  658. tab->setVisible(true);
  660. // Expand all accordion tabs when filtering
  661. if(!sFilterSubString.empty())
  662. {
  663. //store accordion tab state when filter is not empty
  664. tab->notifyChildren(LLSD().with("action","store_state"));
  666. tab->setDisplayChildren(true);
  667. }
  668. // Restore each tab's expand state when not filtering
  669. else
  670. {
  671. bool collapsed = isAccordionCollapsedByUser(tab);
  672. tab->setDisplayChildren(!collapsed);
  674. //restore accordion state after all those accodrion tabmanipulations
  675. tab->notifyChildren(LLSD().with("action","restore_state"));
  676. }
  678. curr_flat_view = getFlatListViewFromTab(tab);
  679. }
  681. if (curr_flat_view)
  682. {
  683. LLTeleportHistoryFlatItem* item =
  684. LLTeleportHistoryFlatItemStorage::instance()
  685. .getFlatItemForPersistentItem(&mContextMenu,
  686.   items[mCurrentItem],
  687.   mCurrentItem,
  688.   sFilterSubString);
  689. if ( !curr_flat_view->addItem(item, LLUUID::null, ADD_BOTTOM, false) )
  690. llerrs << "Couldn't add flat item to teleport history." << llendl;
  691. if (mLastSelectedItemIndex == mCurrentItem)
  692. curr_flat_view->selectItem(item, true);
  693. }
  695. mCurrentItem--;
  697. if (++added_items >= ADD_LIMIT)
  698. break;
  699. }
  701. for (S32 n = mItemContainers.size() - 1; n >= 0; --n)
  702. {
  703. LLAccordionCtrlTab* tab = mItemContainers.get(n);
  704. LLFlatListView* fv = getFlatListViewFromTab(tab);
  705. if (fv)
  706. {
  707. fv->notify(LLSD().with("rearrange", LLSD()));
  708. }
  709. }
  711. mHistoryAccordion->arrange();
  713. updateVerbs();
  715. if (mCurrentItem < 0)
  716. mDirty = false;
  717. }
  719. void LLTeleportHistoryPanel::onTeleportHistoryChange(S32 removed_index)
  720. {
  721. mLastSelectedItemIndex = -1;
  723. if (-1 == removed_index)
  724. showTeleportHistory(); // recreate all items
  725. else
  726. {
  727. replaceItem(removed_index); // replace removed item by most recent
  728. updateVerbs();
  729. }
  730. }
  732. void LLTeleportHistoryPanel::replaceItem(S32 removed_index)
  733. {
  734. // Flat list for 'Today' (mItemContainers keeps accordion tabs in reverse order)
  735. LLFlatListView* fv = getFlatListViewFromTab(mItemContainers[mItemContainers.size() - 1]);
  737. // Empty flat list for 'Today' means that other flat lists are empty as well,
  738. // so all items from teleport history should be added.
  739. if (!fv || fv->size() == 0)
  740. {
  741. showTeleportHistory();
  742. return;
  743. }
  745. const LLTeleportHistoryStorage::slurl_list_t& history_items = mTeleportHistory->getItems();
  746. LLTeleportHistoryFlatItem* item = LLTeleportHistoryFlatItemStorage::instance()
  747. .getFlatItemForPersistentItem(&mContextMenu,
  748.   history_items[history_items.size() - 1], // Most recent item, it was added instead of removed
  749.   history_items.size(), // index will be decremented inside loop below
  750.   sFilterSubString);
  752. fv->addItem(item, LLUUID::null, ADD_TOP);
  754. // Index of each item, from last to removed item should be decremented
  755. // to point to the right item in LLTeleportHistoryStorage
  756. for (S32 tab_idx = mItemContainers.size() - 1; tab_idx >= 0; --tab_idx)
  757. {
  758. LLAccordionCtrlTab* tab = mItemContainers.get(tab_idx);
  759. if (!tab->getVisible())
  760. continue;
  762. fv = getFlatListViewFromTab(tab);
  763. if (!fv)
  764. {
  765. showTeleportHistory();
  766. return;
  767. }
  769. std::vector<LLPanel*> items;
  770. fv->getItems(items);
  772. S32 items_cnt = items.size();
  773. for (S32 n = 0; n < items_cnt; ++n)
  774. {
  775. LLTeleportHistoryFlatItem *item = (LLTeleportHistoryFlatItem*) items[n];
  777. if (item->getIndex() == removed_index)
  778. {
  779. LLTeleportHistoryFlatItemStorage::instance().removeItem(item);
  781. fv->removeItem(item);
  783. // If flat list becames empty, then accordion tab should be hidden
  784. if (fv->size() == 0)
  785. tab->setVisible(false);
  787. mHistoryAccordion->arrange();
  789. return; // No need to decrement idexes for the rest of items
  790. }
  792. item->setIndex(item->getIndex() - 1);
  793. }
  794. }
  795. }
  797. void LLTeleportHistoryPanel::showTeleportHistory()
  798. {
  799. mDirty = true;
  801. // Starting to add items from last one, in reverse order,
  802. // since TeleportHistory keeps most recent item at the end
  803. mCurrentItem = mTeleportHistory->getItems().size() - 1;
  805. for (S32 n = mItemContainers.size() - 1; n >= 0; --n)
  806. {
  807. LLAccordionCtrlTab* tab = mItemContainers.get(n);
  808. tab->setVisible(false);
  810. LLFlatListView* fv = getFlatListViewFromTab(tab);
  811. if (fv)
  812. {
  813. // Detached panels are managed by LLTeleportHistoryFlatItemStorage
  814. std::vector<LLPanel*> detached_items;
  815. fv->detachItems(detached_items);
  816. }
  817. }
  818. }
  820. void LLTeleportHistoryPanel::handleItemSelect(LLFlatListView* selected)
  821. {
  822. mLastSelectedFlatlList = selected;
  823. LLTeleportHistoryFlatItem* item = dynamic_cast<LLTeleportHistoryFlatItem *> (mLastSelectedFlatlList->getSelectedItem());
  824. if (item)
  825. mLastSelectedItemIndex = item->getIndex();
  827. S32 tabs_cnt = mItemContainers.size();
  829. for (S32 n = 0; n < tabs_cnt; n++)
  830. {
  831. LLAccordionCtrlTab* tab = mItemContainers.get(n);
  833. if (!tab->getVisible())
  834. continue;
  836. LLFlatListView *flv = getFlatListViewFromTab(tab);
  837. if (!flv)
  838. continue;
  840. if (flv == selected)
  841. continue;
  843. flv->resetSelection(true);
  844. }
  846. updateVerbs();
  847. }
  849. void LLTeleportHistoryPanel::onReturnKeyPressed()
  850. {
  851. // Teleport to selected region as default action on return key pressed
  852. onTeleport();
  853. }
  855. void LLTeleportHistoryPanel::onDoubleClickItem()
  856. {
  857. // If item got doubleclick, then that item is already selected
  858. onTeleport();
  859. }
  861. void LLTeleportHistoryPanel::onAccordionTabRightClick(LLView *view, S32 x, S32 y, MASK mask)
  862. {
  863. LLAccordionCtrlTab *tab = (LLAccordionCtrlTab *) view;
  865. // If click occurred below the header, don't show this menu
  866. if (y < tab->getRect().getHeight() - tab->getHeaderHeight() - tab->getPaddingBottom())
  867. return;
  869. if (mAccordionTabMenu)
  870. {
  871. //preventing parent (menu holder) from deleting already "dead" context menus on exit
  872. LLView* parent = mAccordionTabMenu->getParent();
  873. if (parent)
  874. {
  875. parent->removeChild(mAccordionTabMenu);
  876. }
  877. delete mAccordionTabMenu;
  878. }
  880. // set up the callbacks for all of the avatar menu items
  881. // (N.B. callbacks don't take const refs as mID is local scope)
  882. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  884. registrar.add("TeleportHistory.TabOpen", boost::bind(&LLTeleportHistoryPanel::onAccordionTabOpen, this, tab));
  885. registrar.add("TeleportHistory.TabClose", boost::bind(&LLTeleportHistoryPanel::onAccordionTabClose, this, tab));
  887. // create the context menu from the XUI
  888. mAccordionTabMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>(
  889. "menu_teleport_history_tab.xml", LLMenuGL::sMenuContainer, LLViewerMenuHolderGL::child_registry_t::instance());
  891. mAccordionTabMenu->setItemVisible("TabOpen", !tab->isExpanded() ? true : false);
  892. mAccordionTabMenu->setItemVisible("TabClose", tab->isExpanded() ? true : false);
  894. mAccordionTabMenu->show(x, y);
  895. LLMenuGL::showPopup(tab, mAccordionTabMenu, x, y);
  896. }
  898. void LLTeleportHistoryPanel::onAccordionTabOpen(LLAccordionCtrlTab *tab)
  899. {
  900. tab->setDisplayChildren(true);
  901. mHistoryAccordion->arrange();
  902. }
  904. void LLTeleportHistoryPanel::onAccordionTabClose(LLAccordionCtrlTab *tab)
  905. {
  906. tab->setDisplayChildren(false);
  907. mHistoryAccordion->arrange();
  908. }
  910. void LLTeleportHistoryPanel::onExpandAllFolders()
  911. {
  912. S32 tabs_cnt = mItemContainers.size();
  914. for (S32 n = 0; n < tabs_cnt; n++)
  915. {
  916. mItemContainers.get(n)->setDisplayChildren(true);
  917. }
  918. mHistoryAccordion->arrange();
  919. }
  921. void LLTeleportHistoryPanel::onCollapseAllFolders()
  922. {
  923. S32 tabs_cnt = mItemContainers.size();
  925. for (S32 n = 0; n < tabs_cnt; n++)
  926. {
  927. mItemContainers.get(n)->setDisplayChildren(false);
  928. }
  929. mHistoryAccordion->arrange();
  930. }
  932. void LLTeleportHistoryPanel::onClearTeleportHistory()
  933. {
  934. LLNotificationsUtil::add("ConfirmClearTeleportHistory", LLSD(), LLSD(), boost::bind(&LLTeleportHistoryPanel::onClearTeleportHistoryDialog, this, _1, _2));
  935. }
  937. bool LLTeleportHistoryPanel::onClearTeleportHistoryDialog(const LLSD& notification, const LLSD& response)
  938. {
  940. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  942. if (0 == option)
  943. {
  944. // order does matter, call this first or teleport history will contain one record(current location)
  945. LLTeleportHistory::getInstance()->purgeItems();
  947. LLTeleportHistoryStorage *th = LLTeleportHistoryStorage::getInstance();
  948. th->purgeItems();
  949. th->save();
  950. }
  952. return false;
  953. }
  955. LLFlatListView* LLTeleportHistoryPanel::getFlatListViewFromTab(LLAccordionCtrlTab *tab)
  956. {
  957. for (child_list_const_iter_t iter = tab->beginChild(); iter != tab->endChild(); iter++)
  958. {
  959. if (dynamic_cast<LLFlatListView*>(*iter))
  960. {
  961. return (LLFlatListView*)*iter; // There should be one scroll list per tab.
  962. }
  963. }
  965. return NULL;
  966. }
  968. void LLTeleportHistoryPanel::onGearButtonClicked()
  969. {
  970. LLMenuGL* menu = (LLMenuGL*)mGearMenuHandle.get();
  971. if (!menu)
  972. return;
  974. // Shows the menu at the top of the button bar.
  976. // Calculate its coordinates.
  977. LLPanel* bottom_panel = getChild<LLPanel>("bottom_panel");
  978. menu->arrangeAndClear();
  979. S32 menu_height = menu->getRect().getHeight();
  980. S32 menu_x = -2; // *HACK: compensates HPAD in showPopup()
  981. S32 menu_y = bottom_panel->getRect().mTop + menu_height;
  983. // Actually show the menu.
  984. menu->buildDrawLabels();
  985. menu->updateParent(LLMenuGL::sMenuContainer);
  986. LLMenuGL::showPopup(this, menu, menu_x, menu_y);
  987. }
  989. bool LLTeleportHistoryPanel::isActionEnabled(const LLSD& userdata) const
  990. {
  991. S32 tabs_cnt = mItemContainers.size();
  993. bool has_expanded_tabs = false;
  994. bool has_collapsed_tabs = false;
  996. for (S32 n = 0; n < tabs_cnt; n++)
  997. {
  998. LLAccordionCtrlTab* tab = mItemContainers.get(n);
  999. if (!tab->getVisible())
  1000. continue;
  1002. if (tab->getDisplayChildren())
  1003. {
  1004. has_expanded_tabs = true;
  1005. }
  1006. else
  1007. {
  1008. has_collapsed_tabs = true;
  1009. }
  1011. if (has_expanded_tabs && has_collapsed_tabs)
  1012. {
  1013. break;
  1014. }
  1015. }
  1017. std::string command_name = userdata.asString();
  1019. if (has_expanded_tabs && command_name == "collapse_all")
  1020. {
  1021. return true;
  1022. }
  1024. if (has_collapsed_tabs && command_name ==  "expand_all")
  1025. {
  1026. return true;
  1027. }
  1029. return false;
  1030. }
  1032. void LLTeleportHistoryPanel::setAccordionCollapsedByUser(LLUICtrl* acc_tab, bool collapsed)
  1033. {
  1034. LLSD param = acc_tab->getValue();
  1035. param[COLLAPSED_BY_USER] = collapsed;
  1036. acc_tab->setValue(param);
  1037. }
  1039. bool LLTeleportHistoryPanel::isAccordionCollapsedByUser(LLUICtrl* acc_tab)
  1040. {
  1041. LLSD param = acc_tab->getValue();
  1042. if(!param.has(COLLAPSED_BY_USER))
  1043. {
  1044. return false;
  1045. }
  1046. return param[COLLAPSED_BY_USER].asBoolean();
  1047. }
  1049. void LLTeleportHistoryPanel::onAccordionExpand(LLUICtrl* ctrl, const LLSD& param)
  1050. {
  1051. bool expanded = param.asBoolean();
  1052. // Save accordion tab state to restore it in refresh()
  1053. setAccordionCollapsedByUser(ctrl, !expanded);
  1055. // Reset selection upon accordion being collapsed
  1056. // to disable "Teleport" and "Map" buttons for hidden item.
  1057. if (!expanded && mLastSelectedFlatlList)
  1058. {
  1059. mLastSelectedFlatlList->resetSelection();
  1060. }
  1061. }