llfloaterchat.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#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 "llresizehandle.h"
#include "llchatbar.h"
#include "llstatusbar.h"
#include "llviewertexteditor.h"
#include "llviewergesture.h"                    // for triggering gestures
#include "llviewermessage.h"
#include "llviewerwindow.h"
#include "llviewercontrol.h"
#include "lluictrlfactory.h"
#include "llchatbar.h"
#include "lllogchat.h"
#include "lltexteditor.h"
#include "llfloaterhtml.h"
#include "llweb.h"
#include "llstylemap.h"

// 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 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;
        LLUICtrlFactory::getInstance()->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 = getChild<LLChatBar>("chat_panel", TRUE);
        if (chat_barp)
        {
                chat_barp->refresh();
        }

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

BOOL LLFloaterChat::postBuild()
{
        mPanel = (LLPanelActiveSpeakers*)getChild<LLPanel>("active_speakers_panel");

        LLChatBar* chat_barp = getChild<LLChatBar>("chat_panel", TRUE);
        if (chat_barp)
        {
                chat_barp->setGestureCombo(getChild<LLComboBox>( "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.
        updateConsoleVisibility();

        // stop chat history tab from flashing when it appears
        if (new_visibility)
        {
                LLFloaterChatterBox::getInstance()->setFloaterFlashing(this, FALSE);
        }

        LLFloater::onVisibilityChange(new_visibility);
}

void LLFloaterChat::setMinimized(BOOL minimized)
{
        LLFloater::setMinimized(minimized);
        updateConsoleVisibility();
}


void LLFloaterChat::updateConsoleVisibility()
{
        // determine whether we should show console due to not being visible
        gConsole->setVisible( !isInVisibleChain()                                                               // are we not in part of UI being drawn?
                                                        || isMinimized()                                                                // are we minimized?
                                                        || (getHost() && getHost()->isMinimized() ));   // are we hosted in a minimized floater?
}

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

        // If the msg is not from an agent (not yourself though),
        // extract out the sender name and replace it with the hotlinked name.
        if (chat.mSourceType == CHAT_SOURCE_AGENT &&
                chat.mFromID != LLUUID::null &&
                (line.length() > chat.mFromName.length() && line.find(chat.mFromName,0) == 0))
        {
                line = line.substr(chat.mFromName.length());
                const LLStyleSP &sourceStyle = LLStyleMap::instance().lookup(chat.mFromID);
                edit->appendStyledText(chat.mFromName, false, false, &sourceStyle);
        }
        edit->appendColoredText(line, false, prepend_newline, color);
}

void log_chat_text(const LLChat& chat)
{
                LLString histstr;
                if (gSavedPerAccountSettings.getBOOL("LogChatTimestamp"))
                        histstr = LLLogChat::timestamp(gSavedPerAccountSettings.getBOOL("LogTimestampDate")) + chat.mText;
                else
                        histstr = chat.mText;

                LLLogChat::saveHistory("chat",histstr);
}
// 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 = chat_floater->getChild<LLViewerTextEditor>("Chat History Editor");
        LLViewerTextEditor*     history_editor_with_mute = chat_floater->getChild<LLViewerTextEditor>("Chat History Editor with mute");

        history_editor->setParseHTML(TRUE);
        history_editor_with_mute->setParseHTML(TRUE);
        
        if (!chat.mMuted)
        {
                add_timestamped_line(history_editor, chat, color);
                add_timestamped_line(history_editor_with_mute, chat, color);
        }
        else
        {
                // desaturate muted chat
                LLColor4 muted_color = lerp(color, LLColor4::grey, 0.5f);
                add_timestamped_line(history_editor_with_mute, chat, 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);
        }

        // start tab flashing on incoming text from other users (ignoring system text, etc)
        if (!chat_floater->isInVisibleChain() && chat.mSourceType == CHAT_SOURCE_AGENT)
        {
                LLFloaterChatterBox::getInstance()->setFloaterFlashing(chat_floater, TRUE);
        }
}

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


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

        LLComboBox*     chatter_combo = self->getChild<LLComboBox>("chatter combobox");

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

        if (name.empty()) return;

        LLMute mute(id);
        mute.setFromDisplayName(name);
        LLMuteList::getInstance()->add(mute);
        
        LLFloaterMute::showInstance();
}

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


        //LLCheckBoxCtrl*       
        BOOL show_mute = floater->getChild<LLCheckBoxCtrl>("show mutes")->get();
        LLViewerTextEditor*     history_editor = floater->getChild<LLViewerTextEditor>("Chat History Editor");
        LLViewerTextEditor*     history_editor_with_mute = floater->getChild<LLViewerTextEditor>("Chat History Editor with mute");

        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 from_instant_message, 
                          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;
                if (chat.mSourceType == CHAT_SOURCE_SYSTEM)
                {
                        text_color = gSavedSettings.getColor("SystemChatColor");
                }
                else if(from_instant_message)
                {
                        text_color = gSavedSettings.getColor("IMChatColor");
                        size = INSTANT_MSG_SIZE;
                }
                gConsole->addLine(chat.mText, size, text_color);
        }

        if(from_instant_message && gSavedPerAccountSettings.getBOOL("LogChatIM"))
                log_chat_text(chat);
        
        if(from_instant_message && gSavedSettings.getBOOL("IMInChatHistory"))
                addChatHistory(chat,false);
        
        if(!from_instant_message)
                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(LLLogChat::ELogLineType type , LLString line, void* userdata)
{
        switch (type)
        {
        case LLLogChat::LOG_EMPTY:
        case LLLogChat::LOG_END:
                // *TODO: nice message from XML file here
                break;
        case LLLogChat::LOG_LINE:
                {
                        LLChat chat;                                    
                        chat.mText = line;
                        addChatHistory(chat,  FALSE);
                }
                break;
        default:
                // nothing
                break;
        }
}

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

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

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

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

//static 
bool LLFloaterChat::visible(LLFloater* instance, const LLSD& key)
{
        return VisibilityPolicy<LLFloater>::visible(instance, key);
}

//static 
void LLFloaterChat::show(LLFloater* instance, const LLSD& key)
{
        VisibilityPolicy<LLFloater>::show(instance, key);
}

//static 
void LLFloaterChat::hide(LLFloater* instance, const LLSD& key)
{
        if(instance->getHost())
        {
                LLFloaterChatterBox::hideInstance();
        }
        else
        {
                VisibilityPolicy<LLFloater>::hide(instance, key);
        }
}

---