llfloaterchat.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"
#include <iostream>

#include "llfloaterchat.h"
#include "llfloateractivespeakers.h"
#include "llfloaterscriptdebug.h"

#include "llchat.h"
#include "llfontgl.h"
#include "llrect.h"
#include "llerror.h"
#include "llstring.h"
#include "message.h"

// project include
#include "llagent.h"
#include "llbutton.h"
#include "llcheckboxctrl.h"
#include "llcombobox.h"
#include "llconsole.h"
#include "llfloaterchatterbox.h"
#include "llfloatermute.h"
#include "llkeyboard.h"
//#include "lllineeditor.h"
#include "llmutelist.h"
#include "llregionnamecache.h"
//#include "llresizehandle.h"
#include "llchatbar.h"
#include "lllineeditor.h"
#include "llstatusbar.h"
#include "lltextbox.h"
#include "llviewertexteditor.h"
#include "llviewergesture.h"                    // for triggering gestures
#include "llviewermessage.h"
#include "llviewerwindow.h"
#include "llviewercontrol.h"
#include "llvieweruictrlfactory.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llchatbar.h"
#include "lllogchat.h"
#include "lltexteditor.h"
#include "llfloaterhtml.h"
#include "llweb.h"

#include <algorithm>  // For find

// Used for LCD display
extern void AddNewIMToLCD(const LLString &newLine);
extern void AddNewChatToLCD(const LLString &newLine);
//
// Constants
//
const F32 INSTANT_MSG_SIZE = 8.0f;
const F32 CHAT_MSG_SIZE = 8.0f;
const LLColor4 INSTANT_MSG_COLOR(1, 1, 1, 1);
const LLColor4 MUTED_MSG_COLOR(0.5f, 0.5f, 0.5f, 1.f);
const S32 MAX_CHATTER_COUNT = 16;

//
// Global statics
//
LLColor4 get_text_color(const LLChat& chat);

//
// Member Functions
//
LLFloaterChat::LLFloaterChat(const LLSD& seed)
:       LLFloater("chat floater", "FloaterChatRect", "", 
                          RESIZE_YES, 440, 100, DRAG_ON_TOP, MINIMIZE_NO, CLOSE_YES),
        mPanel(NULL)
{
        mFactoryMap["chat_panel"] = LLCallbackMap(createChatPanel, NULL);
        mFactoryMap["active_speakers_panel"] = LLCallbackMap(createSpeakersPanel, NULL);
        // do not automatically open singleton floaters (as result of getInstance())
        BOOL no_open = FALSE;
        gUICtrlFactory->buildFloater(this,"floater_chat_history.xml",&getFactoryMap(),no_open);

        childSetCommitCallback("show mutes",onClickToggleShowMute,this); //show mutes
        childSetVisible("Chat History Editor with mute",FALSE);
        childSetAction("toggle_active_speakers_btn", onClickToggleActiveSpeakers, this);
        setDefaultBtn("Chat");
}

LLFloaterChat::~LLFloaterChat()
{
        // Children all cleaned up by default view destructor.
}

void LLFloaterChat::setVisible(BOOL visible)
{
        LLFloater::setVisible( visible );

        gSavedSettings.setBOOL("ShowChatHistory", visible);
}

void LLFloaterChat::draw()
{
        // enable say and shout only when text available
                
        childSetValue("toggle_active_speakers_btn", childIsVisible("active_speakers_panel"));

        LLChatBar* chat_barp = (LLChatBar*)getChildByName("chat_panel", TRUE);
        if (chat_barp)
        {
                chat_barp->refresh();
        }

        mPanel->refreshSpeakers();
        LLFloater::draw();
}

BOOL LLFloaterChat::postBuild()
{
        mPanel = (LLPanelActiveSpeakers*)LLUICtrlFactory::getPanelByName(this, "active_speakers_panel");

        LLChatBar* chat_barp = (LLChatBar*)getChildByName("chat_panel", TRUE);
        if (chat_barp)
        {
                chat_barp->setGestureCombo(LLUICtrlFactory::getComboBoxByName(this, "Gesture"));
        }
        return TRUE;
}

// public virtual
void LLFloaterChat::onClose(bool app_quitting)
{
        if (!app_quitting)
        {
                gSavedSettings.setBOOL("ShowChatHistory", FALSE);
        }
        setVisible(FALSE);
}

