1 files changed, 428 insertions, 105 deletions

diff --git a/linden/indra/newview/llfloatermap.cpp b/linden/indra/newview/llfloatermap.cpp
index 9ade3bf..29a95c2 100644
--- a/linden/indra/newview/llfloatermap.cpp
+++ b/linden/indra/newview/llfloatermap.cpp
@@ -47,11 +47,16 @@
 #include "llfloaterfriends.h"
 #include "llfloatergroupinvite.h"
 #include "llfloatergroups.h"
+#include "llfloaterreporter.h"
 #include "llimview.h"
+#include "llmutelist.h"
 #include "roles_constants.h"
 #include "llscrolllistctrl.h"
 #include "lltracker.h"
+#include "llviewerobjectlist.h"
 #include "llviewermessage.h"
+#include "llviewerregion.h"
+#include "llviewerwindow.h"
 #include "llworld.h"
 
 LLFloaterMap* LLFloaterMap::sInstance = NULL;
@@ -59,11 +64,16 @@ LLFloaterMap* LLFloaterMap::sInstance = NULL;
 LLFloaterMap::LLFloaterMap(const LLSD& key)
         :
         LLFloater(std::string("minimap")),
-        mPanelMap(NULL)
+        mPanelMap(NULL),
+        mUpdate(TRUE)
 {
         LLCallbackMap::map_t factory_map;
         factory_map["mini_mapview"] = LLCallbackMap(createPanelMiniMap, this);
         LLUICtrlFactory::getInstance()->buildFloater(this, "floater_mini_map.xml", &factory_map, FALSE);
+
+        mSelectedAvatar.setNull();
+        mAvatars.clear();
+
         sInstance = this;
 }
 
@@ -73,7 +83,6 @@ void* LLFloaterMap::createPanelMiniMap(void* data)
 {
         LLFloaterMap* self = (LLFloaterMap*)data;
         self->mPanelMap = new LLNetMap("Mapview");
-        self->mSelectedAvatar.setNull();
         return self->mPanelMap;
 }
 
@@ -88,12 +97,20 @@ BOOL LLFloaterMap::postBuild()
         childSetCommitCallback("RadarList", onList, this);
         mRadarList->setDoubleClickCallback(onClickIM);
 
+        childSetFocusChangedCallback("near_me_range", onRangeChange, this);
+
         childSetAction("im_btn", onClickIM, this);
         childSetAction("profile_btn", onClickProfile, this);
         childSetAction("offer_teleport_btn", onClickOfferTeleport, this);
         childSetAction("track_btn", onClickTrack, this);
         childSetAction("invite_btn", onClickInvite, this);
         childSetAction("add_btn", onClickAddFriend, this);
+        childSetAction("freeze_btn", onClickFreeze, this);
+        childSetAction("eject_btn", onClickEject, this);
+        childSetAction("mute_btn", onClickMute, this);
+        childSetAction("unmute_btn", onClickUnmute, this);
+        childSetAction("ar_btn", onClickAR, this);
+        childSetAction("estate_eject_btn", onClickEjectFromEstate, this);
 
         setDefaultBtn("im_btn");
 
@@ -155,11 +172,25 @@ void LLFloaterMap::draw()
         }
 }
 
+// [RLVa:KB] - Version: 1.22.11 | Checked: 2009-07-05 (RLVa-1.0.0c)
+void LLFloaterMap::open()
+{
+        if (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWMINIMAP))
+        {
+                LLFloater::open();
+        }
+}
+// [/RLVa:KB]
+
 // TODO: make this detachable
+// TODO: make this expand/collapse
 
-//
-// Radar
-//
+/*
+* Imprudence Radar
+* @brief inworld radar integrated with the minimap
+* by McCabe Maxsted
+* Estate tab portion by Dale Glass
+*/
 
 //static
 void LLFloaterMap::updateRadar()
