llfloateravatarlist.h

Go to the documentation of this file.

//
// C++ Interface: llfloateravatarlist
//
// Description: 
//
//
// Author: Dale Glass <dale@daleglass.net>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "llfloater.h"
#include "llfloaterreporter.h"
#include "lluuid.h"
#include "lltimer.h"
#include "llchat.h"
#include "viewer.h"

#include <time.h>
#include <map>

class LLFloaterAvatarList;

enum ACCOUNT_TYPE
{
        ACCOUNT_RESIDENT,         
        ACCOUNT_TRIAL,            
        ACCOUNT_CHARTER_MEMBER,   
        ACCOUNT_EMPLOYEE,         
        ACCOUNT_CUSTOM            
};

enum PAYMENT_TYPE
{
        PAYMENT_NONE,             
        PAYMENT_ON_FILE,          
        PAYMENT_USED,             
        PAYMENT_LINDEN            
};


enum ACTIVITY_TYPE
{
        ACTIVITY_NONE,           
        ACTIVITY_MOVING,         
        ACTIVITY_GESTURING,      
        ACTIVITY_SOUND,          
        ACTIVITY_REZZING,        
        ACTIVITY_PARTICLES,      
        ACTIVITY_TYPING,         
        ACTIVITY_NEW,            
        ACTIVITY_DEAD            
};

enum DATA_STATUS
{
        DATA_UNKNOWN,
        DATA_REQUESTING,
        DATA_ERROR,
        DATA_RETRIEVED
};

enum e_coloring_type
{
        CT_NONE,
        CT_DISTANCE,
        CT_AGE,
        CT_SCORE,
        CT_PAYMENT
};

template <class T> 
class LLAvatarListDatum
{
public:
        LLAvatarListDatum()
        {
                mMaxPending = 32;

                mRetryDelay = 0.0f;
                mRequestDelay = 1.0f;
                mFirstRequestTimeout = 16.0f;
                mMaxRequestTimeout = 8192.0f;

                mRequestTimer.start();
                mRequestDelayTimer.start();
                mStatus = DATA_UNKNOWN;
                
        }

        BOOL retryNeeded()
        {
                switch(mStatus)
                {
                        case DATA_UNKNOWN:
                        case DATA_REQUESTING:
                        case DATA_ERROR:
                                // Don't request too many at once
                                if ( mPending >= mMaxPending )
                                {
                                        return FALSE;
                                }

                                // Don't re-request if the requests would be made too fast
                                if ( mRequestDelayTimer.getElapsedTimeF32() < mRequestDelay )
                                {
                                        return FALSE;
                                }

                                // Re-request if retry timeout was reached
                                return ( mRequestTimer.getElapsedTimeF32() > mRetryDelay );
                        case DATA_RETRIEVED:
                                return FALSE;
                }

                return FALSE;
        }

        void requestStarted()
        {

                if ( mStatus != DATA_REQUESTING )
                {
                        mPending++;
                        //llinfos << "Pe
                }

                mStatus = DATA_REQUESTING;

                if ( mRetryDelay == 0 )
                {
                        mRetryDelay = mFirstRequestTimeout;
                }
                else
                {
                        if ( mRetryDelay < mMaxRequestTimeout )
                        {
                                mRetryDelay *= 2;
                        }
                }

                mRequestTimer.start();
                mRequestDelayTimer.start();
        }

        BOOL requestIfNeeded()
        {
                BOOL ret = retryNeeded();
                if ( ret )
                {
                        requestStarted();
                }

                return ret;
        }

        DATA_STATUS getStatus()
        {
                if ( mStatus == DATA_REQUESTING 
                     && mRequestTimer.getElapsedTimeF32() > mRetryDelay )
                {
                        mStatus = DATA_ERROR;

                        // Consider this request failed, so the slot is free.
                        mPending--;
                }

                return mStatus;
        }

        T& getValue()
        {
                return mValue;
        }

        void setValue(T val)
        {
                if ( mStatus != DATA_RETRIEVED )
                {
                        mPending--;
                }

                mValue = val;
                mStatus = DATA_RETRIEVED;
        }

        void setRequestDelay(F32 delay)
        {
                mRequestDelay = delay;
        }

