First version of the SOurce SDK 2013

1 files changed, 2744 insertions, 0 deletions

diff --git a/mp/src/vgui2/vgui_controls/RichText.cpp b/mp/src/vgui2/vgui_controls/RichText.cpp
new file mode 100644
index 00000000..c4c76682
--- /dev/null
+++ b/mp/src/vgui2/vgui_controls/RichText.cpp
@@ -0,0 +1,2744 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

+// $NoKeywords: $

+//=============================================================================//

+

+#include "vgui_controls/pch_vgui_controls.h"

+#include "vgui/ILocalize.h"

+

+// memdbgon must be the last include file in a .cpp file

+#include "tier0/memdbgon.h"

+

+enum

+{

+	MAX_BUFFER_SIZE = 999999,	// maximum size of text buffer

+	DRAW_OFFSET_X =	3,

+	DRAW_OFFSET_Y =	1,

+};

+

+using namespace vgui;

+

+#ifndef max

+#define max(a,b)            (((a) > (b)) ? (a) : (b))

+#endif

+

+namespace vgui

+{

+

+//#define DRAW_CLICK_PANELS

+	

+//-----------------------------------------------------------------------------

+// Purpose: Panel used for clickable URL's

+//-----------------------------------------------------------------------------

+class ClickPanel : public Panel

+{

+	DECLARE_CLASS_SIMPLE( ClickPanel, Panel );

+

+public:

+	ClickPanel(Panel *parent)

+	{

+		_viewIndex = 0;

+		_textIndex = 0;

+		SetParent(parent);

+		AddActionSignalTarget(parent);

+		

+		SetCursor(dc_hand);

+		

+		SetPaintBackgroundEnabled(false);

+		SetPaintEnabled(false);

+//		SetPaintAppearanceEnabled(false);

+

+#if defined( DRAW_CLICK_PANELS )

+		SetPaintEnabled(true);

+#endif

+	}

+	

+	void SetTextIndex( int linkStartIndex, int viewStartIndex )

+	{

+		_textIndex = linkStartIndex;

+		_viewIndex = viewStartIndex;

+	}

+

+#if defined( DRAW_CLICK_PANELS )

+	virtual void Paint()

+	{

+		surface()->DrawSetColor( Color( 255, 0, 0, 255 ) );

+		surface()->DrawOutlinedRect( 0, 0, GetWide(), GetTall() );

+	}

+#endif

+	

+	int GetTextIndex()

+	{

+		return _textIndex;

+	}

+

+	int GetViewTextIndex()

+	{

+		return _viewIndex;

+	}

+	

+	void OnMousePressed(MouseCode code)

+	{

+		if (code == MOUSE_LEFT)

+		{

+			PostActionSignal(new KeyValues("ClickPanel", "index", _textIndex));

+		}

+		else

+		{

+			GetParent()->OnMousePressed( code );

+		}

+	}

+

+private:

+	int _textIndex;

+	int _viewIndex;

+};

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Panel used only to draw the interior border region

+//-----------------------------------------------------------------------------

+class RichTextInterior : public Panel

+{

+	DECLARE_CLASS_SIMPLE( RichTextInterior, Panel );

+

+public:

+	RichTextInterior( RichText *pParent, const char *pchName ) : BaseClass( pParent, pchName )  

+	{

+		SetKeyBoardInputEnabled( false );

+		SetMouseInputEnabled( false );

+		SetPaintBackgroundEnabled( false );

+		SetPaintEnabled( false );

+		m_pRichText = pParent;

+	}

+

+/*	virtual IAppearance *GetAppearance()

+	{

+		if ( m_pRichText->IsScrollbarVisible() )

+			return m_pAppearanceScrollbar;

+

+		return BaseClass::GetAppearance();

+	}*/

+

+	virtual void ApplySchemeSettings( IScheme *pScheme )

+	{

+		BaseClass::ApplySchemeSettings( pScheme );

+//		m_pAppearanceScrollbar = FindSchemeAppearance( pScheme, "scrollbar_visible" );

+	}

+

+private:

+	RichText *m_pRichText;

+//	IAppearance *m_pAppearanceScrollbar;    

+};

+	

+};	// namespace vgui

+

+DECLARE_BUILD_FACTORY( RichText );

+

+//-----------------------------------------------------------------------------

+// Purpose: Constructor

+//-----------------------------------------------------------------------------

+RichText::RichText(Panel *parent, const char *panelName) : BaseClass(parent, panelName)

