Merge branch 'spaces-merge' into roxie/webrtc-voice

1 files changed, 904 insertions, 904 deletions

diff --git a/indra/newview/llavataractions.cpp b/indra/newview/llavataractions.cpp
index 156b5b4047..2857235dd2 100644
--- a/indra/newview/llavataractions.cpp
+++ b/indra/newview/llavataractions.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llavataractions.cpp
  * @brief Friend-related actions (add, remove, offer teleport, etc)
  *
  * $LicenseInfo:firstyear=2009&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -29,20 +29,20 @@
 
 #include "llavataractions.h"
 
-#include "boost/lambda/lambda.hpp"	// for lambda::constant
+#include "boost/lambda/lambda.hpp"  // for lambda::constant
 
-#include "llavatarnamecache.h"	// IDEVO
+#include "llavatarnamecache.h"  // IDEVO
 #include "llsd.h"
 #include "llnotifications.h"
 #include "llnotificationsutil.h"
 #include "roles_constants.h"    // for GP_MEMBER_INVITE
 
 #include "llagent.h"
-#include "llappviewer.h"		// for gLastVersionChannel
+#include "llappviewer.h"        // for gLastVersionChannel
 #include "llcachename.h"
-#include "llcallingcard.h"		// for LLAvatarTracker
+#include "llcallingcard.h"      // for LLAvatarTracker
 #include "llconversationlog.h"
-#include "llfloateravatarpicker.h"	// for LLFloaterAvatarPicker
+#include "llfloateravatarpicker.h"  // for LLFloaterAvatarPicker
 #include "llfloaterconversationpreview.h"
 #include "llfloatergroupinvite.h"
 #include "llfloatergroups.h"
@@ -55,12 +55,12 @@
 #include "llfolderview.h"
 #include "llgiveinventory.h"
 #include "llinventorybridge.h"
-#include "llinventorymodel.h"	// for gInventory.findCategoryUUIDForType
+#include "llinventorymodel.h"   // for gInventory.findCategoryUUIDForType
 #include "llinventorypanel.h"
 #include "llfloaterimcontainer.h"
-#include "llimview.h"			// for gIMMgr
+#include "llimview.h"           // for gIMMgr
 #include "llmutelist.h"
-#include "llnotificationsutil.h"	// for LLNotificationsUtil
+#include "llnotificationsutil.h"    // for LLNotificationsUtil
 #include "llpaneloutfitedit.h"
 #include "llpanelprofile.h"
 #include "llparcel.h"
@@ -68,304 +68,304 @@
 #include "lltrans.h"
 #include "llviewercontrol.h"
 #include "llviewerobjectlist.h"
-#include "llviewermessage.h"	// for handle_lure
+#include "llviewermessage.h"    // for handle_lure
 #include "llviewernetwork.h" //LLGridManager
 #include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
 #include "lltrans.h"
 #include "llcallingcard.h"
-#include "llslurl.h"			// IDEVO
+#include "llslurl.h"            // IDEVO
 #include "llsidepanelinventory.h"
 #include "llavatarname.h"
 #include "llagentui.h"
 #include "lluiusage.h"
 
 // Flags for kick message
-const U32 KICK_FLAGS_DEFAULT	= 0x0;
-const U32 KICK_FLAGS_FREEZE		= 1 << 0;
-const U32 KICK_FLAGS_UNFREEZE	= 1 << 1;
+const U32 KICK_FLAGS_DEFAULT    = 0x0;
+const U32 KICK_FLAGS_FREEZE     = 1 << 0;
+const U32 KICK_FLAGS_UNFREEZE   = 1 << 1;
 
 
 std::string getProfileURL(const std::string& agent_name, bool feed_only)
 {
     std::string url = "[WEB_PROFILE_URL][AGENT_NAME][FEED_ONLY]";
-	LLSD subs;
-	subs["WEB_PROFILE_URL"] = LLGridManager::getInstance()->getWebProfileURL();
-	subs["AGENT_NAME"] = agent_name;
+    LLSD subs;
+    subs["WEB_PROFILE_URL"] = LLGridManager::getInstance()->getWebProfileURL();
+    subs["AGENT_NAME"] = agent_name;
     subs["FEED_ONLY"] = feed_only ? "/?feed_only=true" : "";
-	url = LLWeb::expandURLSubstitutions(url, subs);
-	LLStringUtil::toLower(url);
-	return url;
+    url = LLWeb::expandURLSubstitutions(url, subs);
+    LLStringUtil::toLower(url);
+    return url;
 }
 
 
 // static
 void LLAvatarActions::requestFriendshipDialog(const LLUUID& id, const std::string& name)
 {
-	if(id == gAgentID)
-	{
-		LLNotificationsUtil::add("AddSelfFriend");
-		return;
-	}
+    if(id == gAgentID)
+    {
+        LLNotificationsUtil::add("AddSelfFriend");
+        return;
+    }
+
+    LLSD args;
+    args["NAME"] = LLSLURL("agent", id, "completename").getSLURLString();
+    LLSD payload;
+    payload["id"] = id;
+    payload["name"] = name;
 
-	LLSD args;
-	args["NAME"] = LLSLURL("agent", id, "completename").getSLURLString();
-	LLSD payload;
-	payload["id"] = id;
-	payload["name"] = name;
-    
-	LLNotificationsUtil::add("AddFriendWithMessage", args, payload, &callbackAddFriendWithMessage);
+    LLNotificationsUtil::add("AddFriendWithMessage", args, payload, &callbackAddFriendWithMessage);
 
-	// add friend to recent people list
-	LLRecentPeople::instance().add(id);
+    // add friend to recent people list
+    LLRecentPeople::instance().add(id);
 }
 
 static void on_avatar_name_friendship(const LLUUID& id, const LLAvatarName av_name)
 {
-	LLAvatarActions::requestFriendshipDialog(id, av_name.getCompleteName());
+    LLAvatarActions::requestFriendshipDialog(id, av_name.getCompleteName());
 }
 
 // static
 void LLAvatarActions::requestFriendshipDialog(const LLUUID& id)
 {
-	if(id.isNull())
-	{
-		return;
-	}
+    if(id.isNull())
+    {
+        return;
+    }
 
-	LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_friendship, _1, _2));
+    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_friendship, _1, _2));
 }
 
 // static
 void LLAvatarActions::removeFriendDialog(const LLUUID& id)
 {
-	if (id.isNull())
-		return;
+    if (id.isNull())
+        return;
 
-	uuid_vec_t ids;
-	ids.push_back(id);
-	removeFriendsDialog(ids);
+    uuid_vec_t ids;
+    ids.push_back(id);
+    removeFriendsDialog(ids);
 }
 
 // static
 void LLAvatarActions::removeFriendsDialog(const uuid_vec_t& ids)
 {
-	if(ids.size() == 0)
-		return;
-
-	LLSD args;
-	std::string msgType;
-	if(ids.size() == 1)
-	{
-		LLUUID agent_id = ids[0];
-		LLAvatarName av_name;
-		if(LLAvatarNameCache::get(agent_id, &av_name))
-		{
-			args["NAME"] = av_name.getCompleteName();
-		}
-
-		msgType = "RemoveFromFriends";
-	}
-	else
-	{
-		msgType = "RemoveMultipleFromFriends";
-	}
-
-	LLSD payload;
-	for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
-	{
-		payload["ids"].append(*it);
-	}
-
-	LLNotificationsUtil::add(msgType,
-		args,
-		payload,
-		&handleRemove);
+    if(ids.size() == 0)
+        return;
+
+    LLSD args;
+    std::string msgType;
+    if(ids.size() == 1)
+    {
+        LLUUID agent_id = ids[0];
+        LLAvatarName av_name;
+        if(LLAvatarNameCache::get(agent_id, &av_name))
+        {
+            args["NAME"] = av_name.getCompleteName();
+        }
+
+        msgType = "RemoveFromFriends";
+    }
+    else
+    {
+        msgType = "RemoveMultipleFromFriends";
+    }
+
+    LLSD payload;
+    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
+    {
+        payload["ids"].append(*it);
+    }
+
+    LLNotificationsUtil::add(msgType,
+        args,
+        payload,
+        &handleRemove);
 }
 
 // static
 void LLAvatarActions::offerTeleport(const LLUUID& invitee)
 {
-	if (invitee.isNull())
-		return;
+    if (invitee.isNull())
+        return;
 
-	std::vector<LLUUID> ids;
-	ids.push_back(invitee);
-	offerTeleport(ids);
+    std::vector<LLUUID> ids;
+    ids.push_back(invitee);
+    offerTeleport(ids);
 }
 
 // static