@@ -170,113 +201,128 @@ void LLFloaterMap::updateRadar()
 
 void LLFloaterMap::populateRadar()
 {
-        std::stringstream avatar_count_string;
+        if (!mUpdate)
+        {
+                return;
+        }
+
+        if (visibleItemsSelected())
+        {
+                mSelectedAvatar = mRadarList->getSelectedValue().asUUID();
+        }
+        else
+        {
+                mSelectedAvatar.setNull();
+        }
+
+        S32 scroll_pos = mRadarList->getScrollPos();
+
         LLVector3d current_pos = gAgent.getPositionGlobal();
 
         // find what avatars you can see
-        std::vector<LLUUID> avatar_ids_new;
-        std::vector<LLVector3d> positions_new;
-        LLWorld::getInstance()->getAvatars(&avatar_ids_new, &positions_new, current_pos, gSavedSettings.getF32("NearMeRange"));
-        
-        // add an avatar to the list if it doesn't exist
-        std::vector<LLUUID>::iterator result;
-        for (U32 i=0; i<avatar_ids_new.size(); i++)
+        std::vector<LLUUID> avatar_ids;
+        std::vector<LLVector3d> positions;
+        LLWorld::getInstance()->getAvatars(&avatar_ids, &positions, current_pos, gSavedSettings.getF32("NearMeRange"));
+
+        // Add avatars to the list. If they're already there, update positions
+        std::pair<std::map<LLUUID, LLVector3d>::iterator, bool> ret;
+        for (U32 i=0; i<avatar_ids.size(); i++)
         {
-                result = find(mAvatarIDs.begin(), mAvatarIDs.end(), avatar_ids_new[i]);
-                if (result == mAvatarIDs.end())
+                if (avatar_ids[i] == gAgent.getID() ||
+                        avatar_ids[i].isNull())
                 {
-                        mAvatarIDs.push_back(avatar_ids_new[i]);
-                        mPositions.push_back(positions_new[i]);
-                        addToList(avatar_ids_new[i], positions_new[i], current_pos);
+                        continue;
                 }
-                else // avatar exists, check for updated position
+
+                ret = mAvatars.insert(std::pair<LLUUID, LLVector3d>(avatar_ids[i], positions[i]));
+                if (ret.second == false)
                 {
-                        if (mPositions[i] != positions_new[i])
-                        {
-                                removeFromList(mAvatarIDs[i]);
-                                mPositions[i] = positions_new[i];
-                                addToList(mAvatarIDs[i], mPositions[i], current_pos);
-                        }
+                        mAvatars[avatar_ids[i]] = positions[i]; 
                 }
         }
 
-        // pull out dead entries
-        for (U32 i=0; i<mAvatarIDs.size(); i++)
+        LLSD element;
+
+        mRadarList->deleteAllItems();
+        
+        // if an avatar's not in range anymore, kill it. Otherwise, populate radar
+        std::map<LLUUID, LLVector3d>::iterator mIt;
+        std::vector<LLUUID>::iterator result;
+        for (mIt = mAvatars.begin(); mIt != mAvatars.end(); )
         {
-                result = find(avatar_ids_new.begin(), avatar_ids_new.end(), mAvatarIDs[i]);
-                if (result == avatar_ids_new.end())
+                result = find(avatar_ids.begin(), avatar_ids.end(), mIt->first);
+                if (result == avatar_ids.end())
                 {
-                        removeFromList(mAvatarIDs[i]);
-
-                        // pop_back is faster
-                        std::swap(mAvatarIDs[i], mAvatarIDs.back());
-                        mAvatarIDs.pop_back();
-                        std::swap(mPositions[i], mPositions.back());
-                        mPositions.pop_back();
+                        mAvatars.erase(mIt++);
+                }
+                else
+                {
+                        // Add to list only if we get their name
+                        std::string fullname = getSelectedName(mIt->first);
+                        if (!fullname.empty() && fullname != " ")
+                        {
+                                std::string mute_text = LLMuteList::getInstance()->isMuted(mIt->first) ? getString("muted") : "";
+                                element["id"] = mIt->first;
+                                element["columns"][0]["column"] = "avatar_name";
+                                element["columns"][0]["type"] = "text";
+                                element["columns"][0]["value"] = fullname + " " + mute_text;
+                                element["columns"][1]["column"] = "avatar_distance";
+                                element["columns"][1]["type"] = "text";
+
+                                F64 distance = dist_vec(current_pos, mIt->second);
+                                std::stringstream dist_formatted;
+                                dist_formatted.str("");
+                                dist_formatted << (double)((int)((distance + 0.05)*10.0))/10.0 << "m";
+                                element["columns"][1]["value"] = dist_formatted.str();
+
+                                mRadarList->addElement(element, ADD_BOTTOM);
+                        }
+                        ++mIt;
                 }
         }
 
-        avatar_count_string.str("");
-        if (mAvatarIDs.empty())
-        {
-                childSetEnabled("RadarList", false);childSetEnabled("im_btn", false);
-                mRadarList->addCommentText(getString("no_one_near"));
-                avatar_count_string << "0";
-        }
-        else 
+        mRadarList->sortItems();
+        mRadarList->setScrollPos(scroll_pos);
+
+        if (mSelectedAvatar.notNull())
         {
-                childSetEnabled("RadarList", true);             
-                avatar_count_string << (int)mAvatarIDs.size();
+                mRadarList->selectByID(mSelectedAvatar);
         }
-        LLTextBox* lblAvatarCount = getChild<LLTextBox>("lblAvatarCount");
-        lblAvatarCount->setText(avatar_count_string.str());
-        onList(mRadarList, this);
-}
-
-void LLFloaterMap::addToList(const LLUUID& agent_id, const LLVector3d& agent_pos, const LLVector3d& current_pos)
-{
-        if (agent_id == gAgent.getID()) 
-                return; 
-
-        F64 distance = dist_vec(current_pos, agent_pos);
-        std::stringstream dist_formatted;
-        dist_formatted << (double)((int)((distance + 0.05)*10.0))/10.0 << "m";
-
-        LLSD element;
-        element["id"] = agent_id; // value
-        element["columns"][0]["column"] = "avatar_name";
-        element["columns"][0]["type"] = "text";
 
-        std::string fullname;
-        if(!gCacheName->getFullName(agent_id, fullname))
+        // set count
+        std::stringstream avatar_count; 
+        avatar_count.str("");
+        if (mAvatars.empty())
         {
-                element["columns"][0]["value"] = LLCacheName::getDefaultName();
-        }                       
+                mRadarList->addCommentText(getString("no_one_near"), ADD_TOP);
+                avatar_count << "0";
+        }
         else
         {
-                element["columns"][0]["value"] = fullname;
+                avatar_count << (int)mAvatars.size();
         }
