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

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

游戏引擎

开发平台：

C++ Builder

llsidepaneliteminfo.cpp：源码内容
  1. /** 
  2.  * @file llsidepaneliteminfo.cpp
  3.  * @brief A floater which shows an inventory item's properties.
  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 "llsidepaneliteminfo.h"
  36. #include "roles_constants.h"
  38. #include "llagent.h"
  39. #include "llavataractions.h"
  40. #include "llbutton.h"
  41. #include "llfloaterreg.h"
  42. #include "llgroupactions.h"
  43. #include "llinventorymodel.h"
  44. #include "llinventoryobserver.h"
  45. #include "lllineeditor.h"
  46. #include "llradiogroup.h"
  47. #include "llviewercontrol.h"
  48. #include "llviewerinventory.h"
  49. #include "llviewerobjectlist.h"
  52. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  53. // Class LLItemPropertiesObserver
  54. //
  55. // Helper class to watch for changes to the item.
  56. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  57. class LLItemPropertiesObserver : public LLInventoryObserver
  58. {
  59. public:
  60. LLItemPropertiesObserver(LLSidepanelItemInfo* floater)
  61. : mFloater(floater)
  62. {
  63. gInventory.addObserver(this);
  64. }
  65. virtual ~LLItemPropertiesObserver()
  66. {
  67. gInventory.removeObserver(this);
  68. }
  69. virtual void changed(U32 mask);
  70. private:
  71. LLSidepanelItemInfo* mFloater;
  72. };
  74. void LLItemPropertiesObserver::changed(U32 mask)
  75. {
  76. // if there's a change we're interested in.
  77. if((mask & (LLInventoryObserver::LABEL | LLInventoryObserver::INTERNAL | LLInventoryObserver::REMOVE)) != 0)
  78. {
  79. mFloater->dirty();
  80. }
  81. }
  85. ///----------------------------------------------------------------------------
  86. /// Class LLSidepanelItemInfo
  87. ///----------------------------------------------------------------------------
  89. static LLRegisterPanelClassWrapper<LLSidepanelItemInfo> t_item_info("sidepanel_item_info");
  91. // Default constructor
  92. LLSidepanelItemInfo::LLSidepanelItemInfo()
  93.   : mItemID(LLUUID::null)
  94. {
  95. mPropertiesObserver = new LLItemPropertiesObserver(this);
  97. //LLUICtrlFactory::getInstance()->buildFloater(this,"floater_inventory_item_properties.xml");
  98. }
  100. // Destroys the object
  101. LLSidepanelItemInfo::~LLSidepanelItemInfo()
  102. {
  103. delete mPropertiesObserver;
  104. mPropertiesObserver = NULL;
  105. }
  107. // virtual
  108. BOOL LLSidepanelItemInfo::postBuild()
  109. {
  110. LLSidepanelInventorySubpanel::postBuild();
  112. childSetPrevalidate("LabelItemName",&LLTextValidate::validateASCIIPrintableNoPipe);
  113. getChild<LLUICtrl>("LabelItemName")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitName,this));
  114. childSetPrevalidate("LabelItemDesc",&LLTextValidate::validateASCIIPrintableNoPipe);
  115. getChild<LLUICtrl>("LabelItemDesc")->setCommitCallback(boost::bind(&LLSidepanelItemInfo:: onCommitDescription, this));
  116. // Creator information
  117. getChild<LLUICtrl>("BtnCreator")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onClickCreator,this));
  118. // owner information
  119. getChild<LLUICtrl>("BtnOwner")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onClickOwner,this));
  120. // acquired date
  121. // owner permissions
  122. // Permissions debug text
  123. // group permissions
  124. getChild<LLUICtrl>("CheckShareWithGroup")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitPermissions, this));
  125. // everyone permissions
  126. getChild<LLUICtrl>("CheckEveryoneCopy")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitPermissions, this));
  127. // next owner permissions
  128. getChild<LLUICtrl>("CheckNextOwnerModify")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitPermissions, this));
  129. getChild<LLUICtrl>("CheckNextOwnerCopy")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitPermissions, this));
  130. getChild<LLUICtrl>("CheckNextOwnerTransfer")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitPermissions, this));
  131. // Mark for sale or not, and sale info
  132. getChild<LLUICtrl>("CheckPurchase")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitSaleInfo, this));
  133. getChild<LLUICtrl>("RadioSaleType")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitSaleType, this));
  134. // "Price" label for edit
  135. getChild<LLUICtrl>("Edit Cost")->setCommitCallback(boost::bind(&LLSidepanelItemInfo::onCommitSaleInfo, this));
  136. refresh();
  137. return TRUE;
  138. }
  140. void LLSidepanelItemInfo::setObjectID(const LLUUID& object_id)
  141. {
  142. mObjectID = object_id;
  143. }
  145. void LLSidepanelItemInfo::setItemID(const LLUUID& item_id)
  146. {
  147. mItemID = item_id;
  148. }
  150. void LLSidepanelItemInfo::reset()
  151. {
  152. LLSidepanelInventorySubpanel::reset();
  154. mObjectID = LLUUID::null;
  155. mItemID = LLUUID::null;
  156. }
  158. void LLSidepanelItemInfo::refresh()
  159. {
  160. LLViewerInventoryItem* item = findItem();
  161. if(item)
  162. {
  163. refreshFromItem(item);
  164. updateVerbs();
  165. return;
  166. }
  167. else
  168. {
  169. if (getIsEditing())
  170. {
  171. setIsEditing(FALSE);
  172. }
  173. }
  175. if (!getIsEditing())
  176. {
  177. const std::string no_item_names[]={
  178. "LabelItemName",
  179. "LabelItemDesc",
  180. "LabelCreatorName",
  181. "LabelOwnerName",
  182. "CheckOwnerModify",
  183. "CheckOwnerCopy",
  184. "CheckOwnerTransfer",
  185. "CheckShareWithGroup",
  186. "CheckEveryoneCopy",
  187. "CheckNextOwnerModify",
  188. "CheckNextOwnerCopy",
  189. "CheckNextOwnerTransfer",
  190. "CheckPurchase",
  191. "RadioSaleType",
  192. "Edit Cost"
  193. };
  195. for(size_t t=0; t<LL_ARRAY_SIZE(no_item_names); ++t)
  196. {
  197. childSetEnabled(no_item_names[t],false);
  198. }
  200. const std::string hide_names[]={
  201. "BaseMaskDebug",
  202. "OwnerMaskDebug",
  203. "GroupMaskDebug",
  204. "EveryoneMaskDebug",
  205. "NextMaskDebug"
  206. };
  207. for(size_t t=0; t<LL_ARRAY_SIZE(hide_names); ++t)
  208. {
  209. childSetVisible(hide_names[t],false);
  210. }
  211. }
  213. if (!item)
  214. {
  215. const std::string no_edit_mode_names[]={
  216. "BtnCreator",
  217. "BtnOwner",
  218. };
  219. for(size_t t=0; t<LL_ARRAY_SIZE(no_edit_mode_names); ++t)
  220. {
  221. childSetEnabled(no_edit_mode_names[t],false);
  222. }
  223. }
  225. updateVerbs();
  226. }
  228. void LLSidepanelItemInfo::refreshFromItem(LLViewerInventoryItem* item)
  229. {
  230. ////////////////////////
  231. // PERMISSIONS LOOKUP //
  232. ////////////////////////
  234. llassert(item);
  235. if (!item) return;
  237. // do not enable the UI for incomplete items.
  238. BOOL is_complete = item->isComplete();
  239. const BOOL cannot_restrict_permissions = LLInventoryType::cannotRestrictPermissions(item->getInventoryType());
  240. const BOOL is_calling_card = (item->getInventoryType() == LLInventoryType::IT_CALLINGCARD);
  241. const LLPermissions& perm = item->getPermissions();
  242. const BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm, 
  243. GP_OBJECT_MANIPULATE);
  244. const BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm, 
  245.   GP_OBJECT_SET_SALE) &&
  246. !cannot_restrict_permissions;
  247. const BOOL is_link = item->getIsLinkType();
  249. const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
  250. bool not_in_trash = (item->getUUID() != trash_id) && !gInventory.isObjectDescendentOf(item->getUUID(), trash_id);
  252. // You need permission to modify the object to modify an inventory
  253. // item in it.
  254. LLViewerObject* object = NULL;
  255. if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID);
  256. BOOL is_obj_modify = TRUE;
  257. if(object)
  258. {
  259. is_obj_modify = object->permOwnerModify();
  260. }
  262. //////////////////////
  263. // ITEM NAME & DESC //
  264. //////////////////////
  265. BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm,
  266.    GP_OBJECT_MANIPULATE)
  267. && is_obj_modify && is_complete && not_in_trash;
  269. childSetEnabled("LabelItemNameTitle",TRUE);
  270. childSetEnabled("LabelItemName",is_modifiable && !is_calling_card); // for now, don't allow rename of calling cards
  271. childSetText("LabelItemName",item->getName());
  272. childSetEnabled("LabelItemDescTitle",TRUE);
  273. childSetEnabled("LabelItemDesc",is_modifiable);
  274. childSetVisible("IconLocked",!is_modifiable);
  275. childSetText("LabelItemDesc",item->getDescription());
  277. //////////////////
  278. // CREATOR NAME //
  279. //////////////////
  280. if(!gCacheName) return;
  281. if(!gAgent.getRegion()) return;
  283. if (item->getCreatorUUID().notNull())
  284. {
  285. std::string name;
  286. gCacheName->getFullName(item->getCreatorUUID(), name);
  287. childSetEnabled("BtnCreator",TRUE);
  288. childSetEnabled("LabelCreatorTitle",TRUE);
  289. childSetEnabled("LabelCreatorName",TRUE);
  290. childSetText("LabelCreatorName",name);
  291. }
  292. else
  293. {
  294. childSetEnabled("BtnCreator",FALSE);
  295. childSetEnabled("LabelCreatorTitle",FALSE);
  296. childSetEnabled("LabelCreatorName",FALSE);
  297. childSetText("LabelCreatorName",getString("unknown"));
  298. }
  300. ////////////////
  301. // OWNER NAME //
  302. ////////////////
  303. if(perm.isOwned())
  304. {
  305. std::string name;
  306. if (perm.isGroupOwned())
  307. {
  308. gCacheName->getGroupName(perm.getGroup(), name);
  309. }
  310. else
  311. {
  312. gCacheName->getFullName(perm.getOwner(), name);
  313. }
  314. childSetEnabled("BtnOwner",TRUE);
  315. childSetEnabled("LabelOwnerTitle",TRUE);
  316. childSetEnabled("LabelOwnerName",TRUE);
  317. childSetText("LabelOwnerName",name);
  318. }
  319. else
  320. {
  321. childSetEnabled("BtnOwner",FALSE);
  322. childSetEnabled("LabelOwnerTitle",FALSE);
  323. childSetEnabled("LabelOwnerName",FALSE);
  324. childSetText("LabelOwnerName",getString("public"));
  325. }
  327. //////////////////
  328. // ACQUIRE DATE //
  329. //////////////////
  331. time_t time_utc = item->getCreationDate();
  332. if (0 == time_utc)
  333. {
  334. childSetText("LabelAcquiredDate",getString("unknown"));
  335. }
  336. else
  337. {
  338. std::string timeStr = getString("acquiredDate");
  339. LLSD substitution;
  340. substitution["datetime"] = (S32) time_utc;
  341. LLStringUtil::format (timeStr, substitution);
  342. childSetText ("LabelAcquiredDate", timeStr);
  343. }
  345. /////////////////////////////////////
  346. // PERMISSIONS AND SALE ITEM HIDING
  347. /////////////////////////////////////
  349. const std::string perm_and_sale_items[]={
  350. "perms_inv",
  351. "OwnerLabel",
  352. "perm_modify",
  353. "CheckOwnerModify",
  354. "CheckOwnerCopy",
  355. "CheckOwnerTransfer",
  356. "GroupLabel",
  357. "CheckShareWithGroup",
  358. "AnyoneLabel",
  359. "CheckEveryoneCopy",
  360. "NextOwnerLabel",
  361. "CheckNextOwnerModify",
  362. "CheckNextOwnerCopy",
  363. "CheckNextOwnerTransfer",
  364. "CheckPurchase",
  365. "SaleLabel",
  366. "RadioSaleType",
  367. "combobox sale copy",
  368. "Edit Cost",
  369. "TextPrice"
  370. };
  372. const std::string debug_items[]={
  373. "BaseMaskDebug",
  374. "OwnerMaskDebug",
  375. "GroupMaskDebug",
  376. "EveryoneMaskDebug",
  377. "NextMaskDebug"
  378. };
  380. // Hide permissions checkboxes and labels and for sale info if in the trash
  381. // or ui elements don't apply to these objects and return from function
  382. if (!not_in_trash || cannot_restrict_permissions)
  383. {
  384. for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t)
  385. {
  386. childSetVisible(perm_and_sale_items[t],false);
  387. }
  389. for(size_t t=0; t<LL_ARRAY_SIZE(debug_items); ++t)
  390. {
  391. childSetVisible(debug_items[t],false);
  392. }
  393. return;
  394. }
  395. else // Make sure perms and sale ui elements are visible
  396. {
  397. for(size_t t=0; t<LL_ARRAY_SIZE(perm_and_sale_items); ++t)
  398. {
  399. childSetVisible(perm_and_sale_items[t],true);
  400. }
  401. }
  403. ///////////////////////
  404. // OWNER PERMISSIONS //
  405. ///////////////////////
  406. if(can_agent_manipulate)
  407. {
  408. childSetText("OwnerLabel",getString("you_can"));
  409. }
  410. else
  411. {
  412. childSetText("OwnerLabel",getString("owner_can"));
  413. }
  415. U32 base_mask = perm.getMaskBase();
  416. U32 owner_mask = perm.getMaskOwner();
  417. U32 group_mask = perm.getMaskGroup();
  418. U32 everyone_mask = perm.getMaskEveryone();
  419. U32 next_owner_mask = perm.getMaskNextOwner();
  421. childSetEnabled("OwnerLabel",TRUE);
  422. childSetEnabled("CheckOwnerModify",FALSE);
  423. childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY)));
  424. childSetEnabled("CheckOwnerCopy",FALSE);
  425. childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY)));
  426. childSetEnabled("CheckOwnerTransfer",FALSE);
  427. childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER)));
  429. ///////////////////////
  430. // DEBUG PERMISSIONS //
  431. ///////////////////////
  433. if( gSavedSettings.getBOOL("DebugPermissions") )
  434. {
  435. BOOL slam_perm  = FALSE;
  436. BOOL overwrite_group = FALSE;
  437. BOOL overwrite_everyone = FALSE;
  439. if (item->getType() == LLAssetType::AT_OBJECT)
  440. {
  441. U32 flags = item->getFlags();
  442. slam_perm  = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
  443. overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
  444. overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
  445. }
  447. std::string perm_string;
  449. perm_string = "B: ";
  450. perm_string += mask_to_string(base_mask);
  451. childSetText("BaseMaskDebug",perm_string);
  452. childSetVisible("BaseMaskDebug",TRUE);
  454. perm_string = "O: ";
  455. perm_string += mask_to_string(owner_mask);
  456. childSetText("OwnerMaskDebug",perm_string);
  457. childSetVisible("OwnerMaskDebug",TRUE);
  459. perm_string = "G";
  460. perm_string += overwrite_group ? "*: " : ": ";
  461. perm_string += mask_to_string(group_mask);
  462. childSetText("GroupMaskDebug",perm_string);
  463. childSetVisible("GroupMaskDebug",TRUE);
  465. perm_string = "E";
  466. perm_string += overwrite_everyone ? "*: " : ": ";
  467. perm_string += mask_to_string(everyone_mask);
  468. childSetText("EveryoneMaskDebug",perm_string);
  469. childSetVisible("EveryoneMaskDebug",TRUE);
  471. perm_string = "N";
  472. perm_string += slam_perm ? "*: " : ": ";
  473. perm_string += mask_to_string(next_owner_mask);
  474. childSetText("NextMaskDebug",perm_string);
  475. childSetVisible("NextMaskDebug",TRUE);
  476. }
  477. else
  478. {
  479. childSetVisible("BaseMaskDebug",FALSE);
  480. childSetVisible("OwnerMaskDebug",FALSE);
  481. childSetVisible("GroupMaskDebug",FALSE);
  482. childSetVisible("EveryoneMaskDebug",FALSE);
  483. childSetVisible("NextMaskDebug",FALSE);
  484. }
  486. /////////////
  487. // SHARING //
  488. /////////////
  490. // Check for ability to change values.
  491. if (is_link || cannot_restrict_permissions)
  492. {
  493. childSetEnabled("CheckShareWithGroup",FALSE);
  494. childSetEnabled("CheckEveryoneCopy",FALSE);
  495. }
  496. else if (is_obj_modify && can_agent_manipulate)
  497. {
  498. childSetEnabled("CheckShareWithGroup",TRUE);
  499. childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER));
  500. }
  501. else
  502. {
  503. childSetEnabled("CheckShareWithGroup",FALSE);
  504. childSetEnabled("CheckEveryoneCopy",FALSE);
  505. }
  507. // Set values.
  508. BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE;
  509. BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE;
  510. BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE;
  512. if (is_group_copy && is_group_modify && is_group_move)
  513. {
  514. childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE));
  516. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  517. if(ctl)
  518. {
  519. ctl->setTentative(FALSE);
  520. }
  521. }
  522. else if (!is_group_copy && !is_group_modify && !is_group_move)
  523. {
  524. childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE));
  525. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  526. if(ctl)
  527. {
  528. ctl->setTentative(FALSE);
  529. }
  530. }
  531. else
  532. {
  533. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  534. if(ctl)
  535. {
  536. ctl->setTentative(TRUE);
  537. ctl->set(TRUE);
  538. }
  539. }
  541. childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY)));
  543. ///////////////
  544. // SALE INFO //
  545. ///////////////
  547. const LLSaleInfo& sale_info = item->getSaleInfo();
  548. BOOL is_for_sale = sale_info.isForSale();
  549. // Check for ability to change values.
  550. if (is_obj_modify && can_agent_sell 
  551. && gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE))
  552. {
  553. childSetEnabled("SaleLabel",is_complete);
  554. childSetEnabled("CheckPurchase",is_complete);
  556. childSetEnabled("NextOwnerLabel",TRUE);
  557. childSetEnabled("CheckNextOwnerModify",(base_mask & PERM_MODIFY) && !cannot_restrict_permissions);
  558. childSetEnabled("CheckNextOwnerCopy",(base_mask & PERM_COPY) && !cannot_restrict_permissions);
  559. childSetEnabled("CheckNextOwnerTransfer",(next_owner_mask & PERM_COPY) && !cannot_restrict_permissions);
  561. childSetEnabled("RadioSaleType",is_complete && is_for_sale);
  562. childSetEnabled("TextPrice",is_complete && is_for_sale);
  563. childSetEnabled("Edit Cost",is_complete && is_for_sale);
  564. }
  565. else
  566. {
  567. childSetEnabled("SaleLabel",FALSE);
  568. childSetEnabled("CheckPurchase",FALSE);
  570. childSetEnabled("NextOwnerLabel",FALSE);
  571. childSetEnabled("CheckNextOwnerModify",FALSE);
  572. childSetEnabled("CheckNextOwnerCopy",FALSE);
  573. childSetEnabled("CheckNextOwnerTransfer",FALSE);
  575. childSetEnabled("RadioSaleType",FALSE);
  576. childSetEnabled("TextPrice",FALSE);
  577. childSetEnabled("Edit Cost",FALSE);
  578. }
  580. // Set values.
  581. childSetValue("CheckPurchase", is_for_sale);
  582. childSetEnabled("combobox sale copy", is_for_sale);
  583. childSetEnabled("Edit Cost", is_for_sale);
  584. childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY)));
  585. childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY)));
  586. childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER)));
  588. LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType");
  589. if (is_for_sale)
  590. {
  591. radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1);
  592. S32 numerical_price;
  593. numerical_price = sale_info.getSalePrice();
  594. childSetText("Edit Cost",llformat("%d",numerical_price));
  595. }
  596. else
  597. {
  598. radioSaleType->setSelectedIndex(-1);
  599. childSetText("Edit Cost",llformat("%d",0));
  600. }
  601. }
  603. void LLSidepanelItemInfo::onClickCreator()
  604. {
  605. LLViewerInventoryItem* item = findItem();
  606. if(!item) return;
  607. if(!item->getCreatorUUID().isNull())
  608. {
  609. LLAvatarActions::showProfile(item->getCreatorUUID());
  610. }
  611. }
  613. // static
  614. void LLSidepanelItemInfo::onClickOwner()
  615. {
  616. LLViewerInventoryItem* item = findItem();
  617. if(!item) return;
  618. if(item->getPermissions().isGroupOwned())
  619. {
  620. LLGroupActions::show(item->getPermissions().getGroup());
  621. }
  622. else
  623. {
  624. LLAvatarActions::showProfile(item->getPermissions().getOwner());
  625. }
  626. }
  628. // static
  629. void LLSidepanelItemInfo::onCommitName()
  630. {
  631. //llinfos << "LLSidepanelItemInfo::onCommitName()" << llendl;
  632. LLViewerInventoryItem* item = findItem();
  633. if(!item)
  634. {
  635. return;
  636. }
  637. LLLineEditor* labelItemName = getChild<LLLineEditor>("LabelItemName");
  639. if(labelItemName&&
  640.    (item->getName() != labelItemName->getText()) && 
  641.    (gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)) )
  642. {
  643. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  644. new_item->rename(labelItemName->getText());
  645. if(mObjectID.isNull())
  646. {
  647. new_item->updateServer(FALSE);
  648. gInventory.updateItem(new_item);
  649. gInventory.notifyObservers();
  650. }
  651. else
  652. {
  653. LLViewerObject* object = gObjectList.findObject(mObjectID);
  654. if(object)
  655. {
  656. object->updateInventory(
  657. new_item,
  658. TASK_INVENTORY_ITEM_KEY,
  659. false);
  660. }
  661. }
  662. }
  663. }
  665. void LLSidepanelItemInfo::onCommitDescription()
  666. {
  667. //llinfos << "LLSidepanelItemInfo::onCommitDescription()" << llendl;
  668. LLViewerInventoryItem* item = findItem();
  669. if(!item) return;
  671. LLLineEditor* labelItemDesc = getChild<LLLineEditor>("LabelItemDesc");
  672. if(!labelItemDesc)
  673. {
  674. return;
  675. }
  676. if((item->getDescription() != labelItemDesc->getText()) && 
  677.    (gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)))
  678. {
  679. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  681. new_item->setDescription(labelItemDesc->getText());
  682. if(mObjectID.isNull())
  683. {
  684. new_item->updateServer(FALSE);
  685. gInventory.updateItem(new_item);
  686. gInventory.notifyObservers();
  687. }
  688. else
  689. {
  690. LLViewerObject* object = gObjectList.findObject(mObjectID);
  691. if(object)
  692. {
  693. object->updateInventory(
  694. new_item,
  695. TASK_INVENTORY_ITEM_KEY,
  696. false);
  697. }
  698. }
  699. }
  700. }
  702. // static
  703. void LLSidepanelItemInfo::onCommitPermissions()
  704. {
  705. //llinfos << "LLSidepanelItemInfo::onCommitPermissions()" << llendl;
  706. LLViewerInventoryItem* item = findItem();
  707. if(!item) return;
  708. LLPermissions perm(item->getPermissions());
  711. LLCheckBoxCtrl* CheckShareWithGroup = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  713. if(CheckShareWithGroup)
  714. {
  715. perm.setGroupBits(gAgent.getID(), gAgent.getGroupID(),
  716. CheckShareWithGroup->get(),
  717. PERM_MODIFY | PERM_MOVE | PERM_COPY);
  718. }
  719. LLCheckBoxCtrl* CheckEveryoneCopy = getChild<LLCheckBoxCtrl>("CheckEveryoneCopy");
  720. if(CheckEveryoneCopy)
  721. {
  722. perm.setEveryoneBits(gAgent.getID(), gAgent.getGroupID(),
  723.  CheckEveryoneCopy->get(), PERM_COPY);
  724. }
  726. LLCheckBoxCtrl* CheckNextOwnerModify = getChild<LLCheckBoxCtrl>("CheckNextOwnerModify");
  727. if(CheckNextOwnerModify)
  728. {
  729. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  730. CheckNextOwnerModify->get(), PERM_MODIFY);
  731. }
  732. LLCheckBoxCtrl* CheckNextOwnerCopy = getChild<LLCheckBoxCtrl>("CheckNextOwnerCopy");
  733. if(CheckNextOwnerCopy)
  734. {
  735. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  736. CheckNextOwnerCopy->get(), PERM_COPY);
  737. }
  738. LLCheckBoxCtrl* CheckNextOwnerTransfer = getChild<LLCheckBoxCtrl>("CheckNextOwnerTransfer");
  739. if(CheckNextOwnerTransfer)
  740. {
  741. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  742. CheckNextOwnerTransfer->get(), PERM_TRANSFER);
  743. }
  744. if(perm != item->getPermissions()
  745. && item->isComplete())
  746. {
  747. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  748. new_item->setPermissions(perm);
  749. U32 flags = new_item->getFlags();
  750. // If next owner permissions have changed (and this is an object)
  751. // then set the slam permissions flag so that they are applied on rez.
  752. if((perm.getMaskNextOwner()!=item->getPermissions().getMaskNextOwner())
  753.    && (item->getType() == LLAssetType::AT_OBJECT))
  754. {
  755. flags |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
  756. }
  757. // If everyone permissions have changed (and this is an object)
  758. // then set the overwrite everyone permissions flag so they
  759. // are applied on rez.
  760. if ((perm.getMaskEveryone()!=item->getPermissions().getMaskEveryone())
  761. && (item->getType() == LLAssetType::AT_OBJECT))
  762. {
  763. flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
  764. }
  765. // If group permissions have changed (and this is an object)
  766. // then set the overwrite group permissions flag so they
  767. // are applied on rez.
  768. if ((perm.getMaskGroup()!=item->getPermissions().getMaskGroup())
  769. && (item->getType() == LLAssetType::AT_OBJECT))
  770. {
  771. flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
  772. }
  773. new_item->setFlags(flags);
  774. if(mObjectID.isNull())
  775. {
  776. new_item->updateServer(FALSE);
  777. gInventory.updateItem(new_item);
  778. gInventory.notifyObservers();
  779. }
  780. else
  781. {
  782. LLViewerObject* object = gObjectList.findObject(mObjectID);
  783. if(object)
  784. {
  785. object->updateInventory(
  786. new_item,
  787. TASK_INVENTORY_ITEM_KEY,
  788. false);
  789. }
  790. }
  791. }
  792. else
  793. {
  794. // need to make sure we don't just follow the click
  795. refresh();
  796. }
  797. }
  799. // static
  800. void LLSidepanelItemInfo::onCommitSaleInfo()
  801. {
  802. //llinfos << "LLSidepanelItemInfo::onCommitSaleInfo()" << llendl;
  803. updateSaleInfo();
  804. }
  806. // static
  807. void LLSidepanelItemInfo::onCommitSaleType()
  808. {
  809. //llinfos << "LLSidepanelItemInfo::onCommitSaleType()" << llendl;
  810. updateSaleInfo();
  811. }
  813. void LLSidepanelItemInfo::updateSaleInfo()
  814. {
  815. LLViewerInventoryItem* item = findItem();
  816. if(!item) return;
  817. LLSaleInfo sale_info(item->getSaleInfo());
  818. if(!gAgent.allowOperation(PERM_TRANSFER, item->getPermissions(), GP_OBJECT_SET_SALE))
  819. {
  820. childSetValue("CheckPurchase",LLSD((BOOL)FALSE));
  821. }
  823. if((BOOL)childGetValue("CheckPurchase"))
  824. {
  825. // turn on sale info
  826. LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_COPY;
  828. LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("RadioSaleType");
  829. if(RadioSaleType)
  830. {
  831. switch (RadioSaleType->getSelectedIndex())
  832. {
  833. case 0:
  834. sale_type = LLSaleInfo::FS_ORIGINAL;
  835. break;
  836. case 1:
  837. sale_type = LLSaleInfo::FS_COPY;
  838. break;
  839. case 2:
  840. sale_type = LLSaleInfo::FS_CONTENTS;
  841. break;
  842. default:
  843. sale_type = LLSaleInfo::FS_COPY;
  844. break;
  845. }
  846. }
  848. if (sale_type == LLSaleInfo::FS_COPY 
  849. && !gAgent.allowOperation(PERM_COPY, item->getPermissions(), 
  850.   GP_OBJECT_SET_SALE))
  851. {
  852. sale_type = LLSaleInfo::FS_ORIGINAL;
  853. }
  855.      
  857. S32 price = -1;
  858. price =  getChild<LLUICtrl>("Edit Cost")->getValue().asInteger();;
  860. // Invalid data - turn off the sale
  861. if (price < 0)
  862. {
  863. sale_type = LLSaleInfo::FS_NOT;
  864. price = 0;
  865. }
  867. sale_info.setSaleType(sale_type);
  868. sale_info.setSalePrice(price);
  869. }
  870. else
  871. {
  872. sale_info.setSaleType(LLSaleInfo::FS_NOT);
  873. }
  874. if(sale_info != item->getSaleInfo()
  875. && item->isComplete())
  876. {
  877. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  879. // Force an update on the sale price at rez
  880. if (item->getType() == LLAssetType::AT_OBJECT)
  881. {
  882. U32 flags = new_item->getFlags();
  883. flags |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_SALE;
  884. new_item->setFlags(flags);
  885. }
  887. new_item->setSaleInfo(sale_info);
  888. if(mObjectID.isNull())
  889. {
  890. // This is in the agent's inventory.
  891. new_item->updateServer(FALSE);
  892. gInventory.updateItem(new_item);
  893. gInventory.notifyObservers();
  894. }
  895. else
  896. {
  897. // This is in an object's contents.
  898. LLViewerObject* object = gObjectList.findObject(mObjectID);
  899. if(object)
  900. {
  901. object->updateInventory(
  902. new_item,
  903. TASK_INVENTORY_ITEM_KEY,
  904. false);
  905. }
  906. }
  907. }
  908. else
  909. {
  910. // need to make sure we don't just follow the click
  911. refresh();
  912. }
  913. }
  915. LLViewerInventoryItem* LLSidepanelItemInfo::findItem() const
  916. {
  917. LLViewerInventoryItem* item = NULL;
  918. if(mObjectID.isNull())
  919. {
  920. // it is in agent inventory
  921. item = gInventory.getItem(mItemID);
  922. }
  923. else
  924. {
  925. LLViewerObject* object = gObjectList.findObject(mObjectID);
  926. if(object)
  927. {
  928. item = static_cast<LLViewerInventoryItem*>(object->getInventoryObject(mItemID));
  929. }
  930. }
  931. return item;
  932. }
  934. // virtual
  935. void LLSidepanelItemInfo::save()
  936. {
  937. onCommitName();
  938. onCommitDescription();
  939. onCommitPermissions();
  940. onCommitSaleInfo();
  941. onCommitSaleType();
  942. }