        void setMaxPending(U32 count)
        {
                mMaxPending = count;
        }
private:
        friend class LLFloaterAvatarList;
        T mValue;

        DATA_STATUS mStatus;

        
        F32 mRetryDelay;

        F32 mFirstRequestTimeout;

        F32 mMaxRequestTimeout;

        LLTimer mRequestTimer;



        static LLTimer mRequestDelayTimer;

        static U32 mPending;


        F32 mRequestDelay;

        U32 mMaxPending;
};

template <class T> LLTimer LLAvatarListDatum<T>::mRequestDelayTimer;
template <class T> U32 LLAvatarListDatum<T>::mPending = 0;

//template <class T> F32 LLAvatarListDatum<T>::mRequestDelay;



struct LLAvListTrustNetScore
{
        F32 Score;
        LLString Type;

        LLAvListTrustNetScore(LLString type = "<uninitialized>", F32 score = 0.0f);
};

struct LLAvatarInfo
{
        PAYMENT_TYPE Payment;
        ACCOUNT_TYPE Account;
        struct tm    BirthDate;

        LLAvatarInfo();
        LLAvatarInfo(PAYMENT_TYPE payment, ACCOUNT_TYPE account, struct tm birth);
        S32 getAge();
};

struct LLMiscDBInfo
{
        LLString data;

        LLMiscDBInfo(LLString d)
        {
                data = d;
        }

        LLMiscDBInfo()
        {
                data = "";
        }
};


class LLAvatarListEntry {
public:


        LLAvatarListEntry(const LLUUID& id = LLUUID::null, const LLString &name = "", const LLVector3d &position = LLVector3d::zero, BOOL isLinden = FALSE) :
                mID(id), mName(name), mPosition(position), mMarked(FALSE), mFocused(FALSE), mIsLinden(isLinden), mActivityType(ACTIVITY_NEW), mAccountTitle(""),
                mUpdateTimer(), mActivityTimer(), mFrame(0) 
        {
                mTrustNetScore.setRequestDelay(0.1f);
                mTrustNetScore.setMaxPending(8);
                mFrame = gFrameCount;
        }

        void setPosition(LLVector3d position);

        LLVector3d getPosition();

        U32 getEntryAgeFrames();

        F32 getEntryAgeSeconds();

        LLString getName();

        void setName(LLString name);

        LLUUID getID();

        void setID(LLUUID id);

        BOOL getIsLinden();

        void setAccountCustomTitle(LLString &title);

        LLString getAccountCustomTitle();

        void setActivity(ACTIVITY_TYPE activity);

        ACTIVITY_TYPE getActivity();

        void setFocus(BOOL value) { mFocused = value; }

        BOOL isFocused() { return mFocused; }


        BOOL isMarked();

        BOOL isDead();

        void toggleMark();
private:
        friend class LLFloaterAvatarList;

        LLUUID mID;
        LLString mName;
        LLVector3d mPosition;
        BOOL mMarked;
        BOOL mFocused;
        BOOL mIsLinden;

        ACTIVITY_TYPE mActivityType;

        LLString mAccountTitle;

        LLAvatarListDatum<LLAvListTrustNetScore> mTrustNetScore;
        LLAvatarListDatum<LLAvatarInfo>   mAvatarInfo;
        LLAvatarListDatum<LLMiscDBInfo> mMiscInfo;

        LLTimer mUpdateTimer;

        LLTimer mActivityTimer;

        U32 mFrame;
};


class LLFloaterAvatarList : public LLFloater
{
public:
        LLFloaterAvatarList();
        ~LLFloaterAvatarList();

        void show();

        virtual void onClose(bool app_quitting) { setVisible(FALSE); }

        static void toggle(void*);

        static BOOL visible(void*);

        void updateAvatarList();

        void refreshAvatarList();

        static void processAvatarPropertiesReply(LLMessageSystem *msg, void**);

        BOOL avatarIsInList(LLUUID avatar);

        LLAvatarListEntry* getAvatarEntry(LLUUID avatar);

        void requestTrustNetScore(LLUUID avatar, const LLString name, const LLString type);

        void requestMiscInfo(LLUUID avatar, const LLString name);

        static BOOL handleIM(LLUUID from_id, const LLString message);

        static void processTrustNetReply(char *reply);