+{

+	m_bAllTextAlphaIsZero = false;

+	_font = INVALID_FONT;

+	m_hFontUnderline = INVALID_FONT;

+

+	m_bRecalcLineBreaks = true;

+	m_pszInitialText = NULL;

+	_cursorPos = 0;

+	_mouseSelection = false;

+	_mouseDragSelection = false;

+	_vertScrollBar = new ScrollBar(this, "ScrollBar", true);

+	_vertScrollBar->AddActionSignalTarget(this);

+	_recalcSavedRenderState = true;

+	_maxCharCount = (64 * 1024);

+	AddActionSignalTarget(this);

+	m_pInterior = new RichTextInterior( this, NULL );

+

+	//a -1 for _select[0] means that the selection is empty

+	_select[0] = -1;

+	_select[1] = -1;

+	m_pEditMenu = NULL;

+	

+	SetCursor(dc_ibeam);

+	

+	//position the cursor so it is at the end of the text

+	GotoTextEnd();

+	

+	// set default foreground color to black

+	_defaultTextColor =  Color(0, 0, 0, 0);

+	

+	// initialize the line break array

+	InvalidateLineBreakStream();

+

+	if ( IsProportional() )

+	{

+		int width, height;

+		int sw,sh;

+		surface()->GetProportionalBase( width, height );

+		surface()->GetScreenSize(sw, sh);

+		

+		_drawOffsetX = static_cast<int>( static_cast<float>( DRAW_OFFSET_X )*( static_cast<float>( sw )/ static_cast<float>( width )));

+		_drawOffsetY = static_cast<int>( static_cast<float>( DRAW_OFFSET_Y )*( static_cast<float>( sw )/ static_cast<float>( width )));

+	}

+	else

+	{

+		_drawOffsetX = DRAW_OFFSET_X;

+		_drawOffsetY = DRAW_OFFSET_Y;

+	}

+

+	// add a basic format string

+	TFormatStream stream;

+	stream.color = _defaultTextColor;

+	stream.fade.flFadeStartTime = 0.0f;

+	stream.fade.flFadeLength = -1.0f;

+	stream.pixelsIndent = 0;

+	stream.textStreamIndex = 0;

+	stream.textClickable = false;

+	m_FormatStream.AddToTail(stream);

+

+	m_bResetFades = false;

+	m_bInteractive = true;

+	m_bUnusedScrollbarInvis = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Destructor

+//-----------------------------------------------------------------------------

+RichText::~RichText()

+{

+	delete [] m_pszInitialText;

+	delete m_pEditMenu;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::SetDrawOffsets( int ofsx, int ofsy )

+{

+	_drawOffsetX = ofsx;

+	_drawOffsetY = ofsy;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: sets it as drawing text only - used for embedded RichText control into other text drawing situations

+//-----------------------------------------------------------------------------

+void RichText::SetDrawTextOnly()

+{

+	SetDrawOffsets( 0, 0 );

+	SetPaintBackgroundEnabled( false );

+//	SetPaintAppearanceEnabled( false );

+	SetPostChildPaintEnabled( false );

+	m_pInterior->SetVisible( false );

+	SetVerticalScrollbar( false );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: configures colors

+//-----------------------------------------------------------------------------

+void RichText::ApplySchemeSettings(IScheme *pScheme)

+{

+	BaseClass::ApplySchemeSettings(pScheme);

+	

+	_font = pScheme->GetFont("Default", IsProportional() );

+	m_hFontUnderline = pScheme->GetFont("DefaultUnderline", IsProportional() );

+	

+	SetFgColor(GetSchemeColor("RichText.TextColor", pScheme));

+	SetBgColor(GetSchemeColor("RichText.BgColor", pScheme));

+	

+	_selectionTextColor = GetSchemeColor("RichText.SelectedTextColor", GetFgColor(), pScheme);

+	_selectionColor = GetSchemeColor("RichText.SelectedBgColor", pScheme);

+

+	if ( Q_strlen( pScheme->GetResourceString( "RichText.InsetX" ) ) )

+	{

+		SetDrawOffsets( atoi( pScheme->GetResourceString( "RichText.InsetX" ) ), atoi( pScheme->GetResourceString( "RichText.InsetY" ) ) );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: if the default format color isn't set then set it

+//-----------------------------------------------------------------------------

+void RichText::SetFgColor( Color color )

+{

+	// Replace default format color if 

+	// the stream is empty and the color is the default ( or the previous FgColor )

+	if ( m_FormatStream.Size() == 1 && 

+		( m_FormatStream[0].color == _defaultTextColor || m_FormatStream[0].color == GetFgColor() ) )

+	{

+		m_FormatStream[0].color = color;

+	}

+	

+	BaseClass::SetFgColor( color );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sends a message if the data has changed

+//          Turns off any selected text in the window if we are not using the edit menu

+//-----------------------------------------------------------------------------

+void RichText::OnKillFocus()

+{

+	// check if we clicked the right mouse button or if it is down

+	bool mouseRightClicked = input()->WasMousePressed(MOUSE_RIGHT);

+	bool mouseRightUp = input()->WasMouseReleased(MOUSE_RIGHT);

+	bool mouseRightDown = input()->IsMouseDown(MOUSE_RIGHT);

+	

+	if (mouseRightClicked || mouseRightDown || mouseRightUp )

+	{

+		// get the start and ends of the selection area

+		int start, end;

+		if (GetSelectedRange(start, end)) // we have selected text

+		{

+			// see if we clicked in the selection area

+			int startX, startY;

+			CursorToPixelSpace(start, startX, startY);

+			int endX, endY;

+			CursorToPixelSpace(end, endX, endY);

+			int cursorX, cursorY;

+			input()->GetCursorPos(cursorX, cursorY);

+			ScreenToLocal(cursorX, cursorY);

+			

+			// check the area vertically

+			// we need to handle the horizontal edge cases eventually

+			int fontTall = GetLineHeight();

+			endY = endY + fontTall;

+			if ((startY < cursorY) && (endY > cursorY))

+			{

+				// if we clicked in the selection area, leave the text highlighted

+				return;

+			}

+		}

+	}

+	

+	// clear any selection

+	SelectNone();

+

+	// chain

+	BaseClass::OnKillFocus();

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Wipe line breaks after the size of a panel has been changed

+//-----------------------------------------------------------------------------

+void RichText::OnSizeChanged( int wide, int tall )

+{

+	BaseClass::OnSizeChanged( wide, tall );

+

+   	// blow away the line breaks list 

+	_invalidateVerticalScrollbarSlider = true;

+	InvalidateLineBreakStream();

+	InvalidateLayout();

+

+	if ( _vertScrollBar->IsVisible() )

+	{

+		_vertScrollBar->MakeReadyForUse();

+		m_pInterior->SetBounds( 0, 0, wide - _vertScrollBar->GetWide(), tall );

+	}

+	else

+	{

+		m_pInterior->SetBounds( 0, 0, wide, tall );

+	}

+}

+

+

+const wchar_t *RichText::ResolveLocalizedTextAndVariables( char const *pchLookup, wchar_t *outbuf, size_t outbufsizeinbytes )

+{

+	if ( pchLookup[ 0 ] == '#' )

+	{

+		// try lookup in localization tables

+		StringIndex_t index = g_pVGuiLocalize->FindIndex( pchLookup + 1 );

+		if ( index == INVALID_LOCALIZE_STRING_INDEX )

+		{

+/*			// if it's not found, maybe it's a special expanded variable - look for an expansion

+			char rgchT[MAX_PATH];

+

+			// get the variables

+			KeyValues *variables = GetDialogVariables_R();

+			if ( variables )

+			{

+				// see if any are any special vars to put in

+				for ( KeyValues *pkv = variables->GetFirstSubKey(); pkv != NULL; pkv = pkv->GetNextKey() )

+				{

+					if ( !Q_strncmp( pkv->GetName(), "$", 1 ) )

+					{

+						// make a new lookup, with this key appended

+						Q_snprintf( rgchT, sizeof( rgchT ), "%s%s=%s", pchLookup, pkv->GetName(), pkv->GetString() );

+						index = localize()->FindIndex( rgchT );

+						break;

+					}

+				}

+			}

+			*/

+		}

+

+		// see if we have a valid string

+		if ( index != INVALID_LOCALIZE_STRING_INDEX )

+		{

+			wchar_t *format = g_pVGuiLocalize->GetValueByIndex( index );

+			Assert( format );

+			if ( format )

+			{

+				/*// Try and substitute variables if any

+				KeyValues *variables = GetDialogVariables_R();

+				if ( variables )

+				{

+					localize()->ConstructString( outbuf, outbufsizeinbytes, index, variables );

+					return outbuf;

+				}*/

+			}

+			V_wcsncpy( outbuf, format, outbufsizeinbytes );

+			return outbuf;

+		}

+	}

+

+	Q_UTF8ToUnicode( pchLookup, outbuf, outbufsizeinbytes );

+	return outbuf;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the text array

+//          Using this function will cause all lineBreaks to be discarded.

+//          This is because this fxn replaces the contents of the text buffer.

+//          For modifying large buffers use insert functions.

+//-----------------------------------------------------------------------------

+void RichText::SetText(const char *text)

+{

+	if (!text)

+	{

+		text = "";

+	}

+

+	wchar_t unicode[1024];

+

+	if (text[0] == '#')

+	{

+		ResolveLocalizedTextAndVariables( text, unicode, sizeof( unicode ) );

+		SetText( unicode );

+		return;

+	}

+

+	// convert to unicode

+	Q_UTF8ToUnicode(text, unicode, sizeof(unicode));

+	SetText(unicode);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::SetText(const wchar_t *text)

+{

+	// reset the formatting stream

+	m_FormatStream.RemoveAll();

+	TFormatStream stream;

+	stream.color = GetFgColor();

+	stream.fade.flFadeLength = -1.0f;

+	stream.fade.flFadeStartTime = 0.0f;

+	stream.pixelsIndent = 0;

+	stream.textStreamIndex = 0;

+	stream.textClickable = false;

+	m_FormatStream.AddToTail(stream);

+

+	// set the new text stream

+	m_TextStream.RemoveAll();

+	if ( text && *text )

+	{

+		int textLen = wcslen(text) + 1;

+		m_TextStream.EnsureCapacity(textLen);

+		for(int i = 0; i < textLen; i++)

+		{

+			m_TextStream.AddToTail(text[i]);

+		}

+	}

+	GotoTextStart();

+	SelectNone();

+	

+	// blow away the line breaks list 

+	InvalidateLineBreakStream();

+	InvalidateLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Given cursor's position in the text buffer, convert it to

+//			the local window's x and y pixel coordinates

+// Input:	cursorPos: cursor index

+// Output:	cx, cy, the corresponding coords in the local window

+//-----------------------------------------------------------------------------

+void RichText::CursorToPixelSpace(int cursorPos, int &cx, int &cy)

+{

+	int yStart = _drawOffsetY;

+	int x = _drawOffsetX, y = yStart;

+	_pixelsIndent = 0;

+	int lineBreakIndexIndex = 0;

+	

+	for (int i = GetStartDrawIndex(lineBreakIndexIndex); i < m_TextStream.Count(); i++)

+	{

+		wchar_t ch = m_TextStream[i];

+		

+		// if we've found the position, break

+		if (cursorPos == i)

+		{

+			// if we've passed a line break go to that

+			if (m_LineBreaks[lineBreakIndexIndex] == i)

+			{

+				// add another line

+				AddAnotherLine(x, y);

+				lineBreakIndexIndex++;

+			}

+			break;

+		}

+		

+		// if we've passed a line break go to that

+		if (m_LineBreaks[lineBreakIndexIndex] == i)

+		{

+			// add another line

+			AddAnotherLine(x, y);

+			lineBreakIndexIndex++;

+		}

+		

+		// add to the current position

+		x += surface()->GetCharacterWidth(_font, ch);

+	}

+	

+	cx = x;

+	cy = y;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Converts local pixel coordinates to an index in the text buffer

+//-----------------------------------------------------------------------------

+int RichText::PixelToCursorSpace(int cx, int cy)

+{

+	int fontTall = GetLineHeight();

+	

+	// where to start reading

+	int yStart = _drawOffsetY;

+	int x = _drawOffsetX, y = yStart;

+	_pixelsIndent = 0;

+	int lineBreakIndexIndex = 0;

+	

+	int startIndex = GetStartDrawIndex(lineBreakIndexIndex);

+	if (_recalcSavedRenderState)

+	{

+		RecalculateDefaultState(startIndex);

+	}

+	

+	_pixelsIndent = m_CachedRenderState.pixelsIndent;

+	_currentTextClickable = m_CachedRenderState.textClickable;

+	TRenderState renderState = m_CachedRenderState;

+	

+	bool onRightLine = false;

+	int i;

+	for (i = startIndex; i < m_TextStream.Count(); i++)

+	{

+		wchar_t ch = m_TextStream[i];

+

+		renderState.x = x;

+		if ( UpdateRenderState( i, renderState ) )

+		{

+			x = renderState.x;

+		}

+

+		// if we are on the right line but off the end of if put the cursor at the end of the line

+		if (m_LineBreaks[lineBreakIndexIndex] == i)

+		{

+			// add another line

+			AddAnotherLine(x, y);

+			lineBreakIndexIndex++;

+			

+			if (onRightLine)

+				break;

+		}

+		

+		// check to see if we're on the right line

+		if (cy < yStart)

+		{

+			// cursor is above panel

+			onRightLine = true;

+		}

+		else if (cy >= y && (cy < (y + fontTall + _drawOffsetY)))

+		{

+			onRightLine = true;

+		}

+		

+		int wide = surface()->GetCharacterWidth(_font, ch);

+		

+		// if we've found the position, break

+		if (onRightLine)

+		{

+			if (cx > GetWide())	  // off right side of window

+			{

+			}

+			else if (cx < (_drawOffsetX + renderState.pixelsIndent) || cy < yStart)	 // off left side of window

+			{

+				// Msg( "PixelToCursorSpace() off left size, returning %d '%c'\n", i, m_TextStream[i] );

+				return i; // move cursor one to left

+			}

+			

+			if (cx >= x && cx < (x + wide))

+			{

+				// check which side of the letter they're on

+				if (cx < (x + (wide * 0.5)))  // left side

+				{

+					// Msg( "PixelToCursorSpace() on the left size, returning %d '%c'\n", i, m_TextStream[i] );

+					return i;

+				}

+				else  // right side

+				{						 

+					// Msg( "PixelToCursorSpace() on the right size, returning %d '%c'\n", i + 1, m_TextStream[i + 1] );

+					return i + 1;

+				}

+			}

+		}

+		x += wide;

+	}

+	

+	// Msg( "PixelToCursorSpace() never hit, returning %d\n", i );

+	return i;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Draws a string of characters in the panel

+// Input:	iFirst - Index of the first character to draw

+//			iLast - Index of the last character to draw

+//			renderState - Render state to use

+//			font- font to use

+// Output:	returns the width of the character drawn

+//-----------------------------------------------------------------------------

+int RichText::DrawString(int iFirst, int iLast, TRenderState &renderState, HFont font)

+{

+//	VPROF( "RichText::DrawString" );

+

+	// Calculate the render size

+	int fontTall = surface()->GetFontTall(font);

+	// BUGBUG John: This won't exactly match the rendered size

+	int charWide = 0;

+	for ( int i = iFirst; i <= iLast; i++ )

+	{

+		wchar_t ch = m_TextStream[i];

+#if USE_GETKERNEDCHARWIDTH

+		wchar_t chBefore = 0;

+		wchar_t chAfter = 0;

+		if ( i > 0 )

+			chBefore = m_TextStream[i-1];

+		if ( i < iLast )

+			chAfter = m_TextStream[i+1];

+		float flWide = 0.0f, flabcA = 0.0f;

+		surface()->GetKernedCharWidth(font, ch, chBefore, chAfter, flWide, flabcA);

+		if ( ch == L' ' )

+			flWide = ceil( flWide );

+		charWide += floor( flWide + 0.6 );

+#else

+		charWide += surface()->GetCharacterWidth(font, ch);

+#endif

+	}

+

+	// draw selection, if any

+	int selection0 = -1, selection1 = -1;

+	GetSelectedRange(selection0, selection1);

+		

+	if (iFirst >= selection0 && iFirst < selection1)

+	{

+		// draw background selection color

+		surface()->DrawSetColor(_selectionColor);

+		surface()->DrawFilledRect(renderState.x, renderState.y, renderState.x + charWide, renderState.y + 1 + fontTall);

+		

+		// reset text color

+		surface()->DrawSetTextColor(_selectionTextColor);

+		m_bAllTextAlphaIsZero = false;

+	}

+	else

+	{

+		surface()->DrawSetTextColor(renderState.textColor);

+	}

+		

+	if ( renderState.textColor.a() != 0 )

+	{

+		m_bAllTextAlphaIsZero = false;

+		surface()->DrawSetTextPos(renderState.x, renderState.y);

+		surface()->DrawPrintText(&m_TextStream[iFirst], iLast - iFirst + 1);

+	}

+			

+	return charWide;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Finish drawing url

+//-----------------------------------------------------------------------------

+void RichText::FinishingURL(int x, int y)

+{

+	// finishing URL

+	if ( _clickableTextPanels.IsValidIndex( _clickableTextIndex ) )

+	{

+		ClickPanel *clickPanel = _clickableTextPanels[ _clickableTextIndex ];

+		int px, py;

+		clickPanel->GetPos(px, py);

+		int fontTall = GetLineHeight();

+		clickPanel->SetSize( MAX( x - px, 6 ), y - py + fontTall );

+		clickPanel->SetVisible(true);

+

+		// if we haven't actually advanced any, step back and ignore this one

+		// this is probably a data input problem though, need to find root cause

+		if ( x - px <= 0 )

+		{

+			--_clickableTextIndex;

+			clickPanel->SetVisible(false);

+		}

+	}

+}

+

+void RichText::CalculateFade( TRenderState &renderState )

+{

+	if ( m_FormatStream.IsValidIndex( renderState.formatStreamIndex ) )

+	{

+		if ( m_bResetFades == false )

+		{

+			if ( m_FormatStream[renderState.formatStreamIndex].fade.flFadeLength != -1.0f )

+			{

+				float frac = ( m_FormatStream[renderState.formatStreamIndex].fade.flFadeStartTime -  system()->GetCurrentTime() ) / m_FormatStream[renderState.formatStreamIndex].fade.flFadeLength;

+

+				int alpha = frac * m_FormatStream[renderState.formatStreamIndex].fade.iOriginalAlpha;

+				alpha = clamp( alpha, 0, m_FormatStream[renderState.formatStreamIndex].fade.iOriginalAlpha );

+

+				renderState.textColor.SetColor( renderState.textColor.r(), renderState.textColor.g(), renderState.textColor.b(), alpha );

+			}

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Draws the text in the panel

+//-----------------------------------------------------------------------------

+void RichText::Paint()

+{

+	// Assume the worst

+	m_bAllTextAlphaIsZero = true;

+

+	HFont hFontCurrent = _font;

+		

+	// hide all the clickable panels until we know where they are to reside

+	for (int j = 0; j < _clickableTextPanels.Count(); j++)

+	{

+		_clickableTextPanels[j]->SetVisible(false);

+	}

+

+	if ( !HasText() )

+		return;

+

+	int wide, tall;

+	GetSize( wide, tall );

+

+	int lineBreakIndexIndex = 0;

+	int startIndex = GetStartDrawIndex(lineBreakIndexIndex);

+	_currentTextClickable = false;

+	

+	_clickableTextIndex = GetClickableTextIndexStart(startIndex);

+	

+	// recalculate and cache the render state at the render start

+	if (_recalcSavedRenderState)

+	{

+		RecalculateDefaultState(startIndex);

+	}

+	// copy off the cached render state

+	TRenderState renderState = m_CachedRenderState;

+		

+	_pixelsIndent = m_CachedRenderState.pixelsIndent;

+	_currentTextClickable = m_CachedRenderState.textClickable;

+

+	renderState.textClickable = _currentTextClickable;

+	renderState.textColor = m_FormatStream[renderState.formatStreamIndex].color;

+	CalculateFade( renderState );

+	

+	renderState.formatStreamIndex++;

+

+	if ( _currentTextClickable )

+	{

+		_clickableTextIndex = startIndex;

+	}

+

+	// where to start drawing

+	renderState.x = _drawOffsetX + _pixelsIndent;

+	renderState.y = _drawOffsetY;

+	

+	// draw the text

+	int selection0 = -1, selection1 = -1;

+	GetSelectedRange(selection0, selection1);

+

+	surface()->DrawSetTextFont( hFontCurrent );

+

+	for (int i = startIndex; i < m_TextStream.Count() && renderState.y < tall; )

+	{

+		// 1.

+		// Update our current render state based on the formatting and color streams,

+		// this has to happen if it's our very first iteration, or if we are actually changing

+		// state.

+		int nXBeforeStateChange = renderState.x;

+		if ( UpdateRenderState(i, renderState) || i == startIndex )

+		{

+			// check for url state change

+			if (renderState.textClickable != _currentTextClickable)

+			{

+				if (renderState.textClickable)

+				{

+					// entering new URL

+					_clickableTextIndex++;

+					hFontCurrent = m_hFontUnderline;

+					surface()->DrawSetTextFont( hFontCurrent );

+					

+					// set up the panel

+					ClickPanel *clickPanel = _clickableTextPanels.IsValidIndex( _clickableTextIndex ) ? _clickableTextPanels[_clickableTextIndex] : NULL;

+					

+					if (clickPanel)

+					{

+						clickPanel->SetPos(renderState.x, renderState.y);

+					}

+				}

+				else

+				{

+					FinishingURL(nXBeforeStateChange, renderState.y);

+					hFontCurrent = _font;

+					surface()->DrawSetTextFont( hFontCurrent );

+				}

+				_currentTextClickable = renderState.textClickable;

+			}

+		}

+		

+		// 2.

+		// if we've passed a line break go to that

+		if ( m_LineBreaks.IsValidIndex( lineBreakIndexIndex ) && m_LineBreaks[lineBreakIndexIndex] <= i )

+		{

+			if (_currentTextClickable)

+			{

+				FinishingURL(renderState.x, renderState.y);

+			}

+			

+			// add another line

+			AddAnotherLine(renderState.x, renderState.y);

+			lineBreakIndexIndex++;

+

+			// Skip white space unless the previous line ended from the hard carriage return

+			if ( i && ( m_TextStream[i-1] != '\n' ) && ( m_TextStream[i-1] != '\r') )

+			{

+				while ( m_TextStream[i] == L' ' )

+				{

+					if ( i+1 < m_TextStream.Count() )

+						++i;

+					else

+						break;

+				}

+			}

+

+			if (renderState.textClickable)

+			{

+				// move to the next URL

+				_clickableTextIndex++;

+				ClickPanel *clickPanel = _clickableTextPanels.IsValidIndex( _clickableTextIndex ) ? _clickableTextPanels[_clickableTextIndex] : NULL;

+				if (clickPanel)

+				{

+					clickPanel->SetPos(renderState.x, renderState.y);

+				}

+			}

+		}

+

+		// 3.

+		// Calculate the range of text to draw all at once

+		int iLim = m_TextStream.Count();

+		

+		// Stop at the next format change

+		if ( m_FormatStream.IsValidIndex(renderState.formatStreamIndex) && 

+			m_FormatStream[renderState.formatStreamIndex].textStreamIndex < iLim &&

+			m_FormatStream[renderState.formatStreamIndex].textStreamIndex >= i &&

+			m_FormatStream[renderState.formatStreamIndex].textStreamIndex )

+		{

+			iLim = m_FormatStream[renderState.formatStreamIndex].textStreamIndex;

+		}

+

+		// Stop at the next line break

+		if ( m_LineBreaks.IsValidIndex( lineBreakIndexIndex ) && m_LineBreaks[lineBreakIndexIndex] < iLim )

+			iLim = m_LineBreaks[lineBreakIndexIndex];

+

+		// Handle non-drawing characters specially

+		for ( int iT = i; iT < iLim; iT++ )

+		{

+			if ( iswcntrl(m_TextStream[iT]) )

+			{

+				iLim = iT;

+				break;

+			}

+		}

+

+		// 4.

+		// Draw the current text range

+		if ( iLim <= i )

+		{

+			if ( m_TextStream[i] == '\t' )

+			{

+				int dxTabWidth = 8 * surface()->GetCharacterWidth(hFontCurrent, ' ');

+				dxTabWidth = MAX( 1, dxTabWidth );

+

+				renderState.x = ( dxTabWidth * ( 1 + ( renderState.x / dxTabWidth ) ) );

+			}

+			i++;

+		}

+		else

+		{

+			renderState.x += DrawString(i, iLim - 1, renderState, hFontCurrent );

+			i = iLim;

+		}

+	}

+

+	if (renderState.textClickable)

+	{

+		FinishingURL(renderState.x, renderState.y);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+int RichText::GetClickableTextIndexStart(int startIndex)

+{

+	// cycle to the right url panel	for what is visible	after the startIndex.

+	for (int i = 0; i < _clickableTextPanels.Count(); i++)

+	{

+		if (_clickableTextPanels[i]->GetViewTextIndex() >= startIndex)

+		{

+			return i - 1;

+		}

+	}

+	return -1;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Recalcultes the formatting state from the specified index

+//-----------------------------------------------------------------------------

+void RichText::RecalculateDefaultState(int startIndex)

+{

+	if (!HasText() )

+		return;

+

+	Assert(startIndex < m_TextStream.Count());

+

+	m_CachedRenderState.textColor = GetFgColor();

+	_pixelsIndent = 0;

+	_currentTextClickable = false;

+	_clickableTextIndex = GetClickableTextIndexStart(startIndex);

+	

+	// find where in the formatting stream we need to be

+	GenerateRenderStateForTextStreamIndex(startIndex, m_CachedRenderState);

+	_recalcSavedRenderState = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: updates a render state based on the formatting and color streams

+// Output:	true if we changed the render state

+//-----------------------------------------------------------------------------

+bool RichText::UpdateRenderState(int textStreamPos, TRenderState &renderState)

+{

+	// check the color stream

+	if (m_FormatStream.IsValidIndex(renderState.formatStreamIndex) && 

+		m_FormatStream[renderState.formatStreamIndex].textStreamIndex == textStreamPos)

+	{

+		// set the current formatting

+		renderState.textColor = m_FormatStream[renderState.formatStreamIndex].color;

+		renderState.textClickable = m_FormatStream[renderState.formatStreamIndex].textClickable;

+

+		CalculateFade( renderState );

+

+		int indentChange = m_FormatStream[renderState.formatStreamIndex].pixelsIndent - renderState.pixelsIndent;

+		renderState.pixelsIndent = m_FormatStream[renderState.formatStreamIndex].pixelsIndent;

+

+		if (indentChange)

+		{

+			renderState.x = renderState.pixelsIndent + _drawOffsetX;

+		}

+

+		//!! for supporting old functionality, store off state in globals

+		_pixelsIndent = renderState.pixelsIndent;

+

+		// move to the next position in the color stream

+		renderState.formatStreamIndex++;

+		return true;

+	}

+

+	return false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the index in the format stream for the specified text stream index

+//-----------------------------------------------------------------------------

+int RichText::FindFormatStreamIndexForTextStreamPos(int textStreamIndex)

+{

+	int formatStreamIndex = 0;

+	for (; m_FormatStream.IsValidIndex(formatStreamIndex); formatStreamIndex++)

+	{

+		if (m_FormatStream[formatStreamIndex].textStreamIndex > textStreamIndex)

+			break;

+	}

+

+	// step back to the color change before the new line

+	formatStreamIndex--;

+	if (!m_FormatStream.IsValidIndex(formatStreamIndex))

+	{

+		formatStreamIndex = 0;

+	}

+	return formatStreamIndex;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Generates a base renderstate given a index into the text stream

+//-----------------------------------------------------------------------------

+void RichText::GenerateRenderStateForTextStreamIndex(int textStreamIndex, TRenderState &renderState)

+{

+	// find where in the format stream we need to be given the specified place in the text stream

+	renderState.formatStreamIndex = FindFormatStreamIndexForTextStreamPos(textStreamIndex);

+	

+	// copy the state data

+	renderState.textColor = m_FormatStream[renderState.formatStreamIndex].color;

+	renderState.pixelsIndent = m_FormatStream[renderState.formatStreamIndex].pixelsIndent;

+	renderState.textClickable = m_FormatStream[renderState.formatStreamIndex].textClickable;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Called pre render

+//-----------------------------------------------------------------------------

+void RichText::OnThink()

+{

+	if (m_bRecalcLineBreaks)

+	{

+		_recalcSavedRenderState = true;

+		RecalculateLineBreaks();

+		

+		// recalculate scrollbar position

+		if (_invalidateVerticalScrollbarSlider)

+		{

+			LayoutVerticalScrollBarSlider();

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Called when data changes or panel size changes

+//-----------------------------------------------------------------------------

+void RichText::PerformLayout()

+{

+	BaseClass::PerformLayout();

+

+	// force a Repaint

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: inserts a color change into the formatting stream

+//-----------------------------------------------------------------------------

+void RichText::InsertColorChange(Color col)

+{

+	// see if color already exists in text stream

+	TFormatStream &prevItem = m_FormatStream[m_FormatStream.Count() - 1];

+	if (prevItem.color == col)

+	{

+		// inserting same color into stream, just ignore

+	}

+	else if (prevItem.textStreamIndex == m_TextStream.Count())

+	{

+		// this item is in the same place; update values

+		prevItem.color = col;

+	}

+	else

+	{

+		// add to text stream, based off existing item

+		TFormatStream streamItem = prevItem;

+		streamItem.color = col;

+		streamItem.textStreamIndex = m_TextStream.Count();

+		m_FormatStream.AddToTail(streamItem);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: inserts a fade into the formatting stream

+//-----------------------------------------------------------------------------

+void RichText::InsertFade( float flSustain, float flLength )

+{

+	// see if color already exists in text stream

+	TFormatStream &prevItem = m_FormatStream[m_FormatStream.Count() - 1];

+	if (prevItem.textStreamIndex == m_TextStream.Count())

+	{

+		// this item is in the same place; update values

+		prevItem.fade.flFadeStartTime = system()->GetCurrentTime() + flSustain;

+		prevItem.fade.flFadeSustain = flSustain;

+		prevItem.fade.flFadeLength = flLength;

+		prevItem.fade.iOriginalAlpha = prevItem.color.a();

+	}

+	else

+	{

+		// add to text stream, based off existing item

+		TFormatStream streamItem = prevItem;

+

+		prevItem.fade.flFadeStartTime = system()->GetCurrentTime() + flSustain;

+		prevItem.fade.flFadeLength = flLength;

+		prevItem.fade.flFadeSustain = flSustain;

+		prevItem.fade.iOriginalAlpha = prevItem.color.a();

+

+		streamItem.textStreamIndex = m_TextStream.Count();

+		m_FormatStream.AddToTail(streamItem);

+	}

+}

+

+void RichText::ResetAllFades( bool bHold, bool bOnlyExpired, float flNewSustain )

+{

+	m_bResetFades = bHold;

+

+	if ( m_bResetFades == false )

+	{

+		for (int i = 1; i < m_FormatStream.Count(); i++)

+		{

+			if ( bOnlyExpired == true )

+			{

+				if ( m_FormatStream[i].fade.flFadeStartTime >= system()->GetCurrentTime() )

+					continue;

+			}

+

+			if ( flNewSustain == -1.0f )

+			{

+				flNewSustain = m_FormatStream[i].fade.flFadeSustain;

+			}

+

+			m_FormatStream[i].fade.flFadeStartTime = system()->GetCurrentTime() + flNewSustain;

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: inserts an indent change into the formatting stream

+//-----------------------------------------------------------------------------

+void RichText::InsertIndentChange(int pixelsIndent)

+{

+	if (pixelsIndent < 0)

+	{

+		pixelsIndent = 0;

+	}

+	else if (pixelsIndent > 255)

+	{

+		pixelsIndent = 255;

+	}

+

+	// see if indent change already exists in text stream

+	TFormatStream &prevItem = m_FormatStream[m_FormatStream.Count() - 1];

+	if (prevItem.pixelsIndent == pixelsIndent)

+	{

+		// inserting same indent into stream, just ignore

+	}

+	else if (prevItem.textStreamIndex == m_TextStream.Count())

+	{

+		// this item is in the same place; update

+		prevItem.pixelsIndent = pixelsIndent;

+	}

+	else

+	{

+		// add to text stream, based off existing item

+		TFormatStream streamItem = prevItem;

+		streamItem.pixelsIndent = pixelsIndent;

+		streamItem.textStreamIndex = m_TextStream.Count();

+		m_FormatStream.AddToTail(streamItem);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Inserts character Start for clickable text, eg. URLS

+//-----------------------------------------------------------------------------

+void RichText::InsertClickableTextStart( const char *pchClickAction )

+{

+	// see if indent change already exists in text stream

+	TFormatStream &prevItem = m_FormatStream[m_FormatStream.Count() - 1];

+	TFormatStream *pFormatStream = &prevItem;

+	if (prevItem.textStreamIndex == m_TextStream.Count())

+	{

+		// this item is in the same place; update

+		prevItem.textClickable = true;

+		pFormatStream->m_sClickableTextAction = pchClickAction;

+	}

+	else

+	{

+		// add to text stream, based off existing item

+		TFormatStream formatStreamCopy = prevItem;

+		int iFormatStream = m_FormatStream.AddToTail( formatStreamCopy );

+		

+		// set the new params

+		pFormatStream = &m_FormatStream[iFormatStream];

+		pFormatStream->textStreamIndex = m_TextStream.Count();

+		pFormatStream->textClickable = true;

+		pFormatStream->m_sClickableTextAction = pchClickAction;

+	}

+

+	// invalidate the layout to recalculate where the click panels should go

+	InvalidateLineBreakStream();

+	InvalidateLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Inserts character end for clickable text, eg. URLS

+//-----------------------------------------------------------------------------

+void RichText::InsertClickableTextEnd()

+{

+	// see if indent change already exists in text stream

+	TFormatStream &prevItem = m_FormatStream[m_FormatStream.Count() - 1];

+	if (!prevItem.textClickable)

+	{

+		// inserting same indent into stream, just ignore

+	}

+	else if (prevItem.textStreamIndex == m_TextStream.Count())

+	{

+		// this item is in the same place; update

+		prevItem.textClickable = false;

+	}

+	else

+	{

+		// add to text stream, based off existing item

+		TFormatStream streamItem = prevItem;

+		streamItem.textClickable = false;

+		streamItem.textStreamIndex = m_TextStream.Count();

+		m_FormatStream.AddToTail(streamItem);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: moves x,y to the Start of the next line of text

+//-----------------------------------------------------------------------------

+void RichText::AddAnotherLine(int &cx, int &cy)

+{

+	cx = _drawOffsetX + _pixelsIndent;

+	cy += (GetLineHeight() + _drawOffsetY);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Recalculates line breaks

+//-----------------------------------------------------------------------------

+void RichText::RecalculateLineBreaks()

+{

+	if ( !m_bRecalcLineBreaks )

+		return;

+

+	int wide = GetWide();

+	if (!wide)

+		return;

+

+	wide -= _drawOffsetX;

+

+	m_bRecalcLineBreaks = false;

+	_recalcSavedRenderState = true;

+	if (!HasText())

+		return;

+	

+	int selection0 = -1, selection1 = -1;

+

+	// subtract the scrollbar width

+	if (_vertScrollBar->IsVisible())

+	{

+		wide -= _vertScrollBar->GetWide();

+	}

+	

+	int x = _drawOffsetX, y = _drawOffsetY;

+	

+	HFont fontWordStart = INVALID_FONT;

+	int wordStartIndex = 0;

+	int lineStartIndex = 0;

+	bool hasWord = false;

+	bool justStartedNewLine = true;

+	bool wordStartedOnNewLine = true;

+	

+	int startChar = 0;

+	if (_recalculateBreaksIndex <= 0)

+	{

+		m_LineBreaks.RemoveAll();

+	}

+	else

+	{

+		// remove the rest of the linebreaks list since its out of date.

+		for (int i = _recalculateBreaksIndex + 1; i < m_LineBreaks.Count(); ++i)

+		{

+			m_LineBreaks.Remove(i);

+			--i; // removing shrinks the list!

+		}

+		startChar = m_LineBreaks[_recalculateBreaksIndex];

+		lineStartIndex = m_LineBreaks[_recalculateBreaksIndex];

+		wordStartIndex = lineStartIndex;

+	}

+	

+	// handle the case where this char is a new line, in that case

+	// we have already taken its break index into account above so skip it.

+	if (m_TextStream[startChar] == '\r' || m_TextStream[startChar] == '\n') 

+	{

+		startChar++;

+		lineStartIndex = startChar;

+	}

+	

+	// cycle to the right url panel	for what is visible	after the startIndex.

+	int clickableTextNum = GetClickableTextIndexStart(startChar);

+	clickableTextNum++;

+

+	// initialize the renderstate with the start

+	TRenderState renderState;

+	GenerateRenderStateForTextStreamIndex(startChar, renderState);

+	_currentTextClickable = false;

+

+	HFont font = _font;

+	

+	bool bForceBreak = false;

+	float flLineWidthSoFar = 0;

+

+	// loop through all the characters

+	for (int i = startChar; i < m_TextStream.Count(); ++i)

+	{

+		wchar_t ch = m_TextStream[i];

+		renderState.x = x;

+		if (UpdateRenderState(i, renderState))

+		{

+			x = renderState.x;

+			int preI = i;

+			

+			// check for clickable text

+			if (renderState.textClickable != _currentTextClickable)

+			{

+				if (renderState.textClickable)

+				{

+					// make a new clickable text panel

+					if (clickableTextNum >= _clickableTextPanels.Count())

+					{

+						_clickableTextPanels.AddToTail(new ClickPanel(this));

+					}

+					

+					ClickPanel *clickPanel = _clickableTextPanels[clickableTextNum++];

+					clickPanel->SetTextIndex(preI, preI);

+				}

+				

+				// url state change

+				_currentTextClickable = renderState.textClickable;

+			}

+		}

+

+		bool bIsWSpace = iswspace( ch ) ? true : false;

+

+		bool bPreviousWordStartedOnNewLine = wordStartedOnNewLine;

+		int iPreviousWordStartIndex = wordStartIndex;

+		if ( !bIsWSpace && ch != L'\t' && ch != L'\n' && ch != L'\r' )

+		{

+			if (!hasWord)

+			{

+				// Start a new word

+				wordStartIndex = i;

+				hasWord = true;

+				wordStartedOnNewLine = justStartedNewLine;

+				fontWordStart = font;

+			}

+			// else append to the current word

+		}

+		else

+		{

+			// whitespace/punctuation character

+			// end the word

+			hasWord = false;

+		}

+

+		float w = 0;

+		wchar_t wchBefore = 0;

+		wchar_t wchAfter = 0;

+

+		if ( i > 0 && i > lineStartIndex && i != selection0 && i-1 != selection1 )

+			wchBefore = m_TextStream[i-1];

+		if ( i < m_TextStream.Count() - 1 && i+1 != selection0 && i != selection1 )

+			wchAfter = m_TextStream[i+1];

+

+		float flabcA;

+		surface()->GetKernedCharWidth( font, ch, wchBefore, wchAfter, w, flabcA );

+		flLineWidthSoFar += w;

+	

+		// See if we've exceeded the width we have available, with 

+		if ( floor(flLineWidthSoFar + 0.6) + x > wide )

+		{

+			bForceBreak = true;

+		}

+

+		if (!iswcntrl(ch))

+		{

+			justStartedNewLine = false;

+		}

+		

+		if ( bForceBreak || ch == '\r' || ch == '\n' )

+		{

+			bForceBreak = false;

+			// add another line

+			AddAnotherLine(x, y);

+			

+			if ( ch == '\r' || ch == '\n' )

+			{

+				// skip the newline so it's not at the beginning of the new line

+				lineStartIndex = i + 1;

+				m_LineBreaks.AddToTail(i + 1);

+			}

+			else if ( bPreviousWordStartedOnNewLine || iPreviousWordStartIndex <= lineStartIndex ) 

+			{

+				lineStartIndex = i;

+				m_LineBreaks.AddToTail( i );

+				

+				if (renderState.textClickable)

+				{

+					// need to split the url into two panels

+					int oldIndex = _clickableTextPanels[clickableTextNum - 1]->GetTextIndex();

+					

+					// make a new clickable text panel

+					if (clickableTextNum >= _clickableTextPanels.Count())

+					{

+						_clickableTextPanels.AddToTail(new ClickPanel(this));

+					}

+					

+					ClickPanel *clickPanel = _clickableTextPanels[clickableTextNum++];

+					clickPanel->SetTextIndex(oldIndex, i);

+				}				

+			}

+			else

+			{

+				m_LineBreaks.AddToTail( iPreviousWordStartIndex );

+				lineStartIndex = iPreviousWordStartIndex;

+				i = iPreviousWordStartIndex;

+

+				TRenderState renderStateAtLastWord;

+				GenerateRenderStateForTextStreamIndex( i, renderStateAtLastWord );

+

+				// If the word is clickable, and that started prior to the beginning of the word, then we must split the click panel

+				if ( renderStateAtLastWord.textClickable && m_FormatStream[ renderStateAtLastWord.formatStreamIndex ].textStreamIndex < i )

+				{

+					// need to split the url into two panels

+					int oldIndex = _clickableTextPanels[clickableTextNum - 1]->GetTextIndex();

+

+					// make a new clickable text panel

+					if (clickableTextNum >= _clickableTextPanels.Count())

+					{

+						_clickableTextPanels.AddToTail(new ClickPanel(this));

+					}

+

+					ClickPanel *clickPanel = _clickableTextPanels[clickableTextNum++];

+					clickPanel->SetTextIndex(oldIndex, i);

+				}			

+			}

+

+			flLineWidthSoFar = 0;

+			justStartedNewLine = true;

+			hasWord = false;

+			wordStartedOnNewLine = false;

+			_currentTextClickable = false;

+			continue;

+		}

+	}

+	

+	// end the list

+	m_LineBreaks.AddToTail(MAX_BUFFER_SIZE);

+	

+	// set up the scrollbar

+	_invalidateVerticalScrollbarSlider = true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Recalculate where the vertical scroll bar slider should be 

+//			based on the current cursor line we are on.

+//-----------------------------------------------------------------------------

+void RichText::LayoutVerticalScrollBarSlider()

+{

+	_invalidateVerticalScrollbarSlider = false;

+

+	// set up the scrollbar

+	//if (!_vertScrollBar->IsVisible())

+	//	return;

+

+

+	// see where the scrollbar currently is

+	int previousValue = _vertScrollBar->GetValue();

+	bool bCurrentlyAtEnd = false;

+	int rmin, rmax;

+	_vertScrollBar->GetRange(rmin, rmax);

+	if (rmax && (previousValue + rmin + _vertScrollBar->GetRangeWindow() == rmax))

+	{

+		bCurrentlyAtEnd = true;

+	}

+	

+	// work out position to put scrollbar, factoring in insets

+	int wide, tall;

+	GetSize( wide, tall );

+

+	_vertScrollBar->SetPos( wide - _vertScrollBar->GetWide(), 0 );

+	// scrollbar is inside the borders.

+	_vertScrollBar->SetSize( _vertScrollBar->GetWide(), tall );

+	

+	// calculate how many lines we can fully display

+	int displayLines = tall / (GetLineHeight() + _drawOffsetY);

+	int numLines = m_LineBreaks.Count();

+	

+	if (numLines <= displayLines)

+	{

+		// disable the scrollbar

+		_vertScrollBar->SetEnabled(false);

+		_vertScrollBar->SetRange(0, numLines);

+		_vertScrollBar->SetRangeWindow(numLines);

+		_vertScrollBar->SetValue(0);

+

+		if ( m_bUnusedScrollbarInvis )

+		{

+			SetVerticalScrollbar( false );

+		}

+	}

+	else

+	{

+		if ( m_bUnusedScrollbarInvis )

+		{

+			SetVerticalScrollbar( true );

+		}

+

+		// set the scrollbars range

+		_vertScrollBar->SetRange(0, numLines);

+		_vertScrollBar->SetRangeWindow(displayLines);

+		_vertScrollBar->SetEnabled(true);

+		

+		// this should make it scroll one line at a time

+		_vertScrollBar->SetButtonPressedScrollValue(1);

+		if (bCurrentlyAtEnd)

+		{

+			_vertScrollBar->SetValue(numLines - displayLines);

+		}

+		_vertScrollBar->InvalidateLayout();

+		_vertScrollBar->Repaint();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets whether a vertical scrollbar is visible

+//-----------------------------------------------------------------------------

+void RichText::SetVerticalScrollbar(bool state)

+{

+	if (_vertScrollBar->IsVisible() != state)

+	{

+		_vertScrollBar->SetVisible(state);

+		InvalidateLineBreakStream();

+		InvalidateLayout();

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Create cut/copy/paste dropdown menu

+//-----------------------------------------------------------------------------

+void RichText::CreateEditMenu()

+{	

+	// create a drop down cut/copy/paste menu appropriate for this object's states

+	if (m_pEditMenu)

+		delete m_pEditMenu;

+	m_pEditMenu = new Menu(this, "EditMenu");

+	

+	

+	// add cut/copy/paste drop down options if its editable, just copy if it is not

+	m_pEditMenu->AddMenuItem("C&opy", new KeyValues("DoCopySelected"), this);

+	

+	m_pEditMenu->SetVisible(false);

+	m_pEditMenu->SetParent(this);

+	m_pEditMenu->AddActionSignalTarget(this);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: We want single line windows to scroll horizontally and select text

+//          in response to clicking and holding outside window

+//-----------------------------------------------------------------------------

+void RichText::OnMouseFocusTicked()

+{

+	// if a button is down move the scrollbar slider the appropriate direction

+	if (_mouseDragSelection) // text is being selected via mouse clicking and dragging

+	{

+		OnCursorMoved(0,0);	// we want the text to scroll as if we were dragging

+	}	

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: If a cursor enters the window, we are not elegible for 

+//          MouseFocusTicked events

+//-----------------------------------------------------------------------------

+void RichText::OnCursorEntered()

+{

+	_mouseDragSelection = false; // outside of window dont recieve drag scrolling ticks

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: When the cursor is outside the window, if we are holding the mouse

+//			button down, then we want the window to scroll the text one char at a time using Ticks

+//-----------------------------------------------------------------------------

+void RichText::OnCursorExited() 

+{

+	// outside of window recieve drag scrolling ticks

+	if (_mouseSelection)

+	{

+		_mouseDragSelection = true;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Handle selection of text by mouse

+//-----------------------------------------------------------------------------

+void RichText::OnCursorMoved(int x, int y)

+{

+	if (_mouseSelection)

+	{

+		// update the cursor position

+		int x, y;

+		input()->GetCursorPos(x, y);

+		ScreenToLocal(x, y);

+		_cursorPos = PixelToCursorSpace(x, y);

+		

+		if (_cursorPos != _select[1])

+		{

+			_select[1] = _cursorPos;

+			Repaint();

+		}

+		// Msg( "selecting range [%d..%d]\n", _select[0], _select[1] );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Handle mouse button down events.

+//-----------------------------------------------------------------------------

+void RichText::OnMousePressed(MouseCode code)

+{

+	if (code == MOUSE_LEFT)

+	{

+		// clear current selection

+		SelectNone();

+

+		// move the cursor to where the mouse was pressed

+		int x, y;

+		input()->GetCursorPos(x, y);

+		ScreenToLocal(x, y);

+		

+		_cursorPos = PixelToCursorSpace(x, y);

+		

+		if ( m_bInteractive )

+		{

+			// enter selection mode

+			input()->SetMouseCapture(GetVPanel());

+			_mouseSelection = true;

+			

+			if (_select[0] < 0)

+			{

+				// if no initial selection position, Start selection position at cursor

+				_select[0] = _cursorPos;

+			}

+			_select[1] = _cursorPos;

+		}

+		

+		RequestFocus();

+		Repaint();

+	}

+	else if (code == MOUSE_RIGHT) // check for context menu open

+	{

+		if ( m_bInteractive )

+		{

+			CreateEditMenu();

+			Assert(m_pEditMenu);

+			

+			OpenEditMenu();

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Handle mouse button up events

+//-----------------------------------------------------------------------------

+void RichText::OnMouseReleased(MouseCode code)

+{

+	_mouseSelection = false;

+	input()->SetMouseCapture(NULL);

+	

+	// make sure something has been selected

+	int cx0, cx1;

+	if (GetSelectedRange(cx0, cx1))

+	{

+		if (cx1 - cx0 == 0)

+		{

+			// nullify selection

+			_select[0] = -1;

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Handle mouse double clicks

+//-----------------------------------------------------------------------------

+void RichText::OnMouseDoublePressed(MouseCode code)

+{

+	if ( !m_bInteractive )

+		return; 

+

+	// left double clicking on a word selects the word

+	if (code == MOUSE_LEFT)

+	{

+		// move the cursor just as if you single clicked.

+		OnMousePressed(code);

+		// then find the start and end of the word we are in to highlight it.

+		int selectSpot[2];

+		GotoWordLeft();

+		selectSpot[0] = _cursorPos;

+		GotoWordRight();

+		selectSpot[1] = _cursorPos;

+		

+		if ( _cursorPos > 0 && (_cursorPos-1) < m_TextStream.Count() )

+		{

+			if (iswspace(m_TextStream[_cursorPos-1]))

+			{

+				selectSpot[1]--;

+				_cursorPos--;

+			}

+		}

+		

+		_select[0] = selectSpot[0];

+		_select[1] = selectSpot[1];

+		_mouseSelection = true;

+	}

+	

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Turn off text selection code when mouse button is not down

+//-----------------------------------------------------------------------------

+void RichText::OnMouseCaptureLost()

+{

+	_mouseSelection = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Masks which keys get chained up

+//			Maps keyboard input to text window functions.

+//-----------------------------------------------------------------------------

+void RichText::OnKeyCodeTyped(KeyCode code)

+{

+	bool shift = (input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT));

+	bool ctrl = (input()->IsKeyDown(KEY_LCONTROL) || input()->IsKeyDown(KEY_RCONTROL));

+	bool alt = (input()->IsKeyDown(KEY_LALT) || input()->IsKeyDown(KEY_RALT));

+	bool winkey = (input()->IsKeyDown(KEY_LWIN) || input()->IsKeyDown(KEY_RWIN));

+	bool fallThrough = false;

+		

+	if ( ctrl || ( winkey && IsOSX() ) )

+	{

+		switch(code)

+		{

+		case KEY_INSERT:

+		case KEY_C:

+		case KEY_X:

+			{

+				CopySelected();

+				break;

+			}

+		case KEY_PAGEUP:

+		case KEY_HOME:

+			{

+				GotoTextStart();

+				break;

+			}

+		case KEY_PAGEDOWN:

+		case KEY_END:

+			{

+				GotoTextEnd();

+				break;

+			}

+		default:

+			{

+				fallThrough = true;

+				break;

+			}

+		}

+	}

+	else if (alt)

+	{

+		// do nothing with ALT-x keys

+		fallThrough = true;

+	}

+	else

+	{

+		switch(code)

+		{

+		case KEY_TAB:

+		case KEY_LSHIFT:

+		case KEY_RSHIFT:

+		case KEY_ESCAPE:

+		case KEY_ENTER:

+			{

+				fallThrough = true;

+				break;

+			}

+		case KEY_DELETE:

+			{

+				if (shift)

+				{

+					// shift-delete is cut

+					CopySelected();

+				}

+				break;

+			}

+		case KEY_HOME:

+			{

+				GotoTextStart();

+				break;

+			}

+		case KEY_END:

+			{

+				GotoTextEnd();

+				break;

+			}

+		case KEY_PAGEUP:

+			{

+				// if there is a scroll bar scroll down one rangewindow

+				if (_vertScrollBar->IsVisible())

+				{

+					int window = _vertScrollBar->GetRangeWindow();

+					int newval = _vertScrollBar->GetValue();

+					_vertScrollBar->SetValue(newval - window - 1);

+				}

+				break;

+				

+			}

+		case KEY_PAGEDOWN:

+			{

+				// if there is a scroll bar scroll down one rangewindow

+				if (_vertScrollBar->IsVisible())

+				{

+					int window = _vertScrollBar->GetRangeWindow();

+					int newval = _vertScrollBar->GetValue();

+					_vertScrollBar->SetValue(newval + window + 1);

+				}

+				break;

+			}

+		default:

+			{

+				// return if any other char is pressed.

+				// as it will be a unicode char.

+				// and we don't want select[1] changed unless a char was pressed that this fxn handles

+				return;

+			}

+		}

+	}

+	

+	// select[1] is the location in the line where the blinking cursor started

+	_select[1] = _cursorPos;

+	

+	// chain back on some keys

+	if (fallThrough)

+	{

+		BaseClass::OnKeyCodeTyped(code);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scrolls the list according to the mouse wheel movement

+//-----------------------------------------------------------------------------

+void RichText::OnMouseWheeled(int delta)

+{

+	MoveScrollBar(delta);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scrolls the list 

+// Input  : delta - amount to move scrollbar up

+//-----------------------------------------------------------------------------

+void RichText::MoveScrollBar(int delta)

+{

+	MoveScrollBarDirect( delta * 3 );

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Scrolls the list 

+// Input  : delta - amount to move scrollbar up

+//-----------------------------------------------------------------------------

+void RichText::MoveScrollBarDirect(int delta)

+{

+	if (_vertScrollBar->IsVisible())

+	{

+		int val = _vertScrollBar->GetValue();

+		val -= delta;

+		_vertScrollBar->SetValue(val);

+		_recalcSavedRenderState = true;

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: set the maximum number of chars in the text buffer

+//-----------------------------------------------------------------------------

+void RichText::SetMaximumCharCount(int maxChars)

+{

+	_maxCharCount = maxChars;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Find out what line the cursor is on

+//-----------------------------------------------------------------------------

+int RichText::GetCursorLine()

+{

+	// always returns the last place

+	int pos = m_LineBreaks[m_LineBreaks.Count() - 1];

+	Assert(pos == MAX_BUFFER_SIZE);

+	return pos;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Move the cursor over to the Start of the next word to the right

+//-----------------------------------------------------------------------------

+void RichText::GotoWordRight()

+{

+	// search right until we hit a whitespace character or a newline

+	while (++_cursorPos < m_TextStream.Count())

+	{

+		if (iswspace(m_TextStream[_cursorPos]))

+			break;

+	}

+	

+	// search right until we hit an nonspace character

+	while (++_cursorPos < m_TextStream.Count())

+	{

+		if (!iswspace(m_TextStream[_cursorPos]))

+			break;

+	}

+	

+	if (_cursorPos > m_TextStream.Count())

+	{

+		_cursorPos = m_TextStream.Count();

+	}

+	

+	// now we are at the start of the next word

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Move the cursor over to the Start of the next word to the left

+//-----------------------------------------------------------------------------

+void RichText::GotoWordLeft()

+{

+	if (_cursorPos < 1)

+		return;

+	

+	// search left until we hit an nonspace character

+	while (--_cursorPos >= 0)

+	{

+		if (!iswspace(m_TextStream[_cursorPos]))

+			break;

+	}

+	

+	// search left until we hit a whitespace character

+	while (--_cursorPos >= 0)

+	{

+		if (iswspace(m_TextStream[_cursorPos]))

+		{

+			break;

+		}

+	}

+	

+	// we end one character off

+	_cursorPos++;

+

+	// now we are at the start of the previous word

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Move cursor to the Start of the text buffer

+//-----------------------------------------------------------------------------

+void RichText::GotoTextStart()

+{

+	_cursorPos = 0;	// set cursor to start

+	_invalidateVerticalScrollbarSlider = true;

+	// force scrollbar to the top

+	_vertScrollBar->SetValue(0);

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Move cursor to the end of the text buffer

+//-----------------------------------------------------------------------------

+void RichText::GotoTextEnd()

+{

+	_cursorPos = m_TextStream.Count();	// set cursor to end of buffer

+	_invalidateVerticalScrollbarSlider = true;

+

+	// force the scrollbar to the bottom

+	int min, max;

+	_vertScrollBar->GetRange(min, max);

+	_vertScrollBar->SetValue(max);

+

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Culls the text stream down to a managable size

+//-----------------------------------------------------------------------------

+void RichText::TruncateTextStream()

+{

+	if (_maxCharCount < 1)

+		return;

+

+	// choose a point to cull at

+	int cullPos = _maxCharCount / 2;

+

+	// kill half the buffer

+	m_TextStream.RemoveMultiple(0, cullPos);

+

+	// work out where in the format stream we can start

+	int formatIndex = FindFormatStreamIndexForTextStreamPos(cullPos);

+	if (formatIndex > 0)

+	{

+		// take a copy, make it first

+		m_FormatStream[0] = m_FormatStream[formatIndex];

+		m_FormatStream[0].textStreamIndex = 0;

+		// kill the others

+		m_FormatStream.RemoveMultiple(1, formatIndex);

+	}

+

+	// renormalize the remainder of the format stream

+	for (int i = 1; i < m_FormatStream.Count(); i++)

+	{

+		Assert(m_FormatStream[i].textStreamIndex > cullPos);

+		m_FormatStream[i].textStreamIndex -= cullPos;

+	}

+

+	// mark everything to be recalculated

+	InvalidateLineBreakStream();

+	InvalidateLayout();

+	_invalidateVerticalScrollbarSlider = true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Insert a character into the text buffer

+//-----------------------------------------------------------------------------

+void RichText::InsertChar(wchar_t wch)

+{

+	// throw away redundant linefeed characters

+	if ( wch == '\r' )

+		return;

+

+	if (_maxCharCount > 0 && m_TextStream.Count() > _maxCharCount)

+	{

+		TruncateTextStream();

+	}

+	

+	// insert the new char at the end of the buffer

+	m_TextStream.AddToTail(wch);

+

+	// mark the linebreak steam as needing recalculating from that point

+	_recalculateBreaksIndex = m_LineBreaks.Count() - 2;

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Insert a string into the text buffer, this is just a series

+//			of char inserts because we have to check each char is ok to insert

+//-----------------------------------------------------------------------------

+void RichText::InsertString(const char *text)

+{

+	if (text[0] == '#')

+	{

+		wchar_t unicode[ 1024 ];

+		ResolveLocalizedTextAndVariables( text, unicode, sizeof( unicode ) );

+		InsertString( unicode );

+		return;

+	}

+

+	// upgrade the ansi text to unicode to display it

+	int len = strlen(text);

+	wchar_t *unicode = (wchar_t *)_alloca((len + 1) * sizeof(wchar_t));

+	Q_UTF8ToUnicode(text, unicode, ((len + 1) * sizeof(wchar_t)));

+	InsertString(unicode);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Insertsa a unicode string into the buffer

+//-----------------------------------------------------------------------------

+void RichText::InsertString(const wchar_t *wszText)

+{

+	// insert the whole string

+	for (const wchar_t *ch = wszText; *ch != 0; ++ch)

+	{

+		InsertChar(*ch);

+	}

+	InvalidateLayout();

+	m_bRecalcLineBreaks = true;

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Declare a selection empty

+//-----------------------------------------------------------------------------

+void RichText::SelectNone()

+{

+	// tag the selection as empty

+	_select[0] = -1;

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Load in the selection range so cx0 is the Start and cx1 is the end

+//			from smallest to highest (right to left)

+//-----------------------------------------------------------------------------

+bool RichText::GetSelectedRange(int &cx0, int &cx1)

+{

+	// if there is nothing selected return false

+	if (_select[0] == -1)

+		return false;

+	

+	// sort the two position so cx0 is the smallest

+	cx0 = _select[0];

+	cx1 = _select[1];

+	if (cx1 < cx0)

+	{

+		int temp = cx0;

+		cx0 = cx1;

+		cx1 = temp;

+	}

+	

+	return true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Opens the cut/copy/paste dropdown menu

+//-----------------------------------------------------------------------------

+void RichText::OpenEditMenu()

+{

+	// get cursor position, this is local to this text edit window

+	// so we need to adjust it relative to the parent

+	int cursorX, cursorY;

+	input()->GetCursorPos(cursorX, cursorY);

+	

+	/* !!	disabled since it recursively gets panel pointers, potentially across dll boundaries, 

+			and doesn't need to be necessary (it's just for handling windowed mode)

+

+	// find the frame that has no parent (the one on the desktop)

+	Panel *panel = this;

+	while ( panel->GetParent() != NULL)

+	{

+		panel = panel->GetParent();

+	}

+	panel->ScreenToLocal(cursorX, cursorY);

+	int x, y;

+	// get base panel's postition

+	panel->GetPos(x, y);	  

+	

+	// adjust our cursor position accordingly

+	cursorX += x;

+	cursorY += y;

+	*/

+	

+	int x0, x1;

+	if (GetSelectedRange(x0, x1)) // there is something selected

+	{

+		m_pEditMenu->SetItemEnabled("&Cut", true);

+		m_pEditMenu->SetItemEnabled("C&opy", true);

+	}

+	else	// there is nothing selected, disable cut/copy options

+	{

+		m_pEditMenu->SetItemEnabled("&Cut", false);

+		m_pEditMenu->SetItemEnabled("C&opy", false);

+	}

+	m_pEditMenu->SetVisible(true);

+	m_pEditMenu->RequestFocus();

+	

+	// relayout the menu immediately so that we know it's size

+	m_pEditMenu->InvalidateLayout(true);

+	int menuWide, menuTall;

+	m_pEditMenu->GetSize(menuWide, menuTall);

+	

+	// work out where the cursor is and therefore the best place to put the menu

+	int wide, tall;

+	surface()->GetScreenSize(wide, tall);

+	

+	if (wide - menuWide > cursorX)

+	{

+		// menu hanging right

+		if (tall - menuTall > cursorY)

+		{

+			// menu hanging down

+			m_pEditMenu->SetPos(cursorX, cursorY);

+		}

+		else

+		{

+			// menu hanging up

+			m_pEditMenu->SetPos(cursorX, cursorY - menuTall);

+		}

+	}

+	else

+	{

+		// menu hanging left

+		if (tall - menuTall > cursorY)

+		{

+			// menu hanging down

+			m_pEditMenu->SetPos(cursorX - menuWide, cursorY);

+		}

+		else

+		{

+			// menu hanging up

+			m_pEditMenu->SetPos(cursorX - menuWide, cursorY - menuTall);

+		}

+	}

+	

+	m_pEditMenu->RequestFocus();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Cuts the selected chars from the buffer and 

+//          copies them into the clipboard

+//-----------------------------------------------------------------------------

+void RichText::CutSelected()

+{

+	CopySelected();

+	// have to request focus if we used the menu

+	RequestFocus();	

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Copies the selected chars into the clipboard

+//-----------------------------------------------------------------------------

+void RichText::CopySelected()

+{

+	int x0, x1;

+	if (GetSelectedRange(x0, x1))

+	{

+		CUtlVector<wchar_t> buf;

+		for (int i = x0; i <= x1; i++)

+		{

+			if ( m_TextStream.IsValidIndex(i) == false )

+				 continue;

+

+			if (m_TextStream[i] == '\n') 

+			{

+				buf.AddToTail( '\r' );

+			}

+			// remove any rich edit commands

+			buf.AddToTail(m_TextStream[i]);

+		}

+		buf.AddToTail('\0');

+		system()->SetClipboardText(buf.Base(), buf.Count() - 1);

+	}

+	

+	// have to request focus if we used the menu

+	RequestFocus();	

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the index in the text buffer of the

+//          character the drawing should Start at

+//-----------------------------------------------------------------------------

+int RichText::GetStartDrawIndex(int &lineBreakIndexIndex)

+{

+	int startIndex = 0;

+	int startLine = _vertScrollBar->GetValue();

+	

+	if ( startLine >= m_LineBreaks.Count() ) // incase the line breaks got reset and the scroll bar hasn't

+	{

+		startLine = m_LineBreaks.Count() - 1;

+	}

+

+	lineBreakIndexIndex = startLine;

+	if (startLine && startLine < m_LineBreaks.Count())

+	{

+		startIndex = m_LineBreaks[startLine - 1];

+	}

+	

+	return startIndex;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get a string from text buffer

+// Input:	offset - index to Start reading from 

+//			bufLen - length of string

+//-----------------------------------------------------------------------------

+void RichText::GetText(int offset, wchar_t *buf, int bufLenInBytes)

+{

+	if (!buf)

+		return;

+	

+	Assert( bufLenInBytes >= sizeof(buf[0]) );

+	int bufLen = bufLenInBytes / sizeof(wchar_t);

+	int i;

+	for (i = offset; i < (offset + bufLen - 1); i++)

+	{

+		if (i >= m_TextStream.Count())

+			break;

+		

+		buf[i-offset] = m_TextStream[i];

+	}

+	buf[(i-offset)] = 0;

+	buf[bufLen-1] = 0;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: gets text from the buffer

+//-----------------------------------------------------------------------------

+void RichText::GetText(int offset, char *pch, int bufLenInBytes)

+{

+	wchar_t rgwchT[4096];

+	GetText(offset, rgwchT, sizeof(rgwchT));

+    Q_UnicodeToUTF8(rgwchT, pch, bufLenInBytes);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Set the font of the buffer text 

+//-----------------------------------------------------------------------------

+void RichText::SetFont(HFont font)

+{

+	_font = font;

+	InvalidateLayout();

+	m_bRecalcLineBreaks = true;

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Called when the scrollbar slider is moved

+//-----------------------------------------------------------------------------

+void RichText::OnSliderMoved()

+{

+	_recalcSavedRenderState = true;

+	Repaint();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+bool RichText::RequestInfo(KeyValues *outputData)

+{

+	if (!stricmp(outputData->GetName(), "GetText"))

+	{

+		wchar_t wbuf[512];

+		GetText(0, wbuf, sizeof(wbuf));

+		outputData->SetWString("text", wbuf);

+		return true;

+	}

+	

+	return BaseClass::RequestInfo(outputData);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::OnSetText(const wchar_t *text)

+{

+	SetText(text);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Called when a URL, etc has been clicked on

+//-----------------------------------------------------------------------------

+void RichText::OnClickPanel(int index)

+{

+	wchar_t wBuf[512];

+	int outIndex = 0;

+	

+	// parse out the clickable text, and send it to our listeners

+	_currentTextClickable = true;

+	TRenderState renderState;

+	GenerateRenderStateForTextStreamIndex(index, renderState);

+	for (int i = index; i < (sizeof(wBuf) - 1) && i < m_TextStream.Count(); i++)

+	{

+		// stop getting characters when text is no longer clickable

+		UpdateRenderState(i, renderState);

+		if (!renderState.textClickable)

+			break;

+

+		// copy out the character

+		wBuf[outIndex++] = m_TextStream[i];

+	}

+	

+	wBuf[outIndex] = 0;

+

+	int iFormatSteam = FindFormatStreamIndexForTextStreamPos( index );

+    if ( m_FormatStream[iFormatSteam].m_sClickableTextAction )

+	{

+		Q_UTF8ToUnicode( m_FormatStream[iFormatSteam].m_sClickableTextAction.String(), wBuf, sizeof( wBuf ) );

+	}

+

+	PostActionSignal(new KeyValues("TextClicked", "text", wBuf));

+	OnTextClicked(wBuf);

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::ApplySettings(KeyValues *inResourceData)

+{

+	BaseClass::ApplySettings(inResourceData);

+	SetMaximumCharCount(inResourceData->GetInt("maxchars", -1));

+	SetVerticalScrollbar(inResourceData->GetInt("scrollbar", 1));

+

+	// get the starting text, if any

+	const char *text = inResourceData->GetString("text", "");

+	if (*text)

+	{

+		delete [] m_pszInitialText;

+		int len = Q_strlen(text) + 1;

+		m_pszInitialText = new char[ len ];

+		Q_strncpy( m_pszInitialText, text, len );

+		SetText(text);

+	}

+	else

+	{

+		const char *textfilename = inResourceData->GetString("textfile", NULL);

+		if ( textfilename )

+		{

+			FileHandle_t f = g_pFullFileSystem->Open( textfilename, "rt" );

+			if (!f)

+			{

+				Warning( "RichText: textfile parameter '%s' not found.\n", textfilename );

+				return;

+			}

+

+			int len = g_pFullFileSystem->Size( f );

+			delete [] m_pszInitialText;

+			m_pszInitialText = new char[ len + 1 ];

+			g_pFullFileSystem->Read( m_pszInitialText, len, f );

+			m_pszInitialText[len - 1] = 0;

+			SetText( m_pszInitialText );

+

+			g_pFullFileSystem->Close( f );

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::GetSettings(KeyValues *outResourceData)

+{

+	BaseClass::GetSettings(outResourceData);

+	outResourceData->SetInt("maxchars", _maxCharCount);

+	outResourceData->SetInt("scrollbar", _vertScrollBar->IsVisible() );

+	if (m_pszInitialText)

+	{

+		outResourceData->SetString("text", m_pszInitialText);

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+const char *RichText::GetDescription()

+{

+	static char buf[1024];

+	Q_snprintf(buf, sizeof(buf), "%s, string text, bool scrollbar", BaseClass::GetDescription());

+	return buf;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Get the number of lines in the window

+//-----------------------------------------------------------------------------

+int RichText::GetNumLines()

+{

+	return m_LineBreaks.Count();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Sets the height of the text entry window so all text will fit inside

+//-----------------------------------------------------------------------------

+void RichText::SetToFullHeight()

+{

+	PerformLayout();

+	int wide, tall;

+	GetSize(wide, tall);

+	

+	tall = GetNumLines() * (GetLineHeight() + _drawOffsetY) + _drawOffsetY + 2;

+	SetSize (wide, tall);

+	PerformLayout();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Select all the text.

+//-----------------------------------------------------------------------------

+void RichText::SelectAllText()

+{

+	_cursorPos = 0;

+	_select[0] = 0;

+	_select[1] = m_TextStream.Count();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Select all the text.

+//-----------------------------------------------------------------------------

+void RichText::SelectNoText()

+{

+	_select[0] = 0;

+	_select[1] = 0;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void RichText::OnSetFocus()

+{ 

+	BaseClass::OnSetFocus();

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Invalidates the current linebreak stream

+//-----------------------------------------------------------------------------

+void RichText::InvalidateLineBreakStream()

+{

+	// clear the buffer

+	m_LineBreaks.RemoveAll();

+	m_LineBreaks.AddToTail(MAX_BUFFER_SIZE);

+	_recalculateBreaksIndex = 0;

+	m_bRecalcLineBreaks = true;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Inserts a text string while making URLs clickable/different color

+// Input  : *text - string that may contain URLs to make clickable/color coded

+//			URLTextColor - color for URL text

+//          normalTextColor - color for normal text

+//-----------------------------------------------------------------------------

+void RichText::InsertPossibleURLString(const char* text, Color URLTextColor, Color normalTextColor)

+{

+	InsertColorChange(normalTextColor);

+

+	// parse out the string for URL's

+	int len = Q_strlen(text), pos = 0;

+	bool clickable = false;

+	char *pchURLText = (char *)stackalloc( len + 1 );

+	char *pchURL = (char *)stackalloc( len + 1 );

+

+	while (pos < len)

+	{

+		pos = ParseTextStringForUrls( text, pos, pchURLText, len, pchURL, len, clickable );

+

+		if ( clickable )

+		{

+			InsertClickableTextStart( pchURL );

+			InsertColorChange( URLTextColor );

+		}

+		

+		InsertString( pchURLText );

+		

+		if ( clickable )

+		{

+			InsertColorChange(normalTextColor);

+			InsertClickableTextEnd();

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: looks for URLs in the string and returns information about the URL

+//-----------------------------------------------------------------------------

+int RichText::ParseTextStringForUrls( const char *text, int startPos, char *pchURLText, int cchURLText, char *pchURL, int cchURL, bool &clickable )

+{

+	// scan for text that looks like a URL

+	int i = startPos;

+	while (text[i] != 0)

+	{

+		bool bURLFound = false;

+

+		if ( !Q_strnicmp(text + i, "<a href=", 8) )

+		{

+			if (i > startPos)

+				break;

+

+			// embedded link

+			bURLFound = true;

+			clickable = true;

+			// get the url

+			i += Q_strlen( "<a href=" );

+			const char *pchURLEnd = Q_strstr( text + i, ">" );

+			Q_strncpy( pchURL, text + i, min( pchURLEnd - text - i + 1, cchURL ) ); 

+			i += ( pchURLEnd - text - i + 1 );

+            

+			// get the url text

+			pchURLEnd = Q_strstr( text, "</a>" );

+			Q_strncpy( pchURLText, text + i, min( pchURLEnd - text - i + 1, cchURLText ) ); 

+			i += ( pchURLEnd - text - i );

+			i += Q_strlen( "</a>" );

+

+			// we're done

+			return i;

+		}

+		else if (!Q_strnicmp(text + i, "www.", 4))

+		{

+			// scan ahead for another '.'

+			bool bPeriodFound = false;

+			for (const char *ch = text + i + 5; ch != 0; ch++)

+			{

+				if (*ch == '.')

+				{

+					bPeriodFound = true;

+					break;

+				}

+			}

+			

+			// URL found

+			if (bPeriodFound)

+			{

+				bURLFound = true;

+			}

+		}

+		else if (!Q_strnicmp(text + i, "http://", 7))

+		{

+			bURLFound = true;

+		}

+		else if (!Q_strnicmp(text + i, "ftp://", 6))

+		{

+			bURLFound = true;

+		}

+		else if (!Q_strnicmp(text + i, "steam://", 8))

+		{

+			bURLFound = true;

+		}

+		else if (!Q_strnicmp(text + i, "steambeta://", 12))

+		{

+			bURLFound = true;

+		}

+		else if (!Q_strnicmp(text + i, "mailto:", 7))

+		{

+			bURLFound = true;

+		}

+		else if (!Q_strnicmp(text + i, "\\\\", 2))

+		{

+			bURLFound = true;

+		}

+		

+		if (bURLFound)

+		{

+			if (i == startPos)

+			{

+				// we're at the Start of a URL, so parse that out

+				clickable = true;

+				int outIndex = 0;

+				while (text[i] != 0 && !iswspace(text[i]))

+				{

+					pchURLText[outIndex++] = text[i++];

+				}

+				pchURLText[outIndex] = 0;

+				Q_strncpy( pchURL, pchURLText, cchURL );

+				return i;

+			}

+			else

+			{

+				// no url

+				break;

+			}

+		}

+		

+		// increment and loop

+		i++;

+	}

+	

+	// nothing found;

+	// parse out the text before the end

+	clickable = false;

+	int outIndex = 0;

+	int fromIndex = startPos;

+	while ( fromIndex < i && outIndex < cchURLText )

+	{

+		pchURLText[outIndex++] = text[fromIndex++];

+	}

+	pchURLText[outIndex] = 0;

+	Q_strncpy( pchURL, pchURLText, cchURL );

+

+	return i;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: Executes the text-clicked command, which opens a web browser by

+// default.

+//-----------------------------------------------------------------------------

+void RichText::OnTextClicked(const wchar_t *wszText)

+{

+	// Strip leading/trailing quotes, which may be present on href tags or may not.

+	const wchar_t *pwchURL = wszText;

+	if ( pwchURL[0] == L'"' || pwchURL[0] == L'\'' )

+		pwchURL = wszText + 1;

+	

+	char ansi[2048];

+	Q_UnicodeToUTF8( pwchURL, ansi, sizeof(ansi) );

+

+	size_t strLen = Q_strlen(ansi);

+	if ( strLen && ( ansi[strLen-1] == '"' || ansi[strLen] == '\'' ) )

+	{

+		ansi[strLen-1] = 0;

+	}

+

+	if ( m_hPanelToHandleClickingURLs.Get() )

+	{

+		PostMessage( m_hPanelToHandleClickingURLs.Get(), new KeyValues( "URLClicked", "url", ansi ) );

+	}

+	else

+	{

+		system()->ShellExecute( "open", ansi );

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose:

+//-----------------------------------------------------------------------------

+void RichText::SetURLClickedHandler( Panel *pPanelToHandleClickMsg )

+{

+	m_hPanelToHandleClickingURLs = pPanelToHandleClickMsg;

+}

+

+

+//-----------------------------------------------------------------------------

+// Purpose: data accessor

+//-----------------------------------------------------------------------------

+bool RichText::IsScrollbarVisible()

+{

+	return _vertScrollBar->IsVisible();

+}

+

+void RichText::SetUnderlineFont( HFont font )

+{

+	m_hFontUnderline = font;

+}

+

+bool RichText::IsAllTextAlphaZero() const

+{

+	return m_bAllTextAlphaIsZero;

+}

+

+bool RichText::HasText() const

+{

+	int c = m_TextStream.Count();

+	if ( c == 0 )

+	{

+		return false;

+	}

+	return true;

+}

+

+

+

+//-----------------------------------------------------------------------------

+// Purpose: Returns the height of the base font

+//-----------------------------------------------------------------------------

+int RichText::GetLineHeight()

+{

+	return surface()->GetFontTall( _font );

+}

+

+

+#ifdef DBGFLAG_VALIDATE

+//-----------------------------------------------------------------------------

+// Purpose: Run a global validation pass on all of our data structures and memory

+//			allocations.

+// Input:	validator -		Our global validator object

+//			pchName -		Our name (typically a member var in our container)

+//-----------------------------------------------------------------------------

+void RichText::Validate( CValidator &validator, char *pchName )

+{

+	validator.Push( "vgui::RichText", this, pchName );

+

+	ValidateObj( m_TextStream );

+	ValidateObj( m_FormatStream );

+	ValidateObj( m_LineBreaks );

+	ValidateObj( _clickableTextPanels );

+	validator.ClaimMemory( m_pszInitialText );

+

+	BaseClass::Validate( validator, "vgui::RichText" );

+

+	validator.Pop();

+}

+#endif // DBGFLAG_VALIDATE

+