llfloateravatarlist.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h" // must be first include

#include "llavatarconstants.h"
#include "llfloateravatarlist.h"

#include "llvieweruictrlfactory.h" // builds floaters from XML
#include "llviewerwindow.h"
#include "llscrolllistctrl.h"

#include "llvoavatar.h"
#include "llimview.h"
#include "llfloateravatarinfo.h"
#include "llregionflags.h"
#include "llfloaterreporter.h"
#include "llagent.h"
#include "llviewerregion.h"
#include "lltracker.h"
#include "llviewercontrol.h"
#include "llviewerstats.h"
#include "llerror.h"
#include "llchat.h"
#include "llviewermessage.h"
#include "llweb.h"
#include "llviewerobjectlist.h"
#include "llmutelist.h"

#include <time.h>
#include <string.h>

#include <map>


// Timeouts
const F32 ACTIVITY_TIMEOUT = 1.0f;


const F32 MIN_REQUEST_INTERVAL   = 1.0f;

const F32 FIRST_REQUEST_TIMEOUT  = 16.0f;

const F32 MAX_REQUEST_TIMEOUT    = 2048.0f;
 
const F32 REQUEST_FAIL_TIMEOUT   = 15.0f;

const F32 DEAD_KEEP_TIME = 10.0f;

const F32 CLEANUP_TIMEOUT = 3600.0f;


const S32 TRUSTNET_CHANNEL = 0x44470002;


extern U32 gFrameCount;


LLAvListTrustNetScore::LLAvListTrustNetScore(LLString type, F32 score)
{
        Score = score;
        Type = type;    
}


LLAvatarInfo::LLAvatarInfo()
{
}

LLAvatarInfo::LLAvatarInfo(PAYMENT_TYPE payment, ACCOUNT_TYPE account, struct tm birth)
{
        Payment = payment;
        Account = account;
        BirthDate = birth;
}

S32 LLAvatarInfo::getAge()
{
        time_t birth = mktime(&BirthDate);
        time_t now = time(NULL);
        return(S32)(difftime(now,birth) / (60*60*24));
}

void LLAvatarListEntry::setPosition(LLVector3d position)
{
        if ( mPosition != position )
        {
                setActivity(ACTIVITY_MOVING);
        }
        
        mPosition = position;
        mFrame = gFrameCount;
        mUpdateTimer.start();
}

LLVector3d LLAvatarListEntry::getPosition()
{
        return mPosition;
}

U32 LLAvatarListEntry::getEntryAgeFrames()
{
        return (gFrameCount - mFrame);
}

F32 LLAvatarListEntry::getEntryAgeSeconds()
{
        return mUpdateTimer.getElapsedTimeF32();
}

void LLAvatarListEntry::setName(LLString name)
{
        if ( name.empty() || (name.compare(" ") == 0))
        {
                llwarns << "Trying to set empty name" << llendl;
        }
        mName = name;
}

LLString LLAvatarListEntry::getName()
{
        return mName;
}

LLUUID LLAvatarListEntry::getID()
{
        return mID;
}

void LLAvatarListEntry::setID(LLUUID id)
{
        if ( id.isNull() )
        {
                llwarns << "Trying to set null id" << llendl;
        }
        mID = id;
}

BOOL LLAvatarListEntry::getIsLinden()
{
        // Are there any employees that are not a Linden?
        // I suppose this is a bit redundant.
        return ( mIsLinden || ( mAvatarInfo.getValue().Account == ACCOUNT_EMPLOYEE ) );
}

void LLAvatarListEntry::setAccountCustomTitle(LLString &title)
{
        mAccountTitle = title;
        mAvatarInfo.getValue().Account = ACCOUNT_CUSTOM;
}

LLString LLAvatarListEntry::getAccountCustomTitle()
{
        return mAccountTitle;
}



void LLAvatarListEntry::setActivity(ACTIVITY_TYPE activity)
{
        if ( activity >= mActivityType || mActivityTimer.getElapsedTimeF32() > ACTIVITY_TIMEOUT )
        {
                mActivityType = activity;
                mActivityTimer.start();
        }
}

ACTIVITY_TYPE LLAvatarListEntry::getActivity()
{
        if ( mActivityTimer.getElapsedTimeF32() > ACTIVITY_TIMEOUT )
        {
                mActivityType = ACTIVITY_NONE;
        }
        
        return mActivityType;
}

void LLAvatarListEntry::toggleMark()
{
        mMarked = !mMarked;
}

BOOL LLAvatarListEntry::isMarked()
{
        return mMarked;
}

BOOL LLAvatarListEntry::isDead()
{
        return getEntryAgeSeconds() > DEAD_KEEP_TIME;
}

// Avatar list is global
LLFloaterAvatarList* gFloaterAvatarList = NULL;




LLFloaterAvatarList::LLFloaterAvatarList() :  LLFloater("avatar list")
{

        // Default values
        mTracking = FALSE;
        mTrackByLocation = FALSE;
        mARLastFrame = 0;

        // Create interface from XML
        gUICtrlFactory->buildFloater(this, "floater_avatar_scanner.xml");

        // Floater starts hidden        
        setVisible(FALSE);

        // Set callbacks
        //childSetAction("refresh_btn", onClickRefresh, this);
        childSetAction("profile_btn", onClickProfile, this);
        childSetAction("im_btn", onClickIM, this);
        childSetAction("track_btn", onClickTrack, this);
        childSetAction("mark_btn", onClickMark, this);

        childSetAction("gowarn_btn", onClickGohomerWarn, this);
        childSetAction("goeject_btn", onClickGohomerEject, this);
        childSetAction("goaway_btn", onClickGohomerSendAway, this);
        childSetAction("gohome_btn", onClickGohomerSendHome, this);
        childSetAction("gohomeoff_btn", onClickGohomerOff, this);
        childSetAction("gokey_btn", onClickGohomerSendHomeByKey, this);

        childSetAction("prev_in_list_btn", onClickPrevInList, this);
        childSetAction("next_in_list_btn", onClickNextInList, this);
        childSetAction("prev_marked_btn", onClickPrevMarked, this);
        childSetAction("next_marked_btn", onClickNextMarked, this);
        
        childSetAction("get_key_btn", onClickGetKey, this);

        childSetAction("tn_rate_btn", onClickTrustNetRate, this);
        childSetAction("tn_explain_btn", onClickTrustNetExplain, this);
        childSetAction("tn_website_btn", onClickTrustNetWebsite, this);
        childSetAction("tn_password_btn", onClickTrustNetGetPassword, this);
        childSetAction("tn_renew_btn", onClickTrustNetRenew, this);

        childSetAction("freeze_btn", onClickFreeze, this);
        childSetAction("eject_btn", onClickEject, this);
//      childSetAction("ban_btn", onClickBan, this);
//      childSetAction("unban_btn", onClickUnban, this);
        childSetAction("mute_btn", onClickMute, this);
//      childSetAction("unmute_btn", onClickUnmute, this);
        childSetAction("ar_btn", onClickAR, this);
        childSetAction("teleport_btn", onClickTeleport, this);
        childSetAction("estate_eject_btn", onClickEjectFromEstate, this);

        setDefaultBtn("refresh_btn");

        // Get a pointer to the scroll list from the interface
        mAvatarList = LLUICtrlFactory::getScrollListByName(this, "avatar_list");

        mAvatarList->setCallbackUserData(this);
        mAvatarList->setDoubleClickCallback(onDoubleClick);
        mAvatarList->sortByColumn("distance", TRUE);
        mDataRequestTimer.start();
        refreshAvatarList();

        LLMessageSystem *msg = gMessageSystem;
        msg->addHandlerFunc("AvatarPropertiesReply", processAvatarPropertiesReply);
}

