Second Life viewer sources 1.13.2.12

1 files changed, 816 insertions, 0 deletions

diff --git a/linden/indra/newview/llcallingcard.cpp b/linden/indra/newview/llcallingcard.cpp
new file mode 100644
index 0000000..83a5fac
--- /dev/null
+++ b/linden/indra/newview/llcallingcard.cpp
@@ -0,0 +1,816 @@
+/** 
+ * @file llcallingcard.cpp
+ * @brief Implementation of the LLPreviewCallingCard class
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#if LL_WINDOWS
+#pragma warning( disable : 4800 ) // performance warning in <functional>
+#endif
+
+#include "llcallingcard.h"
+
+#include <vector>
+#include <algorithm>
+//#include <iterator>
+
+#include "indra_constants.h"
+#include "llcachename.h"
+#include "llstl.h"
+#include "lltimer.h"
+#include "lluuid.h"
+#include "message.h"
+
+#include "llagent.h"
+#include "llbutton.h"
+//#include "llinventory.h"
+#include "llinventorymodel.h"
+#include "llnotify.h"
+#include "llresmgr.h"
+#include "llimview.h"
+#include "llviewercontrol.h"
+#include "llviewernetwork.h"
+#include "llviewerobjectlist.h"
+#include "llviewerwindow.h"
+#include "llvoavatar.h"
+
+///----------------------------------------------------------------------------
+/// Local function declarations, constants, enums, and typedefs
+///----------------------------------------------------------------------------
+
+class LLTrackingData
+{
+public:
+        LLTrackingData(const LLUUID& avatar_id, const std::string& name);
+        bool haveTrackingInfo();
+        void setTrackedCoarseLocation(const LLVector3d& global_pos);
+        void agentFound(const LLUUID& prey,
+                                        const LLVector3d& estimated_global_pos);
+        
+public:
+        LLUUID mAvatarID;
+        LLString mName;
+        LLVector3d mGlobalPositionEstimate;
+        bool mHaveInfo;
+        bool mHaveCoarseInfo;
+        LLTimer mCoarseLocationTimer;
+        LLTimer mUpdateTimer;
+        LLTimer mAgentGone;
+};
+
+const F32 COARSE_FREQUENCY = 2.2f;
+const F32 FIND_FREQUENCY = 29.7f;       // This results in a database query, so cut these back
+const F32 OFFLINE_SECONDS = FIND_FREQUENCY + 8.0f;
+
+// static
+LLAvatarTracker LLAvatarTracker::sInstance;
+
+/*
+class LLAvatarTrackerInventoryObserver : public LLInventoryObserver
+{
+public:
+        LLAvatarTrackerInventoryObserver(LLAvatarTracker* at) :
+                mAT(at) {}
+        virtual ~LLAvatarTrackerInventoryObserver() {}
+        virtual void changed(U32 mask);
+protected:
+        LLAvatarTracker* mAT;
+};
+*/
+
+/*
+void LLAvatarTrackerInventoryObserver::changed(U32 mask)
+{
+        // if there's a calling card change, just do it.
+        if((mask & LLInventoryObserver::CALLING_CARD) != 0)
+        {
+                mAT->inventoryChanged();
+        }
+}
+*/
+
+///----------------------------------------------------------------------------
+/// Class LLAvatarTracker
+///----------------------------------------------------------------------------
+
+LLAvatarTracker::LLAvatarTracker() :
+        mTrackingData(NULL),
+        mTrackedAgentValid(false),
+        //mInventory(NULL),
+        //mInventoryObserver(NULL),
+        mModifyMask(0x0)        
+{
+}
+
+LLAvatarTracker::~LLAvatarTracker()
+{
+        deleteTrackingData();
+        std::for_each(mObservers.begin(), mObservers.end(), DeletePointer());
+}
+
+void LLAvatarTracker::track(const LLUUID& avatar_id, const std::string& name)
+{
+        deleteTrackingData();
+        mTrackedAgentValid = false;
+        mTrackingData = new LLTrackingData(avatar_id, name);
+        findAgent();
+
+        // We track here because findAgent() is called on a timer (for now).
+        if(avatar_id.notNull())
+        {
+                LLMessageSystem* msg = gMessageSystem;
+                msg->newMessageFast(_PREHASH_TrackAgent);
+                msg->nextBlockFast(_PREHASH_AgentData);
+                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                msg->nextBlockFast(_PREHASH_TargetData);
+                msg->addUUIDFast(_PREHASH_PreyID, avatar_id);
+                gAgent.sendReliableMessage();
+        }
+}
+
+void LLAvatarTracker::untrack(const LLUUID& avatar_id)
+{
+        if (mTrackingData && mTrackingData->mAvatarID == avatar_id)
+        {
+                deleteTrackingData();
+                mTrackedAgentValid = false;
+                LLMessageSystem* msg = gMessageSystem;
+                msg->newMessageFast(_PREHASH_TrackAgent);
+                msg->nextBlockFast(_PREHASH_AgentData);
+                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                msg->nextBlockFast(_PREHASH_TargetData);
+                msg->addUUIDFast(_PREHASH_PreyID, LLUUID::null);
+                gAgent.sendReliableMessage();
+        }
+}
+
+void LLAvatarTracker::setTrackedCoarseLocation(const LLVector3d& global_pos)
+{
+        if(mTrackingData)
+        {
+                mTrackingData->setTrackedCoarseLocation(global_pos);
+        }
+}
+
+bool LLAvatarTracker::haveTrackingInfo()
+{
+        if(mTrackingData)
+        {
+                return mTrackingData->haveTrackingInfo();
+        }
+        return false;
+}
+
+LLVector3d LLAvatarTracker::getGlobalPos()
+{
+        if(!mTrackedAgentValid) return LLVector3d();
+        LLVector3d global_pos;
+        
+        LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
+        if(object && !object->isDead())
+        {
+                global_pos = object->getPositionGlobal();
+                // HACK - for making the tracker point above the avatar's head
+                // rather than its groin
+                global_pos.mdV[VZ] += 0.7f * ((LLVOAvatar *)object)->mBodySize.mV[VZ];
+
+                mTrackingData->mGlobalPositionEstimate = global_pos;
+        }
+        else
+        {
+                global_pos = mTrackingData->mGlobalPositionEstimate;
+        }
+
+        return global_pos;
+}
+
+void LLAvatarTracker::getDegreesAndDist(F32& rot,
+                                                                                F64& horiz_dist,
+                                                                                F64& vert_dist)
+{
+        if(!mTrackingData) return;
+
+        LLVector3d global_pos;
+
+        LLViewerObject* object = gObjectList.findObject(mTrackingData->mAvatarID);
+        if(object && !object->isDead())
+        {
+                global_pos = object->getPositionGlobal();
+                mTrackingData->mGlobalPositionEstimate = global_pos;
+        }
+        else
+        {
+                global_pos = mTrackingData->mGlobalPositionEstimate;
+        }
+        LLVector3d to_vec = global_pos - gAgent.getPositionGlobal();
+        horiz_dist = sqrt(to_vec.mdV[VX] * to_vec.mdV[VX] + to_vec.mdV[VY] * to_vec.mdV[VY]);
+        vert_dist = to_vec.mdV[VZ];
+        rot = F32(RAD_TO_DEG * atan2(to_vec.mdV[VY], to_vec.mdV[VX]));
+}
+
+const LLString& LLAvatarTracker::getName()
+{
+        if(mTrackingData)
+        {
+                return mTrackingData->mName;
+        }
+        else
+        {
+                return LLString::null;
+        }
+}
+
+const LLUUID& LLAvatarTracker::getAvatarID()
+{
+        if(mTrackingData)
+        {
+                return mTrackingData->mAvatarID;
+        }
+        else
+        {
+                return LLUUID::null;
+        }
+}
+
+S32 LLAvatarTracker::addBuddyList(const LLAvatarTracker::buddy_map_t& buds)
+{
+        using namespace std;
+
+        U32 new_buddy_count = 0;        
+        char first[DB_FIRST_NAME_BUF_SIZE];
+        char last[DB_LAST_NAME_BUF_SIZE];
+        LLUUID agent_id;
+        for(buddy_map_t::const_iterator itr = buds.begin(); itr != buds.end(); ++itr)
+        {
+                agent_id = (*itr).first;
+                if(mBuddyInfo.find(agent_id) == mBuddyInfo.end())
+                {
+                        ++new_buddy_count;
+                        mBuddyInfo[agent_id] = (*itr).second;
+                        gCacheName->getName(agent_id, first, last);
+                        mModifyMask |= LLFriendObserver::ADD;
+                }
+        }
+        
+        return new_buddy_count;
+}
+
+
+void LLAvatarTracker::copyBuddyList(buddy_map_t& buddies) const
+{
+        buddy_map_t::const_iterator it = mBuddyInfo.begin();
+        buddy_map_t::const_iterator end = mBuddyInfo.end();
+        for(; it != end; ++it)
+        {
+                buddies[(*it).first] = (*it).second;
+        }
+}
+
+void LLAvatarTracker::terminateBuddy(const LLUUID& id)
+{
+        lldebugs << "LLAvatarTracker::terminateBuddy()" << llendl;
+        LLRelationship* buddy = get_ptr_in_map(mBuddyInfo, id);
+        if(!buddy) return;
+        mBuddyInfo.erase(id);
+        LLMessageSystem* msg = gMessageSystem;
+        msg->newMessage("TerminateFriendship");
+        msg->nextBlock("AgentData");
+        msg->addUUID("AgentID", gAgent.getID());
+        msg->addUUID("SessionID", gAgent.getSessionID());
+        msg->nextBlock("ExBlock");
+        msg->addUUID("OtherID", id);
+        gAgent.sendReliableMessage();
+        mModifyMask |= LLFriendObserver::REMOVE;
+        delete buddy;
+}
+
+// get all buddy info
+const LLRelationship* LLAvatarTracker::getBuddyInfo(const LLUUID& id) const
+{
+        if(id.isNull()) return NULL;
+        return get_ptr_in_map(mBuddyInfo, id);
+}
+
+// online status
+void LLAvatarTracker::setBuddyOnline(const LLUUID& id, bool is_online)
+{
+        LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
+        if(info)
+        {
+                info->online(is_online);
+                mModifyMask |= LLFriendObserver::ONLINE;
+        }
+}
+
+bool LLAvatarTracker::isBuddyOnline(const LLUUID& id) const
+{
+        LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
+        if(info)
+        {
+                return info->isOnline();
+        }
+        return false;
+}
+
+// empowered status
+void LLAvatarTracker::setBuddyEmpowered(const LLUUID& id, bool is_empowered)
+{
+        LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
+        if(info)
+        {
+                info->grantRights(LLRelationship::GRANT_MODIFY_OBJECTS, 0);
+                mModifyMask |= LLFriendObserver::POWERS;
+        }
+}
+
+bool LLAvatarTracker::isBuddyEmpowered(const LLUUID& id) const
+{
+        LLRelationship* info = get_ptr_in_map(mBuddyInfo, id);
+        if(info)
+        {
+                return info->isRightGrantedTo(LLRelationship::GRANT_MODIFY_OBJECTS);
+        }
+        return false;
+}
+
+void LLAvatarTracker::empower(const LLUUID& id, bool grant)
+{
+        // wrapper for ease of use in some situations.
+        buddy_map_t list;
+        /*
+        list.insert(id);
+        empowerList(list, grant);
+        */
+}
+
+void LLAvatarTracker::empowerList(const buddy_map_t& list, bool grant)
+{
+        llwarns << "LLAvatarTracker::empowerList() not implemented." << llendl;
+/*
+        LLMessageSystem* msg = gMessageSystem;
+        const char* message_name;
+        const char* block_name;
+        const char* field_name;
+        if(grant)
+        {
+                message_name = _PREHASH_GrantModification;
+                block_name = _PREHASH_EmpoweredBlock;
+                field_name = _PREHASH_EmpoweredID;
+        }
+        else
+        {
+                message_name = _PREHASH_RevokeModification;
+                block_name = _PREHASH_RevokedBlock;
+                field_name = _PREHASH_RevokedID;
+        }
+
+        std::string name;
+        gAgent.buildFullnameAndTitle(name);
+
+        bool start_new_message = true;
+        buddy_list_t::const_iterator it = list.begin();
+        buddy_list_t::const_iterator end = list.end();
+        for(; it != end; ++it)
+        {
+                if(NULL == get_ptr_in_map(mBuddyInfo, (*it))) continue;
+                setBuddyEmpowered((*it), grant);
+                if(start_new_message)
+                {
+                        start_new_message = false;
+                        msg->newMessageFast(message_name);
+                        msg->nextBlockFast(_PREHASH_AgentData);
+                        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
+                        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
+                        msg->addStringFast(_PREHASH_GranterName, name);
+                }
+                msg->nextBlockFast(block_name);
+                msg->addUUIDFast(field_name, (*it));
+                if(msg->isSendFullFast(block_name))
+                {
+                        start_new_message = true;
+                        gAgent.sendReliableMessage();
+                }
+        }
+        if(!start_new_message)
+        {
+                gAgent.sendReliableMessage();
+        }
+*/
+}
+
+void LLAvatarTracker::deleteTrackingData()
+{
+        delete mTrackingData;
+        mTrackingData = NULL;
+}
+
+void LLAvatarTracker::findAgent()
+{
+        if (!mTrackingData) return;
+        if (mTrackingData->mAvatarID.isNull()) return;
+        LLMessageSystem* msg = gMessageSystem;
+        msg->newMessageFast(_PREHASH_FindAgent); // Request
+        msg->nextBlockFast(_PREHASH_AgentBlock);
+        msg->addUUIDFast(_PREHASH_Hunter, gAgentID);
+        msg->addUUIDFast(_PREHASH_Prey, mTrackingData->mAvatarID);
+        msg->addU32Fast(_PREHASH_SpaceIP, 0); // will get filled in by userserver
+        msg->nextBlockFast(_PREHASH_LocationBlock);
+        const F64 NO_LOCATION = 0.0;
+        msg->addF64Fast(_PREHASH_GlobalX, NO_LOCATION);
+        msg->addF64Fast(_PREHASH_GlobalY, NO_LOCATION);
+        gAgent.sendReliableMessage();
+}
+
+void LLAvatarTracker::addObserver(LLFriendObserver* observer)
+{
+        if(observer)
+        {
+                mObservers.push_back(observer);
+        }
+}
+
+void LLAvatarTracker::removeObserver(LLFriendObserver* observer)
+{
+        mObservers.erase(
+                std::remove(mObservers.begin(), mObservers.end(), observer),
+                mObservers.end());
+}
+
+void LLAvatarTracker::notifyObservers()
+{
+        observer_list_t observers(mObservers);
+        observer_list_t::iterator it = observers.begin();
+        observer_list_t::iterator end = observers.end();
+        for(; it != end; ++it)
+        {
+                (*it)->changed(mModifyMask);
+        }
+        mModifyMask = LLFriendObserver::NONE;
+}
+
+void LLAvatarTracker::applyFunctor(LLRelationshipFunctor& f)
+{
+        buddy_map_t::iterator it = mBuddyInfo.begin();
+        buddy_map_t::iterator end = mBuddyInfo.end();
+        for(; it != end; ++it)
+        {
+                f((*it).first, (*it).second);
+        }
+}
+
+void LLAvatarTracker::registerCallbacks(LLMessageSystem* msg)
+{
+        msg->setHandlerFuncFast(_PREHASH_FindAgent, processAgentFound);
+        msg->setHandlerFuncFast(_PREHASH_OnlineNotification,
+                                                processOnlineNotification);
+        msg->setHandlerFuncFast(_PREHASH_OfflineNotification,
+                                                processOfflineNotification);
+        //msg->setHandlerFuncFast(_PREHASH_GrantedProxies,
+        //                                      processGrantedProxies);
+        msg->setHandlerFunc("TerminateFriendship", processTerminateFriendship);
+        msg->setHandlerFunc(_PREHASH_ChangeUserRights, processChangeUserRights);
+}
+
+// static
+void LLAvatarTracker::processAgentFound(LLMessageSystem* msg, void**)
+{
+        LLUUID id;
+
+        
+        msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Hunter, id);
+        msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_Prey, id);
+        // *FIX: should make sure prey id matches.
+        LLVector3d estimated_global_pos;
+        msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalX,
+                                 estimated_global_pos.mdV[VX]);
+        msg->getF64Fast(_PREHASH_LocationBlock, _PREHASH_GlobalY,
+                                 estimated_global_pos.mdV[VY]);
+        LLAvatarTracker::instance().agentFound(id, estimated_global_pos);
+}
+
+void LLAvatarTracker::agentFound(const LLUUID& prey,
+                                                                 const LLVector3d& estimated_global_pos)
+{
+        if(!mTrackingData) return;
+        //if we get a valid reply from the server, that means the agent
+        //is our friend and mappable, so enable interest list based updates
+        LLAvatarTracker::instance().setTrackedAgentValid(true);
+        mTrackingData->agentFound(prey, estimated_global_pos);
+}
+
+//      static
+void LLAvatarTracker::processOnlineNotification(LLMessageSystem* msg, void**)
+{
+        lldebugs << "LLAvatarTracker::processOnlineNotification()" << llendl;
+        instance().processNotify(msg, true);
+}
+
+//      static
+void LLAvatarTracker::processOfflineNotification(LLMessageSystem* msg, void**)
+{
+        lldebugs << "LLAvatarTracker::processOfflineNotification()" << llendl;
+        instance().processNotify(msg, false);
+}
+
+void LLAvatarTracker::processChange(LLMessageSystem* msg)
+{
+        S32 count = msg->getNumberOfBlocksFast(_PREHASH_Rights);
+        LLUUID agent_id, agent_related;
+        S32 new_rights;
+        msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
+        for(int i = 0; i < count; ++i)
+        {
+                msg->getUUIDFast(_PREHASH_Rights, _PREHASH_AgentRelated, agent_related, i);
+                msg->getS32Fast(_PREHASH_Rights,_PREHASH_RelatedRights, new_rights, i);
+                if(agent_id == gAgent.getID())
+                {
+                        if(mBuddyInfo.find(agent_related) != mBuddyInfo.end())
+                        {
+                                (mBuddyInfo[agent_related])->setRightsTo(new_rights);
+                        }
+                }
+                else
+                {
+                        if(mBuddyInfo.find(agent_id) != mBuddyInfo.end())
+                        {
+                                if((mBuddyInfo[agent_id]->getRightsGrantedFrom() ^  new_rights) & LLRelationship::GRANT_MODIFY_OBJECTS)
+                                {
+                                        char first[DB_FIRST_NAME_BUF_SIZE];
+                                        char last[DB_LAST_NAME_BUF_SIZE];
+                                        LLStringBase<char>::format_map_t args;
+                                        if(gCacheName->getName(agent_id, first, last))
+                                        {
+                                                args["[FIRST_NAME]"] = first;
+                                                args["[LAST_NAME]"] = last;     
+                                        }
+                                        if(LLRelationship::GRANT_MODIFY_OBJECTS & new_rights)
+                                        {
+                                                gViewerWindow->alertXml("GrantedModifyRights",args);
+                                        }
+                                        else
+                                        {
+                                                gViewerWindow->alertXml("RevokedModifyRights",args);
+                                        }
+                                }
+                                (mBuddyInfo[agent_id])->setRightsFrom(new_rights);
+                        }
+                }
+        }
+        mModifyMask |= LLFriendObserver::POWERS;
+
+        notifyObservers();
+}
+
+void LLAvatarTracker::processChangeUserRights(LLMessageSystem* msg, void**)
+{
+        lldebugs << "LLAvatarTracker::processChangeUserRights()" << llendl;
+        instance().processChange(msg);
+}
+
+void LLAvatarTracker::processNotify(LLMessageSystem* msg, bool online)
+{
+        S32 count = msg->getNumberOfBlocksFast(_PREHASH_AgentBlock);
+        BOOL chat_notify = gSavedSettings.getBOOL("ChatOnlineNotification");
+
+        if(count > 0)
+        {
+                LLUUID agent_id;
+                const LLRelationship* info = NULL;
+                LLUUID tracking_id;
+                if(mTrackingData)
+                {
+                        tracking_id = mTrackingData->mAvatarID;
+                }
+                BOOL notify = FALSE;
+                LLString::format_map_t args;
+                for(S32 i = 0; i < count; ++i)
+                {
+                        msg->getUUIDFast(_PREHASH_AgentBlock, _PREHASH_AgentID, agent_id, i);
+                        info = getBuddyInfo(agent_id);
+                        if(info)
+                        {
+                                setBuddyOnline(agent_id,online);
+                                if(chat_notify)
+                                {
+                                        char first[DB_FIRST_NAME_BUF_SIZE];
+                                        char last[DB_LAST_NAME_BUF_SIZE];
+                                        if(gCacheName->getName(agent_id, first, last))
+                                        {
+                                                notify = TRUE;
+                                                args["[FIRST]"] = first;
+                                                args["[LAST]"] = last;
+                                        }
+                                }
+                        }
+                        if(tracking_id == agent_id)
+                        {
+                                // we were tracking someone who went offline
+                                deleteTrackingData();
+                        }
+                        // *TODO: get actual inventory id
+                        gInventory.addChangedMask(LLInventoryObserver::CALLING_CARD, LLUUID::null);
+                }
+                if(notify)
+                {
+                        LLNotifyBox::showXml(online ? "FriendOnline" : "FriendOffline", args);
+                }
+
+                mModifyMask |= LLFriendObserver::ONLINE;
+                instance().notifyObservers();
+                gInventory.notifyObservers();
+        }
+}
+
+// XUI:translate
+void LLAvatarTracker::formFriendship(const LLUUID& id)
+{
+        if(id.notNull())
+        {
+                LLRelationship* buddy_info = get_ptr_in_map(instance().mBuddyInfo, id);
+                if(!buddy_info)
+                {
+                        LLAvatarTracker& at = LLAvatarTracker::instance();
+                        //The default for relationship establishment is to have both parties
+                        //visible online to each other.
+                        buddy_info = new LLRelationship(LLRelationship::GRANT_ONLINE_STATUS,LLRelationship::GRANT_ONLINE_STATUS, false);
+                        at.mBuddyInfo[id] = buddy_info;
+                        at.mModifyMask |= LLFriendObserver::ADD;
+                        at.notifyObservers();
+                }
+        }
+}
+
+void LLAvatarTracker::processTerminateFriendship(LLMessageSystem* msg, void**)
+{
+        LLUUID id;
+        msg->getUUID("ExBlock", "OtherID", id);
+        if(id.notNull())
+        {
+                LLAvatarTracker& at = LLAvatarTracker::instance();
+                LLRelationship* buddy = get_ptr_in_map(at.mBuddyInfo, id);
+                if(!buddy) return;
+                at.mBuddyInfo.erase(id);
+                at.mModifyMask |= LLFriendObserver::REMOVE;
+                delete buddy;
+                at.notifyObservers();
+        }
+}
+
+///----------------------------------------------------------------------------
+/// Tracking Data
+///----------------------------------------------------------------------------
+
+LLTrackingData::LLTrackingData(const LLUUID& avatar_id, const std::string& name)
+:       mAvatarID(avatar_id),
+        mHaveInfo(false),
+        mHaveCoarseInfo(false)
+{
+        mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
+        mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
+        mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
+        if(!name.empty())
+        {
+                mName = name;
+        }
+}
+
+void LLTrackingData::agentFound(const LLUUID& prey,
+                                                                const LLVector3d& estimated_global_pos)
+{
+        if(prey != mAvatarID)
+        {
+                llwarns << "LLTrackingData::agentFound() - found " << prey
+                                << " but looking for " << mAvatarID << llendl;
+        }
+        mHaveInfo = true;
+        mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
+        mGlobalPositionEstimate = estimated_global_pos;
+}
+
+bool LLTrackingData::haveTrackingInfo()
+{
+        LLViewerObject* object = gObjectList.findObject(mAvatarID);
+        if(object && !object->isDead())
+        {
+                mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY);
+                mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
+                mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
+                mHaveInfo = true;
+                return true;
+        }
+        if(mHaveCoarseInfo &&
+           !mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY))
+        {
+                // if we reach here, then we have a 'recent' coarse update
+                mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY);
+                mAgentGone.setTimerExpirySec(OFFLINE_SECONDS);
+                return true;
+        }
+        if(mUpdateTimer.checkExpirationAndReset(FIND_FREQUENCY))
+        {
+                LLAvatarTracker::instance().findAgent();
+                mHaveCoarseInfo = false;
+        }
+        if(mAgentGone.checkExpirationAndReset(OFFLINE_SECONDS))
+        {
+                mHaveInfo = false;
+                mHaveCoarseInfo = false;
+        }
+        return mHaveInfo;
+}
+
+void LLTrackingData::setTrackedCoarseLocation(const LLVector3d& global_pos)
+{
+        mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY);
+        mGlobalPositionEstimate = global_pos;
+        mHaveInfo = true;
+        mHaveCoarseInfo = true;
+}
+
+///----------------------------------------------------------------------------
+// various buddy functors
+///----------------------------------------------------------------------------
+
+bool LLCollectProxyBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
+{
+        if(buddy->isRightGrantedFrom(LLRelationship::GRANT_MODIFY_OBJECTS))
+        {
+                mProxy.insert(buddy_id);
+        }
+        return true;
+}
+
+bool LLCollectMappableBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
+{
+        mFirst[0] = '\0';
+        mLast[0] = '\0';
+        gCacheName->getName(buddy_id, mFirst, mLast);
+        std::ostringstream fullname;
+        fullname << mFirst << " " << mLast;
+        buddy_map_t::value_type value(fullname.str(), buddy_id);
+        if(buddy->isOnline() && buddy->isRightGrantedFrom(LLRelationship::GRANT_MAP_LOCATION))
+        {
+                mMappable.insert(value);
+        }
+        return true;
+}
+
+bool LLCollectOnlineBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
+{
+        mFirst[0] = '\0';
+        mLast[0] = '\0';
+        gCacheName->getName(buddy_id, mFirst, mLast);
+        std::ostringstream fullname;
+        fullname << mFirst << " " << mLast;
+        buddy_map_t::value_type value(fullname.str(), buddy_id);
+        if(buddy->isOnline())
+        {
+                mOnline.insert(value);
+        }
+        return true;
+}
+
+bool LLCollectAllBuddies::operator()(const LLUUID& buddy_id, LLRelationship* buddy)
+{
+        mFirst[0] = '\0';
+        mLast[0] = '\0';
+        gCacheName->getName(buddy_id, mFirst, mLast);
+        std::ostringstream fullname;
+        fullname << mFirst << " " << mLast;
+        buddy_map_t::value_type value(fullname.str(), buddy_id);
+        if(buddy->isOnline())
+        {
+                mOnline.insert(value);
+        }
+        else
+        {
+                mOffline.insert(value);
+        }
+        return true;
+}
+