tf2/tf2_src/vgui2/vgui_controls/TextEntry.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//


#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <utlvector.h>

#include <vgui/Cursor.h>
#include <vgui/IInput.h>
#include <vgui/IScheme.h>
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui/ILocalize.h>
#include <vgui/IPanel.h>
#include <KeyValues.h>
#include <vgui/MouseCode.h>

#include <vgui_controls/Menu.h>
#include <vgui_controls/ScrollBar.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/Controls.h>
#include <vgui_controls/MenuItem.h>
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>

enum
{
	// maximum size of text buffer
	BUFFER_SIZE=999999,
};

using namespace vgui;

static const int DRAW_OFFSET_X = 3,DRAW_OFFSET_Y = 1; 

DECLARE_BUILD_FACTORY( TextEntry );

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
TextEntry::TextEntry(Panel *parent, const char *panelName) : BaseClass(parent, panelName)
{
	SetTriplePressAllowed( true );

	_font = INVALID_FONT;
	_smallfont = INVALID_FONT;

	m_szComposition[ 0 ] = L'\0';

	m_bAllowNumericInputOnly = false;
	m_bAllowNonAsciiCharacters = false;
	_hideText = false;
	_editable = false;
	_verticalScrollbar = false;
	_cursorPos = 0;
	_currentStartIndex = 0;
	_horizScrollingAllowed = true;
	_cursorIsAtEnd = false;
	_putCursorAtEnd = false;
	_multiline = false;
	_cursorBlinkRate = 400;
	_mouseSelection = false;
	_mouseDragSelection = false;
	_vertScrollBar=NULL;
	_catchEnterKey = false;
	_maxCharCount = -1;
	_charCount = 0;
	_wrap = false; // don't wrap by default
	_sendNewLines = false; // don't pass on a newline msg by default
	_drawWidth = 0;
	m_bAutoProgressOnHittingCharLimit = false;
	m_pIMECandidates = NULL;
	m_hPreviousIME = input()->GetEnglishIMEHandle();
	m_bDrawLanguageIDAtLeft = false;
	m_nLangInset = 0;
	m_bUseFallbackFont = false;
	m_hFallbackFont = INVALID_FONT;

	//a -1 for _select[0] means that the selection is empty
	_select[0] = -1;
	_select[1] = -1;
	m_pEditMenu = NULL;
	
	//this really just inits it when in here	
	ResetCursorBlink();
	
	SetCursor(dc_ibeam);
	
	SetEditable(true);
	
	// initialize the line break array
	m_LineBreaks.AddToTail(BUFFER_SIZE);
	
	_recalculateBreaksIndex = 0;
	
	_selectAllOnFirstFocus = false;
	_selectAllOnFocusAlways = false;

	//position the cursor so it is at the end of the text
	GotoTextEnd();

	// If keyboard focus is in an edit control, don't chain keyboard mappings up to parents since it could mess with typing in text.
	SetAllowKeyBindingChainToParent( false );

	REGISTER_COLOR_AS_OVERRIDABLE( _disabledFgColor, "disabledFgColor_override" );
	REGISTER_COLOR_AS_OVERRIDABLE( _disabledBgColor, "disabledBgColor_override" );
	REGISTER_COLOR_AS_OVERRIDABLE( _selectionColor, "selectionColor_override" );
	REGISTER_COLOR_AS_OVERRIDABLE( _selectionTextColor, "selectionTextColor_override" );
	REGISTER_COLOR_AS_OVERRIDABLE( _defaultSelectionBG2Color, "defaultSelectionBG2Color_override" );
}