-void LLAvatarActions::offerTeleport(const uuid_vec_t& ids) 
+void LLAvatarActions::offerTeleport(const uuid_vec_t& ids)
 {
-	if (ids.size() == 0)
-		return;
+    if (ids.size() == 0)
+        return;
 
-	handle_lure(ids);
+    handle_lure(ids);
 }
 
 static void on_avatar_name_cache_start_im(const LLUUID& agent_id,
-										  const LLAvatarName& av_name)
+                                          const LLAvatarName& av_name)
 {
-	std::string name = av_name.getDisplayName();
-	LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id);
-	if (session_id != LLUUID::null)
-	{
-		LLFloaterIMContainer::getInstance()->showConversation(session_id);
-	}
-	make_ui_sound("UISndStartIM");
+    std::string name = av_name.getDisplayName();
+    LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id);
+    if (session_id != LLUUID::null)
+    {
+        LLFloaterIMContainer::getInstance()->showConversation(session_id);
+    }
+    make_ui_sound("UISndStartIM");
 }
 
 // static
 void LLAvatarActions::startIM(const LLUUID& id)
 {
-	if (id.isNull() || gAgent.getID() == id)
-		return;
+    if (id.isNull() || gAgent.getID() == id)
+        return;
 
-	LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_im, _1, _2));
+    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_im, _1, _2));
 }
 
 // static
 void LLAvatarActions::endIM(const LLUUID& id)
 {
-	if (id.isNull())
-		return;
-	
-	LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
-	if (session_id != LLUUID::null)
-	{
-		gIMMgr->leaveSession(session_id);
-	}
+    if (id.isNull())
+        return;
+
+    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
+    if (session_id != LLUUID::null)
+    {
+        gIMMgr->leaveSession(session_id);
+    }
 }
 
 static void on_avatar_name_cache_start_call(const LLUUID& agent_id,
-											const LLAvatarName& av_name)
+                                            const LLAvatarName& av_name)
 {
-	std::string name = av_name.getDisplayName();
-	LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id, LLSD());
-	if (session_id != LLUUID::null)
-	{
-		gIMMgr->startCall(session_id);
-	}
-	make_ui_sound("UISndStartIM");
+    std::string name = av_name.getDisplayName();
+    LLUUID session_id = gIMMgr->addSession(name, IM_NOTHING_SPECIAL, agent_id, LLSD());
+    if (session_id != LLUUID::null)
+    {
+        gIMMgr->startCall(session_id);
+    }
+    make_ui_sound("UISndStartIM");
 }
 
 // static
 void LLAvatarActions::startCall(const LLUUID& id)
 {
-	if (id.isNull())
-	{
-		return;
-	}
-	LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_call, _1, _2));
+    if (id.isNull())
+    {
+        return;
+    }
+    LLAvatarNameCache::get(id, boost::bind(&on_avatar_name_cache_start_call, _1, _2));
 }
 
 // static
 void LLAvatarActions::startAdhocCall(const uuid_vec_t& ids, const LLUUID& floater_id)
 {
-	if (ids.size() == 0)
-	{
-		return;
-	}
+    if (ids.size() == 0)
+    {
+        return;
+    }
 
-	// convert vector into std::vector for addSession
-	std::vector<LLUUID> id_array;
-	id_array.reserve(ids.size());
-	for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
-	{
-		id_array.push_back(*it);
-	}
+    // convert vector into std::vector for addSession
+    std::vector<LLUUID> id_array;
+    id_array.reserve(ids.size());
+    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
+    {
+        id_array.push_back(*it);
+    }
 
-	// create the new ad hoc voice session
-	const std::string title = LLTrans::getString("conference-title");
-	LLUUID session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], id_array, LLSD(), floater_id);
-	if (session_id == LLUUID::null)
-	{
-		return;
-	}
+    // create the new ad hoc voice session
+    const std::string title = LLTrans::getString("conference-title");
+    LLUUID session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], id_array, LLSD(), floater_id);
+    if (session_id == LLUUID::null)
+    {
+        return;
+    }
 
-	gIMMgr->autoStartCallOnStartup(session_id);
+    gIMMgr->autoStartCallOnStartup(session_id);
 
-	make_ui_sound("UISndStartIM");
+    make_ui_sound("UISndStartIM");
 }
 
 /* AD *TODO: Is this function needed any more?
-	I fixed it a bit(added check for canCall), but it appears that it is not used
-	anywhere. Maybe it should be removed?
+    I fixed it a bit(added check for canCall), but it appears that it is not used
+    anywhere. Maybe it should be removed?
 // static
 bool LLAvatarActions::isCalling(const LLUUID &id)
 {
-	if (id.isNull() || !canCall())
-	{
-		return false;
-	}
+    if (id.isNull() || !canCall())
+    {
+        return false;
+    }
 
-	LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
-	return (LLIMModel::getInstance()->findIMSession(session_id) != NULL);
+    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, id);
+    return (LLIMModel::getInstance()->findIMSession(session_id) != NULL);
 }*/
 
 //static
 bool LLAvatarActions::canCall()
 {
-	return LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
+    return LLVoiceClient::getInstance()->voiceEnabled() && LLVoiceClient::getInstance()->isVoiceWorking();
 }
 
 // static
 void LLAvatarActions::startConference(const uuid_vec_t& ids, const LLUUID& floater_id)
 {
-	// *HACK: Copy into dynamic array
-	std::vector<LLUUID> id_array;
+    // *HACK: Copy into dynamic array
+    std::vector<LLUUID> id_array;
 
-	id_array.reserve(ids.size());
-	for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
-	{
-		id_array.push_back(*it);
-	}
-	const std::string title = LLTrans::getString("conference-title");
+    id_array.reserve(ids.size());
+    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
+    {
+        id_array.push_back(*it);
+    }
+    const std::string title = LLTrans::getString("conference-title");
     LLUUID  session_id = gIMMgr->addSession(title, IM_SESSION_CONFERENCE_START, ids[0], id_array, LLSD(), floater_id);
 
-	if (session_id == LLUUID::null)
-	{
-		return;
-	}
-	
-	LLFloaterIMContainer::getInstance()->showConversation(session_id);
-	
-	make_ui_sound("UISndStartIM");
+    if (session_id == LLUUID::null)
+    {
+        return;
+    }
+
+    LLFloaterIMContainer::getInstance()->showConversation(session_id);
+
+    make_ui_sound("UISndStartIM");
 }
 
 // static
 void LLAvatarActions::showProfile(const LLUUID& avatar_id)
 {
-	if (avatar_id.notNull())
-	{
-		LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id));
-	}
+    if (avatar_id.notNull())
+    {
+        LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id));
+    }
 }
 
 // static
 void LLAvatarActions::showPicks(const LLUUID& avatar_id)
 {
-	if (avatar_id.notNull())
-	{
+    if (avatar_id.notNull())
+    {
         LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
         if (profilefloater)
         {
             profilefloater->showPick();
         }
-	}
+    }
 }
 
 // static
 void LLAvatarActions::showPick(const LLUUID& avatar_id, const LLUUID& pick_id)
 {
-	if (avatar_id.notNull())
-	{
+    if (avatar_id.notNull())
+    {
         LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
         if (profilefloater)
         {
             profilefloater->showPick(pick_id);
         }
-	}
+    }
 }
 
 // static
@@ -413,27 +413,27 @@ bool LLAvatarActions::isPickTabSelected(const LLUUID& avatar_id)
 // static
 void LLAvatarActions::showClassifieds(const LLUUID& avatar_id)
 {
-	if (avatar_id.notNull())
-	{
+    if (avatar_id.notNull())
+    {
         LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
         if (profilefloater)
         {
             profilefloater->showClassified();
         }
-	}
+    }
 }
 
 // static
 void LLAvatarActions::showClassified(const LLUUID& avatar_id, const LLUUID& classified_id, bool edit)
 {
-	if (avatar_id.notNull())
-	{
+    if (avatar_id.notNull())
+    {
         LLFloaterProfile* profilefloater = dynamic_cast<LLFloaterProfile*>(LLFloaterReg::showInstance("profile", LLSD().with("id", avatar_id)));
         if (profilefloater)
         {
             profilefloater->showClassified(classified_id, edit);
         }
-	}
+    }
 }
 
 // static
@@ -446,13 +446,13 @@ void LLAvatarActions::createClassified()
     }
 }
 
-//static 
+//static
 bool LLAvatarActions::profileVisible(const LLUUID& avatar_id)
 {
-	LLSD sd;
-	sd["id"] = avatar_id;
-	LLFloater* floater = getProfileFloater(avatar_id);
-	return floater && floater->isShown();
+    LLSD sd;
+    sd["id"] = avatar_id;
+    LLFloater* floater = getProfileFloater(avatar_id);
+    return floater && floater->isShown();
 }
 
 //static
@@ -462,273 +462,273 @@ LLFloater* LLAvatarActions::getProfileFloater(const LLUUID& avatar_id)
     return floater;
 }
 
-//static 
+//static
 void LLAvatarActions::hideProfile(const LLUUID& avatar_id)
 {
-	LLSD sd;
-	sd["id"] = avatar_id;
-	LLFloater* floater = getProfileFloater(avatar_id);
-	if (floater)
-	{
-		floater->closeFloater();
-	}
+    LLSD sd;
+    sd["id"] = avatar_id;
+    LLFloater* floater = getProfileFloater(avatar_id);
+    if (floater)
+    {
+        floater->closeFloater();
+    }
 }
 
 // static
 void LLAvatarActions::showOnMap(const LLUUID& id)
 {
-	LLAvatarName av_name;
-	if (!LLAvatarNameCache::get(id, &av_name))
-	{
-		LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::showOnMap, id));
-		return;
-	}
+    LLAvatarName av_name;
+    if (!LLAvatarNameCache::get(id, &av_name))
+    {
+        LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::showOnMap, id));
+        return;
+    }
 