        LLString getSelectedNames(const LLString& separator = ", ");

private:
        // when a line editor loses keyboard focus, it is committed.
        // commit callbacks are named onCommitWidgetName by convention.
        //void onCommitBaz(LLUICtrl* ctrl, void *userdata);
        
        enum AVATARS_COLUMN_ORDER
        {
                LIST_AVATAR_ICON,
                LIST_AVATAR_NAME,
                LIST_DISTANCE,
                LIST_AGE,
                LIST_SCORE,
                LIST_PAYMENT,
                LIST_ACTIVITY
        };

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

        void speakText(S32 channel, EChatType type, LLString text);

        void removeFocusFromAll();

        void focusOnPrev(BOOL marked_only);

        void focusOnNext(BOOL marked_only);

        //static void onClickRefresh(void* userdata);

        static void onClickProfile(void *userdata);
        static void onClickIM(void *userdata);
        static void onClickTrack(void *userdata);
        static void onClickMark(void *userdata);

        static void onClickGohomerMark(void *userdata);
        static void onClickGohomerWarn(void *userdata);
        static void onClickGohomerEject(void *userdata);
        static void onClickGohomerSendAway(void *userdata);
        static void onClickGohomerSendHome(void *userdata);
        static void onClickGohomerSendHomeByKey(void *userdata);

        static void onClickGohomerOff(void *userdata);


        static void onClickPrevInList(void *userdata);
        static void onClickNextInList(void *userdata);
        static void onClickPrevMarked(void *userdata);
        static void onClickNextMarked(void *userdata);
        static void onClickGetKey(void *userdata);

        static void onClickTrustNetRate(void *userdata);
        static void onClickTrustNetExplain(void *userdata);
        static void onClickTrustNetWebsite(void *userdata);
        static void onClickTrustNetGetPassword(void *userdata);
        static void onClickTrustNetRenew(void *userdata);

        static void onDoubleClick(void *userdata);

        static void onClickFreeze(void *userdata);
        static void onClickEject(void *userdata);
//      static void onClickBan(void *userdata);
//      static void onClickUnban(void *userdata);
        static void onClickMute(void *userdata);
//      static void onClickUnmute(void *userdata);
        static void onClickAR(void *userdata);
        static void onClickTeleport(void *userdata);
        static void onClickEjectFromEstate(void *userdata);

        static void callbackFreeze(S32 option, void *userdata);
//      static void callbackUnfreeze(S32 option, void *userdata);
        static void callbackEject(S32 option, void *userdata);
//      static void callbackBan(S32 option, void *userdata);
        static void callbackMute(S32 option, void *userdata);
//      static void callbackUnmute(void *userdata);
        static void callbackAR(void *userdata);
        static void callbackEjectFromEstate(S32 option, void *userdata);

        void doCommand(avlist_command_t cmd);

        void expireAvatarList();

        void luskwoodCommand(LLString cmd);

        static void handleLuskwoodDialog(S32 option, void* data);

        static void handleLuskwoodGohomerOffDialog(S32 option, void* data);

        void processARQueue();
private:
        LLScrollListCtrl*                       mAvatarList;
        std::map<LLUUID, LLAvatarListEntry>     mAvatars;

        std::queue<LLUUID> mARQueue;

        std::queue<LLFloaterReporter*> mARReporterQueue;

        S32 mARLastFrame;
        
        
        void sendAvatarPropertiesRequest(LLUUID avid);

        void checkTrackingStatus();

        //LLColor4 getAvatarColor(LLAvatarListEntry *ent, F32 distance);
        LLColor4 getAvatarColor(LLAvatarListEntry *ent, F32 distance, e_coloring_type type);

        static void replaceVars(LLString &str, LLUUID avatar, const LLString& name);

        // tracking data
        BOOL mTracking;             // tracking?
        BOOL mTrackByLocation;      // TRUE if tracking by known position, FALSE for tracking a friend
        LLUUID mTrackedAvatar;     // who we're tracking

        LLTimer mDataRequestTimer;

        LLTimer mTrustNetTimer;

        LLString mLuskwoodCommand;

        LLUUID mFocusedAvatar;
        //e_coloring_type mColoringType;
};

extern LLFloaterAvatarList* gFloaterAvatarList;

---