LLFloaterAvatarList::~LLFloaterAvatarList()
{
        LLMessageSystem *msg = gMessageSystem;
        if ( msg )
        {
                msg->delHandlerFunc("AvatarPropertiesReply", processAvatarPropertiesReply);
        }
}


void LLFloaterAvatarList::show()
{
        // Make sure we make a noise.
        open();
}

//static
void LLFloaterAvatarList::toggle(void*) {
        if (!gFloaterAvatarList) {
                llinfos << "No avatar list!" << llendl;
                return;
        }

        if (gFloaterAvatarList->getVisible())
        {
                gFloaterAvatarList->close();
        }
        else
        {
                gFloaterAvatarList->show();
        }
}

//static
BOOL LLFloaterAvatarList::visible(void*)
{
        return (gFloaterAvatarList && gFloaterAvatarList->getVisible());
}

//static
void LLFloaterAvatarList::updateAvatarList()
{
//      LLVOAvatar *avatarp;

        //llinfos << "avatar list refresh: updating map" << llendl;

        // Check whether updates are enabled
        LLCheckboxCtrl* check;
        check = LLUICtrlFactory::getCheckBoxByName(this, "update_enabled_cb");

        if ( !check->getValue() )
        {
                return;
        }

        /*
         * Iterate over all the avatars known at the time
         * NOTE: Is this the right way to do that? It does appear that LLVOAvatar::isInstances contains
         * the list of avatars known to the client. This seems to do the task of tracking avatars without
         * any additional requests.
         *
         * BUG: It looks like avatars sometimes get stuck in this list, and keep perpetually
         * moving in the same direction. My current guess is that somewhere else the client
         * doesn't notice an avatar disappeared, and keeps updating its position. This should
         * be solved at the source of the problem.
         */
        for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
                iter != LLCharacter::sInstances.end(); ++iter)
        {
                LLVOAvatar* avatarp = (LLVOAvatar*) *iter;

                // Skip if avatar is dead(what's that?)
                // or if the avatar is ourselves.
                if (avatarp->isDead() || avatarp->isSelf())
                {
                        continue;
                }

                // Get avatar data
                LLVector3d position = gAgent.getPosGlobalFromAgent(avatarp->getCharacterPosition());
                LLUUID avid = avatarp->getID();
                LLString name = avatarp->getFullname();

                // Apparently, sometimes the name comes out empty, with a " " name. This is because
                // getFullname concatenates first and last name with a " " in the middle.
                // This code will avoid adding a nameless entry to the list until it acquires a name.
                if (name.empty() || (name.compare(" ") == 0))
                {
                        llinfos << "Name empty for avatar " << avid << llendl;
                        continue;
                }

                if (avid.isNull())
                {
                        llinfos << "Key empty for avatar " << name << llendl;
                        continue;
                }

                if ( mAvatars.count( avid ) > 0 )
                {
                        // Avatar already in list, update position
                        mAvatars[avid].setPosition(position);
                }
                else
                {
                        // Avatar not there yet, add it
                        BOOL isLinden = ( avatarp->getNVPair("LastName")->getString() == "Linden" );

                        LLAvatarListEntry entry(avid, name, position, isLinden);
                        mAvatars[avid] = entry;

                        //sendAvatarPropertiesRequest(avid);
                        llinfos << "avatar list refresh: adding " << name << llendl;

                }

        }

//      llinfos << "avatar list refresh: done" << llendl;

        expireAvatarList();
        refreshAvatarList();
        checkTrackingStatus();
        processARQueue();
}

void LLFloaterAvatarList::processARQueue()
{
        if ( mARQueue.empty() ) return;

        LLUUID avatar_id = mARQueue.front();

        if ( 0 == mARLastFrame )
        {
                // Start of the process: Move the camera to the avatar. This happens gradually,
                // so we'll give it a few frames
                gAgent.lookAtObject(avatar_id, CAMERA_POSITION_OBJECT);
                mARLastFrame = gFrameCount;
                return;
        }

        if ( gFrameCount - mARLastFrame >= 10 )
        {
                // Camera should be in position, show AR screen now
                LLFloaterReporter *report = LLFloaterReporter::showFromObject(avatar_id, false);
                report->setMinimized(TRUE);

                mARReporterQueue.push(report);

                mARQueue.pop();
                mARLastFrame = 0;

                if ( mARQueue.empty() )
                {
                        // Now that all reports are taken, open them.

                        while( !mARReporterQueue.empty() )
                        {
                                LLFloaterReporter *r = mARReporterQueue.front();
                                mARReporterQueue.pop();

                                r->open();
                                r->setMinimized(FALSE);
                        }
                }
        }
}

void LLFloaterAvatarList::expireAvatarList()
{
//      llinfos << "avatar list: expiring" << llendl;
        std::map<LLUUID, LLAvatarListEntry>::iterator iter;
        std::queue<LLUUID> delete_queue;

        for(iter = mAvatars.begin(); iter != mAvatars.end(); iter++)
        {
                LLAvatarListEntry *ent = &iter->second;
                
                if ( ent->getEntryAgeFrames() >= 2 )
                {
                        ent->setActivity(ACTIVITY_DEAD);
                }


                if ( ent->getEntryAgeSeconds() > CLEANUP_TIMEOUT )
                {
                        llinfos << "avatar list: expiring avatar " << ent->getName() << llendl;
                        LLUUID av_id = ent->getID();
                        delete_queue.push(av_id);
                }
        }

        while(!delete_queue.empty())
        {
                mAvatars.erase(delete_queue.front());
                delete_queue.pop();
        }
}

