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

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

游戏引擎

开发平台：

C++ Builder

llsidepaneltaskinfo.cpp：源码内容
  1. /** 
  2.  * @file llsidepaneltaskinfo.cpp
  3.  * @brief LLSidepanelTaskInfo class implementation
  4.  * This class represents the panel in the build view for
  5.  * viewing/editing object names, owners, permissions, etc.
  6.  *
  7.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  8.  * 
  9.  * Copyright (c) 2002-2010, Linden Research, Inc.
  10.  * 
  11.  * Second Life Viewer Source Code
  12.  * The source code in this file ("Source Code") is provided by Linden Lab
  13.  * to you under the terms of the GNU General Public License, version 2.0
  14.  * ("GPL"), unless you have obtained a separate licensing agreement
  15.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  16.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  17.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  18.  * 
  19.  * There are special exceptions to the terms and conditions of the GPL as
  20.  * it is applied to this Source Code. View the full text of the exception
  21.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  22.  * online at
  23.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  24.  * 
  25.  * By copying, modifying or distributing this software, you acknowledge
  26.  * that you have read and understood your obligations described above,
  27.  * and agree to abide by those obligations.
  28.  * 
  29.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  30.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  31.  * COMPLETENESS OR PERFORMANCE.
  32.  * $/LicenseInfo$
  33.  */
  35. #include "llviewerprecompiledheaders.h"
  37. #include "llsidepaneltaskinfo.h"
  39. #include "lluuid.h"
  40. #include "llpermissions.h"
  41. #include "llcategory.h"
  42. #include "llclickaction.h"
  43. #include "llfocusmgr.h"
  44. #include "llnotificationsutil.h"
  45. #include "llstring.h"
  47. #include "llviewerwindow.h"
  48. #include "llresmgr.h"
  49. #include "lltextbox.h"
  50. #include "llbutton.h"
  51. #include "llcheckboxctrl.h"
  52. #include "llviewerobject.h"
  53. #include "llselectmgr.h"
  54. #include "llagent.h"
  55. #include "llstatusbar.h" // for getBalance()
  56. #include "lllineeditor.h"
  57. #include "llcombobox.h"
  58. #include "lluiconstants.h"
  59. #include "lldbstrings.h"
  60. #include "llfloatergroups.h"
  61. #include "llfloaterreg.h"
  62. #include "llavataractions.h"
  63. #include "llnamebox.h"
  64. #include "llviewercontrol.h"
  65. #include "llviewermenu.h"
  66. #include "lluictrlfactory.h"
  67. #include "llspinctrl.h"
  68. #include "roles_constants.h"
  69. #include "llgroupactions.h"
  71. ///----------------------------------------------------------------------------
  72. /// Class llsidepaneltaskinfo
  73. ///----------------------------------------------------------------------------
  75. LLSidepanelTaskInfo* LLSidepanelTaskInfo::sActivePanel = NULL;
  77. static LLRegisterPanelClassWrapper<LLSidepanelTaskInfo> t_task_info("sidepanel_task_info");
  79. // Default constructor
  80. LLSidepanelTaskInfo::LLSidepanelTaskInfo()
  81. {
  82. setMouseOpaque(FALSE);
  83. }
  86. LLSidepanelTaskInfo::~LLSidepanelTaskInfo()
  87. {
  88. if (sActivePanel == this)
  89. sActivePanel = NULL;
  90. }
  92. // virtual
  93. BOOL LLSidepanelTaskInfo::postBuild()
  94. {
  95. LLSidepanelInventorySubpanel::postBuild();
  97. mOpenBtn = getChild<LLButton>("open_btn");
  98. mOpenBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onOpenButtonClicked, this));
  99. mPayBtn = getChild<LLButton>("pay_btn");
  100. mPayBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onPayButtonClicked, this));
  101. mBuyBtn = getChild<LLButton>("buy_btn");
  102. mBuyBtn->setClickedCallback(boost::bind(&LLSidepanelTaskInfo::onBuyButtonClicked, this));
  104. mLabelGroupName = getChild<LLNameBox>("Group Name Proxy");
  106. childSetCommitCallback("Object Name", LLSidepanelTaskInfo::onCommitName,this);
  107. childSetPrevalidate("Object Name", LLTextValidate::validateASCIIPrintableNoPipe);
  108. childSetCommitCallback("Object Description", LLSidepanelTaskInfo::onCommitDesc,this);
  109. childSetPrevalidate("Object Description", LLTextValidate::validateASCIIPrintableNoPipe);
  110. getChild<LLUICtrl>("button set group")->setCommitCallback(boost::bind(&LLSidepanelTaskInfo::onClickGroup,this));
  111. childSetCommitCallback("checkbox share with group", &LLSidepanelTaskInfo::onCommitGroupShare,this);
  112. childSetAction("button deed", &LLSidepanelTaskInfo::onClickDeedToGroup,this);
  113. childSetCommitCallback("checkbox allow everyone move", &LLSidepanelTaskInfo::onCommitEveryoneMove,this);
  114. childSetCommitCallback("checkbox allow everyone copy", &LLSidepanelTaskInfo::onCommitEveryoneCopy,this);
  115. childSetCommitCallback("checkbox for sale", &LLSidepanelTaskInfo::onCommitSaleInfo,this);
  116. childSetCommitCallback("sale type", &LLSidepanelTaskInfo::onCommitSaleType,this);
  117. childSetCommitCallback("Edit Cost",  &LLSidepanelTaskInfo::onCommitSaleInfo, this);
  118. childSetCommitCallback("checkbox next owner can modify", &LLSidepanelTaskInfo::onCommitNextOwnerModify,this);
  119. childSetCommitCallback("checkbox next owner can copy", &LLSidepanelTaskInfo::onCommitNextOwnerCopy,this);
  120. childSetCommitCallback("checkbox next owner can transfer", &LLSidepanelTaskInfo::onCommitNextOwnerTransfer,this);
  121. childSetCommitCallback("clickaction", &LLSidepanelTaskInfo::onCommitClickAction,this);
  122. childSetCommitCallback("search_check", &LLSidepanelTaskInfo::onCommitIncludeInSearch,this);
  123. return TRUE;
  124. }
  126. // virtual
  127. void LLSidepanelTaskInfo::setVisible(BOOL visible)
  128. {
  129. LLPanel::setVisible(visible);
  130. if (visible)
  131. {
  132. sActivePanel = this;
  133. mObject = getFirstSelectedObject();
  134. }
  135. else
  136. {
  137. sActivePanel = NULL;
  138. }
  139. }
  141. void LLSidepanelTaskInfo::disableAll()
  142. {
  143. childSetEnabled("perm_modify", FALSE);
  144. childSetText("perm_modify", LLStringUtil::null);
  146. childSetEnabled("Creator:",     FALSE);
  147. childSetText("Creator Name", LLStringUtil::null);
  148. childSetEnabled("Creator Name", FALSE);
  150. childSetEnabled("Owner:", FALSE);
  151. childSetText("Owner Name", LLStringUtil::null);
  152. childSetEnabled("Owner Name", FALSE);
  154. childSetEnabled("Group:", FALSE);
  155. childSetText("Group Name", LLStringUtil::null);
  156. childSetEnabled("Group Name", FALSE);
  157. childSetEnabled("button set group", FALSE);
  159. childSetText("Object Name", LLStringUtil::null);
  160. childSetEnabled("Object Name", FALSE);
  161. childSetEnabled("Name:",     FALSE);
  162. childSetText("Group Name", LLStringUtil::null);
  163. childSetEnabled("Group Name", FALSE);
  164. childSetEnabled("Description:", FALSE);
  165. childSetText("Object Description", LLStringUtil::null);
  166. childSetEnabled("Object Description", FALSE);
  168. childSetEnabled("Permissions:", FALSE);
  170. childSetValue("checkbox share with group", FALSE);
  171. childSetEnabled("checkbox share with group",     FALSE);
  172. childSetEnabled("button deed", FALSE);
  174. childSetValue("checkbox allow everyone move",     FALSE);
  175. childSetEnabled("checkbox allow everyone move",     FALSE);
  176. childSetValue("checkbox allow everyone copy",     FALSE);
  177. childSetEnabled("checkbox allow everyone copy",     FALSE);
  179. //Next owner can:
  180. childSetEnabled("Next owner can:", FALSE);
  181. childSetValue("checkbox next owner can modify", FALSE);
  182. childSetEnabled("checkbox next owner can modify",   FALSE);
  183. childSetValue("checkbox next owner can copy",     FALSE);
  184. childSetEnabled("checkbox next owner can copy",     FALSE);
  185. childSetValue("checkbox next owner can transfer",   FALSE);
  186. childSetEnabled("checkbox next owner can transfer", FALSE);
  188. //checkbox for sale
  189. childSetValue("checkbox for sale", FALSE);
  190. childSetEnabled("checkbox for sale",     FALSE);
  192. //checkbox include in search
  193. childSetValue("search_check",   FALSE);
  194. childSetEnabled("search_check",   FALSE);
  196. LLComboBox* combo_sale_type = getChild<LLComboBox>("sale type");
  197. combo_sale_type->setValue(LLSaleInfo::FS_COPY);
  198. combo_sale_type->setEnabled(FALSE);
  200. childSetEnabled("Cost", FALSE);
  201. childSetText("Cost",     getString("Cost Default"));
  202. childSetText("Edit Cost", LLStringUtil::null);
  203. childSetEnabled("Edit Cost",     FALSE);
  205. childSetEnabled("label click action", FALSE);
  206. LLComboBox* combo_click_action = getChild<LLComboBox>("clickaction");
  207. if (combo_click_action)
  208. {
  209. combo_click_action->setEnabled(FALSE);
  210. combo_click_action->clear();
  211. }
  212. childSetVisible("B:", FALSE);
  213. childSetVisible("O:", FALSE);
  214. childSetVisible("G:", FALSE);
  215. childSetVisible("E:", FALSE);
  216. childSetVisible("N:", FALSE);
  217. childSetVisible("F:", FALSE);
  219. mOpenBtn->setEnabled(FALSE);
  220. mPayBtn->setEnabled(FALSE);
  221. mBuyBtn->setEnabled(FALSE);
  222. }
  224. void LLSidepanelTaskInfo::refresh()
  225. {
  226. LLButton* btn_deed_to_group = getChild<LLButton>("button deed");
  227. if (btn_deed_to_group)
  228. {
  229. std::string deedText;
  230. if (gWarningSettings.getBOOL("DeedObject"))
  231. {
  232. deedText = getString("text deed continued");
  233. }
  234. else
  235. {
  236. deedText = getString("text deed");
  237. }
  238. btn_deed_to_group->setLabelSelected(deedText);
  239. btn_deed_to_group->setLabelUnselected(deedText);
  240. }
  242. BOOL root_selected = TRUE;
  243. LLSelectNode* nodep = mObjectSelection->getFirstRootNode();
  244. S32 object_count = mObjectSelection->getRootObjectCount();
  245. if (!nodep || (object_count == 0))
  246. {
  247. nodep = mObjectSelection->getFirstNode();
  248. object_count = mObjectSelection->getObjectCount();
  249. root_selected = FALSE;
  250. }
  252. LLViewerObject* objectp = NULL;
  253. if (nodep)
  254. {
  255. objectp = nodep->getObject();
  256. }
  258. // ...nothing selected
  259. if (!nodep || !objectp)
  260. {
  261. disableAll();
  262. return;
  263. }
  265. // figure out a few variables
  266. const BOOL is_one_object = (object_count == 1);
  268. // BUG: fails if a root and non-root are both single-selected.
  269. const BOOL is_perm_modify = (mObjectSelection->getFirstRootNode() && LLSelectMgr::getInstance()->selectGetRootsModify()) ||
  270. LLSelectMgr::getInstance()->selectGetModify();
  271. const LLFocusableElement* keyboard_focus_view = gFocusMgr.getKeyboardFocus();
  273. S32 string_index = 0;
  274. std::string MODIFY_INFO_STRINGS[] =
  275. {
  276. getString("text modify info 1"),
  277. getString("text modify info 2"),
  278. getString("text modify info 3"),
  279. getString("text modify info 4")
  280. };
  281. if (!is_perm_modify)
  282. {
  283. string_index += 2;
  284. }
  285. if (!is_one_object)
  286. {
  287. ++string_index;
  288. }
  289. childSetEnabled("perm_modify",      TRUE);
  290. childSetText("perm_modify", MODIFY_INFO_STRINGS[string_index]);
  292. childSetEnabled("Permissions:",  TRUE);
  294. // Update creator text field
  295. childSetEnabled("Creator:",  TRUE);
  296. BOOL creators_identical;
  297. std::string creator_name;
  298. creators_identical = LLSelectMgr::getInstance()->selectGetCreator(mCreatorID,
  299.   creator_name);
  301. childSetText("Creator Name", creator_name);
  302. childSetEnabled("Creator Name",  TRUE);
  304. // Update owner text field
  305. childSetEnabled("Owner:",  TRUE);
  307. std::string owner_name;
  308. const BOOL owners_identical = LLSelectMgr::getInstance()->selectGetOwner(mOwnerID, owner_name);
  309. if (mOwnerID.isNull())
  310. {
  311. if (LLSelectMgr::getInstance()->selectIsGroupOwned())
  312. {
  313. // Group owned already displayed by selectGetOwner
  314. }
  315. else
  316. {
  317. // Display last owner if public
  318. std::string last_owner_name;
  319. LLSelectMgr::getInstance()->selectGetLastOwner(mLastOwnerID, last_owner_name);
  321. // It should never happen that the last owner is null and the owner
  322. // is null, but it seems to be a bug in the simulator right now. JC
  323. if (!mLastOwnerID.isNull() && !last_owner_name.empty())
  324. {
  325. owner_name.append(", last ");
  326. owner_name.append(last_owner_name);
  327. }
  328. }
  329. }
  330. childSetText("Owner Name", owner_name);
  331. childSetEnabled("Owner Name",  TRUE);
  333. // update group text field
  334. childSetEnabled("Group:",  TRUE);
  335. childSetText("Group Name",  LLStringUtil::null);
  336. LLUUID group_id;
  337. BOOL groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
  338. if (groups_identical)
  339. {
  340. if (mLabelGroupName)
  341. {
  342. mLabelGroupName->setNameID(group_id,TRUE);
  343. mLabelGroupName->setEnabled(TRUE);
  344. }
  345. }
  346. else
  347. {
  348. if (mLabelGroupName)
  349. {
  350. mLabelGroupName->setNameID(LLUUID::null, TRUE);
  351. mLabelGroupName->refresh(LLUUID::null,LLStringUtil::null, LLStringUtil::null, TRUE);
  352. mLabelGroupName->setEnabled(FALSE);
  353. }
  354. }
  356. childSetEnabled("button set group", owners_identical && (mOwnerID == gAgent.getID()));
  358. childSetEnabled("Name:",  TRUE);
  359. LLLineEditor* LineEditorObjectName = getChild<LLLineEditor>("Object Name");
  360. childSetEnabled("Description:",  TRUE);
  361. LLLineEditor* LineEditorObjectDesc = getChild<LLLineEditor>("Object Description");
  363. if (is_one_object)
  364. {
  365. if (keyboard_focus_view != LineEditorObjectName)
  366. {
  367. childSetText("Object Name",nodep->mName);
  368. }
  370. if (LineEditorObjectDesc)
  371. {
  372. if (keyboard_focus_view != LineEditorObjectDesc)
  373. {
  374. LineEditorObjectDesc->setText(nodep->mDescription);
  375. }
  376. }
  377. }
  378. else
  379. {
  380. childSetText("Object Name", LLStringUtil::null);
  381. LineEditorObjectDesc->setText(LLStringUtil::null);
  382. }
  384. // figure out the contents of the name, description, & category
  385. BOOL edit_name_desc = FALSE;
  386. if (is_one_object && objectp->permModify())
  387. {
  388. edit_name_desc = TRUE;
  389. }
  390. if (edit_name_desc)
  391. {
  392. childSetEnabled("Object Name",  TRUE);
  393. childSetEnabled("Object Description",  TRUE);
  394. }
  395. else
  396. {
  397. childSetEnabled("Object Name",  FALSE);
  398. childSetEnabled("Object Description",  FALSE);
  399. }
  401. S32 total_sale_price = 0;
  402. S32 individual_sale_price = 0;
  403. BOOL is_for_sale_mixed = FALSE;
  404. BOOL is_sale_price_mixed = FALSE;
  405. U32 num_for_sale = FALSE;
  406.     LLSelectMgr::getInstance()->selectGetAggregateSaleInfo(num_for_sale,
  407.    is_for_sale_mixed,
  408.    is_sale_price_mixed,
  409.    total_sale_price,
  410.    individual_sale_price);
  412. const BOOL self_owned = (gAgent.getID() == mOwnerID);
  413. const BOOL group_owned = LLSelectMgr::getInstance()->selectIsGroupOwned() ;
  414. const BOOL public_owned = (mOwnerID.isNull() && !LLSelectMgr::getInstance()->selectIsGroupOwned());
  415. const BOOL can_transfer = LLSelectMgr::getInstance()->selectGetRootsTransfer();
  416. const BOOL can_copy = LLSelectMgr::getInstance()->selectGetRootsCopy();
  418. if (!owners_identical)
  419. {
  420. childSetEnabled("Cost",  FALSE);
  421. childSetText("Edit Cost", LLStringUtil::null);
  422. childSetEnabled("Edit Cost",  FALSE);
  423. }
  424. // You own these objects.
  425. else if (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id,GP_OBJECT_SET_SALE)))
  426. {
  427. // If there are multiple items for sale then set text to PRICE PER UNIT.
  428. if (num_for_sale > 1)
  429. {
  430. childSetText("Cost", getString("Cost Per Unit"));
  431. }
  432. else
  433. {
  434. childSetText("Cost", getString("Cost Default"));
  435. }
  437. LLSpinCtrl *edit_price = getChild<LLSpinCtrl>("Edit Cost");
  438. if (!edit_price->hasFocus())
  439. {
  440. // If the sale price is mixed then set the cost to MIXED, otherwise
  441. // set to the actual cost.
  442. if ((num_for_sale > 0) && is_for_sale_mixed)
  443. {
  444. edit_price->setTentative(TRUE);
  445. }
  446. else if ((num_for_sale > 0) && is_sale_price_mixed)
  447. {
  448. edit_price->setTentative(TRUE);
  449. }
  450. else 
  451. {
  452. edit_price->setValue(individual_sale_price);
  453. }
  454. }
  455. // The edit fields are only enabled if you can sell this object
  456. // and the sale price is not mixed.
  457. BOOL enable_edit = (num_for_sale && can_transfer) ? !is_for_sale_mixed : FALSE;
  458. childSetEnabled("Cost", enable_edit);
  459. childSetEnabled("Edit Cost", enable_edit);
  460. }
  461. // Someone, not you, owns these objects.
  462. else if (!public_owned)
  463. {
  464. childSetEnabled("Cost", FALSE);
  465. childSetEnabled("Edit Cost", FALSE);
  467. // Don't show a price if none of the items are for sale.
  468. if (num_for_sale)
  469. childSetText("Edit Cost", llformat("%d",total_sale_price));
  470. else
  471. childSetText("Edit Cost", LLStringUtil::null);
  473. // If multiple items are for sale, set text to TOTAL PRICE.
  474. if (num_for_sale > 1)
  475. childSetText("Cost", getString("Cost Total"));
  476. else
  477. childSetText("Cost", getString("Cost Default"));
  478. }
  479. // This is a public object.
  480. else
  481. {
  482. childSetEnabled("Cost", FALSE);
  483. childSetText("Cost", getString("Cost Default"));
  485. childSetText("Edit Cost", LLStringUtil::null);
  486. childSetEnabled("Edit Cost", FALSE);
  487. }
  489. // Enable and disable the permissions checkboxes
  490. // based on who owns the object.
  491. // TODO: Creator permissions
  493. U32 base_mask_on  = 0;
  494. U32 base_mask_off   = 0;
  495. U32 owner_mask_off = 0;
  496. U32 owner_mask_on  = 0;
  497. U32 group_mask_on  = 0;
  498. U32 group_mask_off  = 0;
  499. U32 everyone_mask_on  = 0;
  500. U32 everyone_mask_off  = 0;
  501. U32 next_owner_mask_on  = 0;
  502. U32 next_owner_mask_off = 0;
  504. BOOL valid_base_perms  = LLSelectMgr::getInstance()->selectGetPerm(PERM_BASE,
  505. &base_mask_on,
  506. &base_mask_off);
  507. //BOOL valid_owner_perms =//
  508. LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER,
  509.   &owner_mask_on,
  510.   &owner_mask_off);
  511. BOOL valid_group_perms  = LLSelectMgr::getInstance()->selectGetPerm(PERM_GROUP,
  512. &group_mask_on,
  513. &group_mask_off);
  515. BOOL valid_everyone_perms  = LLSelectMgr::getInstance()->selectGetPerm(PERM_EVERYONE,
  516. &everyone_mask_on,
  517. &everyone_mask_off);
  519. BOOL valid_next_perms  = LLSelectMgr::getInstance()->selectGetPerm(PERM_NEXT_OWNER,
  520. &next_owner_mask_on,
  521. &next_owner_mask_off);
  524. if (gSavedSettings.getBOOL("DebugPermissions") )
  525. {
  526. if (valid_base_perms)
  527. {
  528. childSetText("B:", "B: " + mask_to_string(base_mask_on));
  529. childSetVisible("B:", TRUE);
  531. childSetText("O:", "O: " + mask_to_string(owner_mask_on));
  532. childSetVisible("O:", TRUE);
  534. childSetText("G:", "G: " + mask_to_string(group_mask_on));
  535. childSetVisible("G:", TRUE);
  537. childSetText("E:", "E: " + mask_to_string(everyone_mask_on));
  538. childSetVisible("E:", TRUE);
  540. childSetText("N:", "N: " + mask_to_string(next_owner_mask_on));
  541. childSetVisible("N:", TRUE);
  542. }
  544. U32 flag_mask = 0x0;
  545. if (objectp->permMove())  flag_mask |= PERM_MOVE;
  546. if (objectp->permModify())  flag_mask |= PERM_MODIFY;
  547. if (objectp->permCopy())  flag_mask |= PERM_COPY;
  548. if (objectp->permTransfer())  flag_mask |= PERM_TRANSFER;
  550. childSetText("F:", "F:" + mask_to_string(flag_mask));
  551. childSetVisible("F:", TRUE);
  552. }
  553. else
  554. {
  555. childSetVisible("B:", FALSE);
  556. childSetVisible("O:", FALSE);
  557. childSetVisible("G:", FALSE);
  558. childSetVisible("E:", FALSE);
  559. childSetVisible("N:", FALSE);
  560. childSetVisible("F:", FALSE);
  561. }
  563. BOOL has_change_perm_ability = FALSE;
  564. BOOL has_change_sale_ability = FALSE;
  566. if (valid_base_perms &&
  567. (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_MANIPULATE))))
  568. {
  569. has_change_perm_ability = TRUE;
  570. }
  571. if (valid_base_perms &&
  572.    (self_owned || (group_owned && gAgent.hasPowerInGroup(group_id, GP_OBJECT_SET_SALE))))
  573. {
  574. has_change_sale_ability = TRUE;
  575. }
  577. if (!has_change_perm_ability && !has_change_sale_ability && !root_selected)
  578. {
  579. // ...must select root to choose permissions
  580. childSetValue("perm_modify",  getString("text modify warning"));
  581. }
  583. if (has_change_perm_ability)
  584. {
  585. childSetEnabled("checkbox share with group", TRUE);
  586. childSetEnabled("checkbox allow everyone move", owner_mask_on & PERM_MOVE);
  587. childSetEnabled("checkbox allow everyone copy", owner_mask_on & PERM_COPY && owner_mask_on & PERM_TRANSFER);
  588. }
  589. else
  590. {
  591. childSetEnabled("checkbox share with group",  FALSE);
  592. childSetEnabled("checkbox allow everyone move",  FALSE);
  593. childSetEnabled("checkbox allow everyone copy",  FALSE);
  594. }
  596. if (has_change_sale_ability && (owner_mask_on & PERM_TRANSFER))
  597. {
  598. childSetEnabled("checkbox for sale",  can_transfer || (!can_transfer && num_for_sale));
  599. // Set the checkbox to tentative if the prices of each object selected
  600. // are not the same.
  601. childSetTentative("checkbox for sale",  is_for_sale_mixed);
  602. childSetEnabled("sale type",  num_for_sale && can_transfer && !is_sale_price_mixed);
  604. childSetEnabled("Next owner can:",  TRUE);
  605. childSetEnabled("checkbox next owner can modify",  base_mask_on & PERM_MODIFY);
  606. childSetEnabled("checkbox next owner can copy",  base_mask_on & PERM_COPY);
  607. childSetEnabled("checkbox next owner can transfer", next_owner_mask_on & PERM_COPY);
  608. }
  609. else 
  610. {
  611. childSetEnabled("checkbox for sale", FALSE);
  612. childSetEnabled("sale type", FALSE);
  614. childSetEnabled("Next owner can:", FALSE);
  615. childSetEnabled("checkbox next owner can modify", FALSE);
  616. childSetEnabled("checkbox next owner can copy", FALSE);
  617. childSetEnabled("checkbox next owner can transfer", FALSE);
  618. }
  620. if (valid_group_perms)
  621. {
  622. if ((group_mask_on & PERM_COPY) && (group_mask_on & PERM_MODIFY) && (group_mask_on & PERM_MOVE))
  623. {
  624. childSetValue("checkbox share with group", TRUE);
  625. childSetTentative("checkbox share with group", FALSE);
  626. childSetEnabled("button deed", gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
  627. }
  628. else if ((group_mask_off & PERM_COPY) && (group_mask_off & PERM_MODIFY) && (group_mask_off & PERM_MOVE))
  629. {
  630. childSetValue("checkbox share with group", FALSE);
  631. childSetTentative("checkbox share with group", FALSE);
  632. childSetEnabled("button deed", FALSE);
  633. }
  634. else
  635. {
  636. childSetValue("checkbox share with group", TRUE);
  637. childSetTentative("checkbox share with group", TRUE);
  638. childSetEnabled("button deed", gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED) && (group_mask_on & PERM_MOVE) && (owner_mask_on & PERM_TRANSFER) && !group_owned && can_transfer);
  639. }
  640. }
  642. if (valid_everyone_perms)
  643. {
  644. // Move
  645. if (everyone_mask_on & PERM_MOVE)
  646. {
  647. childSetValue("checkbox allow everyone move", TRUE);
  648. childSetTentative("checkbox allow everyone move",  FALSE);
  649. }
  650. else if (everyone_mask_off & PERM_MOVE)
  651. {
  652. childSetValue("checkbox allow everyone move", FALSE);
  653. childSetTentative("checkbox allow everyone move",  FALSE);
  654. }
  655. else
  656. {
  657. childSetValue("checkbox allow everyone move", TRUE);
  658. childSetTentative("checkbox allow everyone move",  TRUE);
  659. }
  661. // Copy == everyone can't copy
  662. if (everyone_mask_on & PERM_COPY)
  663. {
  664. childSetValue("checkbox allow everyone copy", TRUE);
  665. childSetTentative("checkbox allow everyone copy",  !can_copy || !can_transfer);
  666. }
  667. else if (everyone_mask_off & PERM_COPY)
  668. {
  669. childSetValue("checkbox allow everyone copy", FALSE);
  670. childSetTentative("checkbox allow everyone copy", FALSE);
  671. }
  672. else
  673. {
  674. childSetValue("checkbox allow everyone copy", TRUE);
  675. childSetTentative("checkbox allow everyone copy", TRUE);
  676. }
  677. }
  679. if (valid_next_perms)
  680. {
  681. // Modify == next owner canot modify
  682. if (next_owner_mask_on & PERM_MODIFY)
  683. {
  684. childSetValue("checkbox next owner can modify", TRUE);
  685. childSetTentative("checkbox next owner can modify", FALSE);
  686. }
  687. else if (next_owner_mask_off & PERM_MODIFY)
  688. {
  689. childSetValue("checkbox next owner can modify", FALSE);
  690. childSetTentative("checkbox next owner can modify", FALSE);
  691. }
  692. else
  693. {
  694. childSetValue("checkbox next owner can modify", TRUE);
  695. childSetTentative("checkbox next owner can modify", TRUE);
  696. }
  698. // Copy == next owner cannot copy
  699. if (next_owner_mask_on & PERM_COPY)
  700. {
  701. childSetValue("checkbox next owner can copy", TRUE);
  702. childSetTentative("checkbox next owner can copy", !can_copy);
  703. }
  704. else if (next_owner_mask_off & PERM_COPY)
  705. {
  706. childSetValue("checkbox next owner can copy", FALSE);
  707. childSetTentative("checkbox next owner can copy", FALSE);
  708. }
  709. else
  710. {
  711. childSetValue("checkbox next owner can copy", TRUE);
  712. childSetTentative("checkbox next owner can copy", TRUE);
  713. }
  715. // Transfer == next owner cannot transfer
  716. if (next_owner_mask_on & PERM_TRANSFER)
  717. {
  718. childSetValue("checkbox next owner can transfer", TRUE);
  719. childSetTentative("checkbox next owner can transfer", !can_transfer);
  720. }
  721. else if (next_owner_mask_off & PERM_TRANSFER)
  722. {
  723. childSetValue("checkbox next owner can transfer", FALSE);
  724. childSetTentative("checkbox next owner can transfer", FALSE);
  725. }
  726. else
  727. {
  728. childSetValue("checkbox next owner can transfer", TRUE);
  729. childSetTentative("checkbox next owner can transfer", TRUE);
  730. }
  731. }
  733. // reflect sale information
  734. LLSaleInfo sale_info;
  735. BOOL valid_sale_info = LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
  736. LLSaleInfo::EForSale sale_type = sale_info.getSaleType();
  738. LLComboBox* combo_sale_type = getChild<LLComboBox>("sale type");
  739. if (valid_sale_info)
  740. {
  741. combo_sale_type->setValue( sale_type == LLSaleInfo::FS_NOT ? LLSaleInfo::FS_COPY : sale_type);
  742. combo_sale_type->setTentative( FALSE); // unfortunately this doesn't do anything at the moment.
  743. }
  744. else
  745. {
  746. // default option is sell copy, determined to be safest
  747. combo_sale_type->setValue( LLSaleInfo::FS_COPY);
  748. combo_sale_type->setTentative( TRUE); // unfortunately this doesn't do anything at the moment.
  749. }
  751. childSetValue("checkbox for sale", (num_for_sale != 0));
  753. // HACK: There are some old objects in world that are set for sale,
  754. // but are no-transfer.  We need to let users turn for-sale off, but only
  755. // if for-sale is set.
  756. bool cannot_actually_sell = !can_transfer || (!can_copy && sale_type == LLSaleInfo::FS_COPY);
  757. if (cannot_actually_sell)
  758. {
  759. if (num_for_sale && has_change_sale_ability)
  760. {
  761. childSetEnabled("checkbox for sale", true);
  762. }
  763. }
  765. // Check search status of objects
  766. const BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME );
  767. bool include_in_search;
  768. const BOOL all_include_in_search = LLSelectMgr::getInstance()->selectionGetIncludeInSearch(&include_in_search);
  769. childSetEnabled("search_check",  has_change_sale_ability && all_volume);
  770. childSetValue("search_check",  include_in_search);
  771. childSetTentative("search_check",  !all_include_in_search);
  773. // Click action (touch, sit, buy)
  774. U8 click_action = 0;
  775. if (LLSelectMgr::getInstance()->selectionGetClickAction(&click_action))
  776. {
  777. LLComboBox* ComboClickAction = getChild<LLComboBox>("clickaction");
  778. if (ComboClickAction)
  779. {
  780. ComboClickAction->setCurrentByIndex((S32)click_action);
  781. }
  782. }
  783. childSetEnabled("label click action", is_perm_modify && all_volume);
  784. childSetEnabled("clickaction", is_perm_modify && all_volume);
  786. if (!getIsEditing())
  787. {
  788. const std::string no_item_names[] = 
  789. {
  790. "Object Name",
  791. "Object Description",
  792. "button set group",
  793. "checkbox share with group",
  794. "button deed",
  795. "checkbox allow everyone move",
  796. "checkbox allow everyone copy",
  797. "checkbox for sale",
  798. "sale type",
  799. "Edit Cost",
  800. "checkbox next owner can modify",
  801. "checkbox next owner can copy",
  802. "checkbox next owner can transfer",
  803. "clickaction",
  804. "search_check",
  805. "perm_modify",
  806. "Group Name",
  807. };
  808. for (size_t t=0; t<LL_ARRAY_SIZE(no_item_names); ++t)
  809. {
  810. childSetEnabled(no_item_names[t], FALSE);
  811. }
  812. }
  813. updateVerbs();
  814. }
  817. // static
  818. void LLSidepanelTaskInfo::onClickClaim(void*)
  819. {
  820. // try to claim ownership
  821. LLSelectMgr::getInstance()->sendOwner(gAgent.getID(), gAgent.getGroupID());
  822. }
  824. // static
  825. void LLSidepanelTaskInfo::onClickRelease(void*)
  826. {
  827. // try to release ownership
  828. LLSelectMgr::getInstance()->sendOwner(LLUUID::null, LLUUID::null);
  829. }
  831. void LLSidepanelTaskInfo::onClickGroup()
  832. {
  833. LLUUID owner_id;
  834. std::string name;
  835. BOOL owners_identical = LLSelectMgr::getInstance()->selectGetOwner(owner_id, name);
  836. LLFloater* parent_floater = gFloaterView->getParentFloater(this);
  838. if (owners_identical && (owner_id == gAgent.getID()))
  839. {
  840. LLFloaterGroupPicker* fg = LLFloaterReg::showTypedInstance<LLFloaterGroupPicker>("group_picker", LLSD(gAgent.getID()));
  841. if (fg)
  842. {
  843. fg->setSelectGroupCallback( boost::bind(&LLSidepanelTaskInfo::cbGroupID, this, _1) );
  844. if (parent_floater)
  845. {
  846. LLRect new_rect = gFloaterView->findNeighboringPosition(parent_floater, fg);
  847. fg->setOrigin(new_rect.mLeft, new_rect.mBottom);
  848. parent_floater->addDependentFloater(fg);
  849. }
  850. }
  851. }
  852. }
  854. void LLSidepanelTaskInfo::cbGroupID(LLUUID group_id)
  855. {
  856. if (mLabelGroupName)
  857. {
  858. mLabelGroupName->setNameID(group_id, TRUE);
  859. }
  860. LLSelectMgr::getInstance()->sendGroup(group_id);
  861. }
  863. static bool callback_deed_to_group(const LLSD& notification, const LLSD& response)
  864. {
  865. const S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  866. if (option == 0)
  867. {
  868. LLUUID group_id;
  869. const BOOL groups_identical = LLSelectMgr::getInstance()->selectGetGroup(group_id);
  870. if (group_id.notNull() && groups_identical && (gAgent.hasPowerInGroup(group_id, GP_OBJECT_DEED)))
  871. {
  872. LLSelectMgr::getInstance()->sendOwner(LLUUID::null, group_id, FALSE);
  873. // LLViewerStats::getInstance()->incStat(LLViewerStats::ST_RELEASE_COUNT);
  874. }
  875. }
  876. return FALSE;
  877. }
  879. void LLSidepanelTaskInfo::onClickDeedToGroup(void *data)
  880. {
  881. LLNotificationsUtil::add("DeedObjectToGroup", LLSD(), LLSD(), callback_deed_to_group);
  882. }
  884. ///----------------------------------------------------------------------------
  885. /// Permissions checkboxes
  886. ///----------------------------------------------------------------------------
  888. // static
  889. void LLSidepanelTaskInfo::onCommitPerm(LLUICtrl *ctrl, void *data, U8 field, U32 perm)
  890. {
  891. LLViewerObject* object = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
  892. if(!object) return;
  894. // Checkbox will have toggled itself
  895. // LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
  896. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  897. BOOL new_state = check->get();
  899. LLSelectMgr::getInstance()->selectionSetObjectPermissions(field, new_state, perm);
  900. }
  902. // static
  903. void LLSidepanelTaskInfo::onCommitGroupShare(LLUICtrl *ctrl, void *data)
  904. {
  905. onCommitPerm(ctrl, data, PERM_GROUP, PERM_MODIFY | PERM_MOVE | PERM_COPY);
  906. }
  908. // static
  909. void LLSidepanelTaskInfo::onCommitEveryoneMove(LLUICtrl *ctrl, void *data)
  910. {
  911. onCommitPerm(ctrl, data, PERM_EVERYONE, PERM_MOVE);
  912. }
  915. // static
  916. void LLSidepanelTaskInfo::onCommitEveryoneCopy(LLUICtrl *ctrl, void *data)
  917. {
  918. onCommitPerm(ctrl, data, PERM_EVERYONE, PERM_COPY);
  919. }
  921. // static
  922. void LLSidepanelTaskInfo::onCommitNextOwnerModify(LLUICtrl* ctrl, void* data)
  923. {
  924. //llinfos << "LLSidepanelTaskInfo::onCommitNextOwnerModify" << llendl;
  925. onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_MODIFY);
  926. }
  928. // static
  929. void LLSidepanelTaskInfo::onCommitNextOwnerCopy(LLUICtrl* ctrl, void* data)
  930. {
  931. //llinfos << "LLSidepanelTaskInfo::onCommitNextOwnerCopy" << llendl;
  932. onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_COPY);
  933. }
  935. // static
  936. void LLSidepanelTaskInfo::onCommitNextOwnerTransfer(LLUICtrl* ctrl, void* data)
  937. {
  938. //llinfos << "LLSidepanelTaskInfo::onCommitNextOwnerTransfer" << llendl;
  939. onCommitPerm(ctrl, data, PERM_NEXT_OWNER, PERM_TRANSFER);
  940. }
  942. // static
  943. void LLSidepanelTaskInfo::onCommitName(LLUICtrl*, void* data)
  944. {
  945. //llinfos << "LLSidepanelTaskInfo::onCommitName()" << llendl;
  946. LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
  947. LLLineEditor* tb = self->getChild<LLLineEditor>("Object Name");
  948. if(tb)
  949. {
  950. LLSelectMgr::getInstance()->selectionSetObjectName(tb->getText());
  951. // LLSelectMgr::getInstance()->selectionSetObjectName(self->mLabelObjectName->getText());
  952. }
  953. }
  956. // static
  957. void LLSidepanelTaskInfo::onCommitDesc(LLUICtrl*, void* data)
  958. {
  959. //llinfos << "LLSidepanelTaskInfo::onCommitDesc()" << llendl;
  960. LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
  961. LLLineEditor* le = self->getChild<LLLineEditor>("Object Description");
  962. if(le)
  963. {
  964. LLSelectMgr::getInstance()->selectionSetObjectDescription(le->getText());
  965. }
  966. }
  968. // static
  969. void LLSidepanelTaskInfo::onCommitSaleInfo(LLUICtrl*, void* data)
  970. {
  971. LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
  972. self->setAllSaleInfo();
  973. }
  975. // static
  976. void LLSidepanelTaskInfo::onCommitSaleType(LLUICtrl*, void* data)
  977. {
  978. LLSidepanelTaskInfo* self = (LLSidepanelTaskInfo*)data;
  979. self->setAllSaleInfo();
  980. }
  983. void LLSidepanelTaskInfo::setAllSaleInfo()
  984. {
  985. LLSaleInfo::EForSale sale_type = LLSaleInfo::FS_NOT;
  987. LLCheckBoxCtrl *checkPurchase = getChild<LLCheckBoxCtrl>("checkbox for sale");
  989. // Set the sale type if the object(s) are for sale.
  990. if(checkPurchase && checkPurchase->get())
  991. {
  992. sale_type = static_cast<LLSaleInfo::EForSale>(getChild<LLComboBox>("sale type")->getValue().asInteger());
  993. }
  995. S32 price = -1;
  997. LLSpinCtrl *edit_price = getChild<LLSpinCtrl>("Edit Cost");
  998. price = (edit_price->getTentative()) ? DEFAULT_PRICE : edit_price->getValue().asInteger();
  1000. // If somehow an invalid price, turn the sale off.
  1001. if (price < 0)
  1002. sale_type = LLSaleInfo::FS_NOT;
  1004. LLSaleInfo old_sale_info;
  1005. LLSelectMgr::getInstance()->selectGetSaleInfo(old_sale_info);
  1007. LLSaleInfo new_sale_info(sale_type, price);
  1008. LLSelectMgr::getInstance()->selectionSetObjectSaleInfo(new_sale_info);
  1010. U8 old_click_action = 0;
  1011. LLSelectMgr::getInstance()->selectionGetClickAction(&old_click_action);
  1013. if (old_sale_info.isForSale()
  1014. && !new_sale_info.isForSale()
  1015. && old_click_action == CLICK_ACTION_BUY)
  1016. {
  1017. // If turned off for-sale, make sure click-action buy is turned
  1018. // off as well
  1019. LLSelectMgr::getInstance()->
  1020. selectionSetClickAction(CLICK_ACTION_TOUCH);
  1021. }
  1022. else if (new_sale_info.isForSale()
  1023. && !old_sale_info.isForSale()
  1024. && old_click_action == CLICK_ACTION_TOUCH)
  1025. {
  1026. // If just turning on for-sale, preemptively turn on one-click buy
  1027. // unless user have a different click action set
  1028. LLSelectMgr::getInstance()->
  1029. selectionSetClickAction(CLICK_ACTION_BUY);
  1030. }
  1031. }
  1033. struct LLSelectionPayable : public LLSelectedObjectFunctor
  1034. {
  1035. virtual bool apply(LLViewerObject* obj)
  1036. {
  1037. // can pay if you or your parent has money() event in script
  1038. LLViewerObject* parent = (LLViewerObject*)obj->getParent();
  1039. return (obj->flagTakesMoney() ||
  1040. (parent && parent->flagTakesMoney()));
  1041. }
  1042. };
  1044. static U8 string_value_to_click_action(std::string p_value)
  1045. {
  1046. if (p_value == "Touch")
  1047. return CLICK_ACTION_TOUCH;
  1048. if (p_value == "Sit")
  1049. return CLICK_ACTION_SIT;
  1050. if (p_value == "Buy")
  1051. return CLICK_ACTION_BUY;
  1052. if (p_value == "Pay")
  1053. return CLICK_ACTION_PAY;
  1054. if (p_value == "Open")
  1055. return CLICK_ACTION_OPEN;
  1056. if (p_value == "Zoom")
  1057. return CLICK_ACTION_ZOOM;
  1058. return CLICK_ACTION_TOUCH;
  1059. }
  1061. // static
  1062. void LLSidepanelTaskInfo::onCommitClickAction(LLUICtrl* ctrl, void*)
  1063. {
  1064. LLComboBox* box = (LLComboBox*)ctrl;
  1065. if (!box) return;
  1066. std::string value = box->getValue().asString();
  1067. U8 click_action = string_value_to_click_action(value);
  1068. doClickAction(click_action);
  1069. }
  1071. // static
  1072. void LLSidepanelTaskInfo::doClickAction(U8 click_action)
  1073. {
  1074. if (click_action == CLICK_ACTION_BUY)
  1075. {
  1076. LLSaleInfo sale_info;
  1077. LLSelectMgr::getInstance()->selectGetSaleInfo(sale_info);
  1078. if (!sale_info.isForSale())
  1079. {
  1080. LLNotificationsUtil::add("CantSetBuyObject");
  1082. // Set click action back to its old value
  1083. U8 click_action = 0;
  1084. LLSelectMgr::getInstance()->selectionGetClickAction(&click_action);
  1085. // box->setCurrentByIndex((S32)click_action);
  1087. return;
  1088. }
  1089. }
  1090. else if (click_action == CLICK_ACTION_PAY)
  1091. {
  1092. // Verify object has script with money() handler
  1093. LLSelectionPayable payable;
  1094. bool can_pay = LLSelectMgr::getInstance()->getSelection()->applyToObjects(&payable);
  1095. if (!can_pay)
  1096. {
  1097. // Warn, but do it anyway.
  1098. LLNotificationsUtil::add("ClickActionNotPayable");
  1099. }
  1100. }
  1101. LLSelectMgr::getInstance()->selectionSetClickAction(click_action);
  1102. }
  1104. // static
  1105. void LLSidepanelTaskInfo::onCommitIncludeInSearch(LLUICtrl* ctrl, void* data)
  1106. {
  1107. LLCheckBoxCtrl* box = (LLCheckBoxCtrl*)ctrl;
  1108. llassert(box);
  1109. LLSelectMgr::getInstance()->selectionSetIncludeInSearch(box->get());
  1110. }
  1112. // virtual
  1113. void LLSidepanelTaskInfo::updateVerbs()
  1114. {
  1115. LLSidepanelInventorySubpanel::updateVerbs();
  1117. /*
  1118. mOpenBtn->setVisible(!getIsEditing());
  1119. mPayBtn->setVisible(!getIsEditing());
  1120. mBuyBtn->setVisible(!getIsEditing());
  1121. //const LLViewerObject *obj = getFirstSelectedObject();
  1122. //mEditBtn->setEnabled(obj && obj->permModify());
  1123. */
  1125. mOpenBtn->setEnabled(enable_object_open());
  1126. mPayBtn->setEnabled(enable_pay_object());
  1127. mBuyBtn->setEnabled(enable_buy_object());
  1128. }
  1130. void LLSidepanelTaskInfo::onOpenButtonClicked()
  1131. {
  1132. if (enable_object_open())
  1133. {
  1134. handle_object_open();
  1135. }
  1136. }
  1138. void LLSidepanelTaskInfo::onPayButtonClicked()
  1139. {
  1140. doClickAction(CLICK_ACTION_PAY);
  1141. }
  1143. void LLSidepanelTaskInfo::onBuyButtonClicked()
  1144. {
  1145. doClickAction(CLICK_ACTION_BUY);
  1146. }
  1148. // virtual
  1149. void LLSidepanelTaskInfo::save()
  1150. {
  1151. onCommitGroupShare(getChild<LLCheckBoxCtrl>("checkbox share with group"), this);
  1152. onCommitEveryoneMove(getChild<LLCheckBoxCtrl>("checkbox allow everyone move"), this);
  1153. onCommitEveryoneCopy(getChild<LLCheckBoxCtrl>("checkbox allow everyone copy"), this);
  1154. onCommitNextOwnerModify(getChild<LLCheckBoxCtrl>("checkbox next owner can modify"), this);
  1155. onCommitNextOwnerCopy(getChild<LLCheckBoxCtrl>("checkbox next owner can copy"), this);
  1156. onCommitNextOwnerTransfer(getChild<LLCheckBoxCtrl>("checkbox next owner can transfer"), this);
  1157. onCommitName(getChild<LLLineEditor>("Object Name"), this);
  1158. onCommitDesc(getChild<LLLineEditor>("Object Description"), this);
  1159. onCommitSaleInfo(NULL, this);
  1160. onCommitSaleType(NULL, this);
  1161. onCommitIncludeInSearch(getChild<LLCheckBoxCtrl>("search_check"), this);
  1162. }
  1164. void LLSidepanelTaskInfo::setObjectSelection(LLObjectSelectionHandle selection)
  1165. {
  1166. mObjectSelection = selection;
  1167. }
  1169. LLSidepanelTaskInfo* LLSidepanelTaskInfo::getActivePanel()
  1170. {
  1171. return sActivePanel;
  1172. }
  1174. LLViewerObject* LLSidepanelTaskInfo::getObject()
  1175. {
  1176. if (!mObject->isDead())
  1177. return mObject;
  1178. return NULL;
  1179. }
  1181. LLViewerObject* LLSidepanelTaskInfo::getFirstSelectedObject()
  1182. {
  1183. LLSelectNode *node = mObjectSelection->getFirstRootNode();
  1184. if (node)
  1185. {
  1186. return node->getObject();
  1187. }
  1188. return NULL;
  1189. }
  1191. const LLUUID& LLSidepanelTaskInfo::getSelectedUUID()
  1192. {
  1193. const LLViewerObject* obj = getFirstSelectedObject();
  1194. if (obj)
  1195. {
  1196. return obj->getID();
  1197. }
  1198. return LLUUID::null;
  1199. }