void LLFloaterChat::onVisibilityChange(BOOL new_visibility)
{
        // Hide the chat overlay when our history is visible.
        gConsole->setVisible( !new_visibility );
        LLFloater::onVisibilityChange(new_visibility);
}


void add_timestamped_line(LLViewerTextEditor* edit, const LLString& line, const LLColor4& color)
{
        bool prepend_newline = true;
        if (gSavedSettings.getBOOL("ChatShowTimestamps"))
        {
                edit->appendTime(prepend_newline);
                prepend_newline = false;
        }
        edit->appendColoredText(line, false, prepend_newline, color);
}

void log_chat_text(const LLChat& chat)
{
                LLString histstr;
                if ( chat.mFromIM )
                        histstr = "IM: ";

                if (gSavedPerAccountSettings.getBOOL("LogChatTimestamp"))
                        histstr += LLLogChat::timestamp(gSavedPerAccountSettings.getBOOL("LogTimestampDate")) + chat.mText;
                else
                        histstr += chat.mText;

                LLLogChat::saveHistory("chat",histstr);
}

LLString LLFloaterChat::getChatAvatar(const LLChat& chat)
{
        if ( chat.mFromIM || chat.mSourceType == CHAT_SOURCE_AGENT )
        {
                // Chat is from an IM, so the speaker is the actual avatar
                return getAvatarName(chat.mFromID, chat.mFromName);
        }
        else
        {
                // this is llSay or similar, the speaker is the object
                LLUUID chatter_id = mObjectOwners[chat.mFromID].mOwnerID;
                mObjectOwners[chat.mFromID].mObjectName = chat.mFromName;

                if ( chatter_id.isNull() )
                {
                        // Owner is unknown, request
                        requestObjectOwner(chat.mFromID, chat.mSourceHost);
                        return "";
                }
                else
                {
                        return getAvatarName(chatter_id, chat.mFromName);
                }
        }
}


LLString LLFloaterChat::getAvatarName(const LLUUID &speaker_id, const LLString &speaker_name)
{
        LLString ret = "";      

        if ( !speaker_id.isNull() )
        {
                // Get actual name of the speaker. This will differ if it's an object talking
                char first_name[DB_FIRST_NAME_BUF_SIZE];                /* Flawfinder: ignore */
                char last_name[DB_FIRST_NAME_BUF_SIZE];         /* Flawfinder: ignore */
                first_name[0] = '\0';
                last_name[0] = '\0';

                if ( gCacheName->getName(speaker_id, first_name, last_name) )
                {
                        // Name was in cache, good
                        ret = first_name;
                        ret += " ";
                        ret += last_name;
        
                        if ( ret == speaker_name )
                        {
                                // Don't add the info if it matches what would appear as the speaker's name
                                ret = "";
                        }
                }
                else
                {
                        // Name not in the cache, but we don't want to lose it, so we queue it up.
                        LLNameLookupEntry ent(speaker_id, speaker_name);

                        std::deque<LLNameLookupEntry>::iterator pos = std::find(mLookupQueue.begin(), mLookupQueue.end(), ent);
                        S32 dist = 0;

                        if ( pos == mLookupQueue.end() )
                        {
                                mLookupQueue.push_back(ent);
                                dist = mLookupQueue.size();

                                // request the name, write to window later.
                                gCacheName->get(speaker_id, FALSE, cache_name_callback, this);
                        }
                        else
                        {
                                dist = std::distance(mLookupQueue.begin(), pos);
                        }

                        std::ostringstream o;
                        o << dist+1;

                        ret = "";
                }
        }

        return ret;
}

//static
void LLFloaterChat::requestObjectOwner(const LLUUID &object_id, const LLHost &host)
{
        if ( object_id.isNull() ) return;

        llinfos << "Requesting object data for " << object_id << llendl;

        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, object_id );
        