TextEntry::~TextEntry()
{
	delete m_pEditMenu;
	delete m_pIMECandidates;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::ApplySchemeSettings(IScheme *pScheme)
{
	BaseClass::ApplySchemeSettings(pScheme);
	
	SetFgColor(GetSchemeColor("TextEntry.TextColor", pScheme));
	SetBgColor(GetSchemeColor("TextEntry.BgColor", pScheme));
	
	_cursorColor = GetSchemeColor("TextEntry.CursorColor", pScheme);
	_disabledFgColor = GetSchemeColor("TextEntry.DisabledTextColor", pScheme);
	_disabledBgColor = GetSchemeColor("TextEntry.DisabledBgColor", pScheme);
	
	_selectionTextColor = GetSchemeColor("TextEntry.SelectedTextColor", GetFgColor(), pScheme);
	_selectionColor = GetSchemeColor("TextEntry.SelectedBgColor", pScheme);
	_defaultSelectionBG2Color = GetSchemeColor("TextEntry.OutOfFocusSelectedBgColor", pScheme);
	_focusEdgeColor = GetSchemeColor("TextEntry.FocusEdgeColor", Color(0, 0, 0, 0), pScheme);

	SetBorder( pScheme->GetBorder("ButtonDepressedBorder"));

	if ( _font == INVALID_FONT ) _font = pScheme->GetFont("Default", IsProportional() );
	if ( _smallfont == INVALID_FONT ) _smallfont = pScheme->GetFont( "DefaultVerySmall", IsProportional() );

	SetFont( _font );
}

void TextEntry::SetSelectionTextColor( const Color& clr )
{
	_selectionTextColor = clr;
}

void TextEntry::SetSelectionBgColor( const Color& clr )
{
	_selectionColor = clr;
}

void TextEntry::SetSelectionUnfocusedBgColor( const Color& clr )
{
	_defaultSelectionBG2Color = clr;
}

//-----------------------------------------------------------------------------
// Purpose: sets the color of the background when the control is disabled
//-----------------------------------------------------------------------------
void TextEntry::SetDisabledBgColor(Color col)
{
	_disabledBgColor = col;
}


//-----------------------------------------------------------------------------
// 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 TextEntry::OnKillFocus()
{
	m_szComposition[ 0 ] = L'\0';
	HideIMECandidates();

	if (_dataChanged)
	{
		FireActionSignal();
		_dataChanged = false;
	}
	
	// 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 )
	{			
		int cursorX, cursorY;
		input()->GetCursorPos(cursorX, cursorY);

		// if we're right clicking within our window, we don't actually kill focus
		if (IsWithin(cursorX, cursorY))
			return;
	}
	
   	// clear any selection
    SelectNone();

	// move the cursor to the start
//	GotoTextStart();

	PostActionSignal( new KeyValues( "TextKillFocus" ) );

	// chain
	BaseClass::OnKillFocus();
}

//-----------------------------------------------------------------------------
// Purpose: Wipe line breaks after the size of a panel has been changed
//-----------------------------------------------------------------------------
void TextEntry::OnSizeChanged(int newWide, int newTall)
{
	BaseClass::OnSizeChanged(newWide, newTall);

   	// blow away the line breaks list 
	_recalculateBreaksIndex = 0;
	m_LineBreaks.RemoveAll();
	m_LineBreaks.AddToTail(BUFFER_SIZE);

    // if we're bigger, see if we can scroll left to put more text in the window
    if (newWide > _drawWidth)
    {
        ScrollLeftForResize();
    }

	_drawWidth = newWide;
	InvalidateLayout();
}


//-----------------------------------------------------------------------------
// Purpose: Set the text array - convert ANSI text to unicode and pass to unicode function
//-----------------------------------------------------------------------------
void TextEntry::SetText(const char *text)
{
	if (!text)
	{
		text = "";
	}

	if (text[0] == '#')
	{
		// check for localization
		wchar_t *wsz = g_pVGuiLocalize->Find(text);
		if (wsz)
		{
			SetText(wsz);
			return;
		}
	}

	size_t len = strlen( text );
	if ( len < 1023 )
	{
		wchar_t unicode[ 1024 ];
		g_pVGuiLocalize->ConvertANSIToUnicode( text, unicode, sizeof( unicode ) );
		SetText( unicode );
	}
	else
	{
		size_t lenUnicode = ( len * sizeof( wchar_t ) + 4 );
		wchar_t *unicode = ( wchar_t * ) malloc( lenUnicode );
			g_pVGuiLocalize->ConvertANSIToUnicode( text, unicode, lenUnicode );
			SetText( unicode );
		free( unicode );
	}
}

//-----------------------------------------------------------------------------
// 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 TextEntry::SetText(const wchar_t *wszText)
{
	if (!wszText)
	{
		wszText = L"";
	}
	int textLen = wcslen(wszText);
	m_TextStream.RemoveAll();
	m_TextStream.EnsureCapacity(textLen);

	int missed_count = 0;
	for (int i = 0; i < textLen; i++)
	{
		if(wszText[i]=='\r') // don't insert \r characters
		{
			missed_count++;
			continue;
		}
		m_TextStream.AddToTail(wszText[i]);
		SetCharAt(wszText[i], i-missed_count);
	}

	GotoTextStart();
	SelectNone();
	
	// reset the data changed flag
	_dataChanged = false;
	
	// blow away the line breaks list 
	_recalculateBreaksIndex = 0;
	m_LineBreaks.RemoveAll();
	m_LineBreaks.AddToTail(BUFFER_SIZE);
	
	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: Sets the value of char at index position.
//-----------------------------------------------------------------------------
void TextEntry::SetCharAt(wchar_t ch, int index)
{
	if ((ch == '\n') || (ch == '\0')) 
	{
		// if its not at the end of the buffer it matters.
		// redo the linebreaks
		//if (index != m_TextStream.Count())
		{
			_recalculateBreaksIndex = 0;
			m_LineBreaks.RemoveAll();
			m_LineBreaks.AddToTail(BUFFER_SIZE);
		}
	}
	
	if (index < 0)
		return;

	if (index >= m_TextStream.Count())
	{
		m_TextStream.AddMultipleToTail(index - m_TextStream.Count() + 1);
	}
	m_TextStream[index] = ch;
	_dataChanged = true;
}

//-----------------------------------------------------------------------------
// Purpose: Restarts the time of the next cursor blink
//-----------------------------------------------------------------------------
void TextEntry::ResetCursorBlink()
{
	_cursorBlink=false;
	_cursorNextBlinkTime=system()->GetTimeMillis()+_cursorBlinkRate;
}

//-----------------------------------------------------------------------------
// Purpose: Hides the text buffer so it will not be drawn
//-----------------------------------------------------------------------------
void TextEntry::SetTextHidden(bool bHideText)
{
	_hideText = bHideText;
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: return character width
//-----------------------------------------------------------------------------
int getCharWidth(HFont font, wchar_t ch)
{
	if (!iswcntrl(ch))
	{
		int a, b, c;
		surface()->GetCharABCwide(font, ch, a, b, c);
		return (a + b + c);
	}
	return 0;
}

//-----------------------------------------------------------------------------
// 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 TextEntry::CursorToPixelSpace(int cursorPos, int &cx, int &cy)
{
	int yStart = GetYStart();
	
	int x = DRAW_OFFSET_X, y = yStart;
	_pixelsIndent = 0;
	int lineBreakIndexIndex = 0;
	
	for (int i = GetStartDrawIndex(lineBreakIndexIndex); i < m_TextStream.Count(); i++)
	{
		wchar_t ch = m_TextStream[i];
		if (_hideText)
		{
			ch = '*';
		}
		
		// if we've found the position, break
		if (cursorPos == i)
		{
			// even if this is a line break entry for the cursor, the next insert
			// will be at this position, which will push the line break forward one
			// so don't push the cursor down a line here...
			/*if (!_putCursorAtEnd)
			{		
				// 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.Count() && 
			lineBreakIndexIndex < m_LineBreaks.Count() &&
			m_LineBreaks[lineBreakIndexIndex] == i)
		{
			// add another line
			AddAnotherLine(x,y);
			lineBreakIndexIndex++;
		}
		
		// add to the current position
		x += getCharWidth(_font, ch);
	}
	
	if ( m_bDrawLanguageIDAtLeft )
	{
		x += m_nLangInset;
	}

	cx = x;
	cy = y;
}

//-----------------------------------------------------------------------------
// Purpose: Converts local pixel coordinates to an index in the text buffer
//          This function appears to be used only in response to mouse clicking
// Input  : cx - 
//			cy - pixel location
//-----------------------------------------------------------------------------
int TextEntry::PixelToCursorSpace(int cx, int cy)
{
	
	int w, h;
	GetSize(w, h);
	cx = clamp(cx, 0, w+100);
	cy = clamp(cy, 0, h);

	_putCursorAtEnd = false; //	Start off assuming we clicked somewhere in the text
	
	int fontTall = surface()->GetFontTall(_font);
	
	// where to Start reading
	int yStart = GetYStart();
	int x = DRAW_OFFSET_X, y = yStart;
	_pixelsIndent = 0;
	int lineBreakIndexIndex = 0;
	
	int startIndex = GetStartDrawIndex(lineBreakIndexIndex);
	bool onRightLine = false;
	int i;
	for (i = startIndex; i < m_TextStream.Count(); i++)
	{
		wchar_t ch = m_TextStream[i];
		if (_hideText)
		{
			ch = '*';
		}
		
		// 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)
			{	
				_putCursorAtEnd = true;
				return i;
			}
		}
		
		// check to see if we're on the right line
		if (cy < yStart)
		{
			// cursor is above panel
			onRightLine = true;
			_putCursorAtEnd = true;	// this will make the text scroll up if needed
		}
		else if (cy >= y && (cy < (y + fontTall + DRAW_OFFSET_Y)))
		{
			onRightLine = true;
		}
		
		int wide = getCharWidth(_font, ch);
		
		// if we've found the position, break
		if (onRightLine)
		{
			if (cx > GetWide())	  // off right side of window
			{
			}
			else if (cx < (DRAW_OFFSET_X + _pixelsIndent) || cy < yStart)	 // off left side of window
			{
				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
				{
					return i;
				}
				else  // right side
				{						 
					return i + 1;
				}
			}
		}
		x += wide;
	}
	
	return i;
}

//-----------------------------------------------------------------------------
// Purpose: Draws a character in the panel
// Input:	ch - character to draw
//			font - font to use
//			x, y - pixel location to draw char at
// Output:	returns the width of the character drawn
//-----------------------------------------------------------------------------
int TextEntry::DrawChar(wchar_t ch, HFont font, int index, int x, int y)
{
	// add to the current position
	int charWide = getCharWidth(font, ch);
	int fontTall=surface()->GetFontTall(font);
	if (!iswcntrl(ch))
	{
		// draw selection, if any
		int selection0 = -1, selection1 = -1;
		GetSelectedRange(selection0, selection1);
		
		if (index >= selection0 && index < selection1)
		{
			// draw background selection color
            VPANEL focus = input()->GetFocus();
			Color bgColor;
			bool hasFocus = HasFocus();
			bool childOfFocus = focus && ipanel()->HasParent(focus, GetVPanel());

            // if one of the children of the SectionedListPanel has focus, then 'we have focus' if we're selected
            if ( hasFocus || childOfFocus )
			{
    			bgColor = _selectionColor;
			}
            else
			{
    			bgColor =_defaultSelectionBG2Color;
			}

			surface()->DrawSetColor(bgColor);

			surface()->DrawFilledRect(x, y, x + charWide, y + 1 + fontTall);
			
			// reset text color
			surface()->DrawSetTextColor(_selectionTextColor);
		}
		if (index == selection1)
		{
			// we've come out of selection, reset the color
			surface()->DrawSetTextColor(GetFgColor());
		}

		surface()->DrawSetTextPos(x, y);
		surface()->DrawUnicodeChar(ch);
		
		return charWide;
	}
	
	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: Draw the cursor, cursor is not drawn when it is blinked gone
// Input:  x,y where to draw cursor
// Output: returns true if cursor was drawn.
//-----------------------------------------------------------------------------
bool TextEntry::DrawCursor(int x, int y)
{
	if (!_cursorBlink)
	{
		int cx, cy;
		CursorToPixelSpace(_cursorPos, cx, cy);
		surface()->DrawSetColor(_cursorColor);
		int fontTall=surface()->GetFontTall(_font);
		surface()->DrawFilledRect(cx, cy, cx + 1, cy + fontTall);
		return true;
	}
	return false;
}

bool TextEntry::NeedsEllipses( HFont font, int *pIndex )
{
	Assert( pIndex );
	*pIndex = -1;
	int wide = DRAW_OFFSET_X; // buffer on left and right end of text.
	for ( int i = 0; i < m_TextStream.Count(); ++i )
	{	
		wide += getCharWidth( font , m_TextStream[i] );
		if (wide > _drawWidth)
		{
			*pIndex = i;
			return true;
		}
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Draws the text in the panel
//-----------------------------------------------------------------------------
void TextEntry::PaintBackground()
{
	BaseClass::PaintBackground();

	// draw background
	Color col;
	if (IsEnabled())
	{
		col = GetBgColor();
	}
	else
	{
		col = _disabledBgColor;
	}
	Color saveBgColor = col;

	int wide, tall;
	GetSize( wide, tall );

//	surface()->DrawSetColor(col);
//	surface()->DrawFilledRect(0, 0, wide, tall);

	// where to Start drawing
	int x = DRAW_OFFSET_X + _pixelsIndent, y = GetYStart();

	m_nLangInset = 0;

	int langlen = 0;
	wchar_t shortcode[ 5 ];
	shortcode[ 0 ] = L'\0';

	if ( m_bAllowNonAsciiCharacters )
	{
		input()->GetIMELanguageShortCode( shortcode, sizeof( shortcode ) );

		if ( shortcode[ 0 ] != L'\0' &&
			 wcsicmp( shortcode, L"EN" ) )
		{
			m_nLangInset = 0;
			langlen = wcslen( shortcode );
			for ( int i = 0; i < langlen; ++i )
			{
				m_nLangInset += getCharWidth( _smallfont, shortcode[ i ] );
			}

			m_nLangInset += 4;

			if ( m_bDrawLanguageIDAtLeft )
			{
				x += m_nLangInset;
			}

			wide -= m_nLangInset;
		}
	}

	HFont useFont = _font;

	surface()->DrawSetTextFont(useFont);
	if (IsEnabled())
	{
		col = GetFgColor();
	}
	else
	{
		col = _disabledFgColor;
	}
	surface()->DrawSetTextColor(col);
	_pixelsIndent = 0;
	
	int lineBreakIndexIndex = 0;
	int startIndex = GetStartDrawIndex(lineBreakIndexIndex);
	int remembery = y;

	int oldEnd = m_TextStream.Count();
	int oldCursorPos = _cursorPos;
	int nCompStart = -1;
	int nCompEnd = -1;

	// FIXME: Should insert at cursor pos instead
	bool composing = m_bAllowNonAsciiCharacters && wcslen( m_szComposition ) > 0;
	bool invertcomposition = input()->GetShouldInvertCompositionString();

	if ( composing )
	{
		nCompStart = _cursorPos;

		wchar_t *s = m_szComposition;
		while ( *s != L'\0' )
		{
			m_TextStream.InsertBefore( _cursorPos, *s );
			++s;
			++_cursorPos;
		}

		nCompEnd = _cursorPos;
	}

	bool highlight_composition = ( nCompStart != -1 && nCompEnd != -1 ) ? true : false;

	// draw text with an elipsis
	if ( (!_multiline) && (!_horizScrollingAllowed) )
	{	
		int endIndex = m_TextStream.Count();
		// In editable windows only do the ellipsis if we don't have focus.
		// In non editable windows do it all the time.
		if ( (!HasFocus() && (IsEditable())) || (!IsEditable()) )
		{
			int i = -1;

			// loop through all the characters and sum their widths	
			bool addEllipses = NeedsEllipses( useFont, &i );
			if ( addEllipses && 
				!IsEditable() &&
				m_bUseFallbackFont && 
				INVALID_FONT != m_hFallbackFont )
			{
				// Switch to small font!!!
				useFont = m_hFallbackFont;
				surface()->DrawSetTextFont(useFont);
				addEllipses = NeedsEllipses( useFont, &i );
			}
			if (addEllipses)
			{
				int elipsisWidth = 3 * getCharWidth(useFont, '.');
				while (elipsisWidth > 0 && i >= 0)
				{
					elipsisWidth -= getCharWidth(useFont, m_TextStream[i]);
					i--;
				}
				endIndex = i + 1;	
			}

			// if we take off less than the last 3 chars we have to make sure
			// we take off the last 3 chars so selected text will look right.
			if (m_TextStream.Count() - endIndex < 3 && m_TextStream.Count() - endIndex > 0 )
			{
				endIndex = m_TextStream.Count() - 3;
			}
		}
		// draw the text
		int i;
		for (i = startIndex; i < endIndex; i++)
		{
			wchar_t ch = m_TextStream[i];
			if (_hideText)
			{
				ch = '*';
			}

			bool iscompositionchar = false;

			if ( highlight_composition )
			{
				iscompositionchar = ( i >= nCompStart && i < nCompEnd ) ? true : false;
				if ( iscompositionchar )
				{
					// Set the underline color to the text color
					surface()->DrawSetColor( col );

					int w = getCharWidth( useFont, ch );

					if ( invertcomposition )
					{
						// Invert color
						surface()->DrawSetTextColor( saveBgColor );
						surface()->DrawSetColor( col );
						
						surface()->DrawFilledRect(x, 0, x+w, tall);
						// Set the underline color to the text color
						surface()->DrawSetColor( saveBgColor );
					}

					surface()->DrawFilledRect( x, tall - 2, x + w, tall - 1 );
				}
			}


			// draw the character and update xposition  
			x += DrawChar(ch, useFont, i, x, y);

			// Restore color
			surface()->DrawSetTextColor(col);

		}
		if (endIndex < m_TextStream.Count()) // add an elipsis
		{
			x += DrawChar('.', useFont, i, x, y);
			i++;
			x += DrawChar('.', useFont, i, x, y);
			i++;
			x += DrawChar('.', useFont, i, x, y);
			i++;
		}
	}	
	else
	{
		// draw the text
		for ( int i = startIndex; i < m_TextStream.Count(); i++)
		{
			wchar_t ch = m_TextStream[i];
			if (_hideText)
			{
				ch = '*';
			}
			
			// if we've passed a line break go to that
			if ( _multiline && m_LineBreaks[lineBreakIndexIndex] == i)
			{
				// add another line
				AddAnotherLine(x, y);
				lineBreakIndexIndex++;
			}
			
			bool iscompositionchar = false;

			if ( highlight_composition )
			{
				iscompositionchar = ( i >= nCompStart && i < nCompEnd ) ? true : false;
				if ( iscompositionchar )
				{	
					// Set the underline color to the text color
					surface()->DrawSetColor( col );

					int w = getCharWidth( useFont, ch );

					if ( invertcomposition )
					{
						// Invert color
						surface()->DrawSetTextColor( saveBgColor );
						surface()->DrawFilledRect(x, 0, x+w, tall);
						// Set the underline color to the text color
						surface()->DrawSetColor( saveBgColor );
					}

					surface()->DrawFilledRect( x, tall - 2, x + w, tall - 1 );
				}
			}

			// draw the character and update xposition  
			x += DrawChar(ch, useFont, i, x, y);

			// Restore color
			surface()->DrawSetTextColor(col);
		}
	}

	// custom border
	//!! need to replace this with scheme stuff (TextEntryBorder/TextEntrySelectedBorder)
	surface()->DrawSetColor(50, 50, 50, 255);
	
	if (IsEnabled() && IsEditable() && HasFocus())
	{
		// set a more distinct border color
		surface()->DrawSetColor(0, 0, 0, 255);
		
		DrawCursor (x, y);

		if ( composing )
		{
			LocalToScreen( x, y );
			input()->SetCandidateWindowPos( x, y );
		}
	}

	int newEnd = m_TextStream.Count();
	int remove = newEnd - oldEnd;
	if ( remove > 0 )
	{
		m_TextStream.RemoveMultiple( oldCursorPos, remove );
	}
	_cursorPos = oldCursorPos;

	if ( HasFocus() && m_bAllowNonAsciiCharacters && langlen > 0 )
	{
		wide += m_nLangInset;

		if ( m_bDrawLanguageIDAtLeft )
		{
			x = 0;
		}
		else
		{
			// Draw language identififer
			x = wide - m_nLangInset;
		}

		surface()->DrawSetColor( col );

		surface()->DrawFilledRect( x, 2, x + m_nLangInset-2, tall - 2 );

		saveBgColor[ 3 ] = 255;
		surface()->DrawSetTextColor( saveBgColor );

		x += 1;

		surface()->DrawSetTextFont(_smallfont);
		for ( int i = 0; i < langlen; ++i )
		{
			x += DrawChar( shortcode[ i ], _smallfont, i, x, remembery );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called when data changes or panel size changes
//-----------------------------------------------------------------------------
void TextEntry::PerformLayout()
{
	BaseClass::PerformLayout();

	RecalculateLineBreaks();
	
	// recalculate scrollbar position
	if (_verticalScrollbar)
	{
		LayoutVerticalScrollBarSlider();
	}
	
	// force a Repaint
	Repaint();
}

// moves x,y to the Start of the next line of text
void TextEntry::AddAnotherLine(int &cx, int &cy)
{
	cx = DRAW_OFFSET_X + _pixelsIndent;
	cy += (surface()->GetFontTall(_font) + DRAW_OFFSET_Y);
}


//-----------------------------------------------------------------------------
// Purpose: Recalculates line breaks
//-----------------------------------------------------------------------------
void TextEntry::RecalculateLineBreaks()
{
	if (!_multiline || _hideText)
		return;

	if (m_TextStream.Count() < 1)
		return;
	
	HFont font = _font;
	
	// line break to our width -2 pixel to keep cursor blinking in window
	// (assumes borders are 1 pixel)
	int wide = GetWide()-2;
	
	// subtract the scrollbar width
	if (_vertScrollBar)
	{
		wide -= _vertScrollBar->GetWide();
	}
	
	int charWidth;
	int x = DRAW_OFFSET_X, y = DRAW_OFFSET_Y;
		
	int wordStartIndex = 0;
	int wordLength = 0;
	bool hasWord = false;
	bool justStartedNewLine = true;
	bool wordStartedOnNewLine = true;
	
	int startChar;
	if (_recalculateBreaksIndex <= 0)
	{
		m_LineBreaks.RemoveAll();
		startChar=0;
	}
	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((int)i);
			--i; // removing shrinks the list!
		}
		startChar = m_LineBreaks[_recalculateBreaksIndex];
	}
	
	// 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++;
	}
	
	// loop through all the characters	
	int i;
	for (i = startChar; i < m_TextStream.Count(); ++i)
	{
		wchar_t ch = m_TextStream[i];
		
		// line break only on whitespace characters
		if (!iswspace(ch))
		{
			if (hasWord)
			{
				// append to the current word
			}
			else
			{
				// Start a new word
				wordStartIndex = i;
				hasWord = true;
				wordStartedOnNewLine = justStartedNewLine;
				wordLength = 0;
			}
		}
		else
		{
			// whitespace/punctuation character
			// end the word
			hasWord = false;
		}
		
		// get the width
		charWidth = getCharWidth(font, ch);
		if (!iswcntrl(ch))
		{
			justStartedNewLine = false;
		}
				
		// check to see if the word is past the end of the line [wordStartIndex, i)
		if ((x + charWidth) >= wide || ch == '\r' || ch == '\n')
		{
			// add another line
			AddAnotherLine(x,y);
			
			justStartedNewLine = true;
			hasWord = false;
			
			if (ch == '\r' || ch == '\n')
			{
				// set the break at the current character
				m_LineBreaks.AddToTail(i);
			}
			else if (wordStartedOnNewLine)
			{
				// word is longer than a line, so set the break at the current cursor
				m_LineBreaks.AddToTail(i);
			}
			else
			{
				// set it at the last word Start
				m_LineBreaks.AddToTail(wordStartIndex);
				
				// just back to reparse the next line of text
				i = wordStartIndex;
			}
			
			// reset word length
			wordLength = 0;
		}
		
		// add to the size
		x += charWidth;
		wordLength += charWidth;
	}
	
	_charCount = i-1;
	
	// end the list
	m_LineBreaks.AddToTail(BUFFER_SIZE);
	
	// set up the scrollbar
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: Recalculate where the vertical scroll bar slider should be 
//			based on the current cursor line we are on.
//-----------------------------------------------------------------------------
void TextEntry::LayoutVerticalScrollBarSlider()
{
	// set up the scrollbar
	if (_vertScrollBar)
	{
		int wide, tall;
		GetSize (wide, tall);
		
		// make sure we factor in insets
		int ileft, iright, itop, ibottom;
		GetInset(ileft, iright, itop, ibottom);
		
		// with a scroll bar we take off the inset
		wide -= iright;
		
		_vertScrollBar->SetPos(wide - _vertScrollBar->GetWide(), 0);
		// scrollbar is inside the borders.
		_vertScrollBar->SetSize(_vertScrollBar->GetWide(), tall - ibottom - itop);
		
		// calculate how many lines we can fully display
		int displayLines = tall / (surface()->GetFontTall(_font) + DRAW_OFFSET_Y);
		int numLines = m_LineBreaks.Count();
		
		if (numLines <= displayLines)
		{
			// disable the scrollbar
			_vertScrollBar->SetEnabled(false);
			_vertScrollBar->SetRange(0, numLines);
			_vertScrollBar->SetRangeWindow(numLines);
			_vertScrollBar->SetValue(0);
		}
		else
		{
			// 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);
			
			// set the value to view the last entries
			int val = _vertScrollBar->GetValue();
			int maxval = _vertScrollBar->GetValue() + displayLines;
			if (GetCursorLine() < val )
			{
				while (GetCursorLine() < val)
				{
					val--;
				}
			}
			else if (GetCursorLine() >= maxval)
			{
				while (GetCursorLine() >= maxval)
				{
					maxval++;
				}
				maxval -= displayLines;	
				val = maxval;
			}
			else 
			{
				//val = GetCursorLine();
			}
			
			_vertScrollBar->SetValue(val);
			_vertScrollBar->InvalidateLayout();
			_vertScrollBar->Repaint();
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Set boolean value of baseclass variables.
//-----------------------------------------------------------------------------
void TextEntry::SetEnabled(bool state)
{
	BaseClass::SetEnabled(state);
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Sets whether text wraps around multiple lines or not
// Input  : state - true or false
//-----------------------------------------------------------------------------
void TextEntry::SetMultiline(bool state)
{
	_multiline = state;
}

bool TextEntry::IsMultiline()
{
	return _multiline;
}

//-----------------------------------------------------------------------------
// Purpose: sets whether or not the edit catches and stores ENTER key presses
//-----------------------------------------------------------------------------
void TextEntry::SetCatchEnterKey(bool state)
{
	_catchEnterKey = state;
}

//-----------------------------------------------------------------------------
// Purpose: Sets whether a vertical scrollbar is visible
// Input  : state - true or false
//-----------------------------------------------------------------------------
void TextEntry::SetVerticalScrollbar(bool state)
{
	_verticalScrollbar = state;
	
	if (_verticalScrollbar)
	{
		if (!_vertScrollBar)
		{
			_vertScrollBar = new ScrollBar(this, "ScrollBar", true);
			_vertScrollBar->AddActionSignalTarget(this);
		}
		
		_vertScrollBar->SetVisible(true);
	}
	else if (_vertScrollBar)
	{
		_vertScrollBar->SetVisible(false);
	}
	
	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: sets _editable flag
// Input  : state - true or false
//-----------------------------------------------------------------------------
void TextEntry::SetEditable(bool state)
{
	if ( state )
	{
		SetDropEnabled( true, 1.0f );
	}
	else
	{
		SetDropEnabled( false );
	}
	_editable = state;
}

const wchar_t *UnlocalizeUnicode( wchar_t *unicode )
{
	if ( !unicode )
		return L"";

	if ( *unicode == L'#' )
	{
		char lookup[ 512 ];
		g_pVGuiLocalize->ConvertUnicodeToANSI( unicode + 1, lookup, sizeof( lookup ) );
		return g_pVGuiLocalize->Find( lookup );
	}
	return unicode;
}

Menu * TextEntry::GetEditMenu()
{
	return m_pEditMenu;
}

//-----------------------------------------------------------------------------
// Purpose: Create cut/copy/paste dropdown menu
//-----------------------------------------------------------------------------
void TextEntry::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");
	
	m_pEditMenu->SetFont( _font );
	
	// add cut/copy/paste drop down options if its editable, just copy if it is not
	if (_editable && !_hideText)
	{	
		m_pEditMenu->AddMenuItem("#TextEntry_Cut", new KeyValues("DoCutSelected"), this);
	}
	
	if ( !_hideText )
	{
		m_pEditMenu->AddMenuItem("#TextEntry_Copy", new KeyValues("DoCopySelected"), this);
	}
	
	if (_editable)
	{
		m_pEditMenu->AddMenuItem("#TextEntry_Paste", new KeyValues("DoPaste"), this);
	}
	

	if ( m_bAllowNonAsciiCharacters )
	{
		IInput::LanguageItem *langs = NULL;

		int count = input()->GetIMELanguageList( NULL, 0 );
		if ( count > 0 )
		{
			langs = new IInput::LanguageItem[ count ];
			input()->GetIMELanguageList( langs, count );

			// Create a submenu
			Menu *subMenu = new Menu( this, "LanguageMenu" );

			subMenu->SetFont( _font );

			for ( int i = 0; i < count; ++i )
			{
				int id = subMenu->AddCheckableMenuItem( "Language", UnlocalizeUnicode( langs[ i ].menuname ), new KeyValues( "DoLanguageChanged", "handle", langs[ i ].handleValue ), this );
				if ( langs[ i ].active )
				{
					subMenu->SetMenuItemChecked( id, true );
				}
			}

			m_pEditMenu->AddCascadingMenuItem( "Language", "#TextEntry_Language", "", this, subMenu );

			delete[] langs;
		}

		IInput::ConversionModeItem *modes = NULL;

		count = input()->GetIMEConversionModes( NULL, 0 );
		// if count == 0 then native mode is the only mode...
		if ( count > 0 )
		{
			modes = new IInput::ConversionModeItem[ count ];
			input()->GetIMEConversionModes( modes, count );

			// Create a submenu
			Menu *subMenu = new Menu( this, "ConversionModeMenu" );

			subMenu->SetFont( _font );

			for ( int i = 0; i < count; ++i )
			{
				int id = subMenu->AddCheckableMenuItem( "ConversionMode", UnlocalizeUnicode( modes[ i ].menuname ), new KeyValues( "DoConversionModeChanged", "handle", modes[ i ].handleValue ), this );
				if ( modes[ i ].active )
				{
					subMenu->SetMenuItemChecked( id, true );
				}
			}

			m_pEditMenu->AddCascadingMenuItem( "ConversionMode", "#TextEntry_ConversionMode", "", this, subMenu );

			delete[] modes;
		}

		IInput::SentenceModeItem *sentencemodes = NULL;

		count = input()->GetIMESentenceModes( NULL, 0 );
		// if count == 0 then native mode is the only mode...
		if ( count > 0 )
		{
			sentencemodes = new IInput::SentenceModeItem[ count ];
			input()->GetIMESentenceModes( sentencemodes, count );

			// Create a submenu
			Menu *subMenu = new Menu( this, "SentenceModeMenu" );

			subMenu->SetFont( _font );

			for ( int i = 0; i < count; ++i )
			{
				int id = subMenu->AddCheckableMenuItem( "SentenceMode", UnlocalizeUnicode( sentencemodes[ i ].menuname ), new KeyValues( "DoConversionModeChanged", "handle", modes[ i ].handleValue ), this );
				if ( modes[ i ].active )
				{
					subMenu->SetMenuItemChecked( id, true );
				}
			}

			m_pEditMenu->AddCascadingMenuItem( "SentenceMode", "#TextEntry_SentenceMode", "", this, subMenu );

			delete[] sentencemodes;
		}
	}
	

	m_pEditMenu->SetVisible(false);
	m_pEditMenu->SetParent(this);
	m_pEditMenu->AddActionSignalTarget(this);
}

//-----------------------------------------------------------------------------
// Purpsoe: Returns state of _editable flag
//-----------------------------------------------------------------------------
bool TextEntry::IsEditable()
{
	return _editable && IsEnabled();
}

//-----------------------------------------------------------------------------
// Purpose: We want single line windows to scroll horizontally and select text
//          in response to clicking and holding outside window
//-----------------------------------------------------------------------------
void TextEntry::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 TextEntry::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 TextEntry::OnCursorExited() // outside of window recieve drag scrolling ticks
{
	if (_mouseSelection)
		_mouseDragSelection = true;
}

//-----------------------------------------------------------------------------
// Purpose: Handle selection of text by mouse
//-----------------------------------------------------------------------------
void TextEntry::OnCursorMoved(int ignX, int ignY)
{
	if (_mouseSelection)
	{
		// update the cursor position
		int x, y;
		input()->GetCursorPos(x, y);
		ScreenToLocal(x, y);
		_cursorPos = PixelToCursorSpace(x, y);
		
		// if we are at Start of buffer don't put cursor at end, this will keep
		// window from scrolling up to a blank line
		if (_cursorPos == 0)
			_putCursorAtEnd = false;
		
		// scroll if we went off left side
		if (_cursorPos == _currentStartIndex)
		{
			if (_cursorPos > 0)
				_cursorPos--;

			ScrollLeft();
			_cursorPos = _currentStartIndex;
		}
		if ( _cursorPos != _select[1])
		{
			_select[1] = _cursorPos;
			Repaint();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle Mouse button down events.
//-----------------------------------------------------------------------------
void TextEntry::OnMousePressed(MouseCode code)
{
	if (code == MOUSE_LEFT)
	{
		bool keepChecking = SelectCheck( true );
		if ( !keepChecking )
		{
			BaseClass::OnMousePressed( code );
			return;
		}
		
		// move the cursor to where the mouse was pressed
		int x, y;
		input()->GetCursorPos(x, y);
		ScreenToLocal(x, y);
		
		_cursorIsAtEnd = _putCursorAtEnd; // save this off before calling PixelToCursorSpace()
		_cursorPos = PixelToCursorSpace(x, y);
		// if we are at Start of buffer don't put cursor at end, this will keep
		// window from scrolling up to a blank line
		if (_cursorPos == 0)
			_putCursorAtEnd = false;
		
		// 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;
		
		ResetCursorBlink();
		RequestFocus();
		Repaint();
	}
	else if (code == MOUSE_RIGHT) // check for context menu open
	{	
		CreateEditMenu();
		Assert(m_pEditMenu);
		
		OpenEditMenu();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle mouse button up events
//-----------------------------------------------------------------------------
void TextEntry::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: 
// Input  : code - 
//-----------------------------------------------------------------------------
void TextEntry::OnMouseTriplePressed( MouseCode code )
{
	BaseClass::OnMouseTriplePressed( code );

	// left triple clicking on a word selects all
	if (code == MOUSE_LEFT)
	{
		GotoTextEnd();

		SelectAllText( false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle mouse double clicks
//-----------------------------------------------------------------------------
void TextEntry::OnMouseDoublePressed(MouseCode code)
{
	// 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)
		{
			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 TextEntry::OnMouseCaptureLost()
{
	_mouseSelection = false;
}

//-----------------------------------------------------------------------------
// Purpose: Only pass some keys upwards 
// everything else we don't relay to the parent
//-----------------------------------------------------------------------------
void TextEntry::OnKeyCodePressed(KeyCode code)
{
	// Pass enter on only if _catchEnterKey isn't set
	if ( code == KEY_ENTER )
	{
		if ( !_catchEnterKey )
		{
			Panel::OnKeyCodePressed( code );
			return;
		}
	}
	
	// Forward on just a few key codes, everything else can be handled by TextEntry itself
	switch ( code )
	{
		case KEY_F1:
		case KEY_F2:
		case KEY_F3:
		case KEY_F4:
		case KEY_F5:
		case KEY_F6:
		case KEY_F7:
		case KEY_F8:
		case KEY_F9:
		case KEY_F10:
		case KEY_F11:
		case KEY_F12:
		case KEY_ESCAPE:
		case KEY_APP:
			Panel::OnKeyCodePressed( code );
			return;
	}
	
	// Pass on the joystick and mouse codes
	if ( IsMouseCode(code) || IsNovintButtonCode(code) || IsJoystickCode(code) || IsJoystickButtonCode(code) ||
	     IsJoystickPOVCode(code) || IsJoystickAxisCode(code) )
	{
		Panel::OnKeyCodePressed( code );
		return;
	}
	    
}


//-----------------------------------------------------------------------------
// Purpose: Masks which keys get chained up
//			Maps keyboard input to text window functions.
//-----------------------------------------------------------------------------
void TextEntry::OnKeyCodeTyped(KeyCode code)
{
	_cursorIsAtEnd = _putCursorAtEnd;
	_putCursorAtEnd = false;
	
	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() ) ) && !alt)
	{
		switch(code)
		{
		case KEY_A:
			SelectAllText(false);
			// move the cursor to the end
			_cursorPos = _select[1];
			break;

		case KEY_INSERT:
		case KEY_C:
			{
				CopySelected();
				break;
			}
		case KEY_V:
			{
				DeleteSelected();
				Paste();
				break;
			}
		case KEY_X:
			{
				CopySelected();
				DeleteSelected();
				break;
			}
		case KEY_Z:
			{
				Undo();
				break;
			}
		case KEY_RIGHT:
			{
				GotoWordRight();
				break;
			}
		case KEY_LEFT:
			{
				GotoWordLeft();
				break;
			}
		case KEY_ENTER:
			{
				// insert a newline
				if (_multiline)
				{
					DeleteSelected();
					SaveUndoState();
					InsertChar('\n');
				}
				// fire newlines back to the main target if asked to
				if(_sendNewLines) 
				{
					PostActionSignal(new KeyValues("TextNewLine"));
				}
				break;
			}
		case KEY_HOME:
			{
				GotoTextStart();
				break;
			}
		case KEY_END:
			{
				GotoTextEnd();
				break;
			}
		case KEY_PAGEUP:
			{
				OnChangeIME( true );
			}
			break;
		case KEY_PAGEDOWN:
			{
				OnChangeIME( false );
			}
			break;
		case KEY_UP:
		case KEY_DOWN:
			if ( m_bAllowNonAsciiCharacters )
			{
				FlipToLastIME();
			}
			else
			{
				fallThrough = true;
			}
			break;
		default:
			{
				fallThrough = true;
				break;
			}
		}
	}
	else if (alt)
	{
		// do nothing with ALT-x keys
		if ( !m_bAllowNonAsciiCharacters || ( code != KEY_BACKQUOTE ) )
		{
			fallThrough = true;
		}
	}
	else
	{
		switch(code)
		{
		case KEY_TAB:
		case KEY_LSHIFT:
		case KEY_RSHIFT:
		case KEY_ESCAPE:
			{
				fallThrough = true;
				break;
			}
		case KEY_INSERT:
			{
				if (shift)
				{
					DeleteSelected();
					Paste();
				}
				else
				{
					fallThrough = true;
				}
				
				break;
			}
		case KEY_DELETE:
			{
				if (shift)
				{
					// shift-delete is cut
					CopySelected();
					DeleteSelected();
				}
				else
				{
					Delete();
				}
				break;
			}
		case KEY_LEFT:
			{
				GotoLeft();
				break;
			}
		case KEY_RIGHT:
			{
				GotoRight();
				break;
			}
		case KEY_UP:
			{
				if (_multiline)
				{
					GotoUp();
				}
				else
				{
					fallThrough = true;
				}
				break;
			}
		case KEY_DOWN:
			{
				if (_multiline)
				{
					GotoDown();
				}
				else
				{
					fallThrough = true;
				}
				break;
			}
		case KEY_HOME:
			{
				if (_multiline)
				{
					GotoFirstOfLine();
				}
				else
				{
					GotoTextStart();
				}
				break;
			}
		case KEY_END:
			{
				GotoEndOfLine();
				break;
			}
		case KEY_BACKSPACE:
			{
				int x0, x1;
				if (GetSelectedRange(x0, x1))
				{
					// act just like delete if there is a selection
					DeleteSelected();
				}
				else
				{
					Backspace();
				}
				break;
			}
		case KEY_ENTER:
			{
				// insert a newline
				if (_multiline && _catchEnterKey)
				{
					DeleteSelected();
					SaveUndoState();
					InsertChar('\n');
				}
				else
				{
					fallThrough = true;
				}
				// fire newlines back to the main target if asked to
				if(_sendNewLines) 
				{
					PostActionSignal(new KeyValues("TextNewLine"));
				}
				break;
			}
		case KEY_PAGEUP:
			{
				int val = 0;
				fallThrough = (!_multiline) && (!_vertScrollBar);
				if (_vertScrollBar)
				{
					val = _vertScrollBar->GetValue();
				}
				
				// if there is a scroll bar scroll down one rangewindow
				if (_multiline)
				{
					int displayLines = GetTall() / (surface()->GetFontTall(_font) + DRAW_OFFSET_Y);
					// move the cursor down
					for (int i=0; i < displayLines; i++)
					{
						GotoUp();
					}
				}
				
				// if there is a scroll bar scroll down one rangewindow
				if (_vertScrollBar)
				{
					int window = _vertScrollBar->GetRangeWindow();
					int newval = _vertScrollBar->GetValue();
					int linesToMove = window - (val - newval);
					_vertScrollBar->SetValue(val - linesToMove - 1);
				}
				break;
				
			}
		case KEY_PAGEDOWN:
			{
				int val = 0;
				fallThrough = (!_multiline) && (!_vertScrollBar);
				if (_vertScrollBar)
				{
					val = _vertScrollBar->GetValue();
				}
				
				if (_multiline)
				{
					int displayLines = GetTall() / (surface()->GetFontTall(_font) + DRAW_OFFSET_Y);
					// move the cursor down
					for (int i=0; i < displayLines; i++)
					{
						GotoDown();
					}
				}
				
				// if there is a scroll bar scroll down one rangewindow
				if (_vertScrollBar)
				{
					int window = _vertScrollBar->GetRangeWindow();
					int newval = _vertScrollBar->GetValue();
					int linesToMove = window - (newval - val);
					_vertScrollBar->SetValue(val + linesToMove + 1);
				}
				break;
			}

		case KEY_F1:
		case KEY_F2:
		case KEY_F3:
		case KEY_F4:
		case KEY_F5:
		case KEY_F6:
		case KEY_F7:
		case KEY_F8:
		case KEY_F9:
		case KEY_F10:
		case KEY_F11:
		case KEY_F12:
			{
				fallThrough = true;
				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;
	
	if (_dataChanged)
	{
		FireActionSignal();
	}
	
	// chain back on some keys
	if (fallThrough)
	{
		_putCursorAtEnd=_cursorIsAtEnd;	// keep state of cursor on fallthroughs
		BaseClass::OnKeyCodeTyped(code);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Masks which keys get chained up
//			Maps keyboard input to text window functions.
//-----------------------------------------------------------------------------
void TextEntry::OnKeyTyped(wchar_t unichar)
{
	_cursorIsAtEnd = _putCursorAtEnd;
	_putCursorAtEnd=false;
	
	bool fallThrough = false;
	
	// KeyCodes handle all non printable chars
	if (iswcntrl(unichar) || unichar == 9 ) // tab key (code 9) is printable but handled elsewhere
		return;
	
	// do readonly keys
	if (!IsEditable())
	{
		BaseClass::OnKeyTyped(unichar);
		return;
	}
	
	if (unichar != 0)
	{
		DeleteSelected();
		SaveUndoState();
		InsertChar(unichar);
	}
	
	// select[1] is the location in the line where the blinking cursor started
	_select[1] = _cursorPos;
	
	if (_dataChanged)
	{
		FireActionSignal();
	}
	
	// chain back on some keys
	if (fallThrough)
	{
		_putCursorAtEnd=_cursorIsAtEnd;	// keep state of cursor on fallthroughs
		BaseClass::OnKeyTyped(unichar);
	}
}


//-----------------------------------------------------------------------------
// Purpose: Scrolls the list according to the mouse wheel movement
//-----------------------------------------------------------------------------
void TextEntry::OnMouseWheeled(int delta)
{
	if (_vertScrollBar)
	{
		MoveScrollBar(delta);
	}
	else
	{
		// if we don't use the input, chain back
		BaseClass::OnMouseWheeled(delta);
	}
}

//-----------------------------------------------------------------------------
// Purpose: Scrolls the list 
// Input  : delta - amount to move scrollbar up
//-----------------------------------------------------------------------------
void TextEntry::MoveScrollBar(int delta)
{
	if (_vertScrollBar)
	{
		int val = _vertScrollBar->GetValue();
		val -= (delta * 3);
		_vertScrollBar->SetValue(val);
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called every frame the entry has keyboard focus; 
//          blinks the text cursor
//-----------------------------------------------------------------------------
void TextEntry::OnKeyFocusTicked()
{
	int time=system()->GetTimeMillis();
	if(time>_cursorNextBlinkTime)
	{
		_cursorBlink=!_cursorBlink;
		_cursorNextBlinkTime=time+_cursorBlinkRate;
		Repaint();
	}
}

Panel *TextEntry::GetDragPanel()
{
	if ( input()->IsMouseDown( MOUSE_LEFT ) )
	{
		int x, y;
		input()->GetCursorPos(x, y);
		ScreenToLocal(x, y);
		int cursor = PixelToCursorSpace(x, y);
	
		int cx0, cx1;
		bool check = GetSelectedRange( cx0, cx1 );

		if ( check && cursor >= cx0 && cursor < cx1 )
		{
			// Don't deselect in this case!!!
			return BaseClass::GetDragPanel();
		}
		return NULL;
	}

	return BaseClass::GetDragPanel();
}

void TextEntry::OnCreateDragData( KeyValues *msg )
{
	BaseClass::OnCreateDragData( msg );

	char txt[ 256 ];
	GetText( txt, sizeof( txt ) );

	int r0, r1;
	if ( GetSelectedRange( r0, r1 ) && r0 != r1 )
	{
		int len = r1 - r0;
		if ( len > 0 && r0 < 1024 )
		{
			char selection[ 512 ];
			Q_strncpy( selection, &txt[ r0 ], len + 1 );
			selection[ len ] = 0;
			msg->SetString( "text", selection );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Check if we are selecting text (so we can highlight it)
//-----------------------------------------------------------------------------
bool TextEntry::SelectCheck( bool fromMouse /*=false*/ )
{
	bool bret = true;
	if (!HasFocus() || !(input()->IsKeyDown(KEY_LSHIFT) || input()->IsKeyDown(KEY_RSHIFT)))
	{
		bool deselect = true;
		int cx0, cx1;
		if ( fromMouse && 
			GetDragPanel() != NULL )
		{
			// move the cursor to where the mouse was pressed
			int x, y;
			input()->GetCursorPos(x, y);
			ScreenToLocal(x, y);
			int cursor = PixelToCursorSpace(x, y);
		
			bool check = GetSelectedRange( cx0, cx1 );

			if ( check && cursor >= cx0 && cursor < cx1 )
			{
				// Don't deselect in this case!!!
				deselect = false;
				bret = false;
			}
		}

		if ( deselect )
		{
			_select[0] = -1;
		}
	}
	else if (_select[0] == -1)
	{
		_select[0] = _cursorPos;
	}
	return bret;
}

//-----------------------------------------------------------------------------
// Purpose: set the maximum number of chars in the text buffer
//-----------------------------------------------------------------------------
void TextEntry::SetMaximumCharCount(int maxChars)
{
	_maxCharCount = maxChars;
}

//-----------------------------------------------------------------------------
// Purpose: data accessor
//-----------------------------------------------------------------------------
int TextEntry::GetMaximumCharCount()
{
	return _maxCharCount;
}

//-----------------------------------------------------------------------------
// Purpose: data accessor
//-----------------------------------------------------------------------------
void TextEntry::SetAutoProgressOnHittingCharLimit(bool state)
{
	m_bAutoProgressOnHittingCharLimit = state;
}

//-----------------------------------------------------------------------------
// Purpose: set whether to wrap the text buffer
//-----------------------------------------------------------------------------
void TextEntry::SetWrap(bool wrap)
{
	_wrap = wrap;
}

//-----------------------------------------------------------------------------
// Purpose: set whether to pass newline msgs to parent
//-----------------------------------------------------------------------------
void TextEntry::SendNewLine(bool send)
{
	_sendNewLines = send;
}

//-----------------------------------------------------------------------------
// Purpose: Tell if an index is a linebreakindex
//-----------------------------------------------------------------------------
bool TextEntry::IsLineBreak(int index)
{
	for (int i=0; i<m_LineBreaks.Count(); ++i)
	{
		if (index ==  m_LineBreaks[i])
			return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor one character to the left, scroll the text
//  horizontally if needed
//-----------------------------------------------------------------------------
void TextEntry::GotoLeft()
{
	SelectCheck();
	
	// if we are on a line break just move the cursor to the prev line
	if (IsLineBreak(_cursorPos))
	{
		// if we're already on the prev line at the end dont put it on the end
		if (!_cursorIsAtEnd)
			_putCursorAtEnd = true;
	}
	// if we are not at Start decrement cursor 
	if (!_putCursorAtEnd && _cursorPos > 0)
	{
		_cursorPos--;	
	}
	
    ScrollLeft();
	
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor one character to the right, scroll the text
//			horizontally if needed
//-----------------------------------------------------------------------------
void TextEntry::GotoRight()
{
	SelectCheck();
	
	// if we are on a line break just move the cursor to the next line
	if (IsLineBreak(_cursorPos))
	{
		if (_cursorIsAtEnd)
		{
			_putCursorAtEnd = false;
		}
		else
		{
			// if we are not at end increment cursor 
			if (_cursorPos < m_TextStream.Count())
			{
				_cursorPos++;
			}	
		}
	}
	else
	{
		// if we are not at end increment cursor 
		if (_cursorPos < m_TextStream.Count())
		{
			_cursorPos++;
		}
		
		// if we are on a line break move the cursor to end of line 
		if (IsLineBreak(_cursorPos))
		{
			if (!_cursorIsAtEnd)
				_putCursorAtEnd = true;
		}
	}
	// scroll right if we need to
	ScrollRight();
	
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Find out what line the cursor is on
//-----------------------------------------------------------------------------
int TextEntry::GetCursorLine()
{
	// find which line the cursor is on
	int cursorLine;
	for (cursorLine = 0; cursorLine < m_LineBreaks.Count(); cursorLine++)
	{
		if (_cursorPos < m_LineBreaks[cursorLine])
			break;
	}
	
	if (_putCursorAtEnd)  // correct for when cursor is at end of line rather than Start of next
	{
		// we are not at end of buffer, in which case there is no next line to be at the Start of
		if (_cursorPos != m_TextStream.Count() ) 
			cursorLine--;
	}
	
	return cursorLine;
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor one line up 
//-----------------------------------------------------------------------------
void TextEntry::GotoUp()
{
	SelectCheck();
	
	if (_cursorIsAtEnd)
	{
		if ( (GetCursorLine() - 1 ) == 0) // we are on first line
		{
			// stay at end of line
			_putCursorAtEnd = true;
			return;	 // dont move the cursor
		}
		else
			_cursorPos--;  
	}
	
	int cx, cy;
	CursorToPixelSpace(_cursorPos, cx, cy);
	
	// move the cursor to the previous line
	MoveCursor(GetCursorLine() - 1, cx);
}


//-----------------------------------------------------------------------------
// Purpose: Move the cursor one line down
//-----------------------------------------------------------------------------
void TextEntry::GotoDown()
{
	SelectCheck();
	
	if (_cursorIsAtEnd)
	{
		_cursorPos--;
		if (_cursorPos < 0)
			_cursorPos = 0;
	}
	
	int cx, cy;
	CursorToPixelSpace(_cursorPos, cx, cy);
	
	// move the cursor to the next line
	MoveCursor(GetCursorLine() + 1, cx);
	if (!_putCursorAtEnd && _cursorIsAtEnd )
	{
		_cursorPos++;
		if (_cursorPos > m_TextStream.Count())
		{
			_cursorPos = m_TextStream.Count();
		}
	}
	LayoutVerticalScrollBarSlider();	
}

//-----------------------------------------------------------------------------
// Purpose: Set the starting ypixel positon for a walk through the window
//-----------------------------------------------------------------------------
int TextEntry::GetYStart()
{
	if (_multiline)
	{
		// just Start from the top
		return DRAW_OFFSET_Y;
	}

	int fontTall = surface()->GetFontTall(_font);
	return (GetTall() / 2) - (fontTall / 2);
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor to a line, need to know how many pixels are in a line
//-----------------------------------------------------------------------------
void TextEntry::MoveCursor(int line, int pixelsAcross)
{
	// clamp to a valid line
	if (line < 0)
		line = 0;
	if (line >= m_LineBreaks.Count())
		line = m_LineBreaks.Count() -1;
	
	// walk the whole text set looking for our place
	// work out where to Start checking
	
	int yStart = GetYStart();
	
	int x = DRAW_OFFSET_X, y = yStart;
	int lineBreakIndexIndex = 0;
	_pixelsIndent = 0;
	int i;
	for ( i = 0; i < m_TextStream.Count(); i++)
	{
		wchar_t ch = m_TextStream[i];
		
		if (_hideText)
		{
			ch = '*';
		}
		
		// if we've passed a line break go to that
		if (m_LineBreaks[lineBreakIndexIndex] == i)
		{
			if (lineBreakIndexIndex == line)
			{
				_putCursorAtEnd = true;
				_cursorPos = i;
				break;
			}
			
			// add another line
			AddAnotherLine(x,y);
			lineBreakIndexIndex++;
			
		}
		
		// add to the current position
		int charWidth = getCharWidth(_font, ch);		
		
		if (line == lineBreakIndexIndex)
		{
			// check to see if we're in range
			if ((x + (charWidth / 2)) > pixelsAcross)
			{
				// found position
				_cursorPos = i;
				break;
			}
		}
		
		x += charWidth;
	}
	
	// if we never find the cursor it must be past the end
	// of the text buffer, to let's just slap it on the end of the text buffer then.
	if (i ==  m_TextStream.Count())
	{
		GotoTextEnd();
	}
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Turn horizontal scrolling on or off.
//			Horizontal scrolling is disabled in multline windows. 
//		    Toggling this will disable it in single line windows as well.
//-----------------------------------------------------------------------------
void TextEntry::SetHorizontalScrolling(bool status) 
{
	_horizScrollingAllowed = status;
}

//-----------------------------------------------------------------------------
// Purpose: Horizontal scrolling function, not used in multiline windows
//			Function will scroll the buffer to the left if the cursor is not in the window
//			scroll left if we need to 
//-----------------------------------------------------------------------------
void TextEntry::ScrollLeft()
{
	if (_multiline)	  // early out
	{
		return;
	}
	
	if (!_horizScrollingAllowed)  //early out
	{
		return;
	}
	
	if(_cursorPos < _currentStartIndex)	 // scroll left if we need to
	{
		if (_cursorPos < 0)// dont scroll past the Start of buffer
		{
			_cursorPos=0;			
		}
		_currentStartIndex = _cursorPos;
	}
	
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::ScrollLeftForResize()
{
	if (_multiline)	  // early out
	{
		return;
	}
	
	if (!_horizScrollingAllowed)  //early out
	{
		return;
	}

    while (_currentStartIndex > 0)     // go until we hit leftmost
    {
        _currentStartIndex--;
		int nVal = _currentStartIndex;

        // check if the cursor is now off the screen
        if (IsCursorOffRightSideOfWindow(_cursorPos))
        {
            _currentStartIndex++;   // we've gone too far, return it
            break;
        }

        // IsCursorOffRightSideOfWindow actually fixes the _currentStartIndex, 
        // so if our value changed that menas we really are off the screen
		if (nVal != _currentStartIndex)
			break;
    }
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: Horizontal scrolling function, not used in multiline windows
//			Scroll one char right until the cursor is visible in the window.
//			We do this one char at a time because char width isn't a constant.
//-----------------------------------------------------------------------------
void TextEntry::ScrollRight()
{
	if (!_horizScrollingAllowed)
		return;

	if (_multiline)	  
	{
	}
	// check if cursor is off the right side of window
	else if (IsCursorOffRightSideOfWindow(_cursorPos))
	{
		_currentStartIndex++; //scroll over
		ScrollRight(); // scroll again, check if cursor is in window yet 
	}
	
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: Check and see if cursor position is off the right side of the window
//			just compare cursor's pixel coords with the window size coords.
// Input:	an integer cursor Position, if you pass _cursorPos fxn will tell you
//			if current cursor is outside window.
// Output:	true: cursor is outside right edge or window 
//			false: cursor is inside right edge
//-----------------------------------------------------------------------------
bool TextEntry::IsCursorOffRightSideOfWindow(int cursorPos)
{
	int cx, cy;
	CursorToPixelSpace(cursorPos, cx, cy);
	int wx=GetWide()-1;	//width of inside of window is GetWide()-1
	if ( wx <= 0 )
		return false;

	return (cx >= wx);
}

//-----------------------------------------------------------------------------
// Purpose: Check and see if cursor position is off the left side of the window
//			just compare cursor's pixel coords with the window size coords.
// Input:	an integer cursor Position, if you pass _cursorPos fxn will tell you
//			if current cursor is outside window.
// Output:	true - cursor is outside left edge or window 
//			false - cursor is inside left edge
//-----------------------------------------------------------------------------
bool TextEntry::IsCursorOffLeftSideOfWindow(int cursorPos)
{
	int cx, cy;
	CursorToPixelSpace(cursorPos, cx, cy);
	return (cx <= 0);
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor over to the Start of the next word to the right
//-----------------------------------------------------------------------------
void TextEntry::GotoWordRight()
{
	SelectCheck();
	
	// 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
		
	// scroll right if we need to
	ScrollRight();
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Move the cursor over to the Start of the next word to the left
//-----------------------------------------------------------------------------
void TextEntry::GotoWordLeft()
{
	SelectCheck();
	
	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
	
	
	// scroll left if we need to
	ScrollLeft();
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Move cursor to the Start of the text buffer
//-----------------------------------------------------------------------------
void TextEntry::GotoTextStart()
{
	SelectCheck();
	_cursorPos = 0;		   // set cursor to Start
	_putCursorAtEnd = false;
	_currentStartIndex=0;  // scroll over to Start
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Move cursor to the end of the text buffer
//-----------------------------------------------------------------------------
void TextEntry::GotoTextEnd()
{
	SelectCheck();
	_cursorPos=m_TextStream.Count();	// set cursor to end of buffer
	_putCursorAtEnd = true; // move cursor Start of next line
	ScrollRight();				// scroll over until cursor is on screen
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Move cursor to the Start of the current line
//-----------------------------------------------------------------------------
void TextEntry::GotoFirstOfLine()
{
	SelectCheck();
	// to get to the Start of the line you have to take into account line wrap
	// we have to figure out at which point the line wraps
	// given the current cursor position, select[1], find the index that is the
	// line Start to the left of the cursor
	//_cursorPos = 0; //TODO: this is wrong, should go to first non-whitespace first, then to zero
	_cursorPos = GetCurrentLineStart();
	_putCursorAtEnd = false;
	
	_currentStartIndex=_cursorPos;
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Get the index of the first char on the current line
//-----------------------------------------------------------------------------
int TextEntry::GetCurrentLineStart()
{
	if (!_multiline)			// quick out for non multline buffers
		return _currentStartIndex;
	
	int i;
	if (IsLineBreak(_cursorPos))
	{
		for (i = 0; i < m_LineBreaks.Count(); ++i )
		{
			if (_cursorPos == m_LineBreaks[i])
				break;
		}
		if (_cursorIsAtEnd)
		{
			if (i > 0)
			{
				return m_LineBreaks[i-1];
			}
			return m_LineBreaks[0];
		}
		else
			return _cursorPos; // we are already at Start
	}
	
	for ( i = 0; i < m_LineBreaks.Count(); ++i )
	{
		if (_cursorPos < m_LineBreaks[i])
		{
			if (i == 0)
				return 0;
			else
				return m_LineBreaks[i-1];
		}
	}
	// if there were no line breaks, the first char in the line is the Start of the buffer
	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: Move cursor to the end of the current line
//-----------------------------------------------------------------------------
void TextEntry::GotoEndOfLine()
{
	SelectCheck();
	// to get to the end of the line you have to take into account line wrap in the buffer
	// we have to figure out at which point the line wraps
	// given the current cursor position, select[1], find the index that is the
	// line end to the right of the cursor
	//_cursorPos=m_TextStream.Count(); //TODO: this is wrong, should go to last non-whitespace, then to true EOL
    _cursorPos = GetCurrentLineEnd();
	_putCursorAtEnd = true;
	
	ScrollRight();
	
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Get the index of the last char on the current line
//-----------------------------------------------------------------------------
int TextEntry::GetCurrentLineEnd()
{
	int i;
	if (IsLineBreak(_cursorPos)	)
	{
		for ( i = 0; i < m_LineBreaks.Count()-1; ++i )
		{
			if (_cursorPos == m_LineBreaks[i])
				break;
		}
		if (!_cursorIsAtEnd)
		{
			if (i == m_LineBreaks.Count()-2 )
				m_TextStream.Count();		
			else
				return m_LineBreaks[i+1];
		}
		else
			return _cursorPos; // we are already at end
	}
	
	for ( i = 0; i < m_LineBreaks.Count()-1; i++ )
	{
		if ( _cursorPos < m_LineBreaks[i])
		{
			return m_LineBreaks[i];
		}
	}
	return m_TextStream.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Insert a character into the text buffer
//-----------------------------------------------------------------------------
void TextEntry::InsertChar(wchar_t ch)
{
	// throw away redundant linefeed characters
	if (ch == '\r')
		return;
	
	// no newline characters in single-line dialogs
	if (!_multiline && ch == '\n')
		return;

	// no tab characters
	if (ch == '\t')
		return;

	if (m_bAllowNumericInputOnly)
	{
		if (!iswdigit(ch) && ((char)ch != '.'))
		{
			surface()->PlaySound("Resource\\warning.wav");
			return;
		}
	}
	
	// check against unicode characters
	if (!m_bAllowNonAsciiCharacters)
	{
		if (ch > 127)
			return;
	}

	// don't add characters if the max char count has been reached
	// ding at the user
	if (_maxCharCount > -1 && m_TextStream.Count() >= _maxCharCount)
	{
		if (_maxCharCount>0 && _multiline && _wrap)
		{
			// if we wrap lines rather than stopping
			while (m_TextStream.Count() > _maxCharCount)
			{
				if (_recalculateBreaksIndex==0) 
				{
					// we can get called before this has been run for the first time :)
					RecalculateLineBreaks();
				}
				if (m_LineBreaks[0]> m_TextStream.Count())
				{
					// if the line break is the past the end of the buffer recalc
					_recalculateBreaksIndex=-1;
					RecalculateLineBreaks();
				}
				
				if (m_LineBreaks[0]+1 < m_TextStream.Count())
				{
					// delete the line
					m_TextStream.RemoveMultiple(0, m_LineBreaks[0]);
					
					// in case we just deleted text from where the cursor is
					if (_cursorPos> m_TextStream.Count())
					{
						_cursorPos = m_TextStream.Count(); 
					}
					else
					{ // shift the cursor up. don't let it wander past zero
						_cursorPos-=m_LineBreaks[0]+1;
						if (_cursorPos<0)
						{
							_cursorPos=0;
						}
					}
					
					// move any selection area up
					if(_select[0]>-1)
					{
						_select[0] -=m_LineBreaks[0]+1;
						
						if(_select[0] <=0)
						{
							_select[0] =-1;
						}
						
						_select[1] -=m_LineBreaks[0]+1;
						if(_select[1] <=0)
						{
							_select[1] =-1;
						}
						
					}
					
					// now redraw the buffer
					for (int i = m_TextStream.Count() - 1; i >= 0; i--)
					{
						SetCharAt(m_TextStream[i], i+1);
					}
					
					// redo all the line breaks
					_recalculateBreaksIndex=-1;
					RecalculateLineBreaks();
					
				}
			}
			
		} 
		else
		{
			// make a sound
			// we've hit the max character limit
			surface()->PlaySound("Resource\\warning.wav");
			return;
		}
	}
	
	
	if (_wrap) 
	{
		// when wrapping you always insert the new char at the end of the buffer
		SetCharAt(ch, m_TextStream.Count());
		_cursorPos=m_TextStream.Count(); 
	}
	else 
	{
		// move chars right 1 starting from cursor, then replace cursorPos with char and increment cursor
		for (int i =  m_TextStream.Count()- 1; i >= _cursorPos; i--)
		{
			SetCharAt(m_TextStream[i], i+1);
		}
		
		SetCharAt(ch, _cursorPos);
		_cursorPos++;
	}
	
	// if its a newline char we can't do the slider until we recalc the line breaks
	if (ch == '\n')
	{
		RecalculateLineBreaks();
	}
	
	// see if we've hit the char limit
	if (m_bAutoProgressOnHittingCharLimit && m_TextStream.Count() == _maxCharCount)
	{
		// move the next panel (most likely another TextEntry)
		RequestFocusNext();
	}

	// scroll right if this pushed the cursor off screen
	ScrollRight();
	
	_dataChanged = true;
	
	CalcBreakIndex();
	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Get the lineBreakIndex index of the line before the cursor
//			note _recalculateBreaksIndex < 0 flags RecalculateLineBreaks 
//			to figure it all out from scratch
//-----------------------------------------------------------------------------
void TextEntry::CalcBreakIndex()
{
	// an optimization to handle when the cursor is at the end of the buffer.
	// pays off if the buffer is large, and the search loop would be long.
	if (_cursorPos == m_TextStream.Count())
	{
		// we know m_LineBreaks array always has at least one element in it (99999 sentinel)
		// when there is just one line this will make recalc = -1 which is ok.
		_recalculateBreaksIndex = m_LineBreaks.Count()-2;
		return;
	}
	
	_recalculateBreaksIndex=0;
	// find the line break just before the cursor position
	while (_cursorPos > m_LineBreaks[_recalculateBreaksIndex])
		++_recalculateBreaksIndex;
	
	// -1  is ok.
	--_recalculateBreaksIndex;	
}

//-----------------------------------------------------------------------------
// 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 TextEntry::InsertString(const wchar_t *wszText)
{
	SaveUndoState();

	for (const wchar_t *ch = wszText; *ch != 0; ++ch)
	{
		InsertChar(*ch);
	}
	
	if (_dataChanged)
	{
		FireActionSignal();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Converts an ansi string to unicode and inserts it into the text stream
//-----------------------------------------------------------------------------
void TextEntry::InsertString(const char *text)
{
	// check for to see if the string is in the localization tables
	if (text[0] == '#')
	{
		wchar_t *wsz = g_pVGuiLocalize->Find(text);
		if (wsz)
		{
			InsertString(wsz);
			return;
		}
	}

	// straight convert the ansi to unicode and insert
	wchar_t unicode[1024];
	g_pVGuiLocalize->ConvertANSIToUnicode(text, unicode, sizeof(unicode));
	InsertString(unicode);
}

//-----------------------------------------------------------------------------
// Purpose: Handle the effect of user hitting backspace key
//			we delete the char before the cursor and reformat the text so it
//			behaves like in windows.
//-----------------------------------------------------------------------------
void TextEntry::Backspace()
{
	if (!IsEditable())
		return;

	//if you are at the first position don't do anything
	if(_cursorPos==0)
	{
		return;
	}
	
	//if the line is empty, don't do anything
	if(m_TextStream.Count()==0)
	{
		return;
	}
	
	SaveUndoState();
	
	//shift chars left one, starting at the cursor position, then make the line one smaller
	for(int i=_cursorPos;i<m_TextStream.Count(); ++i)
	{
		SetCharAt(m_TextStream[i],i-1);
	}
	m_TextStream.Remove(m_TextStream.Count() - 1);
	
	// As we hit the Start of the window, expose more chars so we can see what we are deleting
	if (_cursorPos==_currentStartIndex)
	{
		// windows tabs over 6 chars
		if (_currentStartIndex-6 >= 0) // dont scroll if there are not enough chars to scroll
		{
			_currentStartIndex-=6; 
		}
		else
			_currentStartIndex=0;
	}
	
	//move the cursor left one
	_cursorPos--;
	
	_dataChanged = true;
	
	// recalculate linebreaks (the fast incremental linebreak function doesn't work in this case)
	_recalculateBreaksIndex = 0;
	m_LineBreaks.RemoveAll();
	m_LineBreaks.AddToTail(BUFFER_SIZE);

	LayoutVerticalScrollBarSlider();
	ResetCursorBlink();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Deletes the current selection, if any, moving the cursor to the Start
//			of the selection
//-----------------------------------------------------------------------------
void TextEntry::DeleteSelected()
{
	if (!IsEditable())
		return;

	// if the line is empty, don't do anything
	if (m_TextStream.Count() == 0)
		return;
	
	// get the range to delete
	int x0, x1;
	if (!GetSelectedRange(x0, x1))
	{
		// no selection, don't touch anything
		return;
	}
	
	SaveUndoState();
	
	// shift chars left one starting after cursor position, then make the line one smaller
	int dif = x1 - x0;
	for (int i = 0; i < dif; ++i)
	{
		m_TextStream.Remove(x0);
	}
	
	// clear any selection
	SelectNone();
	ResetCursorBlink();
	
	// move the cursor to just after the deleted section
	_cursorPos = x0;
	
	_dataChanged = true;
	
	_recalculateBreaksIndex = 0;
	m_LineBreaks.RemoveAll();
	m_LineBreaks.AddToTail(BUFFER_SIZE);

	CalcBreakIndex();
	
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: Handle the effect of the user hitting the delete key
//			removes the char in front of the cursor
//-----------------------------------------------------------------------------
void TextEntry::Delete()
{
	if (!IsEditable())
		return;

	// if the line is empty, don't do anything
	if (m_TextStream.Count() == 0)
		return;
	
	// get the range to delete
	int x0, x1;
	if (!GetSelectedRange(x0, x1))
	{
		// no selection, so just delete the one character
		x0 = _cursorPos;
		x1 = x0 + 1;
		
		// if we're at the end of the line don't do anything
		if (_cursorPos >= m_TextStream.Count())
			return;
	}
	
	SaveUndoState();
	
	// shift chars left one starting after cursor position, then make the line one smaller
	int dif = x1 - x0;
	for (int i = 0; i < dif; i++)
	{
		m_TextStream.Remove((int)x0);
	}
	
	ResetCursorBlink();
	
	// clear any selection
	SelectNone();
	
	// move the cursor to just after the deleted section
	_cursorPos = x0;
	
	_dataChanged = true;
	
	_recalculateBreaksIndex = 0;
	m_LineBreaks.RemoveAll();
	m_LineBreaks.AddToTail(BUFFER_SIZE);

	CalcBreakIndex();
	
	LayoutVerticalScrollBarSlider();
}

//-----------------------------------------------------------------------------
// Purpose: Declare a selection empty
//-----------------------------------------------------------------------------
void TextEntry::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 TextEntry::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];
	int temp;
	if(cx1<cx0){temp=cx0;cx0=cx1;cx1=temp;}
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Opens the cut/copy/paste dropdown menu
//-----------------------------------------------------------------------------
void TextEntry::OpenEditMenu()
{
	// get cursor position, this is local to this text edit window
	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 TextEntry::CutSelected()
{
	CopySelected();
	DeleteSelected();
	// have to request focus if we used the menu
	RequestFocus();	

	if ( _dataChanged )
	{
		FireActionSignal();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Copies the selected chars into the clipboard
//-----------------------------------------------------------------------------
void TextEntry::CopySelected()
{
	if (_hideText)
		return;
	
	int x0, x1;
	if (GetSelectedRange(x0, x1))
	{
		CUtlVector<wchar_t> buf;
		for (int i = x0; i < x1; i++)
		{
			if ( m_TextStream[i]=='\n') 
			{
				buf.AddToTail( '\r' );
			}
			buf.AddToTail(m_TextStream[i]);
		}
		buf.AddToTail('\0');
		system()->SetClipboardText(buf.Base(), buf.Count());
	}
	
	// have to request focus if we used the menu
	RequestFocus();	
	
	if ( _dataChanged )
	{
		FireActionSignal();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Pastes the selected chars from the clipboard into the text buffer
//			truncates if text is longer than our _maxCharCount
//-----------------------------------------------------------------------------
void TextEntry::Paste()
{
	if (!IsEditable())
		return;

	CUtlVector<wchar_t> buf;
	int bufferSize = system()->GetClipboardTextCount();
	if (!m_bAutoProgressOnHittingCharLimit)
	{
		bufferSize = _maxCharCount > 0 ? _maxCharCount + 1 : system()->GetClipboardTextCount();  // +1 for terminator
	}

	buf.AddMultipleToTail(bufferSize);
	int len = system()->GetClipboardText(0, buf.Base(), bufferSize * sizeof(wchar_t));
	if (len < 1)
		return;
	
	SaveUndoState();
	bool bHaveMovedFocusAwayFromCurrentEntry = false;

	// insert all the characters
	for (int i = 0; i < len && buf[i] != 0; i++)
	{
		if (m_bAutoProgressOnHittingCharLimit)
		{
			// see if we're about to hit the char limit
			if (m_TextStream.Count() == _maxCharCount)
			{
				// move the next panel (most likely another TextEntry)
				RequestFocusNext();
				// copy the remainder into the clipboard
				wchar_t *remainingText = &buf[i];
				system()->SetClipboardText(remainingText, len - i - 1);
				// set the next entry to paste
				if (GetVParent() && ipanel()->GetCurrentKeyFocus(GetVParent()) != GetVPanel())
				{
					bHaveMovedFocusAwayFromCurrentEntry = true;
					ipanel()->SendMessage(ipanel()->GetCurrentKeyFocus(GetVParent()), new KeyValues("DoPaste"), GetVPanel());
				}
				break;
			}
		}

		// insert the character
		InsertChar(buf[i]);
	}

	// restore the original clipboard text if neccessary
	if (m_bAutoProgressOnHittingCharLimit)
	{
		system()->SetClipboardText(buf.Base(), bufferSize);
	}
	
	_dataChanged = true;
	FireActionSignal();

	if (!bHaveMovedFocusAwayFromCurrentEntry)
	{
		// have to request focus if we used the menu
		RequestFocus();	
	}
}

//-----------------------------------------------------------------------------
// Purpose: Reverts back to last saved changes
//-----------------------------------------------------------------------------
void TextEntry::Undo()
{
	_cursorPos = _undoCursorPos;
	m_TextStream.CopyArray(m_UndoTextStream.Base(), m_UndoTextStream.Count());
	
	InvalidateLayout();
	Repaint();
	SelectNone();
}

//-----------------------------------------------------------------------------
// Purpose: Saves the current state to the undo stack
//-----------------------------------------------------------------------------
void TextEntry::SaveUndoState()
{
	_undoCursorPos = _cursorPos;
	m_UndoTextStream.CopyArray(m_TextStream.Base(), m_TextStream.Count());
}

//-----------------------------------------------------------------------------
// Purpose: Returns the index in the text buffer of the
//          character the drawing should Start at
//-----------------------------------------------------------------------------
int TextEntry::GetStartDrawIndex(int &lineBreakIndexIndex)
{
	int startIndex = 0;
	
	int numLines = m_LineBreaks.Count();
	int startLine = 0;
	
	// determine the Start point from the scroll bar
	// do this only if we are not selecting text in the window with the mouse
	if (_vertScrollBar && !_mouseDragSelection)
	{	
		// skip to line indicated by scrollbar
		startLine = _vertScrollBar->GetValue();
	}
	else
	{
		// check to see if the cursor is off the screen-multiline case
		HFont font = _font;
		int displayLines = GetTall() / (surface()->GetFontTall(font) + DRAW_OFFSET_Y);
		if (displayLines < 1)
		{
			displayLines = 1;
		}
		if (numLines > displayLines)
		{
			int cursorLine = GetCursorLine();
			
			startLine = _currentStartLine;
			
			// see if that is visible
			if (cursorLine < _currentStartLine)
			{
				// cursor is above visible area; scroll back
				startLine = cursorLine;
				if (_vertScrollBar)
				{
					MoveScrollBar( 1 ); // should be calibrated for speed 
					// adjust startline incase we hit a limit
					startLine = _vertScrollBar->GetValue(); 
				}
			}
			else if (cursorLine > (_currentStartLine + displayLines - 1))
			{
				// cursor is down below visible area; scroll forward
				startLine = cursorLine - displayLines + 1;
				if (_vertScrollBar)
				{
					MoveScrollBar( -1 );
					startLine = _vertScrollBar->GetValue();
				}
			}
		}
		else if (!_multiline)
		{
			// check to see if cursor is off the right side of screen-single line case
			// get cursor's x coordinate in pixel space
			bool done = false;
			while ( !done )
			{
				done = true;
				int x = DRAW_OFFSET_X;
				for (int i = _currentStartIndex; i < m_TextStream.Count(); i++)
				{
					done = false;
					wchar_t ch = m_TextStream[i];			
					if (_hideText)
					{
						ch = '*';
					}
					
					// if we've found the position, break
					if (_cursorPos == i)
					{
						break;
					}
					
					// add to the current position		
					x += getCharWidth(font, ch);				
				}
				
				if ( x >= GetWide() )
				{
					_currentStartIndex++;
					// Keep searching...
					continue;
				}
				
				if ( x <= 0 )
				{
					// dont go past the Start of buffer
					if (_currentStartIndex > 0)
						_currentStartIndex--;
				}

				break;
			}
		}
	}
	
	if (startLine > 0)
	{
		lineBreakIndexIndex = startLine;
		if (startLine && startLine < m_LineBreaks.Count())
		{
			startIndex = m_LineBreaks[startLine - 1];
		}
	}
	
	if (!_horizScrollingAllowed)
		return 0;

	_currentStartLine = startLine;
	if (_multiline)
		return startIndex;
	else 
		return _currentStartIndex;

	
}

// helper accessors for common gets
float TextEntry::GetValueAsFloat()
{
	int nTextLength = GetTextLength() + 1;
	char* txt = ( char* )_alloca( nTextLength * sizeof( char ) );
	GetText( txt, nTextLength );

	return V_atof( txt );
}

int TextEntry::GetValueAsInt()
{
	int nTextLength = GetTextLength() + 1;
	char* txt = ( char* )_alloca( nTextLength * sizeof( char ) );
	GetText( txt, nTextLength );

	return V_atoi( txt );
}

//-----------------------------------------------------------------------------
// Purpose: Get a string from text buffer
// Input:	offset - index to Start reading from 
//			bufLenInBytes - length of string
//-----------------------------------------------------------------------------
void TextEntry::GetText(OUT_Z_BYTECAP(bufLenInBytes) char *buf, int bufLenInBytes)
{
	Assert(bufLenInBytes >= sizeof(buf[0]));
	if (m_TextStream.Count())
	{
		// temporarily null terminate the text stream so we can use the conversion function
		int nullTerminatorIndex = m_TextStream.AddToTail((wchar_t)0);
		g_pVGuiLocalize->ConvertUnicodeToANSI(m_TextStream.Base(), buf, bufLenInBytes);
		m_TextStream.FastRemove(nullTerminatorIndex);
	}
	else
	{
		// no characters in the stream
		buf[0] = 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Get a string from text buffer
// Input:	offset - index to Start reading from 
//			bufLen - length of string
//-----------------------------------------------------------------------------
void TextEntry::GetText(OUT_Z_BYTECAP(bufLenInBytes) wchar_t *wbuf, int bufLenInBytes)
{
	Assert(bufLenInBytes >= sizeof(wbuf[0]));
	int len = m_TextStream.Count();
	if (m_TextStream.Count())
	{
		int terminator = min(len, (bufLenInBytes / (int)sizeof(wchar_t)) - 1);
		wcsncpy(wbuf, m_TextStream.Base(), terminator);
		wbuf[terminator] = 0;
	}
	else
	{
		wbuf[0] = 0;
	}
}

void TextEntry::GetTextRange( wchar_t *buf, int from, int numchars )
{
	int len = m_TextStream.Count();
	int cpChars = max( 0, min( numchars, len - from ) );
	
	wcsncpy( buf, m_TextStream.Base() + max( 0, min( len, from ) ), cpChars );
	buf[ cpChars ] = 0;
}

void TextEntry::GetTextRange( char *buf, int from, int numchars )
{
	int len = m_TextStream.Count();
	int cpChars = max( 0, min( numchars, len - from ) );

	g_pVGuiLocalize->ConvertUnicodeToANSI( m_TextStream.Base() + max( 0, min( len, from ) ), buf, cpChars + 1 );
	buf[ cpChars ] = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Sends a message that the text has changed
//-----------------------------------------------------------------------------
void TextEntry::FireActionSignal()
{
	PostActionSignal(new KeyValues("TextChanged"));
	_dataChanged = false;	// reset the data changed flag
	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: Set the font of the buffer text 
// Input:	font to change to
//-----------------------------------------------------------------------------
void TextEntry::SetFont(HFont font)
{
	_font = font;
	InvalidateLayout();
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: Called when the scrollbar slider is moved
//-----------------------------------------------------------------------------
void TextEntry::OnSliderMoved()
{
	Repaint();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool TextEntry::RequestInfo(KeyValues *outputData)
{
	if (!stricmp(outputData->GetName(), "GetText"))
	{
		wchar_t wbuf[256];
		GetText(wbuf, 255);
		outputData->SetWString("text", wbuf);
		return true;
	}
	else if (!stricmp(outputData->GetName(), "GetState"))
	{
		char buf[64];
		GetText(buf, sizeof(buf));
		outputData->SetInt("state", atoi(buf));
		return true;
	}
	return BaseClass::RequestInfo(outputData);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::OnSetText(const wchar_t *text)
{
	SetText(text);
}

//-----------------------------------------------------------------------------
// Purpose: as above, but sets an integer
//-----------------------------------------------------------------------------
void TextEntry::OnSetState(int state)
{
	char buf[64];
	Q_snprintf(buf, sizeof(buf), "%d", state);
	SetText(buf);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );

	_font = scheme()->GetIScheme( GetScheme() )->GetFont( inResourceData->GetString( "font", "Default" ), IsProportional() );
	SetFont( _font );

	SetTextHidden((bool)inResourceData->GetInt("textHidden", 0));
	SetEditable((bool)inResourceData->GetInt("editable", 1));
	SetMaximumCharCount(inResourceData->GetInt("maxchars", -1));
	SetAllowNumericInputOnly(inResourceData->GetInt("NumericInputOnly", 0));
	SetAllowNonAsciiCharacters(inResourceData->GetInt("unicode", 0));
	SelectAllOnFirstFocus(inResourceData->GetInt("selectallonfirstfocus", 0));
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::GetSettings( KeyValues *outResourceData )
{
	BaseClass::GetSettings( outResourceData );
	outResourceData->SetInt("textHidden", _hideText);
	outResourceData->SetInt("editable", IsEditable());
	outResourceData->SetInt("maxchars", GetMaximumCharCount());
	outResourceData->SetInt("NumericInputOnly", m_bAllowNumericInputOnly);
	outResourceData->SetInt("unicode", m_bAllowNonAsciiCharacters);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *TextEntry::GetDescription()
{
	static char buf[1024];
	Q_snprintf(buf, sizeof(buf), "%s, bool textHidden, bool editable, bool unicode, bool NumericInputOnly, int maxchars", BaseClass::GetDescription());
	return buf;
}

//-----------------------------------------------------------------------------
// Purpose: Get the number of lines in the window
//-----------------------------------------------------------------------------
int TextEntry::GetNumLines()
{
	return m_LineBreaks.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Sets the height of the text entry window so all text will fit inside
//-----------------------------------------------------------------------------
void TextEntry::SetToFullHeight()
{
	PerformLayout();
	int wide, tall;
	GetSize(wide, tall);
	
	tall = GetNumLines() * (surface()->GetFontTall(_font) + DRAW_OFFSET_Y) + DRAW_OFFSET_Y + 2;
	SetSize (wide, tall);
	PerformLayout();
	
}

//-----------------------------------------------------------------------------
// Purpose: Select all the text.
//-----------------------------------------------------------------------------
void TextEntry::SelectAllText( bool bResetCursorPos )
{
	// if there's no text at all, select none
	if ( m_TextStream.Count() == 0 )
	{
		_select[0] = -1;
	}
	else
	{
		_select[0] = 0;
	}

	_select[1] = m_TextStream.Count();

	if ( bResetCursorPos )
	{
		_cursorPos = _select[1];
	}
}

//-----------------------------------------------------------------------------
// Purpose: Select no text.
//-----------------------------------------------------------------------------
void TextEntry::SelectNoText()
{
	_select[0] = -1;
	_select[1] = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Sets the width of the text entry window so all text will fit inside
//-----------------------------------------------------------------------------
void TextEntry::SetToFullWidth()
{
	// probably be problems if you try using this on multi line buffers
	// or buffers with clickable text in them.
	if (_multiline)
		return;
	
	PerformLayout();
	int wide = 2*DRAW_OFFSET_X; // buffer on left and right end of text.
	
	// loop through all the characters and sum their widths	
	for (int i = 0; i < m_TextStream.Count(); ++i)
	{
		wide += getCharWidth(_font, m_TextStream[i]);	
	}
	
	// height of one line of text
	int tall = (surface()->GetFontTall(_font) + DRAW_OFFSET_Y) + DRAW_OFFSET_Y + 2;
	
	SetSize (wide, tall);
	PerformLayout();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::SelectAllOnFirstFocus( bool status )
{
	_selectAllOnFirstFocus = status;
}

void TextEntry::SelectAllOnFocusAlways( bool status )
{
	_selectAllOnFirstFocus = status;
	_selectAllOnFocusAlways = status;
}

//-----------------------------------------------------------------------------
// Purpose: called when the text entry receives focus
//-----------------------------------------------------------------------------
void TextEntry::OnSetFocus()
{ 
	// see if we should highlight all on selection
    if (_selectAllOnFirstFocus)
	{
		_select[1] = m_TextStream.Count();
		_select[0] = _select[1] > 0 ? 0 : -1;
		_cursorPos = _select[1]; // cursor at end of line
		if ( !_selectAllOnFocusAlways )
		{
			_selectAllOnFirstFocus = false;
		}
    }
	else if (input()->IsKeyDown(KEY_TAB) || input()->WasKeyReleased(KEY_TAB))
	{
		// if we've tabbed to this field then move to the end of the text
		GotoTextEnd();
		// clear any selection
		SelectNone();
	}
	
	BaseClass::OnSetFocus();
}

//-----------------------------------------------------------------------------
// Purpose: Set the width we have to draw text in.
//			Do not use in multiline windows.
//-----------------------------------------------------------------------------
void TextEntry::SetDrawWidth(int width)
{
	_drawWidth = width;
}

//-----------------------------------------------------------------------------
// Purpose: Get the width we have to draw text in.
//-----------------------------------------------------------------------------
int TextEntry::GetDrawWidth()
{
	return _drawWidth;
}

//-----------------------------------------------------------------------------
// Purpose: data accessor
//-----------------------------------------------------------------------------
void TextEntry::SetAllowNonAsciiCharacters(bool state)
{
	m_bAllowNonAsciiCharacters = state;
}

//-----------------------------------------------------------------------------
// Purpose: data accessor
//-----------------------------------------------------------------------------
void TextEntry::SetAllowNumericInputOnly(bool state)
{
	m_bAllowNumericInputOnly = state;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : forward - 
//-----------------------------------------------------------------------------
void TextEntry::OnChangeIME( bool forward )
{
	// Only change ime if Unicode aware
	if ( m_bAllowNonAsciiCharacters )
	{
		input()->OnChangeIME( forward );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handleValue - 
//-----------------------------------------------------------------------------
void TextEntry::LanguageChanged( int handleValue )
{
	input()->OnChangeIMEByHandle( handleValue );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handleValue - 
//-----------------------------------------------------------------------------
void TextEntry::ConversionModeChanged( int handleValue )
{
	input()->OnChangeIMEConversionModeByHandle( handleValue );
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : handleValue - 
//-----------------------------------------------------------------------------
void TextEntry::SentenceModeChanged( int handleValue )
{
	input()->OnChangeIMESentenceModeByHandle( handleValue );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *compstr - 
//-----------------------------------------------------------------------------
void TextEntry::CompositionString( const wchar_t *compstr )
{
	wcsncpy( m_szComposition, compstr, sizeof( m_szComposition ) / sizeof( wchar_t ) - 1 );
	m_szComposition[  sizeof( m_szComposition ) / sizeof( wchar_t ) - 1 ] = L'\0';
}

void TextEntry::ShowIMECandidates()
{
	HideIMECandidates();

	int c = input()->GetCandidateListCount();
	if ( c == 0 )
	{
		return;
	}

	m_pIMECandidates = new Menu( this, "IMECandidatesMenu" );
	
	int pageStart = input()->GetCandidateListPageStart();
	int pageSize = input()->GetCandidateListPageSize();
	int selected = input()->GetCandidateListSelectedItem();

	int startAtOne = input()->CandidateListStartsAtOne() ? 1 : 0;

	if ( ( selected < pageStart ) || ( selected >= pageStart + pageSize ) )
	{
		pageStart = ( selected / pageSize ) * pageSize;
		input()->SetCandidateListPageStart( pageStart );
	}

	for ( int i = pageStart; i < pageStart + pageSize; ++i )
	{
		if ( i >= c )
			continue;

		bool isSelected = ( i == selected ) ? true : false;

		wchar_t unicode[ 32 ];
		input()->GetCandidate( i, unicode, sizeof( unicode ) );

		wchar_t label[ 64 ];
		_snwprintf( label, sizeof( label ) / sizeof( wchar_t ) - 1, L"%i %s", i - pageStart + startAtOne, unicode );
		label[ sizeof( label ) / sizeof( wchar_t ) - 1 ] = L'\0';

		int id = m_pIMECandidates->AddMenuItem( "Candidate", label, (KeyValues *)NULL, this );
		if ( isSelected )
		{
			m_pIMECandidates->SetCurrentlyHighlightedItem( id );
		}
	}
	
	m_pIMECandidates->SetVisible(true);
	m_pIMECandidates->SetParent(this);
	m_pIMECandidates->AddActionSignalTarget(this);
	m_pIMECandidates->SetKeyBoardInputEnabled( false );

	int cx, cy;
	CursorToPixelSpace(_cursorPos, cx, cy);
	cy = GetTall();

	LocalToScreen( cx, cy );

	//m_pIMECandidates->SetPos( cx, cy );

	// relayout the menu immediately so that we know it's size
	m_pIMECandidates->InvalidateLayout(true);
	int menuWide, menuTall;
	m_pIMECandidates->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 > cx)
	{
		// menu hanging right
		if (tall - menuTall > cy)
		{
			// menu hanging down
			m_pIMECandidates->SetPos(cx, cy);
		}
		else
		{
			// menu hanging up
			m_pIMECandidates->SetPos(cx, cy - menuTall - GetTall());
		}
	}
	else
	{
		// menu hanging left
		if (tall - menuTall > cy)
		{
			// menu hanging down
			m_pIMECandidates->SetPos(cx - menuWide, cy);
		}
		else
		{
			// menu hanging up
			m_pIMECandidates->SetPos(cx - menuWide, cy - menuTall-GetTall());
		}
	}
}

void TextEntry::HideIMECandidates()
{
	if ( m_pIMECandidates )
	{
		m_pIMECandidates->SetVisible( false );
	}
	delete m_pIMECandidates;
	m_pIMECandidates = NULL;
}

void TextEntry::UpdateIMECandidates()
{
	if ( !m_pIMECandidates )
		return;

	int c = input()->GetCandidateListCount();
	if ( c == 0 )
	{
		HideIMECandidates();
		return;
	}

	int oldCount = m_pIMECandidates->GetItemCount();
	int newCount = input()->GetCandidateListPageSize();

	if ( oldCount != newCount )
	{
		// Recreate the entire menu
		ShowIMECandidates();
		return;
	}

	int pageSize = input()->GetCandidateListPageSize();
	int selected = input()->GetCandidateListSelectedItem();
	int pageStart = input()->GetCandidateListPageStart();

	if ( ( selected < pageStart ) || selected >= pageStart + pageSize )
	{
		pageStart = ( selected / pageSize ) * pageSize;
		input()->SetCandidateListPageStart( pageStart );
	}

	int startAtOne = input()->CandidateListStartsAtOne() ? 1 : 0;

	for ( int i = pageStart; i < pageStart + pageSize; ++i )
	{
		int id = m_pIMECandidates->GetMenuID( i - pageStart );

		MenuItem *item = m_pIMECandidates->GetMenuItem( id );
		if ( !item )
			continue;

		if ( i >= c )
		{
			item->SetVisible( false );
			continue;
		}
		else
		{
			item->SetVisible( true );
		}

		bool isSelected = ( i == selected ) ? true : false;

		wchar_t unicode[ 32 ];
		input()->GetCandidate( i, unicode, sizeof( unicode ) );

		wchar_t label[ 64 ];
		_snwprintf( label, sizeof( label ) / sizeof( wchar_t ) - 1, L"%i %s", i - pageStart + startAtOne, unicode );
		label[ sizeof( label ) / sizeof( wchar_t ) - 1 ] = L'\0';
		item->SetText( label );
		if ( isSelected )
		{
			m_pIMECandidates->SetCurrentlyHighlightedItem( id );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TextEntry::FlipToLastIME()
{
	int hCurrentIME = input()->GetCurrentIMEHandle();
	int hEnglishIME = input()->GetEnglishIMEHandle();

	bool isEnglish = ( hCurrentIME == hEnglishIME ) ? true : false;

	// If in english, flip back to previous
	if ( isEnglish )
	{
		input()->OnChangeIMEByHandle( m_hPreviousIME );
	}
	else
	{
		// If not, remember language and flip to english...
		m_hPreviousIME = hCurrentIME;
		input()->OnChangeIMEByHandle( hEnglishIME );
	}
}

void TextEntry::SetDrawLanguageIDAtLeft( bool state )
{
	m_bDrawLanguageIDAtLeft = state;
}

bool TextEntry::GetDropContextMenu( Menu *menu, CUtlVector< KeyValues * >& msglist )
{
	menu->AddMenuItem( "replace", "#TextEntry_ReplaceText", "replace", this );
	menu->AddMenuItem( "append", "#TextEntry_AppendText", "append", this );
	menu->AddMenuItem( "prepend", "#TextEntry_PrependText", "prepend", this );
	return true;
}

bool TextEntry::IsDroppable( CUtlVector< KeyValues * >& msglist )
{
	if ( msglist.Count() != 1 )
		return false;

	if ( !IsEnabled() )
		return false;

	KeyValues *msg = msglist[ 0 ];

	const wchar_t *txt = msg->GetWString( "text", L"" );
	if ( !txt || txt[ 0 ] == L'\0' )
		return false;

	return true;
}

void TextEntry::OnPanelDropped( CUtlVector< KeyValues * >& msglist )
{
	if ( msglist.Count() != 1 )
		return;

	KeyValues *data = msglist[ 0 ];

	const wchar_t *newText = data->GetWString( "text" );
	if ( !newText || newText[ 0 ] == L'\0' )
		return;

	char const *cmd = data->GetString( "command" );
	if ( !Q_stricmp( cmd, "replace" ) ||
		 !Q_stricmp( cmd, "default" ) )
	{
		SetText( newText );
		_dataChanged = true;
		FireActionSignal();
	}
	else if ( !Q_stricmp( cmd, "append" ) )
	{
		int newLen = wcslen( newText );
		int curLen = m_TextStream.Count();

		size_t outsize = sizeof( wchar_t ) * ( newLen + curLen + 1 );
		wchar_t *out = (wchar_t *)_alloca( outsize );
		Q_memset( out, 0, outsize );
		wcsncpy( out, m_TextStream.Base(), curLen );
		wcsncat( out, newText, wcslen( newText ) );
		out[ newLen + curLen ] = L'\0';
		SetText( out );
		_dataChanged = true;
		FireActionSignal();
	}
	else if ( !Q_stricmp( cmd, "prepend" ) )
	{
		int newLen = wcslen( newText );
		int curLen = m_TextStream.Count();

		size_t outsize = sizeof( wchar_t ) * ( newLen + curLen + 1 );
		wchar_t *out = (wchar_t *)_alloca( outsize );
		Q_memset( out, 0, outsize );
		wcsncpy( out, newText, wcslen( newText ) );
		wcsncat( out, m_TextStream.Base(), curLen );
		out[ newLen + curLen ] = L'\0';
		SetText( out );
		_dataChanged = true;
		FireActionSignal();
	}
}

int TextEntry::GetTextLength() const
{
	return m_TextStream.Count();
}

bool TextEntry::IsTextFullySelected() const 
{
	if ( _select[ 0 ] != 0 )
		return false;

	if ( _select[ 1 ] != GetTextLength() )
		return false;

	return true;
}

void TextEntry::SetUseFallbackFont( bool bState, HFont hFallback )
{
	m_bUseFallbackFont = bState;
	m_hFallbackFont = hFallback;
}