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

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

游戏引擎

开发平台：

C++ Builder

llpanelgrouproles.cpp：源码内容
  1. /** 
  2.  * @file llpanelgrouproles.cpp
  3.  * @brief Panel for roles information about a particular group.
  4.  *
  5.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2006-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"
  35. #include "llcheckboxctrl.h"
  37. #include "llagent.h"
  38. #include "llbutton.h"
  39. #include "llfiltereditor.h"
  40. #include "llfloatergroupinvite.h"
  41. #include "llavataractions.h"
  42. #include "lliconctrl.h"
  43. #include "lllineeditor.h"
  44. #include "llnamelistctrl.h"
  45. #include "llnotifications.h"
  46. #include "llnotificationsutil.h"
  47. #include "llpanelgrouproles.h"
  48. #include "llscrolllistctrl.h"
  49. #include "llscrolllistitem.h"
  50. #include "llscrolllistcell.h"
  51. #include "lltabcontainer.h"
  52. #include "lltextbox.h"
  53. #include "lltexteditor.h"
  54. #include "llviewertexturelist.h"
  55. #include "llviewerwindow.h"
  56. #include "llfocusmgr.h"
  58. #include "roles_constants.h"
  60. static LLRegisterPanelClassWrapper<LLPanelGroupRoles> t_panel_group_roles("panel_group_roles");
  62. bool agentCanRemoveFromRole(const LLUUID& group_id,
  63. const LLUUID& role_id)
  64. {
  65. return gAgent.hasPowerInGroup(group_id, GP_ROLE_REMOVE_MEMBER);
  66. }
  68. bool agentCanAddToRole(const LLUUID& group_id,
  69.    const LLUUID& role_id)
  70. {
  71. if (gAgent.isGodlike())
  72. return true;
  73.     
  74. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(group_id);
  75. if (!gdatap) 
  76. {
  77. llwarns << "agentCanAddToRole "
  78. << "-- No group data!" << llendl;
  79. return false;
  80. }
  82. //make sure the agent is in the group
  83. LLGroupMgrGroupData::member_list_t::iterator mi = gdatap->mMembers.find(gAgent.getID());
  84. if (mi == gdatap->mMembers.end())
  85. {
  86. return false;
  87. }
  89. LLGroupMemberData* member_data = (*mi).second;
  91. // Owners can add to any role.
  92. if ( member_data->isInRole(gdatap->mOwnerRole) )
  93. {
  94. return true;
  95. }
  97. // 'Limited assign members' can add to roles the user is in.
  98. if ( gAgent.hasPowerInGroup(group_id, GP_ROLE_ASSIGN_MEMBER_LIMITED) &&
  99. member_data->isInRole(role_id) )
  100. {
  101. return true;
  102. }
  104. // 'assign members' can add to non-owner roles.
  105. if ( gAgent.hasPowerInGroup(group_id, GP_ROLE_ASSIGN_MEMBER) &&
  106.  role_id != gdatap->mOwnerRole )
  107. {
  108. return true;
  109. }
  111. return false;
  112. }
  114. // static
  116. LLPanelGroupRoles::LLPanelGroupRoles()
  117. : LLPanelGroupTab(),
  118. mCurrentTab(NULL),
  119. mRequestedTab( NULL ),
  120. mSubTabContainer( NULL ),
  121. mFirstUse( TRUE ),
  122. mIgnoreTransition( FALSE )
  123. {
  124. }
  126. LLPanelGroupRoles::~LLPanelGroupRoles()
  127. {
  128. }
  130. BOOL LLPanelGroupRoles::postBuild()
  131. {
  132. lldebugs << "LLPanelGroupRoles::postBuild()" << llendl;
  134. mSubTabContainer = getChild<LLTabContainer>("roles_tab_container");
  136. if (!mSubTabContainer) return FALSE;
  138. // Hook up each sub-tabs callback and widgets.
  139. for (S32 i = 0; i < mSubTabContainer->getTabCount(); ++i)
  140. {
  141. LLPanel* panel = mSubTabContainer->getPanelByIndex(i);
  142. LLPanelGroupSubTab* subtabp = dynamic_cast<LLPanelGroupSubTab*>(panel);
  143. if (!subtabp)
  144. {
  145. llwarns << "Invalid subtab panel: " << panel->getName() << llendl;
  146. return FALSE;
  147. }
  148. // Add click callbacks to all the tabs.
  149. mSubTabContainer->setCommitCallback(boost::bind(&LLPanelGroupRoles::handleClickSubTab, this));
  151. // Hand the subtab a pointer to this LLPanelGroupRoles, so that it can
  152. // look around for the widgets it is interested in.
  153. if (!subtabp->postBuildSubTab(this))
  154. return FALSE;
  156. //subtabp->addObserver(this);
  157. }
  159. // Set the current tab to whatever is currently being shown.
  160. mCurrentTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  161. if (!mCurrentTab)
  162. {
  163. // Need to select a tab.
  164. mSubTabContainer->selectFirstTab();
  165. mCurrentTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  166. }
  168. if (!mCurrentTab) return FALSE;
  170. // Act as though this tab was just activated.
  171. mCurrentTab->activate();
  173. // Read apply text from the xml file.
  174. mDefaultNeedsApplyMesg = getString("default_needs_apply_text");
  175. mWantApplyMesg = getString("want_apply_text");
  177. return LLPanelGroupTab::postBuild();
  178. }
  180. BOOL LLPanelGroupRoles::isVisibleByAgent(LLAgent* agentp)
  181. {
  182. /* This power was removed to make group roles simpler
  183. return agentp->hasPowerInGroup(mGroupID, 
  184.    GP_ROLE_CREATE |
  185.    GP_ROLE_DELETE |
  186.    GP_ROLE_PROPERTIES |
  187.    GP_ROLE_VIEW |
  188.    GP_ROLE_ASSIGN_MEMBER |
  189.    GP_ROLE_REMOVE_MEMBER |
  190.    GP_ROLE_CHANGE_ACTIONS |
  191.    GP_MEMBER_INVITE |
  192.    GP_MEMBER_EJECT |
  193.    GP_MEMBER_OPTIONS );
  194. */
  195. return mAllowEdit && agentp->isInGroup(mGroupID);
  196.    
  197. }
  199. void LLPanelGroupRoles::handleClickSubTab()
  200. {
  201. // If we are already handling a transition,
  202. // ignore this.
  203. if (mIgnoreTransition)
  204. {
  205. return;
  206. }
  208. mRequestedTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  210. // Make sure they aren't just clicking the same tab...
  211. if (mRequestedTab == mCurrentTab)
  212. {
  213. return;
  214. }
  216. // Try to switch from the current panel to the panel the user selected.
  217. attemptTransition();
  218. }
  220. BOOL LLPanelGroupRoles::attemptTransition()
  221. {
  222. // Check if the current tab needs to be applied.
  223. std::string mesg;
  224. if (mCurrentTab && mCurrentTab->needsApply(mesg))
  225. {
  226. // If no message was provided, give a generic one.
  227. if (mesg.empty())
  228. {
  229. mesg = mDefaultNeedsApplyMesg;
  230. }
  231. // Create a notify box, telling the user about the unapplied tab.
  232. LLSD args;
  233. args["NEEDS_APPLY_MESSAGE"] = mesg;
  234. args["WANT_APPLY_MESSAGE"] = mWantApplyMesg;
  235. LLNotificationsUtil::add("PanelGroupApply", args, LLSD(),
  236. boost::bind(&LLPanelGroupRoles::handleNotifyCallback, this, _1, _2));
  237. mHasModal = TRUE;
  238. // We need to reselect the current tab, since it isn't finished.
  239. if (mSubTabContainer)
  240. {
  241. mIgnoreTransition = TRUE;
  242. mSubTabContainer->selectTabPanel( mCurrentTab );
  243. mIgnoreTransition = FALSE;
  244. }
  245. // Returning FALSE will block a close action from finishing until
  246. // we get a response back from the user.
  247. return FALSE;
  248. }
  249. else
  250. {
  251. // The current panel didn't have anything it needed to apply.
  252. if (mRequestedTab)
  253. {
  254. transitionToTab();
  255. }
  256. return TRUE;
  257. }
  258. }
  260. void LLPanelGroupRoles::transitionToTab()
  261. {
  262. // Tell the current panel that it is being deactivated.
  263. if (mCurrentTab)
  264. {
  265. mCurrentTab->deactivate();
  266. }
  268. // Tell the new panel that it is being activated.
  269. if (mRequestedTab)
  270. {
  271. // This is now the current tab;
  272. mCurrentTab = mRequestedTab;
  273. mCurrentTab->activate();
  274. }
  275. }
  277. bool LLPanelGroupRoles::handleNotifyCallback(const LLSD& notification, const LLSD& response)
  278. {
  279. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  280. mHasModal = FALSE;
  281. switch (option)
  282. {
  283. case 0: // "Apply Changes"
  284. {
  285. // Try to apply changes, and switch to the requested tab.
  286. std::string apply_mesg;
  287. if ( !apply( apply_mesg ) )
  288. {
  289. // There was a problem doing the apply.
  290. if ( !apply_mesg.empty() )
  291. {
  292. mHasModal = TRUE;
  293. LLSD args;
  294. args["MESSAGE"] = apply_mesg;
  295. LLNotificationsUtil::add("GenericAlert", args, LLSD(), boost::bind(&LLPanelGroupRoles::onModalClose, this, _1, _2));
  296. }
  297. // Skip switching tabs.
  298. break;
  299. }
  301. // This panel's info successfully applied.
  302. // Switch to the next panel.
  303. // No break!  Continue into 'Ignore Changes' which just switches tabs.
  304. mIgnoreTransition = TRUE;
  305. mSubTabContainer->selectTabPanel( mRequestedTab );
  306. mIgnoreTransition = FALSE;
  307. transitionToTab();
  308. break;
  309. }
  310. case 1: // "Ignore Changes"
  311. // Switch to the requested panel without applying changes
  312. cancel();
  313. mIgnoreTransition = TRUE;
  314. mSubTabContainer->selectTabPanel( mRequestedTab );
  315. mIgnoreTransition = FALSE;
  316. transitionToTab();
  317. break;
  318. case 2: // "Cancel"
  319. default:
  320. // Do nothing.  The user is canceling the action.
  321. break;
  322. }
  323. return false;
  324. }
  326. bool LLPanelGroupRoles::onModalClose(const LLSD& notification, const LLSD& response)
  327. {
  328. mHasModal = FALSE;
  329. return false;
  330. }
  333. bool LLPanelGroupRoles::apply(std::string& mesg)
  334. {
  335. // Pass this along to the currently visible sub tab.
  336. if (!mSubTabContainer) return false;
  338. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  339. if (!panelp) return false;
  341. // Ignore the needs apply message.
  342. std::string ignore_mesg;
  343. if ( !panelp->needsApply(ignore_mesg) )
  344. {
  345. // We don't need to apply anything.
  346. // We're done.
  347. return true;
  348. }
  350. // Try to do the actual apply.
  351. return panelp->apply(mesg);
  352. }
  354. void LLPanelGroupRoles::cancel()
  355. {
  356. // Pass this along to the currently visible sub tab.
  357. if (!mSubTabContainer) return;
  359. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  360. if (!panelp) return;
  362. panelp->cancel();
  363. }
  365. void LLPanelGroupRoles::update(LLGroupChange gc)
  366. {
  367. if (mGroupID.isNull()) return;
  370. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  371. if (panelp)
  372. {
  373. panelp->update(gc);
  374. }
  375. else
  376. {
  377. llwarns << "LLPanelGroupRoles::update() -- No subtab to update!" << llendl;
  378. }
  380. }
  382. void LLPanelGroupRoles::activate()
  383. {
  384. // Start requesting member and role data if needed.
  385. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  386. //if (!gdatap || mFirstUse)
  387. {
  388. // Check member data.
  390. if (!gdatap || !gdatap->isMemberDataComplete() )
  391. {
  392. LLGroupMgr::getInstance()->sendGroupMembersRequest(mGroupID);
  393. }
  395. // Check role data.
  396. if (!gdatap || !gdatap->isRoleDataComplete() )
  397. {
  398. // Mildly hackish - clear all pending changes
  399. cancel();
  401. LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mGroupID);
  402. }
  404. // Check role-member mapping data.
  405. if (!gdatap || !gdatap->isRoleMemberDataComplete() )
  406. {
  407. LLGroupMgr::getInstance()->sendGroupRoleMembersRequest(mGroupID);
  408. }
  410. // Need this to get base group member powers
  411. if (!gdatap || !gdatap->isGroupPropertiesDataComplete() )
  412. {
  413. LLGroupMgr::getInstance()->sendGroupPropertiesRequest(mGroupID);
  414. }
  416. mFirstUse = FALSE;
  417. }
  419. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  420. if (panelp) panelp->activate();
  421. }
  423. void LLPanelGroupRoles::deactivate()
  424. {
  425. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  426. if (panelp) panelp->deactivate();
  427. }
  429. bool LLPanelGroupRoles::needsApply(std::string& mesg)
  430. {
  431. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  432. if (!panelp) return false;
  434. return panelp->needsApply(mesg);
  435. }
  437. BOOL LLPanelGroupRoles::hasModal()
  438. {
  439. if (mHasModal) return TRUE;
  441. LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
  442. if (!panelp) return FALSE;
  444. return panelp->hasModal();
  445. }
  448. ////////////////////////////
  449. // LLPanelGroupSubTab
  450. ////////////////////////////
  451. LLPanelGroupSubTab::LLPanelGroupSubTab()
  452. : LLPanelGroupTab(),
  453. mHeader(NULL),
  454. mFooter(NULL),
  455. mActivated(false),
  456. mSearchEditor(NULL)
  457. {
  458. }
  460. LLPanelGroupSubTab::~LLPanelGroupSubTab()
  461. {
  462. }
  464. BOOL LLPanelGroupSubTab::postBuildSubTab(LLView* root) 
  465. { 
  466. // Get icons for later use.
  467. mActionIcons.clear();
  469. if (hasString("power_folder_icon"))
  470. {
  471. mActionIcons["folder"] = getString("power_folder_icon");
  472. }
  474. if (hasString("power_all_have_icon"))
  475. {
  476. mActionIcons["full"] = getString("power_all_have_icon");
  477. }
  479. if (hasString("power_partial_icon"))
  480. {
  481. mActionIcons["partial"] = getString("power_partial_icon");
  482. }
  483. return TRUE; 
  484. }
  486. BOOL LLPanelGroupSubTab::postBuild()
  487. {
  488. // Hook up the search widgets.
  489. bool recurse = true;
  490. mSearchEditor = getChild<LLFilterEditor>("filter_input", recurse);
  492. if (!mSearchEditor) 
  493. return FALSE;
  495. mSearchEditor->setCommitCallback(boost::bind(&LLPanelGroupSubTab::setSearchFilter, this, _2));
  497. return LLPanelGroupTab::postBuild();
  498. }
  500. void LLPanelGroupSubTab::setGroupID(const LLUUID& id)
  501. {
  502. LLPanelGroupTab::setGroupID(id);
  503. if(mSearchEditor)
  504. {
  505. mSearchEditor->clear();
  506. setSearchFilter("");
  507. }
  509. mActivated = false;
  510. }
  512. void LLPanelGroupSubTab::setSearchFilter(const std::string& filter)
  513. {
  514. if(mSearchFilter == filter)
  515. return;
  516. mSearchFilter = filter;
  517. LLStringUtil::toLower(mSearchFilter);
  518. update(GC_ALL);
  519. }
  521. void LLPanelGroupSubTab::activate()
  522. {
  523. setOthersVisible(TRUE);
  524. }
  526. void LLPanelGroupSubTab::deactivate()
  527. {
  528. setOthersVisible(FALSE);
  529. }
  531. void LLPanelGroupSubTab::setOthersVisible(BOOL b)
  532. {
  533. if (mHeader)
  534. {
  535. mHeader->setVisible( b );
  536. }
  538. if (mFooter)
  539. {
  540. mFooter->setVisible( b );
  541. }
  542. }
  544. bool LLPanelGroupSubTab::matchesActionSearchFilter(std::string action)
  545. {
  546. // If the search filter is empty, everything passes.
  547. if (mSearchFilter.empty()) return true;
  549. LLStringUtil::toLower(action);
  550. std::string::size_type match = action.find(mSearchFilter);
  552. if (std::string::npos == match)
  553. {
  554. // not found
  555. return false;
  556. }
  557. else
  558. {
  559. return true;
  560. }
  561. }
  563. void LLPanelGroupSubTab::buildActionsList(LLScrollListCtrl* ctrl, 
  564.   U64 allowed_by_some, 
  565.   U64 allowed_by_all,
  566.   LLUICtrl::commit_callback_t commit_callback,
  567.   BOOL show_all,
  568.   BOOL filter,
  569.   BOOL is_owner_role)
  570. {
  571. if (LLGroupMgr::getInstance()->mRoleActionSets.empty())
  572. {
  573. llwarns << "Can't build action list - no actions found." << llendl;
  574. return;
  575. }
  577. std::vector<LLRoleActionSet*>::iterator ras_it = LLGroupMgr::getInstance()->mRoleActionSets.begin();
  578. std::vector<LLRoleActionSet*>::iterator ras_end = LLGroupMgr::getInstance()->mRoleActionSets.end();
  580. for ( ; ras_it != ras_end; ++ras_it)
  581. {
  582. buildActionCategory(ctrl,
  583. allowed_by_some,
  584. allowed_by_all,
  585. (*ras_it),
  586. commit_callback,
  587. show_all,
  588. filter,
  589. is_owner_role);
  590. }
  591. }
  593. void LLPanelGroupSubTab::buildActionCategory(LLScrollListCtrl* ctrl,
  594.  U64 allowed_by_some,
  595.  U64 allowed_by_all,
  596.  LLRoleActionSet* action_set,
  597.  LLUICtrl::commit_callback_t commit_callback,
  598.  BOOL show_all,
  599.  BOOL filter,
  600.  BOOL is_owner_role)
  601. {
  602. lldebugs << "Building role list for: " << action_set->mActionSetData->mName << llendl;
  603. // See if the allow mask matches anything in this category.
  604. if (show_all || (allowed_by_some & action_set->mActionSetData->mPowerBit))
  605. {
  606. // List all the actions in this category that at least some members have.
  607. LLSD row;
  609. row["columns"][0]["column"] = "icon";
  610. row["columns"][0]["type"] = "icon";
  612. icon_map_t::iterator iter = mActionIcons.find("folder");
  613. if (iter != mActionIcons.end())
  614. {
  615. row["columns"][0]["value"] = (*iter).second;
  616. }
  618. row["columns"][1]["column"] = "action";
  619. row["columns"][1]["type"] = "text";
  620. row["columns"][1]["value"] = action_set->mActionSetData->mName;
  621. row["columns"][1]["font"]["name"] = "SANSSERIF_SMALL";
  624. LLScrollListItem* title_row = ctrl->addElement(row, ADD_BOTTOM, action_set->mActionSetData);
  626. LLScrollListText* name_textp = dynamic_cast<LLScrollListText*>(title_row->getColumn(2)); //?? I have no idea fix getColumn(1) return column spacer...
  627. if (name_textp)
  628. name_textp->setFontStyle(LLFontGL::BOLD);
  630. bool category_matches_filter = (filter) ? matchesActionSearchFilter(action_set->mActionSetData->mName) : true;
  632. std::vector<LLRoleAction*>::iterator ra_it = action_set->mActions.begin();
  633. std::vector<LLRoleAction*>::iterator ra_end = action_set->mActions.end();
  635. bool items_match_filter = false;
  636. BOOL can_change_actions = (!is_owner_role && gAgent.hasPowerInGroup(mGroupID, GP_ROLE_CHANGE_ACTIONS));
  638. for ( ; ra_it != ra_end; ++ra_it)
  639. {
  640. // See if anyone has these action.
  641. if (!show_all && !(allowed_by_some & (*ra_it)->mPowerBit))
  642. {
  643. continue;
  644. }
  646. // See if we are filtering out these actions
  647. // If we aren't using filters, category_matches_filter will be true.
  648. if (!category_matches_filter
  649. && !matchesActionSearchFilter((*ra_it)->mDescription))
  650. {
  651. continue;
  652. }
  654. items_match_filter = true;
  656. // See if everyone has these actions.
  657. bool show_full_strength = false;
  658. if ( (allowed_by_some & (*ra_it)->mPowerBit) == (allowed_by_all & (*ra_it)->mPowerBit) )
  659. {
  660. show_full_strength = true;
  661. }
  663. LLSD row;
  665. S32 column_index = 0;
  666. row["columns"][column_index]["column"] = "icon";
  667. ++column_index;
  670. S32 check_box_index = -1;
  671. if (commit_callback)
  672. {
  673. row["columns"][column_index]["column"] = "checkbox";
  674. row["columns"][column_index]["type"] = "checkbox";
  675. check_box_index = column_index;
  676. ++column_index;
  677. }
  678. else
  679. {
  680. if (show_full_strength)
  681. {
  682. icon_map_t::iterator iter = mActionIcons.find("full");
  683. if (iter != mActionIcons.end())
  684. {
  685. row["columns"][column_index]["column"] = "checkbox";
  686. row["columns"][column_index]["type"] = "icon";
  687. row["columns"][column_index]["value"] = (*iter).second;
  688. ++column_index;
  689. }
  690. }
  691. else
  692. {
  693. icon_map_t::iterator iter = mActionIcons.find("partial");
  694. if (iter != mActionIcons.end())
  695. {
  696. row["columns"][column_index]["column"] = "checkbox";
  697. row["columns"][column_index]["type"] = "icon";
  698. row["columns"][column_index]["value"] = (*iter).second;
  699. ++column_index;
  700. }
  701. row["enabled"] = false;
  702. }
  703. }
  705. row["columns"][column_index]["column"] = "action";
  706. row["columns"][column_index]["value"] = (*ra_it)->mDescription;
  707. row["columns"][column_index]["font"] = "SANSSERIF_SMALL";
  709. LLScrollListItem* item = ctrl->addElement(row, ADD_BOTTOM, (*ra_it));
  711. if (-1 != check_box_index)
  712. {
  713. // Extract the checkbox that was created.
  714. LLScrollListCheck* check_cell = (LLScrollListCheck*) item->getColumn(check_box_index);
  715. LLCheckBoxCtrl* check = check_cell->getCheckBox();
  716. check->setEnabled(can_change_actions);
  717. check->setCommitCallback(commit_callback);
  718. check->setToolTip( check->getLabel() );
  720. if (show_all)
  721. {
  722. check->setTentative(FALSE);
  723. if (allowed_by_some & (*ra_it)->mPowerBit)
  724. {
  725. check->set(TRUE);
  726. }
  727. else
  728. {
  729. check->set(FALSE);
  730. }
  731. }
  732. else
  733. {
  734. check->set(TRUE);
  735. if (show_full_strength)
  736. {
  737. check->setTentative(FALSE);
  738. }
  739. else
  740. {
  741. check->setTentative(TRUE);
  742. }
  743. }
  744. }
  745. }
  747. if (!items_match_filter)
  748. {
  749. S32 title_index = ctrl->getItemIndex(title_row);
  750. ctrl->deleteSingleItem(title_index);
  751. }
  752. }
  753. }
  755. void LLPanelGroupSubTab::setFooterEnabled(BOOL enable)
  756. {
  757. if (mFooter)
  758. {
  759. mFooter->setAllChildrenEnabled(enable);
  760. }
  761. }
  763. ////////////////////////////
  764. // LLPanelGroupMembersSubTab
  765. ////////////////////////////
  768. static LLRegisterPanelClassWrapper<LLPanelGroupMembersSubTab> t_panel_group_members_subtab("panel_group_members_subtab");
  770. LLPanelGroupMembersSubTab::LLPanelGroupMembersSubTab()
  771. :  LLPanelGroupSubTab(),
  772. mMembersList(NULL),
  773. mAssignedRolesList(NULL),
  774. mAllowedActionsList(NULL),
  775. mChanged(FALSE),
  776. mPendingMemberUpdate(FALSE),
  777. mHasMatch(FALSE),
  778. mNumOwnerAdditions(0)
  779. {
  780. }
  782. LLPanelGroupMembersSubTab::~LLPanelGroupMembersSubTab()
  783. {
  784. }
  786. BOOL LLPanelGroupMembersSubTab::postBuildSubTab(LLView* root)
  787. {
  788. LLPanelGroupSubTab::postBuildSubTab(root);
  790. // Upcast parent so we can ask it for sibling controls.
  791. LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
  793. // Look recursively from the parent to find all our widgets.
  794. bool recurse = true;
  795. mHeader = parent->getChild<LLPanel>("members_header", recurse);
  796. mFooter = parent->getChild<LLPanel>("members_footer", recurse);
  798. mMembersList  = parent->getChild<LLNameListCtrl>("member_list", recurse);
  799. mAssignedRolesList = parent->getChild<LLScrollListCtrl>("member_assigned_roles", recurse);
  800. mAllowedActionsList = parent->getChild<LLScrollListCtrl>("member_allowed_actions", recurse);
  802. if (!mMembersList || !mAssignedRolesList || !mAllowedActionsList) return FALSE;
  804. // We want to be notified whenever a member is selected.
  805. mMembersList->setCommitOnSelectionChange(TRUE);
  806. mMembersList->setCommitCallback(onMemberSelect, this);
  807. // Show the member's profile on double click.
  808. mMembersList->setDoubleClickCallback(onMemberDoubleClick, this);
  809. mMembersList->setContextMenu(LLScrollListCtrl::MENU_AVATAR);
  811. LLButton* button = parent->getChild<LLButton>("member_invite", recurse);
  812. if ( button )
  813. {
  814. button->setClickedCallback(onInviteMember, this);
  815. button->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_MEMBER_INVITE));
  816. }
  818. mEjectBtn = parent->getChild<LLButton>("member_eject", recurse);
  819. if ( mEjectBtn )
  820. {
  821. mEjectBtn->setClickedCallback(onEjectMembers, this);
  822. mEjectBtn->setEnabled(FALSE);
  823. }
  825. return TRUE;
  826. }
  828. void LLPanelGroupMembersSubTab::setGroupID(const LLUUID& id)
  829. {
  830. LLPanelGroupSubTab::setGroupID(id);
  832. }
  835. // static
  836. void LLPanelGroupMembersSubTab::onMemberSelect(LLUICtrl* ctrl, void* user_data)
  837. {
  838. LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
  839. self->handleMemberSelect();
  840. }
  842. void LLPanelGroupMembersSubTab::handleMemberSelect()
  843. {
  844. lldebugs << "LLPanelGroupMembersSubTab::handleMemberSelect" << llendl;
  846. mAssignedRolesList->deleteAllItems();
  847. mAllowedActionsList->deleteAllItems();
  849. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  850. if (!gdatap) 
  851. {
  852. llwarns << "LLPanelGroupMembersSubTab::handleMemberSelect() "
  853. << "-- No group data!" << llendl;
  854. return;
  855. }
  857. // Check if there is anything selected.
  858. std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
  859. if (selection.empty()) return;
  861. // Build a vector of all selected members, and gather allowed actions.
  862. std::vector<LLUUID> selected_members;
  863. U64 allowed_by_all = 0xffffffffffffLL;
  864. U64 allowed_by_some = 0;
  866. std::vector<LLScrollListItem*>::iterator itor;
  867. for (itor = selection.begin();
  868.  itor != selection.end(); ++itor)
  869. {
  870. LLUUID member_id = (*itor)->getUUID();
  872. selected_members.push_back( member_id );
  873. // Get this member's power mask including any unsaved changes
  875. U64 powers = getAgentPowersBasedOnRoleChanges( member_id );
  877. allowed_by_all &= powers;
  878. allowed_by_some |= powers;
  879. }
  880. std::sort(selected_members.begin(), selected_members.end());
  882. //////////////////////////////////
  883. // Build the allowed actions list.
  884. //////////////////////////////////
  885. buildActionsList(mAllowedActionsList,
  886.  allowed_by_some,
  887.  allowed_by_all,
  888.  NULL,
  889.  FALSE,
  890.  FALSE,
  891.  FALSE);
  893. //////////////////////////////////
  894. // Build the assigned roles list.
  895. //////////////////////////////////
  896. // Add each role to the assigned roles list.
  897. LLGroupMgrGroupData::role_list_t::iterator iter = gdatap->mRoles.begin();
  898. LLGroupMgrGroupData::role_list_t::iterator end  = gdatap->mRoles.end();
  900. BOOL can_eject_members = gAgent.hasPowerInGroup(mGroupID,
  901. GP_MEMBER_EJECT);
  902. BOOL member_is_owner = FALSE;
  904. for( ; iter != end; ++iter)
  905. {
  906. // Count how many selected users are in this role.
  907. const LLUUID& role_id = iter->first;
  908. LLGroupRoleData* group_role_data = iter->second;
  910. if (group_role_data)
  911. {
  912. const BOOL needs_sort = FALSE;
  913. S32 count = group_role_data->getMembersInRole(
  914. selected_members, needs_sort);
  915. //check if the user has permissions to assign/remove
  916. //members to/from the role (but the ability to add/remove
  917. //should only be based on the "saved" changes to the role
  918. //not in the temp/meta data. -jwolk
  919. BOOL cb_enable = ( (count > 0) ?
  920.    agentCanRemoveFromRole(mGroupID, role_id) :
  921.    agentCanAddToRole(mGroupID, role_id) );
  924. // Owner role has special enabling permissions for removal.
  925. if (cb_enable && (count > 0) && role_id == gdatap->mOwnerRole)
  926. {
  927. // Check if any owners besides this agent are selected.
  928. std::vector<LLUUID>::const_iterator member_iter;
  929. std::vector<LLUUID>::const_iterator member_end =
  930. selected_members.end();
  931. for (member_iter = selected_members.begin();
  932.  member_iter != member_end;
  933.  ++member_iter)
  934. {
  935. // Don't count the agent.
  936. if ((*member_iter) == gAgent.getID()) continue;
  938. // Look up the member data.
  939. LLGroupMgrGroupData::member_list_t::iterator mi = 
  940. gdatap->mMembers.find((*member_iter));
  941. if (mi == gdatap->mMembers.end()) continue;
  942. LLGroupMemberData* member_data = (*mi).second;
  943. // Is the member an owner?
  944. if ( member_data && member_data->isInRole(gdatap->mOwnerRole) )
  945. {
  946. // Can't remove other owners.
  947. cb_enable = FALSE;
  948. break;
  949. }
  950. }
  951. }
  953. //now see if there are any role changes for the selected
  954. //members and remember to include them
  955. std::vector<LLUUID>::iterator sel_mem_iter = selected_members.begin();
  956. for (; sel_mem_iter != selected_members.end(); sel_mem_iter++)
  957. {
  958. LLRoleMemberChangeType type;
  959. if ( getRoleChangeType(*sel_mem_iter, role_id, type) )
  960. {
  961. if ( type == RMC_ADD ) count++;
  962. else if ( type == RMC_REMOVE ) count--;
  963. }
  964. }
  966. // If anyone selected is in any role besides 'Everyone' then they can't be ejected.
  967. if (role_id.notNull() && (count > 0))
  968. {
  969. can_eject_members = FALSE;
  970. if (role_id == gdatap->mOwnerRole)
  971. {
  972. member_is_owner = TRUE;
  973. }
  974. }
  976. LLRoleData rd;
  977. if (gdatap->getRoleData(role_id,rd))
  978. {
  979. std::ostringstream label;
  980. label << rd.mRoleName;
  981. // Don't bother showing a count, if there is only 0 or 1.
  982. if (count > 1)
  983. {
  984. label << ": " << count ;
  985. }
  987. LLSD row;
  988. row["id"] = role_id;
  990. row["columns"][0]["column"] = "checkbox";
  991. row["columns"][0]["type"] = "checkbox";
  993. row["columns"][1]["column"] = "role";
  994. row["columns"][1]["value"] = label.str();
  996. if (row["id"].asUUID().isNull())
  997. {
  998. // This is the everyone role, you can't take people out of the everyone role!
  999. row["enabled"] = false;
  1000. }
  1002. LLScrollListItem* item = mAssignedRolesList->addElement(row);
  1004. // Extract the checkbox that was created.
  1005. LLScrollListCheck* check_cell = (LLScrollListCheck*) item->getColumn(0);
  1006. LLCheckBoxCtrl* check = check_cell->getCheckBox();
  1007. check->setCommitCallback(onRoleCheck, this);
  1008. check->set( count > 0 );
  1009. check->setTentative(
  1010. (0 != count)
  1011. && (selected_members.size() !=
  1012. (std::vector<LLUUID>::size_type)count));
  1014. //NOTE: as of right now a user can break the group
  1015. //by removing himself from a role if he is the
  1016. //last owner.  We should check for this special case
  1017. // -jwolk
  1018. check->setEnabled(cb_enable);
  1019. item->setEnabled(cb_enable);
  1020. }
  1021. }
  1022. else
  1023. {
  1024. // This could happen if changes are not synced right on sub-panel change.
  1025. llwarns << "No group role data for " << iter->second << llendl;
  1026. }
  1027. }
  1028. mAssignedRolesList->setEnabled(TRUE);
  1030. if (gAgent.isGodlike())
  1031. can_eject_members = TRUE;
  1033. if (!can_eject_members && !member_is_owner)
  1034. {
  1035. // Maybe we can eject them because we are an owner...
  1036. LLGroupMgrGroupData::member_list_t::iterator mi = gdatap->mMembers.find(gAgent.getID());
  1037. if (mi != gdatap->mMembers.end())
  1038. {
  1039. LLGroupMemberData* member_data = (*mi).second;
  1041. if ( member_data && member_data->isInRole(gdatap->mOwnerRole) )
  1042. {
  1043. can_eject_members = TRUE;
  1044. }
  1045. }
  1046. }
  1048. mEjectBtn->setEnabled(can_eject_members);
  1049. }
  1051. // static
  1052. void LLPanelGroupMembersSubTab::onMemberDoubleClick(void* user_data)
  1053. {
  1054. LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
  1055. self->handleMemberDoubleClick();
  1056. }
  1058. //static
  1059. void LLPanelGroupMembersSubTab::onInviteMember(void *userdata)
  1060. {
  1061. LLPanelGroupMembersSubTab* selfp = (LLPanelGroupMembersSubTab*) userdata;
  1063. if ( selfp )
  1064. {
  1065. selfp->handleInviteMember();
  1066. }
  1067. }
  1069. void LLPanelGroupMembersSubTab::handleInviteMember()
  1070. {
  1071. LLFloaterGroupInvite::showForGroup(mGroupID);
  1072. }
  1074. void LLPanelGroupMembersSubTab::onEjectMembers(void *userdata)
  1075. {
  1076. LLPanelGroupMembersSubTab* selfp = (LLPanelGroupMembersSubTab*) userdata;
  1078. if ( selfp )
  1079. {
  1080. selfp->handleEjectMembers();
  1081. }
  1082. }
  1084. void LLPanelGroupMembersSubTab::handleEjectMembers()
  1085. {
  1086. //send down an eject message
  1087. std::vector<LLUUID> selected_members;
  1089. std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
  1090. if (selection.empty()) return;
  1092. std::vector<LLScrollListItem*>::iterator itor;
  1093. for (itor = selection.begin() ; 
  1094.  itor != selection.end(); ++itor)
  1095. {
  1096. LLUUID member_id = (*itor)->getUUID();
  1097. selected_members.push_back( member_id );
  1098. }
  1100. mMembersList->deleteSelectedItems();
  1102. sendEjectNotifications(mGroupID, selected_members);
  1104. LLGroupMgr::getInstance()->sendGroupMemberEjects(mGroupID,
  1105.  selected_members);
  1106. }
  1108. void LLPanelGroupMembersSubTab::sendEjectNotifications(const LLUUID& group_id, const std::vector<LLUUID>& selected_members)
  1109. {
  1110. LLGroupMgrGroupData* group_data = LLGroupMgr::getInstance()->getGroupData(group_id);
  1112. if (group_data)
  1113. {
  1114. for (std::vector<LLUUID>::const_iterator i = selected_members.begin(); i != selected_members.end(); ++i)
  1115. {
  1116. LLSD args;
  1117. std::string name;
  1119. gCacheName->getFullName(*i, name);
  1121. args["AVATAR_NAME"] = name;
  1122. args["GROUP_NAME"] = group_data->mName;
  1124. LLNotifications::instance().add(LLNotification::Params("EjectAvatarFromGroup").substitutions(args));
  1125. }
  1126. }
  1127. }
  1129. void LLPanelGroupMembersSubTab::handleRoleCheck(const LLUUID& role_id,
  1130. LLRoleMemberChangeType type)
  1131. {
  1132. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1133. if (!gdatap) return;
  1135. //add that the user is requesting to change the roles for selected
  1136. //members
  1137. U64 powers_all_have  = 0xffffffffffffLL;
  1138. U64 powers_some_have = 0;
  1140. BOOL   is_owner_role = ( gdatap->mOwnerRole == role_id );
  1141. LLUUID member_id;
  1144. std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
  1145. if (selection.empty())
  1146. {
  1147. return;
  1148. }
  1150. for (std::vector<LLScrollListItem*>::iterator itor = selection.begin() ; 
  1151.  itor != selection.end(); ++itor)
  1152. {
  1154. member_id = (*itor)->getUUID();
  1156. //see if we requested a change for this member before
  1157. if ( mMemberRoleChangeData.find(member_id) == mMemberRoleChangeData.end() )
  1158. {
  1159. mMemberRoleChangeData[member_id] = new role_change_data_map_t;
  1160. }
  1161. role_change_data_map_t* role_change_datap = mMemberRoleChangeData[member_id];
  1163. //now check to see if the selected group member
  1164. //had changed his association with the selected role before
  1166. role_change_data_map_t::iterator  role = role_change_datap->find(role_id);
  1167. if ( role != role_change_datap->end() )
  1168. {
  1169. //see if the new change type cancels out the previous change
  1170. if (role->second != type)
  1171. {
  1172. role_change_datap->erase(role_id);
  1173. if ( is_owner_role ) mNumOwnerAdditions--;
  1174. }
  1175. //else do nothing
  1177. if ( role_change_datap->empty() )
  1178. {
  1179. //the current member now has no role changes
  1180. //so erase the role change and erase the member's entry
  1181. delete role_change_datap;
  1182.                 role_change_datap = NULL;
  1184. mMemberRoleChangeData.erase(member_id);
  1185. }
  1186. }
  1187. else
  1188. {
  1189. //a previously unchanged role is being changed
  1190. (*role_change_datap)[role_id] = type;
  1191. if ( is_owner_role && type == RMC_ADD ) mNumOwnerAdditions++;
  1192. }
  1194. //we need to calculate what powers the selected members
  1195. //have (including the role changes we're making)
  1196. //so that we can rebuild the action list
  1197. U64 new_powers = getAgentPowersBasedOnRoleChanges(member_id);
  1199. powers_all_have  &= new_powers;
  1200. powers_some_have |= new_powers;
  1201. }
  1204. mChanged = !mMemberRoleChangeData.empty();
  1205. notifyObservers();
  1207. //alrighty now we need to update the actions list
  1208. //to reflect the changes
  1209. mAllowedActionsList->deleteAllItems();
  1210. buildActionsList(mAllowedActionsList,
  1211.  powers_some_have,
  1212.  powers_all_have,
  1213.  NULL,
  1214.  FALSE,
  1215.  FALSE,
  1216.  FALSE);
  1217. }
  1220. // static 
  1221. void LLPanelGroupMembersSubTab::onRoleCheck(LLUICtrl* ctrl, void* user_data)
  1222. {
  1223. LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
  1224. LLCheckBoxCtrl* check_box = static_cast<LLCheckBoxCtrl*>(ctrl);
  1225. if (!check_box || !self) return;
  1227. LLScrollListItem* first_selected =
  1228. self->mAssignedRolesList->getFirstSelected();
  1229. if (first_selected)
  1230. {
  1231. LLUUID role_id = first_selected->getUUID();
  1232. LLRoleMemberChangeType change_type = (check_box->get() ? 
  1233.       RMC_ADD : 
  1234.       RMC_REMOVE);
  1236. self->handleRoleCheck(role_id, change_type);
  1237. }
  1238. }
  1240. void LLPanelGroupMembersSubTab::handleMemberDoubleClick()
  1241. {
  1242. LLScrollListItem* selected = mMembersList->getFirstSelected();
  1243. if (selected)
  1244. {
  1245. LLUUID member_id = selected->getUUID();
  1246. LLAvatarActions::showProfile( member_id );
  1247. }
  1248. }
  1250. void LLPanelGroupMembersSubTab::activate()
  1251. {
  1252. LLPanelGroupSubTab::activate();
  1253. if(!mActivated)
  1254. {
  1255. update(GC_ALL);
  1256. mActivated = true;
  1257. }
  1258. }
  1260. void LLPanelGroupMembersSubTab::deactivate()
  1261. {
  1262. LLPanelGroupSubTab::deactivate();
  1263. }
  1265. bool LLPanelGroupMembersSubTab::needsApply(std::string& mesg)
  1266. {
  1267. return mChanged;
  1268. }
  1270. void LLPanelGroupMembersSubTab::cancel()
  1271. {
  1272. if ( mChanged )
  1273. {
  1274. std::for_each(mMemberRoleChangeData.begin(),
  1275.   mMemberRoleChangeData.end(),
  1276.   DeletePairedPointer());
  1277. mMemberRoleChangeData.clear();
  1279. mChanged = FALSE;
  1280. notifyObservers();
  1281. }
  1282. }
  1284. bool LLPanelGroupMembersSubTab::apply(std::string& mesg)
  1285. {
  1286. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1287. if (!gdatap)
  1288. {
  1289. llwarns << "Unable to get group data for group " << mGroupID << llendl;
  1291. mesg.assign("Unable to save member data.  Try again later.");
  1292. return false;
  1293. }
  1295. if (mChanged)
  1296. {
  1297. //figure out if we are somehow adding an owner or not and alert
  1298. //the user...possibly make it ignorable
  1299. if ( mNumOwnerAdditions > 0 )
  1300. {
  1301. LLRoleData rd;
  1302. LLSD args;
  1304. if ( gdatap->getRoleData(gdatap->mOwnerRole, rd) )
  1305. {
  1306. mHasModal = TRUE;
  1307. args["ROLE_NAME"] = rd.mRoleName;
  1308. LLNotificationsUtil::add("AddGroupOwnerWarning",
  1309. args,
  1310. LLSD(),
  1311. boost::bind(&LLPanelGroupMembersSubTab::addOwnerCB, this, _1, _2));
  1312. }
  1313. else
  1314. {
  1315. llwarns << "Unable to get role information for the owner role in group " << mGroupID << llendl;
  1317. mesg.assign("Unable to retried specific group information.  Try again later");
  1318. return false;
  1319. }
  1320.  
  1321. }
  1322. else
  1323. {
  1324. applyMemberChanges();
  1325. }
  1326. }
  1328. return true;
  1329. }
  1331. bool LLPanelGroupMembersSubTab::addOwnerCB(const LLSD& notification, const LLSD& response)
  1332. {
  1333. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1334. mHasModal = FALSE;
  1336. if (0 == option)
  1337. {
  1338. // User clicked "Yes"
  1339. applyMemberChanges();
  1340. }
  1341. return false;
  1342. }
  1344. void LLPanelGroupMembersSubTab::applyMemberChanges()
  1345. {
  1346. //sucks to do a find again here, but it is in constant time, so, could
  1347. //be worse
  1348. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1349. if (!gdatap)
  1350. {
  1351. llwarns << "Unable to get group data for group " << mGroupID << llendl;
  1352. return;
  1353. }
  1355. //we need to add all of the changed roles data
  1356. //for each member whose role changed
  1357. for (member_role_changes_map_t::iterator member = mMemberRoleChangeData.begin();
  1358.  member != mMemberRoleChangeData.end(); ++member)
  1359. {
  1360. for (role_change_data_map_t::iterator role = member->second->begin();
  1361.  role != member->second->end(); ++role)
  1362. {
  1363. gdatap->changeRoleMember(role->first, //role_id
  1364.  member->first, //member_id
  1365.  role->second); //add/remove
  1366. }
  1368. member->second->clear();
  1369. delete member->second;
  1370. }
  1371. mMemberRoleChangeData.clear();
  1373. LLGroupMgr::getInstance()->sendGroupRoleMemberChanges(mGroupID);
  1374. //force a UI update
  1375. handleMemberSelect();
  1377. mChanged = FALSE;
  1378. mNumOwnerAdditions = 0;
  1379. notifyObservers();
  1380. }
  1382. bool LLPanelGroupMembersSubTab::matchesSearchFilter(const std::string& fullname)
  1383. {
  1384. // If the search filter is empty, everything passes.
  1385. if (mSearchFilter.empty()) return true;
  1387. // Create a full name, and compare it to the search filter.
  1388. std::string fullname_lc(fullname);
  1389. LLStringUtil::toLower(fullname_lc);
  1391. std::string::size_type match = fullname_lc.find(mSearchFilter);
  1393. if (std::string::npos == match)
  1394. {
  1395. // not found
  1396. return false;
  1397. }
  1398. else
  1399. {
  1400. return true;
  1401. }
  1402. }
  1404. U64 LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges(const LLUUID& agent_id)
  1405. {
  1406. //we loop over all of the changes
  1407. //if we are adding a role, then we simply add the role's powers
  1408. //if we are removing a role, we store that role id away
  1409. //and then we have to build the powers up bases on the roles the agent
  1410. //is in
  1412. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1413. if (!gdatap) 
  1414. {
  1415. llwarns << "LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges() -- No group data!" << llendl;
  1416. return GP_NO_POWERS;
  1417. }
  1419. LLGroupMemberData* member_data = gdatap->mMembers[agent_id];
  1420. if ( !member_data )
  1421. {
  1422. llwarns << "LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges() -- No member data for member with UUID " << agent_id << llendl;
  1423. return GP_NO_POWERS;
  1424. }
  1426. //see if there are unsaved role changes for this agent
  1427. role_change_data_map_t* role_change_datap = NULL;
  1428. member_role_changes_map_t::iterator member = mMemberRoleChangeData.find(agent_id);
  1429. if ( member != mMemberRoleChangeData.end() )
  1430. {
  1431. //this member has unsaved role changes
  1432. //so grab them
  1433. role_change_datap = (*member).second;
  1434. }
  1436. U64 new_powers = GP_NO_POWERS;
  1438. if ( role_change_datap )
  1439. {
  1440. std::vector<LLUUID> roles_to_be_removed;
  1442. for (role_change_data_map_t::iterator role = role_change_datap->begin();
  1443.  role != role_change_datap->end(); ++ role)
  1444. {
  1445. if ( role->second == RMC_ADD )
  1446. {
  1447. new_powers |= gdatap->getRolePowers(role->first);
  1448. }
  1449. else
  1450. {
  1451. roles_to_be_removed.push_back(role->first);
  1452. }
  1453. }
  1455. //loop over the member's current roles, summing up
  1456. //the powers (not including the role we are removing)
  1457. for (LLGroupMemberData::role_list_t::iterator current_role = member_data->roleBegin();
  1458.  current_role != member_data->roleEnd(); ++current_role)
  1459. {
  1460. bool role_in_remove_list =
  1461. (std::find(roles_to_be_removed.begin(),
  1462.    roles_to_be_removed.end(),
  1463.    current_role->second->getID()) !=
  1464.  roles_to_be_removed.end());
  1466. if ( !role_in_remove_list )
  1467. {
  1468. new_powers |= 
  1469. current_role->second->getRoleData().mRolePowers;
  1470. }
  1471. }
  1472. }
  1473. else
  1474. {
  1475. //there are no changes for this member
  1476. //the member's powers are just the ones stored in the group
  1477. //manager
  1478. new_powers = member_data->getAgentPowers();
  1479. }
  1481. return new_powers;
  1482. }
  1484. //If there is no change, returns false be sure to verify
  1485. //that there is a role change before attempting to get it or else
  1486. //the data will make no sense.  Stores the role change type
  1487. bool LLPanelGroupMembersSubTab::getRoleChangeType(const LLUUID& member_id,
  1488.   const LLUUID& role_id,
  1489.   LLRoleMemberChangeType& type)
  1490. {
  1491. member_role_changes_map_t::iterator member_changes_iter = mMemberRoleChangeData.find(member_id);
  1492. if ( member_changes_iter != mMemberRoleChangeData.end() )
  1493. {
  1494. role_change_data_map_t::iterator role_changes_iter = member_changes_iter->second->find(role_id);
  1495. if ( role_changes_iter != member_changes_iter->second->end() )
  1496. {
  1497. type = role_changes_iter->second;
  1498. return true;
  1499. }
  1500. }
  1502. return false;
  1503. }
  1505. void LLPanelGroupMembersSubTab::draw()
  1506. {
  1507. LLPanelGroupSubTab::draw();
  1509. if (mPendingMemberUpdate)
  1510. {
  1511. updateMembers();
  1512. }
  1513. }
  1515. void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
  1516. {
  1517. if (mGroupID.isNull()) return;
  1519. if ( GC_TITLES == gc || GC_PROPERTIES == gc )
  1520. {
  1521. // Don't care about title or general group properties updates.
  1522. return;
  1523. }
  1525. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1526. if (!gdatap) 
  1527. {
  1528. llwarns << "LLPanelGroupMembersSubTab::update() -- No group data!" << llendl;
  1529. return;
  1530. }
  1532. // Wait for both all data to be retrieved before displaying anything.
  1533. if (   gdatap->isMemberDataComplete() 
  1534. && gdatap->isRoleDataComplete()
  1535. && gdatap->isRoleMemberDataComplete())
  1536. {
  1537. mMemberProgress = gdatap->mMembers.begin();
  1538. mPendingMemberUpdate = TRUE;
  1539. mHasMatch = FALSE;
  1540. }
  1541. else
  1542. {
  1543. // Build a string with info on retrieval progress.
  1544. std::ostringstream retrieved;
  1545. if ( !gdatap->isMemberDataComplete() )
  1546. {
  1547. // Still busy retreiving member list.
  1548. retrieved << "Retrieving member list (" << gdatap->mMembers.size()
  1549.   << " / " << gdatap->mMemberCount << ")...";
  1550. }
  1551. else if( !gdatap->isRoleDataComplete() )
  1552. {
  1553. // Still busy retreiving role list.
  1554. retrieved << "Retrieving role list (" << gdatap->mRoles.size()
  1555.   << " / " << gdatap->mRoleCount << ")...";
  1556. }
  1557. else // (!gdatap->isRoleMemberDataComplete())
  1558. {
  1559. // Still busy retreiving role/member mappings.
  1560. retrieved << "Retrieving role member mappings...";
  1561. }
  1562. mMembersList->setEnabled(FALSE);
  1563. mMembersList->setCommentText(retrieved.str());
  1564. }
  1565. }
  1567. void LLPanelGroupMembersSubTab::updateMembers()
  1568. {
  1569. mPendingMemberUpdate = FALSE;
  1571. // Rebuild the members list.
  1573. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1574. if (!gdatap) 
  1575. {
  1576. llwarns << "LLPanelGroupMembersSubTab::updateMembers() -- No group data!" << llendl;
  1577. return;
  1578. }
  1580. // Make sure all data is still complete.  Incomplete data
  1581. // may occur if we refresh.
  1582. if (   !gdatap->isMemberDataComplete() 
  1583. || !gdatap->isRoleDataComplete()
  1584. || !gdatap->isRoleMemberDataComplete())
  1585. {
  1586. return;
  1587. }
  1589. //cleanup list only for first iretation
  1590. if(mMemberProgress == gdatap->mMembers.begin())
  1591. mMembersList->deleteAllItems();
  1594. LLGroupMgrGroupData::member_list_t::iterator end = gdatap->mMembers.end();
  1596. S32 i = 0;
  1597. for( ; mMemberProgress != end && i<UPDATE_MEMBERS_PER_FRAME; 
  1598. ++mMemberProgress, ++i)
  1599. {
  1600. if (!mMemberProgress->second)
  1601. continue;
  1602. // Do filtering on name if it is already in the cache.
  1603. bool add_member = true;
  1605. std::string fullname;
  1606. if (gCacheName->getFullName(mMemberProgress->first, fullname))
  1607. {
  1608. if ( !matchesSearchFilter(fullname) )
  1609. {
  1610. add_member = false;
  1611. }
  1612. }
  1614. if (add_member)
  1615. {
  1616. // Build the donated tier string.
  1617. std::ostringstream donated;
  1618. donated << mMemberProgress->second->getContribution() << " sq. m.";
  1620. LLSD row;
  1621. row["id"] = (*mMemberProgress).first;
  1623. row["columns"][0]["column"] = "name";
  1624. // value is filled in by name list control
  1626. row["columns"][1]["column"] = "donated";
  1627. row["columns"][1]["value"] = donated.str();
  1629. row["columns"][2]["column"] = "online";
  1630. row["columns"][2]["value"] = mMemberProgress->second->getOnlineStatus();
  1631. row["columns"][2]["font"] = "SANSSERIF_SMALL";
  1633. LLScrollListItem* member = mMembersList->addElement(row);//, ADD_SORTED);
  1635. LLUUID id = member->getUUID();
  1636. mHasMatch = TRUE;
  1637. }
  1638. }
  1640. if (mMemberProgress == end)
  1641. {
  1642. if (mHasMatch)
  1643. {
  1644. mMembersList->setEnabled(TRUE);
  1645. }
  1646. else
  1647. {
  1648. mMembersList->setEnabled(FALSE);
  1649. mMembersList->setCommentText(std::string("No match."));
  1650. }
  1651. }
  1652. else
  1653. {
  1654. mPendingMemberUpdate = TRUE;
  1655. }
  1657. // This should clear the other two lists, since nothing is selected.
  1658. handleMemberSelect();
  1659. }
  1663. ////////////////////////////
  1664. // LLPanelGroupRolesSubTab
  1665. ////////////////////////////
  1667. static LLRegisterPanelClassWrapper<LLPanelGroupRolesSubTab> t_panel_group_roles_subtab("panel_group_roles_subtab");
  1669. LLPanelGroupRolesSubTab::LLPanelGroupRolesSubTab()
  1670.   : LLPanelGroupSubTab(),
  1671. mRolesList(NULL),
  1672. mAssignedMembersList(NULL),
  1673. mAllowedActionsList(NULL),
  1674. mRoleName(NULL),
  1675. mRoleTitle(NULL),
  1676. mRoleDescription(NULL),
  1677. mMemberVisibleCheck(NULL),
  1678. mDeleteRoleButton(NULL),
  1679. mCreateRoleButton(NULL),
  1681. mHasRoleChange(FALSE)
  1682. {
  1683. }
  1685. LLPanelGroupRolesSubTab::~LLPanelGroupRolesSubTab()
  1686. {
  1687. }
  1689. BOOL LLPanelGroupRolesSubTab::postBuildSubTab(LLView* root)
  1690. {
  1691. LLPanelGroupSubTab::postBuildSubTab(root);
  1693. // Upcast parent so we can ask it for sibling controls.
  1694. LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
  1696. // Look recursively from the parent to find all our widgets.
  1697. bool recurse = true;
  1698. mHeader = parent->getChild<LLPanel>("roles_header", recurse);
  1699. mFooter = parent->getChild<LLPanel>("roles_footer", recurse);
  1702. mRolesList  = parent->getChild<LLScrollListCtrl>("role_list", recurse);
  1703. mAssignedMembersList = parent->getChild<LLNameListCtrl>("role_assigned_members", recurse);
  1704. mAllowedActionsList = parent->getChild<LLScrollListCtrl>("role_allowed_actions", recurse);
  1706. mRoleName = parent->getChild<LLLineEditor>("role_name", recurse);
  1707. mRoleTitle = parent->getChild<LLLineEditor>("role_title", recurse);
  1708. mRoleDescription = parent->getChild<LLTextEditor>("role_description", recurse);
  1710. mMemberVisibleCheck = parent->getChild<LLCheckBoxCtrl>("role_visible_in_list", recurse);
  1712. if (!mRolesList || !mAssignedMembersList || !mAllowedActionsList
  1713. || !mRoleName || !mRoleTitle || !mRoleDescription || !mMemberVisibleCheck)
  1714. {
  1715. llwarns << "ARG! element not found." << llendl;
  1716. return FALSE;
  1717. }
  1719. mRemoveEveryoneTxt = getString("cant_delete_role");
  1721. mCreateRoleButton = 
  1722. parent->getChild<LLButton>("role_create", recurse);
  1723. if ( mCreateRoleButton )
  1724. {
  1725. mCreateRoleButton->setClickedCallback(onCreateRole, this);
  1726. mCreateRoleButton->setEnabled(FALSE);
  1727. }
  1729. mDeleteRoleButton =  
  1730. parent->getChild<LLButton>("role_delete", recurse);
  1731. if ( mDeleteRoleButton )
  1732. {
  1733. mDeleteRoleButton->setClickedCallback(onDeleteRole, this);
  1734. mDeleteRoleButton->setEnabled(FALSE);
  1735. }
  1737. mRolesList->setCommitOnSelectionChange(TRUE);
  1738. mRolesList->setCommitCallback(onRoleSelect, this);
  1740. mAssignedMembersList->setContextMenu(LLScrollListCtrl::MENU_AVATAR);
  1742. mMemberVisibleCheck->setCommitCallback(onMemberVisibilityChange, this);
  1744. mAllowedActionsList->setCommitOnSelectionChange(TRUE);
  1746. mRoleName->setCommitOnFocusLost(TRUE);
  1747. mRoleName->setKeystrokeCallback(onPropertiesKey, this);
  1749. mRoleTitle->setCommitOnFocusLost(TRUE);
  1750. mRoleTitle->setKeystrokeCallback(onPropertiesKey, this);
  1752. mRoleDescription->setCommitOnFocusLost(TRUE);
  1753. mRoleDescription->setCommitCallback(onDescriptionCommit, this);
  1754. mRoleDescription->setFocusReceivedCallback(boost::bind(onDescriptionFocus, _1, this));
  1756. setFooterEnabled(FALSE);
  1758. return TRUE;
  1759. }
  1761. void LLPanelGroupRolesSubTab::activate()
  1762. {
  1763. LLPanelGroupSubTab::activate();
  1765. mRolesList->deselectAllItems();
  1766. mAssignedMembersList->deleteAllItems();
  1767. mAllowedActionsList->deleteAllItems();
  1768. mRoleName->clear();
  1769. mRoleDescription->clear();
  1770. mRoleTitle->clear();
  1772. setFooterEnabled(FALSE);
  1774. mHasRoleChange = FALSE;
  1775. update(GC_ALL);
  1776. }
  1778. void LLPanelGroupRolesSubTab::deactivate()
  1779. {
  1780. lldebugs << "LLPanelGroupRolesSubTab::deactivate()" << llendl;
  1782. LLPanelGroupSubTab::deactivate();
  1783. }
  1785. bool LLPanelGroupRolesSubTab::needsApply(std::string& mesg)
  1786. {
  1787. lldebugs << "LLPanelGroupRolesSubTab::needsApply()" << llendl;
  1789. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1791. return (mHasRoleChange // Text changed in current role
  1792. || (gdatap && gdatap->pendingRoleChanges())); // Pending role changes in the group
  1793. }
  1795. bool LLPanelGroupRolesSubTab::apply(std::string& mesg)
  1796. {
  1797. lldebugs << "LLPanelGroupRolesSubTab::apply()" << llendl;
  1799. saveRoleChanges();
  1800. LLGroupMgr::getInstance()->sendGroupRoleChanges(mGroupID);
  1802. notifyObservers();
  1804. return true;
  1805. }
  1807. void LLPanelGroupRolesSubTab::cancel()
  1808. {
  1809. mHasRoleChange = FALSE;
  1810. LLGroupMgr::getInstance()->cancelGroupRoleChanges(mGroupID);
  1812. notifyObservers();
  1813. }
  1815. LLSD LLPanelGroupRolesSubTab::createRoleItem(const LLUUID& role_id, 
  1816.  std::string name, 
  1817.  std::string title, 
  1818.  S32 members)
  1819. {
  1820. LLSD row;
  1821. row["id"] = role_id;
  1823. row["columns"][0]["column"] = "name";
  1824. row["columns"][0]["value"] = name;
  1826. row["columns"][1]["column"] = "title";
  1827. row["columns"][1]["value"] = title;
  1829. row["columns"][2]["column"] = "members";
  1830. row["columns"][2]["value"] = members;
  1832. return row;
  1833. }
  1835. bool LLPanelGroupRolesSubTab::matchesSearchFilter(std::string rolename, std::string roletitle)
  1836. {
  1837. // If the search filter is empty, everything passes.
  1838. if (mSearchFilter.empty()) return true;
  1840. LLStringUtil::toLower(rolename);
  1841. LLStringUtil::toLower(roletitle);
  1842. std::string::size_type match_name = rolename.find(mSearchFilter);
  1843. std::string::size_type match_title = roletitle.find(mSearchFilter);
  1845. if ( (std::string::npos == match_name)
  1846. && (std::string::npos == match_title))
  1847. {
  1848. // not found
  1849. return false;
  1850. }
  1851. else
  1852. {
  1853. return true;
  1854. }
  1855. }
  1857. void LLPanelGroupRolesSubTab::update(LLGroupChange gc)
  1858. {
  1859. lldebugs << "LLPanelGroupRolesSubTab::update()" << llendl;
  1861. if (mGroupID.isNull()) return;
  1863. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1865. if (!gdatap || !gdatap->isRoleDataComplete())
  1866. {
  1867. LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mGroupID);
  1868. }
  1869. else
  1870. {
  1871. bool had_selection = false;
  1872. LLUUID last_selected;
  1873. if (mRolesList->getFirstSelected())
  1874. {
  1875. last_selected = mRolesList->getFirstSelected()->getUUID();
  1876. had_selection = true;
  1877. }
  1878. mRolesList->deleteAllItems();
  1880. LLScrollListItem* item = NULL;
  1882. LLGroupMgrGroupData::role_list_t::iterator rit = gdatap->mRoles.begin();
  1883. LLGroupMgrGroupData::role_list_t::iterator end = gdatap->mRoles.end();
  1885. for ( ; rit != end; ++rit)
  1886. {
  1887. LLRoleData rd;
  1888. if (gdatap->getRoleData((*rit).first,rd))
  1889. {
  1890. if (matchesSearchFilter(rd.mRoleName, rd.mRoleTitle))
  1891. {
  1892. // If this is the everyone role, then EVERYONE is in it.
  1893. S32 members_in_role = (*rit).first.isNull() ? gdatap->mMembers.size() : (*rit).second->getTotalMembersInRole();
  1894. LLSD row = createRoleItem((*rit).first,rd.mRoleName, rd.mRoleTitle, members_in_role);
  1895. item = mRolesList->addElement(row, ((*rit).first.isNull()) ? ADD_TOP : ADD_BOTTOM, this);
  1896. if (had_selection && ((*rit).first == last_selected))
  1897. {
  1898. item->setSelected(TRUE);
  1899. }
  1900. }
  1901. }
  1902. else
  1903. {
  1904. llwarns << "LLPanelGroupRolesSubTab::update() No role data for role " << (*rit).first << llendl;
  1905. }
  1906. }
  1908. mRolesList->sortByColumn(std::string("name"), TRUE);
  1910. if ( (gdatap->mRoles.size() < (U32)MAX_ROLES)
  1911. && gAgent.hasPowerInGroup(mGroupID, GP_ROLE_CREATE) )
  1912. {
  1913. mCreateRoleButton->setEnabled(TRUE);
  1914. }
  1915. else
  1916. {
  1917. mCreateRoleButton->setEnabled(FALSE);
  1918. }
  1920. if (had_selection)
  1921. {
  1922. handleRoleSelect();
  1923. }
  1924. else
  1925. {
  1926. mAssignedMembersList->deleteAllItems();
  1927. mAllowedActionsList->deleteAllItems();
  1928. mRoleName->clear();
  1929. mRoleDescription->clear();
  1930. mRoleTitle->clear();
  1931. setFooterEnabled(FALSE);
  1932. mDeleteRoleButton->setEnabled(FALSE);
  1933. }
  1934. }
  1936. if (!gdatap || !gdatap->isMemberDataComplete())
  1937. {
  1938. LLGroupMgr::getInstance()->sendGroupMembersRequest(mGroupID);
  1939. }
  1941. if (!gdatap || !gdatap->isRoleMemberDataComplete())
  1942. {
  1943. LLGroupMgr::getInstance()->sendGroupRoleMembersRequest(mGroupID);
  1944. }
  1946. if ((GC_ROLE_MEMBER_DATA == gc || GC_MEMBER_DATA == gc)
  1947.     && gdatap
  1948.     && gdatap->isMemberDataComplete()
  1949.     && gdatap->isRoleMemberDataComplete())
  1950. {
  1951. buildMembersList();
  1952. }
  1953. }
  1955. // static
  1956. void LLPanelGroupRolesSubTab::onRoleSelect(LLUICtrl* ctrl, void* user_data)
  1957. {
  1958. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  1959. self->handleRoleSelect();
  1960. }
  1962. void LLPanelGroupRolesSubTab::handleRoleSelect()
  1963. {
  1964. BOOL can_delete = TRUE;
  1965. lldebugs << "LLPanelGroupRolesSubTab::handleRoleSelect()" << llendl;
  1967. mAssignedMembersList->deleteAllItems();
  1968. mAllowedActionsList->deleteAllItems();
  1970. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  1971. if (!gdatap) 
  1972. {
  1973. llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
  1974. << "-- No group data!" << llendl;
  1975. return;
  1976. }
  1978. saveRoleChanges();
  1980. // Check if there is anything selected.
  1981. LLScrollListItem* item = mRolesList->getFirstSelected();
  1982. if (!item)
  1983. {
  1984. setFooterEnabled(FALSE);
  1985. return;
  1986. }
  1988. setFooterEnabled(TRUE);
  1990. LLRoleData rd;
  1991. if (gdatap->getRoleData(item->getUUID(),rd))
  1992. {
  1993. BOOL is_owner_role = ( gdatap->mOwnerRole == item->getUUID() );
  1994. mRoleName->setText(rd.mRoleName);
  1995. mRoleTitle->setText(rd.mRoleTitle);
  1996. mRoleDescription->setText(rd.mRoleDescription);
  1998. mAllowedActionsList->setEnabled(gAgent.hasPowerInGroup(mGroupID,
  1999.    GP_ROLE_CHANGE_ACTIONS));
  2000. buildActionsList(mAllowedActionsList,
  2001.  rd.mRolePowers,
  2002.  0LL,
  2003.  boost::bind(&LLPanelGroupRolesSubTab::handleActionCheck, this, _1, false),
  2004.  TRUE,
  2005.  FALSE,
  2006.  is_owner_role);
  2009. mMemberVisibleCheck->set((rd.mRolePowers & GP_MEMBER_VISIBLE_IN_DIR) == GP_MEMBER_VISIBLE_IN_DIR);
  2010. mRoleName->setEnabled(!is_owner_role &&
  2011. gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
  2012. mRoleTitle->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
  2013. mRoleDescription->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
  2015. if ( is_owner_role ) 
  2016. {
  2017. // you can't delete the owner role
  2018. can_delete = FALSE;
  2019. // ... or hide members with this role
  2020. mMemberVisibleCheck->setEnabled(FALSE);
  2021. }
  2022. else
  2023. {
  2024. mMemberVisibleCheck->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
  2025. }
  2027. if (item->getUUID().isNull())
  2028. {
  2029. // Everyone role, can't edit description or name or delete
  2030. mRoleDescription->setEnabled(FALSE);
  2031. mRoleName->setEnabled(FALSE);
  2032. can_delete = FALSE;
  2033. }
  2034. }
  2035. else
  2036. {
  2037. mRolesList->deselectAllItems();
  2038. mAssignedMembersList->deleteAllItems();
  2039. mAllowedActionsList->deleteAllItems();
  2040. mRoleName->clear();
  2041. mRoleDescription->clear();
  2042. mRoleTitle->clear();
  2043. setFooterEnabled(FALSE);
  2045. can_delete = FALSE;
  2046. }
  2047. mSelectedRole = item->getUUID();
  2048. buildMembersList();
  2050. can_delete = can_delete && gAgent.hasPowerInGroup(mGroupID,
  2051.   GP_ROLE_DELETE);
  2052. mDeleteRoleButton->setEnabled(can_delete);
  2053. }
  2055. void LLPanelGroupRolesSubTab::buildMembersList()
  2056. {
  2057. mAssignedMembersList->deleteAllItems();
  2059. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2060. if (!gdatap) 
  2061. {
  2062. llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
  2063. << "-- No group data!" << llendl;
  2064. return;
  2065. }
  2067. // Check if there is anything selected.
  2068. LLScrollListItem* item = mRolesList->getFirstSelected();
  2069. if (!item) return;
  2071. if (item->getUUID().isNull())
  2072. {
  2073. // Special cased 'Everyone' role
  2074. LLGroupMgrGroupData::member_list_t::iterator mit = gdatap->mMembers.begin();
  2075. LLGroupMgrGroupData::member_list_t::iterator end = gdatap->mMembers.end();
  2076. for ( ; mit != end; ++mit)
  2077. {
  2078. mAssignedMembersList->addNameItem((*mit).first);
  2079. }
  2080. }
  2081. else
  2082. {
  2083. LLGroupMgrGroupData::role_list_t::iterator rit = gdatap->mRoles.find(item->getUUID());
  2084. if (rit != gdatap->mRoles.end())
  2085. {
  2086. LLGroupRoleData* rdatap = (*rit).second;
  2087. if (rdatap)
  2088. {
  2089. std::vector<LLUUID>::const_iterator mit = rdatap->getMembersBegin();
  2090. std::vector<LLUUID>::const_iterator end = rdatap->getMembersEnd();
  2091. for ( ; mit != end; ++mit)
  2092. {
  2093. mAssignedMembersList->addNameItem((*mit));
  2094. }
  2095. }
  2096. }
  2097. }
  2098. }
  2100. struct ActionCBData
  2101. {
  2102. LLPanelGroupRolesSubTab* mSelf;
  2103. LLCheckBoxCtrl*  mCheck;
  2104. };
  2106. void LLPanelGroupRolesSubTab::handleActionCheck(LLUICtrl* ctrl, bool force)
  2107. {
  2108. LLCheckBoxCtrl* check = dynamic_cast<LLCheckBoxCtrl*>(ctrl);
  2109. if (!check)
  2110. return;
  2112. lldebugs << "LLPanelGroupRolesSubTab::handleActionSelect()" << llendl;
  2114. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2115. if (!gdatap) 
  2116. {
  2117. llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
  2118. << "-- No group data!" << llendl;
  2119. return;
  2120. }
  2122. LLScrollListItem* action_item = mAllowedActionsList->getFirstSelected();
  2123. if (!action_item)
  2124. {
  2125. return;
  2126. }
  2128. LLScrollListItem* role_item = mRolesList->getFirstSelected();
  2129. if (!role_item)
  2130. {
  2131. return;
  2132. }
  2133. LLUUID role_id = role_item->getUUID();
  2135. LLRoleAction* rap = (LLRoleAction*)action_item->getUserdata();
  2136. U64 power = rap->mPowerBit;
  2138. if (check->get())
  2139. {
  2140. if (!force && (    (GP_ROLE_ASSIGN_MEMBER == power)
  2141. || (GP_ROLE_CHANGE_ACTIONS == power) ))
  2142. {
  2143. // Uncheck the item, for now.  It will be
  2144. // checked if they click 'Yes', below.
  2145. check->set(FALSE);
  2147. LLRoleData rd;
  2148. LLSD args;
  2150. if ( gdatap->getRoleData(role_id, rd) )
  2151. {
  2152. args["ACTION_NAME"] = rap->mDescription;
  2153. args["ROLE_NAME"] = rd.mRoleName;
  2154. mHasModal = TRUE;
  2155. std::string warning = "AssignDangerousActionWarning";
  2156. if (GP_ROLE_CHANGE_ACTIONS == power)
  2157. {
  2158. warning = "AssignDangerousAbilityWarning";
  2159. }
  2160. LLNotificationsUtil::add(warning, args, LLSD(), boost::bind(&LLPanelGroupRolesSubTab::addActionCB, this, _1, _2, check));
  2161. }
  2162. else
  2163. {
  2164. llwarns << "Unable to look up role information for role id: "
  2165. << role_id << llendl;
  2166. }
  2167. }
  2168. else
  2169. {
  2170. gdatap->addRolePower(role_id,power);
  2171. }
  2172. }
  2173. else
  2174. {
  2175. gdatap->removeRolePower(role_id,power);
  2176. }
  2178. mHasRoleChange = TRUE;
  2179. notifyObservers();
  2180. }
  2182. bool LLPanelGroupRolesSubTab::addActionCB(const LLSD& notification, const LLSD& response, LLCheckBoxCtrl* check)
  2183. {
  2184. if (!check) return false;
  2186. mHasModal = FALSE;
  2188. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  2189. if (0 == option)
  2190. {
  2191. // User clicked "Yes"
  2192. check->set(TRUE);
  2193. const bool force_add = true;
  2194. handleActionCheck(check, force_add);
  2195. }
  2196. return false;
  2197. }
  2200. // static
  2201. void LLPanelGroupRolesSubTab::onPropertiesKey(LLLineEditor* ctrl, void* user_data)
  2202. {
  2203. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2204. if (!self) return;
  2206. self->mHasRoleChange = TRUE;
  2207. self->notifyObservers();
  2208. }
  2210. // static 
  2211. void LLPanelGroupRolesSubTab::onDescriptionFocus(LLFocusableElement* ctrl, void* user_data)
  2212. {
  2213. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2214. if (!self) return;
  2216. self->mHasRoleChange = TRUE;
  2217. self->notifyObservers();
  2218. }
  2220. // static 
  2221. void LLPanelGroupRolesSubTab::onDescriptionCommit(LLUICtrl* ctrl, void* user_data)
  2222. {
  2223. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2224. if (!self) return;
  2226. self->mHasRoleChange = TRUE;
  2227. self->notifyObservers();
  2228. }
  2230. // static 
  2231. void LLPanelGroupRolesSubTab::onMemberVisibilityChange(LLUICtrl* ctrl, void* user_data)
  2232. {
  2233. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2234. LLCheckBoxCtrl* check = static_cast<LLCheckBoxCtrl*>(ctrl);
  2235. if (!check || !self) return;
  2237. self->handleMemberVisibilityChange(check->get());
  2238. }
  2240. void LLPanelGroupRolesSubTab::handleMemberVisibilityChange(bool value)
  2241. {
  2242. lldebugs << "LLPanelGroupRolesSubTab::handleMemberVisibilityChange()" << llendl;
  2244. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2245. if (!gdatap) 
  2246. {
  2247. llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
  2248. << "-- No group data!" << llendl;
  2249. return;
  2250. }
  2252. LLScrollListItem* role_item = mRolesList->getFirstSelected();
  2253. if (!role_item)
  2254. {
  2255. return;
  2256. }
  2258. if (value)
  2259. {
  2260. gdatap->addRolePower(role_item->getUUID(),GP_MEMBER_VISIBLE_IN_DIR);
  2261. }
  2262. else
  2263. {
  2264. gdatap->removeRolePower(role_item->getUUID(),GP_MEMBER_VISIBLE_IN_DIR);
  2265. }
  2266. }
  2268. // static 
  2269. void LLPanelGroupRolesSubTab::onCreateRole(void* user_data)
  2270. {
  2271. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2272. if (!self) return;
  2274. self->handleCreateRole();
  2275. }
  2277. void LLPanelGroupRolesSubTab::handleCreateRole()
  2278. {
  2279. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2281. if (!gdatap) return;
  2283. LLUUID new_role_id;
  2284. new_role_id.generate();
  2286. LLRoleData rd;
  2287. rd.mRoleName = "New Role";
  2288. gdatap->createRole(new_role_id,rd);
  2290. mRolesList->deselectAllItems(TRUE);
  2291. LLSD row;
  2292. row["id"] = new_role_id;
  2293. row["columns"][0]["column"] = "name";
  2294. row["columns"][0]["value"] = rd.mRoleName;
  2295. mRolesList->addElement(row, ADD_BOTTOM, this);
  2296. mRolesList->selectByID(new_role_id);
  2298. // put focus on name field and select its contents
  2299. if(mRoleName)
  2300. {
  2301. mRoleName->setFocus(TRUE);
  2302. mRoleName->onTabInto();
  2303. gFocusMgr.triggerFocusFlash();
  2304. }
  2306. notifyObservers();
  2307. }
  2309. // static 
  2310. void LLPanelGroupRolesSubTab::onDeleteRole(void* user_data)
  2311. {
  2312. LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
  2313. if (!self) return;
  2315. self->handleDeleteRole();
  2316. }
  2318. void LLPanelGroupRolesSubTab::handleDeleteRole()
  2319. {
  2320. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2322. if (!gdatap) return;
  2324. LLScrollListItem* role_item = mRolesList->getFirstSelected();
  2325. if (!role_item)
  2326. {
  2327. return;
  2328. }
  2330. if (role_item->getUUID().isNull() || role_item->getUUID() == gdatap->mOwnerRole)
  2331. {
  2332. LLSD args;
  2333. args["MESSAGE"] = mRemoveEveryoneTxt;
  2334. LLNotificationsUtil::add("GenericAlert", args);
  2335. return;
  2336. }
  2338. gdatap->deleteRole(role_item->getUUID());
  2339. mRolesList->deleteSingleItem(mRolesList->getFirstSelectedIndex());
  2340. mRolesList->selectFirstItem();
  2342. notifyObservers();
  2343. }
  2345. void LLPanelGroupRolesSubTab::saveRoleChanges()
  2346. {
  2347. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2349. if (!gdatap) return;
  2351. if (mHasRoleChange)
  2352. {
  2353. LLRoleData rd;
  2354. if (!gdatap->getRoleData(mSelectedRole,rd)) return;
  2356. rd.mRoleName = mRoleName->getText();
  2357. rd.mRoleDescription = mRoleDescription->getText();
  2358. rd.mRoleTitle = mRoleTitle->getText();
  2360. gdatap->setRoleData(mSelectedRole,rd);
  2362. mRolesList->deleteSingleItem(mRolesList->getItemIndex(mSelectedRole));
  2364. LLSD row = createRoleItem(mSelectedRole,rd.mRoleName,rd.mRoleTitle,0);
  2365. LLScrollListItem* item = mRolesList->addElement(row, ADD_BOTTOM, this);
  2366. item->setSelected(TRUE);
  2368. mHasRoleChange = FALSE;
  2369. }
  2370. }
  2371. ////////////////////////////
  2372. // LLPanelGroupActionsSubTab
  2373. ////////////////////////////
  2375. static LLRegisterPanelClassWrapper<LLPanelGroupActionsSubTab> t_panel_group_actions_subtab("panel_group_actions_subtab");
  2378. LLPanelGroupActionsSubTab::LLPanelGroupActionsSubTab()
  2379. : LLPanelGroupSubTab()
  2380. {
  2381. }
  2383. LLPanelGroupActionsSubTab::~LLPanelGroupActionsSubTab()
  2384. {
  2385. }
  2387. BOOL LLPanelGroupActionsSubTab::postBuildSubTab(LLView* root)
  2388. {
  2389. LLPanelGroupSubTab::postBuildSubTab(root);
  2391. // Upcast parent so we can ask it for sibling controls.
  2392. LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
  2394. // Look recursively from the parent to find all our widgets.
  2395. bool recurse = true;
  2396. mHeader = parent->getChild<LLPanel>("actions_header", recurse);
  2397. mFooter = parent->getChild<LLPanel>("actions_footer", recurse);
  2399. mActionDescription = parent->getChild<LLTextEditor>("action_description", recurse);
  2401. mActionList = parent->getChild<LLScrollListCtrl>("action_list",recurse);
  2402. mActionRoles = parent->getChild<LLScrollListCtrl>("action_roles",recurse);
  2403. mActionMembers  = parent->getChild<LLNameListCtrl>("action_members",recurse);
  2405. if (!mActionList || !mActionDescription || !mActionRoles || !mActionMembers) return FALSE;
  2407. mActionList->setCommitOnSelectionChange(TRUE);
  2408. mActionList->setCommitCallback(boost::bind(&LLPanelGroupActionsSubTab::handleActionSelect, this));
  2409. mActionList->setContextMenu(LLScrollListCtrl::MENU_AVATAR);
  2411. update(GC_ALL);
  2413. return TRUE;
  2414. }
  2416. void LLPanelGroupActionsSubTab::activate()
  2417. {
  2418. LLPanelGroupSubTab::activate();
  2420. update(GC_ALL);
  2421. }
  2423. void LLPanelGroupActionsSubTab::deactivate()
  2424. {
  2425. lldebugs << "LLPanelGroupActionsSubTab::deactivate()" << llendl;
  2427. LLPanelGroupSubTab::deactivate();
  2428. }
  2430. bool LLPanelGroupActionsSubTab::needsApply(std::string& mesg)
  2431. {
  2432. lldebugs << "LLPanelGroupActionsSubTab::needsApply()" << llendl;
  2434. return false;
  2435. }
  2437. bool LLPanelGroupActionsSubTab::apply(std::string& mesg)
  2438. {
  2439. lldebugs << "LLPanelGroupActionsSubTab::apply()" << llendl;
  2440. return true;
  2441. }
  2443. void LLPanelGroupActionsSubTab::update(LLGroupChange gc)
  2444. {
  2445. lldebugs << "LLPanelGroupActionsSubTab::update()" << llendl;
  2447. if (mGroupID.isNull()) return;
  2449. mActionList->deselectAllItems();
  2450. mActionMembers->deleteAllItems();
  2451. mActionRoles->deleteAllItems();
  2452. mActionDescription->clear();
  2454. mActionList->deleteAllItems();
  2455. buildActionsList(mActionList,
  2456.  GP_ALL_POWERS,
  2457.  GP_ALL_POWERS,
  2458.  NULL,
  2459.  FALSE,
  2460.  TRUE,
  2461.  FALSE);
  2462. }
  2464. void LLPanelGroupActionsSubTab::handleActionSelect()
  2465. {
  2466. mActionMembers->deleteAllItems();
  2467. mActionRoles->deleteAllItems();
  2469. U64 power_mask = GP_NO_POWERS;
  2470. std::vector<LLScrollListItem*> selection = 
  2471. mActionList->getAllSelected();
  2472. if (selection.empty()) return;
  2474. LLRoleAction* rap;
  2476. std::vector<LLScrollListItem*>::iterator itor;
  2477. for (itor = selection.begin() ; 
  2478.  itor != selection.end(); ++itor)
  2479. {
  2480. rap = (LLRoleAction*)( (*itor)->getUserdata() );
  2481. power_mask |= rap->mPowerBit;
  2482. }
  2484. if (selection.size() == 1)
  2485. {
  2486. LLScrollListItem* item = selection[0];
  2487. rap = (LLRoleAction*)(item->getUserdata());
  2489. if (rap->mLongDescription.empty())
  2490. {
  2491. mActionDescription->setText(rap->mDescription);
  2492. }
  2493. else
  2494. {
  2495. mActionDescription->setText(rap->mLongDescription);
  2496. }
  2497. }
  2498. else
  2499. {
  2500. mActionDescription->clear();
  2501. }
  2503. LLGroupMgrGroupData* gdatap = LLGroupMgr::getInstance()->getGroupData(mGroupID);
  2505. if (!gdatap) return;
  2507. if (gdatap->isMemberDataComplete())
  2508. {
  2509. LLGroupMgrGroupData::member_list_t::iterator it = gdatap->mMembers.begin();
  2510. LLGroupMgrGroupData::member_list_t::iterator end = gdatap->mMembers.end();
  2511. LLGroupMemberData* gmd;
  2513. for ( ; it != end; ++it)
  2514. {
  2515. gmd = (*it).second;
  2516. if (!gmd) continue;
  2517. if ((gmd->getAgentPowers() & power_mask) == power_mask)
  2518. {
  2519. mActionMembers->addNameItem(gmd->getID());
  2520. }
  2521. }
  2522. }
  2523. else
  2524. {
  2525. LLGroupMgr::getInstance()->sendGroupMembersRequest(mGroupID);
  2526. }
  2528. if (gdatap->isRoleDataComplete())
  2529. {
  2530. LLGroupMgrGroupData::role_list_t::iterator it = gdatap->mRoles.begin();
  2531. LLGroupMgrGroupData::role_list_t::iterator end = gdatap->mRoles.end();
  2532. LLGroupRoleData* rmd;
  2534. for ( ; it != end; ++it)
  2535. {
  2536. rmd = (*it).second;
  2537. if (!rmd) continue;
  2538. if ((rmd->getRoleData().mRolePowers & power_mask) == power_mask)
  2539. {
  2540. mActionRoles->addSimpleElement(rmd->getRoleData().mRoleName);
  2541. }
  2542. }
  2543. }
  2544. else
  2545. {
  2546. LLGroupMgr::getInstance()->sendGroupRoleDataRequest(mGroupID);
  2547. }
  2548. }
  2549. void LLPanelGroupRoles::setGroupID(const LLUUID& id)
  2550. {
  2551. LLPanelGroupTab::setGroupID(id);
  2553. LLPanelGroupMembersSubTab* group_members_tab = findChild<LLPanelGroupMembersSubTab>("members_sub_tab");
  2554. LLPanelGroupRolesSubTab*  group_roles_tab = findChild<LLPanelGroupRolesSubTab>("roles_sub_tab");
  2555. LLPanelGroupActionsSubTab* group_actions_tab = findChild<LLPanelGroupActionsSubTab>("actions_sub_tab");
  2557. if(group_members_tab) group_members_tab->setGroupID(id);
  2558. if(group_roles_tab) group_roles_tab->setGroupID(id);
  2559. if(group_actions_tab) group_actions_tab->setGroupID(id);
  2561. LLButton* button = getChild<LLButton>("member_invite");
  2562. if ( button )
  2563. button->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_MEMBER_INVITE));
  2565. if(mSubTabContainer)
  2566. mSubTabContainer->selectTab(0);
  2568. activate();
  2569. }