llfloatereventlog.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"
#include "llfloatereventlog.h"

#include "llvieweruictrlfactory.h" // builds floaters from XML
#include "llviewerwindow.h"
#include "llscrolllistctrl.h"
#include "viewer.h"
#include "llagent.h"
#include "llpartdata.h"
#include "llfloateravatarinfo.h"
#include "llmutelist.h"
#include "lltracker.h"
#include "llviewerregion.h"
#include "llviewerobject.h"
#include "llviewerpartsource.h"
#include "lltextbox.h"
#include "audioengine.h"
#include <iostream>
#include <vector>
#include <algorithm>


// TODO
// Angel Fluffy:
//      1) cols need to be narrower
//      2) score needs to be the 2nd col
//      3) you need to be able to right click the key and copy it
//      5) you need headers to make numbers readable (what does 'distance' mean, for example?
//      8) perhaps a toggle to list all objects owned by avatars under the avatar's name, without doing individual objects? 
//      9) I know that but I think you need to color-code it so that people don't go "is >10 a griefer? >100? >1000? >10,000?" the numbers are... less good.
//      10) Those boxes need to be clearly marked so that you know what they are
//          e.g. "Textures by score" with "#1" and "#2" and "#3" below them
//
// Michi Lumin:
//      1) gohome button
//
// DONE:
// Thomas Shikami: 
//      1) add a bonus at that z-bouncing types
//
// NOT POSSIBLE/INCORRECT
//      6) the blue button needs a purpose 
//      7) if the particle texture has a name, then it would be great to show the name too



LLFloaterEventLog *gFloaterEventLog = NULL;

/*************************************************************************
* Events
*************************************************************************/

void LLWorldEvent::incCount(S32 count)
{
        if ( mLastFrame != gFrameCount )
        {
                mAgeTimer.reset();
                mDuration += mDurationTimer.getElapsedTimeAndResetF32();
                mLastFrame = gFrameCount;
        }

        mCount += count;
}

LLParticleEvent::LLParticleEvent(const LLPartSysData &data)
{
        mTexture = data.mPartImageID;
}

S32 LLParticleEvent::getScore() const
{

        // Extra score for being bouncy
        F32 bounce_factor = 1.0f;
        if ( mPartSysData.mPartData.mFlags & LLPartData::LL_PART_BOUNCE_MASK )
                bounce_factor = 1.5f;

        // TODO: Add bonus for bouncing
        return (S32)(mPartSysData.mBurstPartCount *
               ( 1 + mPartSysData.mPartData.mMaxAge ) *
               ( 1 / mPartSysData.mBurstRate ) *
               ( 1 + mPartSysData.mPartData.mStartScale.magVec() + 
                     mPartSysData.mPartData.mEndScale.magVec() ) *
                     bounce_factor );
}


/*************************************************************************
* Emitters
*************************************************************************/

LLAvatarOwnedEmitter::LLAvatarOwnedEmitter(const LLUUID& id, const LLString& name)
{
        mNamePending = false;
        setOwner(id, name);

}

void LLAvatarOwnedEmitter::setOwner(const LLUUID &id, const LLString &name)
{
        mOwnerID = id;
        mOwnerName = name;
}

void LLAvatarOwnedEmitter::update()
{
        if ( mOwnerName.empty() && !mNamePending )
        {
                llinfos << "Requesting name for id " << mOwnerID << llendl;
                mNamePending = true;
                gCacheName->get( mOwnerID, FALSE, nameLookupCallback, this );
        }
}

// static
void LLAvatarOwnedEmitter::nameLookupCallback(const LLUUID&id, const char *first, const char *last, BOOL group, void *userdata)
{
        if ( first && last && !id.isNull())
        {
                

                LLAvatarOwnedEmitter *em = (LLAvatarOwnedEmitter*)userdata;

                LLString name;

                name += first;
                name += " ";
                name += last;
        
                llinfos << "Setting name for id " << em->mOwnerID << " to " << name << llendl;
//              em->mOwnerID = id;
                em->mOwnerName = name;
                em->mNamePending = false;
        }
}

LLAvatarOwnedEmitter::~LLAvatarOwnedEmitter()
{
        if ( mNamePending && gCacheName )
        {
                gCacheName->cancelCallback( mOwnerID, nameLookupCallback, this );
        }
}

LLObjectEmitter::LLObjectEmitter(const LLUUID& id, const LLUUID &owner)
{
        mRequestedProperties = false;

        setOwner(owner);
        setObject(id);
}

LLObjectEmitter::LLObjectEmitter(LLPointer<LLViewerObject> vo)
{
        mRequestedProperties = false;
        setObject(vo->getID());
        setPosition(vo->getPositionGlobal());

        if ( vo->isParticleSource() )
        {
                setOwner(vo->mPartSourcep->getOwnerUUID());
        }

        requestObjectInfo(vo->getRegion());
}


