Second Life viewer sources 1.13.2.12

1 files changed, 287 insertions, 0 deletions

diff --git a/linden/indra/newview/llconsole.cpp b/linden/indra/newview/llconsole.cpp
new file mode 100644
index 0000000..1ed0e17
--- /dev/null
+++ b/linden/indra/newview/llconsole.cpp
@@ -0,0 +1,287 @@
+/** 
+ * @file llconsole.cpp
+ * @brief a scrolling console output device
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#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"
+#include "viewer.h"
+
+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();
+}
+
+EWidgetType LLConsole::getWidgetType() const
+{
+        return WIDGET_TYPE_CONSOLE;
+}
+
+LLString LLConsole::getWidgetTag() const
+{
+        return LL_CONSOLE_TAG;
+}
+
+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(mRect.getWidth(), gViewerWindow->getWindowWidth()));
+        S32 new_height = llmax(llfloor(mFont->getLineHeight()) + 15, llmin(mRect.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;
+
+        // skip lines added more than mLinePersistTime ago
+        F32 cur_time = mTimer.getElapsedTimeF32();
+        
+        if( gStartupState != 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
+        {
+                LLUUID image_id;
+                image_id.set(gViewerArt.getString("rounded_square.tga"));
+                LLViewerImage* imagep = gImageList.getImage(image_id, MIPMAP_FALSE, TRUE);
+
+                F32 console_opacity = llclamp(gSavedSettings.getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
+                LLColor4 color(0.f, 0.f, 0.f, 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)));
+                gl_draw_scaled_image_with_border(-15, -10, 16, 16, mLastBoxWidth + 15, mLastBoxHeight,
+                                                                imagep, color, TRUE );
+        }
+
+        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)
+{
+        if (!wline.empty() && mFont != NULL)
+        {
+                // Wrap lines that are longer than the view is wide.
+                S32 offset = 0;
+                while( offset < (S32)wline.length() )
+                {
+                        S32 skip_chars; // skip '\n'
+                        // Figure out if a word-wrapped line fits here.
+                        LLWString::size_type line_end = wline.find_first_of(llwchar('\n'), offset);
+                        if (line_end != LLWString::npos)
+                        {
+                                skip_chars = 1; // skip '\n'
+                        }
+                        else
+                        {
+                                line_end = wline.size();
+                                skip_chars = 0;
+                        }
+                        U32 drawable = mFont->maxDrawableChars(wline.c_str()+offset, (F32)mRect.getWidth(), line_end-offset, TRUE);
+                        if (drawable != 0)
+                        {
+                                LLFixedBuffer::addLine(wline.substr(offset, drawable));
+                        }
+                        else
+                        {
+                                // force a blank line
+                                LLFixedBuffer::addLine(" ");
+                        }
+                        mColors.push_back(color);
+                        offset += (drawable + skip_chars);
+                }
+        }
+}
+
+void LLConsole::removeExtraLines()
+{
+        while((S32)mColors.size() > llmax(0, (S32)(mMaxLines - 1)))
+        {
+                mColors.pop_front();
+        }
+        LLFixedBuffer::removeExtraLines();
+}