+        childSetText("lblAvatarCount", avatar_count.str());
 
-        element["columns"][1]["column"] = "avatar_distance";
-        element["columns"][1]["type"] = "text";
-        element["columns"][1]["value"] = dist_formatted.str();
-
-        mRadarList->addElement(element);
-        mRadarList->selectByID(mSelectedAvatar);
-
-        onList(mRadarList, this);
-}
+        toggleButtons();
+}       
 
-void LLFloaterMap::removeFromList(const LLUUID& agent_id)
+void LLFloaterMap::toggleButtons()
 {
-        S32 index = mRadarList->getItemIndex(agent_id);
-        if (index >= 0)
-        {
-                mRadarList->deleteSingleItem(index);
-                mRadarList->selectByID(mSelectedAvatar);
-
-                onList(mRadarList, this);
-        }
+        BOOL enabled = mRadarList->hasFocus() ? visibleItemsSelected() : FALSE;
+        BOOL unmute_enabled = mRadarList->hasFocus() ? LLMuteList::getInstance()->isMuted(mSelectedAvatar) : FALSE;
+
+        childSetEnabled("im_btn", enabled);
+        childSetEnabled("profile_btn", enabled);
+        childSetEnabled("offer_teleport_btn", enabled);
+        childSetEnabled("track_btn", enabled);
+        childSetEnabled("invite_btn", enabled);
+        childSetEnabled("add_btn", enabled);
+        childSetEnabled("freeze_btn", enabled);
+        childSetEnabled("eject_btn", enabled);
+        childSetEnabled("mute_btn", enabled);
+        childSetEnabled("unmute_btn", unmute_enabled);
+        childSetEnabled("ar_btn", enabled);
+        childSetEnabled("estate_eject_btn", enabled);
 }
 
 // static
@@ -285,26 +331,10 @@ void LLFloaterMap::onList(LLUICtrl* ctrl, void* user_data)
         LLFloaterMap* self = (LLFloaterMap*)user_data;
         if (self)
         {
-                self->childSetEnabled("im_btn", self->visibleItemsSelected());
-                self->childSetEnabled("profile_btn", self->visibleItemsSelected());
-                self->childSetEnabled("offer_teleport_btn", self->visibleItemsSelected());
-                self->childSetEnabled("track_btn", self->visibleItemsSelected());
-                self->childSetEnabled("invite_btn", self->visibleItemsSelected());
-                self->childSetEnabled("add_btn", self->visibleItemsSelected());
-
-                if (self->visibleItemsSelected())
-                {
-                        if (self->mSelectedAvatar != self->mRadarList->getFirstSelected()->getUUID())
-                        {
-                                self->mSelectedAvatar = self->mRadarList->getFirstSelected()->getUUID();
-                        }
-                }
-                else
-                {       
-                        self->mSelectedAvatar.setNull();
-                }
+                self->toggleButtons();
         }
 }