void LLObjectEmitter::setObject( const LLUUID& id, const LLString &name )
{
        if ( id.isNull() )
        {
                llwarns << "Trying to set object id to null" << llendl;
                return;
        }       
        mObjectID = id; mObjectName = name; 
}

void LLObjectEmitter::requestObjectInfo(const LLViewerRegion *reg)
{
        LLAvatarOwnedEmitter::update();

        if ( !mObjectID.isNull() && mObjectName.empty() && !mRequestedProperties )
        {
                llinfos << "Requesting object data for " << mObjectID << llendl;

                mRequestedProperties = true;
                
                LLMessageSystem* msg = gMessageSystem;
 
                msg->newMessageFast(_PREHASH_RequestObjectPropertiesFamily);
                msg->nextBlockFast(_PREHASH_AgentData);
                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
                msg->nextBlockFast(_PREHASH_ObjectData);
                msg->addU32Fast(_PREHASH_RequestFlags, 0x0 );
                msg->addUUIDFast(_PREHASH_ObjectID, mObjectID );
                
                //LLViewerRegion* regionp = gAgent.getRegion();
                msg->sendReliable( reg->getHost() );
        }
}


/*************************************************************************
* Event Log
*************************************************************************/


LLFloaterEventLog::LLFloaterEventLog() :  LLFloater("event log")
{
        // Create interface from XML
        gUICtrlFactory->buildFloater(this, "floater_event_log.xml");

        // Floater starts hidden        
        setVisible(FALSE);

        // Get a pointer to the scroll list from the interface
        mEventList = LLUICtrlFactory::getScrollListByName(this, "event_log");
        mSelectedTexture = LLUICtrlFactory::getTexturePickerByName(this, "selected_texture");

        // List of all the names of the action buttons
        // This is used to help with translation issues: We copy the button's name
        // to the configurable button.
        mActionButtons[QB_AVATAR_PROFILE]   = LLUICtrlFactory::getButtonByName(this, "av_profile_btn");
        mActionButtons[QB_AVATAR_KEY]       = LLUICtrlFactory::getButtonByName(this, "av_get_key_btn");
        mActionButtons[QB_AVATAR_TRACK]     = LLUICtrlFactory::getButtonByName(this, "av_track_btn");
        mActionButtons[QB_AVATAR_MUTE]      = LLUICtrlFactory::getButtonByName(this, "av_mute_btn");
        mActionButtons[QB_AVATAR_EJECT]     = LLUICtrlFactory::getButtonByName(this, "av_eject_btn");
        mActionButtons[QB_AVATAR_LW_GOHOME] = LLUICtrlFactory::getButtonByName(this, "av_luskwood_gohome_btn");
        mActionButtons[QB_OBJECT_KEY]       = LLUICtrlFactory::getButtonByName(this, "obj_get_key_btn");
        mActionButtons[QB_OBJECT_TRACK]     = LLUICtrlFactory::getButtonByName(this, "obj_track_btn");
        mActionButtons[QB_OBJECT_MUTE]      = LLUICtrlFactory::getButtonByName(this, "obj_mute_btn");
        mActionButtons[QB_OBJECT_RETURN]    = LLUICtrlFactory::getButtonByName(this, "obj_return_btn");
        mActionButtons[QB_UUID_BLACKLIST]   = LLUICtrlFactory::getButtonByName(this, "uuid_blacklist_btn");
        mActionButtons[QB_UUID_WHITELIST]   = LLUICtrlFactory::getButtonByName(this, "uuid_whitelist_btn");
        mActionButtons[QB_UUID_MUTELIST]    = LLUICtrlFactory::getButtonByName(this, "uuid_mutelist_btn");


        mActionButtonsType[QB_AVATAR_PROFILE]   = QBT_AVATAR;
        mActionButtonsType[QB_AVATAR_KEY]       = QBT_AVATAR;
        mActionButtonsType[QB_AVATAR_TRACK]     = QBT_AVATAR;
        mActionButtonsType[QB_AVATAR_MUTE]      = QBT_AVATAR;
        mActionButtonsType[QB_AVATAR_EJECT]     = QBT_AVATAR;
        mActionButtonsType[QB_AVATAR_LW_GOHOME] = QBT_AVATAR;
        mActionButtonsType[QB_OBJECT_KEY]       = QBT_OBJECT;
        mActionButtonsType[QB_OBJECT_TRACK]     = QBT_OBJECT;
        mActionButtonsType[QB_OBJECT_MUTE]      = QBT_OBJECT;
        mActionButtonsType[QB_OBJECT_RETURN]    = QBT_OBJECT;
        mActionButtonsType[QB_UUID_BLACKLIST]   = QBT_UUID;
        mActionButtonsType[QB_UUID_WHITELIST]   = QBT_UUID;
        mActionButtonsType[QB_UUID_MUTELIST]    = QBT_UUID;


        // Make list of texture selectors
        for(int i=0;i<MAX_INTERESTING_TEXTURES;i++)
        {
                std::ostringstream o;
                o << "hiscore_texture_" << i;
                mHiscoreTextures[i] = LLUICtrlFactory::getTexturePickerByName(this, o.str());

                o.str(""); o << "hiscore_name_" << i;
                mHiscoreNames[i] = LLUICtrlFactory::getTextBoxByName(this, o.str());

                o.str(""); o << "hiscore_owner_" << i;
                mHiscoreOwners[i] = LLUICtrlFactory::getTextBoxByName(this, o.str());

                o.str(""); o << "hiscore_action_" << i;
                mHiscoreButtons[i] = LLUICtrlFactory::getButtonByName(this, o.str());

                childSetAction(o.str(), onClickQuickButton, mHiscoreButtons[i]);
        }
        

        mEventList->setCallbackUserData(this);
        mEventList->sortByColumn("score", FALSE);
        mEventList->setDoubleClickCallback(onDoubleClick);

        childSetAction("av_profile_btn",         onClickAvatarProfile, this);
        childSetAction("av_get_key_btn",         onClickAvatarGetKey, this);
        childSetAction("av_track_btn",           onClickAvatarTrack, this);
        childSetAction("av_mute_btn",            onClickAvatarMute, this);
        childSetAction("av_eject_btn",           onClickAvatarEject, this);
        childSetAction("av_luskwood_gohome_btn", onClickAvatarGohomerSendHome, this);

        childSetAction("obj_get_key_btn",        onClickObjectGetKey, this);
        childSetAction("obj_track_btn",          onClickObjectTrack, this);
        childSetAction("obj_mute_btn",           onClickObjectMute, this);
        childSetAction("obj_return_btn",         onClickObjectReturn, this);


        childSetAction("uuid_blacklist_btn",     onClickUUIDBlacklist, this);
        childSetAction("uuid_whitelist_btn",     onClickUUIDWhitelist, this);
        childSetAction("uuid_mutelist_btn",      onClickUUIDMutelist, this);

        LLMessageSystem *msg = gMessageSystem;
        msg->addHandlerFuncFast(_PREHASH_ObjectPropertiesFamily, processObjectPropertiesFamily);
        msg->addHandlerFuncFast(_PREHASH_ObjectPropertiesFamily, processObjectProperties);

        updateControlsState();
        
}