-	gFloaterWorldMap->trackAvatar(id, av_name.getDisplayName());
-	LLFloaterReg::showInstance("world_map", "center");
+    gFloaterWorldMap->trackAvatar(id, av_name.getDisplayName());
+    LLFloaterReg::showInstance("world_map", "center");
 }
 
 // static
 void LLAvatarActions::pay(const LLUUID& id)
 {
-	LLNotification::Params params("DoNotDisturbModePay");
-	params.functor.function(boost::bind(&LLAvatarActions::handlePay, _1, _2, id));
+    LLNotification::Params params("DoNotDisturbModePay");
+    params.functor.function(boost::bind(&LLAvatarActions::handlePay, _1, _2, id));
 
-	if (gAgent.isDoNotDisturb())
-	{
-		// warn users of being in do not disturb mode during a transaction
-		LLNotifications::instance().add(params);
-	}
-	else
-	{
-		LLNotifications::instance().forceResponse(params, 1);
-	}
+    if (gAgent.isDoNotDisturb())
+    {
+        // warn users of being in do not disturb mode during a transaction
+        LLNotifications::instance().add(params);
+    }
+    else
+    {
+        LLNotifications::instance().forceResponse(params, 1);
+    }
 }
 
 void LLAvatarActions::teleport_request_callback(const LLSD& notification, const LLSD& response)
 {
-	S32 option;
-	if (response.isInteger()) 
-	{
-		option = response.asInteger();
-	}
-	else
-	{
-		option = LLNotificationsUtil::getSelectedOption(notification, response);
-	}
-
-	if (0 == option)
-	{
-		LLMessageSystem* msg = gMessageSystem;
-
-		msg->newMessageFast(_PREHASH_ImprovedInstantMessage);
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-		msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-
-		msg->nextBlockFast(_PREHASH_MessageBlock);
-		msg->addBOOLFast(_PREHASH_FromGroup, FALSE);
-		msg->addUUIDFast(_PREHASH_ToAgentID, notification["substitutions"]["uuid"] );
-		msg->addU8Fast(_PREHASH_Offline, IM_ONLINE);
-		msg->addU8Fast(_PREHASH_Dialog, IM_TELEPORT_REQUEST);
-		msg->addUUIDFast(_PREHASH_ID, LLUUID::null);
-		msg->addU32Fast(_PREHASH_Timestamp, NO_TIMESTAMP); // no timestamp necessary
-
-		std::string name;
-		LLAgentUI::buildFullname(name);
-
-		msg->addStringFast(_PREHASH_FromAgentName, name);
-		msg->addStringFast(_PREHASH_Message, response["message"]);
-		msg->addU32Fast(_PREHASH_ParentEstateID, 0);
-		msg->addUUIDFast(_PREHASH_RegionID, LLUUID::null);
-		msg->addVector3Fast(_PREHASH_Position, gAgent.getPositionAgent());
-
-		gMessageSystem->addBinaryDataFast(
-				_PREHASH_BinaryBucket,
-				EMPTY_BINARY_BUCKET,
-				EMPTY_BINARY_BUCKET_SIZE);
-
-		gAgent.sendReliableMessage();
-	}
+    S32 option;
+    if (response.isInteger())
+    {
+        option = response.asInteger();
+    }
+    else
+    {
+        option = LLNotificationsUtil::getSelectedOption(notification, response);
+    }
+
+    if (0 == option)
+    {
+        LLMessageSystem* msg = gMessageSystem;
+
+        msg->newMessageFast(_PREHASH_ImprovedInstantMessage);
+        msg->nextBlockFast(_PREHASH_AgentData);
+        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+
+        msg->nextBlockFast(_PREHASH_MessageBlock);
+        msg->addBOOLFast(_PREHASH_FromGroup, FALSE);
+        msg->addUUIDFast(_PREHASH_ToAgentID, notification["substitutions"]["uuid"] );
+        msg->addU8Fast(_PREHASH_Offline, IM_ONLINE);
+        msg->addU8Fast(_PREHASH_Dialog, IM_TELEPORT_REQUEST);
+        msg->addUUIDFast(_PREHASH_ID, LLUUID::null);
+        msg->addU32Fast(_PREHASH_Timestamp, NO_TIMESTAMP); // no timestamp necessary
+
+        std::string name;
+        LLAgentUI::buildFullname(name);
+
+        msg->addStringFast(_PREHASH_FromAgentName, name);
+        msg->addStringFast(_PREHASH_Message, response["message"]);
+        msg->addU32Fast(_PREHASH_ParentEstateID, 0);
+        msg->addUUIDFast(_PREHASH_RegionID, LLUUID::null);
+        msg->addVector3Fast(_PREHASH_Position, gAgent.getPositionAgent());
+
+        gMessageSystem->addBinaryDataFast(
+                _PREHASH_BinaryBucket,
+                EMPTY_BINARY_BUCKET,
+                EMPTY_BINARY_BUCKET_SIZE);
+
+        gAgent.sendReliableMessage();
+    }
 }
 
 // static
 void LLAvatarActions::teleportRequest(const LLUUID& id)
 {
-	LLSD notification;
-	notification["uuid"] = id;
-	LLAvatarName av_name;
-	if (!LLAvatarNameCache::get(id, &av_name))
-	{
-		// unlikely ... they just picked this name from somewhere...
-		LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::teleportRequest, id));
-		return; // reinvoke this when the name resolves
-	}
-	notification["NAME"] = av_name.getCompleteName();
+    LLSD notification;
+    notification["uuid"] = id;
+    LLAvatarName av_name;
+    if (!LLAvatarNameCache::get(id, &av_name))
+    {
+        // unlikely ... they just picked this name from somewhere...
+        LLAvatarNameCache::get(id, boost::bind(&LLAvatarActions::teleportRequest, id));
+        return; // reinvoke this when the name resolves
+    }
+    notification["NAME"] = av_name.getCompleteName();
 
-	LLSD payload;
+    LLSD payload;
 
-	LLNotificationsUtil::add("TeleportRequestPrompt", notification, payload, teleport_request_callback);
+    LLNotificationsUtil::add("TeleportRequestPrompt", notification, payload, teleport_request_callback);
 }
 
 // static
 void LLAvatarActions::kick(const LLUUID& id)
 {
-	LLSD payload;
-	payload["avatar_id"] = id;
-	LLNotifications::instance().add("KickUser", LLSD(), payload, handleKick);
+    LLSD payload;
+    payload["avatar_id"] = id;
+    LLNotifications::instance().add("KickUser", LLSD(), payload, handleKick);
 }
 
 // static
 void LLAvatarActions::freezeAvatar(const LLUUID& id)
 {
-	LLAvatarName av_name;
-	LLSD payload;
-	payload["avatar_id"] = id;
+    LLAvatarName av_name;
+    LLSD payload;
+    payload["avatar_id"] = id;
 
-	if (LLAvatarNameCache::get(id, &av_name))
-	{
-		LLSD args;
-		args["AVATAR_NAME"] = av_name.getUserName();
-		LLNotificationsUtil::add("FreezeAvatarFullname", args, payload, handleFreezeAvatar);
-	}
-	else
-	{
-		LLNotificationsUtil::add("FreezeAvatar", LLSD(), payload, handleFreezeAvatar);
-	}
+    if (LLAvatarNameCache::get(id, &av_name))
+    {
+        LLSD args;
+        args["AVATAR_NAME"] = av_name.getUserName();
+        LLNotificationsUtil::add("FreezeAvatarFullname", args, payload, handleFreezeAvatar);
+    }
+    else
+    {
+        LLNotificationsUtil::add("FreezeAvatar", LLSD(), payload, handleFreezeAvatar);
+    }
 }
 
 // static
 void LLAvatarActions::ejectAvatar(const LLUUID& id, bool ban_enabled)
 {
-	LLAvatarName av_name;
-	LLSD payload;
-	payload["avatar_id"] = id;
-	payload["ban_enabled"] = ban_enabled;
-	LLSD args;
-	bool has_name = LLAvatarNameCache::get(id, &av_name);
-	if (has_name)
-	{
-		args["AVATAR_NAME"] = av_name.getUserName();
-	}
-
-	if (ban_enabled)
-	{
-			LLNotificationsUtil::add("EjectAvatarFullname", args, payload, handleEjectAvatar);
-	}
-	else
-	{
-		if (has_name)
-		{
-			LLNotificationsUtil::add("EjectAvatarFullnameNoBan", args, payload, handleEjectAvatar);
-		}
-		else
-		{
-			LLNotificationsUtil::add("EjectAvatarNoBan", LLSD(), payload, handleEjectAvatar);
-		}
-	}
+    LLAvatarName av_name;
+    LLSD payload;
+    payload["avatar_id"] = id;
+    payload["ban_enabled"] = ban_enabled;
+    LLSD args;
+    bool has_name = LLAvatarNameCache::get(id, &av_name);
+    if (has_name)
+    {
+        args["AVATAR_NAME"] = av_name.getUserName();
+    }
+
+    if (ban_enabled)
+    {
+            LLNotificationsUtil::add("EjectAvatarFullname", args, payload, handleEjectAvatar);
+    }
+    else
+    {
+        if (has_name)
+        {
+            LLNotificationsUtil::add("EjectAvatarFullnameNoBan", args, payload, handleEjectAvatar);
+        }
+        else
+        {
+            LLNotificationsUtil::add("EjectAvatarNoBan", LLSD(), payload, handleEjectAvatar);
+        }
+    }
 }
 
 // static
 void LLAvatarActions::freeze(const LLUUID& id)
 {
-	LLSD payload;
-	payload["avatar_id"] = id;
-	LLNotifications::instance().add("FreezeUser", LLSD(), payload, handleFreeze);
+    LLSD payload;
+    payload["avatar_id"] = id;
+    LLNotifications::instance().add("FreezeUser", LLSD(), payload, handleFreeze);
 }
 // static
 void LLAvatarActions::unfreeze(const LLUUID& id)
 {
-	LLSD payload;
-	payload["avatar_id"] = id;
-	LLNotifications::instance().add("UnFreezeUser", LLSD(), payload, handleUnfreeze);
+    LLSD payload;
+    payload["avatar_id"] = id;
+    LLNotifications::instance().add("UnFreezeUser", LLSD(), payload, handleUnfreeze);
 }
 
