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

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

游戏引擎

开发平台：

C++ Builder

llviewerinventory.cpp：源码内容
  1. /** 
  2.  * @file llviewerinventory.cpp
  3.  * @brief Implementation of the viewer side inventory objects.
  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. #include "llviewerprecompiledheaders.h"
  34. #include "llviewerinventory.h"
  36. #include "llnotificationsutil.h"
  37. #include "llsdserialize.h"
  38. #include "message.h"
  39. #include "indra_constants.h"
  41. #include "llagent.h"
  42. #include "llviewerfoldertype.h"
  43. #include "llfolderview.h"
  44. #include "llviewercontrol.h"
  45. #include "llconsole.h"
  46. #include "llinventorymodel.h"
  47. #include "llgesturemgr.h"
  48. #include "llsidetray.h"
  50. #include "llinventorybridge.h"
  51. #include "llfloaterinventory.h"
  53. #include "llviewerassettype.h"
  54. #include "llviewerregion.h"
  55. #include "llviewerobjectlist.h"
  56. #include "llpreviewgesture.h"
  57. #include "llviewerwindow.h"
  58. #include "lltrans.h"
  59. #include "llappearancemgr.h"
  60. #include "llfloatercustomize.h"
  61. #include "llcommandhandler.h"
  62. #include "llviewermessage.h"
  64. ///----------------------------------------------------------------------------
  65. /// Local function declarations, constants, enums, and typedefs
  66. ///----------------------------------------------------------------------------
  68. class LLInventoryHandler : public LLCommandHandler
  69. {
  70. public:
  71. // requires trusted browser to trigger
  72. LLInventoryHandler() : LLCommandHandler("inventory", UNTRUSTED_THROTTLE) { }
  74. bool handle(const LLSD& params, const LLSD& query_map,
  75. LLMediaCtrl* web)
  76. {
  77. if (params.size() < 1)
  78. {
  79. return false;
  80. }
  82. // support secondlife:///app/inventory/show
  83. if (params[0].asString() == "show")
  84. {
  85. LLSideTray::getInstance()->showPanel("sidepanel_inventory", LLSD());
  86. return true;
  87. }
  89. // otherwise, we need a UUID and a verb...
  90. if (params.size() < 2) 
  91. {
  92. return false;
  93. }
  94. LLUUID inventory_id;
  95. if (!inventory_id.set(params[0], FALSE))
  96. {
  97. return false;
  98. }
  100. const std::string verb = params[1].asString();
  101. if (verb == "select")
  102. {
  103. std::vector<LLUUID> items_to_open;
  104. items_to_open.push_back(inventory_id);
  105. //inventory_handler is just a stub, because we don't know from who this offer
  106. open_inventory_offer(items_to_open, "inventory_handler");
  107. return true;
  108. }
  110. return false;
  111. }
  112. };
  113. LLInventoryHandler gInventoryHandler;
  115. ///----------------------------------------------------------------------------
  116. /// Class LLViewerInventoryItem
  117. ///----------------------------------------------------------------------------
  119. LLViewerInventoryItem::LLViewerInventoryItem(const LLUUID& uuid,
  120.  const LLUUID& parent_uuid,
  121.  const LLPermissions& perm,
  122.  const LLUUID& asset_uuid,
  123.  LLAssetType::EType type,
  124.  LLInventoryType::EType inv_type,
  125.  const std::string& name,
  126.  const std::string& desc,
  127.  const LLSaleInfo& sale_info,
  128.  U32 flags,
  129.  time_t creation_date_utc) :
  130. LLInventoryItem(uuid, parent_uuid, perm, asset_uuid, type, inv_type,
  131. name, desc, sale_info, flags, creation_date_utc),
  132. mIsComplete(TRUE)
  133. {
  134. }
  136. LLViewerInventoryItem::LLViewerInventoryItem(const LLUUID& item_id,
  137.  const LLUUID& parent_id,
  138.  const std::string& name,
  139.  LLInventoryType::EType inv_type) :
  140. LLInventoryItem(),
  141. mIsComplete(FALSE)
  142. {
  143. mUUID = item_id;
  144. mParentUUID = parent_id;
  145. mInventoryType = inv_type;
  146. mName = name;
  147. }
  149. LLViewerInventoryItem::LLViewerInventoryItem() :
  150. LLInventoryItem(),
  151. mIsComplete(FALSE)
  152. {
  153. }
  155. LLViewerInventoryItem::LLViewerInventoryItem(const LLViewerInventoryItem* other) :
  156. LLInventoryItem()
  157. {
  158. copyViewerItem(other);
  159. if (!mIsComplete)
  160. {
  161. llwarns << "LLViewerInventoryItem copy constructor for incomplete item"
  162. << mUUID << llendl;
  163. }
  164. }
  166. LLViewerInventoryItem::LLViewerInventoryItem(const LLInventoryItem *other) :
  167. LLInventoryItem(other),
  168. mIsComplete(TRUE)
  169. {
  170. }
  173. LLViewerInventoryItem::~LLViewerInventoryItem()
  174. {
  175. }
  177. void LLViewerInventoryItem::copyViewerItem(const LLViewerInventoryItem* other)
  178. {
  179. LLInventoryItem::copyItem(other);
  180. mIsComplete = other->mIsComplete;
  181. mTransactionID = other->mTransactionID;
  182. }
  184. // virtual
  185. void LLViewerInventoryItem::copyItem(const LLInventoryItem *other)
  186. {
  187. LLInventoryItem::copyItem(other);
  188. mIsComplete = true;
  189. mTransactionID.setNull();
  190. }
  192. void LLViewerInventoryItem::cloneViewerItem(LLPointer<LLViewerInventoryItem>& newitem) const
  193. {
  194. newitem = new LLViewerInventoryItem(this);
  195. if(newitem.notNull())
  196. {
  197. LLUUID item_id;
  198. item_id.generate();
  199. newitem->setUUID(item_id);
  200. }
  201. }
  203. void LLViewerInventoryItem::removeFromServer()
  204. {
  205. llinfos << "Removing inventory item " << mUUID << " from server."
  206. << llendl;
  208. LLInventoryModel::LLCategoryUpdate up(mParentUUID, -1);
  209. gInventory.accountForUpdate(up);
  211. LLMessageSystem* msg = gMessageSystem;
  212. msg->newMessageFast(_PREHASH_RemoveInventoryItem);
  213. msg->nextBlockFast(_PREHASH_AgentData);
  214. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  215. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID()); 
  216. msg->nextBlockFast(_PREHASH_InventoryData);
  217. msg->addUUIDFast(_PREHASH_ItemID, mUUID);
  218. gAgent.sendReliableMessage();
  219. }
  221. void LLViewerInventoryItem::updateServer(BOOL is_new) const
  222. {
  223. if(!mIsComplete)
  224. {
  225. // *FIX: deal with this better.
  226. // If we're crashing here then the UI is incorrectly enabled.
  227. llerrs << "LLViewerInventoryItem::updateServer() - for incomplete item"
  228.    << llendl;
  229. return;
  230. }
  231. if(gAgent.getID() != mPermissions.getOwner())
  232. {
  233. // *FIX: deal with this better.
  234. llwarns << "LLViewerInventoryItem::updateServer() - for unowned item"
  235. << llendl;
  236. return;
  237. }
  238. LLInventoryModel::LLCategoryUpdate up(mParentUUID, is_new ? 1 : 0);
  239. gInventory.accountForUpdate(up);
  241. LLMessageSystem* msg = gMessageSystem;
  242. msg->newMessageFast(_PREHASH_UpdateInventoryItem);
  243. msg->nextBlockFast(_PREHASH_AgentData);
  244. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  245. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  246. msg->addUUIDFast(_PREHASH_TransactionID, mTransactionID);
  247. msg->nextBlockFast(_PREHASH_InventoryData);
  248. msg->addU32Fast(_PREHASH_CallbackID, 0);
  249. packMessage(msg);
  250. gAgent.sendReliableMessage();
  251. }
  253. void LLViewerInventoryItem::fetchFromServer(void) const
  254. {
  255. if(!mIsComplete)
  256. {
  257. std::string url; 
  259. LLViewerRegion* region = gAgent.getRegion();
  260. // we have to check region. It can be null after region was destroyed. See EXT-245
  261. if (region)
  262. {
  263. if( ALEXANDRIA_LINDEN_ID.getString() == mPermissions.getOwner().getString())
  264. url = region->getCapability("FetchLib");
  265. else
  266. url = region->getCapability("FetchInventory");
  267. }
  268. else
  269. {
  270. llwarns << "Agent Region is absent" << llendl;
  271. }
  273. if (!url.empty())
  274. {
  275. LLSD body;
  276. body["agent_id"] = gAgent.getID();
  277. body["items"][0]["owner_id"] = mPermissions.getOwner();
  278. body["items"][0]["item_id"] = mUUID;
  280. LLHTTPClient::post(url, body, new LLInventoryModel::fetchInventoryResponder(body));
  281. }
  282. else
  283. {
  284. LLMessageSystem* msg = gMessageSystem;
  285. msg->newMessage("FetchInventory");
  286. msg->nextBlock("AgentData");
  287. msg->addUUID("AgentID", gAgent.getID());
  288. msg->addUUID("SessionID", gAgent.getSessionID());
  289. msg->nextBlock("InventoryData");
  290. msg->addUUID("OwnerID", mPermissions.getOwner());
  291. msg->addUUID("ItemID", mUUID);
  292. gAgent.sendReliableMessage();
  293. }
  294. }
  295. else
  296. {
  297. // *FIX: this can be removed after a bit.
  298. llwarns << "request to fetch complete item" << llendl;
  299. }
  300. }
  302. // virtual
  303. BOOL LLViewerInventoryItem::unpackMessage(LLSD item)
  304. {
  305. BOOL rv = LLInventoryItem::fromLLSD(item);
  306. mIsComplete = TRUE;
  307. return rv;
  308. }
  310. // virtual
  311. BOOL LLViewerInventoryItem::unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num)
  312. {
  313. BOOL rv = LLInventoryItem::unpackMessage(msg, block, block_num);
  314. mIsComplete = TRUE;
  315. return rv;
  316. }
  318. void LLViewerInventoryItem::setTransactionID(const LLTransactionID& transaction_id)
  319. {
  320. mTransactionID = transaction_id;
  321. }
  322. // virtual
  323. void LLViewerInventoryItem::packMessage(LLMessageSystem* msg) const
  324. {
  325. msg->addUUIDFast(_PREHASH_ItemID, mUUID);
  326. msg->addUUIDFast(_PREHASH_FolderID, mParentUUID);
  327. mPermissions.packMessage(msg);
  328. msg->addUUIDFast(_PREHASH_TransactionID, mTransactionID);
  329. S8 type = static_cast<S8>(mType);
  330. msg->addS8Fast(_PREHASH_Type, type);
  331. type = static_cast<S8>(mInventoryType);
  332. msg->addS8Fast(_PREHASH_InvType, type);
  333. msg->addU32Fast(_PREHASH_Flags, mFlags);
  334. mSaleInfo.packMessage(msg);
  335. msg->addStringFast(_PREHASH_Name, mName);
  336. msg->addStringFast(_PREHASH_Description, mDescription);
  337. msg->addS32Fast(_PREHASH_CreationDate, mCreationDate);
  338. U32 crc = getCRC32();
  339. msg->addU32Fast(_PREHASH_CRC, crc);
  340. }
  341. // virtual
  342. BOOL LLViewerInventoryItem::importFile(LLFILE* fp)
  343. {
  344. BOOL rv = LLInventoryItem::importFile(fp);
  345. mIsComplete = TRUE;
  346. return rv;
  347. }
  349. // virtual
  350. BOOL LLViewerInventoryItem::importLegacyStream(std::istream& input_stream)
  351. {
  352. BOOL rv = LLInventoryItem::importLegacyStream(input_stream);
  353. mIsComplete = TRUE;
  354. return rv;
  355. }
  357. bool LLViewerInventoryItem::importFileLocal(LLFILE* fp)
  358. {
  359. // TODO: convert all functions that return BOOL to return bool
  360. bool rv = (LLInventoryItem::importFile(fp) ? true : false);
  361. mIsComplete = false;
  362. return rv;
  363. }
  365. bool LLViewerInventoryItem::exportFileLocal(LLFILE* fp) const
  366. {
  367. std::string uuid_str;
  368. fprintf(fp, "tinv_itemt0nt{n");
  369. mUUID.toString(uuid_str);
  370. fprintf(fp, "ttitem_idt%sn", uuid_str.c_str());
  371. mParentUUID.toString(uuid_str);
  372. fprintf(fp, "ttparent_idt%sn", uuid_str.c_str());
  373. mPermissions.exportFile(fp);
  374. fprintf(fp, "tttypet%sn", LLAssetType::lookup(mType));
  375. const std::string inv_type_str = LLInventoryType::lookup(mInventoryType);
  376. if(!inv_type_str.empty()) fprintf(fp, "ttinv_typet%sn", inv_type_str.c_str());
  377. fprintf(fp, "ttnamet%s|n", mName.c_str());
  378. fprintf(fp, "ttcreation_datet%dn", (S32) mCreationDate);
  379. fprintf(fp,"t}n");
  380. return true;
  381. }
  383. void LLViewerInventoryItem::updateParentOnServer(BOOL restamp) const
  384. {
  385. LLMessageSystem* msg = gMessageSystem;
  386. msg->newMessageFast(_PREHASH_MoveInventoryItem);
  387. msg->nextBlockFast(_PREHASH_AgentData);
  388. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  389. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  390. msg->addBOOLFast(_PREHASH_Stamp, restamp);
  391. msg->nextBlockFast(_PREHASH_InventoryData);
  392. msg->addUUIDFast(_PREHASH_ItemID, mUUID);
  393. msg->addUUIDFast(_PREHASH_FolderID, mParentUUID);
  394. msg->addString("NewName", NULL);
  395. gAgent.sendReliableMessage();
  396. }
  398. //void LLViewerInventoryItem::setCloneCount(S32 clones)
  399. //{
  400. // mClones = clones;
  401. //}
  403. //S32 LLViewerInventoryItem::getCloneCount() const
  404. //{
  405. // return mClones;
  406. //}
  408. ///----------------------------------------------------------------------------
  409. /// Class LLViewerInventoryCategory
  410. ///----------------------------------------------------------------------------
  412. LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& uuid,
  413.  const LLUUID& parent_uuid,
  414.  LLFolderType::EType pref,
  415.  const std::string& name,
  416.  const LLUUID& owner_id) :
  417. LLInventoryCategory(uuid, parent_uuid, pref, name),
  418. mOwnerID(owner_id),
  419. mVersion(LLViewerInventoryCategory::VERSION_UNKNOWN),
  420. mDescendentCount(LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)
  421. {
  422. mDescendentsRequested.reset();
  423. }
  425. LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& owner_id) :
  426. mOwnerID(owner_id),
  427. mVersion(LLViewerInventoryCategory::VERSION_UNKNOWN),
  428. mDescendentCount(LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)
  429. {
  430. mDescendentsRequested.reset();
  431. }
  433. LLViewerInventoryCategory::LLViewerInventoryCategory(const LLViewerInventoryCategory* other)
  434. {
  435. copyViewerCategory(other);
  436. }
  438. LLViewerInventoryCategory::~LLViewerInventoryCategory()
  439. {
  440. }
  442. void LLViewerInventoryCategory::copyViewerCategory(const LLViewerInventoryCategory* other)
  443. {
  444. copyCategory(other);
  445. mOwnerID = other->mOwnerID;
  446. mVersion = other->mVersion;
  447. mDescendentCount = other->mDescendentCount;
  448. mDescendentsRequested = other->mDescendentsRequested;
  449. }
  452. void LLViewerInventoryCategory::updateParentOnServer(BOOL restamp) const
  453. {
  454. LLMessageSystem* msg = gMessageSystem;
  455. msg->newMessageFast(_PREHASH_MoveInventoryFolder);
  456. msg->nextBlockFast(_PREHASH_AgentData);
  457. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  458. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  460. msg->addBOOL("Stamp", restamp);
  461. msg->nextBlockFast(_PREHASH_InventoryData);
  462. msg->addUUIDFast(_PREHASH_FolderID, mUUID);
  463. msg->addUUIDFast(_PREHASH_ParentID, mParentUUID);
  464. gAgent.sendReliableMessage();
  465. }
  467. void LLViewerInventoryCategory::updateServer(BOOL is_new) const
  468. {
  469. // communicate that change with the server.
  471. if (LLFolderType::lookupIsProtectedType(mPreferredType))
  472. {
  473. LLNotificationsUtil::add("CannotModifyProtectedCategories");
  474. return;
  475. }
  477. LLInventoryModel::LLCategoryUpdate up(mParentUUID, is_new ? 1 : 0);
  478. gInventory.accountForUpdate(up);
  480. LLMessageSystem* msg = gMessageSystem;
  481. msg->newMessageFast(_PREHASH_UpdateInventoryFolder);
  482. msg->nextBlockFast(_PREHASH_AgentData);
  483. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  484. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  485. msg->nextBlockFast(_PREHASH_FolderData);
  486. packMessage(msg);
  487. gAgent.sendReliableMessage();
  488. }
  490. void LLViewerInventoryCategory::removeFromServer( void )
  491. {
  492. llinfos << "Removing inventory category " << mUUID << " from server."
  493. << llendl;
  494. // communicate that change with the server.
  495. if(LLFolderType::lookupIsProtectedType(mPreferredType))
  496. {
  497. LLNotificationsUtil::add("CannotRemoveProtectedCategories");
  498. return;
  499. }
  501. LLInventoryModel::LLCategoryUpdate up(mParentUUID, -1);
  502. gInventory.accountForUpdate(up);
  504. LLMessageSystem* msg = gMessageSystem;
  505. msg->newMessageFast(_PREHASH_RemoveInventoryFolder);
  506. msg->nextBlockFast(_PREHASH_AgentData);
  507. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  508. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  509. msg->nextBlockFast(_PREHASH_FolderData);
  510. msg->addUUIDFast(_PREHASH_FolderID, mUUID);
  511. gAgent.sendReliableMessage();
  512. }
  514. bool LLViewerInventoryCategory::fetchDescendents()
  515. {
  516. if((VERSION_UNKNOWN == mVersion)
  517.    && mDescendentsRequested.hasExpired()) //Expired check prevents multiple downloads.
  518. {
  519. const F32 FETCH_TIMER_EXPIRY = 10.0f;
  520. mDescendentsRequested.reset();
  521. mDescendentsRequested.setTimerExpirySec(FETCH_TIMER_EXPIRY);
  523. // bitfield
  524. // 1 = by date
  525. // 2 = folders by date
  526. // Need to mask off anything but the first bit.
  527. // This comes from LLInventoryFilter from llfolderview.h
  528. U32 sort_order = gSavedSettings.getU32("InventorySortOrder") & 0x1;
  530. // *NOTE: For bug EXT-2879, originally commented out
  531. // gAgent.getRegion()->getCapability in order to use the old
  532. // message-based system.  This has been uncommented now that
  533. // AIS folks are aware of the issue and have a fix in process.
  534. // see ticket for details.
  536. std::string url = gAgent.getRegion()->getCapability("WebFetchInventoryDescendents");
  537. if (!url.empty()) //Capability found.  Build up LLSD and use it.
  538. {
  539. gInventory.startBackgroundFetch(mUUID);
  540. }
  541. else
  542. { //Deprecated, but if we don't have a capability, use the old system.
  543. llinfos << "WebFetchInventoryDescendents capability not found.  Using deprecated UDP message." << llendl;
  544. LLMessageSystem* msg = gMessageSystem;
  545. msg->newMessage("FetchInventoryDescendents");
  546. msg->nextBlock("AgentData");
  547. msg->addUUID("AgentID", gAgent.getID());
  548. msg->addUUID("SessionID", gAgent.getSessionID());
  549. msg->nextBlock("InventoryData");
  550. msg->addUUID("FolderID", mUUID);
  551. msg->addUUID("OwnerID", mOwnerID);
  553. msg->addS32("SortOrder", sort_order);
  554. msg->addBOOL("FetchFolders", FALSE);
  555. msg->addBOOL("FetchItems", TRUE);
  556. gAgent.sendReliableMessage();
  557. }
  558. return true;
  559. }
  560. return false;
  561. }
  563. bool LLViewerInventoryCategory::importFileLocal(LLFILE* fp)
  564. {
  565. // *NOTE: This buffer size is hard coded into scanf() below.
  566. char buffer[MAX_STRING]; /* Flawfinder: ignore */
  567. char keyword[MAX_STRING]; /* Flawfinder: ignore */
  568. char valuestr[MAX_STRING]; /* Flawfinder: ignore */
  570. keyword[0] = '';
  571. valuestr[0] = '';
  572. while(!feof(fp))
  573. {
  574. if (fgets(buffer, MAX_STRING, fp) == NULL)
  575. {
  576. buffer[0] = '';
  577. }
  579. sscanf( /* Flawfinder: ignore */
  580. buffer, " %254s %254s", keyword, valuestr); 
  581. if(0 == strcmp("{",keyword))
  582. {
  583. continue;
  584. }
  585. if(0 == strcmp("}", keyword))
  586. {
  587. break;
  588. }
  589. else if(0 == strcmp("cat_id", keyword))
  590. {
  591. mUUID.set(valuestr);
  592. }
  593. else if(0 == strcmp("parent_id", keyword))
  594. {
  595. mParentUUID.set(valuestr);
  596. }
  597. else if(0 == strcmp("type", keyword))
  598. {
  599. mType = LLAssetType::lookup(valuestr);
  600. }
  601. else if(0 == strcmp("pref_type", keyword))
  602. {
  603. mPreferredType = LLFolderType::lookup(valuestr);
  604. }
  605. else if(0 == strcmp("name", keyword))
  606. {
  607. //strcpy(valuestr, buffer + strlen(keyword) + 3);
  608. // *NOTE: Not ANSI C, but widely supported.
  609. sscanf( /* Flawfinder: ignore */
  610. buffer, " %254s %254[^|]", keyword, valuestr);
  611. mName.assign(valuestr);
  612. LLStringUtil::replaceNonstandardASCII(mName, ' ');
  613. LLStringUtil::replaceChar(mName, '|', ' ');
  614. }
  615. else if(0 == strcmp("owner_id", keyword))
  616. {
  617. mOwnerID.set(valuestr);
  618. }
  619. else if(0 == strcmp("version", keyword))
  620. {
  621. sscanf(valuestr, "%d", &mVersion);
  622. }
  623. else
  624. {
  625. llwarns << "unknown keyword '" << keyword
  626. << "' in inventory import category "  << mUUID << llendl;
  627. }
  628. }
  629. return true;
  630. }
  632. bool LLViewerInventoryCategory::exportFileLocal(LLFILE* fp) const
  633. {
  634. std::string uuid_str;
  635. fprintf(fp, "tinv_categoryt0nt{n");
  636. mUUID.toString(uuid_str);
  637. fprintf(fp, "ttcat_idt%sn", uuid_str.c_str());
  638. mParentUUID.toString(uuid_str);
  639. fprintf(fp, "ttparent_idt%sn", uuid_str.c_str());
  640. fprintf(fp, "tttypet%sn", LLAssetType::lookup(mType));
  641. fprintf(fp, "ttpref_typet%sn", LLFolderType::lookup(mPreferredType).c_str());
  642. fprintf(fp, "ttnamet%s|n", mName.c_str());
  643. mOwnerID.toString(uuid_str);
  644. fprintf(fp, "ttowner_idt%sn", uuid_str.c_str());
  645. fprintf(fp, "ttversiont%dn", mVersion);
  646. fprintf(fp,"t}n");
  647. return true;
  648. }
  650. void LLViewerInventoryCategory::determineFolderType()
  651. {
  652. /* Do NOT uncomment this code.  This is for future 2.1 support of ensembles.
  653. llassert(FALSE);
  654. LLFolderType::EType original_type = getPreferredType();
  655. if (LLFolderType::lookupIsProtectedType(original_type))
  656. return;
  658. U64 folder_valid = 0;
  659. U64 folder_invalid = 0;
  660. LLInventoryModel::cat_array_t category_array;
  661. LLInventoryModel::item_array_t item_array;
  662. gInventory.collectDescendents(getUUID(),category_array,item_array,FALSE);
  664. // For ensembles
  665. if (category_array.empty())
  666. {
  667. for (LLInventoryModel::item_array_t::iterator item_iter = item_array.begin();
  668.  item_iter != item_array.end();
  669.  item_iter++)
  670. {
  671. const LLViewerInventoryItem *item = (*item_iter);
  672. if (item->getIsLinkType())
  673. return;
  674. if (item->isWearableType())
  675. {
  676. const EWearableType wearable_type = item->getWearableType();
  677. const std::string& wearable_name = LLWearableDictionary::getTypeName(wearable_type);
  678. U64 valid_folder_types = LLViewerFolderType::lookupValidFolderTypes(wearable_name);
  679. folder_valid |= valid_folder_types;
  680. folder_invalid |= ~valid_folder_types;
  681. }
  682. }
  683. for (U8 i = LLFolderType::FT_ENSEMBLE_START; i <= LLFolderType::FT_ENSEMBLE_END; i++)
  684. {
  685. if ((folder_valid & (1LL << i)) &&
  686. !(folder_invalid & (1LL << i)))
  687. {
  688. changeType((LLFolderType::EType)i);
  689. return;
  690. }
  691. }
  692. }
  693. if (LLFolderType::lookupIsEnsembleType(original_type))
  694. {
  695. changeType(LLFolderType::FT_NONE);
  696. }
  697. llassert(FALSE);
  698. */
  699. }
  701. void LLViewerInventoryCategory::changeType(LLFolderType::EType new_folder_type)
  702. {
  703. const LLUUID &folder_id = getUUID();
  704. const LLUUID &parent_id = getParentUUID();
  705. const std::string &name = getName();
  707. LLMessageSystem* msg = gMessageSystem;
  708. msg->newMessageFast(_PREHASH_UpdateInventoryFolder);
  709. msg->nextBlockFast(_PREHASH_AgentData);
  710. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  711. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  712. msg->nextBlockFast(_PREHASH_FolderData);
  713. msg->addUUIDFast(_PREHASH_FolderID, folder_id);
  714. msg->addUUIDFast(_PREHASH_ParentID, parent_id);
  715. msg->addS8Fast(_PREHASH_Type, new_folder_type);
  716. msg->addStringFast(_PREHASH_Name, name);
  717. gAgent.sendReliableMessage();
  719. setPreferredType(new_folder_type);
  720. gInventory.addChangedMask(LLInventoryObserver::LABEL, folder_id);
  721. }
  723. ///----------------------------------------------------------------------------
  724. /// Local function definitions
  725. ///----------------------------------------------------------------------------
  727. LLInventoryCallbackManager *LLInventoryCallbackManager::sInstance = NULL;
  729. LLInventoryCallbackManager::LLInventoryCallbackManager() :
  730. mLastCallback(0)
  731. {
  732. if( sInstance != NULL )
  733. {
  734. llwarns << "LLInventoryCallbackManager::LLInventoryCallbackManager: unexpected multiple instances" << llendl;
  735. return;
  736. }
  737. sInstance = this;
  738. }
  740. LLInventoryCallbackManager::~LLInventoryCallbackManager()
  741. {
  742. if( sInstance != this )
  743. {
  744. llwarns << "LLInventoryCallbackManager::~LLInventoryCallbackManager: unexpected multiple instances" << llendl;
  745. return;
  746. }
  747. sInstance = NULL;
  748. }
  750. U32 LLInventoryCallbackManager::registerCB(LLPointer<LLInventoryCallback> cb)
  751. {
  752. if (cb.isNull())
  753. return 0;
  755. mLastCallback++;
  756. if (!mLastCallback)
  757. mLastCallback++;
  759. mMap[mLastCallback] = cb;
  760. return mLastCallback;
  761. }
  763. void LLInventoryCallbackManager::fire(U32 callback_id, const LLUUID& item_id)
  764. {
  765. if (!callback_id || item_id.isNull())
  766. return;
  768. std::map<U32, LLPointer<LLInventoryCallback> >::iterator i;
  770. i = mMap.find(callback_id);
  771. if (i != mMap.end())
  772. {
  773. (*i).second->fire(item_id);
  774. mMap.erase(i);
  775. }
  776. }
  778. void WearOnAvatarCallback::fire(const LLUUID& inv_item)
  779. {
  780. if (inv_item.isNull())
  781. return;
  783. LLViewerInventoryItem *item = gInventory.getItem(inv_item);
  784. if (item)
  785. {
  786. wear_inventory_item_on_avatar(item);
  787. }
  788. }
  790. void ModifiedCOFCallback::fire(const LLUUID& inv_item)
  791. {
  792. LLAppearanceManager::instance().updateAppearanceFromCOF();
  793. if( CAMERA_MODE_CUSTOMIZE_AVATAR == gAgent.getCameraMode() )
  794. {
  795. // If we're in appearance editing mode, the current tab may need to be refreshed
  796. if (gFloaterCustomize)
  797. {
  798. gFloaterCustomize->switchToDefaultSubpart();
  799. }
  800. }
  801. }
  803. RezAttachmentCallback::RezAttachmentCallback(LLViewerJointAttachment *attachmentp)
  804. {
  805. mAttach = attachmentp;
  806. }
  807. RezAttachmentCallback::~RezAttachmentCallback()
  808. {
  809. }
  811. void RezAttachmentCallback::fire(const LLUUID& inv_item)
  812. {
  813. if (inv_item.isNull())
  814. return;
  816. LLViewerInventoryItem *item = gInventory.getItem(inv_item);
  817. if (item)
  818. {
  819. rez_attachment(item, mAttach);
  820. }
  821. }
  823. void ActivateGestureCallback::fire(const LLUUID& inv_item)
  824. {
  825. if (inv_item.isNull())
  826. return;
  828. LLGestureManager::instance().activateGesture(inv_item);
  829. }
  831. void CreateGestureCallback::fire(const LLUUID& inv_item)
  832. {
  833. if (inv_item.isNull())
  834. return;
  836. LLGestureManager::instance().activateGesture(inv_item);
  838. LLViewerInventoryItem* item = gInventory.getItem(inv_item);
  839. if (!item) return;
  840.     gInventory.updateItem(item);
  841.     gInventory.notifyObservers();
  843. LLPreviewGesture* preview = LLPreviewGesture::show(inv_item,  LLUUID::null);
  844. // Force to be entirely onscreen.
  845. gFloaterView->adjustToFitScreen(preview, FALSE);
  846. }
  848. void AddFavoriteLandmarkCallback::fire(const LLUUID& inv_item_id)
  849. {
  850. if (mTargetLandmarkId.isNull()) return;
  852. gInventory.rearrangeFavoriteLandmarks(inv_item_id, mTargetLandmarkId);
  853. }
  855. LLInventoryCallbackManager gInventoryCallbacks;
  857. void create_inventory_item(const LLUUID& agent_id, const LLUUID& session_id,
  858.    const LLUUID& parent, const LLTransactionID& transaction_id,
  859.    const std::string& name,
  860.    const std::string& desc, LLAssetType::EType asset_type,
  861.    LLInventoryType::EType inv_type, EWearableType wtype,
  862.    U32 next_owner_perm,
  863.    LLPointer<LLInventoryCallback> cb)
  864. {
  865. LLMessageSystem* msg = gMessageSystem;
  866. msg->newMessageFast(_PREHASH_CreateInventoryItem);
  867. msg->nextBlock(_PREHASH_AgentData);
  868. msg->addUUIDFast(_PREHASH_AgentID, agent_id);
  869. msg->addUUIDFast(_PREHASH_SessionID, session_id);
  870. msg->nextBlock(_PREHASH_InventoryBlock);
  871. msg->addU32Fast(_PREHASH_CallbackID, gInventoryCallbacks.registerCB(cb));
  872. msg->addUUIDFast(_PREHASH_FolderID, parent);
  873. msg->addUUIDFast(_PREHASH_TransactionID, transaction_id);
  874. msg->addU32Fast(_PREHASH_NextOwnerMask, next_owner_perm);
  875. msg->addS8Fast(_PREHASH_Type, (S8)asset_type);
  876. msg->addS8Fast(_PREHASH_InvType, (S8)inv_type);
  877. msg->addU8Fast(_PREHASH_WearableType, (U8)wtype);
  878. msg->addStringFast(_PREHASH_Name, name);
  879. msg->addStringFast(_PREHASH_Description, desc);
  881. gAgent.sendReliableMessage();
  882. }
  884. void create_inventory_callingcard(const LLUUID& avatar_id, const LLUUID& parent /*= LLUUID::null*/, LLPointer<LLInventoryCallback> cb/*=NULL*/)
  885. {
  886. std::string item_desc = avatar_id.asString();
  887. std::string item_name;
  888. gCacheName->getFullName(avatar_id, item_name);
  889. create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
  890.   parent, LLTransactionID::tnull, item_name, item_desc, LLAssetType::AT_CALLINGCARD,
  891.   LLInventoryType::IT_CALLINGCARD, NOT_WEARABLE, PERM_MOVE | PERM_TRANSFER, cb);
  892. }
  894. void copy_inventory_item(
  895. const LLUUID& agent_id,
  896. const LLUUID& current_owner,
  897. const LLUUID& item_id,
  898. const LLUUID& parent_id,
  899. const std::string& new_name,
  900. LLPointer<LLInventoryCallback> cb)
  901. {
  902. LLMessageSystem* msg = gMessageSystem;
  903. msg->newMessageFast(_PREHASH_CopyInventoryItem);
  904. msg->nextBlockFast(_PREHASH_AgentData);
  905. msg->addUUIDFast(_PREHASH_AgentID, agent_id);
  906. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  907. msg->nextBlockFast(_PREHASH_InventoryData);
  908. msg->addU32Fast(_PREHASH_CallbackID, gInventoryCallbacks.registerCB(cb));
  909. msg->addUUIDFast(_PREHASH_OldAgentID, current_owner);
  910. msg->addUUIDFast(_PREHASH_OldItemID, item_id);
  911. msg->addUUIDFast(_PREHASH_NewFolderID, parent_id);
  912. msg->addStringFast(_PREHASH_NewName, new_name);
  913. gAgent.sendReliableMessage();
  914. }
  916. void link_inventory_item(
  917. const LLUUID& agent_id,
  918. const LLUUID& item_id,
  919. const LLUUID& parent_id,
  920. const std::string& new_name,
  921. const LLAssetType::EType asset_type,
  922. LLPointer<LLInventoryCallback> cb)
  923. {
  924. const LLInventoryObject *baseobj = gInventory.getObject(item_id);
  925. if (!baseobj)
  926. {
  927. llwarns << "attempt to link to unknown item, linked-to-item's itemID " << item_id << llendl;
  928. return;
  929. }
  930. if (baseobj && baseobj->getIsLinkType())
  931. {
  932. llwarns << "attempt to create a link to a link, linked-to-item's itemID " << item_id << llendl;
  933. return;
  934. }
  936. if (baseobj && !LLAssetType::lookupCanLink(baseobj->getType()))
  937. {
  938. // Fail if item can be found but is of a type that can't be linked.
  939. // Arguably should fail if the item can't be found too, but that could
  940. // be a larger behavioral change.
  941. llwarns << "attempt to link an unlinkable item, type = " << baseobj->getActualType() << llendl;
  942. return;
  943. }
  945. LLUUID transaction_id;
  946. std::string desc = "Broken link"; // This should only show if the object can't find its baseobj.
  947. LLInventoryType::EType inv_type = LLInventoryType::IT_NONE;
  948. if (dynamic_cast<const LLInventoryCategory *>(baseobj))
  949. {
  950. inv_type = LLInventoryType::IT_CATEGORY;
  951. }
  952. else
  953. {
  954. const LLViewerInventoryItem *baseitem = dynamic_cast<const LLViewerInventoryItem *>(baseobj);
  955. if (baseitem)
  956. {
  957. inv_type = baseitem->getInventoryType();
  958. }
  959. }
  961. LLMessageSystem* msg = gMessageSystem;
  962. msg->newMessageFast(_PREHASH_LinkInventoryItem);
  963. msg->nextBlock(_PREHASH_AgentData);
  964. {
  965. msg->addUUIDFast(_PREHASH_AgentID, agent_id);
  966. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  967. }
  968. msg->nextBlock(_PREHASH_InventoryBlock);
  969. {
  970. msg->addU32Fast(_PREHASH_CallbackID, gInventoryCallbacks.registerCB(cb));
  971. msg->addUUIDFast(_PREHASH_FolderID, parent_id);
  972. msg->addUUIDFast(_PREHASH_TransactionID, transaction_id);
  973. msg->addUUIDFast(_PREHASH_OldItemID, item_id);
  974. msg->addS8Fast(_PREHASH_Type, (S8)asset_type);
  975. msg->addS8Fast(_PREHASH_InvType, (S8)inv_type);
  976. msg->addStringFast(_PREHASH_Name, new_name);
  977. msg->addStringFast(_PREHASH_Description, desc);
  978. }
  979. gAgent.sendReliableMessage();
  980. }
  982. void move_inventory_item(
  983. const LLUUID& agent_id,
  984. const LLUUID& session_id,
  985. const LLUUID& item_id,
  986. const LLUUID& parent_id,
  987. const std::string& new_name,
  988. LLPointer<LLInventoryCallback> cb)
  989. {
  990. LLMessageSystem* msg = gMessageSystem;
  991. msg->newMessageFast(_PREHASH_MoveInventoryItem);
  992. msg->nextBlockFast(_PREHASH_AgentData);
  993. msg->addUUIDFast(_PREHASH_AgentID, agent_id);
  994. msg->addUUIDFast(_PREHASH_SessionID, session_id);
  995. msg->addBOOLFast(_PREHASH_Stamp, FALSE);
  996. msg->nextBlockFast(_PREHASH_InventoryData);
  997. msg->addUUIDFast(_PREHASH_ItemID, item_id);
  998. msg->addUUIDFast(_PREHASH_FolderID, parent_id);
  999. msg->addStringFast(_PREHASH_NewName, new_name);
  1000. gAgent.sendReliableMessage();
  1001. }
  1003. void copy_inventory_from_notecard(const LLUUID& object_id, const LLUUID& notecard_inv_id, const LLInventoryItem *src, U32 callback_id)
  1004. {
  1005. LLViewerRegion* viewer_region = NULL;
  1006.     LLViewerObject* vo = NULL;
  1007. if (object_id.notNull() && (vo = gObjectList.findObject(object_id)) != NULL)
  1008.     {
  1009.         viewer_region = vo->getRegion();
  1010. }
  1012. // Fallback to the agents region if for some reason the 
  1013. // object isn't found in the viewer.
  1014. if (! viewer_region)
  1015. {
  1016. viewer_region = gAgent.getRegion();
  1017. }
  1019. if (! viewer_region)
  1020. {
  1021.         LL_WARNS("copy_inventory_from_notecard") << "Can't find region from object_id "
  1022.                                                  << object_id << " or gAgent"
  1023.                                                  << LL_ENDL;
  1024.         return;
  1025.     }
  1027.     LLSD request, body;
  1028.     body["notecard-id"] = notecard_inv_id;
  1029.     body["object-id"] = object_id;
  1030.     body["item-id"] = src->getUUID();
  1031. body["folder-id"] = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(src->getType()));
  1032.     body["callback-id"] = (LLSD::Integer)callback_id;
  1034.     request["message"] = "CopyInventoryFromNotecard";
  1035.     request["payload"] = body;
  1037.     viewer_region->getCapAPI().post(request);
  1038. }
  1040. void create_new_item(const std::string& name,
  1041.    const LLUUID& parent_id,
  1042.    LLAssetType::EType asset_type,
  1043.    LLInventoryType::EType inv_type,
  1044.    U32 next_owner_perm)
  1045. {
  1046. std::string desc;
  1047. LLViewerAssetType::generateDescriptionFor(asset_type, desc);
  1048. next_owner_perm = (next_owner_perm) ? next_owner_perm : PERM_MOVE | PERM_TRANSFER;
  1051. if (inv_type == LLInventoryType::IT_GESTURE)
  1052. {
  1053. LLPointer<LLInventoryCallback> cb = new CreateGestureCallback();
  1054. create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
  1055.   parent_id, LLTransactionID::tnull, name, desc, asset_type, inv_type,
  1056.   NOT_WEARABLE, next_owner_perm, cb);
  1057. }
  1058. else
  1059. {
  1060. LLPointer<LLInventoryCallback> cb = NULL;
  1061. create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
  1062.   parent_id, LLTransactionID::tnull, name, desc, asset_type, inv_type,
  1063.   NOT_WEARABLE, next_owner_perm, cb);
  1064. }
  1066. }
  1068. const std::string NEW_LSL_NAME = "New Script"; // *TODO:Translate? (probably not)
  1069. const std::string NEW_NOTECARD_NAME = "New Note"; // *TODO:Translate? (probably not)
  1070. const std::string NEW_GESTURE_NAME = "New Gesture"; // *TODO:Translate? (probably not)
  1072. // ! REFACTOR ! Really need to refactor this so that it's not a bunch of if-then statements...
  1073. void menu_create_inventory_item(LLFolderView* folder, LLFolderBridge *bridge, const LLSD& userdata, const LLUUID& default_parent_uuid)
  1074. {
  1075. std::string type_name = userdata.asString();
  1077. if (("category" == type_name) || ("current" == type_name) || ("outfit" == type_name) || ("my_otfts" == type_name))
  1078. {
  1079. LLFolderType::EType preferred_type = LLFolderType::lookup(type_name);
  1081. LLUUID parent_id;
  1082. if (bridge)
  1083. {
  1084. parent_id = bridge->getUUID();
  1085. }
  1086. else if (default_parent_uuid.notNull())
  1087. {
  1088. parent_id = default_parent_uuid;
  1089. }
  1090. else
  1091. {
  1092. parent_id = gInventory.getRootFolderID();
  1093. }
  1095. LLUUID category = gInventory.createNewCategory(parent_id, preferred_type, LLStringUtil::null);
  1096. gInventory.notifyObservers();
  1097. folder->setSelectionByID(category, TRUE);
  1098. }
  1099. else if ("lsl" == type_name)
  1100. {
  1101. const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_LSL_TEXT);
  1102. create_new_item(NEW_LSL_NAME,
  1103.   parent_id,
  1104.   LLAssetType::AT_LSL_TEXT,
  1105.   LLInventoryType::IT_LSL,
  1106.   PERM_MOVE | PERM_TRANSFER);
  1107. }
  1108. else if ("notecard" == type_name)
  1109. {
  1110. const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_NOTECARD);
  1111. create_new_item(NEW_NOTECARD_NAME,
  1112.   parent_id,
  1113.   LLAssetType::AT_NOTECARD,
  1114.   LLInventoryType::IT_NOTECARD,
  1115.   PERM_ALL);
  1116. }
  1117. else if ("gesture" == type_name)
  1118. {
  1119. const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
  1120. create_new_item(NEW_GESTURE_NAME,
  1121.   parent_id,
  1122.   LLAssetType::AT_GESTURE,
  1123.   LLInventoryType::IT_GESTURE,
  1124.   PERM_ALL);
  1125. }
  1126. else
  1127. {
  1128. // Use for all clothing and body parts.  Adding new wearable types requires updating LLWearableDictionary.
  1129. EWearableType wearable_type = LLWearableDictionary::typeNameToType(type_name);
  1130. if (wearable_type >= WT_SHAPE && wearable_type < WT_COUNT)
  1131. {
  1132. LLAssetType::EType asset_type = LLWearableDictionary::getAssetType(wearable_type);
  1133. LLFolderType::EType folder_type = LLFolderType::assetTypeToFolderType(asset_type);
  1134. const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(folder_type);
  1135. LLFolderBridge::createWearable(parent_id, wearable_type);
  1136. }
  1137. else
  1138. {
  1139. llwarns << "Can't create unrecognized type " << type_name << llendl;
  1140. }
  1141. }
  1142. folder->setNeedsAutoRename(TRUE);
  1143. }
  1145. LLAssetType::EType LLViewerInventoryItem::getType() const
  1146. {
  1147. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1148. {
  1149. return linked_item->getType();
  1150. }
  1151. if (const LLViewerInventoryCategory *linked_category = getLinkedCategory())
  1152. {
  1153. return linked_category->getType();
  1154. }
  1155. return LLInventoryItem::getType();
  1156. }
  1158. const LLUUID& LLViewerInventoryItem::getAssetUUID() const
  1159. {
  1160. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1161. {
  1162. return linked_item->getAssetUUID();
  1163. }
  1165. return LLInventoryItem::getAssetUUID();
  1166. }
  1168. const std::string& LLViewerInventoryItem::getName() const
  1169. {
  1170. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1171. {
  1172. return linked_item->getName();
  1173. }
  1174. if (const LLViewerInventoryCategory *linked_category = getLinkedCategory())
  1175. {
  1176. return linked_category->getName();
  1177. }
  1179. return  LLInventoryItem::getName();
  1180. }
  1182. /**
  1183.  * Class to store sorting order of favorites landmarks in a local file. EXT-3985.
  1184.  * It replaced previously implemented solution to store sort index in landmark's name as a "<N>@" prefix.
  1185.  * Data are stored in user home directory.
  1186.  */
  1187. class LLFavoritesOrderStorage : public LLSingleton<LLFavoritesOrderStorage>
  1188. , public LLDestroyClass<LLFavoritesOrderStorage>
  1189. {
  1190. public:
  1191. /**
  1192.  * Sets sort index for specified with LLUUID favorite landmark
  1193.  */
  1194. void setSortIndex(const LLUUID& inv_item_id, S32 sort_index);
  1196. /**
  1197.  * Gets sort index for specified with LLUUID favorite landmark
  1198.  */
  1199. S32 getSortIndex(const LLUUID& inv_item_id);
  1200. void removeSortIndex(const LLUUID& inv_item_id);
  1202. /**
  1203.  * Implementation of LLDestroyClass. Calls cleanup() instance method.
  1204.  *
  1205.  * It is important this callback is called before gInventory is cleaned.
  1206.  * For now it is called from LLAppViewer::cleanup() -> LLAppViewer::disconnectViewer(),
  1207.  * Inventory is cleaned later from LLAppViewer::cleanup() after LLAppViewer::disconnectViewer() is called.
  1208.  * @see cleanup()
  1209.  */
  1210. static void destroyClass();
  1212. const static S32 NO_INDEX;
  1213. private:
  1214. friend class LLSingleton<LLFavoritesOrderStorage>;
  1215. LLFavoritesOrderStorage() : mIsDirty(false) { load(); }
  1216. ~LLFavoritesOrderStorage() { save(); }
  1218. /**
  1219.  * Removes sort indexes for items which are not in Favorites bar for now.
  1220.  */
  1221. void cleanup();
  1223. const static std::string SORTING_DATA_FILE_NAME;
  1225. void load();
  1226. void save();
  1228. typedef std::map<LLUUID, S32> sort_index_map_t;
  1229. sort_index_map_t mSortIndexes;
  1231. bool mIsDirty;
  1233. struct IsNotInFavorites
  1234. {
  1235. IsNotInFavorites(const LLInventoryModel::item_array_t& items)
  1236. : mFavoriteItems(items)
  1237. {
  1239. }
  1241. /**
  1242.  * Returns true if specified item is not found among inventory items
  1243.  */
  1244. bool operator()(const sort_index_map_t::value_type& id_index_pair) const
  1245. {
  1246. LLPointer<LLViewerInventoryItem> item = gInventory.getItem(id_index_pair.first);
  1247. if (item.isNull()) return true;
  1249. LLInventoryModel::item_array_t::const_iterator found_it =
  1250. std::find(mFavoriteItems.begin(), mFavoriteItems.end(), item);
  1252. return found_it == mFavoriteItems.end();
  1253. }
  1254. private:
  1255. LLInventoryModel::item_array_t mFavoriteItems;
  1256. };
  1258. };
  1260. const std::string LLFavoritesOrderStorage::SORTING_DATA_FILE_NAME = "landmarks_sorting.xml";
  1261. const S32 LLFavoritesOrderStorage::NO_INDEX = -1;
  1263. void LLFavoritesOrderStorage::setSortIndex(const LLUUID& inv_item_id, S32 sort_index)
  1264. {
  1265. mSortIndexes[inv_item_id] = sort_index;
  1266. mIsDirty = true;
  1267. }
  1269. S32 LLFavoritesOrderStorage::getSortIndex(const LLUUID& inv_item_id)
  1270. {
  1271. sort_index_map_t::const_iterator it = mSortIndexes.find(inv_item_id);
  1272. if (it != mSortIndexes.end())
  1273. {
  1274. return it->second;
  1275. }
  1276. return NO_INDEX;
  1277. }
  1279. void LLFavoritesOrderStorage::removeSortIndex(const LLUUID& inv_item_id)
  1280. {
  1281. mSortIndexes.erase(inv_item_id);
  1282. mIsDirty = true;
  1283. }
  1285. // static
  1286. void LLFavoritesOrderStorage::destroyClass()
  1287. {
  1288. LLFavoritesOrderStorage::instance().cleanup();
  1289. }
  1291. void LLFavoritesOrderStorage::load()
  1292. {
  1293. // load per-resident sorting information
  1294. std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, SORTING_DATA_FILE_NAME);
  1296. LLSD settings_llsd;
  1297. llifstream file;
  1298. file.open(filename);
  1299. if (file.is_open())
  1300. {
  1301. LLSDSerialize::fromXML(settings_llsd, file);
  1302. }
  1304. for (LLSD::map_const_iterator iter = settings_llsd.beginMap();
  1305. iter != settings_llsd.endMap(); ++iter)
  1306. {
  1307. mSortIndexes.insert(std::make_pair(LLUUID(iter->first), (S32)iter->second.asInteger()));
  1308. }
  1309. }
  1311. void LLFavoritesOrderStorage::save()
  1312. {
  1313. // nothing to save if clean
  1314. if (!mIsDirty) return;
  1316. // If we quit from the login screen we will not have an SL account
  1317. // name.  Don't try to save, otherwise we'll dump a file in
  1318. // C:Program FilesSecondLife or similar. JC
  1319. std::string user_dir = gDirUtilp->getLindenUserDir();
  1320. if (!user_dir.empty())
  1321. {
  1322. std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, SORTING_DATA_FILE_NAME);
  1323. LLSD settings_llsd;
  1325. for(sort_index_map_t::const_iterator iter = mSortIndexes.begin(); iter != mSortIndexes.end(); ++iter)
  1326. {
  1327. settings_llsd[iter->first.asString()] = iter->second;
  1328. }
  1330. llofstream file;
  1331. file.open(filename);
  1332. LLSDSerialize::toPrettyXML(settings_llsd, file);
  1333. }
  1334. }
  1336. void LLFavoritesOrderStorage::cleanup()
  1337. {
  1338. // nothing to clean
  1339. if (!mIsDirty) return;
  1341. const LLUUID fav_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
  1342. LLInventoryModel::cat_array_t cats;
  1343. LLInventoryModel::item_array_t items;
  1344. gInventory.collectDescendents(fav_id, cats, items, LLInventoryModel::EXCLUDE_TRASH);
  1346. IsNotInFavorites is_not_in_fav(items);
  1348. sort_index_map_t  aTempMap;
  1349. //copy unremoved values from mSortIndexes to aTempMap
  1350. std::remove_copy_if(mSortIndexes.begin(), mSortIndexes.end(), 
  1351. inserter(aTempMap, aTempMap.begin()),
  1352. is_not_in_fav);
  1354. //Swap the contents of mSortIndexes and aTempMap
  1355. mSortIndexes.swap(aTempMap);
  1356. }
  1359. S32 LLViewerInventoryItem::getSortField() const
  1360. {
  1361. return LLFavoritesOrderStorage::instance().getSortIndex(mUUID);
  1362. }
  1364. void LLViewerInventoryItem::setSortField(S32 sortField)
  1365. {
  1366. LLFavoritesOrderStorage::instance().setSortIndex(mUUID, sortField);
  1367. }
  1369. const LLPermissions& LLViewerInventoryItem::getPermissions() const
  1370. {
  1371. // Use the actual permissions of the symlink, not its parent.
  1372. return LLInventoryItem::getPermissions();
  1373. }
  1375. const LLUUID& LLViewerInventoryItem::getCreatorUUID() const
  1376. {
  1377. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1378. {
  1379. return linked_item->getCreatorUUID();
  1380. }
  1382. return LLInventoryItem::getCreatorUUID();
  1383. }
  1385. const std::string& LLViewerInventoryItem::getDescription() const
  1386. {
  1387. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1388. {
  1389. return linked_item->getDescription();
  1390. }
  1392. return LLInventoryItem::getDescription();
  1393. }
  1395. const LLSaleInfo& LLViewerInventoryItem::getSaleInfo() const
  1396. {
  1397. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1398. {
  1399. return linked_item->getSaleInfo();
  1400. }
  1402. return LLInventoryItem::getSaleInfo();
  1403. }
  1405. LLInventoryType::EType LLViewerInventoryItem::getInventoryType() const
  1406. {
  1407. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1408. {
  1409. return linked_item->getInventoryType();
  1410. }
  1412. // Categories don't have types.  If this item is an AT_FOLDER_LINK,
  1413. // treat it as a category.
  1414. if (getLinkedCategory())
  1415. {
  1416. return LLInventoryType::IT_CATEGORY;
  1417. }
  1419. return LLInventoryItem::getInventoryType();
  1420. }
  1422. U32 LLViewerInventoryItem::getFlags() const
  1423. {
  1424. if (const LLViewerInventoryItem *linked_item = getLinkedItem())
  1425. {
  1426. return linked_item->getFlags();
  1427. }
  1428. return LLInventoryItem::getFlags();
  1429. }
  1431. bool LLViewerInventoryItem::isWearableType() const
  1432. {
  1433. return (getInventoryType() == LLInventoryType::IT_WEARABLE);
  1434. }
  1436. EWearableType LLViewerInventoryItem::getWearableType() const
  1437. {
  1438. if (!isWearableType())
  1439. {
  1440. llwarns << "item is not a wearable" << llendl;
  1441. return WT_INVALID;
  1442. }
  1443. return EWearableType(getFlags() & LLInventoryItem::II_FLAGS_WEARABLES_MASK);
  1444. }
  1447. time_t LLViewerInventoryItem::getCreationDate() const
  1448. {
  1449. return LLInventoryItem::getCreationDate();
  1450. }
  1452. U32 LLViewerInventoryItem::getCRC32() const
  1453. {
  1454. return LLInventoryItem::getCRC32();
  1455. }
  1457. // *TODO: mantipov: should be removed with LMSortPrefix patch in llinventorymodel.cpp, EXT-3985
  1458. static char getSeparator() { return '@'; }
  1459. BOOL LLViewerInventoryItem::extractSortFieldAndDisplayName(const std::string& name, S32* sortField, std::string* displayName)
  1460. {
  1461. using std::string;
  1462. using std::stringstream;
  1464. const char separator = getSeparator();
  1465. const string::size_type separatorPos = name.find(separator, 0);
  1467. BOOL result = FALSE;
  1469. if (separatorPos < string::npos)
  1470. {
  1471. if (sortField)
  1472. {
  1473. /*
  1474.  * The conversion from string to S32 is made this way instead of old plain
  1475.  * atoi() to ensure portability. If on some other platform S32 will not be
  1476.  * defined to be signed int, this conversion will still work because of
  1477.  * operators overloading, but atoi() may fail.
  1478.  */
  1479. stringstream ss(name.substr(0, separatorPos));
  1480. ss >> *sortField;
  1481. }
  1483. if (displayName)
  1484. {
  1485. *displayName = name.substr(separatorPos + 1, string::npos);
  1486. }
  1488. result = TRUE;
  1489. }
  1491. return result;
  1492. }
  1494. // This returns true if the item that this item points to 
  1495. // doesn't exist in memory (i.e. LLInventoryModel).  The baseitem
  1496. // might still be in the database but just not loaded yet.
  1497. bool LLViewerInventoryItem::getIsBrokenLink() const
  1498. {
  1499. // If the item's type resolves to be a link, that means either:
  1500. // A. It wasn't able to perform indirection, i.e. the baseobj doesn't exist in memory.
  1501. // B. It's pointing to another link, which is illegal.
  1502. return LLAssetType::lookupIsLinkType(getType());
  1503. }
  1505. LLViewerInventoryItem *LLViewerInventoryItem::getLinkedItem() const
  1506. {
  1507. if (mType == LLAssetType::AT_LINK)
  1508. {
  1509. LLViewerInventoryItem *linked_item = gInventory.getItem(mAssetUUID);
  1510. if (linked_item && linked_item->getIsLinkType())
  1511. {
  1512. llwarns << "Warning: Accessing link to link" << llendl;
  1513. return NULL;
  1514. }
  1515. return linked_item;
  1516. }
  1517. return NULL;
  1518. }
  1520. LLViewerInventoryCategory *LLViewerInventoryItem::getLinkedCategory() const
  1521. {
  1522. if (mType == LLAssetType::AT_LINK_FOLDER)
  1523. {
  1524. LLViewerInventoryCategory *linked_category = gInventory.getCategory(mAssetUUID);
  1525. return linked_category;
  1526. }
  1527. return NULL;
  1528. }
  1530. bool LLViewerInventoryItem::checkPermissionsSet(PermissionMask mask) const
  1531. {
  1532. const LLPermissions& perm = getPermissions();
  1533. PermissionMask curr_mask = PERM_NONE;
  1534. if(perm.getOwner() == gAgent.getID())
  1535. {
  1536. curr_mask = perm.getMaskBase();
  1537. }
  1538. else if(gAgent.isInGroup(perm.getGroup()))
  1539. {
  1540. curr_mask = perm.getMaskGroup();
  1541. }
  1542. else
  1543. {
  1544. curr_mask = perm.getMaskEveryone();
  1545. }
  1546. return ((curr_mask & mask) == mask);
  1547. }
  1549. //----------
  1551. void LLViewerInventoryItem::onCallingCardNameLookup(const LLUUID& id, const std::string& first_name, const std::string& last_name)
  1552. {
  1553. rename(first_name + " " + last_name);
  1554. gInventory.addChangedMask(LLInventoryObserver::LABEL, getUUID());
  1555. gInventory.notifyObservers();
  1556. }
  1558. class LLRegenerateLinkCollector : public LLInventoryCollectFunctor
  1559. {
  1560. public:
  1561. LLRegenerateLinkCollector(const LLViewerInventoryItem *target_item) : mTargetItem(target_item) {}
  1562. virtual ~LLRegenerateLinkCollector() {}
  1563. virtual bool operator()(LLInventoryCategory* cat,
  1564. LLInventoryItem* item)
  1565. {
  1566. if (item)
  1567. {
  1568. if ((item->getName() == mTargetItem->getName()) &&
  1569. (item->getInventoryType() == mTargetItem->getInventoryType()) &&
  1570. (!item->getIsLinkType()))
  1571. {
  1572. return true;
  1573. }
  1574. }
  1575. return false;
  1576. }
  1577. protected:
  1578. const LLViewerInventoryItem* mTargetItem;
  1579. };
  1581. LLUUID find_possible_item_for_regeneration(const LLViewerInventoryItem *target_item)
  1582. {
  1583. LLViewerInventoryCategory::cat_array_t cats;
  1584. LLViewerInventoryItem::item_array_t items;
  1586. LLRegenerateLinkCollector candidate_matches(target_item);
  1587. gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
  1588. cats,
  1589. items,
  1590. LLInventoryModel::EXCLUDE_TRASH,
  1591. candidate_matches);
  1592. for (LLViewerInventoryItem::item_array_t::const_iterator item_iter = items.begin();
  1593.  item_iter != items.end();
  1594.  ++item_iter)
  1595. {
  1596.     const LLViewerInventoryItem *item = (*item_iter);
  1597. if (true) return item->getUUID();
  1598. }
  1599. return LLUUID::null;
  1600. }
  1602. // This currently dosen't work, because the sim does not allow us 
  1603. // to change an item's assetID.
  1604. BOOL LLViewerInventoryItem::regenerateLink()
  1605. {
  1606. const LLUUID target_item_id = find_possible_item_for_regeneration(this);
  1607. if (target_item_id.isNull())
  1608. return FALSE;
  1609. LLViewerInventoryCategory::cat_array_t cats;
  1610. LLViewerInventoryItem::item_array_t items;
  1611. LLAssetIDMatches asset_id_matches(getAssetUUID());
  1612. gInventory.collectDescendentsIf(gInventory.getRootFolderID(),
  1613. cats,
  1614. items,
  1615. LLInventoryModel::EXCLUDE_TRASH,
  1616. asset_id_matches);
  1617. for (LLViewerInventoryItem::item_array_t::iterator item_iter = items.begin();
  1618.  item_iter != items.end();
  1619.  item_iter++)
  1620. {
  1621.     LLViewerInventoryItem *item = (*item_iter);
  1622. item->setAssetUUID(target_item_id);
  1623. item->updateServer(FALSE);
  1624. gInventory.addChangedMask(LLInventoryObserver::REBUILD, item->getUUID());
  1625. }
  1626. gInventory.notifyObservers();
  1627. return TRUE;
  1628. }