LLFloaterEventLog::~LLFloaterEventLog()
{
        LLMessageSystem *msg = gMessageSystem;
        if ( msg )
        {
                msg->delHandlerFuncFast(_PREHASH_ObjectPropertiesFamily, processObjectPropertiesFamily);
                msg->delHandlerFuncFast(_PREHASH_ObjectPropertiesFamily, processObjectProperties);
        }
}

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

void LLFloaterEventLog::updateControlsState()
{
        BOOL row_selected = FALSE;
        EVENT_TYPE type = LLFloaterEventLog::EVENT_PARTICLE; // TODO: fix

        if ( mEventList->getFirstSelected() ) row_selected = TRUE;


        childSetVisible("particle_info_container", row_selected && type == LLFloaterEventLog::EVENT_PARTICLE);
        childSetEnabled("av_profile_btn", row_selected);
        childSetEnabled("av_get_key_btn", row_selected);
        childSetEnabled("av_track_btn", row_selected);
        childSetEnabled("av_mute_btn", row_selected);
        childSetEnabled("av_eject_btn", row_selected);
        childSetEnabled("av_luskwood_gohome_btn", row_selected);

        childSetEnabled("obj_get_key_btn", row_selected);
        childSetEnabled("obj_track_btn", row_selected);
        childSetEnabled("obj_mute_btn", row_selected);
        childSetEnabled("obj_return_btn", row_selected);

        childSetEnabled("uuid_blacklist_btn", row_selected);
        childSetEnabled("uuid_whitelist_btn", row_selected);
        childSetEnabled("uuid_mutelist_btn", row_selected);
}

