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

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

游戏引擎

开发平台：

C++ Builder

llpanelplaces.cpp：源码内容
  1. /**
  2.  * @file llpanelplaces.cpp
  3.  * @brief Side Bar "Places" panel
  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 "llpanelplaces.h"
  37. #include "llassettype.h"
  38. #include "lltimer.h"
  40. #include "llinventory.h"
  41. #include "lllandmark.h"
  42. #include "llparcel.h"
  44. #include "llcombobox.h"
  45. #include "llfiltereditor.h"
  46. #include "llfloaterreg.h"
  47. #include "llnotificationsutil.h"
  48. #include "lltabcontainer.h"
  49. #include "lltexteditor.h"
  50. #include "lltrans.h"
  51. #include "lluictrlfactory.h"
  53. #include "llwindow.h"
  55. #include "llagent.h"
  56. #include "llagentpicksinfo.h"
  57. #include "llavatarpropertiesprocessor.h"
  58. #include "llfloaterworldmap.h"
  59. #include "llinventorybridge.h"
  60. #include "llinventoryobserver.h"
  61. #include "llinventorymodel.h"
  62. #include "lllandmarkactions.h"
  63. #include "lllandmarklist.h"
  64. #include "llpanellandmarkinfo.h"
  65. #include "llpanellandmarks.h"
  66. #include "llpanelpick.h"
  67. #include "llpanelplaceprofile.h"
  68. #include "llpanelteleporthistory.h"
  69. #include "llremoteparcelrequest.h"
  70. #include "llteleporthistorystorage.h"
  71. #include "lltoggleablemenu.h"
  72. #include "llviewerinventory.h"
  73. #include "llviewermenu.h"
  74. #include "llviewermessage.h"
  75. #include "llviewerparcelmgr.h"
  76. #include "llviewerregion.h"
  77. #include "llviewerwindow.h"
  79. static const S32 LANDMARK_FOLDERS_MENU_WIDTH = 250;
  80. static const F32 PLACE_INFO_UPDATE_INTERVAL = 3.0;
  81. static const std::string AGENT_INFO_TYPE = "agent";
  82. static const std::string CREATE_LANDMARK_INFO_TYPE = "create_landmark";
  83. static const std::string LANDMARK_INFO_TYPE = "landmark";
  84. static const std::string REMOTE_PLACE_INFO_TYPE = "remote_place";
  85. static const std::string TELEPORT_HISTORY_INFO_TYPE = "teleport_history";
  87. // Helper functions
  88. static bool is_agent_in_selected_parcel(LLParcel* parcel);
  89. static void onSLURLBuilt(std::string& slurl);
  91. //Observer classes
  92. class LLPlacesParcelObserver : public LLParcelObserver
  93. {
  94. public:
  95. LLPlacesParcelObserver(LLPanelPlaces* places_panel) :
  96. LLParcelObserver(),
  97. mPlaces(places_panel)
  98. {}
  100. /*virtual*/ void changed()
  101. {
  102. if (mPlaces)
  103. mPlaces->changedParcelSelection();
  104. }
  106. private:
  107. LLPanelPlaces* mPlaces;
  108. };
  110. class LLPlacesInventoryObserver : public LLInventoryAddedObserver
  111. {
  112. public:
  113. LLPlacesInventoryObserver(LLPanelPlaces* places_panel) :
  114. mPlaces(places_panel),
  115. mTabsCreated(false)
  116. {}
  118. /*virtual*/ void changed(U32 mask)
  119. {
  120. LLInventoryAddedObserver::changed(mask);
  122. if (!mTabsCreated && mPlaces)
  123. {
  124. mPlaces->createTabs();
  125. mTabsCreated = true;
  126. }
  127. }
  129. protected:
  130. /*virtual*/ void done()
  131. {
  132. mPlaces->showAddedLandmarkInfo(mAdded);
  133. mAdded.clear();
  134. }
  136. private:
  137. LLPanelPlaces* mPlaces;
  138. bool mTabsCreated;
  139. };
  141. class LLPlacesRemoteParcelInfoObserver : public LLRemoteParcelInfoObserver
  142. {
  143. public:
  144. LLPlacesRemoteParcelInfoObserver(LLPanelPlaces* places_panel) :
  145. LLRemoteParcelInfoObserver(),
  146. mPlaces(places_panel)
  147. {}
  149. ~LLPlacesRemoteParcelInfoObserver()
  150. {
  151. // remove any in-flight observers
  152. std::set<LLUUID>::iterator it;
  153. for (it = mParcelIDs.begin(); it != mParcelIDs.end(); ++it)
  154. {
  155. const LLUUID &id = *it;
  156. LLRemoteParcelInfoProcessor::getInstance()->removeObserver(id, this);
  157. }
  158. mParcelIDs.clear();
  159. }
  161. /*virtual*/ void processParcelInfo(const LLParcelData& parcel_data)
  162. {
  163. if (mPlaces)
  164. {
  165. mPlaces->changedGlobalPos(LLVector3d(parcel_data.global_x,
  166.  parcel_data.global_y,
  167.  parcel_data.global_z));
  168. }
  170. mParcelIDs.erase(parcel_data.parcel_id);
  171. LLRemoteParcelInfoProcessor::getInstance()->removeObserver(parcel_data.parcel_id, this);
  172. }
  173. /*virtual*/ void setParcelID(const LLUUID& parcel_id)
  174. {
  175. if (!parcel_id.isNull())
  176. {
  177. mParcelIDs.insert(parcel_id);
  178. LLRemoteParcelInfoProcessor::getInstance()->addObserver(parcel_id, this);
  179. LLRemoteParcelInfoProcessor::getInstance()->sendParcelInfoRequest(parcel_id);
  180. }
  181. }
  182. /*virtual*/ void setErrorStatus(U32 status, const std::string& reason)
  183. {
  184. llerrs << "Can't complete remote parcel request. Http Status: "
  185.    << status << ". Reason : " << reason << llendl;
  186. }
  188. private:
  189. std::set<LLUUID> mParcelIDs;
  190. LLPanelPlaces* mPlaces;
  191. };
  194. static LLRegisterPanelClassWrapper<LLPanelPlaces> t_places("panel_places");
  196. LLPanelPlaces::LLPanelPlaces()
  197. : LLPanel(),
  198. mActivePanel(NULL),
  199. mFilterEditor(NULL),
  200. mPlaceProfile(NULL),
  201. mLandmarkInfo(NULL),
  202. mPickPanel(NULL),
  203. mItem(NULL),
  204. mPlaceMenu(NULL),
  205. mLandmarkMenu(NULL),
  206. mPosGlobal(),
  207. isLandmarkEditModeOn(false)
  208. {
  209. mParcelObserver = new LLPlacesParcelObserver(this);
  210. mInventoryObserver = new LLPlacesInventoryObserver(this);
  211. mRemoteParcelObserver = new LLPlacesRemoteParcelInfoObserver(this);
  213. gInventory.addObserver(mInventoryObserver);
  215. LLViewerParcelMgr::getInstance()->addAgentParcelChangedCallback(
  216. boost::bind(&LLPanelPlaces::updateVerbs, this));
  218. //LLUICtrlFactory::getInstance()->buildPanel(this, "panel_places.xml"); // Called from LLRegisterPanelClass::defaultPanelClassBuilder()
  219. }
  221. LLPanelPlaces::~LLPanelPlaces()
  222. {
  223. if (gInventory.containsObserver(mInventoryObserver))
  224. gInventory.removeObserver(mInventoryObserver);
  226. LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
  228. delete mInventoryObserver;
  229. delete mParcelObserver;
  230. delete mRemoteParcelObserver;
  231. }
  233. BOOL LLPanelPlaces::postBuild()
  234. {
  235. mTeleportBtn = getChild<LLButton>("teleport_btn");
  236. mTeleportBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onTeleportButtonClicked, this));
  238. mShowOnMapBtn = getChild<LLButton>("map_btn");
  239. mShowOnMapBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onShowOnMapButtonClicked, this));
  241. mEditBtn = getChild<LLButton>("edit_btn");
  242. mEditBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
  244. mSaveBtn = getChild<LLButton>("save_btn");
  245. mSaveBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onSaveButtonClicked, this));
  247. mCancelBtn = getChild<LLButton>("cancel_btn");
  248. mCancelBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onCancelButtonClicked, this));
  250. mCloseBtn = getChild<LLButton>("close_btn");
  251. mCloseBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
  253. mOverflowBtn = getChild<LLButton>("overflow_btn");
  254. mOverflowBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onOverflowButtonClicked, this));
  256. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
  257. registrar.add("Places.OverflowMenu.Action",  boost::bind(&LLPanelPlaces::onOverflowMenuItemClicked, this, _2));
  258. LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
  259. enable_registrar.add("Places.OverflowMenu.Enable",  boost::bind(&LLPanelPlaces::onOverflowMenuItemEnable, this, _2));
  261. mPlaceMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_place.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  262. if (!mPlaceMenu)
  263. {
  264. llwarns << "Error loading Place menu" << llendl;
  265. }
  267. mLandmarkMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_landmark.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  268. if (!mLandmarkMenu)
  269. {
  270. llwarns << "Error loading Landmark menu" << llendl;
  271. }
  273. mTabContainer = getChild<LLTabContainer>("Places Tabs");
  274. if (mTabContainer)
  275. {
  276. mTabContainer->setCommitCallback(boost::bind(&LLPanelPlaces::onTabSelected, this));
  277. }
  279. mFilterEditor = getChild<LLFilterEditor>("Filter");
  280. if (mFilterEditor)
  281. {
  282. mFilterEditor->setCommitCallback(boost::bind(&LLPanelPlaces::onFilterEdit, this, _2, false));
  283. }
  285. mPlaceProfile = getChild<LLPanelPlaceProfile>("panel_place_profile");
  286. mLandmarkInfo = getChild<LLPanelLandmarkInfo>("panel_landmark_info");
  287. if (!mPlaceProfile || !mLandmarkInfo)
  288. return FALSE;
  290. mPlaceProfileBackBtn = mPlaceProfile->getChild<LLButton>("back_btn");
  291. mPlaceProfileBackBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
  293. mLandmarkInfoBackBtn = mLandmarkInfo->getChild<LLButton>("back_btn");
  294. mLandmarkInfoBackBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
  296. LLLineEditor* title_editor = mLandmarkInfo->getChild<LLLineEditor>("title_editor");
  297. title_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this), NULL);
  299. LLTextEditor* notes_editor = mLandmarkInfo->getChild<LLTextEditor>("notes_editor");
  300. notes_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
  302. LLComboBox* folder_combo = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
  303. folder_combo->setCommitCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
  305. return TRUE;
  306. }
  308. void LLPanelPlaces::onOpen(const LLSD& key)
  309. {
  310. if (!mPlaceProfile || !mLandmarkInfo)
  311. return;
  313. if (key.size() != 0)
  314. {
  315. mFilterEditor->clear();
  316. onFilterEdit("", false);
  318. mPlaceInfoType = key["type"].asString();
  319. mPosGlobal.setZero();
  320. mItem = NULL;
  321. isLandmarkEditModeOn = false;
  322. togglePlaceInfoPanel(TRUE);
  324. if (mPlaceInfoType == AGENT_INFO_TYPE)
  325. {
  326. mPlaceProfile->setInfoType(LLPanelPlaceInfo::AGENT);
  327. }
  328. else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
  329. {
  330. mLandmarkInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
  332. if (key.has("x") && key.has("y") && key.has("z"))
  333. {
  334. mPosGlobal = LLVector3d(key["x"].asReal(),
  335. key["y"].asReal(),
  336. key["z"].asReal());
  337. }
  338. else
  339. {
  340. mPosGlobal = gAgent.getPositionGlobal();
  341. }
  343. mLandmarkInfo->displayParcelInfo(LLUUID(), mPosGlobal);
  345. // Disabling "Save", "Close" and "Back" buttons to prevent closing "Create Landmark"
  346. // panel before created landmark is loaded.
  347. // These buttons will be enabled when created landmark is added to inventory.
  348. mSaveBtn->setEnabled(FALSE);
  349. mCloseBtn->setEnabled(FALSE);
  350. mLandmarkInfoBackBtn->setEnabled(FALSE);
  351. }
  352. else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
  353. {
  354. mLandmarkInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
  356. LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
  357. if (!item)
  358. return;
  360. setItem(item);
  361. }
  362. else if (mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
  363. {
  364. if (key.has("id"))
  365. {
  366. LLUUID parcel_id = key["id"].asUUID();
  367. mPlaceProfile->setParcelID(parcel_id);
  369. // query the server to get the global 3D position of this
  370. // parcel - we need this for teleport/mapping functions.
  371. mRemoteParcelObserver->setParcelID(parcel_id);
  372. }
  373. else
  374. {
  375. mPosGlobal = LLVector3d(key["x"].asReal(),
  376. key["y"].asReal(),
  377. key["z"].asReal());
  378. mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
  379. }
  381. mPlaceProfile->setInfoType(LLPanelPlaceInfo::PLACE);
  382. }
  383. else if (mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
  384. {
  385. S32 index = key["id"].asInteger();
  387. const LLTeleportHistoryStorage::slurl_list_t& hist_items =
  388. LLTeleportHistoryStorage::getInstance()->getItems();
  390. mPosGlobal = hist_items[index].mGlobalPos;
  392. mPlaceProfile->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
  393. mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
  394. }
  396. updateVerbs();
  397. }
  399. LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
  400. if (!parcel_mgr)
  401. return;
  403. // Start using LLViewerParcelMgr for land selection if
  404. // information about nearby land is requested.
  405. // Otherwise stop using land selection and deselect land.
  406. if (mPlaceInfoType == AGENT_INFO_TYPE)
  407. {
  408. // We don't know if we are already added to LLViewerParcelMgr observers list
  409. // so try to remove observer not to add an extra one.
  410. parcel_mgr->removeObserver(mParcelObserver);
  412. parcel_mgr->addObserver(mParcelObserver);
  413. parcel_mgr->selectParcelAt(gAgent.getPositionGlobal());
  414. }
  415. else
  416. {
  417. parcel_mgr->removeObserver(mParcelObserver);
  419. // Clear the reference to selection to allow its removal in deselectUnused().
  420. mParcel.clear();
  422. if (!parcel_mgr->selectionEmpty())
  423. {
  424. parcel_mgr->deselectUnused();
  425. }
  426. }
  427. }
  429. void LLPanelPlaces::setItem(LLInventoryItem* item)
  430. {
  431. if (!mLandmarkInfo || !item)
  432. return;
  434. mItem = item;
  436. LLAssetType::EType item_type = mItem->getActualType();
  437. if (item_type == LLAssetType::AT_LANDMARK || item_type == LLAssetType::AT_LINK)
  438. {
  439. // If the item is a link get a linked item
  440. if (item_type == LLAssetType::AT_LINK)
  441. {
  442. mItem = gInventory.getItem(mItem->getLinkedUUID());
  443. if (mItem.isNull())
  444. return;
  445. }
  446. }
  447. else
  448. {
  449. return;
  450. }
  452. // Check if item is in agent's inventory and he has the permission to modify it.
  453. BOOL is_landmark_editable = gInventory.isObjectDescendentOf(mItem->getUUID(), gInventory.getRootFolderID()) &&
  454. mItem->getPermissions().allowModifyBy(gAgent.getID());
  456. mEditBtn->setEnabled(is_landmark_editable);
  457. mSaveBtn->setEnabled(is_landmark_editable);
  458. mCloseBtn->setEnabled(TRUE);
  459. mLandmarkInfoBackBtn->setEnabled(TRUE);
  461. if (is_landmark_editable)
  462. {
  463. if(!mLandmarkInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
  464. {
  465. const LLViewerInventoryCategory* cat = gInventory.getCategory(mItem->getParentUUID());
  466. if (cat)
  467. {
  468. std::string cat_fullname = LLPanelLandmarkInfo::getFullFolderName(cat);
  469. LLComboBox* folderList = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
  470. folderList->add(cat_fullname, cat->getUUID(), ADD_TOP);
  471. }
  472. }
  473. }
  475. mLandmarkInfo->displayItemInfo(mItem);
  477. LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
  478. boost::bind(&LLPanelPlaces::onLandmarkLoaded, this, _1));
  479. if (lm)
  480. {
  481. onLandmarkLoaded(lm);
  482. }
  483. }
  485. S32 LLPanelPlaces::notifyParent(const LLSD& info)
  486. {
  487. if(info.has("update_verbs"))
  488. {
  489. if(mPosGlobal.isExactlyZero())
  490. {
  491. mPosGlobal.setVec(info["global_x"], info["global_y"], info["global_z"]);
  492. }
  494. updateVerbs();
  496. return 1;
  497. }
  498. return LLPanel::notifyParent(info);
  499. }
  501. void LLPanelPlaces::onLandmarkLoaded(LLLandmark* landmark)
  502. {
  503. if (!mLandmarkInfo)
  504. return;
  506. LLUUID region_id;
  507. landmark->getRegionID(region_id);
  508. landmark->getGlobalPos(mPosGlobal);
  509. mLandmarkInfo->displayParcelInfo(region_id, mPosGlobal);
  511. updateVerbs();
  512. }
  514. void LLPanelPlaces::onFilterEdit(const std::string& search_string, bool force_filter)
  515. {
  516. if (!mActivePanel)
  517. return;
  519. if (force_filter || mActivePanel->getFilterSubString() != search_string)
  520. {
  521. std::string string = search_string;
  523. // Searches are case-insensitive
  524. LLStringUtil::toUpper(string);
  525. LLStringUtil::trimHead(string);
  527. mActivePanel->onSearchEdit(string);
  528. }
  529. }
  531. void LLPanelPlaces::onTabSelected()
  532. {
  533. mActivePanel = dynamic_cast<LLPanelPlacesTab*>(mTabContainer->getCurrentPanel());
  534. if (!mActivePanel)
  535. return;
  537. onFilterEdit(mActivePanel->getFilterSubString(), true);
  538. mActivePanel->updateVerbs();
  539. }
  541. void LLPanelPlaces::onTeleportButtonClicked()
  542. {
  543. LLPanelPlaceInfo* panel = getCurrentInfoPanel();
  544. if (panel && panel->getVisible())
  545. {
  546. if (mPlaceInfoType == LANDMARK_INFO_TYPE)
  547. {
  548. LLSD payload;
  549. payload["asset_id"] = mItem->getAssetUUID();
  550. LLNotificationsUtil::add("TeleportFromLandmark", LLSD(), payload);
  551. }
  552. else if (mPlaceInfoType == AGENT_INFO_TYPE ||
  553.  mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
  554.  mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
  555. {
  556. LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
  557. if (!mPosGlobal.isExactlyZero() && worldmap_instance)
  558. {
  559. gAgent.teleportViaLocation(mPosGlobal);
  560. worldmap_instance->trackLocation(mPosGlobal);
  561. }
  562. }
  563. }
  564. else
  565. {
  566. if (mActivePanel)
  567. mActivePanel->onTeleport();
  568. }
  569. }
  571. void LLPanelPlaces::onShowOnMapButtonClicked()
  572. {
  573. LLPanelPlaceInfo* panel = getCurrentInfoPanel();
  574. if (panel && panel->getVisible())
  575. {
  576. LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
  577. if(!worldmap_instance)
  578. return;
  580. if (mPlaceInfoType == AGENT_INFO_TYPE ||
  581. mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
  582. mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
  583. mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
  584. {
  585. if (!mPosGlobal.isExactlyZero())
  586. {
  587. worldmap_instance->trackLocation(mPosGlobal);
  588. LLFloaterReg::showInstance("world_map", "center");
  589. }
  590. }
  591. else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
  592. {
  593. LLLandmark* landmark = gLandmarkList.getAsset(mItem->getAssetUUID());
  594. if (!landmark)
  595. return;
  597. LLVector3d landmark_global_pos;
  598. if (!landmark->getGlobalPos(landmark_global_pos))
  599. return;
  601. if (!landmark_global_pos.isExactlyZero())
  602. {
  603. worldmap_instance->trackLocation(landmark_global_pos);
  604. LLFloaterReg::showInstance("world_map", "center");
  605. }
  606. }
  607. }
  608. else
  609. {
  610. if (mActivePanel)
  611. mActivePanel->onShowOnMap();
  612. }
  613. }
  615. void LLPanelPlaces::onEditButtonClicked()
  616. {
  617. if (!mLandmarkInfo || isLandmarkEditModeOn)
  618. return;
  620. isLandmarkEditModeOn = true;
  622. mLandmarkInfo->toggleLandmarkEditMode(TRUE);
  624. updateVerbs();
  625. }
  627. void LLPanelPlaces::onSaveButtonClicked()
  628. {
  629. if (!mLandmarkInfo || mItem.isNull())
  630. return;
  632. std::string current_title_value = mLandmarkInfo->getLandmarkTitle();
  633. std::string item_title_value = mItem->getName();
  634. std::string current_notes_value = mLandmarkInfo->getLandmarkNotes();
  635. std::string item_notes_value = mItem->getDescription();
  637. LLStringUtil::trim(current_title_value);
  638. LLStringUtil::trim(current_notes_value);
  640. LLUUID item_id = mItem->getUUID();
  641. LLUUID folder_id = mLandmarkInfo->getLandmarkFolder();
  643. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(mItem);
  645. if (!current_title_value.empty() &&
  646. (item_title_value != current_title_value || item_notes_value != current_notes_value))
  647. {
  648. new_item->rename(current_title_value);
  649. new_item->setDescription(current_notes_value);
  650. new_item->updateServer(FALSE);
  651. }
  653. if(folder_id != mItem->getParentUUID())
  654. {
  655. LLInventoryModel::update_list_t update;
  656. LLInventoryModel::LLCategoryUpdate old_folder(mItem->getParentUUID(),-1);
  657. update.push_back(old_folder);
  658. LLInventoryModel::LLCategoryUpdate new_folder(folder_id, 1);
  659. update.push_back(new_folder);
  660. gInventory.accountForUpdate(update);
  662. new_item->setParent(folder_id);
  663. new_item->updateParentOnServer(FALSE);
  664. }
  666. gInventory.updateItem(new_item);
  667. gInventory.notifyObservers();
  669. onCancelButtonClicked();
  670. }
  672. void LLPanelPlaces::onCancelButtonClicked()
  673. {
  674. if (!mLandmarkInfo)
  675. return;
  677. if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
  678. {
  679. onBackButtonClicked();
  680. }
  681. else
  682. {
  683. mLandmarkInfo->toggleLandmarkEditMode(FALSE);
  684. isLandmarkEditModeOn = false;
  686. updateVerbs();
  688. // Reload the landmark properties.
  689. mLandmarkInfo->displayItemInfo(mItem);
  690. }
  691. }
  693. void LLPanelPlaces::onOverflowButtonClicked()
  694. {
  695. LLToggleableMenu* menu;
  697. bool is_agent_place_info_visible = mPlaceInfoType == AGENT_INFO_TYPE;
  699. if ((is_agent_place_info_visible ||
  700.  mPlaceInfoType == "remote_place" ||
  701.  mPlaceInfoType == "teleport_history") && mPlaceMenu != NULL)
  702. {
  703. menu = mPlaceMenu;
  705. // Enable adding a landmark only for agent current parcel and if
  706. // there is no landmark already pointing to that parcel in agent's inventory.
  707. menu->getChild<LLMenuItemCallGL>("landmark")->setEnabled(is_agent_place_info_visible &&
  708.  !LLLandmarkActions::landmarkAlreadyExists());
  709. }
  710. else if (mPlaceInfoType == LANDMARK_INFO_TYPE && mLandmarkMenu != NULL)
  711. {
  712. menu = mLandmarkMenu;
  714. BOOL is_landmark_removable = FALSE;
  715. if (mItem.notNull())
  716. {
  717. const LLUUID& item_id = mItem->getUUID();
  718. const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
  719. is_landmark_removable = gInventory.isObjectDescendentOf(item_id, gInventory.getRootFolderID()) &&
  720. !gInventory.isObjectDescendentOf(item_id, trash_id);
  721. }
  723. menu->getChild<LLMenuItemCallGL>("delete")->setEnabled(is_landmark_removable);
  724. }
  725. else
  726. {
  727. return;
  728. }
  730. if (!menu->toggleVisibility())
  731. return;
  733. if (menu->getButtonRect().isEmpty())
  734. {
  735. menu->setButtonRect(mOverflowBtn);
  736. }
  737. menu->updateParent(LLMenuGL::sMenuContainer);
  738. LLRect rect = mOverflowBtn->getRect();
  739. LLMenuGL::showPopup(this, menu, rect.mRight, rect.mTop);
  740. }
  742. bool LLPanelPlaces::onOverflowMenuItemEnable(const LLSD& param)
  743. {
  744. std::string value = param.asString();
  745. if("can_create_pick" == value)
  746. {
  747. return !LLAgentPicksInfo::getInstance()->isPickLimitReached();
  748. }
  749. return true;
  750. }
  752. void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
  753. {
  754. std::string item = param.asString();
  755. if (item == "landmark")
  756. {
  757. LLSD key;
  758. key["type"] = CREATE_LANDMARK_INFO_TYPE;
  759. key["x"] = mPosGlobal.mdV[VX];
  760. key["y"] = mPosGlobal.mdV[VY];
  761. key["z"] = mPosGlobal.mdV[VZ];
  762. onOpen(key);
  763. }
  764. else if (item == "copy")
  765. {
  766. LLLandmarkActions::getSLURLfromPosGlobal(mPosGlobal, boost::bind(&onSLURLBuilt, _1));
  767. }
  768. else if (item == "delete")
  769. {
  770. gInventory.removeItem(mItem->getUUID());
  772. onBackButtonClicked();
  773. }
  774. else if (item == "pick")
  775. {
  776. if (mPickPanel == NULL)
  777. {
  778. mPickPanel = LLPanelPickEdit::create();
  779. addChild(mPickPanel);
  781. mPickPanel->setExitCallback(boost::bind(&LLPanelPlaces::togglePickPanel, this, FALSE));
  782. mPickPanel->setCancelCallback(boost::bind(&LLPanelPlaces::togglePickPanel, this, FALSE));
  783. mPickPanel->setSaveCallback(boost::bind(&LLPanelPlaces::togglePickPanel, this, FALSE));
  784. }
  786. togglePickPanel(TRUE);
  787. mPickPanel->onOpen(LLSD());
  789. LLPanelPlaceInfo* panel = getCurrentInfoPanel();
  790. if (panel)
  791. {
  792. panel->createPick(mPosGlobal, mPickPanel);
  793. }
  795. LLRect rect = getRect();
  796. mPickPanel->reshape(rect.getWidth(), rect.getHeight());
  797. mPickPanel->setRect(rect);
  798. }
  799. else if (item == "add_to_favbar")
  800. {
  801. if ( mItem.notNull() )
  802. {
  803. const LLUUID& favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
  804. if ( favorites_id.notNull() )
  805. {
  806. copy_inventory_item(gAgent.getID(),
  807. mItem->getPermissions().getOwner(),
  808. mItem->getUUID(),
  809. favorites_id,
  810. std::string(),
  811. LLPointer<LLInventoryCallback>(NULL));
  812. llinfos << "Copied inventory item #" << mItem->getUUID() << " to favorites." << llendl;
  813. }
  814. }
  815. }
  816. }
  818. void LLPanelPlaces::onBackButtonClicked()
  819. {
  820. togglePlaceInfoPanel(FALSE);
  822. // Resetting mPlaceInfoType when Place Info panel is closed.
  823. mPlaceInfoType = LLStringUtil::null;
  825. isLandmarkEditModeOn = false;
  827. updateVerbs();
  828. }
  830. void LLPanelPlaces::togglePickPanel(BOOL visible)
  831. {
  832. if (mPickPanel)
  833. mPickPanel->setVisible(visible);
  834. }
  836. void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
  837. {
  838. if (!mPlaceProfile || !mLandmarkInfo)
  839. return;
  841. mFilterEditor->setVisible(!visible);
  842. mTabContainer->setVisible(!visible);
  844. if (mPlaceInfoType == AGENT_INFO_TYPE ||
  845. mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
  846. mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
  847. {
  848. mPlaceProfile->setVisible(visible);
  850. if (visible)
  851. {
  852. mPlaceProfile->resetLocation();
  854. // Do not reset location info until mResetInfoTimer has expired
  855. // to avoid text blinking.
  856. mResetInfoTimer.setTimerExpirySec(PLACE_INFO_UPDATE_INTERVAL);
  858. LLRect rect = getRect();
  859. LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
  860. mPlaceProfile->reshape(new_rect.getWidth(), new_rect.getHeight());
  862. mLandmarkInfo->setVisible(FALSE);
  863. }
  864. else if (mPlaceInfoType == AGENT_INFO_TYPE)
  865. {
  866. LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
  868. // Clear reference to parcel selection when closing place profile panel.
  869. // LLViewerParcelMgr removes the selection if it has 1 reference to it.
  870. mParcel.clear();
  871. }
  872. }
  873. else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
  874.  mPlaceInfoType == LANDMARK_INFO_TYPE)
  875. {
  876. mLandmarkInfo->setVisible(visible);
  878. if (visible)
  879. {
  880. mLandmarkInfo->resetLocation();
  882. LLRect rect = getRect();
  883. LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
  884. mLandmarkInfo->reshape(new_rect.getWidth(), new_rect.getHeight());
  886. mPlaceProfile->setVisible(FALSE);
  887. }
  888. else
  889. {
  890. LLLandmarksPanel* landmarks_panel =
  891. dynamic_cast<LLLandmarksPanel*>(mTabContainer->getPanelByName("Landmarks"));
  892. if (landmarks_panel && mItem.notNull())
  893. {
  894. // If a landmark info is being closed we open the landmarks tab
  895. // and set this landmark selected.
  896. mTabContainer->selectTabPanel(landmarks_panel);
  898. landmarks_panel->setItemSelected(mItem->getUUID(), TRUE);
  899. }
  900. }
  901. }
  902. }
  904. // virtual
  905. void LLPanelPlaces::handleVisibilityChange(BOOL new_visibility)
  906. {
  907. LLPanel::handleVisibilityChange(new_visibility);
  909. if (!new_visibility && mPlaceInfoType == AGENT_INFO_TYPE)
  910. {
  911. LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
  913. // Clear reference to parcel selection when closing places panel.
  914. mParcel.clear();
  915. }
  916. }
  918. void LLPanelPlaces::changedParcelSelection()
  919. {
  920. if (!mPlaceProfile)
  921. return;
  923. LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
  924. mParcel = parcel_mgr->getFloatingParcelSelection();
  925. LLParcel* parcel = mParcel->getParcel();
  926. LLViewerRegion* region = parcel_mgr->getSelectionRegion();
  927. if (!region || !parcel)
  928. return;
  930. LLVector3d prev_pos_global = mPosGlobal;
  932. // If agent is inside the selected parcel show agent's region<X, Y, Z>,
  933. // otherwise show region<X, Y, Z> of agent's selection point.
  934. bool is_current_parcel = is_agent_in_selected_parcel(parcel);
  935. if (is_current_parcel)
  936. {
  937. mPosGlobal = gAgent.getPositionGlobal();
  938. }
  939. else
  940. {
  941. LLVector3d pos_global = gViewerWindow->getLastPick().mPosGlobal;
  942. if (!pos_global.isExactlyZero())
  943. {
  944. mPosGlobal = pos_global;
  945. }
  946. }
  948. // Reset location info only if global position has changed
  949. // and update timer has expired to reduce unnecessary text and icons updates.
  950. if (prev_pos_global != mPosGlobal && mResetInfoTimer.hasExpired())
  951. {
  952. mPlaceProfile->resetLocation();
  953. mResetInfoTimer.setTimerExpirySec(PLACE_INFO_UPDATE_INTERVAL);
  954. }
  956. mPlaceProfile->displaySelectedParcelInfo(parcel, region, mPosGlobal, is_current_parcel);
  958. updateVerbs();
  959. }
  961. void LLPanelPlaces::createTabs()
  962. {
  963. if (!(gInventory.isInventoryUsable() && LLTeleportHistory::getInstance()))
  964. return;
  966. LLLandmarksPanel* landmarks_panel = new LLLandmarksPanel();
  967. if (landmarks_panel)
  968. {
  969. landmarks_panel->setPanelPlacesButtons(this);
  971. mTabContainer->addTabPanel(
  972. LLTabContainer::TabPanelParams().
  973. panel(landmarks_panel).
  974. label(getString("landmarks_tab_title")).
  975. insert_at(LLTabContainer::END));
  976. }
  978. LLTeleportHistoryPanel* teleport_history_panel = new LLTeleportHistoryPanel();
  979. if (teleport_history_panel)
  980. {
  981. teleport_history_panel->setPanelPlacesButtons(this);
  983. mTabContainer->addTabPanel(
  984. LLTabContainer::TabPanelParams().
  985. panel(teleport_history_panel).
  986. label(getString("teleport_history_tab_title")).
  987. insert_at(LLTabContainer::END));
  988. }
  990. mTabContainer->selectFirstTab();
  992. mActivePanel = dynamic_cast<LLPanelPlacesTab*>(mTabContainer->getCurrentPanel());
  994. // Filter applied to show all items.
  995. if (mActivePanel)
  996. mActivePanel->onSearchEdit(mActivePanel->getFilterSubString());
  997. }
  999. void LLPanelPlaces::changedGlobalPos(const LLVector3d &global_pos)
  1000. {
  1001. mPosGlobal = global_pos;
  1002. updateVerbs();
  1003. }
  1005. void LLPanelPlaces::showAddedLandmarkInfo(const std::vector<LLUUID>& items)
  1006. {
  1007. for (std::vector<LLUUID>::const_iterator item_iter = items.begin();
  1008.  item_iter != items.end();
  1009.  ++item_iter)
  1010. {
  1011. const LLUUID& item_id = (*item_iter);
  1012. if(!highlight_offered_item(item_id))
  1013. {
  1014. continue;
  1015. }
  1017. LLInventoryItem* item = gInventory.getItem(item_id);
  1019. llassert(item);
  1020. if (item && (LLAssetType::AT_LANDMARK == item->getType()) )
  1021. {
  1022. // Created landmark is passed to Places panel to allow its editing.
  1023. // If the panel is closed we don't reopen it until created landmark is loaded.
  1024. if("create_landmark" == getPlaceInfoType() && !getItem())
  1025. {
  1026. setItem(item);
  1027. }
  1028. }
  1029. }
  1030. }
  1032. void LLPanelPlaces::updateVerbs()
  1033. {
  1034. bool is_place_info_visible;
  1036. LLPanelPlaceInfo* panel = getCurrentInfoPanel();
  1037. if (panel)
  1038. {
  1039. is_place_info_visible = panel->getVisible();
  1040. }
  1041. else
  1042. {
  1043. is_place_info_visible = false;
  1044. }
  1046. bool is_agent_place_info_visible = mPlaceInfoType == AGENT_INFO_TYPE;
  1047. bool is_create_landmark_visible = mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE;
  1048. bool have_3d_pos = ! mPosGlobal.isExactlyZero();
  1050. mTeleportBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
  1051. mShowOnMapBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
  1052. mOverflowBtn->setVisible(is_place_info_visible && !is_create_landmark_visible && !isLandmarkEditModeOn);
  1053. mEditBtn->setVisible(mPlaceInfoType == LANDMARK_INFO_TYPE && !isLandmarkEditModeOn);
  1054. mSaveBtn->setVisible(isLandmarkEditModeOn);
  1055. mCancelBtn->setVisible(isLandmarkEditModeOn);
  1056. mCloseBtn->setVisible(is_create_landmark_visible && !isLandmarkEditModeOn);
  1058. mShowOnMapBtn->setEnabled(!is_create_landmark_visible && !isLandmarkEditModeOn && have_3d_pos);
  1060. if (is_place_info_visible)
  1061. {
  1062. if (is_agent_place_info_visible)
  1063. {
  1064. // We don't need to teleport to the current location
  1065. // so check if the location is not within the current parcel.
  1066. mTeleportBtn->setEnabled(have_3d_pos &&
  1067.  !LLViewerParcelMgr::getInstance()->inAgentParcel(mPosGlobal));
  1068. }
  1069. else if (mPlaceInfoType == LANDMARK_INFO_TYPE || mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
  1070. {
  1071. mTeleportBtn->setEnabled(have_3d_pos);
  1072. }
  1074. // Do not enable landmark info Back button when we are waiting
  1075. // for newly created landmark to load.
  1076. if (!is_create_landmark_visible)
  1077. {
  1078. mLandmarkInfoBackBtn->setEnabled(TRUE);
  1079. }
  1080. }
  1081. else
  1082. {
  1083. if (mActivePanel)
  1084. mActivePanel->updateVerbs();
  1085. }
  1086. }
  1088. LLPanelPlaceInfo* LLPanelPlaces::getCurrentInfoPanel()
  1089. {
  1090. if (mPlaceInfoType == AGENT_INFO_TYPE ||
  1091. mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
  1092. mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
  1093. {
  1094. return mPlaceProfile;
  1095. }
  1096. else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
  1097.  mPlaceInfoType == LANDMARK_INFO_TYPE)
  1098. {
  1099. return mLandmarkInfo;
  1100. }
  1102. return NULL;
  1103. }
  1105. static bool is_agent_in_selected_parcel(LLParcel* parcel)
  1106. {
  1107. LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
  1109. LLViewerRegion* region = parcel_mgr->getSelectionRegion();
  1110. if (!region || !parcel)
  1111. return false;
  1113. return region == gAgent.getRegion() &&
  1114. parcel->getLocalID() == parcel_mgr->getAgentParcel()->getLocalID();
  1115. }
  1117. static void onSLURLBuilt(std::string& slurl)
  1118. {
  1119. LLView::getWindow()->copyTextToClipboard(utf8str_to_wstring(slurl));
  1121. LLSD args;
  1122. args["SLURL"] = slurl;
  1124. LLNotificationsUtil::add("CopySLURL", args);
  1125. }