llfloatereventlog.h

Go to the documentation of this file.

//
// C++ Interface: llfloatereventlog
//
// Description: 
//
//
// Author: Dale Glass <dale@daleglass.net>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef LL_LLFLOATERVENTLOG_H
#define LL_LLFLOATERVENTLOG_H

#include "llviewerprecompiledheaders.h"
#include "llfloater.h"
#include "viewer.h"
#include "llviewerobject.h"
#include "lltexturectrl.h"
#include "llpartdata.h"

#include <map>

using std::map;

class LLFloaterEventLog;
class LLEventEmitter;

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

const S32 MAX_INTERESTING_TEXTURES = 3;


class LLWorldEvent : public LLRefCount
{
public:
        LLWorldEvent(const LLUUID &id = LLUUID::null ) : mDuration(0), mCount(0) { mLastFrame = gFrameCount; mGlobalID.generate();}

        F32 getAge() const { return mAgeTimer.getElapsedTimeF32(); }
        F32 getDuration() const { return mDuration; }
        S32 getCount() const { return mCount; }

        virtual S32 getScore() const = 0;

        virtual LLUUID getID() const = 0;

        LLUUID getGlobalID() const { return mGlobalID; }

        void checkDuration() { if ( mLastFrame != gFrameCount ) mDurationTimer.reset(); }

        void incCount(S32 count = 1);

        bool operator+=(const LLWorldEvent &ev) { incCount(ev.mCount); return true; }
        bool operator<(const LLWorldEvent &ev) { return getScore() > ev.getScore(); }

        virtual LLString getIcon() = 0;

        void setParent(LLPointer<LLEventEmitter> parent) { mParent = parent; }
        LLPointer<LLEventEmitter> getParent() { return mParent; }
private:
        F32 mDuration;
        S32 mCount;
        LLTimer mAgeTimer;
        LLTimer mDurationTimer;
        U32 mLastFrame;

        LLUUID mGlobalID;
        LLPointer<LLEventEmitter> mParent;
};

class LLParticleEvent : public LLWorldEvent
{
public:
        LLParticleEvent(const LLUUID &texture = LLUUID::null) : mTexture(texture) { }
        LLParticleEvent(const LLPartSysData &data);

        LLUUID getTexture() const { return mTexture; }
        virtual LLUUID getID() const { return mTexture; }

        virtual LLString getIcon() { return gViewerArt.getString("account_id_blue.tga"); }

        virtual S32 getScore() const;

        void setParticleData(const LLPartSysData &data) { mPartSysData = data; }
private:
        friend class LLFloaterEventLog;

        LLUUID mTexture;
        LLPartSysData mPartSysData;
        
};


class LLSoundEvent : public LLWorldEvent
{
public:
        LLSoundEvent(const LLUUID &sound = LLUUID::null) : mSound(sound) {}
        
        LLUUID getSound() const { return mSound; }
        virtual LLUUID getID() const { return mSound; }
        virtual S32 getScore() const { return 0; }
        virtual LLString getIcon() { return gViewerArt.getString("inv_item_sound.tga"); }
private:
        LLUUID mSound;
};


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

class LLEventEmitter : public LLRefCount
{
public:
        LLEventEmitter() {}

        virtual LLString getName() const { return ""; }

        virtual void setName(const LLString &name) {}

        virtual LLUUID   getID() const { return LLUUID::null; }

        virtual void update() {}


        virtual LLString getOwnerName() const { return ""; }
        virtual LLUUID   getOwnerID() const { return LLUUID::null; }

        LLVector3d getPosition() const { return mPosition; }
        void setPosition(const LLVector3d &pos) { mPosition = pos; }

        void addEvent(LLPointer<LLWorldEvent> ev) { mEvents[ev->getID()] = ev; ev->setParent(this); }
        LLPointer<LLWorldEvent> getEvent(const LLUUID &id) { if ( mEvents.count( id ) > 0 )     { return mEvents[id]; } return NULL; }
protected:
        friend class LLFloaterEventLog;

        LLVector3d mPosition;
        map <LLUUID, LLPointer<LLWorldEvent> > mEvents;
};

class LLAvatarOwnedEmitter: public LLEventEmitter
{
public:
        LLAvatarOwnedEmitter(const LLUUID& id = LLUUID::null, const LLString& name = "");
        ~LLAvatarOwnedEmitter();

        virtual LLString getOwnerName() const { return mOwnerName; }
        virtual LLUUID   getOwnerID() const { return mOwnerID; }
        virtual void update();

        void setOwner(const LLUUID &id, const LLString &name = "");

protected:
        LLUUID mOwnerID;
        LLString mOwnerName;

private:
        bool mNamePending;
        static void nameLookupCallback(const LLUUID&id, const char *first, const char *last, BOOL group, void *userdata);
};


class LLAvatarEmitter : public LLAvatarOwnedEmitter
{
public:
        LLAvatarEmitter(const LLUUID& id = LLUUID::null, const LLString& name = "") { setOwner(id, name); }
        
        virtual LLUUID   getID() const { return mOwnerID; }
        virtual LLString getName() const { return "<avatar>"; }
private:
};