//      LLViewerObject *chatter = gObjectList.findObject(object_id);
//      LLViewerRegion *regionp;
//      if ( chatter )
//      {
//              regionp = chatter->getRegion();
//      }
//      else
//      {
//              llwarns << "Couldn't find speaking object " << object_id << ", don't know which region to use for the message. Trying with agent's" << llendl;
//              regionp = gAgent.getRegion();
//      }


        //msg->sendReliable( regionp->getHost() );
        msg->sendReliable( host );
}

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

        LLUUID id;
        LLUUID owner_id;
        U32 request_flags;

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

        LLFloaterChat* chat_floater = LLFloaterChat::getInstance(LLSD());

        llinfos << "Processing properties for " << id << ". Owner is " << owner_id << llendl;

        if ( chat_floater->mObjectOwners.count( id ) > 0 )
        {
                // We've got an entry for this object, so we were looking for information on it
                LLOwnerCacheEntry *ent = &chat_floater->mObjectOwners[id];

                if ( ent->mOwnerID == LLUUID::null )
                {
                        // We were looking for info, and it just arrived.
                        llinfos << "First arrival of requested data for object " << id << llendl;
                        LLString name = chat_floater->getAvatarName(owner_id, ent->mObjectName);
                        if ( !name.empty() )
                        {
                                LLChat chat(ent->mObjectName + " is owned by " + name);
                                chat.mFromName = "Name Lookup";
                                addChatHistory(chat);
                        }
                        else
                        {
                                llinfos << "Got owner, but name lookup failed for " << owner_id << ", queueing up" << llendl;
                        }
                }

                ent->mOwnerID = owner_id;
        }
}
//static
void LLFloaterChat::cache_name_callback(const LLUUID &id, const char *first, const char *last, BOOL is_group, void *data)
{
        LLFloaterChat *floater = (LLFloaterChat*)data;

        std::deque<LLNameLookupEntry>::iterator pos = std::find(floater->mLookupQueue.begin(), floater->mLookupQueue.end(), LLNameLookupEntry(id));
        if ( pos == floater->mLookupQueue.end() )
        {
                llwarns << "Strange, callback called, but we weren't looking for UUID " << id << llendl;
                return;
        }

        LLString name = first;
        name += " ";
        name += last;

        LLChat chat(pos->mObject + " is owned by " + name);
        chat.mFromName = "Name Lookup";

        floater->mLookupQueue.erase(pos);
        addChatHistory(chat);
}

// static
LLString LLFloaterChat::getChatPosition(const LLChat &chat)
{
        if ( chat.mRegionID.isNull() ) return "";
        return llformat("secondlife://%s/%.0f/%.0f/%.0f", gRegionNameCache->get( chat.mRegionID ).c_str(),
                                                          chat.mPosAgent.mV[VX],
                                                          chat.mPosAgent.mV[VY],
                                                          chat.mPosAgent.mV[VZ]);
}

// static
void LLFloaterChat::addChatHistory(const LLChat& chat, bool log_to_file)
{       
        if ( gSavedPerAccountSettings.getBOOL("LogChat") && log_to_file) 
        {
                log_chat_text(chat);
        }
        
        LLColor4 color = get_text_color(chat);
        
        if (!log_to_file) color = LLColor4::grey;       //Recap from log file.

        if (chat.mChatType == CHAT_TYPE_DEBUG_MSG)
        {
                LLFloaterScriptDebug::addScriptLine(chat.mText,
                                                                                        chat.mFromName, 
                                                                                        color, 
                                                                                        chat.mFromID);
                if (!gSavedSettings.getBOOL("ScriptErrorsAsChat"))
                {
                        return;
                }
        }
        
        // could flash the chat button in the status bar here. JC
        LLFloaterChat* chat_floater = LLFloaterChat::getInstance(LLSD());
        LLViewerTextEditor*     history_editor = (LLViewerTextEditor*)chat_floater->getChildByName("Chat History Editor", TRUE);
        LLViewerTextEditor*     history_editor_with_mute = (LLViewerTextEditor*)chat_floater->getChildByName("Chat History Editor with mute", TRUE);

        history_editor->setParseHTML(TRUE);
        history_editor_with_mute->setParseHTML(TRUE);
        
        LLString owner_coords_line;

        if ( LLUICtrlFactory::getCheckBoxByName(chat_floater,"log owner coords")->get() )
        {
                // Add owner and position info, if needed
                if ( !chat.mFromID.isNull() && chat.mSourceType == CHAT_SOURCE_OBJECT )
                {
                        owner_coords_line = chat_floater->getChatAvatar(chat);
                        if ( owner_coords_line.empty() )
                        {
                                owner_coords_line = "(requesting)";
                        }
                }

                LLString pos = getChatPosition(chat);

                if ( !pos.empty() && !owner_coords_line.empty() ) 
                {
                        owner_coords_line = "Owner: " + owner_coords_line;
                        owner_coords_line += " ";
                }

                if ( ! pos.empty() )
                {
                        owner_coords_line += "at ";
                        owner_coords_line += pos;
                }

                if ( ! owner_coords_line.empty() )
                {
                        owner_coords_line = " [" + owner_coords_line + "]";
                        //owner_coords_line = " " + owner_coords_line;
                }
        }

        LLString chat_text(chat.mText + owner_coords_line);
        if ( chat.mFromIM )
        {
                chat_text = "IM: " + chat_text;
        }

        if (!chat.mMuted)
        {
                add_timestamped_line(history_editor, chat_text, color);
                add_timestamped_line(history_editor_with_mute, chat_text, color);
        }
        else
        {
                // desaturate muted chat
                LLColor4 muted_color = lerp(color, LLColor4::grey, 0.5f);
                add_timestamped_line(history_editor_with_mute, chat_text, color);
        }
        
        // add objects as transient speakers that can be muted
        if (chat.mSourceType == CHAT_SOURCE_OBJECT)
        {
                chat_floater->mPanel->setSpeaker(chat.mFromID, chat.mFromName, LLSpeaker::STATUS_NOT_IN_CHANNEL, LLSpeaker::SPEAKER_OBJECT);
        }
}