void LLFloaterAvatarList::refreshAvatarList() 
{



        // Don't update list when interface is hidden
        if (!LLFloaterAvatarList::visible(NULL))
        {
                return;
        }


        LLCheckboxCtrl* fetch_data;
        fetch_data = LLUICtrlFactory::getCheckBoxByName(this, "fetch_avdata_enabled_cb");

        BOOL db_enabled = gSavedSettings.getBOOL("DBEnabled");
        LLString db_avatar = gSavedPerAccountSettings.getString("DBAvatarName");
        if ( db_avatar.empty() )
        {
                db_enabled = FALSE;
        }



        // We rebuild the list fully each time it's refreshed
        // The assumption is that it's faster to refill it and sort than
        // to rebuild the whole list.
        LLDynamicArray<LLUUID> selected = mAvatarList->getSelectedIDs();
        S32 scrollpos = mAvatarList->getScrollPos();

        mAvatarList->deleteAllItems();

        LLVector3d mypos = gAgent.getPositionGlobal();


        std::map<LLUUID, LLAvatarListEntry>::iterator iter;
        for(iter = mAvatars.begin(); iter != mAvatars.end(); iter++)
        {
                LLSD element;
                LLUUID av_id;

                
                LLAvatarListEntry *ent = &iter->second;

                // Skip if avatar hasn't been around
                if ( ent->isDead() )
                {
                        continue;
                }

                av_id = ent->getID();

                // Get avatar name, position
                LLAvatarInfo avinfo = ent->mAvatarInfo.getValue();
                LLAvListTrustNetScore avscore = ent->mTrustNetScore.getValue();

                DATA_STATUS avinfo_status = ent->mAvatarInfo.getStatus();
                DATA_STATUS avscore_status = ent->mTrustNetScore.getStatus();

                LLVector3d position = ent->getPosition();
                LLVector3d delta = position - mypos;
                F32 distance = (F32)delta.magVec();

                LLString icon = "";

                // HACK: Workaround for an apparent bug:
                // sometimes avatar entries get stuck, and are registered
                // by the client as perpetually moving in the same direction.
                // this makes sure they get removed from the visible list eventually
                if ( distance > 1024 )
                {
                        continue;
                }

                if ( av_id.isNull() )
                {
                        llwarns << "Avatar with null key somehow got into the list!" << llendl;
                        continue;
                }





                element["id"] = av_id;

                element["columns"][LIST_AVATAR_ICON]["column"] = "avatar_icon";
                element["columns"][LIST_AVATAR_ICON]["type"] = "text";
                if ( ent->isMarked() )
                {
                        element["columns"][LIST_AVATAR_ICON]["type"] = "icon";
                        element["columns"][LIST_AVATAR_ICON]["value"] = gViewerArt.getString("flag_blue.tga");
                }


                if ( ent->getIsLinden() )
                {
                        element["columns"][LIST_AVATAR_NAME]["font-style"] = "BOLD";
                }

                if ( ent->isFocused() )
                {
                        element["columns"][LIST_AVATAR_NAME]["color"] = LLColor4::cyan.getValue();
                }

                //element["columns"][LIST_AVATAR_NAME]["font-color"] = getAvatarColor(ent, distance).getValue();
                element["columns"][LIST_AVATAR_NAME]["column"] = "avatar_name";
                element["columns"][LIST_AVATAR_NAME]["type"] = "text";
                element["columns"][LIST_AVATAR_NAME]["value"] = ent->getName().c_str();

                char temp[32];
                snprintf(temp, sizeof(temp), "%.2f", distance);

                element["columns"][LIST_DISTANCE]["column"] = "distance";
                element["columns"][LIST_DISTANCE]["type"] = "text";
                element["columns"][LIST_DISTANCE]["value"] = temp;
                element["columns"][LIST_DISTANCE]["color"] = getAvatarColor(ent, distance, CT_DISTANCE).getValue();

                
                if ( avinfo_status == DATA_RETRIEVED )
                {
                        element["columns"][LIST_AGE]["column"] = "age";
                        element["columns"][LIST_AGE]["type"] = "text";
                        element["columns"][LIST_AGE]["value"] = avinfo.getAge();
                        element["columns"][LIST_AGE]["color"] = getAvatarColor(ent, distance, CT_AGE).getValue();
                }

                element["columns"][LIST_SCORE]["column"] = "score";
                element["columns"][LIST_SCORE]["type"] = "text";

                icon = "";
                switch(avscore_status)
                {
                        case DATA_UNKNOWN:
                                icon = gViewerArt.getString("info_unknown.tga");
                                break;
                        case DATA_REQUESTING:
                                icon = gViewerArt.getString("info_fetching.tga");
                                break;
                        case DATA_ERROR:
                                icon =  gViewerArt.getString("info_error.tga");
                        case DATA_RETRIEVED:
                                element["columns"][LIST_SCORE]["value"] = avscore.Score;
                                element["columns"][LIST_SCORE]["color"] = getAvatarColor(ent, distance, CT_SCORE).getValue();
                                break;
                }
                
                if (!icon.empty() )
                {       
                        element["columns"][LIST_SCORE].erase("color");
                        element["columns"][LIST_SCORE]["type"] = "icon";
                        element["columns"][LIST_SCORE]["value"] = icon;
                }
        

                // Get an icon for the payment data
                // These should be replaced with something proper instead of reusing whatever
                // LL-provided images happened to fit
                icon = "";

                switch(avinfo_status)
                {
                        case DATA_UNKNOWN:
                                icon = gViewerArt.getString("info_unknown.tga");
                                break;
                        case DATA_REQUESTING:
                                icon = gViewerArt.getString("info_fetching.tga");
                                break;
                        case DATA_ERROR:
                                icon =  gViewerArt.getString("info_error.tga");
                                break;
                        case DATA_RETRIEVED:
                                switch(avinfo.Payment)
                                {
                                        case PAYMENT_NONE:
                                                break;
                                        case PAYMENT_ON_FILE:
                                                icon =  gViewerArt.getString("payment_info_filled.tga");
                                                break;
                                        case PAYMENT_USED:
                                                icon =  gViewerArt.getString("payment_info_used.tga");
                                                break;
                                        case PAYMENT_LINDEN:
                                                // confusingly named icon, maybe use something else
                                                icon =  gViewerArt.getString("icon_top_pick.tga");
                                                break;
                                }
                                break;
                }

                element["columns"][LIST_PAYMENT]["column"] = "payment_data";
                element["columns"][LIST_PAYMENT]["type"] = "text";

                // TODO: Add icon for "unknown" status
                //if ( PAYMENT_NONE != avinfo.Payment && DATA_UNKNOWN != avinfo_status )
                if ( !icon.empty() )
                {
                        element["columns"][LIST_PAYMENT].erase("color");
                        element["columns"][LIST_PAYMENT]["type"] = "icon";
                        element["columns"][LIST_PAYMENT]["value"] =  icon;
                        //llinfos << "Payment icon: " << payment_icon << llendl;
                }

                
                ACTIVITY_TYPE activity = ent->getActivity();
                icon = "";
                switch( activity )
                {
                        case ACTIVITY_NONE:
                                break;
                        case ACTIVITY_MOVING:
                                icon = gViewerArt.getString("inv_item_animation.tga");
                                break;
                        case ACTIVITY_GESTURING:
                                icon = gViewerArt.getString("inv_item_gesture.tga");
                                break;
                        case ACTIVITY_SOUND:
                                icon = gViewerArt.getString("inv_item_sound.tga");
                                break;
                        case ACTIVITY_REZZING:
                                icon = gViewerArt.getString("ff_edit_theirs.tga");
                                break;
                        case ACTIVITY_PARTICLES:
                                // TODO: Replace with something better
                                icon = gViewerArt.getString("account_id_blue.tga");
                                break;
                        case ACTIVITY_NEW:
                                icon = gViewerArt.getString("avatar_new.tga");
                                break;
                        case ACTIVITY_TYPING:
                                icon = gViewerArt.getString("avatar_typing.tga");
                                break;
                        case ACTIVITY_DEAD:
                                // TODO: Replace, icon is quite inappropiate
                                icon = gViewerArt.getString("avatar_gone.tga");
                                break;
                }

                element["columns"][LIST_ACTIVITY]["column"] = "activity";
                element["columns"][LIST_ACTIVITY]["type"] = "text";

                if (!icon.empty() )
                {       
                        element["columns"][LIST_ACTIVITY]["type"] = "icon";
                        element["columns"][LIST_ACTIVITY]["value"] = icon;
                        //llinfos << "Activity icon: " << activity_icon << llendl;
                }
                

                // Add to list
                mAvatarList->addElement(element, ADD_BOTTOM);

                // Request data only if fetching avatar data is enabled
                if ( fetch_data->getValue() && ent->mAvatarInfo.requestIfNeeded() )
                {
                        sendAvatarPropertiesRequest(av_id);
                        llinfos << "Data for avatar " << ent->getName() << " didn't arrive yet, retrying" << llendl;
                }

                if ( ent->mTrustNetScore.requestIfNeeded() )
                {
                        requestTrustNetScore(av_id, ent->getName(), "behavior");
                        llinfos << "Requesting TrustNet score for " << ent->getName() << llendl;
                }
                
                if ( db_enabled && ent->mMiscInfo.requestIfNeeded() )
                {
                        requestMiscInfo(av_id, ent->getName());
                        llinfos << "Requesting misc info for " << ent->getName() << llendl;
                }
        }

        // finish
        mAvatarList->sort();
        mAvatarList->selectMultiple(selected);
        mAvatarList->setScrollPos(scrollpos);

//      llinfos << "avatar list refresh: done" << llendl;

}