//static
void LLFloaterEventLog::toggle(void*) {
        if (!gFloaterEventLog) {
                llinfos << "No event log!" << llendl;
                return;
        }

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

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

void LLFloaterEventLog::logAvatarEvent( const LLUUID &avatar, const LLString &name, LLPointer <LLWorldEvent> ev)
{
        logEvent( new LLAvatarEmitter(avatar, name), ev);
}

void LLFloaterEventLog::logObjectEvent( const LLUUID &object, const LLUUID &owner, LLPointer <LLWorldEvent> ev)
{
        LLObjectEmitter *em = new LLObjectEmitter(object, owner);
        logEvent( em, ev);
}

void LLFloaterEventLog::logEvent( LLPointer<LLEventEmitter> emitter, LLPointer <LLWorldEvent> event)
{
        LLUUID id = emitter->getID();

        LLPointer<LLEventEmitter> em = getEmitter(id);

        if ( !em )
        {
                em = emitter;
                mEmitters[id] = em;
        }

        LLPointer<LLWorldEvent> ev = em->getEvent(event->getID());
        if ( !ev )
        {
                em->addEvent(event);
                ev = event;
        }

        //ev->incCount();
        *ev += *event;
}

void LLFloaterEventLog::logObject(  LLPointer<LLViewerObject> vo )
{

        // Ignore things that aren't interesting.
        if ( !vo->isParticleSource() ) return;

        LLUUID emitter_id = vo->getID();

        LLPointer<LLEventEmitter> em = getEmitter(emitter_id);
        LLPointer<LLWorldEvent> ev;

        if ( !em )
        {
                em = new LLObjectEmitter(vo);
                mEmitters[emitter_id] = em;
        }



        if ( vo->isParticleSource() )
        {
                ev = em->getEvent( vo->mPartSourcep->mPartSysData.mPartImageID );
                if ( ! ev )
                {
                        ev = new LLParticleEvent( vo->mPartSourcep->mPartSysData );
                        em->addEvent( ev );
                }

                ev->incCount( vo->mPartSourcep->mPartSysData.mBurstPartCount );

                LLParticleEvent *pev = dynamic_cast<LLParticleEvent*>( ev.get() );
                if ( pev )
                {
                        pev->setParticleData(vo->mPartSourcep->mPartSysData);
                }
        }

        LLAudioSource *src = vo->getAudioSource( em->getOwnerID() );

        if ( src )
        {
                // If there wasn't a sound played, getAudioSource adds one, with gain = 0.02f as
                // some sort of placeholder. That's not very interesting, so we ignore very 
                // silent sounds.

                LLAudioData *data = src->getCurrentData();

                if ( data )
                {
                        LLUUID sound_id = data->getID();
                        ev = em->getEvent( sound_id );

                        if ( !ev )
                        {
                                ev = new LLSoundEvent( sound_id );
                                em->addEvent( ev );
                        }
                }
        }

}


struct DescendingEventSort
{
     bool operator()(LLPointer<LLWorldEvent> a, LLPointer<LLWorldEvent> b)
     {
          return a->getScore() > b->getScore();
     }
};

void LLFloaterEventLog::updateList()
{
        BOOL show_null       = LLUICtrlFactory::getCheckBoxByName(this, "show_null_cb")->getValue();
        BOOL show_zero_count = LLUICtrlFactory::getCheckBoxByName(this, "show_zero_count_cb")->getValue();

        LLDynamicArray<LLUUID> selected = mEventList->getSelectedIDs();
        S32 scrollpos = mEventList->getScrollPos();

        U32 max_age = gSavedSettings.getU32("EventLogMaxAge");
        U32 max_entries = gSavedSettings.getU32("EventLogMaxEntries");
        LLVector3d mypos = gAgent.getPositionGlobal();

        mEventList->deleteAllItems();


        std::vector< LLPointer<LLWorldEvent> > annoyances;

        
        std::map<LLUUID, LLPointer<LLEventEmitter> >::iterator iter;

        for(iter = mEmitters.begin(); iter != mEmitters.end(); iter++)
        {
                LLPointer<LLEventEmitter> em = iter->second;


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

                //llinfos << "Emitter: " << em->getID() << llendl;

                std::map<LLUUID, LLPointer<LLWorldEvent> >::iterator iter_events;
                for(iter_events = em->mEvents.begin(); iter_events != em->mEvents.end(); iter_events++)
                {
                        LLPointer<LLWorldEvent> ev = iter_events->second;

                        if ( ev->getAge() > max_age ) continue;
                        if ( --max_entries == 0 ) goto too_many_entries;
                        if ( !show_null && ev->getID().isNull() ) continue;
                        if ( !show_zero_count && ev->getCount() == 0 ) continue;

                        ev->checkDuration();

                        if ( !ev->getID().isNull() && ev->getAge() < 1.0f )
                        {
                                annoyances.push_back( ev );
                        }

                        LLSD row;

                        row["id"] = ev->getGlobalID();

                        row["columns"][LIST_EVENT_ICON]["column"] = "type_icon";
                        row["columns"][LIST_EVENT_ICON]["type"]   = "icon";
                        row["columns"][LIST_EVENT_ICON]["value"]  = ev->getIcon();

                        row["columns"][LIST_OWNER_NAME]["column"] = "owner_name";
                        row["columns"][LIST_OWNER_NAME]["type"]   = "text";
                        row["columns"][LIST_OWNER_NAME]["value"]  = em->getOwnerName();

                        row["columns"][LIST_OBJECT_NAME]["column"] = "object_name";
                        row["columns"][LIST_OBJECT_NAME]["type"]   = "text";
                        row["columns"][LIST_OBJECT_NAME]["value"]  = em->getName();

                        row["columns"][LIST_ID]["column"] = "id";
                        row["columns"][LIST_ID]["type"]   = "text";
                        row["columns"][LIST_ID]["value"]  = ev->getID();

                        row["columns"][LIST_DISTANCE]["column"] = "distance";
                        row["columns"][LIST_DISTANCE]["type"]   = "text";
                        row["columns"][LIST_DISTANCE]["value"]  = llformat("%.2f", distance);

                        row["columns"][LIST_COUNT]["column"] = "count";
                        row["columns"][LIST_COUNT]["type"]   = "text";
                        row["columns"][LIST_COUNT]["value"]  = ev->getCount();

                        row["columns"][LIST_DURATION]["column"] = "duration";
                        row["columns"][LIST_DURATION]["type"]   = "text";
                        row["columns"][LIST_DURATION]["value"]  = llformat("%.2f", ev->getDuration());
                         
                        row["columns"][LIST_AGE]["column"] = "age";
                        row["columns"][LIST_AGE]["type"]   = "text";
                        row["columns"][LIST_AGE]["value"]  = llformat("%.2f", ev->getAge());

                        row["columns"][LIST_SCORE]["column"] = "score";
                        row["columns"][LIST_SCORE]["type"]   = "text";
                        row["columns"][LIST_SCORE]["value"]  = ev->getScore();

                        // Add to list
                        //llinfos << "Event: " << ev->getID() << llendl;
                        mEventList->addElement(row, ADD_BOTTOM);
                }

                em->update();
        }

too_many_entries:
        // finish
        mEventList->sort();
        mEventList->selectMultiple(selected);
        mEventList->setScrollPos(scrollpos);


        // Update list of major annoyances
        std::sort(annoyances.begin(), annoyances.end(), DescendingEventSort());
        int count = 0;
        while( annoyances.size() > count && count < MAX_INTERESTING_TEXTURES)
        {
                mHiscoreTextures[count]->setImageAssetID( annoyances[count]->getID() );
                mHiscoreNames[count]->setText( annoyances[count]->getParent()->getName() );
                mHiscoreOwners[count]->setText( annoyances[count]->getParent()->getOwnerName() );
                mHiscoreButtons[count]->setEnabled(TRUE);
                mHiscoreEvents[count] = annoyances[count];
                count++;
        }

        // Clear remaining ones if any
        while( count < MAX_INTERESTING_TEXTURES )
        {
                mHiscoreTextures[count]->setImageAssetID( LLUUID::null );
                mHiscoreNames[count]->setText(LLString(""));
                mHiscoreOwners[count]->setText(LLString(""));
                mHiscoreButtons[count]->setEnabled(FALSE);
                mHiscoreEvents[count] = NULL;
                count++;
        }

}


void LLFloaterEventLog::updateQuickButtons()
{
        S32 action = gSavedSettings.getS32("EventLogQuickAction");
        if ( action >= QB_COUNT )
        {
                llwarns << "Quick action button set to out of range value: " << action << llendl;
                return;
        }

        LLString text = mActionButtons[action]->getLabelSelected();

        switch( mActionButtonsType[action] )
        {
                case QBT_AVATAR: text = "Avatar: " + text; break;
                case QBT_OBJECT: text = "Object: " + text; break;
                case QBT_UUID:   text = "UUID: " + text; break;
        }

        for(S32 i = 0;i<MAX_INTERESTING_TEXTURES;i++)
        {
                mHiscoreButtons[i]->setLabel(text);
        }
}

void LLFloaterEventLog::updateSelectedEventInfo()
{


        // Update texture selectors
        LLScrollListItem *selected_item =   mEventList->getFirstSelected();
        if ( selected_item )
        {
                LLParticleEvent *pev = dynamic_cast<LLParticleEvent*>( findEventBySelectedID(selected_item->getUUID()).get() );
                if ( pev )
                {
                        mSelectedTexture->setImageAssetID( pev->getID() );
                        LLString pattern;

                        switch( pev->mPartSysData.mPattern )
                        {
                                case LLPartSysData::LL_PART_SRC_PATTERN_DROP:             pattern = "DROP"; break;
                                case LLPartSysData::LL_PART_SRC_PATTERN_EXPLODE:          pattern = "EXPLODE"; break;
                                case LLPartSysData::LL_PART_SRC_PATTERN_ANGLE:            pattern = "ANGLE"; break;
                                case LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE:       pattern = "ANGLE_CONE"; break;
                                case LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY: pattern = "ANGLE_CONE_EMPTY"; break;
                                default:                                   pattern = "UNKNOWN"; break;
                        }

                        childSetTextArg("part_pattern",    "[PATTERN]",        pattern);
                        childSetTextArg("part_texture",    "[TEXTURE]",        pev->getID().asString());
                        childSetTextArg("part_burst_rate", "[BURST_COUNT]",    llformat("%i", (U32)pev->mPartSysData.mBurstPartCount));
                        childSetTextArg("part_burst_rate", "[BURST_RATE]",     llformat("%.3f", pev->mPartSysData.mBurstRate));
                        childSetTextArg("part_burst_rate", "[PARTICLE_COUNT]", llformat("%.3f", pev->mPartSysData.mBurstPartCount *
                                                                                                (1 / pev->mPartSysData.mBurstRate)) );

                        childSetTextArg("part_radius",     "[RADIUS]",         llformat("%.3f", pev->mPartSysData.mBurstRadius));
                        childSetTextArg("part_angle",      "[ANGLE_BEGIN]",    llformat("%.3f", pev->mPartSysData.mInnerAngle));
                        childSetTextArg("part_angle",      "[ANGLE_END]",      llformat("%.3f", pev->mPartSysData.mOuterAngle));

                        childSetTextArg("part_speed",      "[SPEED_MIN]",      llformat("%.3f", pev->mPartSysData.mBurstSpeedMin));
                        childSetTextArg("part_speed",      "[SPEED_MAX]",      llformat("%.3f", pev->mPartSysData.mBurstSpeedMax));

                        childSetTextArg("part_size",       "[SCALE_BEGIN]",    llformat("<%.3f, %.3f>", pev->mPartSysData.mPartData.mStartScale.mV[VX],
                                                                                                        pev->mPartSysData.mPartData.mStartScale.mV[VY]));
                        childSetTextArg("part_size",       "[SCALE_END]",      llformat("<%.3f, %.3f>", pev->mPartSysData.mPartData.mEndScale.mV[VX],
                                                                                                        pev->mPartSysData.mPartData.mEndScale.mV[VY]));
                        childSetTextArg("part_color",      "[COLOR_BEGIN]",    llformat("<%.3f, %.3f, %.3f>", pev->mPartSysData.mPartData.mStartColor.mV[0],
                                                                                                              pev->mPartSysData.mPartData.mStartColor.mV[1],
                                                                                                              pev->mPartSysData.mPartData.mStartColor.mV[2]));
                        childSetTextArg("part_color",      "[COLOR_END]",      llformat("<%.3f, %.3f, %.3f>", pev->mPartSysData.mPartData.mEndColor.mV[0],
                                                                                                              pev->mPartSysData.mPartData.mEndColor.mV[1],
                                                                                                              pev->mPartSysData.mPartData.mEndColor.mV[2]));
                        childSetTextArg("part_alpha",      "[ALPHA_BEGIN]",    llformat("%.3f", pev->mPartSysData.mPartData.mStartColor.mV[3]));
                        childSetTextArg("part_alpha",      "[ALPHA_END]",      llformat("%.3f", pev->mPartSysData.mPartData.mEndColor.mV[3]));

                        
                        LLString flags = "";
                        U32 f = pev->mPartSysData.mPartData.mFlags;
                        if ( f &  LLPartData::LL_PART_INTERP_COLOR_MASK )      flags += "interp_color ";
                        if ( f &  LLPartData::LL_PART_INTERP_SCALE_MASK )      flags += "interp_size ";
                        if ( f &  LLPartData::LL_PART_BOUNCE_MASK )            flags += "bounce ";
                        if ( f &  LLPartData::LL_PART_WIND_MASK )              flags += "wind ";
                        if ( f &  LLPartData::LL_PART_FOLLOW_SRC_MASK )        flags += "follow_src ";
                        if ( f &  LLPartData::LL_PART_FOLLOW_VELOCITY_MASK )   flags += "follow_vel ";
                        if ( f &  LLPartData::LL_PART_TARGET_POS_MASK )        flags += "target ";
                        if ( f &  LLPartData::LL_PART_TARGET_LINEAR_MASK )     flags += "linear ";
                        if ( f &  LLPartData::LL_PART_EMISSIVE_MASK )          flags += "glow ";
                        if ( f &  LLPartData::LL_PART_BEAM_MASK )              flags += "beam ";
                        if ( f &  LLPartData::LL_PART_DEAD_MASK )              flags += "dead ";

                        childSetTextArg("part_flags",      "[FLAGS]", flags);
                }
        }

}

void LLFloaterEventLog::updateWindow()
{
        if (!LLFloaterEventLog::visible(NULL))
        {
                return;
        }


        BOOL enabled         = LLUICtrlFactory::getCheckBoxByName(this, "enabled_cb")->getValue();
        if ( enabled ) updateList();


        updateSelectedEventInfo();
        updateControlsState();
        updateQuickButtons();
}


//static
void LLFloaterEventLog::processObjectProperties(LLMessageSystem *msg, void **user_data)
{
        S32 i;
        S32 count = msg->getNumberOfBlocksFast(_PREHASH_ObjectData);
        for( i = 0; i < count; i++ )
        {
                LLUUID id;
                char name[DB_INV_ITEM_NAME_BUF_SIZE];           /* Flawfinder: ignore */

                
                msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ObjectID, id, i);
                llinfos << "Processing object data for " << id << llendl;

                if ( gFloaterEventLog->mEmitters.count( id ) > 0 )
                {
                        llinfos << "Setting data for " << id << llendl;
                        LLPointer<LLEventEmitter> em = gFloaterEventLog->mEmitters[id];

                        msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Name, DB_INV_ITEM_NAME_BUF_SIZE, name, i);

                        em->setName( name );
                }

        }
}

