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

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

游戏引擎

开发平台：

C++ Builder

llfloaterproperties.cpp：源码内容
  1. /** 
  2.  * @file llfloaterproperties.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 "llfloaterproperties.h"
  36. #include <algorithm>
  37. #include <functional>
  38. #include "llcachename.h"
  39. #include "lldbstrings.h"
  40. #include "llfloaterreg.h"
  41. #include "llinventory.h"
  43. #include "llagent.h"
  44. #include "llbutton.h"
  45. #include "llcheckboxctrl.h"
  46. #include "llavataractions.h"
  47. #include "llinventoryobserver.h"
  48. #include "llinventorymodel.h"
  49. #include "lllineeditor.h"
  50. //#include "llspinctrl.h"
  51. #include "llradiogroup.h"
  52. #include "llresmgr.h"
  53. #include "roles_constants.h"
  54. #include "llselectmgr.h"
  55. #include "lltextbox.h"
  56. #include "lltrans.h"
  57. #include "lluiconstants.h"
  58. #include "llviewerinventory.h"
  59. #include "llviewerobjectlist.h"
  60. #include "llviewerregion.h"
  61. #include "llviewercontrol.h"
  62. #include "llviewerwindow.h"
  63. #include "llgroupactions.h"
  65. #include "lluictrlfactory.h"
  68. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  69. // Class LLPropertiesObserver
  70. //
  71. // helper class to watch the inventory. 
  72. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  74. // Ugh. This can't be a singleton because it needs to remove itself
  75. //  from the inventory observer list when destroyed, which could
  76. //  happen after gInventory has already been destroyed if a singleton.
  77. // Instead, do our own ref counting and create / destroy it as needed
  78. class LLPropertiesObserver : public LLInventoryObserver
  79. {
  80. public:
  81. LLPropertiesObserver(LLFloaterProperties* floater)
  82. : mFloater(floater)
  83. {
  84. gInventory.addObserver(this);
  85. }
  86. virtual ~LLPropertiesObserver()
  87. {
  88. gInventory.removeObserver(this);
  89. }
  90. virtual void changed(U32 mask);
  91. private:
  92. LLFloaterProperties* mFloater;
  93. };
  95. void LLPropertiesObserver::changed(U32 mask)
  96. {
  97. // if there's a change we're interested in.
  98. if((mask & (LLInventoryObserver::LABEL | LLInventoryObserver::INTERNAL | LLInventoryObserver::REMOVE)) != 0)
  99. {
  100. mFloater->dirty();
  101. }
  102. }
  106. ///----------------------------------------------------------------------------
  107. /// Class LLFloaterProperties
  108. ///----------------------------------------------------------------------------
  110. // Default constructor
  111. LLFloaterProperties::LLFloaterProperties(const LLUUID& item_id)
  112.   : LLFloater(mItemID),
  113. mItemID(item_id),
  114. mDirty(TRUE)
  115. {
  116. mPropertiesObserver = new LLPropertiesObserver(this);
  118. //LLUICtrlFactory::getInstance()->buildFloater(this,"floater_inventory_item_properties.xml");
  119. }
  121. // Destroys the object
  122. LLFloaterProperties::~LLFloaterProperties()
  123. {
  124. delete mPropertiesObserver;
  125. mPropertiesObserver = NULL;
  126. }
  128. // virtual
  129. BOOL LLFloaterProperties::postBuild()
  130. {
  131. // build the UI
  132. // item name & description
  133. childSetPrevalidate("LabelItemName",&LLTextValidate::validateASCIIPrintableNoPipe);
  134. getChild<LLUICtrl>("LabelItemName")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitName,this));
  135. childSetPrevalidate("LabelItemDesc",&LLTextValidate::validateASCIIPrintableNoPipe);
  136. getChild<LLUICtrl>("LabelItemDesc")->setCommitCallback(boost::bind(&LLFloaterProperties:: onCommitDescription, this));
  137. // Creator information
  138. getChild<LLUICtrl>("BtnCreator")->setCommitCallback(boost::bind(&LLFloaterProperties::onClickCreator,this));
  139. // owner information
  140. getChild<LLUICtrl>("BtnOwner")->setCommitCallback(boost::bind(&LLFloaterProperties::onClickOwner,this));
  141. // acquired date
  142. // owner permissions
  143. // Permissions debug text
  144. // group permissions
  145. getChild<LLUICtrl>("CheckShareWithGroup")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitPermissions, this));
  146. // everyone permissions
  147. getChild<LLUICtrl>("CheckEveryoneCopy")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitPermissions, this));
  148. // next owner permissions
  149. getChild<LLUICtrl>("CheckNextOwnerModify")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitPermissions, this));
  150. getChild<LLUICtrl>("CheckNextOwnerCopy")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitPermissions, this));
  151. getChild<LLUICtrl>("CheckNextOwnerTransfer")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitPermissions, this));
  152. // Mark for sale or not, and sale info
  153. getChild<LLUICtrl>("CheckPurchase")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitSaleInfo, this));
  154. getChild<LLUICtrl>("RadioSaleType")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitSaleType, this));
  155. // "Price" label for edit
  156. getChild<LLUICtrl>("Edit Cost")->setCommitCallback(boost::bind(&LLFloaterProperties::onCommitSaleInfo, this));
  157. // The UI has been built, now fill in all the values
  158. refresh();
  160. return TRUE;
  161. }
  163. // virtual
  164. void LLFloaterProperties::onOpen(const LLSD& key)
  165. {
  166. refresh();
  167. }
  169. void LLFloaterProperties::refresh()
  170. {
  171. LLInventoryItem* item = findItem();
  172. if(item)
  173. {
  174. refreshFromItem(item);
  175. }
  176. else
  177. {
  178. //RN: it is possible that the container object is in the middle of an inventory refresh
  179. // causing findItem() to fail, so just temporarily disable everything
  181. mDirty = TRUE;
  183. const char* enableNames[]={
  184. "LabelItemName",
  185. "LabelItemDesc",
  186. "LabelCreatorName",
  187. "BtnCreator",
  188. "LabelOwnerName",
  189. "BtnOwner",
  190. "CheckOwnerModify",
  191. "CheckOwnerCopy",
  192. "CheckOwnerTransfer",
  193. "CheckShareWithGroup",
  194. "CheckEveryoneCopy",
  195. "CheckNextOwnerModify",
  196. "CheckNextOwnerCopy",
  197. "CheckNextOwnerTransfer",
  198. "CheckPurchase",
  199. "RadioSaleType",
  200. "Edit Cost"
  201. };
  202. for(size_t t=0; t<LL_ARRAY_SIZE(enableNames); ++t)
  203. {
  204. childSetEnabled(enableNames[t],false);
  205. }
  206. const char* hideNames[]={
  207. "BaseMaskDebug",
  208. "OwnerMaskDebug",
  209. "GroupMaskDebug",
  210. "EveryoneMaskDebug",
  211. "NextMaskDebug"
  212. };
  213. for(size_t t=0; t<LL_ARRAY_SIZE(hideNames); ++t)
  214. {
  215. childSetVisible(hideNames[t],false);
  216. }
  217. }
  218. }
  220. void LLFloaterProperties::draw()
  221. {
  222. if (mDirty)
  223. {
  224. // RN: clear dirty first because refresh can set dirty to TRUE
  225. mDirty = FALSE;
  226. refresh();
  227. }
  229. LLFloater::draw();
  230. }
  232. void LLFloaterProperties::refreshFromItem(LLInventoryItem* item)
  233. {
  234. ////////////////////////
  235. // PERMISSIONS LOOKUP //
  236. ////////////////////////
  238. // do not enable the UI for incomplete items.
  239. LLViewerInventoryItem* i = (LLViewerInventoryItem*)item;
  240. BOOL is_complete = i->isComplete();
  241. const BOOL cannot_restrict_permissions = LLInventoryType::cannotRestrictPermissions(i->getInventoryType());
  242. const BOOL is_calling_card = (i->getInventoryType() == LLInventoryType::IT_CALLINGCARD);
  243. const LLPermissions& perm = item->getPermissions();
  244. const BOOL can_agent_manipulate = gAgent.allowOperation(PERM_OWNER, perm, 
  245. GP_OBJECT_MANIPULATE);
  246. const BOOL can_agent_sell = gAgent.allowOperation(PERM_OWNER, perm, 
  247.   GP_OBJECT_SET_SALE) &&
  248. !cannot_restrict_permissions;
  249. const BOOL is_link = i->getIsLinkType();
  251. // You need permission to modify the object to modify an inventory
  252. // item in it.
  253. LLViewerObject* object = NULL;
  254. if(!mObjectID.isNull()) object = gObjectList.findObject(mObjectID);
  255. BOOL is_obj_modify = TRUE;
  256. if(object)
  257. {
  258. is_obj_modify = object->permOwnerModify();
  259. }
  261. //////////////////////
  262. // ITEM NAME & DESC //
  263. //////////////////////
  264. BOOL is_modifiable = gAgent.allowOperation(PERM_MODIFY, perm,
  265.    GP_OBJECT_MANIPULATE)
  266. && is_obj_modify && is_complete;
  268. childSetEnabled("LabelItemNameTitle",TRUE);
  269. childSetEnabled("LabelItemName",is_modifiable && !is_calling_card); // for now, don't allow rename of calling cards
  270. childSetText("LabelItemName",item->getName());
  271. childSetEnabled("LabelItemDescTitle",TRUE);
  272. childSetEnabled("LabelItemDesc",is_modifiable);
  273. childSetVisible("IconLocked",!is_modifiable);
  274. childSetText("LabelItemDesc",item->getDescription());
  276. //////////////////
  277. // CREATOR NAME //
  278. //////////////////
  279. if(!gCacheName) return;
  280. if(!gAgent.getRegion()) return;
  282. if (item->getCreatorUUID().notNull())
  283. {
  284. std::string name;
  285. gCacheName->getFullName(item->getCreatorUUID(), name);
  286. childSetEnabled("BtnCreator",TRUE);
  287. childSetEnabled("LabelCreatorTitle",TRUE);
  288. childSetEnabled("LabelCreatorName",TRUE);
  289. childSetText("LabelCreatorName",name);
  290. }
  291. else
  292. {
  293. childSetEnabled("BtnCreator",FALSE);
  294. childSetEnabled("LabelCreatorTitle",FALSE);
  295. childSetEnabled("LabelCreatorName",FALSE);
  296. childSetText("LabelCreatorName",getString("unknown"));
  297. }
  299. ////////////////
  300. // OWNER NAME //
  301. ////////////////
  302. if(perm.isOwned())
  303. {
  304. std::string name;
  305. if (perm.isGroupOwned())
  306. {
  307. gCacheName->getGroupName(perm.getGroup(), name);
  308. }
  309. else
  310. {
  311. gCacheName->getFullName(perm.getOwner(), name);
  312. }
  313. childSetEnabled("BtnOwner",TRUE);
  314. childSetEnabled("LabelOwnerTitle",TRUE);
  315. childSetEnabled("LabelOwnerName",TRUE);
  316. childSetText("LabelOwnerName",name);
  317. }
  318. else
  319. {
  320. childSetEnabled("BtnOwner",FALSE);
  321. childSetEnabled("LabelOwnerTitle",FALSE);
  322. childSetEnabled("LabelOwnerName",FALSE);
  323. childSetText("LabelOwnerName",getString("public"));
  324. }
  326. //////////////////
  327. // ACQUIRE DATE //
  328. //////////////////
  330. time_t time_utc = item->getCreationDate();
  331. if (0 == time_utc)
  332. {
  333. childSetText("LabelAcquiredDate",getString("unknown"));
  334. }
  335. else
  336. {
  337. std::string timeStr = getString("acquiredDate");
  338. LLSD substitution;
  339. substitution["datetime"] = (S32) time_utc;
  340. LLStringUtil::format (timeStr, substitution);
  341. childSetText ("LabelAcquiredDate", timeStr);
  342. }
  344. ///////////////////////
  345. // OWNER PERMISSIONS //
  346. ///////////////////////
  347. if(can_agent_manipulate)
  348. {
  349. childSetText("OwnerLabel",getString("you_can"));
  350. }
  351. else
  352. {
  353. childSetText("OwnerLabel",getString("owner_can"));
  354. }
  356. U32 base_mask = perm.getMaskBase();
  357. U32 owner_mask = perm.getMaskOwner();
  358. U32 group_mask = perm.getMaskGroup();
  359. U32 everyone_mask = perm.getMaskEveryone();
  360. U32 next_owner_mask = perm.getMaskNextOwner();
  362. childSetEnabled("OwnerLabel",TRUE);
  363. childSetEnabled("CheckOwnerModify",FALSE);
  364. childSetValue("CheckOwnerModify",LLSD((BOOL)(owner_mask & PERM_MODIFY)));
  365. childSetEnabled("CheckOwnerCopy",FALSE);
  366. childSetValue("CheckOwnerCopy",LLSD((BOOL)(owner_mask & PERM_COPY)));
  367. childSetEnabled("CheckOwnerTransfer",FALSE);
  368. childSetValue("CheckOwnerTransfer",LLSD((BOOL)(owner_mask & PERM_TRANSFER)));
  370. ///////////////////////
  371. // DEBUG PERMISSIONS //
  372. ///////////////////////
  374. if( gSavedSettings.getBOOL("DebugPermissions") )
  375. {
  376. BOOL slam_perm  = FALSE;
  377. BOOL overwrite_group = FALSE;
  378. BOOL overwrite_everyone = FALSE;
  380. if (item->getType() == LLAssetType::AT_OBJECT)
  381. {
  382. U32 flags = item->getFlags();
  383. slam_perm  = flags & LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
  384. overwrite_everyone = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
  385. overwrite_group = flags & LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
  386. }
  388. std::string perm_string;
  390. perm_string = "B: ";
  391. perm_string += mask_to_string(base_mask);
  392. childSetText("BaseMaskDebug",perm_string);
  393. childSetVisible("BaseMaskDebug",TRUE);
  395. perm_string = "O: ";
  396. perm_string += mask_to_string(owner_mask);
  397. childSetText("OwnerMaskDebug",perm_string);
  398. childSetVisible("OwnerMaskDebug",TRUE);
  400. perm_string = "G";
  401. perm_string += overwrite_group ? "*: " : ": ";
  402. perm_string += mask_to_string(group_mask);
  403. childSetText("GroupMaskDebug",perm_string);
  404. childSetVisible("GroupMaskDebug",TRUE);
  406. perm_string = "E";
  407. perm_string += overwrite_everyone ? "*: " : ": ";
  408. perm_string += mask_to_string(everyone_mask);
  409. childSetText("EveryoneMaskDebug",perm_string);
  410. childSetVisible("EveryoneMaskDebug",TRUE);
  412. perm_string = "N";
  413. perm_string += slam_perm ? "*: " : ": ";
  414. perm_string += mask_to_string(next_owner_mask);
  415. childSetText("NextMaskDebug",perm_string);
  416. childSetVisible("NextMaskDebug",TRUE);
  417. }
  418. else
  419. {
  420. childSetVisible("BaseMaskDebug",FALSE);
  421. childSetVisible("OwnerMaskDebug",FALSE);
  422. childSetVisible("GroupMaskDebug",FALSE);
  423. childSetVisible("EveryoneMaskDebug",FALSE);
  424. childSetVisible("NextMaskDebug",FALSE);
  425. }
  427. /////////////
  428. // SHARING //
  429. /////////////
  431. // Check for ability to change values.
  432. if (is_link || cannot_restrict_permissions)
  433. {
  434. childSetEnabled("CheckShareWithGroup",FALSE);
  435. childSetEnabled("CheckEveryoneCopy",FALSE);
  436. }
  437. else if (is_obj_modify && can_agent_manipulate)
  438. {
  439. childSetEnabled("CheckShareWithGroup",TRUE);
  440. childSetEnabled("CheckEveryoneCopy",(owner_mask & PERM_COPY) && (owner_mask & PERM_TRANSFER));
  441. }
  442. else
  443. {
  444. childSetEnabled("CheckShareWithGroup",FALSE);
  445. childSetEnabled("CheckEveryoneCopy",FALSE);
  446. }
  448. // Set values.
  449. BOOL is_group_copy = (group_mask & PERM_COPY) ? TRUE : FALSE;
  450. BOOL is_group_modify = (group_mask & PERM_MODIFY) ? TRUE : FALSE;
  451. BOOL is_group_move = (group_mask & PERM_MOVE) ? TRUE : FALSE;
  453. if (is_group_copy && is_group_modify && is_group_move)
  454. {
  455. childSetValue("CheckShareWithGroup",LLSD((BOOL)TRUE));
  457. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  458. if(ctl)
  459. {
  460. ctl->setTentative(FALSE);
  461. }
  462. }
  463. else if (!is_group_copy && !is_group_modify && !is_group_move)
  464. {
  465. childSetValue("CheckShareWithGroup",LLSD((BOOL)FALSE));
  466. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  467. if(ctl)
  468. {
  469. ctl->setTentative(FALSE);
  470. }
  471. }
  472. else
  473. {
  474. LLCheckBoxCtrl* ctl = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  475. if(ctl)
  476. {
  477. ctl->setTentative(TRUE);
  478. ctl->set(TRUE);
  479. }
  480. }
  482. childSetValue("CheckEveryoneCopy",LLSD((BOOL)(everyone_mask & PERM_COPY)));
  484. ///////////////
  485. // SALE INFO //
  486. ///////////////
  488. const LLSaleInfo& sale_info = item->getSaleInfo();
  489. BOOL is_for_sale = sale_info.isForSale();
  490. // Check for ability to change values.
  491. if (is_obj_modify && can_agent_sell 
  492. && gAgent.allowOperation(PERM_TRANSFER, perm, GP_OBJECT_MANIPULATE))
  493. {
  494. childSetEnabled("SaleLabel",is_complete);
  495. childSetEnabled("CheckPurchase",is_complete);
  497. childSetEnabled("NextOwnerLabel",TRUE);
  498. childSetEnabled("CheckNextOwnerModify",(base_mask & PERM_MODIFY) && !cannot_restrict_permissions);
  499. childSetEnabled("CheckNextOwnerCopy",(base_mask & PERM_COPY) && !cannot_restrict_permissions);
  500. childSetEnabled("CheckNextOwnerTransfer",(next_owner_mask & PERM_COPY) && !cannot_restrict_permissions);
  502. childSetEnabled("RadioSaleType",is_complete && is_for_sale);
  503. childSetEnabled("TextPrice",is_complete && is_for_sale);
  504. childSetEnabled("Edit Cost",is_complete && is_for_sale);
  505. }
  506. else
  507. {
  508. childSetEnabled("SaleLabel",FALSE);
  509. childSetEnabled("CheckPurchase",FALSE);
  511. childSetEnabled("NextOwnerLabel",FALSE);
  512. childSetEnabled("CheckNextOwnerModify",FALSE);
  513. childSetEnabled("CheckNextOwnerCopy",FALSE);
  514. childSetEnabled("CheckNextOwnerTransfer",FALSE);
  516. childSetEnabled("RadioSaleType",FALSE);
  517. childSetEnabled("TextPrice",FALSE);
  518. childSetEnabled("Edit Cost",FALSE);
  519. }
  521. // Set values.
  522. childSetValue("CheckPurchase", is_for_sale);
  523. childSetEnabled("combobox sale copy", is_for_sale);
  524. childSetEnabled("Edit Cost", is_for_sale);
  525. childSetValue("CheckNextOwnerModify",LLSD(BOOL(next_owner_mask & PERM_MODIFY)));
  526. childSetValue("CheckNextOwnerCopy",LLSD(BOOL(next_owner_mask & PERM_COPY)));
  527. childSetValue("CheckNextOwnerTransfer",LLSD(BOOL(next_owner_mask & PERM_TRANSFER)));
  529. LLRadioGroup* radioSaleType = getChild<LLRadioGroup>("RadioSaleType");
  530. if (is_for_sale)
  531. {
  532. radioSaleType->setSelectedIndex((S32)sale_info.getSaleType() - 1);
  533. S32 numerical_price;
  534. numerical_price = sale_info.getSalePrice();
  535. childSetText("Edit Cost",llformat("%d",numerical_price));
  536. }
  537. else
  538. {
  539. radioSaleType->setSelectedIndex(-1);
  540. childSetText("Edit Cost",llformat("%d",0));
  541. }
  542. }
  544. void LLFloaterProperties::onClickCreator()
  545. {
  546. LLInventoryItem* item = findItem();
  547. if(!item) return;
  548. if(!item->getCreatorUUID().isNull())
  549. {
  550. LLAvatarActions::showProfile(item->getCreatorUUID());
  551. }
  552. }
  554. // static
  555. void LLFloaterProperties::onClickOwner()
  556. {
  557. LLInventoryItem* item = findItem();
  558. if(!item) return;
  559. if(item->getPermissions().isGroupOwned())
  560. {
  561. LLGroupActions::show(item->getPermissions().getGroup());
  562. }
  563. else
  564. {
  565. LLAvatarActions::showProfile(item->getPermissions().getOwner());
  566. }
  567. }
  569. // static
  570. void LLFloaterProperties::onCommitName()
  571. {
  572. //llinfos << "LLFloaterProperties::onCommitName()" << llendl;
  573. LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
  574. if(!item)
  575. {
  576. return;
  577. }
  578. LLLineEditor* labelItemName = getChild<LLLineEditor>("LabelItemName");
  580. if(labelItemName&&
  581.    (item->getName() != labelItemName->getText()) && 
  582.    (gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)) )
  583. {
  584. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  585. new_item->rename(labelItemName->getText());
  586. if(mObjectID.isNull())
  587. {
  588. new_item->updateServer(FALSE);
  589. gInventory.updateItem(new_item);
  590. gInventory.notifyObservers();
  591. }
  592. else
  593. {
  594. LLViewerObject* object = gObjectList.findObject(mObjectID);
  595. if(object)
  596. {
  597. object->updateInventory(
  598. new_item,
  599. TASK_INVENTORY_ITEM_KEY,
  600. false);
  601. }
  602. }
  603. }
  604. }
  606. void LLFloaterProperties::onCommitDescription()
  607. {
  608. //llinfos << "LLFloaterProperties::onCommitDescription()" << llendl;
  609. LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
  610. if(!item) return;
  612. LLLineEditor* labelItemDesc = getChild<LLLineEditor>("LabelItemDesc");
  613. if(!labelItemDesc)
  614. {
  615. return;
  616. }
  617. if((item->getDescription() != labelItemDesc->getText()) && 
  618.    (gAgent.allowOperation(PERM_MODIFY, item->getPermissions(), GP_OBJECT_MANIPULATE)))
  619. {
  620. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  622. new_item->setDescription(labelItemDesc->getText());
  623. if(mObjectID.isNull())
  624. {
  625. new_item->updateServer(FALSE);
  626. gInventory.updateItem(new_item);
  627. gInventory.notifyObservers();
  628. }
  629. else
  630. {
  631. LLViewerObject* object = gObjectList.findObject(mObjectID);
  632. if(object)
  633. {
  634. object->updateInventory(
  635. new_item,
  636. TASK_INVENTORY_ITEM_KEY,
  637. false);
  638. }
  639. }
  640. }
  641. }
  643. // static
  644. void LLFloaterProperties::onCommitPermissions()
  645. {
  646. //llinfos << "LLFloaterProperties::onCommitPermissions()" << llendl;
  647. LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
  648. if(!item) return;
  649. LLPermissions perm(item->getPermissions());
  652. LLCheckBoxCtrl* CheckShareWithGroup = getChild<LLCheckBoxCtrl>("CheckShareWithGroup");
  654. if(CheckShareWithGroup)
  655. {
  656. perm.setGroupBits(gAgent.getID(), gAgent.getGroupID(),
  657. CheckShareWithGroup->get(),
  658. PERM_MODIFY | PERM_MOVE | PERM_COPY);
  659. }
  660. LLCheckBoxCtrl* CheckEveryoneCopy = getChild<LLCheckBoxCtrl>("CheckEveryoneCopy");
  661. if(CheckEveryoneCopy)
  662. {
  663. perm.setEveryoneBits(gAgent.getID(), gAgent.getGroupID(),
  664.  CheckEveryoneCopy->get(), PERM_COPY);
  665. }
  667. LLCheckBoxCtrl* CheckNextOwnerModify = getChild<LLCheckBoxCtrl>("CheckNextOwnerModify");
  668. if(CheckNextOwnerModify)
  669. {
  670. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  671. CheckNextOwnerModify->get(), PERM_MODIFY);
  672. }
  673. LLCheckBoxCtrl* CheckNextOwnerCopy = getChild<LLCheckBoxCtrl>("CheckNextOwnerCopy");
  674. if(CheckNextOwnerCopy)
  675. {
  676. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  677. CheckNextOwnerCopy->get(), PERM_COPY);
  678. }
  679. LLCheckBoxCtrl* CheckNextOwnerTransfer = getChild<LLCheckBoxCtrl>("CheckNextOwnerTransfer");
  680. if(CheckNextOwnerTransfer)
  681. {
  682. perm.setNextOwnerBits(gAgent.getID(), gAgent.getGroupID(),
  683. CheckNextOwnerTransfer->get(), PERM_TRANSFER);
  684. }
  685. if(perm != item->getPermissions()
  686. && item->isComplete())
  687. {
  688. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  689. new_item->setPermissions(perm);
  690. U32 flags = new_item->getFlags();
  691. // If next owner permissions have changed (and this is an object)
  692. // then set the slam permissions flag so that they are applied on rez.
  693. if((perm.getMaskNextOwner()!=item->getPermissions().getMaskNextOwner())
  694.    && (item->getType() == LLAssetType::AT_OBJECT))
  695. {
  696. flags |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_PERM;
  697. }
  698. // If everyone permissions have changed (and this is an object)
  699. // then set the overwrite everyone permissions flag so they
  700. // are applied on rez.
  701. if ((perm.getMaskEveryone()!=item->getPermissions().getMaskEveryone())
  702. && (item->getType() == LLAssetType::AT_OBJECT))
  703. {
  704. flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
  705. }
  706. // If group permissions have changed (and this is an object)
  707. // then set the overwrite group permissions flag so they
  708. // are applied on rez.
  709. if ((perm.getMaskGroup()!=item->getPermissions().getMaskGroup())
  710. && (item->getType() == LLAssetType::AT_OBJECT))
  711. {
  712. flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
  713. }
  714. new_item->setFlags(flags);
  715. if(mObjectID.isNull())
  716. {
  717. new_item->updateServer(FALSE);
  718. gInventory.updateItem(new_item);
  719. gInventory.notifyObservers();
  720. }
  721. else
  722. {
  723. LLViewerObject* object = gObjectList.findObject(mObjectID);
  724. if(object)
  725. {
  726. object->updateInventory(
  727. new_item,
  728. TASK_INVENTORY_ITEM_KEY,
  729. false);
  730. }
  731. }
  732. }
  733. else
  734. {
  735. // need to make sure we don't just follow the click
  736. refresh();
  737. }
  738. }
  740. // static
  741. void LLFloaterProperties::onCommitSaleInfo()
  742. {
  743. //llinfos << "LLFloaterProperties::onCommitSaleInfo()" << llendl;
  744. updateSaleInfo();
  745. }
  747. // static
  748. void LLFloaterProperties::onCommitSaleType()
  749. {
  750. //llinfos << "LLFloaterProperties::onCommitSaleType()" << llendl;
  751. updateSaleInfo();
  752. }
  754. void LLFloaterProperties::updateSaleInfo()
  755. {
  756. LLViewerInventoryItem* item = (LLViewerInventoryItem*)findItem();
  757. if(!item) return;
  758. LLSaleInfo sale_info(item->getSaleInfo());
  759. if(!gAgent.allowOperation(PERM_TRANSFER, item->getPermissions(), GP_OBJECT_SET_SALE))
  760. {
  761. childSetValue("CheckPurchase",LLSD((BOOL)FALSE));
  762. }
  764. if((BOOL)childGetValue("CheckPurchase"))
  765. {
  766. // turn on sale info
  767. LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_COPY;
  769. LLRadioGroup* RadioSaleType = getChild<LLRadioGroup>("RadioSaleType");
  770. if(RadioSaleType)
  771. {
  772. switch (RadioSaleType->getSelectedIndex())
  773. {
  774. case 0:
  775. sale_type = LLSaleInfo::FS_ORIGINAL;
  776. break;
  777. case 1:
  778. sale_type = LLSaleInfo::FS_COPY;
  779. break;
  780. case 2:
  781. sale_type = LLSaleInfo::FS_CONTENTS;
  782. break;
  783. default:
  784. sale_type = LLSaleInfo::FS_COPY;
  785. break;
  786. }
  787. }
  789. if (sale_type == LLSaleInfo::FS_COPY 
  790. && !gAgent.allowOperation(PERM_COPY, item->getPermissions(), 
  791.   GP_OBJECT_SET_SALE))
  792. {
  793. sale_type = LLSaleInfo::FS_ORIGINAL;
  794. }
  796.      
  798. S32 price = -1;
  799. price =  getChild<LLUICtrl>("Edit Cost")->getValue().asInteger();;
  801. // Invalid data - turn off the sale
  802. if (price < 0)
  803. {
  804. sale_type = LLSaleInfo::FS_NOT;
  805. price = 0;
  806. }
  808. sale_info.setSaleType(sale_type);
  809. sale_info.setSalePrice(price);
  810. }
  811. else
  812. {
  813. sale_info.setSaleType(LLSaleInfo::FS_NOT);
  814. }
  815. if(sale_info != item->getSaleInfo()
  816. && item->isComplete())
  817. {
  818. LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
  820. // Force an update on the sale price at rez
  821. if (item->getType() == LLAssetType::AT_OBJECT)
  822. {
  823. U32 flags = new_item->getFlags();
  824. flags |= LLInventoryItem::II_FLAGS_OBJECT_SLAM_SALE;
  825. new_item->setFlags(flags);
  826. }
  828. new_item->setSaleInfo(sale_info);
  829. if(mObjectID.isNull())
  830. {
  831. // This is in the agent's inventory.
  832. new_item->updateServer(FALSE);
  833. gInventory.updateItem(new_item);
  834. gInventory.notifyObservers();
  835. }
  836. else
  837. {
  838. // This is in an object's contents.
  839. LLViewerObject* object = gObjectList.findObject(mObjectID);
  840. if(object)
  841. {
  842. object->updateInventory(
  843. new_item,
  844. TASK_INVENTORY_ITEM_KEY,
  845. false);
  846. }
  847. }
  848. }
  849. else
  850. {
  851. // need to make sure we don't just follow the click
  852. refresh();
  853. }
  854. }
  856. LLInventoryItem* LLFloaterProperties::findItem() const
  857. {
  858. LLInventoryItem* item = NULL;
  859. if(mObjectID.isNull())
  860. {
  861. // it is in agent inventory
  862. item = gInventory.getItem(mItemID);
  863. }
  864. else
  865. {
  866. LLViewerObject* object = gObjectList.findObject(mObjectID);
  867. if(object)
  868. {
  869. item = (LLInventoryItem*)object->getInventoryObject(mItemID);
  870. }
  871. }
  872. return item;
  873. }
  875. //static
  876. void LLFloaterProperties::dirtyAll()
  877. {
  878. LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("properties");
  879. for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin();
  880.  iter != inst_list.end(); ++iter)
  881. {
  882. LLFloaterProperties* floater = dynamic_cast<LLFloaterProperties*>(*iter);
  883. llassert(floater); // else cast failed - wrong type D:
  884. if (floater)
  885. {
  886. floater->dirty();
  887. }
  888. }
  889. }
  891. ///----------------------------------------------------------------------------
  892. /// LLMultiProperties
  893. ///----------------------------------------------------------------------------
  895. LLMultiProperties::LLMultiProperties()
  896. : LLMultiFloater(LLSD())
  897. {
  898. // *TODO: There should be a .xml file for this
  899. const LLRect& nextrect = LLFloaterReg::getFloaterRect("properties"); // place where the next properties should show up
  900. if (nextrect.getWidth() > 0)
  901. {
  902. setRect(nextrect);
  903. }
  904. else
  905. {
  906. // start with a small rect in the top-left corner ; will get resized
  907. LLRect rect;
  908. rect.setLeftTopAndSize(0, gViewerWindow->getWindowHeightScaled(), 20, 20);
  909. setRect(rect);
  910. }
  911. setTitle(LLTrans::getString("MultiPropertiesTitle"));
  912. buildTabContainer();
  913. }
  915. ///----------------------------------------------------------------------------
  916. /// Local function definitions
  917. ///----------------------------------------------------------------------------