class LLObjectEmitter : public LLAvatarOwnedEmitter
{
public:
        LLObjectEmitter(const LLUUID& id = LLUUID::null, const LLUUID &owner = LLUUID::null);
        LLObjectEmitter(LLPointer <LLViewerObject> obj);

        virtual LLString getName() const { return mObjectName; }
        virtual void setName(const LLString &name) { mObjectName = name; }

        virtual LLUUID getID() const { return mObjectID; }

        LLUUID getObjectID() const { return mObjectID; }
        LLString getObjectName() const { return mObjectName; }

        void requestObjectInfo(const LLViewerRegion *reg);

        void setObject( const LLUUID& id, const LLString &name = "" );
private:
        LLUUID mObjectID;
        LLString mObjectName;
        bool mRequestedProperties;
};



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

class LLFloaterEventLog : public LLFloater
{
public:
        enum QUICK_BUTTON_FUNCTION
        {
                QB_AVATAR_PROFILE,
                QB_AVATAR_KEY,
                QB_AVATAR_TRACK,
                QB_AVATAR_MUTE,
                QB_AVATAR_EJECT,
                QB_AVATAR_LW_GOHOME,
                QB_OBJECT_KEY,
                QB_OBJECT_TRACK,
                QB_OBJECT_MUTE,
                QB_OBJECT_RETURN,
                QB_UUID_BLACKLIST,
                QB_UUID_WHITELIST,
                QB_UUID_MUTELIST,
                QB_COUNT /* must be the last one */
        } quick_button_function_t;

        enum QUICK_BUTTON_TYPE
        {
                QBT_AVATAR,
                QBT_OBJECT,
                QBT_UUID
        } quick_button_type_t;

        LLFloaterEventLog();
        ~LLFloaterEventLog();

        void show();
        virtual void onClose(bool app_quitting) { setVisible(FALSE); }
        static void toggle(void*);
        static BOOL visible(void*);

        void logAvatarEvent( const LLUUID &avatar, const LLString &name = "", LLPointer <LLWorldEvent> ev = NULL);
        void logObjectEvent( const LLUUID &object, const LLUUID &owner = LLUUID::null, LLPointer <LLWorldEvent> ev = NULL);

        void logObject( LLPointer<LLViewerObject> vo);

        void logEvent( LLPointer<LLEventEmitter> em, LLPointer <LLWorldEvent> ev);

        void updateWindow();

        static void processObjectProperties(LLMessageSystem *msg, void **user_data);
        static void processObjectPropertiesFamily(LLMessageSystem *msg, void **user_data);
        static void onDoubleClick(void *userdata);
private:
        enum EVENTS_COLUMN_ORDER
        {
                LIST_EVENT_ICON,
                LIST_OWNER_NAME,
                LIST_OBJECT_NAME,
                LIST_ID,
                LIST_DISTANCE,
                LIST_COUNT,
                LIST_DURATION,
                LIST_AGE,
                LIST_SCORE
        } event_type_t;

        enum EVENT_TYPE
        {
                EVENT_PARTICLE,
                EVENT_SOUND
        };

        LLPointer<LLEventEmitter> getEmitter(const LLUUID &id) { if ( mEmitters.count( id ) > 0 )       { return mEmitters[id]; } return NULL; }

        LLPointer<LLEventEmitter> findEmitterBySelectedID(const LLUUID &id);
        LLPointer<LLWorldEvent> findEventBySelectedID(const LLUUID &id);
        

        void updateControlsState();

        LLScrollListCtrl *mEventList;

        LLTextureCtrl *mSelectedTexture;

        LLTextureCtrl*          mHiscoreTextures[MAX_INTERESTING_TEXTURES];
        LLTextBox*              mHiscoreNames[MAX_INTERESTING_TEXTURES];
        LLTextBox*              mHiscoreOwners[MAX_INTERESTING_TEXTURES];
        LLButton*               mHiscoreButtons[MAX_INTERESTING_TEXTURES];
        LLPointer<LLWorldEvent> mHiscoreEvents[MAX_INTERESTING_TEXTURES];

        LLButton*             mActionButtons[QB_COUNT]; 
        QUICK_BUTTON_TYPE   mActionButtonsType[QB_COUNT];

        map<LLUUID, LLPointer<LLEventEmitter> > mEmitters;


        void updateList();
        void updateSelectedEventInfo();
        void updateQuickButtons();

        typedef void (*avlist_command_t)(const LLUUID &avatar, const LLString &name);

        void LLFloaterEventLog::doCommand(avlist_command_t func, bool use_object_id, bool first_only = false);

        static void onClickAvatarGohomerSendHome(void *userdata);
        static void onClickAvatarGetKey(void *userdata);
        static void onClickAvatarEject(void *userdata);
        static void onClickAvatarMute(void *userdata);
        static void onClickAvatarProfile(void* userdata);
        static void onClickAvatarTrack(void* userdata);

        static void onClickObjectGetKey(void* userdata);
        static void onClickObjectTrack(void* userdata);
        static void onClickObjectMute(void* userdata);
        static void onClickObjectReturn(void* userdata);

        static void onClickUUIDBlacklist(void* userdata);
        static void onClickUUIDWhitelist(void* userdata);
        static void onClickUUIDMutelist(void* userdata);

        static void onClickQuickButton(void *userdata);
};



extern LLFloaterEventLog *gFloaterEventLog;

#endif

---