//static
void LLFloaterEventLog::processObjectPropertiesFamily(LLMessageSystem *msg, void **user_data)
{

        LLUUID id;
        U32 request_flags;

        char name[DB_INV_ITEM_NAME_BUF_SIZE];           /* Flawfinder: ignore */

        
        msg->getU32Fast(_PREHASH_ObjectData, _PREHASH_RequestFlags,     request_flags );
         msg->getUUIDFast(_PREHASH_ObjectData, _PREHASH_ObjectID,                id );

        llinfos << "Processing object data for " << id << llendl;

        if ( gFloaterEventLog->mEmitters.count( id ) > 0 )
        {
                LLPointer<LLEventEmitter> em = gFloaterEventLog->mEmitters[id];

                msg->getStringFast(_PREHASH_ObjectData, _PREHASH_Name, DB_INV_ITEM_NAME_BUF_SIZE, name);

                em->setName( name );
        }


}

LLPointer<LLEventEmitter> LLFloaterEventLog::findEmitterBySelectedID(const LLUUID &id)
{
        std::map<LLUUID, LLPointer<LLEventEmitter> >::iterator iter;
        for(iter = mEmitters.begin(); iter != mEmitters.end(); iter++)
        {
                LLPointer<LLEventEmitter> em = iter->second;

                std::map<LLUUID, LLPointer<LLWorldEvent> >::iterator iter_events;
                for(iter_events = em->mEvents.begin(); iter_events != em->mEvents.end(); iter_events++)
                {
                        LLPointer<LLWorldEvent> ev = iter_events->second;

                        if ( ev->getGlobalID() == id )
                        {
                                return em;
                        }
                }
        }
        
        return NULL;
}

