llconsole.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llconsole.h"

// linden library includes
#include "llmath.h"
#include "llviewercontrol.h"
#include "llcriticaldamp.h"
#include "llfontgl.h"
#include "llgl.h"
#include "llui.h"
#include "llviewerimage.h"
#include "llviewerimagelist.h"
#include "llviewerwindow.h"
#include "llfontgl.h"
#include "llmath.h"

#include "llstartup.h"

// Used for LCD display
extern void AddNewDebugConsoleToLCD(const LLWString &newLine);

LLConsole* gConsole = NULL;  // Created and destroyed in LLViewerWindow.

const F32 FADE_DURATION = 2.f;
const S32 MIN_CONSOLE_WIDTH = 200;
 
LLConsole::LLConsole(const std::string& name, const U32 max_lines, const LLRect &rect, 
                                         S32 font_size_index, F32 persist_time ) 
        : 
        LLFixedBuffer(max_lines),
        LLView(name, rect, FALSE),
        mLastBoxHeight(0),
        mLastBoxWidth(0)
{
        mLinePersistTime = persist_time;                // seconds
        mFadeTime = persist_time - FADE_DURATION;

        setFontSize( font_size_index );
        setMaxLines(gSavedSettings.getS32("ConsoleMaxLines"));
}

LLConsole::~LLConsole()
{
        mColors.clear();
}

void LLConsole::setLinePersistTime(F32 seconds)
{
        mLinePersistTime = seconds;
        mFadeTime = mLinePersistTime - FADE_DURATION;
}

void LLConsole::reshape(S32 width, S32 height, BOOL called_from_parent)
{
        S32 new_width = llmax(50, llmin(getRect().getWidth(), gViewerWindow->getWindowWidth()));
        S32 new_height = llmax(llfloor(mFont->getLineHeight()) + 15, llmin(getRect().getHeight(), gViewerWindow->getWindowHeight()));

        LLView::reshape(new_width, new_height, called_from_parent);
}

void LLConsole::setFontSize(S32 size_index)
{
        if (-1 == size_index)
        {
                mFont = LLFontGL::sMonospace;
        }
        else if (0 == size_index)
        {
                mFont = LLFontGL::sSansSerif;
        }
        else if (1 == size_index)
        {
                mFont = LLFontGL::sSansSerifBig;
        }
        else
        {
                mFont = LLFontGL::sSansSerifHuge;
        }
}