// static
void LLFloaterAvatarList::onClickIM(void* userdata)
{
        //llinfos << "LLFloaterFriends::onClickIM()" << llendl;
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;

        LLDynamicArray<LLUUID> ids = avlist->mAvatarList->getSelectedIDs();
        if(ids.size() > 0)
        {
                if(ids.size() == 1)
                {
                        // Single avatar
                        LLUUID agent_id = ids[0];

                        char buffer[MAX_STRING];
                        snprintf(buffer, MAX_STRING, "%s", avlist->mAvatars[agent_id].getName().c_str());
                        gIMMgr->setFloaterOpen(TRUE);
                        gIMMgr->addSession(
                                buffer,
                                IM_NOTHING_SPECIAL,
                                agent_id);
                }
                else
                {
                        // Group IM
                        LLUUID session_id;
                        session_id.generate();
                        gIMMgr->setFloaterOpen(TRUE);
                        gIMMgr->addSession("Avatars Conference", IM_SESSION_CONFERENCE_START, ids[0], ids);
                }
        }
}

void LLFloaterAvatarList::onClickTrack(void *userdata)
{
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
        
        LLScrollListItem *item =   avlist->mAvatarList->getFirstSelected();
        if (!item) return;

        LLUUID agent_id = item->getUUID();

        if ( avlist->mTracking && avlist->mTrackedAvatar == agent_id ) {
                LLTracker::stopTracking(NULL);
                avlist->mTracking = FALSE;
        }
        else
        {
                avlist->mTracking = TRUE;
                avlist->mTrackByLocation = FALSE;
                avlist->mTrackedAvatar = agent_id;
                LLTracker::trackAvatar(agent_id, avlist->mAvatars[agent_id].getName());
        }
}

void LLFloaterAvatarList::sendAvatarPropertiesRequest(LLUUID avid)
{
        

        lldebugs << "LLPanelAvatar::sendAvatarPropertiesRequest()" << llendl; 
        LLMessageSystem *msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_AvatarPropertiesRequest);
        msg->nextBlockFast( _PREHASH_AgentData);
        msg->addUUIDFast(   _PREHASH_AgentID, gAgent.getID() );
        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
        msg->addUUIDFast(   _PREHASH_AvatarID, avid);
        gAgent.sendReliableMessage();

        mAvatars[avid].mAvatarInfo.requestStarted();
}