LLPointer<LLWorldEvent> LLFloaterEventLog::findEventBySelectedID(const LLUUID &id)
{
        std::map<LLUUID, LLPointer<LLEventEmitter> >::iterator iter;
        for(iter = mEmitters.begin(); iter != mEmitters.end(); iter++)
        {
                LLPointer<LLEventEmitter> em = iter->second;

                std::map<LLUUID, LLPointer<LLWorldEvent> >::iterator iter_events;
                for(iter_events = em->mEvents.begin(); iter_events != em->mEvents.end(); iter_events++)
                {
                        LLPointer<LLWorldEvent> ev = iter_events->second;

                        if ( ev->getGlobalID() == id )
                        {
                                return ev;
                        }
                }
        }

        return NULL;
}

//static
void LLFloaterEventLog::onDoubleClick(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        LLScrollListItem *item =   self->mEventList->getFirstSelected();
        LLUUID item_id = item->getUUID();


        // TODO: Ok, this is rather ugly and should be reworked.
        // We've assigned an arbitrary ID to each element, as there's no way to
        // uniquely identify a row otherwise -- as both emitters and events may not
        // be unique.
        //
        // Now we need to find the emitter for a key, so we scan through the whole
        // list looking for it

        LLPointer<LLEventEmitter> em = self->findEmitterBySelectedID(item_id);
        if ( em )
        {
                gAgent.lookAtObject(em->getID(), CAMERA_POSITION_OBJECT);
                
        }
        else
        {
                llwarns << "Searched the whole list for " << item_id << " but couldn't find it!" << llendl;
        }
}



