H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 06:36:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8a366537e7
source-engine/vgui2/vgui_controls/TextEntry.cpp
nillerusr dc2be1dcb4 physics: fix a lot of problems
2021-10-23 14:41:59 +03:00

4284 lines
107 KiB
C++
Raw Blame History

//========= 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>
#include <inputsystem/iinputsystem.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;
}
if( IsEnabled() )
g_pInputSystem->StartTextInput();
// 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;
}
Reference in New Issue View Git Blame Copy Permalink