// static
void LLFloaterAvatarList::processAvatarPropertiesReply(LLMessageSystem *msg, void**)
{

        
        LLFloaterAvatarList* self = NULL;
        LLAvatarInfo avinfo;

        BOOL    identified = FALSE;
        BOOL    transacted = FALSE;

        LLUUID  agent_id;       // your id
        LLUUID  avatar_id;      // target of this panel
        U32     flags = 0x0;
        char    born_on[DB_BORN_BUF_SIZE];
        S32     charter_member_size = 0;

        msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
        msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AvatarID, avatar_id );

        
        self = gFloaterAvatarList;

        // Verify that the avatar is in the list, if not, ignore.
        if ( self->mAvatarList->getItemIndex(avatar_id) < 0 )
        {
                return;
        }

        LLAvatarListEntry *entry = &self->mAvatars[avatar_id];

        msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_BornOn, DB_BORN_BUF_SIZE, born_on);
        msg->getU32Fast(_PREHASH_PropertiesData, _PREHASH_Flags, flags);

        identified = (flags & AVATAR_IDENTIFIED);
        transacted = (flags & AVATAR_TRANSACTED);

        // What's this?
        // Let's see if I understand correctly: CharterMember property is dual purpose:
        // it either contains a number indicating an account type (usual value), or 
        // it contains a string with a custom title. Probably that's where Philip Linden's
        // "El Presidente" title comes from. Heh.
        U8 caption_index = 0;
        LLString caption_text;
        charter_member_size = msg->getSize("PropertiesData", "CharterMember");

        if(1 == charter_member_size)
        {
                msg->getBinaryData("PropertiesData", "CharterMember", &caption_index, 1);
        }
        else if(1 < charter_member_size)
        {
                char caption[MAX_STRING];
                msg->getString("PropertiesData", "CharterMember", MAX_STRING, caption);

                caption_text = caption;
                entry->setAccountCustomTitle(caption_text);
        }
                

        if(caption_text.empty())
        {
                
                const enum ACCOUNT_TYPE ACCT_TYPE[] = {
                        ACCOUNT_RESIDENT,
                        ACCOUNT_TRIAL,
                        ACCOUNT_CHARTER_MEMBER,
                        ACCOUNT_EMPLOYEE
                };

                //enum ACCOUNT_TYPE acct =
                avinfo.Account =  ACCT_TYPE[llclamp(caption_index, (U8)0, (U8)(sizeof(ACCT_TYPE)/sizeof(ACCT_TYPE[0])-1))];
                //entry->setAccountType(acct);

                
                if ( avinfo.Account != ACCOUNT_EMPLOYEE )
                {
                        if ( transacted )
                        {
                                avinfo.Payment = PAYMENT_USED;
                        }
                        else if ( identified )
                        {
                                avinfo.Payment = PAYMENT_ON_FILE;
                        }
                        else
                        {
                                avinfo.Payment = PAYMENT_NONE;
                        }
                }
                else
                {
                        avinfo.Payment = PAYMENT_LINDEN;
                }
        }
        
        // Structure must be zeroed to have sane results, as we
        // have an incomplete string for input
        memset(&avinfo.BirthDate, 0, sizeof(avinfo.BirthDate));

        int num_read = sscanf(born_on, "%d/%d/%d", &avinfo.BirthDate.tm_mon,
                                                   &avinfo.BirthDate.tm_mday,
                                                   &avinfo.BirthDate.tm_year);

        if ( num_read == 3 && avinfo.BirthDate.tm_mon <= 12 )
        {
                avinfo.BirthDate.tm_year -= 1900;
                avinfo.BirthDate.tm_mon--;
        }
        else
        {
                // Zero again to remove any partially read data
                memset(&avinfo.BirthDate, 0, sizeof(avinfo.BirthDate));
                llwarns << "Error parsing birth date: " << born_on << llendl;
        }

        entry->mAvatarInfo.setValue(avinfo);
}

void LLFloaterAvatarList::checkTrackingStatus()
{

        if ( mTracking && LLTracker::getTrackedPositionGlobal().isExactlyZero() )
        {
                // trying to track an avatar, but tracker stopped tracking              
                if ( mAvatars.count( mTrackedAvatar ) > 0 && !mTrackByLocation )
                {
                        llinfos << "Switching to location-based tracking" << llendl;
                        mTrackByLocation = TRUE;
                }
                else
                {
                        // not found
                        llinfos << "Stopping tracking avatar, server-side didn't work, and not in list anymore." << llendl;
                        LLTracker::stopTracking(NULL);
                        mTracking = FALSE;
                }
        }

        if ( mTracking && mTrackByLocation )
        {
                LLString name = mAvatars[mTrackedAvatar].getName();
                LLString tooltip = "Tracking last known position";
                name += " (near)";
                LLTracker::trackLocation(mAvatars[mTrackedAvatar].getPosition(), name, tooltip);
        }

        //llinfos << "Tracking position: " << LLTracker::getTrackedPositionGlobal() << llendl;
        
}


BOOL  LLFloaterAvatarList::avatarIsInList(LLUUID avatar)
{
        return ( mAvatars.count( avatar ) > 0 );
}

LLAvatarListEntry * LLFloaterAvatarList::getAvatarEntry(LLUUID avatar)
{
        if ( avatar.isNull() )
        {
                return NULL;
        }

        std::map<LLUUID, LLAvatarListEntry>::iterator iter;

        iter = mAvatars.find(avatar);
        if ( iter == mAvatars.end() )
        {
                return NULL;
        }

        return &iter->second;   
        
        //if ( mAvatars.count( avatar ) < 0 )
        //{
                //return NULL;
        //}

        //return &mAvatars[avatar];
}

void LLFloaterAvatarList::speakText(S32 channel, EChatType type, LLString text)
{
        LLMessageSystem* msg = gMessageSystem;

        msg->newMessageFast(_PREHASH_ChatFromViewer);
        msg->nextBlockFast(_PREHASH_AgentData);
        msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
        msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
        msg->nextBlockFast(_PREHASH_ChatData);
        msg->addStringFast(_PREHASH_Message, text);
        msg->addU8Fast(_PREHASH_Type, type);
        msg->addS32("Channel", channel);

        gAgent.sendReliableMessage();

        gViewerStats->incStat(LLViewerStats::ST_CHAT_COUNT);
}


void LLFloaterAvatarList::requestTrustNetScore(LLUUID avatar, const LLString name, const LLString type)
{
        char *temp = new char[UUID_STR_LENGTH];
        avatar.toString(temp);

        LLString text = "GetScore|" + name + "|" + temp + "|" + type;
        speakText(TRUSTNET_CHANNEL, CHAT_TYPE_WHISPER, text);
}

//static
void LLFloaterAvatarList::replaceVars(LLString &str, LLUUID avatar, const LLString& name)
{
        char *temp = new char[UUID_STR_LENGTH];
        avatar.toString(temp);

        LLString vars[][2] = {
                {"$NAME", name},
                {"$KEY",  temp},
        };

        BOOL replaced = TRUE;

        while( replaced )
        {
                replaced = FALSE;
                for(U32 i=0;i<sizeof(vars)/sizeof(vars[0]);i++)
                {
                        U32 pos = str.find(vars[i][0]);
                        if ( pos != std::string::npos )
                        {
                                str.replace(pos, vars[i][0].size(), vars[i][1]);
                                replaced = TRUE;
                        }
                }
        }

}

void LLFloaterAvatarList::requestMiscInfo(LLUUID avatar, const LLString name)
{
        LLUUID   db_av_key;

        LLString message      = gSavedPerAccountSettings.getString("DBSendPattern");
        LLString db_av_name   = gSavedPerAccountSettings.getString("DBAvatarName");
        db_av_key.set(gSavedPerAccountSettings.getString("DBAvatarKey"));

        
        llinfos << "Requesting info " << llendl;
        replaceVars(message, avatar, name);

        llinfos << "Request string: " << message << llendl;
        send_simple_im(db_av_key, message.c_str());
 }