// static
void LLFloaterChat::setHistoryCursorAndScrollToEnd()
{
        LLViewerTextEditor*     history_editor = (LLViewerTextEditor*)LLFloaterChat::getInstance(LLSD())->getChildByName("Chat History Editor", TRUE);
        LLViewerTextEditor*     history_editor_with_mute = (LLViewerTextEditor*)LLFloaterChat::getInstance(LLSD())->getChildByName("Chat History Editor with mute", TRUE);
        
        history_editor->setCursorAndScrollToEnd();
        history_editor_with_mute->setCursorAndScrollToEnd();
}


//static 
void LLFloaterChat::onClickMute(void *data)
{
        LLFloaterChat* self = (LLFloaterChat*)data;

        LLComboBox*     chatter_combo = LLUICtrlFactory::getComboBoxByName(self,"chatter combobox");

        const LLString& name = chatter_combo->getSimple();
        LLUUID id = chatter_combo->getCurrentID();

        if (name.empty()) return;

        LLMute mute(id);
        mute.setFromDisplayName(name);
        gMuteListp->add(mute);
        
        if (gFloaterMute)
        {
                gFloaterMute->show();
        }
}

//static
void LLFloaterChat::onClickToggleShowMute(LLUICtrl* caller, void *data)
{
        LLFloaterChat* floater = (LLFloaterChat*)data;


        //LLCheckBoxCtrl*       
        BOOL show_mute = LLUICtrlFactory::getCheckBoxByName(floater,"show mutes")->get();
        LLViewerTextEditor*     history_editor = (LLViewerTextEditor*)floater->getChildByName("Chat History Editor", TRUE);
        LLViewerTextEditor*     history_editor_with_mute = (LLViewerTextEditor*)floater->getChildByName("Chat History Editor with mute", TRUE);

        if (!history_editor || !history_editor_with_mute)
                return;

        //BOOL show_mute = floater->mShowMuteCheckBox->get();
        if (show_mute)
        {
                history_editor->setVisible(FALSE);
                history_editor_with_mute->setVisible(TRUE);
                history_editor_with_mute->setCursorAndScrollToEnd();
        }
        else
        {
                history_editor->setVisible(TRUE);
                history_editor_with_mute->setVisible(FALSE);
                history_editor->setCursorAndScrollToEnd();
        }
}

