Print done when done.

1 files changed, 2642 insertions, 0 deletions

diff --git a/indra/newview/llpanelgrouproles.cpp b/indra/newview/llpanelgrouproles.cpp
new file mode 100644
index 0000000000..ccec55efce
--- /dev/null
+++ b/indra/newview/llpanelgrouproles.cpp
@@ -0,0 +1,2642 @@
+/** 
+ * @file llpanelgrouproles.cpp
+ * @brief Panel for roles information about a particular group.
+ *
+ * Copyright (c) 2006-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llcheckboxctrl.h"
+
+#include "llagent.h"
+#include "llbutton.h"
+#include "llfloateravatarinfo.h"
+#include "llfloatergroupinvite.h"
+#include "lliconctrl.h"
+#include "lllineeditor.h"
+#include "llnamelistctrl.h"
+#include "llnotify.h"
+#include "llpanelgrouproles.h"
+#include "llscrolllistctrl.h"
+#include "lltabcontainer.h"
+#include "lltextbox.h"
+#include "lltexteditor.h"
+#include "llviewerimagelist.h"
+#include "llviewerwindow.h"
+#include "llfocusmgr.h"
+
+#include "roles_constants.h"
+
+bool agentCanRemoveFromRole(const LLUUID& group_id,
+							const LLUUID& role_id)
+{
+	return gAgent.hasPowerInGroup(group_id, GP_ROLE_REMOVE_MEMBER);
+}
+
+bool agentCanAddToRole(const LLUUID& group_id,
+					   const LLUUID& role_id)
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(group_id);
+	if (!gdatap) 
+	{
+		llwarns << "agentCanAddToRole "
+				<< "-- No group data!" << llendl;
+		return false;
+	}
+
+	//make sure the agent is in the group
+	LLGroupMgrGroupData::member_iter mi = gdatap->mMembers.find(gAgent.getID());
+	if (mi == gdatap->mMembers.end())
+	{
+		return false;
+	}
+	
+	LLGroupMemberData* member_data = (*mi).second;
+
+	// Owners can add to any role.
+	if ( member_data->isInRole(gdatap->mOwnerRole) )
+	{
+		return true;
+	}
+
+	// 'Limited assign members' can add to roles the user is in.
+	if ( gAgent.hasPowerInGroup(group_id, GP_ROLE_ASSIGN_MEMBER_LIMITED) &&
+			member_data->isInRole(role_id) )
+	{
+		return true;
+	}
+
+	// 'assign members' can add to non-owner roles.
+	if ( gAgent.hasPowerInGroup(group_id, GP_ROLE_ASSIGN_MEMBER) &&
+			 role_id != gdatap->mOwnerRole )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+// static
+void* LLPanelGroupRoles::createTab(void* data)
+{
+	LLUUID* group_id = static_cast<LLUUID*>(data);
+	return new LLPanelGroupRoles("panel group roles", *group_id);
+}
+
+LLPanelGroupRoles::LLPanelGroupRoles(const std::string& name, const LLUUID& group_id)
+:	LLPanelGroupTab(name, group_id),
+	mCurrentTab(NULL),
+	mRequestedTab( NULL ),
+	mSubTabContainer( NULL ),
+	mFirstUse( TRUE ),
+	mIgnoreTransition( FALSE )
+{
+}
+
+LLPanelGroupRoles::~LLPanelGroupRoles()
+{
+	int i;
+	for (i = 0; i < mSubTabContainer->getTabCount(); ++i)
+	{
+		LLPanelGroupSubTab* subtabp = (LLPanelGroupSubTab*) mSubTabContainer->getPanelByIndex(i);
+
+		subtabp->removeObserver(this);
+	}
+}
+
+BOOL LLPanelGroupRoles::postBuild()
+{
+	lldebugs << "LLPanelGroupRoles::postBuild()" << llendl;
+
+	mSubTabContainer = (LLTabContainerCommon*) getChildByName("roles_tab_container");
+
+	if (!mSubTabContainer) return FALSE;
+
+	// Hook up each sub-tabs callback and widgets.
+	S32 i;
+	for (i = 0; i < mSubTabContainer->getTabCount(); ++i)
+	{
+		LLPanelGroupSubTab* subtabp = (LLPanelGroupSubTab*) mSubTabContainer->getPanelByIndex(i);
+
+		// Add click callbacks to all the tabs.
+		mSubTabContainer->setTabChangeCallback(subtabp, onClickSubTab);
+		mSubTabContainer->setTabUserData(subtabp, this);
+
+		// Hand the subtab a pointer to this LLPanelGroupRoles, so that it can
+		// look around for the widgets it is interested in.
+		if (!subtabp->postBuildSubTab(this)) return FALSE;
+
+		subtabp->addObserver(this);
+	}
+
+	// Set the current tab to whatever is currently being shown.
+	mCurrentTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (!mCurrentTab)
+	{
+		// Need to select a tab.
+		mSubTabContainer->selectFirstTab();
+		mCurrentTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	}
+
+	if (!mCurrentTab) return FALSE;
+
+	// Act as though this tab was just activated.
+	mCurrentTab->activate();
+
+	// Read apply text from the xml file.
+	LLTextBox* txt;
+	// Don't recurse for this, since we don't currently have a recursive removeChild()
+	txt = (LLTextBox*)getChildByName("default_needs_apply_text");
+	if (txt)
+	{
+		mDefaultNeedsApplyMesg = txt->getText();
+		removeChild(txt);
+	}
+	txt = (LLTextBox*)getChildByName("want_apply_text");
+	if (txt)
+	{
+		mWantApplyMesg = txt->getText();
+		removeChild(txt);
+	}
+
+	return LLPanelGroupTab::postBuild();
+}
+
+BOOL LLPanelGroupRoles::isVisibleByAgent(LLAgent* agentp)
+{
+	/* This power was removed to make group roles simpler
+	return agentp->hasPowerInGroup(mGroupID, 
+								   GP_ROLE_CREATE |
+								   GP_ROLE_DELETE |
+								   GP_ROLE_PROPERTIES |
+								   GP_ROLE_VIEW |
+								   GP_ROLE_ASSIGN_MEMBER |
+								   GP_ROLE_REMOVE_MEMBER |
+								   GP_ROLE_CHANGE_ACTIONS |
+								   GP_MEMBER_INVITE |
+								   GP_MEMBER_EJECT |
+								   GP_MEMBER_OPTIONS );
+	*/
+	return mAllowEdit && agentp->isInGroup(mGroupID);
+								   
+}
+
+// static
+void LLPanelGroupRoles::onClickSubTab(void* user_data, bool from_click)
+{
+	LLPanelGroupRoles* self = static_cast<LLPanelGroupRoles*>(user_data);
+	self->handleClickSubTab();
+}
+
+void LLPanelGroupRoles::handleClickSubTab()
+{
+	// If we are already handling a transition,
+	// ignore this.
+	if (mIgnoreTransition)
+	{
+		return;
+	}
+
+	mRequestedTab = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+
+	// Make sure they aren't just clicking the same tab...
+	if (mRequestedTab == mCurrentTab)
+	{
+		return;
+	}
+
+	// Try to switch from the current panel to the panel the user selected.
+	attemptTransition();
+}
+
+BOOL LLPanelGroupRoles::attemptTransition()
+{
+	// Check if the current tab needs to be applied.
+	LLString mesg;
+	if (mCurrentTab && mCurrentTab->needsApply(mesg))
+	{
+		// If no message was provided, give a generic one.
+		if (mesg.empty())
+		{
+			mesg = mDefaultNeedsApplyMesg;
+		}
+		// Create a notify box, telling the user about the unapplied tab.
+		LLString::format_map_t args;
+		args["[NEEDS_APPLY_MESSAGE]"] = mesg;
+		args["[WANT_APPLY_MESSAGE]"] = mWantApplyMesg;
+		gViewerWindow->alertXml("PanelGroupApply", args,
+								onNotifyCallback, (void*) this);
+		mHasModal = TRUE;
+		// We need to reselect the current tab, since it isn't finished.
+		if (mSubTabContainer)
+		{
+			mIgnoreTransition = TRUE;
+			mSubTabContainer->selectTabPanel( mCurrentTab );
+			mIgnoreTransition = FALSE;
+		}
+		// Returning FALSE will block a close action from finishing until
+		// we get a response back from the user.
+		return FALSE;
+	}
+	else
+	{
+		// The current panel didn't have anything it needed to apply.
+		if (mRequestedTab)
+		{
+			transitionToTab();
+		}
+		return TRUE;
+	}
+}
+
+void LLPanelGroupRoles::transitionToTab()
+{
+	// Tell the current panel that it is being deactivated.
+	if (mCurrentTab)
+	{
+		mCurrentTab->deactivate();
+	}
+	
+	// Tell the new panel that it is being activated.
+	if (mRequestedTab)
+	{
+		// This is now the current tab;
+		mCurrentTab = mRequestedTab;
+		mCurrentTab->activate();
+	}
+}
+
+// static
+void LLPanelGroupRoles::onNotifyCallback(S32 option, void* user_data)
+{
+	LLPanelGroupRoles* self = static_cast<LLPanelGroupRoles*>(user_data);
+	if (self)
+	{
+		self->handleNotifyCallback(option);
+	}
+}
+
+void LLPanelGroupRoles::handleNotifyCallback(S32 option)
+{
+	mHasModal = FALSE;
+	switch (option)
+	{
+	case 0: // "Apply Changes"
+	{
+		// Try to apply changes, and switch to the requested tab.
+		LLString apply_mesg;
+		if ( !apply( apply_mesg ) )
+		{
+			// There was a problem doing the apply.
+			if ( !apply_mesg.empty() )
+			{
+				mHasModal = TRUE;
+				LLString::format_map_t args;
+				args["[MESSAGE]"] = apply_mesg;
+				gViewerWindow->alertXml("GenericAlert", args, onModalClose, (void*) this);
+			}
+			// Skip switching tabs.
+			break;
+		}
+
+		// This panel's info successfully applied.
+		// Switch to the next panel.
+		// No break!  Continue into 'Ignore Changes' which just switches tabs.
+		mIgnoreTransition = TRUE;
+		mSubTabContainer->selectTabPanel( mRequestedTab );
+		mIgnoreTransition = FALSE;
+		transitionToTab();
+		break;
+	}
+	case 1: // "Ignore Changes"
+		// Switch to the requested panel without applying changes
+		cancel();
+		mIgnoreTransition = TRUE;
+		mSubTabContainer->selectTabPanel( mRequestedTab );
+		mIgnoreTransition = FALSE;
+		transitionToTab();
+		break;
+	case 2: // "Cancel"
+	default:
+		// Do nothing.  The user is canceling the action.
+		break;
+	}
+}
+
+// static
+void LLPanelGroupRoles::onModalClose(S32 option, void* user_data)
+{
+	LLPanelGroupRoles* self = static_cast<LLPanelGroupRoles*>(user_data);
+	if (self)
+	{
+		self->mHasModal = FALSE;
+	}
+}
+
+
+bool LLPanelGroupRoles::apply(LLString& mesg)
+{
+	// Pass this along to the currently visible sub tab.
+	if (!mSubTabContainer) return false;
+
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (!panelp) return false;
+	
+	// Ignore the needs apply message.
+	LLString ignore_mesg;
+	if ( !panelp->needsApply(ignore_mesg) )
+	{
+		// We don't need to apply anything.
+		// We're done.
+		return true;
+	}
+
+	// Try to do the actual apply.
+	return panelp->apply(mesg);
+}
+
+void LLPanelGroupRoles::cancel()
+{
+	// Pass this along to the currently visible sub tab.
+	if (!mSubTabContainer) return;
+
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (!panelp) return;
+
+	panelp->cancel();
+}
+
+// Pass all of these messages to the currently visible sub tab.
+LLString LLPanelGroupRoles::getHelpText() const
+{
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (panelp)
+	{
+		return panelp->getHelpText();
+	}
+	else
+	{
+		return mHelpText;
+	}
+}
+
+void LLPanelGroupRoles::update(LLGroupChange gc)
+{
+	if (mGroupID.isNull()) return;
+
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (panelp)
+	{
+		panelp->update(gc);
+	}
+	else
+	{
+		llwarns << "LLPanelGroupRoles::update() -- No subtab to update!" << llendl;
+	}
+}
+
+void LLPanelGroupRoles::activate()
+{
+	// Start requesting member and role data if needed.
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	//if (!gdatap || mFirstUse)
+	{
+		// Check member data.
+		
+		if (!gdatap || !gdatap->isMemberDataComplete() )
+		{
+			gGroupMgr->sendGroupMembersRequest(mGroupID);
+		}
+
+		// Check role data.
+		if (!gdatap || !gdatap->isRoleDataComplete() )
+		{
+			// Mildly hackish - clear all pending changes
+			cancel();
+
+			gGroupMgr->sendGroupRoleDataRequest(mGroupID);
+		}
+
+		// Check role-member mapping data.
+		if (!gdatap || !gdatap->isRoleMemberDataComplete() )
+		{
+			gGroupMgr->sendGroupRoleMembersRequest(mGroupID);
+		}
+
+		// Need this to get base group member powers
+		if (!gdatap || !gdatap->isGroupPropertiesDataComplete() )
+		{
+			gGroupMgr->sendGroupPropertiesRequest(mGroupID);
+		}
+
+		mFirstUse = FALSE;
+	}
+
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (panelp) panelp->activate();
+}
+
+void LLPanelGroupRoles::deactivate()
+{
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (panelp) panelp->deactivate();
+}
+
+bool LLPanelGroupRoles::needsApply(LLString& mesg)
+{
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (!panelp) return false;
+		
+	return panelp->needsApply(mesg);
+}
+
+BOOL LLPanelGroupRoles::hasModal()
+{
+	if (mHasModal) return TRUE;
+
+	LLPanelGroupTab* panelp = (LLPanelGroupTab*) mSubTabContainer->getCurrentPanel();
+	if (!panelp) return FALSE;
+		
+	return panelp->hasModal();
+}
+
+// PanelGroupTab observer trigger
+void LLPanelGroupRoles::tabChanged()
+{
+	notifyObservers();
+}
+
+////////////////////////////
+// LLPanelGroupSubTab
+////////////////////////////
+LLPanelGroupSubTab::LLPanelGroupSubTab(const std::string& name, const LLUUID& group_id)
+:	LLPanelGroupTab(name, group_id),
+	mHeader(NULL),
+	mFooter(NULL),
+	mSearchLineEditor(NULL),
+	mSearchButton(NULL),
+	mShowAllButton(NULL)
+{
+}
+
+LLPanelGroupSubTab::~LLPanelGroupSubTab()
+{
+}
+
+BOOL LLPanelGroupSubTab::postBuild()
+{
+	// Hook up the search widgets.
+	bool recurse = true;
+	mSearchLineEditor = (LLLineEditor*) getChildByName("search_text", recurse);
+
+	if (!mSearchLineEditor) return FALSE;
+	mSearchLineEditor->setKeystrokeCallback(onSearchKeystroke);
+	mSearchLineEditor->setCallbackUserData(this);
+
+	mSearchButton = (LLButton*) getChildByName("search_button", recurse);
+
+	if (!mSearchButton) return FALSE;
+	mSearchButton->setClickedCallback(onClickSearch);
+	mSearchButton->setCallbackUserData(this);
+	mSearchButton->setEnabled(FALSE);
+
+	mShowAllButton = (LLButton*) getChildByName("show_all_button", recurse);
+
+	if (!mShowAllButton) return FALSE;
+	mShowAllButton->setClickedCallback(onClickShowAll);
+	mShowAllButton->setCallbackUserData(this);
+	mShowAllButton->setEnabled(FALSE);
+	
+	// Get icons for later use.
+	mActionIcons.clear();
+
+	bool no_recurse = false;
+
+	LLIconCtrl* icon = (LLIconCtrl*) getChildByName("power_folder_icon",no_recurse);
+	if (icon && icon->getImage().notNull())
+	{
+		mActionIcons["folder"] = icon->getImage();
+		removeChild(icon);
+	}
+
+	icon = (LLIconCtrl*) getChildByName("power_all_have_icon",no_recurse);
+	if (icon && icon->getImage().notNull())
+	{
+		mActionIcons["full"] = icon->getImage();
+		removeChild(icon);
+	}
+
+	icon = (LLIconCtrl*) getChildByName("power_partial_icon",no_recurse);
+	if (icon && icon->getImage().notNull())
+	{
+		mActionIcons["partial"] = icon->getImage();
+		removeChild(icon);
+	}
+
+	return LLPanelGroupTab::postBuild();
+}
+
+// static
+void LLPanelGroupSubTab::onSearchKeystroke(LLLineEditor* caller, void* user_data)
+{
+	LLPanelGroupSubTab* self = static_cast<LLPanelGroupSubTab*>(user_data);
+	self->handleSearchKeystroke(caller);
+}
+
+void LLPanelGroupSubTab::handleSearchKeystroke(LLLineEditor* caller)
+{
+	if (caller->getText().size())
+	{
+		setDefaultBtn( mSearchButton );
+		mSearchButton->setEnabled(TRUE);
+	}
+	else
+	{
+		setDefaultBtn( NULL );
+		mSearchButton->setEnabled(FALSE);
+	}
+}
+
+// static 
+void LLPanelGroupSubTab::onClickSearch(void* user_data)
+{
+	LLPanelGroupSubTab* self = static_cast<LLPanelGroupSubTab*>(user_data);
+	self->handleClickSearch();
+}
+ 
+void LLPanelGroupSubTab::handleClickSearch()
+{
+	lldebugs << "LLPanelGroupSubTab::handleClickSearch()" << llendl;
+
+	if (0 == mSearchLineEditor->getText().size())
+	{
+		// No search text.  (This shouldn't happen... the search button should have been disabled).
+		llwarns << "handleClickSearch with no search text!" << llendl;
+		mSearchButton->setEnabled(FALSE);
+		return;
+	}
+
+	setSearchFilter( mSearchLineEditor->getText() );
+	mShowAllButton->setEnabled(TRUE);
+}
+
+// static
+void LLPanelGroupSubTab::onClickShowAll(void* user_data)
+{
+	LLPanelGroupSubTab* self = static_cast<LLPanelGroupSubTab*>(user_data);
+	self->handleClickShowAll();
+}
+
+void LLPanelGroupSubTab::handleClickShowAll()
+{
+	lldebugs << "LLPanelGroupSubTab::handleClickShowAll()" << llendl;
+	setSearchFilter( LLString::null );
+	mShowAllButton->setEnabled(FALSE);
+}
+
+void LLPanelGroupSubTab::setSearchFilter(const LLString& filter)
+{
+	lldebugs << "LLPanelGroupSubTab::setSearchFilter() ==> '" << filter << "'" << llendl;
+	mSearchFilter = filter;
+	LLString::toLower(mSearchFilter);
+	update(GC_ALL);
+}
+
+void LLPanelGroupSubTab::activate()
+{
+	lldebugs << "LLPanelGroupSubTab::activate()" << llendl;
+	setOthersVisible(TRUE);
+}
+
+void LLPanelGroupSubTab::deactivate()
+{
+	lldebugs << "LLPanelGroupSubTab::deactivate()" << llendl;
+	setOthersVisible(FALSE);
+}
+
+void LLPanelGroupSubTab::setOthersVisible(BOOL b)
+{
+	if (mHeader)
+	{
+		mHeader->setVisible( b );
+	}
+	else
+	{
+		llwarns << "LLPanelGroupSubTab missing header!" << llendl;
+	}
+
+	if (mFooter)
+	{
+		mFooter->setVisible( b );
+	}
+	else
+	{
+		llwarns << "LLPanelGroupSubTab missing footer!" << llendl;
+	}
+}
+
+bool LLPanelGroupSubTab::matchesActionSearchFilter(std::string action)
+{
+	// If the search filter is empty, everything passes.
+	if (mSearchFilter.empty()) return true;
+
+	LLString::toLower(action);
+	std::string::size_type match = action.find(mSearchFilter);
+
+	if (std::string::npos == match)
+	{
+		// not found
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+void LLPanelGroupSubTab::buildActionsList(LLScrollListCtrl* ctrl, 
+										  U64 allowed_by_some, 
+										  U64 allowed_by_all,
+										  icon_map_t& icons,
+										  void (*commit_callback)(LLUICtrl*,void*),
+										  BOOL show_all,
+										  BOOL filter,
+										  BOOL is_owner_role)
+{
+	if (gGroupMgr->mRoleActionSets.empty())
+	{
+		llwarns << "Can't build action list - no actions found." << llendl;
+		return;
+	}
+
+	std::vector<LLRoleActionSet*>::iterator ras_it = gGroupMgr->mRoleActionSets.begin();
+	std::vector<LLRoleActionSet*>::iterator ras_end = gGroupMgr->mRoleActionSets.end();
+
+	for ( ; ras_it != ras_end; ++ras_it)
+	{
+		buildActionCategory(ctrl,
+							allowed_by_some,
+							allowed_by_all,
+							(*ras_it),
+							icons, 
+							commit_callback,
+							show_all,
+							filter,
+							is_owner_role);
+	}
+}
+
+void LLPanelGroupSubTab::buildActionCategory(LLScrollListCtrl* ctrl,
+											 U64 allowed_by_some,
+											 U64 allowed_by_all,
+											 LLRoleActionSet* action_set,
+											 icon_map_t& icons,
+											 void (*commit_callback)(LLUICtrl*,void*),
+											 BOOL show_all,
+											 BOOL filter,
+											 BOOL is_owner_role)
+{
+	lldebugs << "Building role list for: " << action_set->mActionSetData->mName << llendl;
+	// See if the allow mask matches anything in this category.
+	if (show_all || (allowed_by_some & action_set->mActionSetData->mPowerBit))
+	{
+		// List all the actions in this category that at least some members have.
+		LLSD row;
+
+		row["columns"][0]["column"] = "icon";
+		icon_map_t::iterator iter = icons.find("folder");
+		if (iter != icons.end())
+		{
+			row["columns"][0]["type"] = "icon";
+			row["columns"][0]["value"] = (*iter).second;
+		}
+
+		row["columns"][1]["column"] = "action";
+		row["columns"][1]["value"] = action_set->mActionSetData->mName;
+		row["columns"][1]["font-style"] = "BOLD";
+
+		LLScrollListItem* title_row = ctrl->addElement(row, ADD_BOTTOM, action_set->mActionSetData);
+
+		bool category_matches_filter = (filter) ? matchesActionSearchFilter(action_set->mActionSetData->mName) : true;
+
+		std::vector<LLRoleAction*>::iterator ra_it = action_set->mActions.begin();
+		std::vector<LLRoleAction*>::iterator ra_end = action_set->mActions.end();
+
+		bool items_match_filter = false;
+		BOOL can_change_actions = (!is_owner_role && gAgent.hasPowerInGroup(mGroupID, GP_ROLE_CHANGE_ACTIONS));
+
+		for ( ; ra_it != ra_end; ++ra_it)
+		{
+			// See if anyone has these action.
+			if (!show_all && !(allowed_by_some & (*ra_it)->mPowerBit))
+			{
+				continue;
+			}
+
+			// See if we are filtering out these actions
+			// If we aren't using filters, category_matches_filter will be true.
+			if (!category_matches_filter
+				&& !matchesActionSearchFilter((*ra_it)->mDescription))
+			{
+				continue;										
+			}
+
+			items_match_filter = true;
+
+			// See if everyone has these actions.
+			bool show_full_strength = false;
+			if ( (allowed_by_some & (*ra_it)->mPowerBit) == (allowed_by_all & (*ra_it)->mPowerBit) )
+			{
+				show_full_strength = true;
+			}
+
+			LLSD row;
+
+			S32 column_index = 0;
+			row["columns"][column_index]["column"] = "icon";
+			++column_index;
+
+			
+			S32 check_box_index = -1;
+			if (commit_callback)
+			{
+				row["columns"][column_index]["column"] = "checkbox";
+				row["columns"][column_index]["type"] = "checkbox";
+				row["columns"][column_index]["value"] = (*ra_it)->mName;
+				check_box_index = column_index;
+				++column_index;
+			}
+			else
+			{
+				if (show_full_strength)
+				{
+					icon_map_t::iterator iter = icons.find("full");
+					if (iter != icons.end())
+					{
+						row["columns"][column_index]["column"] = "checkbox";
+						row["columns"][column_index]["type"] = "icon";
+						row["columns"][column_index]["value"] = (*iter).second;
+						++column_index;
+					}
+				}
+				else
+				{
+					icon_map_t::iterator iter = icons.find("partial");
+					if (iter != icons.end())
+					{
+						row["columns"][column_index]["column"] = "checkbox";
+						row["columns"][column_index]["type"] = "icon";
+						row["columns"][column_index]["value"] = (*iter).second;
+						++column_index;
+					}
+					row["enabled"] = false;
+				}
+			}
+
+			row["columns"][column_index]["column"] = "action";
+			row["columns"][column_index]["value"] = (*ra_it)->mDescription;
+			row["columns"][column_index]["font"] = "SANSSERIFSMALL";
+
+			LLScrollListItem* item = ctrl->addElement(row, ADD_BOTTOM, (*ra_it));
+
+			if (-1 != check_box_index)
+			{
+				// Extract the checkbox that was created.
+				LLScrollListCheck* check_cell = (LLScrollListCheck*) item->getColumn(check_box_index);
+				LLCheckBoxCtrl* check = check_cell->getCheckBox();
+				check->setEnabled(can_change_actions);
+				check->setCommitCallback(commit_callback);
+				check->setCallbackUserData(ctrl->getCallbackUserData());
+				check->setToolTip( check->getLabel() );
+
+				if (show_all)
+				{
+					check->setTentative(FALSE);
+					if (allowed_by_some & (*ra_it)->mPowerBit)
+					{
+						check->set(TRUE);
+					}
+					else
+					{
+						check->set(FALSE);
+					}
+				}
+				else
+				{
+					check->set(TRUE);
+					if (show_full_strength)
+					{
+						check->setTentative(FALSE);
+					}
+					else
+					{
+						check->setTentative(TRUE);
+					}
+				}
+			}
+		}
+
+		if (!items_match_filter)
+		{
+			S32 title_index = ctrl->getItemIndex(title_row);
+			ctrl->deleteSingleItem(title_index);
+		}
+	}
+}
+
+void LLPanelGroupSubTab::setFooterEnabled(BOOL enable)
+{
+	if (mFooter)
+	{
+		mFooter->setAllChildrenEnabled(enable);
+	}
+}
+
+////////////////////////////
+// LLPanelGroupMembersSubTab
+////////////////////////////
+
+// static
+void* LLPanelGroupMembersSubTab::createTab(void* data)
+{
+	LLUUID* group_id = static_cast<LLUUID*>(data);
+	return new LLPanelGroupMembersSubTab("panel group members sub tab", *group_id);
+}
+
+LLPanelGroupMembersSubTab::LLPanelGroupMembersSubTab(const std::string& name, const LLUUID& group_id)
+: 	LLPanelGroupSubTab(name, group_id),
+	mMembersList(NULL),
+	mAssignedRolesList(NULL),
+	mAllowedActionsList(NULL),
+	mChanged(FALSE),
+	mPendingMemberUpdate(FALSE),
+	mHasMatch(FALSE),
+	mNumOwnerAdditions(0)
+{
+}
+
+LLPanelGroupMembersSubTab::~LLPanelGroupMembersSubTab()
+{
+}
+
+BOOL LLPanelGroupMembersSubTab::postBuildSubTab(LLView* root)
+{
+	// Upcast parent so we can ask it for sibling controls.
+	LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
+
+	// Look recursively from the parent to find all our widgets.
+	bool recurse = true;
+	mHeader = (LLPanel*) parent->getChildByName("members_header", recurse);
+	mFooter = (LLPanel*) parent->getChildByName("members_footer", recurse);
+
+	mMembersList 		= (LLNameListCtrl*) 	parent->getChildByName("member_list", recurse);
+	mAssignedRolesList	= (LLScrollListCtrl*)	parent->getChildByName("member_assigned_roles", recurse);
+	mAllowedActionsList	= (LLScrollListCtrl*)	parent->getChildByName("member_allowed_actions", recurse);
+
+	if (!mMembersList || !mAssignedRolesList || !mAllowedActionsList) return FALSE;
+
+	// We want to be notified whenever a member is selected.
+	mMembersList->setCallbackUserData(this);
+	mMembersList->setCommitOnSelectionChange(TRUE);
+	mMembersList->setCommitCallback(onMemberSelect);
+	// Show the member's profile on double click.
+	mMembersList->setDoubleClickCallback(onMemberDoubleClick);
+
+	LLButton* button = (LLButton*) parent->getChildByName("member_invite", recurse);
+	if ( button )
+	{
+		button->setClickedCallback(onInviteMember);
+		button->setCallbackUserData(this);
+		button->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_MEMBER_INVITE));
+	}
+
+	mEjectBtn = (LLButton*) parent->getChildByName("member_eject", recurse);
+	if ( mEjectBtn )
+	{
+		mEjectBtn->setClickedCallback(onEjectMembers);
+		mEjectBtn->setCallbackUserData(this);
+		mEjectBtn->setEnabled(FALSE);
+	}
+
+	return TRUE;
+}
+
+
+// static
+void LLPanelGroupMembersSubTab::onMemberSelect(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
+	self->handleMemberSelect();
+}
+
+void LLPanelGroupMembersSubTab::handleMemberSelect()
+{
+	lldebugs << "LLPanelGroupMembersSubTab::handleMemberSelect" << llendl;
+
+	mAssignedRolesList->deleteAllItems();
+	mAllowedActionsList->deleteAllItems();
+	
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupMembersSubTab::handleMemberSelect() "
+				<< "-- No group data!" << llendl;
+		return;
+	}
+
+	// Check if there is anything selected.
+	std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
+	if (selection.empty()) return;
+
+	// Build a vector of all selected members, and gather allowed actions.
+	std::vector<LLUUID> selected_members;
+	U64 allowed_by_all = 0xffffffffffffLL;
+	U64 allowed_by_some = 0;
+
+	std::vector<LLScrollListItem*>::iterator itor;
+	for (itor = selection.begin();
+		 itor != selection.end(); ++itor)
+	{
+		selected_members.push_back( (*itor)->getUUID() );
+		// Get this member's power mask including any unsaved changes
+
+		U64 powers = getAgentPowersBasedOnRoleChanges((*itor)->getUUID());
+
+		allowed_by_all &= powers;
+		allowed_by_some |= powers;
+	}
+	std::sort(selected_members.begin(), selected_members.end());
+
+	//////////////////////////////////
+	// Build the allowed actions list.
+	//////////////////////////////////
+	buildActionsList(mAllowedActionsList,
+					 allowed_by_some,
+					 allowed_by_all,
+					 mActionIcons,
+					 NULL,
+					 FALSE,
+					 FALSE,
+					 FALSE);
+
+	//////////////////////////////////
+	// Build the assigned roles list.
+	//////////////////////////////////
+	// Add each role to the assigned roles list.
+	LLGroupMgrGroupData::role_iter iter = gdatap->mRoles.begin();
+	LLGroupMgrGroupData::role_iter end  = gdatap->mRoles.end();
+
+	BOOL can_eject_members = gAgent.hasPowerInGroup(mGroupID,
+													GP_MEMBER_EJECT);
+	BOOL member_is_owner = FALSE;
+	
+	for( ; iter != end; ++iter)
+	{
+		// Count how many selected users are in this role.
+		const LLUUID& role_id = iter->first;
+		LLGroupRoleData* group_role_data = iter->second;
+
+		if (group_role_data)
+		{
+			const BOOL needs_sort = FALSE;
+			S32 count = group_role_data->getMembersInRole(
+											selected_members, needs_sort);
+			//check if the user has permissions to assign/remove
+			//members to/from the role (but the ability to add/remove
+			//should only be based on the "saved" changes to the role
+			//not in the temp/meta data. -jwolk
+			BOOL cb_enable = ( (count > 0) ?
+							   agentCanRemoveFromRole(mGroupID, role_id) :
+							   agentCanAddToRole(mGroupID, role_id) );
+
+
+			// Owner role has special enabling permissions for removal.
+			if (cb_enable && (count > 0) && role_id == gdatap->mOwnerRole)
+			{
+				// Check if any owners besides this agent are selected.
+				std::vector<LLUUID>::const_iterator member_iter;
+				std::vector<LLUUID>::const_iterator member_end =
+												selected_members.end();
+				for (member_iter = selected_members.begin();
+					 member_iter != member_end;	
+					 ++member_iter)
+				{
+					// Don't count the agent.
+					if ((*member_iter) == gAgent.getID()) continue;
+					
+					// Look up the member data.
+					LLGroupMgrGroupData::member_iter mi = 
+									gdatap->mMembers.find((*member_iter));
+					if (mi == gdatap->mMembers.end()) continue;
+					LLGroupMemberData* member_data = (*mi).second;
+					// Is the member an owner?
+					if ( member_data->isInRole(gdatap->mOwnerRole) )
+					{
+						// Can't remove other owners.
+						cb_enable = FALSE;
+						break;
+					}
+				}
+			}
+
+			//now see if there are any role changes for the selected
+			//members and remember to include them
+			std::vector<LLUUID>::iterator sel_mem_iter = selected_members.begin();
+			for (; sel_mem_iter != selected_members.end(); sel_mem_iter++)
+			{
+				LLRoleMemberChangeType type;
+				if ( getRoleChangeType(*sel_mem_iter, role_id, type) )
+				{
+					if ( type == RMC_ADD ) count++;
+					else if ( type == RMC_REMOVE ) count--;
+				}
+			}
+			
+			// If anyone selected is in any role besides 'Everyone' then they can't be ejected.
+			if (role_id.notNull() && (count > 0))
+			{
+				can_eject_members = FALSE;
+				if (role_id == gdatap->mOwnerRole)
+				{
+					member_is_owner = TRUE;
+				}
+			}
+
+			LLRoleData rd;
+			if (gdatap->getRoleData(role_id,rd))
+			{
+				std::ostringstream label;
+				label << rd.mRoleName;
+				// Don't bother showing a count, if there is only 0 or 1.
+				if (count > 1)
+				{
+					label << ": " << count ;
+				}
+	
+				LLSD row;
+				row["id"] = role_id;
+
+				row["columns"][0]["column"] = "checkbox";
+				row["columns"][0]["type"] = "checkbox";
+
+				row["columns"][1]["column"] = "role";
+				row["columns"][1]["value"] = label.str();
+
+				if (row["id"].asUUID().isNull())
+				{
+					// This is the everyone role, you can't take people out of the everyone role!
+					row["enabled"] = false;
+				}
+
+				LLScrollListItem* item = mAssignedRolesList->addElement(row);
+
+				// Extract the checkbox that was created.
+				LLScrollListCheck* check_cell = (LLScrollListCheck*) item->getColumn(0);
+				LLCheckBoxCtrl* check = check_cell->getCheckBox();
+				check->setCommitCallback(onRoleCheck);
+				check->setCallbackUserData(this);
+				check->set( count > 0 );
+				check->setTentative(0 != count && selected_members.size() != count);
+
+				//NOTE: as of right now a user can break the group
+				//by removing himself from a role if he is the
+				//last owner.  We should check for this special case
+				// -jwolk
+				check->setEnabled(cb_enable);
+			}
+		}
+		else
+		{
+			// This could happen if changes are not synced right on sub-panel change.
+			llwarns << "No group role data for " << iter->second << llendl;
+		}
+	}
+	mAssignedRolesList->setEnabled(TRUE);
+
+	if (!can_eject_members && !member_is_owner)
+	{
+		// Maybe we can eject them because we are an owner...
+		LLGroupMgrGroupData::member_iter mi = gdatap->mMembers.find(gAgent.getID());
+		if (mi != gdatap->mMembers.end())
+		{
+			LLGroupMemberData* member_data = (*mi).second;
+
+			if ( member_data && member_data->isInRole(gdatap->mOwnerRole) )
+			{
+				can_eject_members = TRUE;
+			}
+		}
+	}
+
+	mEjectBtn->setEnabled(can_eject_members);
+}
+
+// static
+void LLPanelGroupMembersSubTab::onMemberDoubleClick(void* user_data)
+{
+	LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
+	self->handleMemberDoubleClick();
+}
+
+//static
+void LLPanelGroupMembersSubTab::onInviteMember(void *userdata)
+{
+	LLPanelGroupMembersSubTab* selfp = (LLPanelGroupMembersSubTab*) userdata;
+
+	if ( selfp )
+	{
+		selfp->handleInviteMember();
+	}
+}
+
+void LLPanelGroupMembersSubTab::handleInviteMember()
+{
+	LLFloaterGroupInvite::showForGroup(mGroupID);
+}
+
+void LLPanelGroupMembersSubTab::onEjectMembers(void *userdata)
+{
+	LLPanelGroupMembersSubTab* selfp = (LLPanelGroupMembersSubTab*) userdata;
+
+	if ( selfp )
+	{
+		selfp->handleEjectMembers();
+	}
+}
+
+void LLPanelGroupMembersSubTab::handleEjectMembers()
+{
+	//send down an eject message
+	std::vector<LLUUID> selected_members;
+
+	std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
+	if (selection.empty()) return;
+
+	std::vector<LLScrollListItem*>::iterator itor;
+	for (itor = selection.begin() ; 
+		 itor != selection.end(); ++itor)
+	{
+		selected_members.push_back((*itor)->getUUID());
+	}
+
+	mMembersList->deleteSelectedItems();
+
+	gGroupMgr->sendGroupMemberEjects(mGroupID,
+									 selected_members);
+}
+
+void LLPanelGroupMembersSubTab::handleRoleCheck(const LLUUID& role_id,
+												LLRoleMemberChangeType type)
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) return;
+
+	//add that the user is requesting to change the roles for selected
+	//members
+	U64 powers_all_have  = 0xffffffffffffLL;
+	U64 powers_some_have = 0;
+
+	BOOL   is_owner_role = ( gdatap->mOwnerRole == role_id );
+	LLUUID member_id;
+	
+
+	member_role_change_iter           member_end = mMemberRoleChangeData.end();
+	member_role_change_iter           member;
+	role_change_data_map_t           *role_change_datap;
+	role_change_data_map_t::iterator  role_end;
+	role_change_data_map_t::iterator  role;
+
+	std::vector<LLScrollListItem*> selection = mMembersList->getAllSelected();
+	if (selection.empty()) return;
+
+	std::vector<LLScrollListItem*>::iterator itor;
+	for (itor = selection.begin() ; 
+		 itor != selection.end(); ++itor)
+	{
+		member_id = (*itor)->getUUID();
+
+		//see if we requested a change for this member before
+		member = mMemberRoleChangeData.find(member_id);
+		if ( member != member_end )
+		{
+			//this member had previously had their role data changed
+			//so grab it
+			role_change_datap = (*member).second;
+		}
+		else
+		{
+			role_change_datap = new role_change_data_map_t;
+			mMemberRoleChangeData[member_id] = role_change_datap;
+		}
+
+		//now check to see if the selected group member
+		//had changed his association with the selected role before
+		role_end = role_change_datap->end();
+		role     = role_change_datap->find(role_id);
+
+		if ( role != role_end )
+		{
+			//see if the new change type cancels out the previous change
+			if (role->second != type)
+			{
+				role_change_datap->erase(role_id);
+				if ( is_owner_role ) mNumOwnerAdditions--;
+			}
+			//else do nothing
+
+			if ( role_change_datap->empty() )
+			{
+				//the current member now has no role changes
+				//so erase the role change and erase the member's entry
+				delete role_change_datap;
+                role_change_datap = NULL;
+
+				mMemberRoleChangeData.erase(member_id);
+			}
+		}
+		else
+		{
+			//a previously unchanged role is being changed
+			(*role_change_datap)[role_id] = type;
+			if ( is_owner_role && type == RMC_ADD ) mNumOwnerAdditions++;
+		}
+
+		//we need to calculate what powers the selected members
+		//have (including the role changes we're making)
+		//so that we can rebuild the action list
+		U64 new_powers = getAgentPowersBasedOnRoleChanges(member_id);
+
+		powers_all_have  &= new_powers;
+		powers_some_have |= new_powers;
+	}
+
+	
+	mChanged = !mMemberRoleChangeData.empty();
+	notifyObservers();
+
+	//alrighty now we need to update the actions list
+	//to reflect the changes
+	mAllowedActionsList->deleteAllItems();
+	buildActionsList(mAllowedActionsList,
+					 powers_some_have,
+					 powers_all_have,
+					 mActionIcons,
+					 NULL,
+					 FALSE,
+					 FALSE,
+					 FALSE);
+}
+
+
+// static 
+void LLPanelGroupMembersSubTab::onRoleCheck(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupMembersSubTab* self = static_cast<LLPanelGroupMembersSubTab*>(user_data);
+	LLCheckBoxCtrl* check_box = static_cast<LLCheckBoxCtrl*>(ctrl);
+	if (!check_box || !self) return;
+
+
+	LLUUID role_id = self->mAssignedRolesList->getFirstSelected()->getUUID();
+	LLRoleMemberChangeType change_type = (check_box->get() ? 
+										  RMC_ADD : 
+										  RMC_REMOVE);
+
+	self->handleRoleCheck(role_id, change_type);
+}
+
+void LLPanelGroupMembersSubTab::handleMemberDoubleClick()
+{
+	LLScrollListItem* selected = mMembersList->getFirstSelected();
+	if (selected)
+	{
+		LLFloaterAvatarInfo::showFromDirectory( selected->getUUID() );
+	}
+}
+
+void LLPanelGroupMembersSubTab::activate()
+{
+	LLPanelGroupSubTab::activate();
+
+	update(GC_ALL);
+}
+
+void LLPanelGroupMembersSubTab::deactivate()
+{
+	LLPanelGroupSubTab::deactivate();
+}
+
+bool LLPanelGroupMembersSubTab::needsApply(LLString& mesg)
+{
+	return mChanged;
+}
+
+void LLPanelGroupMembersSubTab::cancel()
+{
+	if ( mChanged )
+	{
+		std::for_each(mMemberRoleChangeData.begin(),
+					  mMemberRoleChangeData.end(),
+					  DeletePairedPointer());
+		mMemberRoleChangeData.clear();
+
+		mChanged = FALSE;
+		notifyObservers();
+	}
+}
+
+bool LLPanelGroupMembersSubTab::apply(LLString& mesg)
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap)
+	{
+		llwarns << "Unable to get group data for group " << mGroupID << llendl;
+
+		mesg.assign("Unable to save member data.  Try again later.");
+		return false;
+	}
+
+	if (mChanged)
+	{
+		//figure out if we are somehow adding an owner or not and alert
+		//the user...possibly make it ignorable
+		if ( mNumOwnerAdditions > 0 )
+		{
+			LLRoleData rd;
+			LLStringBase<char>::format_map_t args;
+
+			if ( gdatap->getRoleData(gdatap->mOwnerRole, rd) )
+			{
+				mHasModal = TRUE;
+				args["[ROLE_NAME]"] = rd.mRoleName;
+				gViewerWindow->alertXml("AddGroupOwnerWarning",
+										args,
+										addOwnerCB,
+										this);
+			}
+			else
+			{
+				llwarns << "Unable to get role information for the owner role in group " << mGroupID << llendl;
+
+				mesg.assign("Unable to retried specific group information.  Try again later");
+				return false;
+			}
+				 
+		}
+		else
+		{
+			applyMemberChanges();
+		}
+	}
+
+	return true;
+}
+
+//static
+void LLPanelGroupMembersSubTab::addOwnerCB(S32 option, void* data)
+{
+	LLPanelGroupMembersSubTab* self = (LLPanelGroupMembersSubTab*) data;
+
+	if (!self) return;
+	
+	self->mHasModal = FALSE;
+
+	if (0 == option)
+	{
+		// User clicked "Yes"
+		self->applyMemberChanges();
+	}
+}
+
+void LLPanelGroupMembersSubTab::applyMemberChanges()
+{
+	//sucks to do a find again here, but it is in constant time, so, could
+	//be worse
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap)
+	{
+		llwarns << "Unable to get group data for group " << mGroupID << llendl;
+		return;
+	}
+
+	//we need to add all of the changed roles data
+	//for each member whose role changed
+	member_role_change_iter member_end = mMemberRoleChangeData.end();
+	member_role_change_iter member     = mMemberRoleChangeData.begin();
+
+	for (; member != member_end; member++)
+	{
+		role_change_data_map_t::iterator role_end = member->second->end();
+		role_change_data_map_t::iterator role     = member->second->begin();
+
+		for (; role != role_end; role++)
+		{
+			gdatap->changeRoleMember(role->first, //role_id
+									 member->first, //member_id
+									 role->second); //add/remove
+		}
+
+		member->second->clear();
+		delete member->second;
+	}
+	mMemberRoleChangeData.clear();
+
+	gGroupMgr->sendGroupRoleMemberChanges(mGroupID);	
+	//force a UI update
+	handleMemberSelect();
+
+	mChanged = FALSE;
+	mNumOwnerAdditions = 0;
+	notifyObservers();
+}
+
+bool LLPanelGroupMembersSubTab::matchesSearchFilter(char* first, char* last)
+{
+	// If the search filter is empty, everything passes.
+	if (mSearchFilter.empty()) return true;
+
+	// Create a full name, and compare it to the search filter.
+	LLString fullname;
+	fullname.assign(first);
+	fullname.append(1, ' ');
+	fullname.append(last);
+	LLString::toLower(fullname);
+
+	std::string::size_type match = fullname.find(mSearchFilter);
+
+	if (std::string::npos == match)
+	{
+		// not found
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+U64 LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges(const LLUUID& agent_id)
+{
+	//we loop over all of the changes
+	//if we are adding a role, then we simply add the role's powers
+	//if we are removing a role, we store that role id away
+	//and then we have to build the powers up bases on the roles the agent
+	//is in
+	member_role_change_iter          member_end = mMemberRoleChangeData.end();
+	member_role_change_iter          member;
+	role_change_data_map_t          *role_change_datap = NULL;
+	role_change_data_map_t::iterator role_end;
+	role_change_data_map_t::iterator role;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges() -- No group data!" << llendl;
+		return GP_NO_POWERS;
+	}
+
+	LLGroupMemberData* member_data = gdatap->mMembers[agent_id];
+	if ( !member_data )
+	{
+		llwarns << "LLPanelGroupMembersSubTab::getAgentPowersBasedOnRoleChanges() -- No member data for member with UUID " << agent_id << llendl;
+		return GP_NO_POWERS;
+	}
+
+	//see if there are unsaved role changes for this agent
+	member = mMemberRoleChangeData.find(agent_id);
+	if ( member != member_end )
+	{
+		//this member has unsaved role changes
+		//so grab them
+		role_change_datap = (*member).second;
+	}
+
+	U64 new_powers = GP_NO_POWERS;
+
+	if ( role_change_datap )
+	{
+		std::vector<LLUUID> roles_to_be_removed;
+
+		role_end = role_change_datap->end();
+		role     = role_change_datap->begin();
+
+		for (; role != role_end; role++)
+		{
+			if ( role->second == RMC_ADD )
+				new_powers |= gdatap->getRolePowers(role->first);
+			else
+			{
+				roles_to_be_removed.push_back(role->first);
+			}
+		}
+
+		//loop over the member's current roles, summing up
+		//the powers (not including the role we are removing)
+		std::map<LLUUID,LLGroupRoleData*>::iterator current_role =
+			member_data->roleBegin();
+		std::map<LLUUID,LLGroupRoleData*>::iterator end_role = 
+			member_data->roleEnd();
+
+		for (; current_role != end_role; current_role++)
+		{
+			bool role_in_remove_list =
+				(std::find(roles_to_be_removed.begin(),
+						   roles_to_be_removed.end(),
+						   current_role->second->getID()) !=
+				 roles_to_be_removed.end());
+
+			if ( !role_in_remove_list )
+			{
+				new_powers |= 
+					current_role->second->getRoleData().mRolePowers;
+			}
+		}
+	}
+	else
+	{
+		//there are no changes for this member
+		//the member's powers are just the ones stored in the group
+		//manager
+		new_powers = member_data->getAgentPowers();
+	}
+
+	return new_powers;
+}
+
+//If there is no change, returns false be sure to verify
+//that there is a role change before attempting to get it or else
+//the data will make no sense.  Stores the role change type
+bool LLPanelGroupMembersSubTab::getRoleChangeType(const LLUUID& member_id,
+												  const LLUUID& role_id,
+												  LLRoleMemberChangeType& type)
+{
+	member_role_change_iter           member_changes_iter;
+	role_change_data_map_t::iterator  role_changes_iter;
+
+	member_changes_iter = mMemberRoleChangeData.find(member_id);
+	if ( member_changes_iter != mMemberRoleChangeData.end() )
+	{
+		role_changes_iter = member_changes_iter->second->find(role_id);
+		if ( role_changes_iter != member_changes_iter->second->end() )
+		{
+			type = role_changes_iter->second;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void LLPanelGroupMembersSubTab::draw()
+{
+	LLPanelGroupSubTab::draw();
+
+	if (mPendingMemberUpdate)
+	{
+		updateMembers();
+	}
+}
+
+void LLPanelGroupMembersSubTab::update(LLGroupChange gc)
+{
+	if (mGroupID.isNull()) return;
+
+	if ( GC_TITLES == gc || GC_PROPERTIES == gc )
+	{
+		// Don't care about title or general group properties updates.
+		return;
+	}
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupMembersSubTab::update() -- No group data!" << llendl;
+		return;
+	}
+
+	// Rebuild the members list.
+	mMembersList->deleteAllItems();
+
+	// Wait for both all data to be retrieved before displaying anything.
+	if (   gdatap->isMemberDataComplete() 
+		&& gdatap->isRoleDataComplete()
+		&& gdatap->isRoleMemberDataComplete())
+	{
+		mMemberProgress = gdatap->mMembers.begin();
+		mPendingMemberUpdate = TRUE;
+		mHasMatch = FALSE;
+	}
+	else
+	{
+		// Build a string with info on retrieval progress.
+		std::ostringstream retrieved;
+		if ( !gdatap->isMemberDataComplete() )
+		{
+			// Still busy retreiving member list.
+			retrieved << "Retrieving member list (" << gdatap->mMembers.size()
+					  << " / " << gdatap->mMemberCount << ")...";
+		}
+		else if( !gdatap->isRoleDataComplete() )
+		{
+			// Still busy retreiving role list.
+			retrieved << "Retrieving role list (" << gdatap->mRoles.size()
+					  << " / " << gdatap->mRoleCount << ")...";
+		}
+		else // (!gdatap->isRoleMemberDataComplete())
+		{
+			// Still busy retreiving role/member mappings.
+			retrieved << "Retrieving role member mappings...";
+		}
+		mMembersList->setEnabled(FALSE);
+		mMembersList->addSimpleItem(retrieved.str());
+	}
+}
+
+void LLPanelGroupMembersSubTab::updateMembers()
+{
+	mPendingMemberUpdate = FALSE;
+
+	lldebugs << "LLPanelGroupMembersSubTab::updateMembers()" << llendl;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupMembersSubTab::updateMembers() -- No group data!" << llendl;
+		return;
+	}
+
+	// Make sure all data is still complete.  Incomplete data
+	// may occur if we refresh.
+	if (   !gdatap->isMemberDataComplete() 
+		|| !gdatap->isRoleDataComplete()
+		|| !gdatap->isRoleMemberDataComplete())
+	{
+		return;
+	}
+		
+	LLGroupMgrGroupData::member_iter end = gdatap->mMembers.end();
+
+	char first[DB_FIRST_NAME_BUF_SIZE];
+	char last[DB_LAST_NAME_BUF_SIZE];
+	S32 i = 0;
+	for( ; mMemberProgress != end && i<UPDATE_MEMBERS_PER_FRAME; 
+			++mMemberProgress, ++i)
+	{
+		if (!mMemberProgress->second)
+			continue;
+		// Do filtering on name if it is already in the cache.
+		bool add_member = true;
+
+		if (gCacheName->getName(mMemberProgress->first, first, last))
+		{
+			if ( !matchesSearchFilter(first, last) )
+			{
+				add_member = false;
+			}
+		}
+
+		if (add_member)
+		{
+			// Build the donated tier string.
+			std::ostringstream donated;
+			donated << mMemberProgress->second->getContribution() << " sq. m.";
+
+			LLSD row;
+			row["id"] = (*mMemberProgress).first;
+
+			row["columns"][0]["column"] = "name";
+			// value is filled in by name list control
+
+			row["columns"][1]["column"] = "donated";
+			row["columns"][1]["value"] = donated.str();
+
+			row["columns"][2]["column"] = "online";
+			row["columns"][2]["value"] = mMemberProgress->second->getOnlineStatus();
+			row["columns"][2]["font"] = "SANSSERIFSMALL";
+
+			mMembersList->addElement(row);//, ADD_SORTED);
+			mHasMatch = TRUE;
+		}
+	}
+
+	if (mMemberProgress == end)
+	{
+		if (mHasMatch)
+		{
+			mMembersList->setEnabled(TRUE);
+		}
+		else
+		{
+			mMembersList->setEnabled(FALSE);
+			mMembersList->addSimpleItem("No match.");
+		}
+	}
+	else
+	{
+		mPendingMemberUpdate = TRUE;
+	}
+
+	// This should clear the other two lists, since nothing is selected.
+	handleMemberSelect();
+}
+
+
+
+////////////////////////////
+// LLPanelGroupRolesSubTab
+////////////////////////////
+
+// static
+void* LLPanelGroupRolesSubTab::createTab(void* data)
+{
+	LLUUID* group_id = static_cast<LLUUID*>(data);
+	return new LLPanelGroupRolesSubTab("panel group roles sub tab", *group_id);
+}
+
+LLPanelGroupRolesSubTab::LLPanelGroupRolesSubTab(const std::string& name, const LLUUID& group_id)
+: LLPanelGroupSubTab(name, group_id), mHasRoleChange(FALSE)
+{
+}
+
+LLPanelGroupRolesSubTab::~LLPanelGroupRolesSubTab()
+{
+}
+
+BOOL LLPanelGroupRolesSubTab::postBuildSubTab(LLView* root)
+{
+	// Upcast parent so we can ask it for sibling controls.
+	LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
+
+	// Look recursively from the parent to find all our widgets.
+	bool recurse = true;
+	mHeader = (LLPanel*) parent->getChildByName("roles_header", recurse);
+	mFooter = (LLPanel*) parent->getChildByName("roles_footer", recurse);
+
+
+	mRolesList 		= (LLScrollListCtrl*) 	parent->getChildByName("role_list", recurse);
+	mAssignedMembersList	= (LLNameListCtrl*)	parent->getChildByName("role_assigned_members", recurse);
+	mAllowedActionsList	= (LLScrollListCtrl*)	parent->getChildByName("role_allowed_actions", recurse);
+
+	mRoleName = (LLLineEditor*) parent->getChildByName("role_name", recurse);
+	mRoleTitle = (LLLineEditor*) parent->getChildByName("role_title", recurse);
+	mRoleDescription = (LLTextEditor*) parent->getChildByName("role_description", recurse);
+
+	mMemberVisibleCheck = (LLCheckBoxCtrl*) parent->getChildByName("role_visible_in_list", recurse);
+
+	if (!mRolesList || !mAssignedMembersList || !mAllowedActionsList
+		|| !mRoleName || !mRoleTitle || !mRoleDescription || !mMemberVisibleCheck)
+	{
+		llwarns << "ARG! element not found." << llendl;
+		return FALSE;
+	}
+
+	LLTextBox* txt = (LLTextBox*) parent->getChildByName("cant_delete_role", FALSE);
+	if (txt)
+	{
+		mRemoveEveryoneTxt = txt->getText();
+		parent->removeChild(txt);
+	}
+
+	mCreateRoleButton = 
+		(LLButton*) parent->getChildByName("role_create", recurse);
+	if ( mCreateRoleButton )
+	{
+		mCreateRoleButton->setCallbackUserData(this);
+		mCreateRoleButton->setClickedCallback(onCreateRole);
+		mCreateRoleButton->setEnabled(FALSE);
+	}
+	
+	mDeleteRoleButton =  
+		(LLButton*) parent->getChildByName("role_delete", recurse);
+	if ( mDeleteRoleButton )
+	{
+		mDeleteRoleButton->setCallbackUserData(this);
+		mDeleteRoleButton->setClickedCallback(onDeleteRole);
+		mDeleteRoleButton->setEnabled(FALSE);
+	}
+
+	mRolesList->setCommitOnSelectionChange(TRUE);
+	mRolesList->setCallbackUserData(this);
+	mRolesList->setCommitCallback(onRoleSelect);
+
+	mMemberVisibleCheck->setCallbackUserData(this);
+	mMemberVisibleCheck->setCommitCallback(onMemberVisibilityChange);
+
+	mAllowedActionsList->setCommitOnSelectionChange(TRUE);
+	mAllowedActionsList->setCallbackUserData(this);
+
+	mRoleName->setCommitOnFocusLost(TRUE);
+	mRoleName->setCallbackUserData(this);
+	mRoleName->setKeystrokeCallback(onPropertiesKey);
+
+	mRoleTitle->setCommitOnFocusLost(TRUE);
+	mRoleTitle->setCallbackUserData(this);
+	mRoleTitle->setKeystrokeCallback(onPropertiesKey);
+
+	mRoleDescription->setCommitOnFocusLost(TRUE);
+	mRoleDescription->setCallbackUserData(this);
+	mRoleDescription->setCommitCallback(onDescriptionCommit);
+	mRoleDescription->setFocusReceivedCallback(onDescriptionCommit);
+
+	setFooterEnabled(FALSE);
+
+	return TRUE;
+}
+
+void LLPanelGroupRolesSubTab::activate()
+{
+	LLPanelGroupSubTab::activate();
+
+	mRolesList->deselectAllItems();
+	mAssignedMembersList->deleteAllItems();
+	mAllowedActionsList->deleteAllItems();
+	mRoleName->clear();
+	mRoleDescription->clear();
+	mRoleTitle->clear();
+
+	setFooterEnabled(FALSE);
+
+	mHasRoleChange = FALSE;
+	update(GC_ALL);
+}
+
+void LLPanelGroupRolesSubTab::deactivate()
+{
+	lldebugs << "LLPanelGroupRolesSubTab::deactivate()" << llendl;
+
+	LLPanelGroupSubTab::deactivate();
+}
+
+bool LLPanelGroupRolesSubTab::needsApply(LLString& mesg)
+{
+	lldebugs << "LLPanelGroupRolesSubTab::needsApply()" << llendl;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	return (mHasRoleChange								// Text changed in current role
+			|| (gdatap && gdatap->pendingRoleChanges()));	// Pending role changes in the group
+}
+
+bool LLPanelGroupRolesSubTab::apply(LLString& mesg)
+{
+	lldebugs << "LLPanelGroupRolesSubTab::apply()" << llendl;
+
+	saveRoleChanges();
+	gGroupMgr->sendGroupRoleChanges(mGroupID);
+
+	notifyObservers();
+
+	return true;
+}
+
+void LLPanelGroupRolesSubTab::cancel()
+{
+	mHasRoleChange = FALSE;
+	gGroupMgr->cancelGroupRoleChanges(mGroupID);
+
+	notifyObservers();
+}
+
+LLSD LLPanelGroupRolesSubTab::createRoleItem(const LLUUID& role_id, 
+								 std::string name, 
+								 std::string title, 
+								 S32 members)
+{
+	LLSD row;
+	row["id"] = role_id;
+
+	row["columns"][0]["column"] = "name";
+	row["columns"][0]["value"] = name;
+
+	row["columns"][1]["column"] = "title";
+	row["columns"][1]["value"] = title;
+
+	row["columns"][2]["column"] = "members";
+	row["columns"][2]["value"] = members;
+	
+	return row;
+}
+
+bool LLPanelGroupRolesSubTab::matchesSearchFilter(std::string rolename, std::string roletitle)
+{
+	// If the search filter is empty, everything passes.
+	if (mSearchFilter.empty()) return true;
+
+	LLString::toLower(rolename);
+	LLString::toLower(roletitle);
+	std::string::size_type match_name = rolename.find(mSearchFilter);
+	std::string::size_type match_title = roletitle.find(mSearchFilter);
+
+	if ( (std::string::npos == match_name)
+		&& (std::string::npos == match_title))
+	{
+		// not found
+		return false;
+	}
+	else
+	{
+		return true;
+	}
+}
+
+void LLPanelGroupRolesSubTab::update(LLGroupChange gc)
+{
+	lldebugs << "LLPanelGroupRolesSubTab::update()" << llendl;
+
+	if (mGroupID.isNull()) return;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	if (!gdatap || !gdatap->isRoleDataComplete())
+	{
+		gGroupMgr->sendGroupRoleDataRequest(mGroupID);
+	}
+	else
+	{
+		bool had_selection = false;
+		LLUUID last_selected;
+		if (mRolesList->getFirstSelected())
+		{
+			last_selected = mRolesList->getFirstSelected()->getUUID();
+			had_selection = true;
+		}
+		mRolesList->deleteAllItems();
+
+		LLScrollListItem* item = NULL;
+
+		LLGroupMgrGroupData::role_iter rit = gdatap->mRoles.begin();
+		LLGroupMgrGroupData::role_iter end = gdatap->mRoles.end();
+
+		for ( ; rit != end; ++rit)
+		{
+			LLRoleData rd;
+			if (gdatap->getRoleData((*rit).first,rd))
+			{
+				if (matchesSearchFilter(rd.mRoleName, rd.mRoleTitle))
+				{
+					// If this is the everyone role, then EVERYONE is in it.
+					S32 members_in_role = (*rit).first.isNull() ? gdatap->mMembers.size() : (*rit).second->getTotalMembersInRole();
+					LLSD row = createRoleItem((*rit).first,rd.mRoleName, rd.mRoleTitle, members_in_role);
+					item = mRolesList->addElement(row, ((*rit).first.isNull()) ? ADD_TOP : ADD_BOTTOM, this);
+					if (had_selection && ((*rit).first == last_selected))
+					{
+						item->setSelected(TRUE);
+					}
+				}
+			}
+			else
+			{
+				llwarns << "LLPanelGroupRolesSubTab::update() No role data for role " << (*rit).first << llendl;
+			}
+		}
+
+		mRolesList->sortByColumn("name", TRUE);
+
+		if ( (gdatap->mRoles.size() < MAX_ROLES)
+			&& gAgent.hasPowerInGroup(mGroupID, GP_ROLE_CREATE) )
+		{
+			mCreateRoleButton->setEnabled(TRUE);
+		}
+		else
+		{
+			mCreateRoleButton->setEnabled(FALSE);
+		}
+
+		if (had_selection)
+		{
+			handleRoleSelect();
+		}
+		else
+		{
+			mAssignedMembersList->deleteAllItems();
+			mAllowedActionsList->deleteAllItems();
+			mRoleName->clear();
+			mRoleDescription->clear();
+			mRoleTitle->clear();
+			setFooterEnabled(FALSE);
+			mDeleteRoleButton->setEnabled(FALSE);
+		}
+	}
+
+	if (!gdatap || !gdatap->isMemberDataComplete())
+	{
+		gGroupMgr->sendGroupMembersRequest(mGroupID);
+	}
+	
+	if (!gdatap || !gdatap->isRoleMemberDataComplete())
+	{
+		gGroupMgr->sendGroupRoleMembersRequest(mGroupID);
+	}
+
+	if ((GC_ROLE_MEMBER_DATA == gc || GC_MEMBER_DATA == gc)
+		&& gdatap->isMemberDataComplete()
+		&& gdatap->isRoleMemberDataComplete())
+	{
+		buildMembersList();
+	}
+}
+
+// static
+void LLPanelGroupRolesSubTab::onRoleSelect(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	self->handleRoleSelect();
+}
+
+void LLPanelGroupRolesSubTab::handleRoleSelect()
+{
+	BOOL can_delete = TRUE;
+	lldebugs << "LLPanelGroupRolesSubTab::handleRoleSelect()" << llendl;
+
+	mAssignedMembersList->deleteAllItems();
+	mAllowedActionsList->deleteAllItems();
+	
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
+				<< "-- No group data!" << llendl;
+		return;
+	}
+
+	saveRoleChanges();
+
+	// Check if there is anything selected.
+	LLScrollListItem* item = mRolesList->getFirstSelected();
+	if (!item)
+	{
+		setFooterEnabled(FALSE);
+		return;
+	}
+
+	setFooterEnabled(TRUE);
+
+	LLRoleData rd;
+	if (gdatap->getRoleData(item->getUUID(),rd))
+	{
+		BOOL is_owner_role = ( gdatap->mOwnerRole == item->getUUID() );
+		mRoleName->setText(rd.mRoleName);
+		mRoleTitle->setText(rd.mRoleTitle);
+		mRoleDescription->setText(rd.mRoleDescription);
+
+		mAllowedActionsList->setEnabled(gAgent.hasPowerInGroup(mGroupID,
+									   GP_ROLE_CHANGE_ACTIONS));
+		buildActionsList(mAllowedActionsList,
+						 rd.mRolePowers,
+						 0LL,
+						 mActionIcons,
+						 onActionCheck,
+						 TRUE,
+						 FALSE,
+						 is_owner_role);
+
+
+		mMemberVisibleCheck->set((rd.mRolePowers & GP_MEMBER_VISIBLE_IN_DIR) == GP_MEMBER_VISIBLE_IN_DIR);
+		mRoleName->setEnabled(!is_owner_role &&
+				gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
+		mRoleTitle->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
+		mRoleDescription->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
+		mMemberVisibleCheck->setEnabled(gAgent.hasPowerInGroup(mGroupID, GP_ROLE_PROPERTIES));
+
+		if (item->getUUID().isNull())
+		{
+			// Everyone role, can't edit description or name or delete
+			mRoleDescription->setEnabled(FALSE);
+			mRoleName->setEnabled(FALSE);
+			can_delete = FALSE;
+		}
+		//you can't delete the owner role
+		if ( is_owner_role ) can_delete = FALSE;
+	}
+	else
+	{
+		mRolesList->deselectAllItems();
+		mAssignedMembersList->deleteAllItems();
+		mAllowedActionsList->deleteAllItems();
+		mRoleName->clear();
+		mRoleDescription->clear();
+		mRoleTitle->clear();
+		setFooterEnabled(FALSE);
+
+		can_delete = FALSE;
+	}
+	mSelectedRole = item->getUUID();
+	buildMembersList();
+
+	can_delete = can_delete && gAgent.hasPowerInGroup(mGroupID,
+													  GP_ROLE_DELETE);
+	mDeleteRoleButton->setEnabled(can_delete);
+}
+
+void LLPanelGroupRolesSubTab::buildMembersList()
+{
+	mAssignedMembersList->deleteAllItems();
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
+				<< "-- No group data!" << llendl;
+		return;
+	}
+
+	// Check if there is anything selected.
+	LLScrollListItem* item = mRolesList->getFirstSelected();
+	if (!item) return;
+
+	if (item->getUUID().isNull())
+	{
+		// Special cased 'Everyone' role
+		LLGroupMgrGroupData::member_iter mit = gdatap->mMembers.begin();
+		LLGroupMgrGroupData::member_iter end = gdatap->mMembers.end();
+		for ( ; mit != end; ++mit)
+		{
+			mAssignedMembersList->addNameItem((*mit).first);
+		}
+	}
+	else
+	{
+		LLGroupMgrGroupData::role_iter rit = gdatap->mRoles.find(item->getUUID());
+		if (rit != gdatap->mRoles.end())
+		{
+			LLGroupRoleData* rdatap = (*rit).second;
+			if (rdatap)
+			{
+				std::vector<LLUUID>::const_iterator mit = rdatap->getMembersBegin();
+				std::vector<LLUUID>::const_iterator end = rdatap->getMembersEnd();
+				for ( ; mit != end; ++mit)
+				{
+					mAssignedMembersList->addNameItem((*mit));
+				}
+			}
+		}
+	}
+}
+
+// static
+void LLPanelGroupRolesSubTab::onActionCheck(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	LLCheckBoxCtrl* check = static_cast<LLCheckBoxCtrl*>(ctrl);
+	if (!check || !self) return;
+
+	self->handleActionCheck(check);
+}
+
+struct ActionCBData
+{
+	LLPanelGroupRolesSubTab*	mSelf;
+	LLCheckBoxCtrl* 			mCheck;
+};
+
+void LLPanelGroupRolesSubTab::handleActionCheck(LLCheckBoxCtrl* check, bool force)
+{
+	lldebugs << "LLPanelGroupRolesSubTab::handleActionSelect()" << llendl;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
+				<< "-- No group data!" << llendl;
+		return;
+	}
+
+	LLScrollListItem* action_item = mAllowedActionsList->getFirstSelected();
+	if (!action_item)
+	{
+		return;
+	}
+
+	LLScrollListItem* role_item = mRolesList->getFirstSelected();
+	if (!role_item)
+	{
+		return;
+	}
+	LLUUID role_id = role_item->getUUID();
+
+	LLRoleAction* rap = (LLRoleAction*)action_item->getUserdata();
+	U64 power = rap->mPowerBit;
+
+	if (check->get())
+	{
+		if (!force && (    (GP_ROLE_ASSIGN_MEMBER == power)
+						|| (GP_ROLE_CHANGE_ACTIONS == power) ))
+		{
+			// Uncheck the item, for now.  It will be
+			// checked if they click 'Yes', below.
+			check->set(FALSE);
+
+			LLRoleData rd;
+			LLStringBase<char>::format_map_t args;
+
+			if ( gdatap->getRoleData(role_id, rd) )
+			{
+				args["[ACTION_NAME]"] = rap->mDescription;
+				args["[ROLE_NAME]"] = rd.mRoleName;
+				struct ActionCBData* cb_data = new ActionCBData;
+				cb_data->mSelf = this;
+				cb_data->mCheck = check;
+				mHasModal = TRUE;
+				LLString warning = "AssignDangerousActionWarning";
+				if (GP_ROLE_CHANGE_ACTIONS == power)
+				{
+					warning = "AssignDangerousAbilityWarning";
+				}
+				gViewerWindow->alertXml(warning, args, addActionCB, cb_data);
+			}
+			else
+			{
+				llwarns << "Unable to look up role information for role id: "
+						<< role_id << llendl;
+			}
+		}
+		else
+		{
+			gdatap->addRolePower(role_id,power);
+		}
+	}
+	else
+	{
+		gdatap->removeRolePower(role_id,power);
+	}
+
+	mHasRoleChange = TRUE;
+	notifyObservers();
+}
+
+//static
+void LLPanelGroupRolesSubTab::addActionCB(S32 option, void* data)
+{
+	struct ActionCBData* cb_data = (struct ActionCBData*) data;
+
+	if (!cb_data || !cb_data->mSelf || !cb_data->mCheck) return;
+
+	cb_data->mSelf->mHasModal = FALSE;
+
+	if (0 == option)
+	{
+		// User clicked "Yes"
+		cb_data->mCheck->set(TRUE);
+		const bool force_add = true;
+		cb_data->mSelf->handleActionCheck(cb_data->mCheck, force_add);
+	}
+}
+
+
+// static
+void LLPanelGroupRolesSubTab::onPropertiesKey(LLLineEditor* ctrl, void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	if (!self) return;
+
+	self->mHasRoleChange = TRUE;
+	self->notifyObservers();
+}
+
+// static 
+void LLPanelGroupRolesSubTab::onDescriptionCommit(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	if (!self) return;
+
+	self->mHasRoleChange = TRUE;
+	self->notifyObservers();
+}
+
+// static 
+void LLPanelGroupRolesSubTab::onMemberVisibilityChange(LLUICtrl* ctrl, void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	LLCheckBoxCtrl* check = static_cast<LLCheckBoxCtrl*>(ctrl);
+	if (!check || !self) return;
+
+	self->handleMemberVisibilityChange(check->get());
+}
+
+void LLPanelGroupRolesSubTab::handleMemberVisibilityChange(bool value)
+{
+	lldebugs << "LLPanelGroupRolesSubTab::handleMemberVisibilityChange()" << llendl;
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+	if (!gdatap) 
+	{
+		llwarns << "LLPanelGroupRolesSubTab::handleRoleSelect() "
+				<< "-- No group data!" << llendl;
+		return;
+	}
+
+	LLScrollListItem* role_item = mRolesList->getFirstSelected();
+	if (!role_item)
+	{
+		return;
+	}
+
+	if (value)
+	{
+		gdatap->addRolePower(role_item->getUUID(),GP_MEMBER_VISIBLE_IN_DIR);
+	}
+	else
+	{
+		gdatap->removeRolePower(role_item->getUUID(),GP_MEMBER_VISIBLE_IN_DIR);
+	}
+}
+
+// static 
+void LLPanelGroupRolesSubTab::onCreateRole(void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	if (!self) return;
+
+	self->handleCreateRole();
+}
+
+void LLPanelGroupRolesSubTab::handleCreateRole()
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	if (!gdatap) return;
+
+	LLUUID new_role_id;
+	new_role_id.generate();
+
+	LLRoleData rd;
+	rd.mRoleName = "New Role";
+	gdatap->createRole(new_role_id,rd);
+
+	mRolesList->deselectAllItems(TRUE);
+	LLSD row;
+	row["id"] = new_role_id;
+	row["columns"][0]["column"] = "name";
+	row["columns"][0]["value"] = rd.mRoleName;
+	mRolesList->addElement(row, ADD_BOTTOM, this);
+	mRolesList->selectByID(new_role_id);
+
+	// put focus on name field and select its contents
+	if(mRoleName)
+	{
+		mRoleName->setFocus(TRUE);
+		mRoleName->onTabInto();
+		gFocusMgr.triggerFocusFlash();
+	}
+
+	notifyObservers();
+}
+
+// static 
+void LLPanelGroupRolesSubTab::onDeleteRole(void* user_data)
+{
+	LLPanelGroupRolesSubTab* self = static_cast<LLPanelGroupRolesSubTab*>(user_data);
+	if (!self) return;
+
+	self->handleDeleteRole();
+}
+
+void LLPanelGroupRolesSubTab::handleDeleteRole()
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	if (!gdatap) return;
+
+	LLScrollListItem* role_item = mRolesList->getFirstSelected();
+	if (!role_item)
+	{
+		return;
+	}
+
+	if (role_item->getUUID().isNull() || role_item->getUUID() == gdatap->mOwnerRole)
+	{
+		LLString::format_map_t args;
+		args["[MESSAGE]"] = mRemoveEveryoneTxt;
+		LLNotifyBox::showXml("GenericNotify", args);
+		return;
+	}
+
+	gdatap->deleteRole(role_item->getUUID());
+	mRolesList->deleteSingleItem(mRolesList->getFirstSelectedIndex());
+	mRolesList->selectFirstItem();
+
+	notifyObservers();
+}
+
+void LLPanelGroupRolesSubTab::saveRoleChanges()
+{
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	if (!gdatap) return;
+
+	if (mHasRoleChange)
+	{
+		LLRoleData rd;
+		if (!gdatap->getRoleData(mSelectedRole,rd)) return;
+
+		rd.mRoleName = mRoleName->getText();
+		rd.mRoleDescription = mRoleDescription->getText();
+		rd.mRoleTitle = mRoleTitle->getText();
+
+		gdatap->setRoleData(mSelectedRole,rd);
+
+		mRolesList->deleteSingleItem(mRolesList->getItemIndex(mSelectedRole));
+		
+		LLSD row = createRoleItem(mSelectedRole,rd.mRoleName,rd.mRoleTitle,0);
+		LLScrollListItem* item = mRolesList->addElement(row, ADD_BOTTOM, this);
+		item->setSelected(TRUE);
+
+		mHasRoleChange = FALSE;
+	}
+}
+////////////////////////////
+// LLPanelGroupActionsSubTab
+////////////////////////////
+
+// static
+void* LLPanelGroupActionsSubTab::createTab(void* data)
+{
+	LLUUID* group_id = static_cast<LLUUID*>(data);
+	return new LLPanelGroupActionsSubTab("panel group actions sub tab", *group_id);
+}
+
+LLPanelGroupActionsSubTab::LLPanelGroupActionsSubTab(const std::string& name, const LLUUID& group_id)
+: LLPanelGroupSubTab(name, group_id)
+{
+}
+
+LLPanelGroupActionsSubTab::~LLPanelGroupActionsSubTab()
+{
+}
+
+BOOL LLPanelGroupActionsSubTab::postBuildSubTab(LLView* root)
+{
+	// Upcast parent so we can ask it for sibling controls.
+	LLPanelGroupRoles* parent = (LLPanelGroupRoles*) root;
+
+	// Look recursively from the parent to find all our widgets.
+	bool recurse = true;
+	mHeader = (LLPanel*) parent->getChildByName("actions_header", recurse);
+	mFooter = (LLPanel*) parent->getChildByName("actions_footer", recurse);
+
+	mActionDescription = (LLTextEditor*) parent->getChildByName("action_description", recurse);
+
+	mActionList = (LLScrollListCtrl*) parent->getChildByName("action_list",recurse);
+	mActionRoles = (LLScrollListCtrl*) parent->getChildByName("action_roles",recurse);
+	mActionMembers  = (LLNameListCtrl*) parent->getChildByName("action_members",recurse);
+
+	if (!mActionList || !mActionDescription || !mActionRoles || !mActionMembers) return FALSE;
+
+	mActionList->setCallbackUserData(this);
+	mActionList->setCommitOnSelectionChange(TRUE);
+	mActionList->setCommitCallback(onActionSelect);
+
+	mActionMembers->setCallbackUserData(this);
+	mActionRoles->setCallbackUserData(this);
+
+	update(GC_ALL);
+
+	return TRUE;
+}
+
+void LLPanelGroupActionsSubTab::activate()
+{
+	LLPanelGroupSubTab::activate();
+	lldebugs << "LLPanelGroupActionsSubTab::activate()" << llendl;
+
+	mActionList->deselectAllItems();
+	mActionMembers->deleteAllItems();
+	mActionRoles->deleteAllItems();
+	mActionDescription->clear();
+}
+
+void LLPanelGroupActionsSubTab::deactivate()
+{
+	lldebugs << "LLPanelGroupActionsSubTab::deactivate()" << llendl;
+
+	LLPanelGroupSubTab::deactivate();
+}
+
+bool LLPanelGroupActionsSubTab::needsApply(LLString& mesg)
+{
+	lldebugs << "LLPanelGroupActionsSubTab::needsApply()" << llendl;
+
+	return false;
+}
+
+bool LLPanelGroupActionsSubTab::apply(LLString& mesg)
+{
+	lldebugs << "LLPanelGroupActionsSubTab::apply()" << llendl;
+	return true;
+}
+
+void LLPanelGroupActionsSubTab::update(LLGroupChange gc)
+{
+	lldebugs << "LLPanelGroupActionsSubTab::update()" << llendl;
+
+	if (mGroupID.isNull()) return;
+
+	mActionList->deselectAllItems();
+	mActionMembers->deleteAllItems();
+	mActionRoles->deleteAllItems();
+	mActionDescription->clear();
+
+	mActionList->deleteAllItems();
+	buildActionsList(mActionList,
+					 GP_ALL_POWERS,
+					 GP_ALL_POWERS,
+					 mActionIcons,
+					 NULL,
+					 FALSE,
+					 TRUE,
+					 FALSE);
+}
+
+// static 
+void LLPanelGroupActionsSubTab::onActionSelect(LLUICtrl* scroll, void* data)
+{
+	LLPanelGroupActionsSubTab* self = static_cast<LLPanelGroupActionsSubTab*>(data);
+	self->handleActionSelect();
+}
+
+void LLPanelGroupActionsSubTab::handleActionSelect()
+{
+	mActionMembers->deleteAllItems();
+	mActionRoles->deleteAllItems();
+
+	U64 power_mask = GP_NO_POWERS;
+	std::vector<LLScrollListItem*> selection = 
+							mActionList->getAllSelected();
+	if (selection.empty()) return;
+
+	LLRoleAction* rap;
+
+	std::vector<LLScrollListItem*>::iterator itor;
+	for (itor = selection.begin() ; 
+		 itor != selection.end(); ++itor)
+	{
+		rap = (LLRoleAction*)( (*itor)->getUserdata() );
+		power_mask |= rap->mPowerBit;
+	}
+
+	if (selection.size() == 1)
+	{
+		LLScrollListItem* item = selection[0];
+		rap = (LLRoleAction*)(item->getUserdata());
+
+		if (rap->mLongDescription.empty())
+		{
+			mActionDescription->setText(rap->mDescription);
+		}
+		else
+		{
+			mActionDescription->setText(rap->mLongDescription);
+		}
+	}
+	else
+	{
+		mActionDescription->clear();
+	}
+
+	LLGroupMgrGroupData* gdatap = gGroupMgr->getGroupData(mGroupID);
+
+	if (!gdatap) return;
+
+	if (gdatap->isMemberDataComplete())
+	{
+		LLGroupMgrGroupData::member_iter it = gdatap->mMembers.begin();
+		LLGroupMgrGroupData::member_iter end = gdatap->mMembers.end();
+		LLGroupMemberData* gmd;
+
+		for ( ; it != end; ++it)
+		{
+			gmd = (*it).second;
+			if (!gmd) continue;
+			if ((gmd->getAgentPowers() & power_mask) == power_mask)
+			{
+				mActionMembers->addNameItem(gmd->getID());
+			}
+		}
+	}
+	else
+	{
+		gGroupMgr->sendGroupMembersRequest(mGroupID);
+	}
+
+	if (gdatap->isRoleDataComplete())
+	{
+		LLGroupMgrGroupData::role_iter it = gdatap->mRoles.begin();
+		LLGroupMgrGroupData::role_iter end = gdatap->mRoles.end();
+		LLGroupRoleData* rmd;
+
+		for ( ; it != end; ++it)
+		{
+			rmd = (*it).second;
+			if (!rmd) continue;
+			if ((rmd->getRoleData().mRolePowers & power_mask) == power_mask)
+			{
+				mActionRoles->addSimpleItem(rmd->getRoleData().mRoleName);
+			}
+		}
+	}
+	else
+	{
+		gGroupMgr->sendGroupRoleDataRequest(mGroupID);
+	}
+}