//static
BOOL LLFloaterAvatarList::handleIM(LLUUID from_id, const LLString message)
{
        LLUUID   db_av_key;
        db_av_key.set(gSavedPerAccountSettings.getString("DBAvatarKey"));

        if ( db_av_key == from_id )
        {
                std::map<LLUUID, LLAvatarListEntry>::iterator iter;

                for(iter = gFloaterAvatarList->mAvatars.begin(); iter != gFloaterAvatarList->mAvatars.end(); iter++)
                {
                        LLAvatarListEntry *ent = &iter->second;
                
                        // Check if the key, or the name are found in the reply.
                        // Name is only accepted if it's in the beginning of the message.
                        if ( message.find(ent->getID().asString()) != std::string::npos
                             || message.find(ent->getName().c_str()) == 0 )
                        {
                                LLMiscDBInfo info;
                                info.data = message;

                                llinfos << "Database reply arrived for avatar " << ent->getName() << llendl;
                                ent->mMiscInfo.setValue(info);
                        }
                }

                return TRUE;
        }
        return FALSE;
}

//static
void LLFloaterAvatarList::processTrustNetReply(char *reply)
{
        char *tokens[10];
        char *tmp = &reply[0];
        U32 count = 0;

        llinfos << "TrustNet reply: " << reply << llendl;
        

        // Split into tokens
        while( (NULL != (tmp = strtok(tmp, "|"))) && count < (sizeof(tokens)/sizeof(tokens[0])) )
        {
                tokens[count++] = tmp;
                llinfos << "token: " << tmp << llendl;
                tmp = NULL;
        }

        llinfos << "Got " << count << " tokens" << llendl;

        if ( count >= 1 )
        {
                if (!strcmp(tokens[0], "Score") && count >= 4)
                {
                        //format: key|type|score
                        LLUUID avatar(tokens[1]);
                        LLString type = tokens[2];
                        F32 score = (F32)strtod(tokens[3], NULL);
                        
                        LLAvatarListEntry *ent = gFloaterAvatarList->getAvatarEntry(avatar);
                        if ( ent != NULL )
                        {
                                LLAvListTrustNetScore s(type, score);
                                ent->mTrustNetScore.setValue(s);
                                llinfos << "Score arrived for avatar " << avatar << ": " << score << llendl;
                        }
                        else
                        {
                                llinfos << "Score arrived for avatar " << avatar << ", but it wasn't in the list anymore" << llendl;
                        }
                }
                else if (!strcmp(tokens[0], "WebAuthToken") && count >= 2)
                {
                        LLString URL = LLWeb::escapeURL(llformat("http://trustnet.daleglass.net/?session=%s", tokens[1]));
                        LLWeb::loadURL(URL);
                }
                else if (!strcmp(tokens[0], "WebPassword") && count >= 2)
                {
                        LLString password = tokens[1];
                        gViewerWindow->mWindow->copyTextToClipboard(utf8str_to_wstring(password));
                }
                else
                {
                        llwarns << "Unrecognized TrustNet reply " << tokens[0] << llendl;
                }
        }
}

void LLFloaterAvatarList::luskwoodCommand(LLString cmd)
{
        LLDynamicArray<LLUUID> ids = mAvatarList->getSelectedIDs();

        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID avid = *itr;
                LLAvatarListEntry *ent = getAvatarEntry(avid);
                if ( ent != NULL )
                {
                        //llinfos << "Would say: " << cmd << " " << ent->getName() << llendl;
                        // Use key got gokey, name for everything else
                        speakText(0, CHAT_TYPE_SHOUT, cmd + " " + ( cmd == "gokey" ? ent->getID().asString() :  ent->getName() ) );
                }
        }
}

//static
void LLFloaterAvatarList::onClickMark(void *userdata)
{
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
        LLDynamicArray<LLUUID> ids = avlist->mAvatarList->getSelectedIDs();

        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID avid = *itr;
                LLAvatarListEntry *ent = avlist->getAvatarEntry(avid);
                if ( ent != NULL )
                {
                        ent->toggleMark();
                }
        }
}

void LLFloaterAvatarList::handleLuskwoodDialog(S32 option, void* data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;
        if ( 0 == option )
        {
                self->luskwoodCommand(self->mLuskwoodCommand);
        }
}

void LLFloaterAvatarList::handleLuskwoodGohomerOffDialog(S32 option, void* data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;
        if ( 0 == option )
        {
                self->speakText(0, CHAT_TYPE_SHOUT, "gohome off");
        }
}

//static
void LLFloaterAvatarList::onClickGohomerWarn(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        self->mLuskwoodCommand = "gowarn";
        gViewerWindow->alertXml("LuskwoodGohomerWarn", handleLuskwoodDialog, self);

}

//static
void LLFloaterAvatarList::onClickGohomerEject(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        self->mLuskwoodCommand = "goeject";
        gViewerWindow->alertXml("LuskwoodGohomerEject", handleLuskwoodDialog, self);
}

//static
void LLFloaterAvatarList::onClickGohomerSendAway(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        self->mLuskwoodCommand = "goaway";
        gViewerWindow->alertXml("LuskwoodGohomerKeepAway", handleLuskwoodDialog, self);
}

//static
void LLFloaterAvatarList::onClickGohomerSendHome(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        self->mLuskwoodCommand = "gohome";
        gViewerWindow->alertXml("LuskwoodGohomerSendHome", handleLuskwoodDialog, self);
}

//static
void LLFloaterAvatarList::onClickGohomerSendHomeByKey(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        self->mLuskwoodCommand = "gokey";
        gViewerWindow->alertXml("LuskwoodGohomerSendHome", handleLuskwoodDialog, self);
}


//static
void LLFloaterAvatarList::onClickGohomerOff(void *data)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)data;

        gViewerWindow->alertXml("LuskwoodGohomerOff", handleLuskwoodGohomerOffDialog, self);
}

