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

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

游戏引擎

开发平台：

C++ Builder

llpanelobjectinventory.cpp：源码内容
  1. /**
  2.  * @file llsidepanelinventory.cpp
  3.  * @brief LLPanelObjectInventory class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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. //*****************************************************************************
  34. //
  35. // Implementation of the panel inventory - used to view and control a
  36. // task's inventory.
  37. //
  38. //*****************************************************************************
  40. #include "llviewerprecompiledheaders.h"
  42. #include "llpanelobjectinventory.h"
  44. #include "llmenugl.h"
  45. #include "llnotificationsutil.h"
  46. #include "roles_constants.h"
  48. #include "llagent.h"
  49. #include "llcallbacklist.h"
  50. #include "llfloaterbuycurrency.h"
  51. #include "llfloaterreg.h"
  52. #include "llinventorybridge.h"
  53. #include "llinventoryfilter.h"
  54. #include "llinventoryfunctions.h"
  55. #include "llpreviewanim.h"
  56. #include "llpreviewgesture.h"
  57. #include "llpreviewnotecard.h"
  58. #include "llpreviewscript.h"
  59. #include "llpreviewsound.h"
  60. #include "llpreviewtexture.h"
  61. #include "llscrollcontainer.h"
  62. #include "llselectmgr.h"
  63. #include "llsidetray.h"
  64. #include "llstatusbar.h"
  65. #include "lltrans.h"
  66. #include "llviewerassettype.h"
  67. #include "llviewerregion.h"
  68. #include "llviewerobjectlist.h"
  69. #include "llviewermessage.h"
  72. ///----------------------------------------------------------------------------
  73. /// Class LLTaskInvFVBridge
  74. ///----------------------------------------------------------------------------
  76. class LLTaskInvFVBridge : public LLFolderViewEventListener
  77. {
  78. protected:
  79. LLUUID mUUID;
  80. std::string mName;
  81. mutable std::string mDisplayName;
  82. LLPanelObjectInventory* mPanel;
  83. U32 mFlags;
  85. LLInventoryItem* findItem() const;
  87. public:
  88. LLTaskInvFVBridge(
  89. LLPanelObjectInventory* panel,
  90. const LLUUID& uuid,
  91. const std::string& name,
  92. U32 flags=0);
  93. virtual ~LLTaskInvFVBridge( void ) {}
  95. virtual LLFontGL::StyleFlags getLabelStyle() const { return LLFontGL::NORMAL; }
  96. virtual std::string getLabelSuffix() const { return LLStringUtil::null; }
  98. static LLTaskInvFVBridge* createObjectBridge(LLPanelObjectInventory* panel,
  99.  LLInventoryObject* object);
  100. void showProperties();
  101. void buyItem();
  102. S32 getPrice();
  103. static bool commitBuyItem(const LLSD& notification, const LLSD& response);
  105. // LLFolderViewEventListener functionality
  106. virtual const std::string& getName() const;
  107. virtual const std::string& getDisplayName() const;
  108. virtual PermissionMask getPermissionMask() const { return PERM_NONE; }
  109. /*virtual*/ LLFolderType::EType getPreferredType() const { return LLFolderType::FT_NONE; }
  110. virtual const LLUUID& getUUID() const { return mUUID; }
  111. virtual time_t getCreationDate() const;
  112. virtual LLUIImagePtr getIcon() const;
  113. virtual void openItem();
  114. virtual void closeItem() {}
  115. virtual void previewItem();
  116. virtual void selectItem() {}
  117. virtual BOOL isItemRenameable() const;
  118. virtual BOOL renameItem(const std::string& new_name);
  119. virtual BOOL isItemMovable() const;
  120. virtual BOOL isItemRemovable() const;
  121. virtual BOOL removeItem();
  122. virtual void removeBatch(LLDynamicArray<LLFolderViewEventListener*>& batch);
  123. virtual void move(LLFolderViewEventListener* parent_listener);
  124. virtual BOOL isItemCopyable() const;
  125. virtual BOOL copyToClipboard() const;
  126. virtual void cutToClipboard();
  127. virtual BOOL isClipboardPasteable() const;
  128. virtual void pasteFromClipboard();
  129. virtual void pasteLinkFromClipboard();
  130. virtual void buildContextMenu(LLMenuGL& menu, U32 flags);
  131. virtual void performAction(LLFolderView* folder, LLInventoryModel* model, std::string action);
  132. virtual BOOL isUpToDate() const { return TRUE; }
  133. virtual BOOL hasChildren() const { return FALSE; }
  134. virtual LLInventoryType::EType getInventoryType() const { return LLInventoryType::IT_NONE; }
  135. // LLDragAndDropBridge functionality
  136. virtual BOOL startDrag(EDragAndDropType* type, LLUUID* id) const;
  137. virtual BOOL dragOrDrop(MASK mask, BOOL drop,
  138. EDragAndDropType cargo_type,
  139. void* cargo_data);
  140. };
  142. LLTaskInvFVBridge::LLTaskInvFVBridge(
  143. LLPanelObjectInventory* panel,
  144. const LLUUID& uuid,
  145. const std::string& name,
  146. U32 flags):
  147. mUUID(uuid),
  148. mName(name),
  149. mPanel(panel),
  150. mFlags(flags)
  151. {
  153. }
  155. LLInventoryItem* LLTaskInvFVBridge::findItem() const
  156. {
  157. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  158. if(object)
  159. {
  160. return dynamic_cast<LLInventoryItem*>(object->getInventoryObject(mUUID));
  161. }
  162. return NULL;
  163. }
  165. void LLTaskInvFVBridge::showProperties()
  166. {
  167. LLSD key;
  168. key["object"] = mPanel->getTaskUUID();
  169. key["id"] = mUUID;
  170. LLSideTray::getInstance()->showPanel("sidepanel_inventory", key);
  173. // Disable old properties floater; this is replaced by the sidepanel.
  174. /*
  175. LLFloaterProperties* floater = LLFloaterReg::showTypedInstance<LLFloaterProperties>("properties", mUUID);
  176. if (floater)
  177. {
  178. floater->setObjectID(mPanel->getTaskUUID());
  179. }
  180. */
  181. }
  183. struct LLBuyInvItemData
  184. {
  185. LLUUID mTaskID;
  186. LLUUID mItemID;
  187. LLAssetType::EType mType;
  189. LLBuyInvItemData(const LLUUID& task,
  190.  const LLUUID& item,
  191.  LLAssetType::EType type) :
  192. mTaskID(task), mItemID(item), mType(type)
  193. {}
  194. };
  196. void LLTaskInvFVBridge::buyItem()
  197. {
  198. llinfos << "LLTaskInvFVBridge::buyItem()" << llendl;
  199. LLInventoryItem* item = findItem();
  200. if(!item || !item->getSaleInfo().isForSale()) return;
  201. LLBuyInvItemData* inv = new LLBuyInvItemData(mPanel->getTaskUUID(),
  202.  mUUID,
  203.  item->getType());
  205. const LLSaleInfo& sale_info = item->getSaleInfo();
  206. const LLPermissions& perm = item->getPermissions();
  207. const std::string owner_name; // no owner name currently... FIXME?
  209. LLViewerObject* obj;
  210. if( ( obj = gObjectList.findObject( mPanel->getTaskUUID() ) ) && obj->isAttachment() )
  211. {
  212. LLNotificationsUtil::add("Cannot_Purchase_an_Attachment");
  213. llinfos << "Attempt to purchase an attachment" << llendl;
  214. delete inv;
  215. }
  216. else
  217. {
  218.         LLSD args;
  219.         args["PRICE"] = llformat("%d",sale_info.getSalePrice());
  220.         args["OWNER"] = owner_name;
  221.         if (sale_info.getSaleType() != LLSaleInfo::FS_CONTENTS)
  222.         {
  223.          U32 next_owner_mask = perm.getMaskNextOwner();
  224.          args["MODIFYPERM"] = LLTrans::getString((next_owner_mask & PERM_MODIFY) ? "PermYes" : "PermNo");
  225.          args["COPYPERM"] = LLTrans::getString((next_owner_mask & PERM_COPY) ? "PermYes" : "PermNo");
  226.          args["RESELLPERM"] = LLTrans::getString((next_owner_mask & PERM_TRANSFER) ? "PermYes" : "PermNo");
  227.         }
  229. std::string alertdesc;
  230.         switch(sale_info.getSaleType())
  231.         {
  232.           case LLSaleInfo::FS_ORIGINAL:
  233.         alertdesc = owner_name.empty() ? "BuyOriginalNoOwner" : "BuyOriginal";
  234.         break;
  235.           case LLSaleInfo::FS_CONTENTS:
  236.         alertdesc = owner_name.empty() ? "BuyContentsNoOwner" : "BuyContents";
  237.         break;
  238.   case LLSaleInfo::FS_COPY:
  239.           default:
  240.         alertdesc = owner_name.empty() ? "BuyCopyNoOwner" : "BuyCopy";
  241.         break;
  242.         }
  244. LLSD payload;
  245. payload["task_id"] = inv->mTaskID;
  246. payload["item_id"] = inv->mItemID;
  247. payload["type"] = inv->mType;
  248. LLNotificationsUtil::add(alertdesc, args, payload, LLTaskInvFVBridge::commitBuyItem);
  249. }
  250. }
  252. S32 LLTaskInvFVBridge::getPrice()
  253. {
  254. LLInventoryItem* item = findItem();
  255. if(item)
  256. {
  257. return item->getSaleInfo().getSalePrice();
  258. }
  259. else
  260. {
  261. return -1;
  262. }
  263. }
  265. // static
  266. bool LLTaskInvFVBridge::commitBuyItem(const LLSD& notification, const LLSD& response)
  267. {
  268. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  269. if(0 == option)
  270. {
  271. LLViewerObject* object = gObjectList.findObject(notification["payload"]["task_id"].asUUID());
  272. if(!object || !object->getRegion()) return false;
  275. LLMessageSystem* msg = gMessageSystem;
  276. msg->newMessageFast(_PREHASH_BuyObjectInventory);
  277. msg->nextBlockFast(_PREHASH_AgentData);
  278. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  279. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  280. msg->nextBlockFast(_PREHASH_Data);
  281. msg->addUUIDFast(_PREHASH_ObjectID, notification["payload"]["task_id"].asUUID());
  282. msg->addUUIDFast(_PREHASH_ItemID, notification["payload"]["item_id"].asUUID());
  283. msg->addUUIDFast(_PREHASH_FolderID,
  284. gInventory.findCategoryUUIDForType((LLFolderType::EType)notification["payload"]["type"].asInteger()));
  285. msg->sendReliable(object->getRegion()->getHost());
  286. }
  287. return false;
  288. }
  290. const std::string& LLTaskInvFVBridge::getName() const
  291. {
  292. return mName;
  293. }
  295. const std::string& LLTaskInvFVBridge::getDisplayName() const
  296. {
  297. LLInventoryItem* item = findItem();
  299. if(item)
  300. {
  301. if(item->getParentUUID().isNull())
  302. {
  303. if(item->getName() == "Contents")
  304. {
  305. mDisplayName.assign(LLTrans::getString("ViewerObjectContents"));
  306. }
  307. else
  308. {
  309. mDisplayName.assign(item->getName());
  310. }
  311. }
  312. else
  313. {
  314. mDisplayName.assign(item->getName());
  315. }
  316. const LLPermissions& perm(item->getPermissions());
  317. BOOL copy = gAgent.allowOperation(PERM_COPY, perm, GP_OBJECT_MANIPULATE);
  318. BOOL mod  = gAgent.allowOperation(PERM_MODIFY, perm, GP_OBJECT_MANIPULATE);
  319. BOOL xfer = gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE);
  321. if(!copy)
  322. {
  323. mDisplayName.append(LLTrans::getString("no_copy"));
  324. }
  325. if(!mod)
  326. {
  327. mDisplayName.append(LLTrans::getString("no_modify"));
  328. }
  329. if(!xfer)
  330. {
  331. mDisplayName.append(LLTrans::getString("no_transfer"));
  332. }
  333. }
  335. return mDisplayName;
  336. }
  338. // BUG: No creation dates for task inventory
  339. time_t LLTaskInvFVBridge::getCreationDate() const
  340. {
  341. return 0;
  342. }
  344. LLUIImagePtr LLTaskInvFVBridge::getIcon() const
  345. {
  346. BOOL item_is_multi = FALSE;
  347. if ( mFlags & LLInventoryItem::II_FLAGS_OBJECT_HAS_MULTIPLE_ITEMS )
  348. {
  349. item_is_multi = TRUE;
  350. }
  352. return get_item_icon(LLAssetType::AT_OBJECT, LLInventoryType::IT_OBJECT, 0, item_is_multi );
  353. }
  355. void LLTaskInvFVBridge::openItem()
  356. {
  357. // no-op.
  358. lldebugs << "LLTaskInvFVBridge::openItem()" << llendl;
  359. }
  361. void LLTaskInvFVBridge::previewItem()
  362. {
  363. openItem();
  364. }
  366. BOOL LLTaskInvFVBridge::isItemRenameable() const
  367. {
  368. if(gAgent.isGodlike()) return TRUE;
  369. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  370. if(object)
  371. {
  372. LLInventoryItem* item;
  373. item = (LLInventoryItem*)(object->getInventoryObject(mUUID));
  374. if(item && gAgent.allowOperation(PERM_MODIFY, item->getPermissions(),
  375.  GP_OBJECT_MANIPULATE, GOD_LIKE))
  376. {
  377. return TRUE;
  378. }
  379. }
  380. return FALSE;
  381. }
  383. BOOL LLTaskInvFVBridge::renameItem(const std::string& new_name)
  384. {
  385. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  386. if(object)
  387. {
  388. LLViewerInventoryItem* item = NULL;
  389. item = (LLViewerInventoryItem*)object->getInventoryObject(mUUID);
  390. if(item && (gAgent.allowOperation(PERM_MODIFY, item->getPermissions(),
  391. GP_OBJECT_MANIPULATE, GOD_LIKE)))
  392. {
  393. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  394. new_item->rename(new_name);
  395. object->updateInventory(
  396. new_item,
  397. TASK_INVENTORY_ITEM_KEY,
  398. false);
  399. }
  400. }
  401. return TRUE;
  402. }
  404. BOOL LLTaskInvFVBridge::isItemMovable() const
  405. {
  406. //LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  407. //if(object && (object->permModify() || gAgent.isGodlike()))
  408. //{
  409. // return TRUE;
  410. //}
  411. //return FALSE;
  412. return TRUE;
  413. }
  415. BOOL LLTaskInvFVBridge::isItemRemovable() const
  416. {
  417. const LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  418. if(object
  419.    && (object->permModify() || object->permYouOwner()))
  420. {
  421. return TRUE;
  422. }
  423. return FALSE;
  424. }
  426. bool remove_task_inventory_callback(const LLSD& notification, const LLSD& response, LLPanelObjectInventory* panel)
  427. {
  428. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  429. LLViewerObject* object = gObjectList.findObject(notification["payload"]["task_id"].asUUID());
  430. if(option == 0 && object)
  431. {
  432. // yes
  433. LLSD::array_const_iterator list_end = notification["payload"]["inventory_ids"].endArray();
  434. for (LLSD::array_const_iterator list_it = notification["payload"]["inventory_ids"].beginArray();
  435. list_it != list_end; 
  436. ++list_it)
  437. {
  438. object->removeInventory(list_it->asUUID());
  439. }
  441. // refresh the UI.
  442. panel->refresh();
  443. }
  444. return false;
  445. }
  447. // helper for remove
  448. // ! REFACTOR ! two_uuids_list_t is also defined in llinventorybridge.h, but differently.
  449. typedef std::pair<LLUUID, std::list<LLUUID> > panel_two_uuids_list_t;
  450. typedef std::pair<LLPanelObjectInventory*, panel_two_uuids_list_t> remove_data_t;
  451. BOOL LLTaskInvFVBridge::removeItem()
  452. {
  453. if(isItemRemovable() && mPanel)
  454. {
  455. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  456. if(object)
  457. {
  458. if(object->permModify())
  459. {
  460. // just do it.
  461. object->removeInventory(mUUID);
  462. return TRUE;
  463. }
  464. else
  465. {
  466. LLSD payload;
  467. payload["task_id"] = mPanel->getTaskUUID();
  468. payload["inventory_ids"].append(mUUID);
  469. LLNotificationsUtil::add("RemoveItemWarn", LLSD(), payload, boost::bind(&remove_task_inventory_callback, _1, _2, mPanel));
  470. return FALSE;
  471. }
  472. }
  473. }
  474. return FALSE;
  475. }
  477. void LLTaskInvFVBridge::removeBatch(LLDynamicArray<LLFolderViewEventListener*>& batch)
  478. {
  479. if (!mPanel)
  480. {
  481. return;
  482. }
  484. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  485. if (!object)
  486. {
  487. return;
  488. }
  490. if (!object->permModify())
  491. {
  492. LLSD payload;
  493. payload["task_id"] = mPanel->getTaskUUID();
  494. for (S32 i = 0; i < (S32)batch.size(); i++)
  495. {
  496. LLTaskInvFVBridge* itemp = (LLTaskInvFVBridge*)batch[i];
  497. payload["inventory_ids"].append(itemp->getUUID());
  498. }
  499. LLNotificationsUtil::add("RemoveItemWarn", LLSD(), payload, boost::bind(&remove_task_inventory_callback, _1, _2, mPanel));
  501. }
  502. else
  503. {
  504. for (S32 i = 0; i < (S32)batch.size(); i++)
  505. {
  506. LLTaskInvFVBridge* itemp = (LLTaskInvFVBridge*)batch[i];
  508. if(itemp->isItemRemovable())
  509. {
  510. // just do it.
  511. object->removeInventory(itemp->getUUID());
  512. }
  513. }
  514. }
  515. }
  517. void LLTaskInvFVBridge::move(LLFolderViewEventListener* parent_listener)
  518. {
  519. }
  521. BOOL LLTaskInvFVBridge::isItemCopyable() const
  522. {
  523. LLInventoryItem* item = findItem();
  524. if(!item) return FALSE;
  525. return gAgent.allowOperation(PERM_COPY, item->getPermissions(),
  526. GP_OBJECT_MANIPULATE);
  527. }
  529. BOOL LLTaskInvFVBridge::copyToClipboard() const
  530. {
  531. return FALSE;
  532. }
  534. void LLTaskInvFVBridge::cutToClipboard()
  535. {
  536. }
  538. BOOL LLTaskInvFVBridge::isClipboardPasteable() const
  539. {
  540. return FALSE;
  541. }
  543. void LLTaskInvFVBridge::pasteFromClipboard()
  544. {
  545. }
  547. void LLTaskInvFVBridge::pasteLinkFromClipboard()
  548. {
  549. }
  551. BOOL LLTaskInvFVBridge::startDrag(EDragAndDropType* type, LLUUID* id) const
  552. {
  553. //llinfos << "LLTaskInvFVBridge::startDrag()" << llendl;
  554. if(mPanel)
  555. {
  556. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  557. if(object)
  558. {
  559. LLInventoryItem* inv = NULL;
  560. if((inv = (LLInventoryItem*)object->getInventoryObject(mUUID)))
  561. {
  562. const LLPermissions& perm = inv->getPermissions();
  563. bool can_copy = gAgent.allowOperation(PERM_COPY, perm,
  564. GP_OBJECT_MANIPULATE);
  565. if (object->isAttachment() && !can_copy)
  566. {
  567.                     //RN: no copy contents of attachments cannot be dragged out
  568.                     // due to a race condition and possible exploit where
  569.                     // attached objects do not update their inventory items
  570.                     // when their contents are manipulated
  571.                     return FALSE;
  572. }
  573. if((can_copy && perm.allowTransferTo(gAgent.getID()))
  574.    || object->permYouOwner())
  575. //    || gAgent.isGodlike())
  577. {
  578. *type = LLViewerAssetType::lookupDragAndDropType(inv->getType());
  580. *id = inv->getUUID();
  581. return TRUE;
  582. }
  583. }
  584. }
  585. }
  586. return FALSE;
  587. }
  589. BOOL LLTaskInvFVBridge::dragOrDrop(MASK mask, BOOL drop,
  590.    EDragAndDropType cargo_type,
  591.    void* cargo_data)
  592. {
  593. //llinfos << "LLTaskInvFVBridge::dragOrDrop()" << llendl;
  594. return FALSE;
  595. }
  597. // virtual
  598. void LLTaskInvFVBridge::performAction(LLFolderView* folder, LLInventoryModel* model, std::string action)
  599. {
  600. if (action == "task_buy")
  601. {
  602. // Check the price of the item.
  603. S32 price = getPrice();
  604. if (-1 == price)
  605. {
  606. llwarns << "label_buy_task_bridged_item: Invalid price" << llendl;
  607. }
  608. else
  609. {
  610. if (price > 0 && price > gStatusBar->getBalance())
  611. {
  612. LLFloaterBuyCurrency::buyCurrency("This costs", price);
  613. }
  614. else
  615. {
  616. buyItem();
  617. }
  618. }
  619. }
  620. else if (action == "task_open")
  621. {
  622. openItem();
  623. }
  624. else if (action == "task_properties")
  625. {
  626. showProperties();
  627. }
  628. }
  630. void LLTaskInvFVBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
  631. {
  632. LLInventoryItem* item = findItem();
  633. std::vector<std::string> items;
  634. std::vector<std::string> disabled_items;
  636. if (!item)
  637. {
  638. hide_context_entries(menu, items, disabled_items);
  639. return;
  640. }
  642. if(gAgent.allowOperation(PERM_OWNER, item->getPermissions(),
  643.  GP_OBJECT_MANIPULATE)
  644.    && item->getSaleInfo().isForSale())
  645. {
  646. items.push_back(std::string("Task Buy"));
  648. std::string label= LLTrans::getString("Buy");
  649. // Check the price of the item.
  650. S32 price = getPrice();
  651. if (-1 == price)
  652. {
  653. llwarns << "label_buy_task_bridged_item: Invalid price" << llendl;
  654. }
  655. else
  656. {
  657. std::ostringstream info;
  658. info << LLTrans::getString("BuyforL$") << price;
  659. label.assign(info.str());
  660. }
  662. const LLView::child_list_t *list = menu.getChildList();
  663. LLView::child_list_t::const_iterator itor;
  664. for (itor = list->begin(); itor != list->end(); ++itor)
  665. {
  666. std::string name = (*itor)->getName();
  667. LLMenuItemCallGL* menu_itemp = dynamic_cast<LLMenuItemCallGL*>(*itor);
  668. if (name == "Task Buy" && menu_itemp)
  669. {
  670. menu_itemp->setLabel(label);
  671. }
  672. }
  673. }
  674. else
  675. {
  676. items.push_back(std::string("Task Open"));
  677. if (!isItemCopyable())
  678. {
  679. disabled_items.push_back(std::string("Task Open"));
  680. }
  681. }
  682. items.push_back(std::string("Task Properties"));
  683. if(isItemRenameable())
  684. {
  685. items.push_back(std::string("Task Rename"));
  686. }
  687. if(isItemRemovable())
  688. {
  689. items.push_back(std::string("Task Remove"));
  690. }
  692. hide_context_entries(menu, items, disabled_items);
  693. }
  696. ///----------------------------------------------------------------------------
  697. /// Class LLTaskFolderBridge
  698. ///----------------------------------------------------------------------------
  700. class LLTaskCategoryBridge : public LLTaskInvFVBridge
  701. {
  702. public:
  703. LLTaskCategoryBridge(
  704. LLPanelObjectInventory* panel,
  705. const LLUUID& uuid,
  706. const std::string& name);
  708. virtual LLUIImagePtr getIcon() const;
  709. virtual const std::string& getDisplayName() const { return getName(); }
  710. virtual BOOL isItemRenameable() const;
  711. // virtual BOOL isItemCopyable() const { return FALSE; }
  712. virtual BOOL renameItem(const std::string& new_name);
  713. virtual BOOL isItemRemovable() const;
  714. virtual void buildContextMenu(LLMenuGL& menu, U32 flags);
  715. virtual BOOL hasChildren() const;
  716. virtual BOOL startDrag(EDragAndDropType* type, LLUUID* id) const;
  717. virtual BOOL dragOrDrop(MASK mask, BOOL drop,
  718. EDragAndDropType cargo_type,
  719. void* cargo_data);
  720. };
  722. LLTaskCategoryBridge::LLTaskCategoryBridge(
  723. LLPanelObjectInventory* panel,
  724. const LLUUID& uuid,
  725. const std::string& name) :
  726. LLTaskInvFVBridge(panel, uuid, name)
  727. {
  728. }
  730. LLUIImagePtr LLTaskCategoryBridge::getIcon() const
  731. {
  732. return LLUI::getUIImage("Inv_FolderClosed");
  733. }
  735. BOOL LLTaskCategoryBridge::isItemRenameable() const
  736. {
  737. return FALSE;
  738. }
  740. BOOL LLTaskCategoryBridge::renameItem(const std::string& new_name)
  741. {
  742. return FALSE;
  743. }
  745. BOOL LLTaskCategoryBridge::isItemRemovable() const
  746. {
  747. return FALSE;
  748. }
  750. void LLTaskCategoryBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
  751. {
  752. std::vector<std::string> items;
  753. std::vector<std::string> disabled_items;
  754. items.push_back(std::string("Task Open"));
  755. hide_context_entries(menu, items, disabled_items);
  756. }
  758. BOOL LLTaskCategoryBridge::hasChildren() const
  759. {
  760. // return TRUE if we have or do know know if we have children.
  761. // *FIX: For now, return FALSE - we will know for sure soon enough.
  762. return FALSE;
  763. }
  765. BOOL LLTaskCategoryBridge::startDrag(EDragAndDropType* type, LLUUID* id) const
  766. {
  767. //llinfos << "LLTaskInvFVBridge::startDrag()" << llendl;
  768. if(mPanel)
  769. {
  770. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  771. if(object)
  772. {
  773. LLInventoryItem* inv = NULL;
  774. if((inv = (LLInventoryItem*)object->getInventoryObject(mUUID)))
  775. {
  776. const LLPermissions& perm = inv->getPermissions();
  777. bool can_copy = gAgent.allowOperation(PERM_COPY, perm,
  778. GP_OBJECT_MANIPULATE);
  779. if((can_copy && perm.allowTransferTo(gAgent.getID()))
  780.    || object->permYouOwner())
  781. //    || gAgent.isGodlike())
  783. {
  784. *type = LLViewerAssetType::lookupDragAndDropType(inv->getType());
  786. *id = inv->getUUID();
  787. return TRUE;
  788. }
  789. }
  790. }
  791. }
  792. return FALSE;
  793. }
  795. BOOL LLTaskCategoryBridge::dragOrDrop(MASK mask, BOOL drop,
  796.   EDragAndDropType cargo_type,
  797.   void* cargo_data)
  798. {
  799. //llinfos << "LLTaskCategoryBridge::dragOrDrop()" << llendl;
  800. BOOL accept = FALSE;
  801. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  802. if(object)
  803. {
  804. switch(cargo_type)
  805. {
  806. case DAD_CATEGORY:
  807. accept = LLToolDragAndDrop::getInstance()->dadUpdateInventoryCategory(object,drop);
  808. break;
  809. case DAD_TEXTURE:
  810. case DAD_SOUND:
  811. case DAD_LANDMARK:
  812. case DAD_OBJECT:
  813. case DAD_NOTECARD:
  814. case DAD_CLOTHING:
  815. case DAD_BODYPART:
  816. case DAD_ANIMATION:
  817. case DAD_GESTURE:
  818. case DAD_CALLINGCARD:
  819. accept = LLToolDragAndDrop::isInventoryDropAcceptable(object, (LLViewerInventoryItem*)cargo_data);
  820. if(accept && drop)
  821. {
  822. LLToolDragAndDrop::dropInventory(object,
  823.  (LLViewerInventoryItem*)cargo_data,
  824.  LLToolDragAndDrop::getInstance()->getSource(),
  825.  LLToolDragAndDrop::getInstance()->getSourceID());
  826. }
  827. break;
  828. case DAD_SCRIPT:
  829. // *HACK: In order to resolve SL-22177, we need to block
  830. // drags from notecards and objects onto other
  831. // objects. uncomment the simpler version when we have
  832. // that right.
  833. //accept = LLToolDragAndDrop::isInventoryDropAcceptable(object, (LLViewerInventoryItem*)cargo_data);
  834. if(LLToolDragAndDrop::isInventoryDropAcceptable(
  835.    object, (LLViewerInventoryItem*)cargo_data)
  836.    && (LLToolDragAndDrop::SOURCE_WORLD != LLToolDragAndDrop::getInstance()->getSource())
  837.    && (LLToolDragAndDrop::SOURCE_NOTECARD != LLToolDragAndDrop::getInstance()->getSource()))
  838. {
  839. accept = TRUE;
  840. }
  841. if(accept && drop)
  842. {
  843. LLViewerInventoryItem* item = (LLViewerInventoryItem*)cargo_data;
  844. // rez in the script active by default, rez in
  845. // inactive if the control key is being held down.
  846. BOOL active = ((mask & MASK_CONTROL) == 0);
  847. LLToolDragAndDrop::dropScript(object, item, active,
  848.   LLToolDragAndDrop::getInstance()->getSource(),
  849.   LLToolDragAndDrop::getInstance()->getSourceID());
  850. }
  851. break;
  852. default:
  853. break;
  854. }
  855. }
  856. return accept;
  857. }
  859. ///----------------------------------------------------------------------------
  860. /// Class LLTaskTextureBridge
  861. ///----------------------------------------------------------------------------
  863. class LLTaskTextureBridge : public LLTaskInvFVBridge
  864. {
  865. public:
  866. LLTaskTextureBridge(
  867. LLPanelObjectInventory* panel,
  868. const LLUUID& uuid,
  869. const std::string& name,
  870. LLInventoryType::EType it);
  872. virtual LLUIImagePtr getIcon() const;
  873. virtual void openItem();
  874. protected:
  875. LLInventoryType::EType mInventoryType;
  876. };
  878. LLTaskTextureBridge::LLTaskTextureBridge(
  879. LLPanelObjectInventory* panel,
  880. const LLUUID& uuid,
  881. const std::string& name,
  882. LLInventoryType::EType it) :
  883. LLTaskInvFVBridge(panel, uuid, name),
  884. mInventoryType(it)
  885. {
  886. }
  888. LLUIImagePtr LLTaskTextureBridge::getIcon() const
  889. {
  890. return get_item_icon(LLAssetType::AT_TEXTURE, mInventoryType, 0, FALSE);
  891. }
  893. void LLTaskTextureBridge::openItem()
  894. {
  895. llinfos << "LLTaskTextureBridge::openItem()" << llendl;
  896. LLPreviewTexture* preview = LLFloaterReg::showTypedInstance<LLPreviewTexture>("preview_texture", LLSD(mUUID), TAKE_FOCUS_YES);
  897. if(preview)
  898. {
  899. preview->setObjectID(mPanel->getTaskUUID());
  900. }
  901. }
  904. ///----------------------------------------------------------------------------
  905. /// Class LLTaskSoundBridge
  906. ///----------------------------------------------------------------------------
  908. class LLTaskSoundBridge : public LLTaskInvFVBridge
  909. {
  910. public:
  911. LLTaskSoundBridge(
  912. LLPanelObjectInventory* panel,
  913. const LLUUID& uuid,
  914. const std::string& name);
  916. virtual LLUIImagePtr getIcon() const;
  917. virtual void openItem();
  918. virtual void performAction(LLFolderView* folder, LLInventoryModel* model, std::string action);
  919. virtual void buildContextMenu(LLMenuGL& menu, U32 flags);
  920. static void openSoundPreview(void* data);
  921. };
  923. LLTaskSoundBridge::LLTaskSoundBridge(
  924. LLPanelObjectInventory* panel,
  925. const LLUUID& uuid,
  926. const std::string& name) :
  927. LLTaskInvFVBridge(panel, uuid, name)
  928. {
  929. }
  931. LLUIImagePtr LLTaskSoundBridge::getIcon() const
  932. {
  933. return get_item_icon(LLAssetType::AT_SOUND, LLInventoryType::IT_SOUND, 0, FALSE);
  934. }
  936. void LLTaskSoundBridge::openItem()
  937. {
  938. openSoundPreview((void*)this);
  939. }
  941. void LLTaskSoundBridge::openSoundPreview(void* data)
  942. {
  943. LLTaskSoundBridge* self = (LLTaskSoundBridge*)data;
  944. if(!self)
  945. return;
  947. LLPreviewSound* preview = LLFloaterReg::showTypedInstance<LLPreviewSound>("preview_sound", LLSD(self->mUUID), TAKE_FOCUS_YES);
  948. if (preview)
  949. {
  950. preview->setObjectID(self->mPanel->getTaskUUID());
  951. }
  952. }
  954. // virtual
  955. void LLTaskSoundBridge::performAction(LLFolderView* folder, LLInventoryModel* model, std::string action)
  956. {
  957. if (action == "task_play")
  958. {
  959. LLInventoryItem* item = findItem();
  960. if(item)
  961. {
  962. send_sound_trigger(item->getAssetUUID(), 1.0);
  963. }
  964. }
  965. LLTaskInvFVBridge::performAction(folder, model, action);
  966. }
  968. void LLTaskSoundBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
  969. {
  970. LLInventoryItem* item = findItem();
  971. if(!item) return;
  972. std::vector<std::string> items;
  973. std::vector<std::string> disabled_items;
  975. if(item->getPermissions().getOwner() != gAgent.getID()
  976.    && item->getSaleInfo().isForSale())
  977. {
  978. items.push_back(std::string("Task Buy"));
  980. std::string label= LLTrans::getString("Buy");
  981. // Check the price of the item.
  982. S32 price = getPrice();
  983. if (-1 == price)
  984. {
  985. llwarns << "label_buy_task_bridged_item: Invalid price" << llendl;
  986. }
  987. else
  988. {
  989. std::ostringstream info;
  990. info <<  LLTrans::getString("BuyforL$") << price;
  991. label.assign(info.str());
  992. }
  994. const LLView::child_list_t *list = menu.getChildList();
  995. LLView::child_list_t::const_iterator itor;
  996. for (itor = list->begin(); itor != list->end(); ++itor)
  997. {
  998. std::string name = (*itor)->getName();
  999. LLMenuItemCallGL* menu_itemp = dynamic_cast<LLMenuItemCallGL*>(*itor);
  1000. if (name == "Task Buy" && menu_itemp)
  1001. {
  1002. menu_itemp->setLabel(label);
  1003. }
  1004. }
  1005. }
  1006. else
  1007. {
  1008. items.push_back(std::string("Task Open")); 
  1009. if (!isItemCopyable())
  1010. {
  1011. disabled_items.push_back(std::string("Task Open"));
  1012. }
  1013. }
  1014. items.push_back(std::string("Task Properties"));
  1015. if(isItemRenameable())
  1016. {
  1017. items.push_back(std::string("Task Rename"));
  1018. }
  1019. if(isItemRemovable())
  1020. {
  1021. items.push_back(std::string("Task Remove"));
  1022. }
  1024. items.push_back(std::string("Task Play"));
  1027. hide_context_entries(menu, items, disabled_items);
  1028. }
  1030. ///----------------------------------------------------------------------------
  1031. /// Class LLTaskLandmarkBridge
  1032. ///----------------------------------------------------------------------------
  1034. class LLTaskLandmarkBridge : public LLTaskInvFVBridge
  1035. {
  1036. public:
  1037. LLTaskLandmarkBridge(
  1038. LLPanelObjectInventory* panel,
  1039. const LLUUID& uuid,
  1040. const std::string& name);
  1042. virtual LLUIImagePtr getIcon() const;
  1043. };
  1045. LLTaskLandmarkBridge::LLTaskLandmarkBridge(
  1046. LLPanelObjectInventory* panel,
  1047. const LLUUID& uuid,
  1048. const std::string& name) :
  1049. LLTaskInvFVBridge(panel, uuid, name)
  1050. {
  1051. }
  1053. LLUIImagePtr LLTaskLandmarkBridge::getIcon() const
  1054. {
  1055. return get_item_icon(LLAssetType::AT_LANDMARK, LLInventoryType::IT_LANDMARK, 0, FALSE);
  1056. }
  1059. ///----------------------------------------------------------------------------
  1060. /// Class LLTaskCallingCardBridge
  1061. ///----------------------------------------------------------------------------
  1063. class LLTaskCallingCardBridge : public LLTaskInvFVBridge
  1064. {
  1065. public:
  1066. LLTaskCallingCardBridge(
  1067. LLPanelObjectInventory* panel,
  1068. const LLUUID& uuid,
  1069. const std::string& name);
  1071. virtual LLUIImagePtr getIcon() const;
  1072. virtual BOOL isItemRenameable() const;
  1073. virtual BOOL renameItem(const std::string& new_name);
  1074. };
  1076. LLTaskCallingCardBridge::LLTaskCallingCardBridge(
  1077. LLPanelObjectInventory* panel,
  1078. const LLUUID& uuid,
  1079. const std::string& name) :
  1080. LLTaskInvFVBridge(panel, uuid, name)
  1081. {
  1082. }
  1084. LLUIImagePtr LLTaskCallingCardBridge::getIcon() const
  1085. {
  1086. return get_item_icon(LLAssetType::AT_CALLINGCARD, LLInventoryType::IT_CALLINGCARD, 0, FALSE);
  1087. }
  1089. BOOL LLTaskCallingCardBridge::isItemRenameable() const
  1090. {
  1091. return FALSE;
  1092. }
  1094. BOOL LLTaskCallingCardBridge::renameItem(const std::string& new_name)
  1095. {
  1096. return FALSE;
  1097. }
  1100. ///----------------------------------------------------------------------------
  1101. /// Class LLTaskScriptBridge
  1102. ///----------------------------------------------------------------------------
  1104. class LLTaskScriptBridge : public LLTaskInvFVBridge
  1105. {
  1106. public:
  1107. LLTaskScriptBridge(
  1108. LLPanelObjectInventory* panel,
  1109. const LLUUID& uuid,
  1110. const std::string& name);
  1112. virtual LLUIImagePtr getIcon() const;
  1113. //static BOOL enableIfCopyable( void* userdata );
  1114. };
  1116. LLTaskScriptBridge::LLTaskScriptBridge(
  1117. LLPanelObjectInventory* panel,
  1118. const LLUUID& uuid,
  1119. const std::string& name) :
  1120. LLTaskInvFVBridge(panel, uuid, name)
  1121. {
  1122. }
  1124. LLUIImagePtr LLTaskScriptBridge::getIcon() const
  1125. {
  1126. return get_item_icon(LLAssetType::AT_SCRIPT, LLInventoryType::IT_LSL, 0, FALSE);
  1127. }
  1130. class LLTaskLSLBridge : public LLTaskScriptBridge
  1131. {
  1132. public:
  1133. LLTaskLSLBridge(
  1134. LLPanelObjectInventory* panel,
  1135. const LLUUID& uuid,
  1136. const std::string& name);
  1138. virtual void openItem();
  1139. virtual BOOL removeItem();
  1140. //virtual void buildContextMenu(LLMenuGL& menu);
  1142. //static void copyToInventory(void* userdata);
  1143. };
  1145. LLTaskLSLBridge::LLTaskLSLBridge(
  1146. LLPanelObjectInventory* panel,
  1147. const LLUUID& uuid,
  1148. const std::string& name) :
  1149. LLTaskScriptBridge(panel, uuid, name)
  1150. {
  1151. }
  1153. void LLTaskLSLBridge::openItem()
  1154. {
  1155. llinfos << "LLTaskLSLBridge::openItem() " << mUUID << llendl;
  1156. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  1157. if(!object || object->isInventoryPending())
  1158. {
  1159. return;
  1160. }
  1161. if (object->permModify() || gAgent.isGodlike())
  1162. {
  1163. LLLiveLSLEditor* preview = LLFloaterReg::showTypedInstance<LLLiveLSLEditor>("preview_scriptedit", LLSD(mUUID), TAKE_FOCUS_YES);
  1164. if (preview)
  1165. {
  1166. preview->setObjectID(mPanel->getTaskUUID());
  1167. }
  1168. }
  1169. else
  1170. {
  1171. LLNotificationsUtil::add("CannotOpenScriptObjectNoMod");
  1172. }
  1173. }
  1175. BOOL LLTaskLSLBridge::removeItem()
  1176. {
  1177. LLFloaterReg::hideInstance("preview_scriptedit", LLSD(mUUID));
  1178. return LLTaskInvFVBridge::removeItem();
  1179. }
  1181. ///----------------------------------------------------------------------------
  1182. /// Class LLTaskObjectBridge
  1183. ///----------------------------------------------------------------------------
  1185. class LLTaskObjectBridge : public LLTaskInvFVBridge
  1186. {
  1187. public:
  1188. LLTaskObjectBridge(
  1189. LLPanelObjectInventory* panel,
  1190. const LLUUID& uuid,
  1191. const std::string& name);
  1193. virtual LLUIImagePtr getIcon() const;
  1194. };
  1196. LLTaskObjectBridge::LLTaskObjectBridge(
  1197. LLPanelObjectInventory* panel,
  1198. const LLUUID& uuid,
  1199. const std::string& name) :
  1200. LLTaskInvFVBridge(panel, uuid, name)
  1201. {
  1202. }
  1204. LLUIImagePtr LLTaskObjectBridge::getIcon() const
  1205. {
  1206. BOOL item_is_multi = FALSE;
  1207. if ( mFlags & LLInventoryItem::II_FLAGS_OBJECT_HAS_MULTIPLE_ITEMS )
  1208. {
  1209. item_is_multi = TRUE;
  1210. }
  1212. return get_item_icon(LLAssetType::AT_OBJECT, LLInventoryType::IT_OBJECT, 0, item_is_multi);
  1213. }
  1215. ///----------------------------------------------------------------------------
  1216. /// Class LLTaskNotecardBridge
  1217. ///----------------------------------------------------------------------------
  1219. class LLTaskNotecardBridge : public LLTaskInvFVBridge
  1220. {
  1221. public:
  1222. LLTaskNotecardBridge(
  1223. LLPanelObjectInventory* panel,
  1224. const LLUUID& uuid,
  1225. const std::string& name);
  1227. virtual LLUIImagePtr getIcon() const;
  1228. virtual void openItem();
  1229. virtual BOOL removeItem();
  1230. };
  1232. LLTaskNotecardBridge::LLTaskNotecardBridge(
  1233. LLPanelObjectInventory* panel,
  1234. const LLUUID& uuid,
  1235. const std::string& name) :
  1236. LLTaskInvFVBridge(panel, uuid, name)
  1237. {
  1238. }
  1240. LLUIImagePtr LLTaskNotecardBridge::getIcon() const
  1241. {
  1242. return get_item_icon(LLAssetType::AT_NOTECARD, LLInventoryType::IT_NOTECARD, 0, FALSE);
  1243. }
  1245. void LLTaskNotecardBridge::openItem()
  1246. {
  1247. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  1248. if(!object || object->isInventoryPending())
  1249. {
  1250. return;
  1251. }
  1252. if(object->permModify() || gAgent.isGodlike())
  1253. {
  1254. LLPreviewNotecard* preview = LLFloaterReg::showTypedInstance<LLPreviewNotecard>("preview_notecard", LLSD(mUUID), TAKE_FOCUS_YES);
  1255. if (preview)
  1256. {
  1257. preview->setObjectID(mPanel->getTaskUUID());
  1258. }
  1259. }
  1260. }
  1262. BOOL LLTaskNotecardBridge::removeItem()
  1263. {
  1264. LLFloaterReg::hideInstance("preview_notecard", LLSD(mUUID));
  1265. return LLTaskInvFVBridge::removeItem();
  1266. }
  1268. ///----------------------------------------------------------------------------
  1269. /// Class LLTaskGestureBridge
  1270. ///----------------------------------------------------------------------------
  1272. class LLTaskGestureBridge : public LLTaskInvFVBridge
  1273. {
  1274. public:
  1275. LLTaskGestureBridge(
  1276. LLPanelObjectInventory* panel,
  1277. const LLUUID& uuid,
  1278. const std::string& name);
  1280. virtual LLUIImagePtr getIcon() const;
  1281. virtual void openItem();
  1282. virtual BOOL removeItem();
  1283. };
  1285. LLTaskGestureBridge::LLTaskGestureBridge(
  1286. LLPanelObjectInventory* panel,
  1287. const LLUUID& uuid,
  1288. const std::string& name) :
  1289. LLTaskInvFVBridge(panel, uuid, name)
  1290. {
  1291. }
  1293. LLUIImagePtr LLTaskGestureBridge::getIcon() const
  1294. {
  1295. return get_item_icon(LLAssetType::AT_GESTURE, LLInventoryType::IT_GESTURE, 0, FALSE);
  1296. }
  1298. void LLTaskGestureBridge::openItem()
  1299. {
  1300. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  1301. if(!object || object->isInventoryPending())
  1302. {
  1303. return;
  1304. }
  1305. LLPreviewGesture::show(mUUID, mPanel->getTaskUUID());
  1306. }
  1308. BOOL LLTaskGestureBridge::removeItem()
  1309. {
  1310. // Don't need to deactivate gesture because gestures inside objects can never be active.
  1311. LLFloaterReg::hideInstance("preview_gesture", LLSD(mUUID));
  1312. return LLTaskInvFVBridge::removeItem();
  1313. }
  1315. ///----------------------------------------------------------------------------
  1316. /// Class LLTaskAnimationBridge
  1317. ///----------------------------------------------------------------------------
  1319. class LLTaskAnimationBridge : public LLTaskInvFVBridge
  1320. {
  1321. public:
  1322. LLTaskAnimationBridge(
  1323. LLPanelObjectInventory* panel,
  1324. const LLUUID& uuid,
  1325. const std::string& name);
  1327. virtual LLUIImagePtr getIcon() const;
  1328. virtual void openItem();
  1329. virtual BOOL removeItem();
  1330. };
  1332. LLTaskAnimationBridge::LLTaskAnimationBridge(
  1333. LLPanelObjectInventory* panel,
  1334. const LLUUID& uuid,
  1335. const std::string& name) :
  1336. LLTaskInvFVBridge(panel, uuid, name)
  1337. {
  1338. }
  1340. LLUIImagePtr LLTaskAnimationBridge::getIcon() const
  1341. {
  1342. return get_item_icon(LLAssetType::AT_ANIMATION, LLInventoryType::IT_ANIMATION, 0, FALSE);
  1343. }
  1345. void LLTaskAnimationBridge::openItem()
  1346. {
  1347. LLViewerObject* object = gObjectList.findObject(mPanel->getTaskUUID());
  1348. if(!object || object->isInventoryPending())
  1349. {
  1350. return;
  1351. }
  1353. LLPreviewAnim* preview = LLFloaterReg::showTypedInstance<LLPreviewAnim>("preview_anim", LLSD(mUUID), TAKE_FOCUS_YES);
  1354. if (preview && (object->permModify() || gAgent.isGodlike()))
  1355. {
  1356. preview->setObjectID(mPanel->getTaskUUID());
  1357. }
  1358. }
  1360. BOOL LLTaskAnimationBridge::removeItem()
  1361. {
  1362. LLFloaterReg::hideInstance("preview_anim", LLSD(mUUID));
  1363. return LLTaskInvFVBridge::removeItem();
  1364. }
  1366. ///----------------------------------------------------------------------------
  1367. /// Class LLTaskWearableBridge
  1368. ///----------------------------------------------------------------------------
  1370. class LLTaskWearableBridge : public LLTaskInvFVBridge
  1371. {
  1372. public:
  1373. LLTaskWearableBridge(
  1374. LLPanelObjectInventory* panel,
  1375. const LLUUID& uuid,
  1376. const std::string& name,
  1377. LLAssetType::EType asset_type,
  1378. U32 flags);
  1380. virtual LLUIImagePtr getIcon() const;
  1382. protected:
  1383. LLAssetType::EType mAssetType;
  1384. };
  1386. LLTaskWearableBridge::LLTaskWearableBridge(
  1387. LLPanelObjectInventory* panel,
  1388. const LLUUID& uuid,
  1389. const std::string& name,
  1390. LLAssetType::EType asset_type,
  1391. U32 flags) :
  1392. LLTaskInvFVBridge(panel, uuid, name, flags),
  1393. mAssetType( asset_type )
  1394. {
  1395. }
  1397. LLUIImagePtr LLTaskWearableBridge::getIcon() const
  1398. {
  1399. return get_item_icon(mAssetType, LLInventoryType::IT_WEARABLE, mFlags, FALSE );
  1400. }
  1403. ///----------------------------------------------------------------------------
  1404. /// LLTaskInvFVBridge impl
  1405. //----------------------------------------------------------------------------
  1407. LLTaskInvFVBridge* LLTaskInvFVBridge::createObjectBridge(LLPanelObjectInventory* panel,
  1408.  LLInventoryObject* object)
  1409. {
  1410. LLTaskInvFVBridge* new_bridge = NULL;
  1411. LLAssetType::EType type = object->getType();
  1412. LLInventoryItem* item = NULL;
  1413. switch(type)
  1414. {
  1415. case LLAssetType::AT_TEXTURE:
  1416. item = (LLInventoryItem*)object;
  1417. new_bridge = new LLTaskTextureBridge(panel,
  1418.  object->getUUID(),
  1419.  object->getName(),
  1420.  item->getInventoryType());
  1421. break;
  1422. case LLAssetType::AT_SOUND:
  1423. new_bridge = new LLTaskSoundBridge(panel,
  1424.    object->getUUID(),
  1425.    object->getName());
  1426. break;
  1427. case LLAssetType::AT_LANDMARK:
  1428. new_bridge = new LLTaskLandmarkBridge(panel,
  1429.   object->getUUID(),
  1430.   object->getName());
  1431. break;
  1432. case LLAssetType::AT_CALLINGCARD:
  1433. new_bridge = new LLTaskCallingCardBridge(panel,
  1434.  object->getUUID(),
  1435.  object->getName());
  1436. break;
  1437. case LLAssetType::AT_SCRIPT:
  1438. // OLD SCRIPTS DEPRECATED - JC
  1439. llwarns << "Old script" << llendl;
  1440. //new_bridge = new LLTaskOldScriptBridge(panel,
  1441. //    object->getUUID(),
  1442. //    object->getName());
  1443. break;
  1444. case LLAssetType::AT_OBJECT:
  1445. new_bridge = new LLTaskObjectBridge(panel,
  1446. object->getUUID(),
  1447. object->getName());
  1448. break;
  1449. case LLAssetType::AT_NOTECARD:
  1450. new_bridge = new LLTaskNotecardBridge(panel,
  1451.   object->getUUID(),
  1452.   object->getName());
  1453. break;
  1454. case LLAssetType::AT_ANIMATION:
  1455. new_bridge = new LLTaskAnimationBridge(panel,
  1456.   object->getUUID(),
  1457.   object->getName());
  1458. break;
  1459. case LLAssetType::AT_GESTURE:
  1460. new_bridge = new LLTaskGestureBridge(panel,
  1461.   object->getUUID(),
  1462.   object->getName());
  1463. break;
  1464. case LLAssetType::AT_CLOTHING:
  1465. case LLAssetType::AT_BODYPART:
  1466. item = (LLInventoryItem*)object;
  1467. new_bridge = new LLTaskWearableBridge(panel,
  1468.   object->getUUID(),
  1469.   object->getName(),
  1470.   type,
  1471.   item->getFlags());
  1472. break;
  1473. case LLAssetType::AT_CATEGORY:
  1474. new_bridge = new LLTaskCategoryBridge(panel,
  1475.   object->getUUID(),
  1476.   object->getName());
  1477. break;
  1478. case LLAssetType::AT_LSL_TEXT:
  1479. new_bridge = new LLTaskLSLBridge(panel,
  1480.  object->getUUID(),
  1481.  object->getName());
  1482. break;
  1484. break;
  1485. default:
  1486. llinfos << "Unhandled inventory type (llassetstorage.h): "
  1487. << (S32)type << llendl;
  1488. break;
  1489. }
  1490. return new_bridge;
  1491. }
  1494. ///----------------------------------------------------------------------------
  1495. /// Class LLPanelObjectInventory
  1496. ///----------------------------------------------------------------------------
  1498. static LLDefaultChildRegistry::Register<LLPanelObjectInventory> r("panel_inventory_object");
  1500. void do_nothing()
  1501. {
  1502. }
  1504. // Default constructor
  1505. LLPanelObjectInventory::LLPanelObjectInventory(const LLPanelObjectInventory::Params& p) :
  1506. LLPanel(p),
  1507. mScroller(NULL),
  1508. mFolders(NULL),
  1509. mHaveInventory(FALSE),
  1510. mIsInventoryEmpty(TRUE),
  1511. mInventoryNeedsUpdate(FALSE)
  1512. {
  1513. // Setup context menu callbacks
  1514. mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelObjectInventory::doToSelected, this, _2));
  1515. mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
  1516. mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
  1517. mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&do_nothing));
  1518. mCommitCallbackRegistrar.add("Inventory.AttachObject", boost::bind(&do_nothing));
  1519. mCommitCallbackRegistrar.add("Inventory.BeginIMSession", boost::bind(&do_nothing));
  1520. }
  1522. // Destroys the object
  1523. LLPanelObjectInventory::~LLPanelObjectInventory()
  1524. {
  1525. if (!gIdleCallbacks.deleteFunction(idle, this))
  1526. {
  1527. llwarns << "LLPanelObjectInventory::~LLPanelObjectInventory() failed to delete callback" << llendl;
  1528. }
  1529. }
  1531. BOOL LLPanelObjectInventory::postBuild()
  1532. {
  1533. // clear contents and initialize menus, sets up mFolders
  1534. reset();
  1536. // Register an idle update callback
  1537. gIdleCallbacks.addFunction(idle, this);
  1539. return TRUE;
  1540. }
  1542. void LLPanelObjectInventory::doToSelected(const LLSD& userdata)
  1543. {
  1544. mFolders->doToSelected(&gInventory, userdata);
  1545. }
  1547. void LLPanelObjectInventory::clearContents()
  1548. {
  1549. mHaveInventory = FALSE;
  1550. mIsInventoryEmpty = TRUE;
  1551. if (LLToolDragAndDrop::getInstance() && LLToolDragAndDrop::getInstance()->getSource() == LLToolDragAndDrop::SOURCE_WORLD)
  1552. {
  1553. LLToolDragAndDrop::getInstance()->endDrag();
  1554. }
  1556. if( mScroller )
  1557. {
  1558. // removes mFolders
  1559. removeChild( mScroller ); //*TODO: Really shouldn't do this during draw()/refresh()
  1560. mScroller->die();
  1561. mScroller = NULL;
  1562. mFolders = NULL;
  1563. }
  1564. }
  1567. void LLPanelObjectInventory::reset()
  1568. {
  1569. clearContents();
  1571. //setBorderVisible(FALSE);
  1573. mCommitCallbackRegistrar.pushScope(); // push local callbacks
  1575. LLRect dummy_rect(0, 1, 1, 0);
  1576. LLFolderView::Params p;
  1577. p.name = "task inventory";
  1578. p.task_id = getTaskUUID();
  1579. p.parent_panel = this;
  1580. p.tool_tip= p.name;
  1581. mFolders = LLUICtrlFactory::create<LLFolderView>(p);
  1582. // this ensures that we never say "searching..." or "no items found"
  1583. mFolders->getFilter()->setShowFolderState(LLInventoryFilter::SHOW_ALL_FOLDERS);
  1584. mFolders->setCallbackRegistrar(&mCommitCallbackRegistrar);
  1586. LLRect scroller_rect(0, getRect().getHeight(), getRect().getWidth(), 0);
  1587. LLScrollContainer::Params scroll_p;
  1588. scroll_p.name("task inventory scroller");
  1589. scroll_p.rect(scroller_rect);
  1590. scroll_p.follows.flags(FOLLOWS_ALL);
  1591. mScroller = LLUICtrlFactory::create<LLScrollContainer>(scroll_p);
  1592. addChild(mScroller);
  1593. mScroller->addChild(mFolders);
  1595. mFolders->setScrollContainer( mScroller );
  1597. mCommitCallbackRegistrar.popScope();
  1598. }
  1600. void LLPanelObjectInventory::inventoryChanged(LLViewerObject* object,
  1601. InventoryObjectList* inventory,
  1602. S32 serial_num,
  1603. void* data)
  1604. {
  1605. if(!object) return;
  1607. //llinfos << "invetnory arrived: n"
  1608. // << " panel UUID: " << panel->mTaskUUID << "n"
  1609. // << " task  UUID: " << object->mID << llendl;
  1610. if(mTaskUUID == object->mID)
  1611. {
  1612. mInventoryNeedsUpdate = TRUE;
  1613. }
  1615. // refresh any properties floaters that are hanging around.
  1616. if(inventory)
  1617. {
  1618. for (InventoryObjectList::const_iterator iter = inventory->begin();
  1619.  iter != inventory->end(); )
  1620. {
  1621. LLInventoryObject* item = *iter++;
  1622. LLFloaterProperties* floater = LLFloaterReg::findTypedInstance<LLFloaterProperties>("properites", item->getUUID());
  1623. if(floater)
  1624. {
  1625. floater->refresh();
  1626. }
  1627. }
  1628. }
  1629. }
  1631. void LLPanelObjectInventory::updateInventory()
  1632. {
  1633. //llinfos << "inventory arrived: n"
  1634. // << " panel UUID: " << panel->mTaskUUID << "n"
  1635. // << " task  UUID: " << object->mID << llendl;
  1636. // We're still interested in this task's inventory.
  1637. std::set<LLUUID> selected_items;
  1638. BOOL inventory_has_focus = FALSE;
  1639. if (mHaveInventory && mFolders->getNumSelectedDescendants())
  1640. {
  1641. mFolders->getSelectionList(selected_items);
  1642. inventory_has_focus = gFocusMgr.childHasKeyboardFocus(mFolders);
  1643. }
  1645. reset();
  1647. LLViewerObject* objectp = gObjectList.findObject(mTaskUUID);
  1648. if (objectp)
  1649. {
  1650. LLInventoryObject* inventory_root = objectp->getInventoryRoot();
  1651. InventoryObjectList contents;
  1652. objectp->getInventoryContents(contents);
  1653. if (inventory_root)
  1654. {
  1655. createFolderViews(inventory_root, contents);
  1656. mHaveInventory = TRUE;
  1657. mIsInventoryEmpty = FALSE;
  1658. mFolders->setEnabled(TRUE);
  1659. }
  1660. else
  1661. {
  1662. // TODO: create an empty inventory
  1663. mIsInventoryEmpty = TRUE;
  1664. mHaveInventory = TRUE;
  1665. }
  1666. }
  1667. else
  1668. {
  1669. // TODO: create an empty inventory
  1670. mIsInventoryEmpty = TRUE;
  1671. mHaveInventory = TRUE;
  1672. }
  1674. // restore previous selection
  1675. std::set<LLUUID>::iterator selection_it;
  1676. BOOL first_item = TRUE;
  1677. for (selection_it = selected_items.begin(); selection_it != selected_items.end(); ++selection_it)
  1678. {
  1679. LLFolderViewItem* selected_item = mFolders->getItemByID(*selection_it);
  1680. if (selected_item)
  1681. {
  1682. //HACK: "set" first item then "change" each other one to get keyboard focus right
  1683. if (first_item)
  1684. {
  1685. mFolders->setSelection(selected_item, TRUE, inventory_has_focus);
  1686. first_item = FALSE;
  1687. }
  1688. else
  1689. {
  1690. mFolders->changeSelection(selected_item, TRUE);
  1691. }
  1692. }
  1693. }
  1695. mFolders->requestArrange();
  1696. mInventoryNeedsUpdate = FALSE;
  1697. // Edit menu handler is set in onFocusReceived
  1698. }
  1700. // *FIX: This is currently a very expensive operation, because we have
  1701. // to iterate through the inventory one time for each category. This
  1702. // leads to an N^2 based on the category count. This could be greatly
  1703. // speeded with an efficient multimap implementation, but we don't
  1704. // have that in our current arsenal.
  1705. void LLPanelObjectInventory::createFolderViews(LLInventoryObject* inventory_root, InventoryObjectList& contents)
  1706. {
  1707. if (!inventory_root)
  1708. {
  1709. return;
  1710. }
  1711. // Create a visible root category.
  1712. LLTaskInvFVBridge* bridge = NULL;
  1713. bridge = LLTaskInvFVBridge::createObjectBridge(this, inventory_root);
  1714. if(bridge)
  1715. {
  1716. LLFolderViewFolder* new_folder = NULL;
  1717. LLFolderViewFolder::Params p;
  1718. p.name = inventory_root->getName();
  1719. p.icon = LLUI::getUIImage("Inv_FolderClosed");
  1720. p.icon_open = LLUI::getUIImage("Inv_FolderOpen");
  1721. p.root = mFolders;
  1722. p.listener = bridge;
  1723. p.tool_tip = p.name;
  1724. new_folder = LLUICtrlFactory::create<LLFolderViewFolder>(p);
  1725. new_folder->addToFolder(mFolders, mFolders);
  1726. new_folder->toggleOpen();
  1728. createViewsForCategory(&contents, inventory_root, new_folder);
  1729. }
  1730. }
  1732. typedef std::pair<LLInventoryObject*, LLFolderViewFolder*> obj_folder_pair;
  1734. void LLPanelObjectInventory::createViewsForCategory(InventoryObjectList* inventory, 
  1735.   LLInventoryObject* parent,
  1736.   LLFolderViewFolder* folder)
  1737. {
  1738. // Find all in the first pass
  1739. LLDynamicArray<obj_folder_pair*> child_categories;
  1740. LLTaskInvFVBridge* bridge;
  1741. LLFolderViewItem* view;
  1743. InventoryObjectList::iterator it = inventory->begin();
  1744. InventoryObjectList::iterator end = inventory->end();
  1745. for( ; it != end; ++it)
  1746. {
  1747. LLInventoryObject* obj = *it;
  1749. if(parent->getUUID() == obj->getParentUUID())
  1750. {
  1751. bridge = LLTaskInvFVBridge::createObjectBridge(this, obj);
  1752. if(!bridge)
  1753. {
  1754. continue;
  1755. }
  1756. if(LLAssetType::AT_CATEGORY == obj->getType())
  1757. {
  1758. LLFolderViewFolder::Params p;
  1759. p.name = obj->getName();
  1760. p.icon = LLUI::getUIImage("Inv_FolderClosed");
  1761. p.icon_open = LLUI::getUIImage("Inv_FolderOpen");
  1762. p.root = mFolders;
  1763. p.listener = bridge;
  1764. p.tool_tip = p.name;
  1765. view = LLUICtrlFactory::create<LLFolderViewFolder>(p);
  1766. child_categories.put(new obj_folder_pair(obj,
  1767.  (LLFolderViewFolder*)view));
  1768. }
  1769. else
  1770. {
  1771. LLFolderViewItem::Params params;
  1772. params.name(obj->getName());
  1773. params.icon(bridge->getIcon());
  1774. params.creation_date(bridge->getCreationDate());
  1775. params.root(mFolders);
  1776. params.listener(bridge);
  1777. params.rect(LLRect());
  1778. params.tool_tip = params.name;
  1779. view = LLUICtrlFactory::create<LLFolderViewItem> (params);
  1780. }
  1781. view->addToFolder(folder, mFolders);
  1782. }
  1783. }
  1785. // now, for each category, do the second pass
  1786. for(S32 i = 0; i < child_categories.count(); i++)
  1787. {
  1788. createViewsForCategory(inventory, child_categories[i]->first,
  1789.    child_categories[i]->second );
  1790. delete child_categories[i];
  1791. }
  1792. }
  1794. void LLPanelObjectInventory::refresh()
  1795. {
  1796. //llinfos << "LLPanelObjectInventory::refresh()" << llendl;
  1797. BOOL has_inventory = FALSE;
  1798. const BOOL non_root_ok = TRUE;
  1799. LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode(NULL, non_root_ok);
  1800. if(node)
  1801. {
  1802. LLViewerObject* object = node->getObject();
  1803. if(object && ((LLSelectMgr::getInstance()->getSelection()->getRootObjectCount() == 1)
  1804.   || (LLSelectMgr::getInstance()->getSelection()->getObjectCount() == 1)))
  1805. {
  1806. // determine if we need to make a request. Start with a
  1807. // default based on if we have inventory at all.
  1808. BOOL make_request = !mHaveInventory;
  1810. // If the task id is different than what we've stored,
  1811. // then make the request.
  1812. if(mTaskUUID != object->mID)
  1813. {
  1814. mTaskUUID = object->mID;
  1815. make_request = TRUE;
  1817. // This is a new object so pre-emptively clear the contents
  1818. // Otherwise we show the old stuff until the update comes in
  1819. clearContents();
  1821. // Register for updates from this object,
  1822. registerVOInventoryListener(object,NULL);
  1823. }
  1825. // Based on the node information, we may need to dirty the
  1826. // object inventory and get it again.
  1827. if(node->mValid)
  1828. {
  1829. if(node->mInventorySerial != object->getInventorySerial() || object->isInventoryDirty())
  1830. {
  1831. make_request = TRUE;
  1832. }
  1833. }
  1835. // do the request if necessary.
  1836. if(make_request)
  1837. {
  1838. requestVOInventory();
  1839. }
  1840. has_inventory = TRUE;
  1841. }
  1842. }
  1843. if(!has_inventory)
  1844. {
  1845. mTaskUUID = LLUUID::null;
  1846. removeVOInventoryListener();
  1847. clearContents();
  1848. }
  1849. //llinfos << "LLPanelObjectInventory::refresh() " << mTaskUUID << llendl;
  1850. }
  1852. void LLPanelObjectInventory::removeSelectedItem()
  1853. {
  1854. if(mFolders)
  1855. {
  1856. mFolders->removeSelectedItems();
  1857. }
  1858. }
  1860. void LLPanelObjectInventory::startRenamingSelectedItem()
  1861. {
  1862. if(mFolders)
  1863. {
  1864. mFolders->startRenamingSelectedItem();
  1865. }
  1866. }
  1868. void LLPanelObjectInventory::draw()
  1869. {
  1870. LLPanel::draw();
  1872. if(mIsInventoryEmpty)
  1873. {
  1874. if((LLUUID::null != mTaskUUID) && (!mHaveInventory))
  1875. {
  1876. LLFontGL::getFontSansSerif()->renderUTF8(LLTrans::getString("LoadingContents"), 0,
  1877.  (S32)(getRect().getWidth() * 0.5f),
  1878.  10,
  1879.  LLColor4( 1, 1, 1, 1 ),
  1880.  LLFontGL::HCENTER,
  1881.  LLFontGL::BOTTOM);
  1882. }
  1883. else if(mHaveInventory)
  1884. {
  1885. LLFontGL::getFontSansSerif()->renderUTF8(LLTrans::getString("NoContents"), 0,
  1886.  (S32)(getRect().getWidth() * 0.5f),
  1887.  10,
  1888.  LLColor4( 1, 1, 1, 1 ),
  1889.  LLFontGL::HCENTER,
  1890.  LLFontGL::BOTTOM);
  1891. }
  1892. }
  1893. }
  1895. void LLPanelObjectInventory::deleteAllChildren()
  1896. {
  1897. mScroller = NULL;
  1898. mFolders = NULL;
  1899. LLView::deleteAllChildren();
  1900. }
  1902. BOOL LLPanelObjectInventory::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, EDragAndDropType cargo_type, void *cargo_data, EAcceptance *accept, std::string& tooltip_msg)
  1903. {
  1904. if (mFolders && mHaveInventory)
  1905. {
  1906. LLFolderViewItem* folderp = mFolders->getNextFromChild(NULL);
  1907. if (!folderp)
  1908. {
  1909. return FALSE;
  1910. }
  1911. // Try to pass on unmodified mouse coordinates
  1912. S32 local_x = x - mFolders->getRect().mLeft;
  1913. S32 local_y = y - mFolders->getRect().mBottom;
  1915. if (mFolders->pointInView(local_x, local_y))
  1916. {
  1917. return mFolders->handleDragAndDrop(local_x, local_y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
  1918. }
  1919. else
  1920. {
  1921. //force mouse coordinates to be inside folder rectangle
  1922. return mFolders->handleDragAndDrop(5, 1, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
  1923. }
  1924. }
  1925. else
  1926. {
  1927. return FALSE;
  1928. }
  1929. }
  1931. //static
  1932. void LLPanelObjectInventory::idle(void* user_data)
  1933. {
  1934. LLPanelObjectInventory* self = (LLPanelObjectInventory*)user_data;
  1937. if (self->mInventoryNeedsUpdate)
  1938. {
  1939. self->updateInventory();
  1940. }
  1941. }
  1943. void LLPanelObjectInventory::onFocusLost()
  1944. {
  1945. // inventory no longer handles cut/copy/paste/delete
  1946. if (LLEditMenuHandler::gEditMenuHandler == mFolders)
  1947. {
  1948. LLEditMenuHandler::gEditMenuHandler = NULL;
  1949. }
  1951. LLPanel::onFocusLost();
  1952. }
  1954. void LLPanelObjectInventory::onFocusReceived()
  1955. {
  1956. // inventory now handles cut/copy/paste/delete
  1957. LLEditMenuHandler::gEditMenuHandler = mFolders;
  1959. LLPanel::onFocusReceived();
  1960. }