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

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

游戏引擎

开发平台：

C++ Builder

llpanelpicks.cpp：源码内容
  1. /** 
  2.  * @file llpanelpicks.cpp
  3.  * @brief LLPanelPicks and related class implementations
  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 "llpanelpicks.h"
  37. #include "llagent.h"
  38. #include "llagentpicksinfo.h"
  39. #include "llavatarconstants.h"
  40. #include "llcommandhandler.h"
  41. #include "lldispatcher.h"
  42. #include "llflatlistview.h"
  43. #include "llfloaterreg.h"
  44. #include "llfloaterworldmap.h"
  45. #include "llnotificationsutil.h"
  46. #include "lltexturectrl.h"
  47. #include "lltoggleablemenu.h"
  48. #include "lltrans.h"
  49. #include "llviewergenericmessage.h" // send_generic_message
  50. #include "llmenugl.h"
  51. #include "llviewermenu.h"
  52. #include "llregistry.h"
  54. #include "llaccordionctrl.h"
  55. #include "llaccordionctrltab.h"
  56. #include "llavatarpropertiesprocessor.h"
  57. #include "llpanelavatar.h"
  58. #include "llpanelprofile.h"
  59. #include "llpanelpick.h"
  60. #include "llpanelclassified.h"
  61. #include "llsidetray.h"
  63. static const std::string XML_BTN_NEW = "new_btn";
  64. static const std::string XML_BTN_DELETE = "trash_btn";
  65. static const std::string XML_BTN_INFO = "info_btn";
  66. static const std::string XML_BTN_TELEPORT = "teleport_btn";
  67. static const std::string XML_BTN_SHOW_ON_MAP = "show_on_map_btn";
  69. static const std::string PICK_ID("pick_id");
  70. static const std::string PICK_CREATOR_ID("pick_creator_id");
  71. static const std::string PICK_NAME("pick_name");
  73. static const std::string CLASSIFIED_ID("classified_id");
  74. static const std::string CLASSIFIED_NAME("classified_name");
  77. static LLRegisterPanelClassWrapper<LLPanelPicks> t_panel_picks("panel_picks");
  79. class LLClassifiedHandler :
  80. public LLCommandHandler,
  81. public LLAvatarPropertiesObserver
  82. {
  83. public:
  84. // throttle calls from untrusted browsers
  85. LLClassifiedHandler() : LLCommandHandler("classified", UNTRUSTED_THROTTLE) {}
  87. std::set<LLUUID> mClassifiedIds;
  89. bool handle(const LLSD& params, const LLSD& query_map, LLMediaCtrl* web)
  90. {
  91. // handle app/classified/create urls first
  92. if (params.size() == 1 && params[0].asString() == "create")
  93. {
  94. createClassified();
  95. return true;
  96. }
  98. // then handle the general app/classified/{UUID}/{CMD} urls
  99. if (params.size() < 2)
  100. {
  101. return false;
  102. }
  104. // get the ID for the classified
  105. LLUUID classified_id;
  106. if (!classified_id.set(params[0], FALSE))
  107. {
  108. return false;
  109. }
  111. // show the classified in the side tray.
  112. // need to ask the server for more info first though...
  113. const std::string verb = params[1].asString();
  114. if (verb == "about")
  115. {
  116. mClassifiedIds.insert(classified_id);
  117. LLAvatarPropertiesProcessor::getInstance()->addObserver(LLUUID(), this);
  118. LLAvatarPropertiesProcessor::getInstance()->sendClassifiedInfoRequest(classified_id);
  119. return true;
  120. }
  122. return false;
  123. }
  125. void createClassified()
  126. {
  127. // open the new classified panel on the Me > Picks sidetray
  128. LLSD params;
  129. params["id"] = gAgent.getID();
  130. params["open_tab_name"] = "panel_picks";
  131. params["show_tab_panel"] = "create_classified";
  132. LLSideTray::getInstance()->showPanel("panel_me", params);
  133. }
  135. void openClassified(LLAvatarClassifiedInfo* c_info)
  136. {
  137. // open the classified info panel on the Me > Picks sidetray
  138. LLSD params;
  139. params["id"] = c_info->creator_id;
  140. params["open_tab_name"] = "panel_picks";
  141. params["show_tab_panel"] = "classified_details";
  142. params["classified_id"] = c_info->classified_id;
  143. params["classified_avatar_id"] = c_info->creator_id;
  144. params["classified_snapshot_id"] = c_info->snapshot_id;
  145. params["classified_name"] = c_info->name;
  146. params["classified_desc"] = c_info->description;
  147. LLSideTray::getInstance()->showPanel("panel_profile_view", params);
  148. }
  150. /*virtual*/ void processProperties(void* data, EAvatarProcessorType type)
  151. {
  152. if (APT_CLASSIFIED_INFO != type)
  153. {
  154. return;
  155. }
  157. // is this the classified that we asked for?
  158. LLAvatarClassifiedInfo* c_info = static_cast<LLAvatarClassifiedInfo*>(data);
  159. if (!c_info || mClassifiedIds.find(c_info->classified_id) == mClassifiedIds.end())
  160. {
  161. return;
  162. }
  164. // open the detail side tray for this classified
  165. openClassified(c_info);
  167. // remove our observer now that we're done
  168. mClassifiedIds.erase(c_info->classified_id);
  169. LLAvatarPropertiesProcessor::getInstance()->removeObserver(LLUUID(), this);
  170. }
  172. };
  173. LLClassifiedHandler gClassifiedHandler;
  175. //////////////////////////////////////////////////////////////////////////
  177. /**
  178.  * Copy&Pasted from old LLPanelClassified. This class does nothing at the moment.
  179.  * Subscribing to "classifiedclickthrough" removes a few warnings.
  180.  */
  181. class LLClassifiedClickThrough : public LLDispatchHandler
  182. {
  183. public:
  185. // "classifiedclickthrough"
  186. // strings[0] = classified_id
  187. // strings[1] = teleport_clicks
  188. // strings[2] = map_clicks
  189. // strings[3] = profile_clicks
  190. virtual bool operator()(
  191. const LLDispatcher* dispatcher,
  192. const std::string& key,
  193. const LLUUID& invoice,
  194. const sparam_t& strings)
  195. {
  196. if (strings.size() != 4) 
  197. return false;
  199. return true;
  200. }
  201. };
  203. //-----------------------------------------------------------------------------
  204. // LLPanelPicks
  205. //-----------------------------------------------------------------------------
  206. LLPanelPicks::LLPanelPicks()
  207. : LLPanelProfileTab(),
  208. mPopupMenu(NULL),
  209. mProfilePanel(NULL),
  210. mPickPanel(NULL),
  211. mPicksList(NULL),
  212. mClassifiedsList(NULL),
  213. mPanelPickInfo(NULL),
  214. mPanelPickEdit(NULL),
  215. mPlusMenu(NULL),
  216. mPicksAccTab(NULL),
  217. mClassifiedsAccTab(NULL),
  218. mPanelClassifiedInfo(NULL),
  219. mPanelClassifiedEdit(NULL),
  220. mClickThroughDisp(NULL),
  221. mNoClassifieds(false),
  222. mNoPicks(false)
  223. {
  224. mClickThroughDisp = new LLClassifiedClickThrough();
  225. gGenericDispatcher.addHandler("classifiedclickthrough", mClickThroughDisp);
  226. }
  228. LLPanelPicks::~LLPanelPicks()
  229. {
  230. if(getAvatarId().notNull())
  231. {
  232. LLAvatarPropertiesProcessor::getInstance()->removeObserver(getAvatarId(),this);
  233. }
  235. delete mClickThroughDisp;
  236. }
  238. void* LLPanelPicks::create(void* data /* = NULL */)
  239. {
  240. return new LLPanelPicks();
  241. }
  243. void LLPanelPicks::updateData()
  244. {
  245. // Send Picks request only when we need to, not on every onOpen(during tab switch).
  246. if(isDirty())
  247. {
  248. mNoPicks = false;
  249. mNoClassifieds = false;
  251. childSetValue("picks_panel_text", LLTrans::getString("PicksClassifiedsLoadingText"));
  253. mPicksList->clear();
  254. LLAvatarPropertiesProcessor::getInstance()->sendAvatarPicksRequest(getAvatarId());
  256. mClassifiedsList->clear();
  257. LLAvatarPropertiesProcessor::getInstance()->sendAvatarClassifiedsRequest(getAvatarId());
  258. }
  259. }
  261. void LLPanelPicks::processProperties(void* data, EAvatarProcessorType type)
  262. {
  263. if(APT_PICKS == type)
  264. {
  265. LLAvatarPicks* avatar_picks = static_cast<LLAvatarPicks*>(data);
  266. if(avatar_picks && getAvatarId() == avatar_picks->target_id)
  267. {
  268. std::string name, second_name;
  269. gCacheName->getName(getAvatarId(),name,second_name);
  270. childSetTextArg("pick_title", "[NAME]",name);
  272. // Save selection, to be able to edit same item after saving changes. See EXT-3023.
  273. LLUUID selected_id = mPicksList->getSelectedValue()[PICK_ID];
  275. mPicksList->clear();
  277. LLAvatarPicks::picks_list_t::const_iterator it = avatar_picks->picks_list.begin();
  278. for(; avatar_picks->picks_list.end() != it; ++it)
  279. {
  280. LLUUID pick_id = it->first;
  281. std::string pick_name = it->second;
  283. LLPickItem* picture = LLPickItem::create();
  284. picture->childSetAction("info_chevron", boost::bind(&LLPanelPicks::onClickInfo, this));
  285. picture->setPickName(pick_name);
  286. picture->setPickId(pick_id);
  287. picture->setCreatorId(getAvatarId());
  289. LLAvatarPropertiesProcessor::instance().addObserver(getAvatarId(), picture);
  290. picture->update();
  292. LLSD pick_value = LLSD();
  293. pick_value.insert(PICK_ID, pick_id);
  294. pick_value.insert(PICK_NAME, pick_name);
  295. pick_value.insert(PICK_CREATOR_ID, getAvatarId());
  297. mPicksList->addItem(picture, pick_value);
  299. // Restore selection by item id. 
  300. if ( pick_id == selected_id )
  301. mPicksList->selectItemByValue(pick_value);
  303. picture->setDoubleClickCallback(boost::bind(&LLPanelPicks::onDoubleClickPickItem, this, _1));
  304. picture->setRightMouseUpCallback(boost::bind(&LLPanelPicks::onRightMouseUpItem, this, _1, _2, _3, _4));
  305. picture->setMouseUpCallback(boost::bind(&LLPanelPicks::updateButtons, this));
  306. }
  308. showAccordion("tab_picks", mPicksList->size());
  310. resetDirty();
  311. updateButtons();
  312. }
  314. mNoPicks = !mPicksList->size();
  315. }
  316. else if(APT_CLASSIFIEDS == type)
  317. {
  318. LLAvatarClassifieds* c_info = static_cast<LLAvatarClassifieds*>(data);
  319. if(c_info && getAvatarId() == c_info->target_id)
  320. {
  321. mClassifiedsList->clear();
  323. LLAvatarClassifieds::classifieds_list_t::const_iterator it = c_info->classifieds_list.begin();
  324. for(; c_info->classifieds_list.end() != it; ++it)
  325. {
  326. LLAvatarClassifieds::classified_data c_data = *it;
  328. LLClassifiedItem* c_item = new LLClassifiedItem(getAvatarId(), c_data.classified_id);
  329. c_item->childSetAction("info_chevron", boost::bind(&LLPanelPicks::onClickInfo, this));
  330. c_item->setClassifiedName(c_data.name);
  332. LLSD pick_value = LLSD();
  333. pick_value.insert(CLASSIFIED_ID, c_data.classified_id);
  334. pick_value.insert(CLASSIFIED_NAME, c_data.name);
  336. mClassifiedsList->addItem(c_item, pick_value);
  338. c_item->setDoubleClickCallback(boost::bind(&LLPanelPicks::onDoubleClickClassifiedItem, this, _1));
  339. c_item->setRightMouseUpCallback(boost::bind(&LLPanelPicks::onRightMouseUpItem, this, _1, _2, _3, _4));
  340. c_item->setMouseUpCallback(boost::bind(&LLPanelPicks::updateButtons, this));
  341. }
  343. showAccordion("tab_classifieds", mClassifiedsList->size());
  345. resetDirty();
  346. updateButtons();
  347. }
  349. mNoClassifieds = !mClassifiedsList->size();
  350. }
  352. if (mNoPicks && mNoClassifieds)
  353. {
  354. if(getAvatarId() == gAgentID)
  355. {
  356. childSetValue("picks_panel_text", LLTrans::getString("NoPicksClassifiedsText"));
  357. }
  358. else
  359. {
  360. childSetValue("picks_panel_text", LLTrans::getString("NoAvatarPicksClassifiedsText"));
  361. }
  362. }
  363. }
  365. LLPickItem* LLPanelPicks::getSelectedPickItem()
  366. {
  367. LLPanel* selected_item = mPicksList->getSelectedItem();
  368. if (!selected_item) return NULL;
  370. return dynamic_cast<LLPickItem*>(selected_item);
  371. }
  373. LLClassifiedItem* LLPanelPicks::getSelectedClassifiedItem()
  374. {
  375. LLPanel* selected_item = mClassifiedsList->getSelectedItem();
  376. if (!selected_item) 
  377. {
  378. return NULL;
  379. }
  380. return dynamic_cast<LLClassifiedItem*>(selected_item);
  381. }
  383. BOOL LLPanelPicks::postBuild()
  384. {
  385. mPicksList = getChild<LLFlatListView>("picks_list");
  386. mClassifiedsList = getChild<LLFlatListView>("classifieds_list");
  388. mPicksList->setCommitOnSelectionChange(true);
  389. mClassifiedsList->setCommitOnSelectionChange(true);
  391. mPicksList->setCommitCallback(boost::bind(&LLPanelPicks::onListCommit, this, mPicksList));
  392. mClassifiedsList->setCommitCallback(boost::bind(&LLPanelPicks::onListCommit, this, mClassifiedsList));
  394. mPicksList->setNoItemsCommentText(getString("no_picks"));
  395. mClassifiedsList->setNoItemsCommentText(getString("no_classifieds"));
  397. childSetAction(XML_BTN_NEW, boost::bind(&LLPanelPicks::onClickPlusBtn, this));
  398. childSetAction(XML_BTN_DELETE, boost::bind(&LLPanelPicks::onClickDelete, this));
  399. childSetAction(XML_BTN_TELEPORT, boost::bind(&LLPanelPicks::onClickTeleport, this));
  400. childSetAction(XML_BTN_SHOW_ON_MAP, boost::bind(&LLPanelPicks::onClickMap, this));
  401. childSetAction(XML_BTN_INFO, boost::bind(&LLPanelPicks::onClickInfo, this));
  403. mPicksAccTab = getChild<LLAccordionCtrlTab>("tab_picks");
  404. mPicksAccTab->setDropDownStateChangedCallback(boost::bind(&LLPanelPicks::onAccordionStateChanged, this, mPicksAccTab));
  405. mPicksAccTab->setDisplayChildren(true);
  407. mClassifiedsAccTab = getChild<LLAccordionCtrlTab>("tab_classifieds");
  408. mClassifiedsAccTab->setDropDownStateChangedCallback(boost::bind(&LLPanelPicks::onAccordionStateChanged, this, mClassifiedsAccTab));
  409. mClassifiedsAccTab->setDisplayChildren(false);
  411. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registar;
  412. registar.add("Pick.Info", boost::bind(&LLPanelPicks::onClickInfo, this));
  413. registar.add("Pick.Edit", boost::bind(&LLPanelPicks::onClickMenuEdit, this)); 
  414. registar.add("Pick.Teleport", boost::bind(&LLPanelPicks::onClickTeleport, this));
  415. registar.add("Pick.Map", boost::bind(&LLPanelPicks::onClickMap, this));
  416. registar.add("Pick.Delete", boost::bind(&LLPanelPicks::onClickDelete, this));
  417. mPopupMenu = LLUICtrlFactory::getInstance()->createFromFile<LLContextMenu>("menu_picks.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  419. LLUICtrl::CommitCallbackRegistry::ScopedRegistrar plus_registar;
  420. plus_registar.add("Picks.Plus.Action", boost::bind(&LLPanelPicks::onPlusMenuItemClicked, this, _2));
  421. mEnableCallbackRegistrar.add("Picks.Plus.Enable", boost::bind(&LLPanelPicks::isActionEnabled, this, _2));
  422. mPlusMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_picks_plus.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
  424. return TRUE;
  425. }
  427. void LLPanelPicks::onPlusMenuItemClicked(const LLSD& param)
  428. {
  429. std::string value = param.asString();
  431. if("new_pick" == value)
  432. {
  433. createNewPick();
  434. }
  435. else if("new_classified" == value)
  436. {
  437. createNewClassified();
  438. }
  439. }
  441. bool LLPanelPicks::isActionEnabled(const LLSD& userdata) const
  442. {
  443. std::string command_name = userdata.asString();
  445. if (command_name == "new_pick" && LLAgentPicksInfo::getInstance()->isPickLimitReached())
  446. {
  447. return false;
  448. }
  450. return true;
  451. }
  453. void LLPanelPicks::onAccordionStateChanged(const LLAccordionCtrlTab* acc_tab)
  454. {
  455. if(!mPicksAccTab->getDisplayChildren())
  456. {
  457. mPicksList->resetSelection(true);
  458. }
  459. if(!mClassifiedsAccTab->getDisplayChildren())
  460. {
  461. mClassifiedsList->resetSelection(true);
  462. }
  464. updateButtons();
  465. }
  467. void LLPanelPicks::onOpen(const LLSD& key)
  468. {
  469. const LLUUID id(key.asUUID());
  470. BOOL self = (gAgent.getID() == id);
  472. // only agent can edit her picks 
  473. childSetEnabled("edit_panel", self);
  474. childSetVisible("edit_panel", self);
  476. // Disable buttons when viewing profile for first time
  477. if(getAvatarId() != id)
  478. {
  479. childSetEnabled(XML_BTN_INFO,FALSE);
  480. childSetEnabled(XML_BTN_TELEPORT,FALSE);
  481. childSetEnabled(XML_BTN_SHOW_ON_MAP,FALSE);
  482. }
  484. // and see a special title - set as invisible by default in xml file
  485. if (self)
  486. {
  487. childSetVisible("pick_title", !self);
  488. childSetVisible("pick_title_agent", self);
  490. mPopupMenu->setItemVisible("pick_delete", TRUE);
  491. mPopupMenu->setItemVisible("pick_edit", TRUE);
  492. mPopupMenu->setItemVisible("pick_separator", TRUE);
  493. }
  495. if(getAvatarId() != id)
  496. {
  497. showAccordion("tab_picks", false);
  498. showAccordion("tab_classifieds", false);
  500. mPicksList->goToTop();
  501. // Set dummy value to make panel dirty and make it reload picks
  502. setValue(LLSD());
  503. }
  505. LLPanelProfileTab::onOpen(key);
  506. }
  508. void LLPanelPicks::onClosePanel()
  509. {
  510. if (mPanelClassifiedInfo)
  511. {
  512. onPanelClassifiedClose(mPanelClassifiedInfo);
  513. }
  514. if (mPanelPickInfo)
  515. {
  516. onPanelPickClose(mPanelPickInfo);
  517. }
  518. }
  520. void LLPanelPicks::onListCommit(const LLFlatListView* f_list)
  521. {
  522. // Make sure only one of the lists has selection.
  523. if(f_list == mPicksList)
  524. {
  525. mClassifiedsList->resetSelection(true);
  526. }
  527. else if(f_list == mClassifiedsList)
  528. {
  529. mPicksList->resetSelection(true);
  530. }
  531. else
  532. {
  533. llwarns << "Unknown list" << llendl;
  534. }
  536. updateButtons();
  537. }
  539. //static
  540. void LLPanelPicks::onClickDelete()
  541. {
  542. LLSD value = mPicksList->getSelectedValue();
  543. if (value.isDefined())
  544. {
  545. LLSD args; 
  546. args["PICK"] = value[PICK_NAME]; 
  547. LLNotificationsUtil::add("DeleteAvatarPick", args, LLSD(), boost::bind(&LLPanelPicks::callbackDeletePick, this, _1, _2)); 
  548. return;
  549. }
  551. value = mClassifiedsList->getSelectedValue();
  552. if(value.isDefined())
  553. {
  554. LLSD args; 
  555. args["NAME"] = value[CLASSIFIED_NAME]; 
  556. LLNotificationsUtil::add("DeleteClassified", args, LLSD(), boost::bind(&LLPanelPicks::callbackDeleteClassified, this, _1, _2)); 
  557. return;
  558. }
  559. }
  561. bool LLPanelPicks::callbackDeletePick(const LLSD& notification, const LLSD& response) 
  562. {
  563. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  564. LLSD pick_value = mPicksList->getSelectedValue();
  566. if (0 == option)
  567. {
  568. LLAvatarPropertiesProcessor::instance().sendPickDelete(pick_value[PICK_ID]);
  569. mPicksList->removeItemByValue(pick_value);
  570. }
  571. updateButtons();
  572. return false;
  573. }
  575. bool LLPanelPicks::callbackDeleteClassified(const LLSD& notification, const LLSD& response) 
  576. {
  577. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  578. LLSD value = mClassifiedsList->getSelectedValue();
  580. if (0 == option)
  581. {
  582. LLAvatarPropertiesProcessor::instance().sendClassifiedDelete(value[CLASSIFIED_ID]);
  583. mClassifiedsList->removeItemByValue(value);
  584. }
  585. updateButtons();
  586. return false;
  587. }
  589. bool LLPanelPicks::callbackTeleport( const LLSD& notification, const LLSD& response )
  590. {
  591. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  593. if (0 == option)
  594. {
  595. onClickTeleport();
  596. }
  597. return false;
  598. }
  600. //static
  601. void LLPanelPicks::onClickTeleport()
  602. {
  603. LLPickItem* pick_item = getSelectedPickItem();
  604. LLClassifiedItem* c_item = getSelectedClassifiedItem();
  606. LLVector3d pos;
  607. if(pick_item)
  608. pos = pick_item->getPosGlobal();
  609. else if(c_item)
  610. pos = c_item->getPosGlobal();
  612. if (!pos.isExactlyZero())
  613. {
  614. gAgent.teleportViaLocation(pos);
  615. LLFloaterWorldMap::getInstance()->trackLocation(pos);
  616. }
  617. }
  619. //static
  620. void LLPanelPicks::onClickMap()
  621. {
  622. LLPickItem* pick_item = getSelectedPickItem();
  623. LLClassifiedItem* c_item = getSelectedClassifiedItem();
  625. LLVector3d pos;
  626. if (pick_item)
  627. pos = pick_item->getPosGlobal();
  628. else if(c_item)
  629. pos = c_item->getPosGlobal();
  631. LLFloaterWorldMap::getInstance()->trackLocation(pos);
  632. LLFloaterReg::showInstance("world_map", "center");
  633. }
  636. void LLPanelPicks::onRightMouseUpItem(LLUICtrl* item, S32 x, S32 y, MASK mask)
  637. {
  638. updateButtons();
  640. if (mPopupMenu)
  641. {
  642. mPopupMenu->buildDrawLabels();
  643. mPopupMenu->updateParent(LLMenuGL::sMenuContainer);
  644. ((LLContextMenu*)mPopupMenu)->show(x, y);
  645. LLMenuGL::showPopup(item, mPopupMenu, x, y);
  646. }
  647. }
  649. void LLPanelPicks::onDoubleClickPickItem(LLUICtrl* item)
  650. {
  651. LLSD pick_value = mPicksList->getSelectedValue();
  652. if (pick_value.isUndefined()) return;
  654. LLSD args; 
  655. args["PICK"] = pick_value[PICK_NAME]; 
  656. LLNotificationsUtil::add("TeleportToPick", args, LLSD(), boost::bind(&LLPanelPicks::callbackTeleport, this, _1, _2)); 
  657. }
  659. void LLPanelPicks::onDoubleClickClassifiedItem(LLUICtrl* item)
  660. {
  661. LLSD value = mClassifiedsList->getSelectedValue();
  662. if (value.isUndefined()) return;
  664. LLSD args; 
  665. args["CLASSIFIED"] = value[CLASSIFIED_NAME]; 
  666. LLNotificationsUtil::add("TeleportToClassified", args, LLSD(), boost::bind(&LLPanelPicks::callbackTeleport, this, _1, _2)); 
  667. }
  669. void LLPanelPicks::updateButtons()
  670. {
  671. bool has_selected = mPicksList->numSelected() > 0 || mClassifiedsList->numSelected() > 0;
  673. if (getAvatarId() == gAgentID)
  674. {
  675. childSetEnabled(XML_BTN_DELETE, has_selected);
  676. }
  678. childSetEnabled(XML_BTN_INFO, has_selected);
  679. childSetEnabled(XML_BTN_TELEPORT, has_selected);
  680. childSetEnabled(XML_BTN_SHOW_ON_MAP, has_selected);
  681. }
  683. void LLPanelPicks::setProfilePanel(LLPanelProfile* profile_panel)
  684. {
  685. mProfilePanel = profile_panel;
  686. }
  689. void LLPanelPicks::buildPickPanel()
  690. {
  691. //  if (mPickPanel == NULL)
  692. //  {
  693. //  mPickPanel = new LLPanelPick();
  694. //  mPickPanel->setExitCallback(boost::bind(&LLPanelPicks::onPanelPickClose, this, NULL));
  695. //  }
  696. }
  698. void LLPanelPicks::onClickPlusBtn()
  699. {
  700. LLRect rect;
  701. childGetRect(XML_BTN_NEW, rect);
  703. mPlusMenu->updateParent(LLMenuGL::sMenuContainer);
  704. mPlusMenu->setButtonRect(rect, this);
  705. LLMenuGL::showPopup(this, mPlusMenu, rect.mLeft, rect.mTop);
  706. }
  708. void LLPanelPicks::createNewPick()
  709. {
  710. createPickEditPanel();
  712. getProfilePanel()->openPanel(mPanelPickEdit, LLSD());
  713. }
  715. void LLPanelPicks::createNewClassified()
  716. {
  717. createClassifiedEditPanel();
  719. getProfilePanel()->openPanel(mPanelClassifiedEdit, LLSD());
  720. }
  722. void LLPanelPicks::onClickInfo()
  723. {
  724. if(mPicksList->numSelected() > 0)
  725. {
  726. openPickInfo();
  727. }
  728. else if(mClassifiedsList->numSelected() > 0)
  729. {
  730. openClassifiedInfo();
  731. }
  732. }
  734. void LLPanelPicks::openPickInfo()
  735. {
  736. LLSD selected_value = mPicksList->getSelectedValue();
  737. if (selected_value.isUndefined()) return;
  739. LLPickItem* pick = (LLPickItem*)mPicksList->getSelectedItem();
  741. createPickInfoPanel();
  743. LLSD params;
  744. params["pick_id"] = pick->getPickId();
  745. params["avatar_id"] = pick->getCreatorId();
  746. params["snapshot_id"] = pick->getSnapshotId();
  747. params["pick_name"] = pick->getPickName();
  748. params["pick_desc"] = pick->getPickDesc();
  750. getProfilePanel()->openPanel(mPanelPickInfo, params);
  751. }
  753. void LLPanelPicks::openClassifiedInfo()
  754. {
  755. LLSD selected_value = mClassifiedsList->getSelectedValue();
  756. if (selected_value.isUndefined()) return;
  758. LLClassifiedItem* c_item = getSelectedClassifiedItem();
  760. openClassifiedInfo(c_item->getClassifiedId(), c_item->getAvatarId(),
  761.    c_item->getSnapshotId(), c_item->getClassifiedName(),
  762.    c_item->getDescription());
  763. }
  765. void LLPanelPicks::openClassifiedInfo(const LLUUID &classified_id, 
  766.   const LLUUID &avatar_id,
  767.   const LLUUID &snapshot_id,
  768.   const std::string &name, const std::string &desc)
  769. {
  770. createClassifiedInfoPanel();
  772. LLSD params;
  773. params["classified_id"] = classified_id;
  774. params["avatar_id"] = avatar_id;
  775. params["snapshot_id"] = snapshot_id;
  776. params["name"] = name;
  777. params["desc"] = desc;
  779. getProfilePanel()->openPanel(mPanelClassifiedInfo, params);
  780. }
  782. void LLPanelPicks::showAccordion(const std::string& name, bool show)
  783. {
  784. LLAccordionCtrlTab* tab = getChild<LLAccordionCtrlTab>(name);
  785. tab->setVisible(show);
  786. LLAccordionCtrl* acc = getChild<LLAccordionCtrl>("accordion");
  787. acc->arrange();
  788. }
  790. void LLPanelPicks::onPanelPickClose(LLPanel* panel)
  791. {
  792. panel->setVisible(FALSE);
  793. }
  795. void LLPanelPicks::onPanelPickSave(LLPanel* panel)
  796. {
  797. onPanelPickClose(panel);
  798. updateButtons();
  799. }
  801. void LLPanelPicks::onPanelClassifiedSave(LLPanelClassifiedEdit* panel)
  802. {
  803. if(!panel->canClose())
  804. {
  805. return;
  806. }
  808. if(panel->isNew())
  809. {
  810. LLClassifiedItem* c_item = new LLClassifiedItem(getAvatarId(), panel->getClassifiedId());
  812. c_item->setClassifiedName(panel->getClassifiedName());
  813. c_item->setDescription(panel->getDescription());
  814. c_item->setSnapshotId(panel->getSnapshotId());
  816. LLSD c_value;
  817. c_value.insert(CLASSIFIED_ID, c_item->getClassifiedId());
  818. c_value.insert(CLASSIFIED_NAME, c_item->getClassifiedName());
  819. mClassifiedsList->addItem(c_item, c_value, ADD_TOP);
  821. c_item->setDoubleClickCallback(boost::bind(&LLPanelPicks::onDoubleClickClassifiedItem, this, _1));
  822. c_item->setRightMouseUpCallback(boost::bind(&LLPanelPicks::onRightMouseUpItem, this, _1, _2, _3, _4));
  823. c_item->setMouseUpCallback(boost::bind(&LLPanelPicks::updateButtons, this));
  824. c_item->childSetAction("info_chevron", boost::bind(&LLPanelPicks::onClickInfo, this));
  826. // order does matter, showAccordion will invoke arrange for accordions.
  827. mClassifiedsAccTab->changeOpenClose(false);
  828. showAccordion("tab_classifieds", true);
  829. }
  830. else 
  831. {
  832. onPanelClassifiedClose(panel);
  833. return;
  834. }
  836. onPanelPickClose(panel);
  837. updateButtons();
  838. }
  840. void LLPanelPicks::onPanelClassifiedClose(LLPanelClassifiedInfo* panel)
  841. {
  842. if(panel->getInfoLoaded() && !panel->isDirty())
  843. {
  844. std::vector<LLSD> values;
  845. mClassifiedsList->getValues(values);
  846. for(size_t n = 0; n < values.size(); ++n)
  847. {
  848. LLUUID c_id = values[n][CLASSIFIED_ID].asUUID();
  849. if(panel->getClassifiedId() == c_id)
  850. {
  851. LLClassifiedItem* c_item = dynamic_cast<LLClassifiedItem*>(
  852. mClassifiedsList->getItemByValue(values[n]));
  853. llassert(c_item);
  854. if (c_item)
  855. {
  856. c_item->setClassifiedName(panel->getClassifiedName());
  857. c_item->setDescription(panel->getDescription());
  858. c_item->setSnapshotId(panel->getSnapshotId());
  859. }
  860. }
  861. }
  862. }
  864. onPanelPickClose(panel);
  865. updateButtons();
  866. }
  868. void LLPanelPicks::createPickInfoPanel()
  869. {
  870. if(!mPanelPickInfo)
  871. {
  872. mPanelPickInfo = LLPanelPickInfo::create();
  873. mPanelPickInfo->setExitCallback(boost::bind(&LLPanelPicks::onPanelPickClose, this, mPanelPickInfo));
  874. mPanelPickInfo->setEditPickCallback(boost::bind(&LLPanelPicks::onPanelPickEdit, this));
  875. mPanelPickInfo->setVisible(FALSE);
  876. }
  877. }
  879. void LLPanelPicks::createClassifiedInfoPanel()
  880. {
  881. if(!mPanelClassifiedInfo)
  882. {
  883. mPanelClassifiedInfo = LLPanelClassifiedInfo::create();
  884. mPanelClassifiedInfo->setExitCallback(boost::bind(&LLPanelPicks::onPanelClassifiedClose, this, mPanelClassifiedInfo));
  885. mPanelClassifiedInfo->setEditClassifiedCallback(boost::bind(&LLPanelPicks::onPanelClassifiedEdit, this));
  886. mPanelClassifiedInfo->setVisible(FALSE);
  887. }
  888. }
  890. void LLPanelPicks::createClassifiedEditPanel()
  891. {
  892. if(!mPanelClassifiedEdit)
  893. {
  894. mPanelClassifiedEdit = LLPanelClassifiedEdit::create();
  895. mPanelClassifiedEdit->setExitCallback(boost::bind(&LLPanelPicks::onPanelClassifiedClose, this, mPanelClassifiedEdit));
  896. mPanelClassifiedEdit->setSaveCallback(boost::bind(&LLPanelPicks::onPanelClassifiedSave, this, mPanelClassifiedEdit));
  897. mPanelClassifiedEdit->setCancelCallback(boost::bind(&LLPanelPicks::onPanelClassifiedClose, this, mPanelClassifiedEdit));
  898. mPanelClassifiedEdit->setVisible(FALSE);
  899. }
  900. }
  902. void LLPanelPicks::createPickEditPanel()
  903. {
  904. if(!mPanelPickEdit)
  905. {
  906. mPanelPickEdit = LLPanelPickEdit::create();
  907. mPanelPickEdit->setExitCallback(boost::bind(&LLPanelPicks::onPanelPickClose, this, mPanelPickEdit));
  908. mPanelPickEdit->setSaveCallback(boost::bind(&LLPanelPicks::onPanelPickSave, this, mPanelPickEdit));
  909. mPanelPickEdit->setCancelCallback(boost::bind(&LLPanelPicks::onPanelPickClose, this, mPanelPickEdit));
  910. mPanelPickEdit->setVisible(FALSE);
  911. }
  912. }
  914. // void LLPanelPicks::openPickEditPanel(LLPickItem* pick)
  915. // {
  916. //  if(!pick)
  917. //  {
  918. //  return;
  919. //  }
  920. // }
  922. // void LLPanelPicks::openPickInfoPanel(LLPickItem* pick)
  923. // {
  924. //  if(!mPanelPickInfo)
  925. //  {
  926. //  mPanelPickInfo = LLPanelPickInfo::create();
  927. //  mPanelPickInfo->setExitCallback(boost::bind(&LLPanelPicks::onPanelPickClose, this, mPanelPickInfo));
  928. //  mPanelPickInfo->setEditPickCallback(boost::bind(&LLPanelPicks::onPanelPickEdit, this));
  929. //  mPanelPickInfo->setVisible(FALSE);
  930. //  }
  931. // 
  932. //  LLSD params;
  933. //  params["pick_id"] = pick->getPickId();
  934. //  params["avatar_id"] = pick->getCreatorId();
  935. //  params["snapshot_id"] = pick->getSnapshotId();
  936. //  params["pick_name"] = pick->getPickName();
  937. //  params["pick_desc"] = pick->getPickDesc();
  938. // 
  939. //  getProfilePanel()->openPanel(mPanelPickInfo, params);
  940. // }
  942. void LLPanelPicks::onPanelPickEdit()
  943. {
  944. LLSD selected_value = mPicksList->getSelectedValue();
  945. if (selected_value.isUndefined()) return;
  947. LLPickItem* pick = dynamic_cast<LLPickItem*>(mPicksList->getSelectedItem());
  949. createPickEditPanel();
  951. LLSD params;
  952. params["pick_id"] = pick->getPickId();
  953. params["avatar_id"] = pick->getCreatorId();
  954. params["snapshot_id"] = pick->getSnapshotId();
  955. params["pick_name"] = pick->getPickName();
  956. params["pick_desc"] = pick->getPickDesc();
  958. getProfilePanel()->openPanel(mPanelPickEdit, params);
  959. }
  961. void LLPanelPicks::onPanelClassifiedEdit()
  962. {
  963. LLSD selected_value = mClassifiedsList->getSelectedValue();
  964. if (selected_value.isUndefined()) 
  965. {
  966. return;
  967. }
  969. LLClassifiedItem* c_item = dynamic_cast<LLClassifiedItem*>(mClassifiedsList->getSelectedItem());
  971. createClassifiedEditPanel();
  973. LLSD params;
  974. params["classified_id"] = c_item->getClassifiedId();
  975. params["avatar_id"] = c_item->getAvatarId();
  976. params["snapshot_id"] = c_item->getSnapshotId();
  977. params["name"] = c_item->getClassifiedName();
  978. params["desc"] = c_item->getDescription();
  980. getProfilePanel()->openPanel(mPanelClassifiedEdit, params);
  981. }
  983. void LLPanelPicks::onClickMenuEdit()
  984. {
  985. if(getSelectedPickItem())
  986. {
  987. onPanelPickEdit();
  988. }
  989. else if(getSelectedClassifiedItem())
  990. {
  991. onPanelClassifiedEdit();
  992. }
  993. }
  995. inline LLPanelProfile* LLPanelPicks::getProfilePanel()
  996. {
  997. llassert_always(NULL != mProfilePanel);
  998. return mProfilePanel;
  999. }
  1001. //-----------------------------------------------------------------------------
  1002. // LLPanelPicks
  1003. //-----------------------------------------------------------------------------
  1004. LLPickItem::LLPickItem()
  1005. : LLPanel()
  1006. , mPickID(LLUUID::null)
  1007. , mCreatorID(LLUUID::null)
  1008. , mParcelID(LLUUID::null)
  1009. , mSnapshotID(LLUUID::null)
  1010. , mNeedData(true)
  1011. {
  1012. LLUICtrlFactory::getInstance()->buildPanel(this,"panel_pick_list_item.xml");
  1013. }
  1015. LLPickItem::~LLPickItem()
  1016. {
  1017. if (mCreatorID.notNull())
  1018. {
  1019. LLAvatarPropertiesProcessor::instance().removeObserver(mCreatorID, this);
  1020. }
  1022. }
  1024. LLPickItem* LLPickItem::create()
  1025. {
  1026. return new LLPickItem();
  1027. }
  1029. void LLPickItem::init(LLPickData* pick_data)
  1030. {
  1031. setPickDesc(pick_data->desc);
  1032. setSnapshotId(pick_data->snapshot_id);
  1033. mPosGlobal = pick_data->pos_global;
  1034. mSimName = pick_data->sim_name;
  1035. mPickDescription = pick_data->desc;
  1036. mUserName = pick_data->user_name;
  1037. mOriginalName = pick_data->original_name;
  1039. LLTextureCtrl* picture = getChild<LLTextureCtrl>("picture");
  1040. picture->setImageAssetID(pick_data->snapshot_id);
  1041. }
  1043. void LLPickItem::setPickName(const std::string& name)
  1044. {
  1045. mPickName = name;
  1046. childSetValue("picture_name",name);
  1048. }
  1050. const std::string& LLPickItem::getPickName()
  1051. {
  1052. return mPickName;
  1053. }
  1055. const LLUUID& LLPickItem::getCreatorId()
  1056. {
  1057. return mCreatorID;
  1058. }
  1060. const LLUUID& LLPickItem::getSnapshotId()
  1061. {
  1062. return mSnapshotID;
  1063. }
  1065. void LLPickItem::setPickDesc(const std::string& descr)
  1066. {
  1067. childSetValue("picture_descr",descr);
  1068. }
  1070. void LLPickItem::setPickId(const LLUUID& id)
  1071. {
  1072. mPickID = id;
  1073. }
  1075. const LLUUID& LLPickItem::getPickId()
  1076. {
  1077. return mPickID;
  1078. }
  1080. const LLVector3d& LLPickItem::getPosGlobal()
  1081. {
  1082. return mPosGlobal;
  1083. }
  1085. const std::string LLPickItem::getDescription()
  1086. {
  1087. return childGetValue("picture_descr").asString();
  1088. }
  1090. void LLPickItem::update()
  1091. {
  1092. setNeedData(true);
  1093. LLAvatarPropertiesProcessor::instance().sendPickInfoRequest(mCreatorID, mPickID);
  1094. }
  1096. void LLPickItem::processProperties(void *data, EAvatarProcessorType type)
  1097. {
  1098. if (APT_PICK_INFO != type) 
  1099. {
  1100. return;
  1101. }
  1103. LLPickData* pick_data = static_cast<LLPickData *>(data);
  1104. if (!pick_data || mPickID != pick_data->pick_id) 
  1105. {
  1106. return;
  1107. }
  1109. init(pick_data);
  1110. setNeedData(false);
  1111. LLAvatarPropertiesProcessor::instance().removeObserver(mCreatorID, this);
  1112. }
  1114. BOOL LLPickItem::postBuild()
  1115. {
  1116. setMouseEnterCallback(boost::bind(&LLPanelPickInfo::childSetVisible, this, "hovered_icon", true));
  1117. setMouseLeaveCallback(boost::bind(&LLPanelPickInfo::childSetVisible, this, "hovered_icon", false));
  1118. return TRUE;
  1119. }
  1121. void LLPickItem::setValue(const LLSD& value)
  1122. {
  1123. if (!value.isMap()) return;;
  1124. if (!value.has("selected")) return;
  1125. childSetVisible("selected_icon", value["selected"]);
  1126. }
  1128. //////////////////////////////////////////////////////////////////////////
  1129. //////////////////////////////////////////////////////////////////////////
  1130. //////////////////////////////////////////////////////////////////////////
  1132. LLClassifiedItem::LLClassifiedItem(const LLUUID& avatar_id, const LLUUID& classified_id)
  1133.  : LLPanel()
  1134.  , mAvatarId(avatar_id)
  1135.  , mClassifiedId(classified_id)
  1136. {
  1137. LLUICtrlFactory::getInstance()->buildPanel(this,"panel_classifieds_list_item.xml");
  1139. LLAvatarPropertiesProcessor::getInstance()->addObserver(getAvatarId(), this);
  1140. LLAvatarPropertiesProcessor::getInstance()->sendClassifiedInfoRequest(getClassifiedId());
  1141. }
  1143. LLClassifiedItem::~LLClassifiedItem()
  1144. {
  1145. LLAvatarPropertiesProcessor::getInstance()->removeObserver(getAvatarId(), this);
  1146. }
  1148. void LLClassifiedItem::processProperties(void* data, EAvatarProcessorType type)
  1149. {
  1150. if(APT_CLASSIFIED_INFO != type)
  1151. {
  1152. return;
  1153. }
  1155. LLAvatarClassifiedInfo* c_info = static_cast<LLAvatarClassifiedInfo*>(data);
  1156. if( !c_info || c_info->classified_id != getClassifiedId() )
  1157. {
  1158. return;
  1159. }
  1161. setClassifiedName(c_info->name);
  1162. setDescription(c_info->description);
  1163. setSnapshotId(c_info->snapshot_id);
  1164. setPosGlobal(c_info->pos_global);
  1166. LLAvatarPropertiesProcessor::getInstance()->removeObserver(getAvatarId(), this);
  1167. }
  1169. BOOL LLClassifiedItem::postBuild()
  1170. {
  1171. setMouseEnterCallback(boost::bind(&LLPanelPickInfo::childSetVisible, this, "hovered_icon", true));
  1172. setMouseLeaveCallback(boost::bind(&LLPanelPickInfo::childSetVisible, this, "hovered_icon", false));
  1173. return TRUE;
  1174. }
  1176. void LLClassifiedItem::setValue(const LLSD& value)
  1177. {
  1178. if (!value.isMap()) return;;
  1179. if (!value.has("selected")) return;
  1180. childSetVisible("selected_icon", value["selected"]);
  1181. }
  1183. void LLClassifiedItem::setClassifiedName(const std::string& name)
  1184. {
  1185. childSetValue("name", name);
  1186. }
  1188. void LLClassifiedItem::setDescription(const std::string& desc)
  1189. {
  1190. childSetValue("description", desc);
  1191. }
  1193. void LLClassifiedItem::setSnapshotId(const LLUUID& snapshot_id)
  1194. {
  1195. childSetValue("picture", snapshot_id);
  1196. }
  1198. LLUUID LLClassifiedItem::getSnapshotId()
  1199. {
  1200. return childGetValue("picture");
  1201. }
  1203. //EOF