+                
 
 BOOL LLFloaterMap::visibleItemsSelected() const
 {
@@ -316,6 +346,16 @@ BOOL LLFloaterMap::visibleItemsSelected() const
 }
 
 // static
+void LLFloaterMap::onRangeChange(LLFocusableElement* focus, void* user_data)
+{
+        LLFloaterMap* self = (LLFloaterMap*)user_data;
+        if (self)
+        {
+                self->mUpdate = !(self->childHasFocus("near_me_range"));
+        }
+}
+
+// static
 BOOL LLFloaterMap::isSelected(LLUUID agent)
 {
         if (sInstance->mSelectedAvatar == agent)
@@ -325,6 +365,10 @@ BOOL LLFloaterMap::isSelected(LLUUID agent)
         return FALSE;
 }
 
+//
+// Avatar tab
+//
+
 // static
 void LLFloaterMap::onClickIM(void* user_data)
 {
@@ -429,3 +473,282 @@ void LLFloaterMap::onClickAddFriend(void* user_data)
                 LLPanelFriends::requestFriendshipDialog(agent_id, fullname);
         }
 }
+
+//
+// Estate tab
+//
+
+//static 
+std::string LLFloaterMap::getSelectedName(LLUUID agent_id)
+{
+        std::string agent_name;
+        if(agent_id.notNull() && gCacheName->getFullName(agent_id, agent_name))
+        {
+                return agent_name;
+        }
+        return LLStringUtil::null;
+}
+
+//static 
+void LLFloaterMap::callbackFreeze(S32 option, void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+
+        if ( option == 0 )
+        {
+                sendFreeze(self->mSelectedAvatar, true);
+        }
+        else if ( option == 1 )
+        {
+                sendFreeze(self->mSelectedAvatar, false);
+        }
+}
+
+//static 
+void LLFloaterMap::callbackEject(S32 option, void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+ 
+        if ( option == 0 )
+        {
+                sendEject(self->mSelectedAvatar, false);
+        }
+        else if ( option == 1 )
+        {
+                sendEject(self->mSelectedAvatar, true);
+        }
+}
+
+//static 
+void LLFloaterMap::callbackEjectFromEstate(S32 option, void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+
+        if ( option == 0 )
+        {
+                cmdEstateEject(self->mSelectedAvatar);
+        } 
+        else if ( option == 1 )
+        {
+                cmdEstateBan(self->mSelectedAvatar);
+        }
+}
+
+void LLFloaterMap::onClickFreeze(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+        LLStringUtil::format_map_t args;
+        LLSD payload;
+        args["[AVATAR_NAME]"] = self->getSelectedName(self->mSelectedAvatar);
+        gViewerWindow->alertXml("FreezeAvatarFullname", args, callbackFreeze, user_data);
+}
+
+//static
+void LLFloaterMap::onClickEject(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+        LLStringUtil::format_map_t args;
+        LLSD payload;
+        args["AVATAR_NAME"] = self->getSelectedName(self->mSelectedAvatar);
+        gViewerWindow->alertXml("EjectAvatarFullName", args, callbackEject, user_data);
+}
+
+//static
+void LLFloaterMap::onClickMute(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+
+        LLUUID agent_id = self->mSelectedAvatar;
+        std::string agent_name = self->getSelectedName(agent_id);
+        if(!agent_name.empty())
+        {
+                if (LLMuteList::getInstance()->isMuted(agent_id))
+                {
+                        //LLMute mute(agent_id, agent_name, LLMute::AGENT);
+                        //LLMuteList::getInstance()->remove(mute);      
+                        //LLFloaterMute::getInstance()->selectMute(agent_id);
+                }
+                else
+                {
+                        LLMute mute(agent_id, agent_name, LLMute::AGENT);
+                        LLMuteList::getInstance()->add(mute);
+                }
+        }
+}
+
+//static
+void LLFloaterMap::onClickUnmute(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+
+        LLUUID agent_id = self->mSelectedAvatar;
+        std::string agent_name = self->getSelectedName(agent_id);
+        if(!agent_name.empty())
+        {
+                if (LLMuteList::getInstance()->isMuted(agent_id))
+                {
+                        LLMute mute(agent_id, agent_name, LLMute::AGENT);
+                        LLMuteList::getInstance()->remove(mute);        
+                        //LLFloaterMute::getInstance()->selectMute(agent_id);
+                }
+                else
+                {
+                        //LLMute mute(agent_id, agent_name, LLMute::AGENT);
+                        //LLMuteList::getInstance()->add(mute);
+                }
+        }
+}
+
+//static
+void LLFloaterMap::onClickEjectFromEstate(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+        LLStringUtil::format_map_t args;
+        LLSD payload;
+        args["EVIL_USER"] = self->getSelectedName(self->mSelectedAvatar);
+        gViewerWindow->alertXml("EstateKickUser", args, callbackEjectFromEstate, user_data);
+}
+
+//static
+void LLFloaterMap::onClickAR(void *user_data)
+{
+        LLFloaterMap *self = (LLFloaterMap*)user_data;
+        LLUUID agent_id = self->mSelectedAvatar;
+                
+        if (agent_id.notNull())
+        {
+                        LLFloaterReporter::showFromObject(agent_id);
+        }
+}
+
+// static 
+void LLFloaterMap::cmdEstateEject(const LLUUID &avatar)
+{ 
+        sendEstateMessage("teleporthomeuser", avatar); 
+}
+
+// static 
+void LLFloaterMap::cmdEstateBan(const LLUUID &avatar)
+{
+        sendEstateMessage("teleporthomeuser", avatar); // Kick first, just to be sure
+        sendEstateBan(avatar);
+}
+
+// static 
+void LLFloaterMap::sendFreeze(const LLUUID& avatar_id, bool freeze)
+{
+        U32 flags = 0x0;
+        if (!freeze)
+        {
+                // unfreeze
+                flags |= 0x1;
+        }
+
+        LLMessageSystem* msg = gMessageSystem;
+        LLViewerObject* avatar = gObjectList.findObject(avatar_id);
+
+        if (avatar)
+        {
+                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 );
+                msg->sendReliable( avatar->getRegion()->getHost() );
+        }
+}
+
+// static 
+void LLFloaterMap::sendEject(const LLUUID& avatar_id, bool ban)
+{       
+        LLMessageSystem* msg = gMessageSystem;
+        LLViewerObject* avatar = gObjectList.findObject(avatar_id);
+
+        if (avatar)
+        {
+                U32 flags = 0x0;
+                if ( ban )
+                {
+                        // eject and add to ban list
+                        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 );
+                msg->sendReliable( avatar->getRegion()->getHost() );
+        }
+}
+
+// static 
+void LLFloaterMap::sendEstateMessage(const char* request, const LLUUID &target)
+{
+
+        LLMessageSystem* msg = gMessageSystem;
+        LLUUID invoice;
+
+        // This seems to provide an ID so that the sim can say which request it's
+        // replying to. I think this can be ignored for now.
+        invoice.generate();
+
+        llinfos << "Sending estate request '" << request << "'" << llendl;
+        msg->newMessage("EstateOwnerMessage");
+        msg->nextBlockFast(_PREHASH_AgentData);
+        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+        msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null); //not used
+        msg->nextBlock("MethodData");
+        msg->addString("Method", request);
+        msg->addUUID("Invoice", invoice);
+
+        // Agent id
+        msg->nextBlock("ParamList");
+        msg->addString("Parameter", gAgent.getID().asString().c_str());
+
+        // Target
+        msg->nextBlock("ParamList");
+        msg->addString("Parameter", target.asString().c_str());
+
+        msg->sendReliable(gAgent.getRegion()->getHost());
+}
+
+// static 
+void LLFloaterMap::sendEstateBan(const LLUUID& agent)
+{
+        LLUUID invoice;
+        U32 flags = ESTATE_ACCESS_BANNED_AGENT_ADD;
+
+        invoice.generate();
+
+        LLMessageSystem* msg = gMessageSystem;
+        msg->newMessage("EstateOwnerMessage");
+        msg->nextBlockFast(_PREHASH_AgentData);
+        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+        msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null); //not used
+
+        msg->nextBlock("MethodData");
+        msg->addString("Method", "estateaccessdelta");
+        msg->addUUID("Invoice", invoice);
+
+        char buf[MAX_STRING];           /* Flawfinder: ignore*/
+        gAgent.getID().toString(buf);
+        msg->nextBlock("ParamList");
+        msg->addString("Parameter", buf);
+
+        snprintf(buf, MAX_STRING, "%u", flags);                 /* Flawfinder: ignore */
+        msg->nextBlock("ParamList");
+        msg->addString("Parameter", buf);
+
+        agent.toString(buf);
+        msg->nextBlock("ParamList");
+        msg->addString("Parameter", buf);
+
+        gAgent.sendReliableMessage();
+}