void LLFloaterEventLog::doCommand(avlist_command_t func, bool use_object_id, bool first_only)
{
        LLDynamicArray<LLUUID> ids = mEventList->getSelectedIDs();

        std::map<LLUUID, S32> seen_ids;

        // Go through the list of selections, removing duplicated object or avatar IDs.
        for(LLDynamicArray<LLUUID>::iterator itr = ids.begin(); itr != ids.end(); ++itr)
        {
                LLUUID id = *itr;
                LLPointer<LLEventEmitter> pev = findEmitterBySelectedID(id);

                if ( pev  )
                {
                        LLUUID dest_id;
                        LLString dest_name;

                        if ( use_object_id )
                        {
                                dest_id   = pev->getID();
                                dest_name = pev->getName();
                        }
                        else
                        {
                                dest_id   = pev->getOwnerID();
                                dest_name = pev->getOwnerName();
                        }

                        
                        if ( seen_ids.count( dest_id ) < 1 )
                        {
                                func(dest_id, dest_name);

                                if ( first_only ) return;
                        }

                        seen_ids[dest_id] = 1;
                }
        }



}


static void cmd_eject(const LLUUID& avatar, const LLString &name)       { /*send_eject(avatar, false);*/ }
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_gohome(const LLUUID&avatar, const LLString &name)       { gAgent.sendChat("gohome " + name + " " + avatar.asString(), 0, CHAT_TYPE_SHOUT); }
static void cmd_track(const LLUUID&avatar, const LLString &name)        { LLTracker::trackAvatar(avatar, name); }
static void cmd_get_key(const LLUUID&avatar, const LLString &name)
{
        char buffer[UUID_STR_LENGTH];           /*Flawfinder: ignore*/
        avatar.toString(buffer);
        gViewerWindow->mWindow->copyTextToClipboard(utf8str_to_wstring(buffer));
}