LLColor4 LLFloaterAvatarList::getAvatarColor(LLAvatarListEntry *ent, F32 distance, e_coloring_type type)
{
        F32 r = 0.0f, g = 0.0f, b = 0.0f, a = 1.0f;

        switch(type)
        {
                case CT_NONE:
                        return LLColor4::black;
                        break;
                case CT_DISTANCE:
                        if ( distance <= 10.0f )
                        {
                                // whisper range
                                g = 0.7f - ( distance / 20.0f );
                        }
                        else if ( distance > 10.0f && distance <= 20.0f )
                        {
                                // talk range
                                g = 0.7f - ( (distance - 10.0f) / 20.0f );
                                b = g;
                        }
                        else if ( distance > 20.0f && distance <= 96.0f )
                        {
                                // shout range
                                r = 0.7f - ( (distance - 20.0f) / 192.0f );
                                b = r;
                        }
                        else
                        {
                                // unreachable by chat
                                r = 1.0;
                        }
                        break;
                case CT_AGE:
                        if ( ent->mAvatarInfo.getStatus() == DATA_RETRIEVED )
                        {
                                S32 age = ent->mAvatarInfo.getValue().getAge();
                                if ( age < 14 )
                                {
                                        r = 0.7f - ( age / 28 );
                                }
                                else if ( age > 14 && age <= 30 )
                                {
                                        r = 0.7f - ( (age-14) / 32 );
                                        g = r;
                                }
                                else if ( age > 30 && age < 90 )
                                {
                                        g = 0.7f - ( (age-30) / 120 );
                                }
                                else
                                {
                                        b = 1.0f;
                                }
                        }
                        break;
                case CT_SCORE:
                        if ( ent->mTrustNetScore.getStatus() == DATA_RETRIEVED )
                        {
                                F32 score = ent->mTrustNetScore.getValue().Score;

                                if ( score == 0.0 )
                                {
                                        b = 1.0f;
                                }
                                else if ( score == 10.0f )
                                {
                                        g = 1.0f;
                                }
                                else if ( score == -10.0f )
                                {
                                        r = 1.0f;
                                }
                                else if ( score > 0.0f )
                                {
                                        g = 0.2f + ( score / 20.0f );
                                }
                                else if ( score < 0.0f )
                                { 
                                        r = 0.2f + ( score / 20.0f );
                                }
                        }
                        break;
                case CT_PAYMENT:
                        break;
        }

        return LLColor4(r,g,b,a);
}

void LLFloaterAvatarList::onDoubleClick(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        LLScrollListItem *item =   self->mAvatarList->getFirstSelected();
        LLUUID agent_id = item->getUUID();

        gAgent.lookAtObject(agent_id, CAMERA_POSITION_OBJECT);
}

void LLFloaterAvatarList::removeFocusFromAll()
{
        std::map<LLUUID, LLAvatarListEntry>::iterator iter;

        for(iter = mAvatars.begin(); iter != mAvatars.end(); iter++)
        {
                LLAvatarListEntry *ent = &iter->second;
                ent->setFocus(FALSE);
        }
}

void LLFloaterAvatarList::focusOnPrev(BOOL marked_only)
{
        std::map<LLUUID, LLAvatarListEntry>::iterator iter;
        LLAvatarListEntry *prev = NULL;
        LLAvatarListEntry *ent;

        if ( mAvatars.size() == 0 )
        {
                return;
        }

        for(iter = mAvatars.begin(); iter != mAvatars.end(); iter++)
        {
                ent = &iter->second;

                if ( ent->isDead() )
                        continue;

                if ( (ent->getID() == mFocusedAvatar) && (prev != NULL)  )
                {
                        removeFocusFromAll();
                        prev->setFocus(TRUE);
                        mFocusedAvatar = prev->getID();
                        gAgent.lookAtObject(mFocusedAvatar, CAMERA_POSITION_OBJECT);
                        return;
                }

                if ( (!marked_only) || ent->isMarked() )
                {
                        prev = ent;
                }
        }

        if (prev != NULL && ((!marked_only) || prev->isMarked()) )
        {
                removeFocusFromAll();
                prev->setFocus(TRUE);
                mFocusedAvatar = prev->getID();
                gAgent.lookAtObject(mFocusedAvatar, CAMERA_POSITION_OBJECT);
        }
}

void LLFloaterAvatarList::focusOnNext(BOOL marked_only)
{

        
        std::map<LLUUID, LLAvatarListEntry>::iterator iter;
        BOOL found = FALSE;
        LLAvatarListEntry *first = NULL;
        LLAvatarListEntry *ent;

        if ( mAvatars.size() == 0 )
        {
                return;
        }

        for(iter = mAvatars.begin(); iter != mAvatars.end(); iter++)
        {
                ent = &iter->second;

                if ( ent->isDead() )
                        continue;

                if ( NULL == first && ((!marked_only) || ent->isMarked()))
                {
                        first = ent;
                }

                if ( found && ((!marked_only) || ent->isMarked()) )
                {
                        removeFocusFromAll();
                        ent->setFocus(TRUE);
                        mFocusedAvatar = ent->getID();
                        gAgent.lookAtObject(mFocusedAvatar, CAMERA_POSITION_OBJECT);
                        return;
                }

                if ( ent->getID() == mFocusedAvatar )
                {
                        found = TRUE;
                } 
        }

        if (first != NULL && ((!marked_only) || first->isMarked()))
        {
                removeFocusFromAll();
                first->setFocus(TRUE);
                mFocusedAvatar = first->getID();
                gAgent.lookAtObject(mFocusedAvatar, CAMERA_POSITION_OBJECT);
        }
}
//static
void LLFloaterAvatarList::onClickPrevInList(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        self->focusOnPrev(FALSE);
}

//static
void LLFloaterAvatarList::onClickNextInList(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        self->focusOnNext(FALSE);
}

//static
void LLFloaterAvatarList::onClickPrevMarked(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        self->focusOnPrev(TRUE);
}

//static
void LLFloaterAvatarList::onClickNextMarked(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        self->focusOnNext(TRUE);
}

//static
void LLFloaterAvatarList::onClickTrustNetRate(void *userdata)
{
        // LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        llinfos << "Ratings not implemented yet" << llendl;
}

//static
void LLFloaterAvatarList::onClickTrustNetExplain(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        LLScrollListItem *item =   self->mAvatarList->getFirstSelected();

        if ( item != NULL )
        {
                LLAvatarListEntry *ent = self->getAvatarEntry(item->getUUID());
                self->speakText(TRUSTNET_CHANNEL, CHAT_TYPE_WHISPER, "Explain|" + ent->getName() + "|" + ent->getID().asString());
        }
}

//static
void LLFloaterAvatarList::onClickTrustNetWebsite(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;

        self->speakText(TRUSTNET_CHANNEL, CHAT_TYPE_WHISPER, "GetWebAuthToken");
}

//static
void LLFloaterAvatarList::onClickTrustNetGetPassword(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;

        self->speakText(TRUSTNET_CHANNEL, CHAT_TYPE_WHISPER, "GetWebPassword");
}