-//static 
+//static
 void LLAvatarActions::csr(const LLUUID& id, std::string name)
 {
-	if (name.empty()) return;
-	
-	std::string url = "http://csr.lindenlab.com/agent/";
-	
-	// slow and stupid, but it's late
-	S32 len = name.length();
-	for (S32 i = 0; i < len; i++)
-	{
-		if (name[i] == ' ')
-		{
-			url += "%20";
-		}
-		else
-		{
-			url += name[i];
-		}
-	}
-	
-	LLWeb::loadURL(url);
-}
-
-//static 
+    if (name.empty()) return;
+
+    std::string url = "http://csr.lindenlab.com/agent/";
+
+    // slow and stupid, but it's late
+    S32 len = name.length();
+    for (S32 i = 0; i < len; i++)
+    {
+        if (name[i] == ' ')
+        {
+            url += "%20";
+        }
+        else
+        {
+            url += name[i];
+        }
+    }
+
+    LLWeb::loadURL(url);
+}
+
+//static
 void LLAvatarActions::share(const LLUUID& id)
 {
-	LLSD key;
-	LLFloaterSidePanelContainer::showPanel("inventory", key);
-	LLFloaterReg::showInstance("im_container");
+    LLSD key;
+    LLFloaterSidePanelContainer::showPanel("inventory", key);
+    LLFloaterReg::showInstance("im_container");
 
-	LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL,id);
+    LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL,id);
 
-	if (!gIMMgr->hasSession(session_id))
-	{
-		startIM(id);
-	}
+    if (!gIMMgr->hasSession(session_id))
+    {
+        startIM(id);
+    }
 