// Button handlers for avatars

//static
void LLFloaterEventLog::onClickAvatarGohomerSendHome(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_gohome, false);
}

//static
void LLFloaterEventLog::onClickAvatarGetKey(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_get_key, false, true);
}

//static
void LLFloaterEventLog::onClickAvatarEject(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_eject, false);
}

//static
void LLFloaterEventLog::onClickAvatarMute(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_mute, false);
}

//static
void LLFloaterEventLog::onClickAvatarProfile(void* userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_profile, false);
}

//static
void LLFloaterEventLog::onClickAvatarTrack(void *userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_track, false, true);
}

// Button handlers for objects

//static
void LLFloaterEventLog::onClickObjectGetKey(void* userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_get_key, true, true);
}


//static
void LLFloaterEventLog::onClickObjectTrack(void* userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_track, true, true);
}

//static
void LLFloaterEventLog::onClickObjectMute(void* userdata)
{
        LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
        self->doCommand(cmd_mute, true);
}

//static
void LLFloaterEventLog::onClickObjectReturn(void* userdata)
{
//      LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
//      self->doCommand(cmd_mute, true);
        llinfos << "not implemented" << llendl;
}

// Button handlers for UUIDs

//static
void LLFloaterEventLog::onClickUUIDBlacklist(void* userdata)
{
//      LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
//      self->doCommand(cmd_mute, true);
        llinfos << "not implemented" << llendl;
}

//static
void LLFloaterEventLog::onClickUUIDWhitelist(void* userdata)
{
//      LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
//      self->doCommand(cmd_mute, true);
        llinfos << "not implemented" << llendl;
}

//static
void LLFloaterEventLog::onClickUUIDMutelist(void* userdata)
{
//      LLFloaterEventLog *self = (LLFloaterEventLog*)userdata;
//      self->doCommand(cmd_mute, true);
        llinfos << "not implemented" << llendl;
}


// Quick buttons
//static
void LLFloaterEventLog::onClickQuickButton(void *button)
{
        S32 pos = -1;
        
        // Find this button in the list of buttons to obtain its position
        for(S32 i=0;i<MAX_INTERESTING_TEXTURES;i++)
        {
                if ( gFloaterEventLog->mHiscoreButtons[i] == button )
                {
                        pos = i;
                        break;
                }
        }

        if ( pos < 0 )
        {
                llwarns << "Failed to find myself in the floater!" << llendl;
                return;
        }
        
        // Get the event associated with that position
        LLPointer<LLWorldEvent>   ev = gFloaterEventLog->mHiscoreEvents[pos];
        LLPointer<LLEventEmitter> em = ev->getParent();

        S32 action = gSavedSettings.getS32("EventLogQuickAction");
        switch(action)
        {
                case QB_AVATAR_PROFILE:   cmd_profile( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_AVATAR_KEY:       cmd_get_key( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_AVATAR_TRACK:     cmd_track( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_AVATAR_MUTE:      cmd_mute( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_AVATAR_EJECT:     cmd_eject( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_AVATAR_LW_GOHOME: cmd_gohome( em->getOwnerID(), em->getOwnerName() ); break;
                case QB_OBJECT_KEY:       cmd_get_key( em->getID(), em->getName() ); break;
                case QB_OBJECT_TRACK:     cmd_track( em->getID(), em->getName() ); break;
                case QB_OBJECT_MUTE:      cmd_mute( em->getID(), em->getName() ); break;
                case QB_OBJECT_RETURN:    llwarns << "Not implemented" << llendl; break;
                case QB_UUID_BLACKLIST:   llwarns << "Not implemented" << llendl; break;
                case QB_UUID_WHITELIST:   llwarns << "Not implemented" << llendl; break;
                case QB_UUID_MUTELIST:    llwarns << "Not implemented" << llendl; break;
                default:                  llwarns << "Unknown action " << action << llendl; break;
        }
}

---