// Put a line of chat in all the right places
void LLFloaterChat::addChat(const LLChat& chat,
                          BOOL local_agent)
{
        LLColor4 text_color = get_text_color(chat);

        BOOL invisible_script_debug_chat = 
                        chat.mChatType == CHAT_TYPE_DEBUG_MSG
                        && !gSavedSettings.getBOOL("ScriptErrorsAsChat");

#if LL_WINDOWS && LL_LCD_COMPILE
        // add into LCD displays
        if (!invisible_script_debug_chat)
        {
                if (!from_instant_message)
                {
                        AddNewChatToLCD(chat.mText);
                }
                else
                {
                        AddNewIMToLCD(chat.mText);
                }
        }
#endif
        if (!invisible_script_debug_chat 
                && !chat.mMuted 
                && gConsole 
                && !local_agent)
        {
                F32 size = CHAT_MSG_SIZE;
                LLString prefix;
                if(chat.mFromIM)
                {
                        text_color = INSTANT_MSG_COLOR;
                        size = INSTANT_MSG_SIZE;
                        prefix = "IM: ";
                }
                gConsole->addLine(prefix + chat.mText, size, text_color);
        }

        if(chat.mFromIM && gSavedPerAccountSettings.getBOOL("LogChatIM"))
                log_chat_text(chat);
        
        if(chat.mFromIM && (gSavedSettings.getBOOL("IMInChatHistory") || chat.mSourceType != CHAT_SOURCE_AGENT) )
                addChatHistory(chat,false);
        
        if(!chat.mFromIM)
                addChatHistory(chat);
}

LLColor4 get_text_color(const LLChat& chat)
{
        LLColor4 text_color;

        if(chat.mMuted)
        {
                text_color.setVec(0.8f, 0.8f, 0.8f, 1.f);
        }
        else
        {
                switch(chat.mSourceType)
                {
                case CHAT_SOURCE_SYSTEM:
                        text_color = gSavedSettings.getColor4("SystemChatColor");
                        break;
                case CHAT_SOURCE_AGENT:
                    if (chat.mFromID.isNull())
                        {
                                text_color = gSavedSettings.getColor4("SystemChatColor");
                        }
                        else
                        {
                                text_color = gSavedSettings.getColor4("AgentChatColor");
                        }
                        break;
                case CHAT_SOURCE_OBJECT:
                        if (chat.mChatType == CHAT_TYPE_DEBUG_MSG)
                        {
                                text_color = gSavedSettings.getColor4("ScriptErrorColor");
                        }
                        else if ( chat.mChatType == CHAT_TYPE_OWNER )
                        {
                                text_color = gSavedSettings.getColor4("llOwnerSayChatColor");
                        }
                        else
                        {
                                text_color = gSavedSettings.getColor4("ObjectChatColor");
                        }
                        break;
                default:
                        text_color.setToWhite();
                }

                if (!chat.mPosAgent.isExactlyZero())
                {
                        LLVector3 pos_agent = gAgent.getPositionAgent();
                        F32 distance = dist_vec(pos_agent, chat.mPosAgent);
                        if (distance > gAgent.getNearChatRadius())
                        {
                                // diminish far-off chat
                                text_color.mV[VALPHA] = 0.8f;
                        }
                }
        }

        return text_color;
}

//static
void LLFloaterChat::loadHistory()
{
        LLLogChat::loadHistory("chat", &chatFromLogFile, (void *)LLFloaterChat::getInstance(LLSD())); 
}

//static
void LLFloaterChat::chatFromLogFile(LLString line, void* userdata)
{
        LLChat chat;
                                
        chat.mText = line;
        addChatHistory(chat,  FALSE);
}

//static
void* LLFloaterChat::createSpeakersPanel(void* data)
{
        return new LLPanelActiveSpeakers(gLocalSpeakerMgr, TRUE);
}

//static
void* LLFloaterChat::createChatPanel(void* data)
{
        LLChatBar* chatp = new LLChatBar("floating_chat_bar");
        return chatp;
}

//static 
void LLFloaterChat::hideInstance(const LLSD& id)
{
        LLFloaterChat* floaterp = LLFloaterChat::getInstance(LLSD());
        // don't do anything when hosted in the chatterbox
        if(floaterp->getHost())
        {
                LLFloaterChatterBox::hideInstance(LLSD());
        }
        else
        {
                LLUISingleton<LLFloaterChat>::hideInstance(id);
        }
}

// static
void LLFloaterChat::onClickToggleActiveSpeakers(void* userdata)
{
        LLFloaterChat* self = (LLFloaterChat*)userdata;

        self->childSetVisible("active_speakers_panel", !self->childIsVisible("active_speakers_panel"));
}

---