-	if (gIMMgr->hasSession(session_id))
-	{
-		// we should always get here, but check to verify anyways
-		LLIMModel::getInstance()->addMessage(session_id, SYSTEM_FROM, LLUUID::null, LLTrans::getString("share_alert"), false);
+    if (gIMMgr->hasSession(session_id))
+    {
+        // we should always get here, but check to verify anyways
+        LLIMModel::getInstance()->addMessage(session_id, SYSTEM_FROM, LLUUID::null, LLTrans::getString("share_alert"), false);
 
-		LLFloaterIMSessionTab* session_floater = LLFloaterIMSessionTab::findConversation(session_id);
-		if (session_floater && session_floater->isMinimized())
-		{
-			session_floater->setMinimized(false);
-		}
-		LLFloaterIMContainer *im_container = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
-		im_container->selectConversationPair(session_id, true);
-	}
+        LLFloaterIMSessionTab* session_floater = LLFloaterIMSessionTab::findConversation(session_id);
+        if (session_floater && session_floater->isMinimized())
+        {
+            session_floater->setMinimized(false);
+        }
+        LLFloaterIMContainer *im_container = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
+        im_container->selectConversationPair(session_id, true);
+    }
 }
 
 namespace action_give_inventory
 {
-	/**
-	 * Returns a pointer to 'Add More' inventory panel of Edit Outfit SP.
-	 */
-	static LLInventoryPanel* get_outfit_editor_inventory_panel()
-	{
-		LLPanelOutfitEdit* panel_outfit_edit = dynamic_cast<LLPanelOutfitEdit*>(LLFloaterSidePanelContainer::getPanel("appearance", "panel_outfit_edit"));
-		if (NULL == panel_outfit_edit) return NULL;
-
-		LLInventoryPanel* inventory_panel = panel_outfit_edit->findChild<LLInventoryPanel>("folder_view");
-		return inventory_panel;
-	}
-
-	/**
-	 * @return active inventory panel, or NULL if there's no such panel
-	 */
-	static LLInventoryPanel* get_active_inventory_panel()
-	{
-		LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
-		LLFloater* floater_appearance = LLFloaterReg::findInstance("appearance");
-		if (!active_panel || (floater_appearance && floater_appearance->hasFocus()))
-		{
-			active_panel = get_outfit_editor_inventory_panel();
-		}
-
-		return active_panel;
-	}
-
-	/**
-	 * Checks My Inventory visibility.
-	 */
+    /**
+     * Returns a pointer to 'Add More' inventory panel of Edit Outfit SP.
+     */
+    static LLInventoryPanel* get_outfit_editor_inventory_panel()
+    {
+        LLPanelOutfitEdit* panel_outfit_edit = dynamic_cast<LLPanelOutfitEdit*>(LLFloaterSidePanelContainer::getPanel("appearance", "panel_outfit_edit"));
+        if (NULL == panel_outfit_edit) return NULL;
+
+        LLInventoryPanel* inventory_panel = panel_outfit_edit->findChild<LLInventoryPanel>("folder_view");
+        return inventory_panel;
+    }
+
+    /**
+     * @return active inventory panel, or NULL if there's no such panel
+     */
+    static LLInventoryPanel* get_active_inventory_panel()
+    {
+        LLInventoryPanel* active_panel = LLInventoryPanel::getActiveInventoryPanel(FALSE);
+        LLFloater* floater_appearance = LLFloaterReg::findInstance("appearance");
+        if (!active_panel || (floater_appearance && floater_appearance->hasFocus()))
+        {
+            active_panel = get_outfit_editor_inventory_panel();
+        }
+
+        return active_panel;
+    }
+
+    /**
+     * Checks My Inventory visibility.
+     */
     static bool is_give_inventory_acceptable_ids(const std::set<LLUUID> inventory_selected_uuids)
     {
         if (inventory_selected_uuids.empty()) return false; // nothing selected
@@ -761,11 +761,11 @@ namespace action_give_inventory
     return acceptable;
     }
 
-	static bool is_give_inventory_acceptable(LLInventoryPanel* panel = NULL)
-	{
-		// check selection in the panel
+    static bool is_give_inventory_acceptable(LLInventoryPanel* panel = NULL)
+    {
+        // check selection in the panel
         std::set<LLUUID> inventory_selected_uuids = LLAvatarActions::getInventorySelectedUUIDs(panel);
-		if (inventory_selected_uuids.empty())
+        if (inventory_selected_uuids.empty())
         {
             if(panel && panel->getRootFolder() && panel->getRootFolder()->isSingleFolderMode())
             {
@@ -778,133 +778,133 @@ namespace action_give_inventory
         }
 
         return is_give_inventory_acceptable_ids(inventory_selected_uuids);
-	}
-
-	static void build_items_string(const std::set<LLUUID>& inventory_selected_uuids , std::string& items_string)
-	{
-		llassert(inventory_selected_uuids.size() > 0);
-
-		const std::string& separator = LLTrans::getString("words_separator");
-		for (std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin(); ; )
-		{
-			LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
-			if (NULL != inv_cat)
-			{
-				items_string = inv_cat->getName();
-				break;
-			}
-			LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
-			if (NULL != inv_item)
-			{
-				items_string.append(inv_item->getName());
-			}
-			if(++it == inventory_selected_uuids.end())
-			{
-				break;
-			}
-			items_string.append(separator);
-		}
-	}
-
-	struct LLShareInfo : public LLSingleton<LLShareInfo>
-	{
-		LLSINGLETON_EMPTY_CTOR(LLShareInfo);
-	public:
-		std::vector<LLAvatarName> mAvatarNames;
-		uuid_vec_t mAvatarUuids;
-	};
-
-	static void give_inventory_cb(const LLSD& notification, const LLSD& response, std::set<LLUUID> inventory_selected_uuids)
-	{
-		S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-		// if Cancel pressed
-		if (option == 1)
-		{
-			return;
-		}
-
-		if (inventory_selected_uuids.empty())
-		{
-			return;
-		}
-
-		S32 count = LLShareInfo::instance().mAvatarNames.size();
-		bool shared = count && !inventory_selected_uuids.empty();
-
-		// iterate through avatars
-		for(S32 i = 0; i < count; ++i)
-		{
-			const LLUUID& avatar_uuid = LLShareInfo::instance().mAvatarUuids[i];
-
-			// We souldn't open IM session, just calculate session ID for logging purpose. See EXT-6710
-			const LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, avatar_uuid);
-
-			std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin();
-			const std::set<LLUUID>::const_iterator it_end = inventory_selected_uuids.end();
-
-			const std::string& separator = LLTrans::getString("words_separator");
-			std::string noncopy_item_names;
-			LLSD noncopy_items = LLSD::emptyArray();
-			// iterate through selected inventory objects
-			for (; it != it_end; ++it)
-			{
-				LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
-				if (inv_cat)
-				{
-					if (!LLGiveInventory::doGiveInventoryCategory(avatar_uuid, inv_cat, session_id, "ItemsShared"))
-					{
-						shared = false;
-					}
-					break;
-				}
-				LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
-				if (!inv_item->getPermissions().allowCopyBy(gAgentID))
-				{
-					if (!noncopy_item_names.empty())
-					{
-						noncopy_item_names.append(separator);
-					}
-					noncopy_item_names.append(inv_item->getName());
-					noncopy_items.append(*it);
-				}
-				else
-				{
-					if (!LLGiveInventory::doGiveInventoryItem(avatar_uuid, inv_item, session_id))
-					{
-						shared = false;
-					}
-				}
-			}
-			if (noncopy_items.beginArray() != noncopy_items.endArray())
-			{
-				LLSD substitutions;
-				substitutions["ITEMS"] = noncopy_item_names;
-				LLSD payload;
-				payload["agent_id"] = avatar_uuid;
-				payload["items"] = noncopy_items;
-				payload["success_notification"] = "ItemsShared";
-				LLNotificationsUtil::add("CannotCopyWarning", substitutions, payload,
-					&LLGiveInventory::handleCopyProtectedItem);
-				shared = false;
-				break;
-			}
-		}
-		if (shared)
-		{
-			LLFloaterReg::hideInstance("avatar_picker");
-			LLNotificationsUtil::add("ItemsShared");
-		}
-	}
-
-	/**
-	 * Performs "give inventory" operations for provided avatars.
-	 *
-	 * Sends one requests to give all selected inventory items for each passed avatar.
-	 * Avatars are represent by two vectors: names and UUIDs which must be sychronized with each other.
-	 *
-	 * @param avatar_names - avatar names request to be sent.
-	 * @param avatar_uuids - avatar names request to be sent.
-	 */
+    }
+
+    static void build_items_string(const std::set<LLUUID>& inventory_selected_uuids , std::string& items_string)
+    {
+        llassert(inventory_selected_uuids.size() > 0);
+
+        const std::string& separator = LLTrans::getString("words_separator");
+        for (std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin(); ; )
+        {
+            LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
+            if (NULL != inv_cat)
+            {
+                items_string = inv_cat->getName();
+                break;
+            }
+            LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
+            if (NULL != inv_item)
+            {
+                items_string.append(inv_item->getName());
+            }
+            if(++it == inventory_selected_uuids.end())
+            {
+                break;
+            }
+            items_string.append(separator);
+        }
+    }
+
+    struct LLShareInfo : public LLSingleton<LLShareInfo>
+    {
+        LLSINGLETON_EMPTY_CTOR(LLShareInfo);
+    public:
+        std::vector<LLAvatarName> mAvatarNames;
+        uuid_vec_t mAvatarUuids;
+    };
+
+    static void give_inventory_cb(const LLSD& notification, const LLSD& response, std::set<LLUUID> inventory_selected_uuids)
+    {
+        S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+        // if Cancel pressed
+        if (option == 1)
+        {
+            return;
+        }
+
+        if (inventory_selected_uuids.empty())
+        {
+            return;
+        }
+
+        S32 count = LLShareInfo::instance().mAvatarNames.size();
+        bool shared = count && !inventory_selected_uuids.empty();
+
+        // iterate through avatars
+        for(S32 i = 0; i < count; ++i)
+        {
+            const LLUUID& avatar_uuid = LLShareInfo::instance().mAvatarUuids[i];
+
+            // We souldn't open IM session, just calculate session ID for logging purpose. See EXT-6710
+            const LLUUID session_id = gIMMgr->computeSessionID(IM_NOTHING_SPECIAL, avatar_uuid);
+
+            std::set<LLUUID>::const_iterator it = inventory_selected_uuids.begin();
+            const std::set<LLUUID>::const_iterator it_end = inventory_selected_uuids.end();
+
+            const std::string& separator = LLTrans::getString("words_separator");
+            std::string noncopy_item_names;
+            LLSD noncopy_items = LLSD::emptyArray();
+            // iterate through selected inventory objects
+            for (; it != it_end; ++it)
+            {
+                LLViewerInventoryCategory* inv_cat = gInventory.getCategory(*it);
+                if (inv_cat)
+                {
+                    if (!LLGiveInventory::doGiveInventoryCategory(avatar_uuid, inv_cat, session_id, "ItemsShared"))
+                    {
+                        shared = false;
+                    }
+                    break;
+                }
+                LLViewerInventoryItem* inv_item = gInventory.getItem(*it);
+                if (!inv_item->getPermissions().allowCopyBy(gAgentID))
+                {
+                    if (!noncopy_item_names.empty())
+                    {
+                        noncopy_item_names.append(separator);
+                    }
+                    noncopy_item_names.append(inv_item->getName());
+                    noncopy_items.append(*it);
+                }
+                else
+                {
+                    if (!LLGiveInventory::doGiveInventoryItem(avatar_uuid, inv_item, session_id))
+                    {
+                        shared = false;
+                    }
+                }
+            }
+            if (noncopy_items.beginArray() != noncopy_items.endArray())
+            {
+                LLSD substitutions;
+                substitutions["ITEMS"] = noncopy_item_names;
+                LLSD payload;
+                payload["agent_id"] = avatar_uuid;
+                payload["items"] = noncopy_items;
+                payload["success_notification"] = "ItemsShared";
+                LLNotificationsUtil::add("CannotCopyWarning", substitutions, payload,
+                    &LLGiveInventory::handleCopyProtectedItem);
+                shared = false;
+                break;
+            }
+        }
+        if (shared)
+        {
+            LLFloaterReg::hideInstance("avatar_picker");
+            LLNotificationsUtil::add("ItemsShared");
+        }
+    }
+
+    /**
+     * Performs "give inventory" operations for provided avatars.
+     *
+     * Sends one requests to give all selected inventory items for each passed avatar.
+     * Avatars are represent by two vectors: names and UUIDs which must be sychronized with each other.
+     *
+     * @param avatar_names - avatar names request to be sent.
+     * @param avatar_uuids - avatar names request to be sent.
+     */
 
     static void give_inventory_ids(const uuid_vec_t& avatar_uuids, const std::vector<LLAvatarName> avatar_names, const uuid_set_t inventory_selected_uuids)
     {
@@ -969,106 +969,106 @@ namespace action_give_inventory
 // static
 void LLAvatarActions::buildResidentsString(std::vector<LLAvatarName> avatar_names, std::string& residents_string, bool complete_name)
 {
-	llassert(avatar_names.size() > 0);
-	
-	std::sort(avatar_names.begin(), avatar_names.end());
-	const std::string& separator = LLTrans::getString("words_separator");
-	for (std::vector<LLAvatarName>::const_iterator it = avatar_names.begin(); ; )
-	{
-		if(complete_name)
-		{
-			residents_string.append((*it).getCompleteName());
-		}
-		else
-		{
-			residents_string.append((*it).getDisplayName());
-		}
-
-		if	(++it == avatar_names.end())
-		{
-			break;
-		}
-		residents_string.append(separator);
-	}
+    llassert(avatar_names.size() > 0);
+
+    std::sort(avatar_names.begin(), avatar_names.end());
+    const std::string& separator = LLTrans::getString("words_separator");
+    for (std::vector<LLAvatarName>::const_iterator it = avatar_names.begin(); ; )
+    {
+        if(complete_name)
+        {
+            residents_string.append((*it).getCompleteName());
+        }
+        else
+        {
+            residents_string.append((*it).getDisplayName());
+        }
+
+        if  (++it == avatar_names.end())
+        {
+            break;
+        }
+        residents_string.append(separator);
+    }
 }
 
 // static
 void LLAvatarActions::buildResidentsString(const uuid_vec_t& avatar_uuids, std::string& residents_string)
 {
-	std::vector<LLAvatarName> avatar_names;
-	uuid_vec_t::const_iterator it = avatar_uuids.begin();
-	for (; it != avatar_uuids.end(); ++it)
-	{
-		LLAvatarName av_name;
-		if (LLAvatarNameCache::get(*it, &av_name))
-		{
-			avatar_names.push_back(av_name);
-		}
-	}
-	
-	// We should check whether the vector is not empty to pass the assertion
-	// that avatar_names.size() > 0 in LLAvatarActions::buildResidentsString.
-	if (!avatar_names.empty())
-	{
-		LLAvatarActions::buildResidentsString(avatar_names, residents_string);
-	}
+    std::vector<LLAvatarName> avatar_names;
+    uuid_vec_t::const_iterator it = avatar_uuids.begin();
+    for (; it != avatar_uuids.end(); ++it)
+    {
+        LLAvatarName av_name;
+        if (LLAvatarNameCache::get(*it, &av_name))
+        {
+            avatar_names.push_back(av_name);
+        }
+    }
+
+    // We should check whether the vector is not empty to pass the assertion
+    // that avatar_names.size() > 0 in LLAvatarActions::buildResidentsString.
+    if (!avatar_names.empty())
+    {
+        LLAvatarActions::buildResidentsString(avatar_names, residents_string);
+    }
 }
 
 //static
 std::set<LLUUID> LLAvatarActions::getInventorySelectedUUIDs(LLInventoryPanel* active_panel)
 {
-	std::set<LLFolderViewItem*> inventory_selected;
-
-	if (!active_panel)
-	{
-		active_panel = action_give_inventory::get_active_inventory_panel();
-	}
-	if (active_panel)
-	{
-		inventory_selected= active_panel->getRootFolder()->getSelectionList();
-	}
-
-	if (inventory_selected.empty())
-	{
-		LLSidepanelInventory *sidepanel_inventory = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
-		if (sidepanel_inventory)
-		{
-			inventory_selected= sidepanel_inventory->getInboxSelectionList();
-		}
-	}
-
-	std::set<LLUUID> inventory_selected_uuids;
-	for (std::set<LLFolderViewItem*>::iterator it = inventory_selected.begin(), end_it = inventory_selected.end();
-		it != end_it;
-		++it)
-	{
-		inventory_selected_uuids.insert(static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID());
-	}
-	return inventory_selected_uuids;
+    std::set<LLFolderViewItem*> inventory_selected;
+
+    if (!active_panel)
+    {
+        active_panel = action_give_inventory::get_active_inventory_panel();
+    }
+    if (active_panel)
+    {
+        inventory_selected= active_panel->getRootFolder()->getSelectionList();
+    }
+
+    if (inventory_selected.empty())
+    {
+        LLSidepanelInventory *sidepanel_inventory = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
+        if (sidepanel_inventory)
+        {
+            inventory_selected= sidepanel_inventory->getInboxSelectionList();
+        }
+    }
+
+    std::set<LLUUID> inventory_selected_uuids;
+    for (std::set<LLFolderViewItem*>::iterator it = inventory_selected.begin(), end_it = inventory_selected.end();
+        it != end_it;
+        ++it)
+    {
+        inventory_selected_uuids.insert(static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID());
+    }
+    return inventory_selected_uuids;
 }
 
 //static
 void LLAvatarActions::shareWithAvatars(LLView * panel)
 {
-	using namespace action_give_inventory;
+    using namespace action_give_inventory;
 
-	LLFloater* root_floater = gFloaterView->getParentFloater(panel);
-	LLInventoryPanel* inv_panel = dynamic_cast<LLInventoryPanel*>(panel);
-	LLFloaterAvatarPicker* picker =
-		LLFloaterAvatarPicker::show(boost::bind(give_inventory, _1, _2, inv_panel), TRUE, FALSE, FALSE, root_floater->getName());
-	if (!picker)
-	{
-		return;
-	}
+    LLFloater* root_floater = gFloaterView->getParentFloater(panel);
+    LLInventoryPanel* inv_panel = dynamic_cast<LLInventoryPanel*>(panel);
+    LLFloaterAvatarPicker* picker =
+        LLFloaterAvatarPicker::show(boost::bind(give_inventory, _1, _2, inv_panel), TRUE, FALSE, FALSE, root_floater->getName());
+    if (!picker)
+    {
+        return;
+    }
+
+    picker->setOkBtnEnableCb(boost::bind(is_give_inventory_acceptable, inv_panel));
+    picker->openFriendsTab();
 
-	picker->setOkBtnEnableCb(boost::bind(is_give_inventory_acceptable, inv_panel));
-	picker->openFriendsTab();
-    
     if (root_floater)
     {
         root_floater->addDependentFloater(picker);
     }
-	LLNotificationsUtil::add("ShareNotification");
+    LLNotificationsUtil::add("ShareNotification");
 }
 
 //static
@@ -1085,7 +1085,7 @@ void LLAvatarActions::shareWithAvatars(const uuid_set_t inventory_selected_uuids
 
     picker->setOkBtnEnableCb(boost::bind(is_give_inventory_acceptable_ids, inventory_selected_uuids));
     picker->openFriendsTab();
-    
+
     if (root_floater)
     {
         root_floater->addDependentFloater(picker);
@@ -1096,177 +1096,177 @@ void LLAvatarActions::shareWithAvatars(const uuid_set_t inventory_selected_uuids
 // static
 bool LLAvatarActions::canShareSelectedItems(LLInventoryPanel* inv_panel /* = NULL*/)
 {
-	using namespace action_give_inventory;
+    using namespace action_give_inventory;
 
-	if (!inv_panel)
-	{
-		LLInventoryPanel* active_panel = get_active_inventory_panel();
-		if (!active_panel) return false;
-		inv_panel = active_panel;
-	}
+    if (!inv_panel)
+    {
+        LLInventoryPanel* active_panel = get_active_inventory_panel();
+        if (!active_panel) return false;
+        inv_panel = active_panel;
+    }
 
-	// check selection in the panel
-	LLFolderView* root_folder = inv_panel->getRootFolder();
+    // check selection in the panel
+    LLFolderView* root_folder = inv_panel->getRootFolder();
     if (!root_folder)
     {
         return false;
     }
-	const std::set<LLFolderViewItem*> inventory_selected = root_folder->getSelectionList();
-	if (inventory_selected.empty()) return false; // nothing selected
-
-	const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
-	bool can_share = true;
-	std::set<LLFolderViewItem*>::const_iterator it = inventory_selected.begin();
-	const std::set<LLFolderViewItem*>::const_iterator it_end = inventory_selected.end();
-	for (; it != it_end; ++it)
-	{
-		LLUUID cat_id = static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID();
-		LLViewerInventoryCategory* inv_cat = gInventory.getCategory(cat_id);
-		// any category can be offered if it's not in trash.
-		if (inv_cat)
-		{
-			if ((cat_id == trash_id) || gInventory.isObjectDescendentOf(cat_id, trash_id))
-			{
-				can_share = false;
-				break;
-			}
-			continue;
-		}
-
-		// check if inventory item can be given
-		LLFolderViewItem* item = *it;
-		if (!item) return false;
-		LLInvFVBridge* bridge = dynamic_cast<LLInvFVBridge*>(item->getViewModelItem());
-		if (bridge && bridge->canShare())
-		{
-			continue;
-		}
-
-		// there are neither item nor category in inventory
-		can_share = false;
-		break;
-	}
-
-	return can_share;
+    const std::set<LLFolderViewItem*> inventory_selected = root_folder->getSelectionList();
+    if (inventory_selected.empty()) return false; // nothing selected
+
+    const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
+    bool can_share = true;
+    std::set<LLFolderViewItem*>::const_iterator it = inventory_selected.begin();
+    const std::set<LLFolderViewItem*>::const_iterator it_end = inventory_selected.end();
+    for (; it != it_end; ++it)
+    {
+        LLUUID cat_id = static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID();
+        LLViewerInventoryCategory* inv_cat = gInventory.getCategory(cat_id);
+        // any category can be offered if it's not in trash.
+        if (inv_cat)
+        {
+            if ((cat_id == trash_id) || gInventory.isObjectDescendentOf(cat_id, trash_id))
+            {
+                can_share = false;
+                break;
+            }
+            continue;
+        }
+
+        // check if inventory item can be given
+        LLFolderViewItem* item = *it;
+        if (!item) return false;
+        LLInvFVBridge* bridge = dynamic_cast<LLInvFVBridge*>(item->getViewModelItem());
+        if (bridge && bridge->canShare())
+        {
+            continue;
+        }
+
+        // there are neither item nor category in inventory
+        can_share = false;
+        break;
+    }
+
+    return can_share;
 }
 
 // static
 bool LLAvatarActions::toggleBlock(const LLUUID& id)
 {
-	LLAvatarName av_name;
-	LLAvatarNameCache::get(id, &av_name);
+    LLAvatarName av_name;
+    LLAvatarNameCache::get(id, &av_name);
 
-	LLMute mute(id, av_name.getUserName(), LLMute::AGENT);
+    LLMute mute(id, av_name.getUserName(), LLMute::AGENT);
 
-	if (LLMuteList::getInstance()->isMuted(mute.mID, mute.mName))
-	{
-		LLMuteList::getInstance()->remove(mute);
-		return false;
-	}
-	else
-	{
-		LLMuteList::getInstance()->add(mute);
-		return true;
-	}
+    if (LLMuteList::getInstance()->isMuted(mute.mID, mute.mName))
+    {
+        LLMuteList::getInstance()->remove(mute);
+        return false;
+    }
+    else
+    {
+        LLMuteList::getInstance()->add(mute);
+        return true;
+    }
 }
 
 // static
 void LLAvatarActions::toggleMute(const LLUUID& id, U32 flags)
 {
-	LLAvatarName av_name;
-	LLAvatarNameCache::get(id, &av_name);
+    LLAvatarName av_name;
+    LLAvatarNameCache::get(id, &av_name);
 
-	LLMuteList* mute_list = LLMuteList::getInstance();
-	bool is_muted = mute_list->isMuted(id, flags);
+    LLMuteList* mute_list = LLMuteList::getInstance();
+    bool is_muted = mute_list->isMuted(id, flags);
 
-	LLMute mute(id, av_name.getUserName(), LLMute::AGENT);
-	if (!is_muted)
-	{
-		mute_list->add(mute, flags);
-	}
-	else
-	{
-		mute_list->remove(mute, flags);
-	}
+    LLMute mute(id, av_name.getUserName(), LLMute::AGENT);
+    if (!is_muted)
+    {
+        mute_list->add(mute, flags);
+    }
+    else
+    {
+        mute_list->remove(mute, flags);
+    }
 }
 
 // static
 void LLAvatarActions::toggleMuteVoice(const LLUUID& id)
 {
-	toggleMute(id, LLMute::flagVoiceChat);
+    toggleMute(id, LLMute::flagVoiceChat);
 }
 
 // static
 bool LLAvatarActions::canOfferTeleport(const LLUUID& id)
 {
-	// First use LLAvatarTracker::isBuddy()
-	// If LLAvatarTracker::instance().isBuddyOnline function only is used
-	// then for avatars that are online and not a friend it will return false.
-	// But we should give an ability to offer a teleport for such avatars.
-	if(LLAvatarTracker::instance().isBuddy(id))
-	{
-		return LLAvatarTracker::instance().isBuddyOnline(id);
-	}
+    // First use LLAvatarTracker::isBuddy()
+    // If LLAvatarTracker::instance().isBuddyOnline function only is used
+    // then for avatars that are online and not a friend it will return false.
+    // But we should give an ability to offer a teleport for such avatars.
+    if(LLAvatarTracker::instance().isBuddy(id))
+    {
+        return LLAvatarTracker::instance().isBuddyOnline(id);
+    }
 
-	return true;
+    return true;
 }
 
 // static
 bool LLAvatarActions::canOfferTeleport(const uuid_vec_t& ids)
 {
-	// We can't send more than 250 lures in a single message, so disable this
-	// button when there are too many id's selected.
-	if(ids.size() > 250) return false;
-	
-	bool result = true;
-	for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
-	{
-		if(!canOfferTeleport(*it))
-		{
-			result = false;
-			break;
-		}
-	}
-	return result;
+    // We can't send more than 250 lures in a single message, so disable this
+    // button when there are too many id's selected.
+    if(ids.size() > 250) return false;
+
+    bool result = true;
+    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
+    {
+        if(!canOfferTeleport(*it))
+        {
+            result = false;
+            break;
+        }
+    }
+    return result;
 }
 
 void LLAvatarActions::inviteToGroup(const LLUUID& id)
 {
-	LLFloaterGroupPicker* widget = LLFloaterReg::showTypedInstance<LLFloaterGroupPicker>("group_picker", LLSD(id));
-	if (widget)
-	{
-		widget->center();
-		widget->setPowersMask(GP_MEMBER_INVITE);
-		widget->removeNoneOption();
-		widget->setSelectGroupCallback(boost::bind(callback_invite_to_group, _1, id));
-	}
+    LLFloaterGroupPicker* widget = LLFloaterReg::showTypedInstance<LLFloaterGroupPicker>("group_picker", LLSD(id));
+    if (widget)
+    {
+        widget->center();
+        widget->setPowersMask(GP_MEMBER_INVITE);
+        widget->removeNoneOption();
+        widget->setSelectGroupCallback(boost::bind(callback_invite_to_group, _1, id));
+    }
 }
 
 // static
 void LLAvatarActions::viewChatHistory(const LLUUID& id)
 {
-	const std::vector<LLConversation>& conversations = LLConversationLog::instance().getConversations();
-	std::vector<LLConversation>::const_iterator iter = conversations.begin();
+    const std::vector<LLConversation>& conversations = LLConversationLog::instance().getConversations();
+    std::vector<LLConversation>::const_iterator iter = conversations.begin();
 
-	for (; iter != conversations.end(); ++iter)
-	{
-		if (iter->getParticipantID() == id)
-		{
-			LLFloaterReg::showInstance("preview_conversation", iter->getSessionID(), true);
-			return;
-		}
-	}
+    for (; iter != conversations.end(); ++iter)
+    {
+        if (iter->getParticipantID() == id)
+        {
+            LLFloaterReg::showInstance("preview_conversation", iter->getSessionID(), true);
+            return;
+        }
+    }
 
-	if (LLLogChat::isTranscriptExist(id))
-	{
-		LLAvatarName avatar_name;
-		LLSD extended_id(id);
+    if (LLLogChat::isTranscriptExist(id))
+    {
+        LLAvatarName avatar_name;
+        LLSD extended_id(id);
 
-		LLAvatarNameCache::get(id, &avatar_name);
-		extended_id[LL_FCP_COMPLETE_NAME] = avatar_name.getCompleteName();
-		extended_id[LL_FCP_ACCOUNT_NAME] = avatar_name.getAccountName();
-		LLFloaterReg::showInstance("preview_conversation", extended_id, true);
-	}
+        LLAvatarNameCache::get(id, &avatar_name);
+        extended_id[LL_FCP_COMPLETE_NAME] = avatar_name.getCompleteName();
+        extended_id[LL_FCP_ACCOUNT_NAME] = avatar_name.getAccountName();
+        LLFloaterReg::showInstance("preview_conversation", extended_id, true);
+    }
 }
 
 //== private methods ========================================================================================
@@ -1274,252 +1274,252 @@ void LLAvatarActions::viewChatHistory(const LLUUID& id)
 // static
 bool LLAvatarActions::handleRemove(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-
-	const LLSD& ids = notification["payload"]["ids"];
-	for (LLSD::array_const_iterator itr = ids.beginArray(); itr != ids.endArray(); ++itr)
-	{
-		LLUUID id = itr->asUUID();
-		const LLRelationship* ip = LLAvatarTracker::instance().getBuddyInfo(id);
-		if (ip)
-		{
-			switch (option)
-			{
-			case 0: // YES
-				if( ip->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS))
-				{
-					LLAvatarTracker::instance().empower(id, FALSE);
-					LLAvatarTracker::instance().notifyObservers();
-				}
-				LLAvatarTracker::instance().terminateBuddy(id);
-				LLAvatarTracker::instance().notifyObservers();
-				break;
-
-			case 1: // NO
-			default:
-				LL_INFOS() << "No removal performed." << LL_ENDL;
-				break;
-			}
-		}
-	}
-	return false;
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+
+    const LLSD& ids = notification["payload"]["ids"];
+    for (LLSD::array_const_iterator itr = ids.beginArray(); itr != ids.endArray(); ++itr)
+    {
+        LLUUID id = itr->asUUID();
+        const LLRelationship* ip = LLAvatarTracker::instance().getBuddyInfo(id);
+        if (ip)
+        {
+            switch (option)
+            {
+            case 0: // YES
+                if( ip->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS))
+                {
+                    LLAvatarTracker::instance().empower(id, FALSE);
+                    LLAvatarTracker::instance().notifyObservers();
+                }
+                LLAvatarTracker::instance().terminateBuddy(id);
+                LLAvatarTracker::instance().notifyObservers();
+                break;
+
+            case 1: // NO
+            default:
+                LL_INFOS() << "No removal performed." << LL_ENDL;
+                break;
+            }
+        }
+    }
+    return false;
 }
 
 // static
 bool LLAvatarActions::handlePay(const LLSD& notification, const LLSD& response, LLUUID avatar_id)
 {
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (option == 0)
-	{
-		gAgent.setDoNotDisturb(false);
-	}
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    if (option == 0)
+    {
+        gAgent.setDoNotDisturb(false);
+    }
 
-	LLFloaterPayUtil::payDirectly(&give_money, avatar_id, /*is_group=*/false);
-	return false;
+    LLFloaterPayUtil::payDirectly(&give_money, avatar_id, /*is_group=*/false);
+    return false;
 }
 
 // static
 void LLAvatarActions::callback_invite_to_group(LLUUID group_id, LLUUID id)
 {
-	uuid_vec_t agent_ids;
-	agent_ids.push_back(id);
-	
-	LLFloaterGroupInvite::showForGroup(group_id, &agent_ids);
+    uuid_vec_t agent_ids;
+    agent_ids.push_back(id);
+
+    LLFloaterGroupInvite::showForGroup(group_id, &agent_ids);
 }
 
 
 // static
 bool LLAvatarActions::callbackAddFriendWithMessage(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (option == 0)
-	{
-		requestFriendship(notification["payload"]["id"].asUUID(), 
-		    notification["payload"]["name"].asString(),
-		    response["message"].asString());
-	}
-	return false;
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    if (option == 0)
+    {
+        requestFriendship(notification["payload"]["id"].asUUID(),
+            notification["payload"]["name"].asString(),
+            response["message"].asString());
+    }
+    return false;
 }
 
 // static
 bool LLAvatarActions::handleKick(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotification::getSelectedOption(notification, response);
-
-	if (option == 0)
-	{
-		LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
-		LLMessageSystem* msg = gMessageSystem;
+    S32 option = LLNotification::getSelectedOption(notification, response);
 
-		msg->newMessageFast(_PREHASH_GodKickUser);
-		msg->nextBlockFast(_PREHASH_UserInfo);
-		msg->addUUIDFast(_PREHASH_GodID,		gAgent.getID() );
-		msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
-		msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
-		msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
-		msg->addStringFast(_PREHASH_Reason,    response["message"].asString() );
-		gAgent.sendReliableMessage();
-	}
-	return false;
+    if (option == 0)
+    {
+        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
+        LLMessageSystem* msg = gMessageSystem;
+
+        msg->newMessageFast(_PREHASH_GodKickUser);
+        msg->nextBlockFast(_PREHASH_UserInfo);
+        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
+        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
+        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
+        msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
+        msg->addStringFast(_PREHASH_Reason,    response["message"].asString() );
+        gAgent.sendReliableMessage();
+    }
+    return false;
 }
 
 bool LLAvatarActions::handleFreezeAvatar(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotification::getSelectedOption(notification, response);
-
-	if (0 == option || 1 == option)
-	{
-	    U32 flags = 0x0;
-	    if (1 == option)
-	    {
-	        // unfreeze
-	        flags |= 0x1;
-	    }
-	    LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
-		LLMessageSystem* msg = gMessageSystem;
-
-		msg->newMessage("FreezeUser");
-		msg->nextBlock("AgentData");
-		msg->addUUID("AgentID", gAgent.getID());
-		msg->addUUID("SessionID", gAgent.getSessionID());
-		msg->nextBlock("Data");
-		msg->addUUID("TargetID", avatar_id );
-		msg->addU32("Flags", flags );
-		gAgent.sendReliableMessage();
-	}
-	return false;
+    S32 option = LLNotification::getSelectedOption(notification, response);
+
+    if (0 == option || 1 == option)
+    {
+        U32 flags = 0x0;
+        if (1 == option)
+        {
+            // unfreeze
+            flags |= 0x1;
+        }
+        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
+        LLMessageSystem* msg = gMessageSystem;
+
+        msg->newMessage("FreezeUser");
+        msg->nextBlock("AgentData");
+        msg->addUUID("AgentID", gAgent.getID());
+        msg->addUUID("SessionID", gAgent.getSessionID());
+        msg->nextBlock("Data");
+        msg->addUUID("TargetID", avatar_id );
+        msg->addU32("Flags", flags );
+        gAgent.sendReliableMessage();
+    }
+    return false;
 }
 
 bool LLAvatarActions::handleEjectAvatar(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (2 == option)
-	{
-		return false;
-	}
-	LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
-	bool ban_enabled = notification["payload"]["ban_enabled"].asBoolean();
-
-	if (0 == option)
-	{
-		LLMessageSystem* msg = gMessageSystem;
-		U32 flags = 0x0;
-		msg->newMessage("EjectUser");
-		msg->nextBlock("AgentData");
-		msg->addUUID("AgentID", gAgent.getID() );
-		msg->addUUID("SessionID", gAgent.getSessionID() );
-		msg->nextBlock("Data");
-		msg->addUUID("TargetID", avatar_id );
-		msg->addU32("Flags", flags );
-		gAgent.sendReliableMessage();
-	}
-	else if (ban_enabled)
-	{
-		LLMessageSystem* msg = gMessageSystem;
-
-		U32 flags = 0x1;
-		msg->newMessage("EjectUser");
-		msg->nextBlock("AgentData");
-		msg->addUUID("AgentID", gAgent.getID() );
-		msg->addUUID("SessionID", gAgent.getSessionID() );
-		msg->nextBlock("Data");
-		msg->addUUID("TargetID", avatar_id );
-		msg->addU32("Flags", flags );
-		gAgent.sendReliableMessage();
-	}
-	return false;
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    if (2 == option)
+    {
+        return false;
+    }
+    LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
+    bool ban_enabled = notification["payload"]["ban_enabled"].asBoolean();
+
+    if (0 == option)
+    {
+        LLMessageSystem* msg = gMessageSystem;
+        U32 flags = 0x0;
+        msg->newMessage("EjectUser");
+        msg->nextBlock("AgentData");
+        msg->addUUID("AgentID", gAgent.getID() );
+        msg->addUUID("SessionID", gAgent.getSessionID() );
+        msg->nextBlock("Data");
+        msg->addUUID("TargetID", avatar_id );
+        msg->addU32("Flags", flags );
+        gAgent.sendReliableMessage();
+    }
+    else if (ban_enabled)
+    {
+        LLMessageSystem* msg = gMessageSystem;
+
+        U32 flags = 0x1;
+        msg->newMessage("EjectUser");
+        msg->nextBlock("AgentData");
+        msg->addUUID("AgentID", gAgent.getID() );
+        msg->addUUID("SessionID", gAgent.getSessionID() );
+        msg->nextBlock("Data");
+        msg->addUUID("TargetID", avatar_id );
+        msg->addU32("Flags", flags );
+        gAgent.sendReliableMessage();
+    }
+    return false;
 }
 
 bool LLAvatarActions::handleFreeze(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotification::getSelectedOption(notification, response);
-	if (option == 0)
-	{
-		LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
-		LLMessageSystem* msg = gMessageSystem;
-
-		msg->newMessageFast(_PREHASH_GodKickUser);
-		msg->nextBlockFast(_PREHASH_UserInfo);
-		msg->addUUIDFast(_PREHASH_GodID,		gAgent.getID() );
-		msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
-		msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
-		msg->addU32("KickFlags", KICK_FLAGS_FREEZE );
-		msg->addStringFast(_PREHASH_Reason, response["message"].asString() );
-		gAgent.sendReliableMessage();
-	}
-	return false;
+    S32 option = LLNotification::getSelectedOption(notification, response);
+    if (option == 0)
+    {
+        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
+        LLMessageSystem* msg = gMessageSystem;
+
+        msg->newMessageFast(_PREHASH_GodKickUser);
+        msg->nextBlockFast(_PREHASH_UserInfo);
+        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
+        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
+        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
+        msg->addU32("KickFlags", KICK_FLAGS_FREEZE );
+        msg->addStringFast(_PREHASH_Reason, response["message"].asString() );
+        gAgent.sendReliableMessage();
+    }
+    return false;
 }
 
 bool LLAvatarActions::handleUnfreeze(const LLSD& notification, const LLSD& response)
 {
-	S32 option = LLNotification::getSelectedOption(notification, response);
-	std::string text = response["message"].asString();
-	if (option == 0)
-	{
-		LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
-		LLMessageSystem* msg = gMessageSystem;
-
-		msg->newMessageFast(_PREHASH_GodKickUser);
-		msg->nextBlockFast(_PREHASH_UserInfo);
-		msg->addUUIDFast(_PREHASH_GodID,		gAgent.getID() );
-		msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
-		msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
-		msg->addU32("KickFlags", KICK_FLAGS_UNFREEZE );
-		msg->addStringFast(_PREHASH_Reason,    text );
-		gAgent.sendReliableMessage();
-	}
-	return false;
+    S32 option = LLNotification::getSelectedOption(notification, response);
+    std::string text = response["message"].asString();
+    if (option == 0)
+    {
+        LLUUID avatar_id = notification["payload"]["avatar_id"].asUUID();
+        LLMessageSystem* msg = gMessageSystem;
+
+        msg->newMessageFast(_PREHASH_GodKickUser);
+        msg->nextBlockFast(_PREHASH_UserInfo);
+        msg->addUUIDFast(_PREHASH_GodID,        gAgent.getID() );
+        msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
+        msg->addUUIDFast(_PREHASH_AgentID,   avatar_id );
+        msg->addU32("KickFlags", KICK_FLAGS_UNFREEZE );
+        msg->addStringFast(_PREHASH_Reason,    text );
+        gAgent.sendReliableMessage();
+    }
+    return false;
 }
 
 // static
 void LLAvatarActions::requestFriendship(const LLUUID& target_id, const std::string& target_name, const std::string& message)
 {
-	const LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
-	LLUIUsage::instance().logCommand("Agent.SendFriendRequest");
+    const LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
+    LLUIUsage::instance().logCommand("Agent.SendFriendRequest");
 
-	send_improved_im(target_id,
-					 target_name,
-					 message,
-					 IM_ONLINE,
-					 IM_FRIENDSHIP_OFFERED,
-					 calling_card_folder_id);
+    send_improved_im(target_id,
+                     target_name,
+                     message,
+                     IM_ONLINE,
+                     IM_FRIENDSHIP_OFFERED,
+                     calling_card_folder_id);
 
-	LLSD args;
-	args["TO_NAME"] = target_name;
+    LLSD args;
+    args["TO_NAME"] = target_name;
 
-	LLSD payload;
-	payload["from_id"] = target_id;
-	LLNotificationsUtil::add("FriendshipOffered", args, payload);
+    LLSD payload;
+    payload["from_id"] = target_id;
+    LLNotificationsUtil::add("FriendshipOffered", args, payload);
 }
 
 //static
 bool LLAvatarActions::isFriend(const LLUUID& id)
 {
-	return ( NULL != LLAvatarTracker::instance().getBuddyInfo(id) );
+    return ( NULL != LLAvatarTracker::instance().getBuddyInfo(id) );
 }
 
 // static
 bool LLAvatarActions::isBlocked(const LLUUID& id)
 {
-	LLAvatarName av_name;
-	LLAvatarNameCache::get(id, &av_name);
-	return LLMuteList::getInstance()->isMuted(id, av_name.getUserName());
+    LLAvatarName av_name;
+    LLAvatarNameCache::get(id, &av_name);
+    return LLMuteList::getInstance()->isMuted(id, av_name.getUserName());
 }
 
 // static
 bool LLAvatarActions::isVoiceMuted(const LLUUID& id)
 {
-	return LLMuteList::getInstance()->isMuted(id, LLMute::flagVoiceChat);
+    return LLMuteList::getInstance()->isMuted(id, LLMute::flagVoiceChat);
 }
 
 // static
 bool LLAvatarActions::canBlock(const LLUUID& id)
 {
-	LLAvatarName av_name;
-	LLAvatarNameCache::get(id, &av_name);
+    LLAvatarName av_name;
+    LLAvatarNameCache::get(id, &av_name);
 
-	std::string full_name = av_name.getUserName();
-	bool is_linden = (full_name.find("Linden") != std::string::npos);
-	bool is_self = id == gAgentID;
-	return !is_self && !is_linden;
+    std::string full_name = av_name.getUserName();
+    bool is_linden = (full_name.find("Linden") != std::string::npos);
+    bool is_self = id == gAgentID;
+    return !is_self && !is_linden;
 }