//static
void LLFloaterAvatarList::onClickTrustNetRenew(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        self->speakText(TRUSTNET_CHANNEL, CHAT_TYPE_WHISPER, "RenewSubscription");
}

//static
void LLFloaterAvatarList::onClickGetKey(void *userdata)
{
        LLFloaterAvatarList *self = (LLFloaterAvatarList*)userdata;
        LLScrollListItem *item = self->mAvatarList->getFirstSelected();

        if ( NULL == item ) return;

        LLUUID agent_id = item->getUUID();

        char buffer[UUID_STR_LENGTH];           /*Flawfinder: ignore*/
        agent_id.toString(buffer);

        gViewerWindow->mWindow->copyTextToClipboard(utf8str_to_wstring(buffer));
}


static void send_freeze(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 send_eject(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 send_estate_message(
        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 send_estate_ban(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();
}

static void cmd_freeze(const LLUUID& avatar, const LLString &name)      { send_freeze(avatar, true); }
static void cmd_unfreeze(const LLUUID& avatar, const LLString &name)    { send_freeze(avatar, false); }
static void cmd_eject(const LLUUID& avatar, const LLString &name)       { send_eject(avatar, false); }
static void cmd_ban(const LLUUID& avatar, const LLString &name)         { send_eject(avatar, true); }
static void cmd_profile(const LLUUID& avatar, const LLString &name)     { LLFloaterAvatarInfo::showFromDirectory(avatar); }
static void cmd_mute(const LLUUID&avatar, const LLString &name)         { gMuteListp->add(LLMute(avatar, name, LLMute::AGENT)); }
static void cmd_unmute(const LLUUID&avatar, const LLString &name)       { gMuteListp->remove(LLMute(avatar, name, LLMute::AGENT)); }
static void cmd_estate_eject(const LLUUID &avatar, const LLString &name){ send_estate_message("teleporthomeuser", avatar); }
static void cmd_estate_ban(const LLUUID &avatar, const LLString &name)
{
        send_estate_message("teleporthomeuser", avatar); // Kick first, just to be sure
        send_estate_ban(avatar);
}

void LLFloaterAvatarList::doCommand(void (*func)(const LLUUID &avatar, const LLString &name))
{
        LLDynamicArray<LLUUID> ids = mAvatarList->getSelectedIDs();

        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID avid = *itr;
                LLAvatarListEntry *ent = getAvatarEntry(avid);
                if ( ent != NULL )
                {
                        llinfos << "Executing command on " << ent->getName() << llendl;
                        func(avid, ent->getName());
                }
        }
}

LLString LLFloaterAvatarList::getSelectedNames(const LLString& separator)
{
        LLString ret = "";
        
        LLDynamicArray<LLUUID> ids = mAvatarList->getSelectedIDs();
        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID avid = *itr;
                LLAvatarListEntry *ent = getAvatarEntry(avid);
                if ( ent != NULL )
                {
                        if (!ret.empty()) ret += separator;
                        ret += ent->getName();
                }
        }

        return ret;
}

//static 
void LLFloaterAvatarList::callbackFreeze(S32 option, void *userdata) { 
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;

        if ( option == 0 )
        {
                avlist->doCommand(cmd_freeze);
        }
        else if ( option == 1 )
        {
                avlist->doCommand(cmd_unfreeze);
        }
}

//static 
void LLFloaterAvatarList::callbackEject(S32 option, void *userdata) {
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
 
        if ( option == 0 )
        {
                avlist->doCommand(cmd_eject);
        }
        else if ( option == 1 )
        {
                avlist->doCommand(cmd_ban);
        }
}

//static 
void LLFloaterAvatarList::callbackMute(S32 option, void *userdata) {
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;

        if ( option == 0 )
        {
                avlist->doCommand(cmd_mute);
        } 
        else if ( option == 1 )
        {
                avlist->doCommand(cmd_unmute);
        }
}

//static 
void LLFloaterAvatarList::callbackEjectFromEstate(S32 option, void *userdata) {
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;

        if ( option == 0 )
        {
                avlist->doCommand(cmd_estate_eject);
        } 
        else if ( option == 1 )
        {
                avlist->doCommand(cmd_estate_ban);
        }
}

//static
void LLFloaterAvatarList::onClickFreeze(void *userdata)
{
        LLStringBase<char>::format_map_t args;
        args["[NAMES]"] = ((LLFloaterAvatarList*)userdata)->getSelectedNames();
        gViewerWindow->alertXml("AvatarListFreezeAvatars", args, callbackFreeze, userdata);
}

//static
void LLFloaterAvatarList::onClickEject(void *userdata)
{
        LLStringBase<char>::format_map_t args;
        args["[NAMES]"] = ((LLFloaterAvatarList*)userdata)->getSelectedNames();
        gViewerWindow->alertXml("AvatarListEjectAvatars", args, callbackEject, userdata);
}

//static
void LLFloaterAvatarList::onClickMute(void *userdata)
{
        LLStringBase<char>::format_map_t args;
        args["[NAMES]"] = ((LLFloaterAvatarList*)userdata)->getSelectedNames();
        gViewerWindow->alertXml("AvatarListMuteAvatars", args, callbackMute, userdata);
}

//static
void LLFloaterAvatarList::onClickEjectFromEstate(void *userdata)
{
        LLStringBase<char>::format_map_t args;
        args["[NAMES]"] = ((LLFloaterAvatarList*)userdata)->getSelectedNames();
        gViewerWindow->alertXml("AvatarListEjectAvatarsFromEstate", args, callbackEjectFromEstate, userdata);
}



//static
void LLFloaterAvatarList::onClickAR(void *userdata)
{
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
        LLDynamicArray<LLUUID> ids = avlist->mAvatarList->getSelectedIDs();

        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID avid = *itr;
                llinfos << "Adding " << avid << " to AR queue" << llendl;
                avlist->mARQueue.push( avid );
        }
}

// static
void LLFloaterAvatarList::onClickProfile(void* userdata)
{
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
        avlist->doCommand(cmd_profile);
}

//static
void LLFloaterAvatarList::onClickTeleport(void* userdata)
{
        LLFloaterAvatarList *avlist = (LLFloaterAvatarList*)userdata;
        LLScrollListItem *item =   avlist->mAvatarList->getFirstSelected();

        if ( item )
        {
                LLUUID agent_id = item->getUUID();
                LLAvatarListEntry *ent = avlist->getAvatarEntry(agent_id);
                
                if ( ent )
                {
                        llinfos << "Trying to teleport to " << ent->getName() << " at " << ent->getPosition() << llendl;
                        gAgent.teleportViaLocation( ent->getPosition() );
                }
        }
}

---