void LLConsole::draw()
{
        LLGLSUIDefault gls_ui;

        addQueuedLines();

        // skip lines added more than mLinePersistTime ago
        F32 cur_time = mTimer.getElapsedTimeF32();
        
        if( LLStartUp::getStartupState() != STATE_STARTED )
        {
                S32 count = mLines.size();
                S32 i = 0;
                while( count-- )
                {
                        mAddTimes[i] = cur_time;
                        i = (i+1) % mMaxLines;
                }
        }

        F32 skip_time = cur_time - mLinePersistTime;
        F32 fade_time = cur_time - mFadeTime;

        // draw remaining lines
        F32 x_pos = 0.f;
        F32 y_pos = 0.f;

        S32 line_count = mLines.size();

        // remove stale lines
        for (S32 line_num = 0; line_num < line_count; line_num++)
        {
                if((mLinePersistTime > 0.f) && (mAddTimes[0] - skip_time)/(mLinePersistTime - mFadeTime) <= 0.f)
                {
                        mLines.pop_front();
                        mAddTimes.pop_front();
                        mLineLengths.pop_front();
                        mColors.pop_front();
                }
        }

        line_count = mLines.size();

        S32 i;
        if (line_count == 0)
        {
                mLastBoxHeight = 0;
                mLastBoxWidth = 0;
                return;
        }
        else
        {
                LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");

                F32 console_opacity = llclamp(gSavedSettings.getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
                LLColor4 color = gColors.getColor("ConsoleBackground");
                color.mV[VALPHA] *= console_opacity;

                S32 max_width = 0;
                for (i = 0; i < line_count; i++)
                {
                        max_width = llmax(max_width, mFont->getWidth(mLines[i].c_str()) + 30);
                }
                max_width = llmin(max_width, gViewerWindow->getWindowWidth());

                F32 u = 1.f;//LLCriticalDamp::getInterpolant(0.1f);
                S32 target_height = llfloor(line_count * mFont->getLineHeight() + 15);
                S32 target_width = max_width;
                mLastBoxHeight = llmax(target_height, (S32)lerp((F32)mLastBoxHeight, (F32)target_height, u));
                mLastBoxWidth = llmax(MIN_CONSOLE_WIDTH, llmax(target_width, (S32)lerp((F32)mLastBoxWidth, (F32)target_width, u)));
                imagep->drawSolid(-15, -10, mLastBoxWidth + 15, mLastBoxHeight, color);
        }

        y_pos += (line_count-1) * mFont->getLineHeight();


        for (i = 0; i < line_count; i++)
        {
                F32 alpha;

                if ((mLinePersistTime > 0.f) && (mAddTimes[i] < fade_time))
                {
                        alpha = (mAddTimes[i] - skip_time)/(mLinePersistTime - mFadeTime);
                }
                else
                {
                        alpha = 1.0f;
                }

                if( alpha > 0.f )
                {
                        // text line itself
                        mFont->render(mLines[i], 0, x_pos, y_pos,
                                LLColor4(
                                        mColors[i].mV[VRED], 
                                        mColors[i].mV[VGREEN], 
                                        mColors[i].mV[VBLUE], 
                                        mColors[i].mV[VALPHA]*alpha),
                                LLFontGL::LEFT, 
                                LLFontGL::BASELINE,
                                LLFontGL::DROP_SHADOW,
                                S32_MAX,
                                mLastBoxWidth
                                );
                }

                y_pos -= mFont->getLineHeight();
        }
}

void LLConsole::addLine(const LLString& utf8line)
{
        LLWString wline = utf8str_to_wstring(utf8line);
        addLine(wline, 0.f, LLColor4(1.f, 1.f, 1.f, 1.f));
}

void LLConsole::addLine(const LLWString& wline)
{
        addLine(wline, 0.f, LLColor4(1.f, 1.f, 1.f, 1.f));
}

void LLConsole::addLine(const LLString& utf8line, F32 size, const LLColor4 &color)
{
        LLWString wline = utf8str_to_wstring(utf8line);
        addLine(wline, size, color);
}

void LLConsole::addLine(const LLWString& wline, F32 size, const LLColor4 &color)
{
        while (mLineQueue.size() >= mMaxLines)
        {
                mLineQueue.pop_front();
        }
        mLineQueue.push_back(LineInfo(wline, size, color, mTimer.getElapsedTimeF32()));
#if LL_WINDOWS && LL_LCD_COMPILE
        // add to LCD screen
        AddNewDebugConsoleToLCD(wline);
#endif  
}

void LLConsole::addQueuedLines()
{
        for (line_queue_t::iterator iter = mLineQueue.begin();
                 iter != mLineQueue.end(); ++iter)
        {
                LineInfo& line_info = *iter;
                LLWString wline = line_info.wline;
                //F32 size = line_info.size;
                LLColor4 color = line_info.color;
                if (!wline.empty() && mFont != NULL)
                {
                        // Wrap lines that are longer than the view is wide.
                        S32 line_start_offset = 0;
                        while( line_start_offset < (S32)wline.length() )
                        {
                                // Find the next '\n', if any
                                LLWString::size_type line_end = wline.find_first_of(llwchar('\n'), line_start_offset);
                                if (LLWString::npos == line_end)
                                {
                                        // no more '\n's, try to use the whole line
                                        line_end = wline.size();
                                }
                                // Find how many characters will reasonably fit in the allowed width
                                U32 drawable = mFont->maxDrawableChars(wline.c_str()+line_start_offset, (F32)getRect().getWidth(), line_end-line_start_offset, TRUE);
                                if (drawable != 0)
                                {
                                        LLFixedBuffer::addLine(wline.substr(line_start_offset, drawable));
                                        mAddTimes[mAddTimes.size()-1] = line_info.add_time;
                                        
                                        // move the line_start_offset by the number of characters we were able to draw, up to an implicit or explicit line-break.
                                        line_start_offset += drawable;
                                }
                                else
                                {
                                        // no drawable characters - force a blank line and try the next character.
                                        LLFixedBuffer::addLine(" ");
                                        line_start_offset++;
                                }
                                mColors.push_back(color);
                                // if this was an *explicit* line-break or the end of the text, then increment the offset for the start of the next line (if any).
                                if (line_start_offset == line_end)
                                {
                                        line_start_offset++;
                                }
                        }
                }
        }
        mLineQueue.clear();
}

void LLConsole::removeExtraLines()
{
        while((S32)mColors.size() > llmax(0, (S32)(mMaxLines - 1)))
        {
                mColors.pop_front();
        }
        LLFixedBuffer::removeExtraLines();
}

---