Validator platform textbox - no rendering, used only for compilation. More...

#include <PlatformTextBox.h>

Inheritance diagram for PlatformTextBox:

Public Member Functions
	PlatformTextBox (std::string text, counted_ptr< PEBLObjectBase > font, int width, int height)

	PlatformTextBox (const PlatformTextBox &textbox)
	This copy constructor isn't const because the font is shared.

virtual	~PlatformTextBox ()
	Standard Destructor.

virtual bool	RenderText ()

virtual bool	SetProperty (std::string, Variant v)

virtual Variant	GetProperty (std::string name) const

virtual void	SetFont (counted_ptr< PEBLObjectBase > font)

virtual void	SetText (std::string text)

virtual void	SetHeight (int h)

virtual void	SetWidth (int w)

virtual counted_ptr< PEBLObjectBase >	GetFont () const

virtual bool	Draw ()
	This method initiates everything needed to display the main window

virtual void	HandleKeyPress (int keycode, int modkeys, Uint16 unicode)

virtual void	HandleTextInput (std::string input)

virtual std::string	ObjectName () const

virtual int	FindCursorPosition (long int x, long int y)

virtual void	SetEditable (bool val)

Variant	GetLineBreaks ()

	PlatformTextBox (const std::string &text, counted_ptr< PEBLObjectBase > font, int width, int height)

	PlatformTextBox (PlatformTextBox &textbox)

virtual	~PlatformTextBox ()

virtual bool	Draw ()
	This method initiates everything needed to display the main window

virtual std::string	ObjectName () const

virtual int	FindCursorPosition (long int x, long int y)

virtual Variant	GetLineBreaks ()

virtual void	SetFont (counted_ptr< PEBLObjectBase > font)

virtual bool	SetProperty (std::string name, Variant v)

virtual ObjectValidationError	ValidateProperty (std::string name, Variant v) const

virtual ObjectValidationError	ValidateProperty (std::string name) const

virtual void	SetPosition (pInt x, pInt y)
	This sets the widget's position on its parent widget.

Public Member Functions inherited from PlatformWidget
	PlatformWidget ()

virtual	~PlatformWidget ()

virtual SDL_Texture *	GetSDL_Texture ()
	Used to extract an SDL surface from the widget. Used by children drawing themselves on their parent.

void	SetParent (PlatformWidget *parent)

SDL_Surface *	GetSurface ()

virtual bool	SetRenderer (SDL_Renderer *renderer)

SDL_Renderer *	GetRenderer ()

virtual bool	AddToParentWidget (PlatformWidget *parent)

virtual bool	AddSubWidget (PlatformWidget *widget)

virtual bool	RemoveSubWidget (PlatformWidget *widget)

virtual bool	RemoveSubWidgets ()

virtual bool	RotoZoom (double angle, double zoomx, double zoomy, int smooth)
	This uses the SDL_gfx package to 'rotozoom'.

bool	SetPoint (int x, int y, PColor col)

PColor	GetPixel (int x, int y)

	PlatformWidget ()

	PlatformWidget (pInt x, pInt y, pInt width, pInt height, bool visible)

virtual	~PlatformWidget ()

virtual bool	RotoZoom (pDouble angle, pDouble zoomx, pDouble zoomy, pInt smooth)

virtual bool	SetPoint (pInt x, pInt y, PColor col)

virtual PColor	GetPixel (pInt x, pInt y)

Public Member Functions inherited from PWidget
	PWidget ()

	PWidget (const PWidget &pw)

	PWidget (pInt x, pInt y, pInt width, pInt height, bool visible)

virtual	~PWidget ()

virtual void	SetParent (PWidget *widget)
	This unconditionally sets the parent widget.

virtual PWidget *	GetParent ()

virtual bool	IsParent (PWidget *parent)

virtual void	SetZoomX (pDouble x)
	This sets the widget's position on its parent widget.

virtual void	SetZoomY (pDouble x)
	This sets the widget's position on its parent widget.

virtual void	SetRotation (pDouble x)
	This sets the widget's position on its parent widget.

virtual void	SetWidth (pInt w)

virtual void	SetHeight (pInt h)

virtual pInt	GetX () const

virtual pInt	GetY () const

virtual pInt	GetWidth () const

virtual pInt	GetHeight () const

virtual void	SetBackgroundColor (const PColor &color)

virtual PColor	GetBackgroundColor ()

virtual bool	AddSubWidget (PWidget *widget)

virtual bool	RemoveSubWidget (PWidget *widget)

virtual bool	RemoveLastSubWidget ()
	This is probably pretty useless.

virtual void	Show ()

virtual void	Hide ()

virtual bool	IsVisible () const

Public Member Functions inherited from PEBLObjectBase
	PEBLObjectBase ()
	Standard Constructor.

	PEBLObjectBase (ComplexDataType cdt)
	Standard Constructor.

	PEBLObjectBase (const PEBLObjectBase &pob)

virtual	~PEBLObjectBase ()
	Standard Destructor.

virtual bool	InitializeProperty (std::string name, Variant v)

Variant	GetProperty (std::string) const

ComplexDataType	GetType ()

virtual std::ostream &	PrintProperties (std::ostream &out)

virtual Variant	GetPropertyList ()

Public Member Functions inherited from PTextBox
	PTextBox ()

	PTextBox (std::string text, int width, int height)

	PTextBox (PTextBox &textbox)

virtual	~PTextBox ()

virtual void	InsertText (const std::string character)

virtual void	DeleteText (int length)

virtual bool	GetEditable ()

virtual void	SetCursorPosition (unsigned long int pos)

virtual unsigned long int	GetCursorPosition ()

virtual long unsigned int	IncrementCursor ()

virtual long unsigned int	DecrementCursor ()

virtual void	SetLineWrap (bool state)

virtual void	SetJustify (Variant j)

virtual bool	AtPrintableCharacter (unsigned long int x)

Public Member Functions inherited from PTextObject
	PTextObject ()

	PTextObject (const std::string &text)

	PTextObject (PTextObject &object)

virtual	~PTextObject ()

virtual void	SetText (const std::string &text)

virtual void	SetDirection (int i)

virtual std::string	GetText () const

virtual unsigned long int	GetNumCharacters ()

Protected Member Functions
virtual std::ostream &	SendToStream (std::ostream &out) const
	An inheritable printing class used by PEBLObjectBase::operator<<.

virtual std::ostream &	SendToStream (std::ostream &out) const
	An inheritable printing class used by PEBLObjectBase::operator<<.

Protected Member Functions inherited from PlatformWidget
virtual void	PrintSubWidgets (std::ostream &out) const

virtual bool	LockSurface ()
	This needs to be used on some platforms/video cards.

virtual bool	UnlockSurface ()
	This needs to be used on some platforms/video cards.

Protected Attributes
std::vector< int >	mBreaks

Protected Attributes inherited from PlatformWidget
pInt	mTextureWidth

pInt	mTextureHeight

bool	mNeedsTexture

SDL_Texture *	mTexture

SDL_Surface *	mSurface

SDL_Renderer *	mRenderer

Protected Attributes inherited from PWidget
pInt	mX

pInt	mY

pInt	mDrawX

pInt	mDrawY

pInt	mWidth

pInt	mHeight

pDouble	mZoomX

pDouble	mZoomY

pDouble	mRotation

PColor	mBackgroundColor
	The background color of the widget. if alpha = 0, will not be painted.

std::list< PWidget * >	mSubWidgets

bool	mIsVisible

PWidget *	mParent

Protected Attributes inherited from PEBLObjectBase
ComplexDataType	mCDT

std::map< std::string, Variant >	mProperties

Protected Attributes inherited from PTextBox
bool	mEditable

unsigned long int	mCursorPos

bool	mCursorChanged

bool	mLineWrap

Variant	mJustify

Protected Attributes inherited from PTextObject
bool	mChanged

std::string	mText

int	mDirection

Detailed Description

Validator platform textbox - no rendering, used only for compilation.

This class defines an SDL-specific text box.

Definition at line 55 of file sdl/PlatformTextBox.h.

Constructor & Destructor Documentation

◆ PlatformTextBox() [1/4]

PlatformTextBox::PlatformTextBox	(	std::string	text,
		counted_ptr< PEBLObjectBase >	font,
		int	width,
		int	height
	)

◆ PlatformTextBox() [2/4]

PlatformTextBox::PlatformTextBox ( const PlatformTextBox & textbox )

This copy constructor isn't const because the font is shared.

Definition at line 147 of file sdl/PlatformTextBox.cpp.

                                                            :
    PTextObject(text.GetText()),  // Must initialize virtual base class directly
    PlatformWidget(),
    PTextBox(text.GetText(), (int)(text.GetWidth()), (int)(text.GetHeight()))
 
 
{
    mSurface = NULL;
    mTexture = NULL;
    mRenderer = NULL;
    mIsUTF8=  utf8::is_valid(mText.begin(),mText.end());
    mCDT = CDT_TEXTBOX;
    mWidth = text.GetWidth();
    mHeight = text.GetHeight();
    mTextureWidth=mWidth;
    mTextureHeight=mHeight;
 
    SetFont(text.GetFont());
    mChanged = true;
    // Don't call Draw() here - no renderer yet since object hasn't been added to window
    // Draw() will be called when object is added to window or explicitly drawn
}

References CDT_TEXTBOX, GetFont(), PWidget::GetHeight(), PWidget::GetWidth(), PEBLObjectBase::mCDT, PTextObject::mChanged, PWidget::mHeight, PlatformWidget::mRenderer, PlatformWidget::mSurface, PTextObject::mText, PlatformWidget::mTexture, PlatformWidget::mTextureHeight, PlatformWidget::mTextureWidth, PWidget::mWidth, NULL, and SetFont().

◆ ~PlatformTextBox() [1/2]

PlatformTextBox::~PlatformTextBox ( )

virtual

Standard Destructor.

Definition at line 172 of file sdl/PlatformTextBox.cpp.

{
 
    // PlatformWidget frees mSurface,
}

◆ PlatformTextBox() [3/4]

PlatformTextBox::PlatformTextBox	(	const std::string &	text,
		counted_ptr< PEBLObjectBase >	font,
		int	width,
		int	height
	)

Definition at line 27 of file validator/PlatformTextBox.cpp.

29 : PTextBox(text, width, height), mFontObject(font) {

30}

◆ PlatformTextBox() [4/4]

PlatformTextBox::PlatformTextBox ( PlatformTextBox & textbox )

Definition at line 32 of file validator/PlatformTextBox.cpp.

33 : PTextBox(textbox), mFontObject(textbox.mFontObject) {

34}

◆ ~PlatformTextBox() [2/2]

virtual PlatformTextBox::~PlatformTextBox ( )

virtual

Member Function Documentation

◆ Draw() [1/2]

bool PlatformTextBox::Draw ( )

virtual

This method initiates everything needed to display the main window

Reimplemented from PlatformWidget.

Definition at line 1651 of file sdl/PlatformTextBox.cpp.

{
    // Check if font properties changed and update widget bgcolor if needed
    if(GetPlatformFont()->HasChanged())
    {
        PWidget::SetBackgroundColor(GetPlatformFont()->GetBackgroundColor());
        mChanged = true;
        GetPlatformFont()->ClearChanged();
    }
 
    // CRITICAL: Always call FindBreaks() when text has changed
    // This was in the backup version and is needed for proper rendering
    if(mChanged)
    {
        FindBreaks();
    }
 
    if(mChanged)
    {
        // Check if adaptive mode is enabled
        Variant isAdaptiveVar = PEBLObjectBase::GetProperty("ISADAPTIVE");
        if (isAdaptiveVar.GetInteger()) {
            // Track whether this is the first time we're creating an adaptive font
            bool hadAdaptiveFont = (mAdaptiveFontObject.get() != NULL);
 
            // Get the requested font size (original size before adaptation)
            Variant requestedSizeVar = PEBLObjectBase::GetProperty("REQUESTEDFONTSIZE");
            int requestedSize = requestedSizeVar.GetInteger();
 
            // If requestedFontSize is 0, it hasn't been set yet - use current font size
            if (requestedSize == 0) {
                requestedSize = GetPlatformFont()->GetFontSize();
                PEBLObjectBase::SetProperty("REQUESTEDFONTSIZE", Variant(requestedSize));
            }
 
            // Iterate to find the right font size
            // Keep previous adaptive font in mIntermediateFonts during iteration
            int maxIterations = 20;
            int iteration = 0;
            bool needsAdaptation = true;
 
            while (iteration < maxIterations && needsAdaptation) {
                // Calculate line breaks with current font
                FindBreaks();
 
                // Check if text currently fits
                Variant textCompleteVar = PEBLObjectBase::GetProperty("TEXTCOMPLETE");
                bool textComplete = textCompleteVar.GetInteger() != 0;
 
                if (textComplete) {
                    // Text fits - stop iteration
                    needsAdaptation = false;
                    break;
                }
 
                // Text doesn't fit - calculate target font size
                int minFontSize = 8;
                int currentFontSize = GetPlatformFont()->GetFontSize();
                int targetSize = currentFontSize;
 
                // Text doesn't fit (TEXTCOMPLETE=0), so we need to shrink the font
                // Reduce by 10% (minimum 1 point) each iteration
                {
                    int reduction = std::max(currentFontSize / 10, 1);
                    targetSize = std::max(currentFontSize - reduction, minFontSize);
                }
 
                // Safety: ensure we're actually shrinking, never growing
                if (targetSize >= currentFontSize) {
                    targetSize = std::max(currentFontSize - 1, minFontSize);
                }
 
                // Create new font if we calculated a different size
                if (targetSize != currentFontSize && targetSize >= minFontSize) {
                    std::string fontFileName = GetPlatformFont()->GetFontFileName();
                    int fontStyle = GetPlatformFont()->GetFontStyle();
                    PColor fontColor = GetPlatformFont()->GetFontColor();
                    PColor bgColor = GetPlatformFont()->GetBackgroundColor();
                    bool antiAliased = GetPlatformFont()->GetAntiAliased();
 
                    // Keep previous adaptive font alive during iteration
                    if (mAdaptiveFontObject.get()) {
                        mIntermediateFonts.push_back(mAdaptiveFontObject);
                    }
 
                    // Create new font and immediately wrap in counted_ptr
                    PlatformFont* newFont = new PlatformFont(fontFileName, fontStyle, targetSize,
                                                             fontColor, bgColor, antiAliased);
                    counted_ptr<PEBLObjectBase> newFontPtr(newFont);
 
                    // Set as new adaptive font
                    mAdaptiveFontObject = newFontPtr;
 
                    // Update widget background color
                    PWidget::SetBackgroundColor(GetPlatformFont()->GetBackgroundColor());
                } else {
                    needsAdaptation = false;
                }
 
                iteration++;
            }
 
            // If we created an adaptive font, make sure it's set
            if (mAdaptiveFontObject.get()) {
                mChanged = true;
            }
 
            // Clear intermediate fonts AFTER rendering is complete
            // This happens later in the function after RenderText() is called
        }
 
        mChanged = true;
    }
 
    if(mChanged || mCursorChanged)
    {
        RenderText();
    }
 
    // Don't clear intermediate fonts - let them persist for the textbox's lifetime
    // They will be cleaned up automatically when the textbox destructor runs
    // This avoids triggering destructor cascades during drawing
 
    mCursorChanged = false;
 
 
   bool ret =  PlatformWidget::Draw();
 
    if(mEditable&false)
       {
            DrawCursor();
       }
 
 
   return ret;
}

References PlatformFont::ClearChanged(), PlatformWidget::Draw(), counted_ptr< X >::get(), PFont::GetAntiAliased(), PWidget::GetBackgroundColor(), PFont::GetBackgroundColor(), PFont::GetFontColor(), PFont::GetFontFileName(), PFont::GetFontSize(), PFont::GetFontStyle(), Variant::GetInteger(), PEBLObjectBase::GetProperty(), PTextObject::mChanged, PTextBox::mCursorChanged, PTextBox::mEditable, NULL, RenderText(), PWidget::SetBackgroundColor(), and PEBLObjectBase::SetProperty().

◆ Draw() [2/2]

virtual bool PlatformTextBox::Draw ( )

virtual

This method initiates everything needed to display the main window

Reimplemented from PlatformWidget.

◆ FindCursorPosition() [1/2]

int PlatformTextBox::FindCursorPosition	(	long int	x,
		long int	y
	)

virtual

Given an x,y position, this will return an integer specifying the character in mText before which the cursor should be n. But, the text may be UTF-8, so an particular character may be several bytes wide so we need to take care to compute cursor position correctly. Cursor position should be related to the byte is the string, but it should not allow half-byte character positions.

Definition at line 1454 of file sdl/PlatformTextBox.cpp.

{
 
 
    if(mText.length()==0)
        {
            return 0;
        }
 
    //Find the height of a line.
    int height = GetPlatformFont()->GetTextHeight(mText);
 
    if(y > mHeight) y = mHeight;
    if(y < 0) y = 0;
 
    //The line will just be y / height, rounded down
    unsigned long int linenum = y / height;  //this is 0-based.
 
 
    //Change the line number to the last one if it is too large.
    //The last element of mBreaks is the 'end' of the text; not really a break for
    //our purposes.
 
    if(linenum > mBreaks.size())
        linenum = mBreaks.size();
 
 
    //find the starting character on the line we care about.
    int startchar;
    if(linenum==0)
        startchar = 0;
    else
        startchar = mBreaks[linenum-1];
 
 
 
    if(startchar >= mBreaks[mBreaks.size()-1])
        {
            return startchar;
        }
 
    //find the length in bytes of the current line:
    int length = mBreaks[linenum] - startchar;
 
    // Get the line text to check for RTL
    std::string line_text = mText.substr(startchar, length);
 
    // For right-justified text, x is the visual position from left edge of textbox
    // We need to convert it to what GetPosition() expects
    unsigned int x_adjusted = x;
    if (is_line_right_justified(line_text, mJustify)) {
        // Get line width to calculate where text starts
        int line_width = GetPlatformFont()->GetTextWidth(line_text);
        int text_start_x = mWidth - line_width;  // Right justification offset
 
        if ((int)x >= text_start_x) {
            // Click is within the text area
            // For RTL text, GetPosition() expects x from LEFT edge of text,
            // but RTL text renders right-to-left, so we need to flip:
            // Visual position from left of text = (x - text_start_x)
            // For RTL, we need position from RIGHT = line_width - (x - text_start_x)
            if (has_rtl_text(line_text)) {
                x_adjusted = line_width - ((int)x - text_start_x);
            } else {
                // Explicit RIGHT justification with LTR text
                x_adjusted = (int)x - text_start_x;
            }
        } else {
            // Click is to the left of the text (in the padding area)
            // For RTL, this means beginning of text (which is visually on right)
            // For LTR right-justified, this means before text starts
            x_adjusted = has_rtl_text(line_text) ? line_width : 0;
        }
    }
 
    int charnum = GetPlatformFont()->GetPosition(line_text, x_adjusted);
 
    //finally, if the current cursor position is a non-printing character (i.e. a carriage return)
    //back up one
 
    if(!AtPrintableCharacter(charnum + startchar -1))
    {
 
        if(charnum + startchar > 0)
            charnum--;
    }
 
 
    return charnum + startchar;
}

References PTextBox::AtPrintableCharacter(), PlatformFont::GetPosition(), PlatformFont::GetTextHeight(), PlatformFont::GetTextWidth(), mBreaks, PWidget::mHeight, PTextBox::mJustify, PTextObject::mText, and PWidget::mWidth.

Referenced by PEBLEnvironment::GetTextBoxCursorFromClick(), and HandleKeyPress().

◆ FindCursorPosition() [2/2]

virtual int PlatformTextBox::FindCursorPosition	(	long int	x,
		long int	y
	)

inlinevirtual

Definition at line 42 of file validator/PlatformTextBox.h.

42{ return 0; } // Stub for validator

◆ GetFont()

virtual counted_ptr< PEBLObjectBase > PlatformTextBox::GetFont ( ) const

inlinevirtual

Definition at line 78 of file sdl/PlatformTextBox.h.

                                                      {
        return mAdaptiveFontObject.get() ? mAdaptiveFontObject : mFontObject;
    }

References counted_ptr< X >::get().

Referenced by PlatformTextBox().

◆ GetLineBreaks() [1/2]

Variant PlatformTextBox::GetLineBreaks ( )

Definition at line 1952 of file sdl/PlatformTextBox.cpp.

{
    //Not sure about this, but let's not refind line breaks when this is called--just get
    //whatever has been calculated.
 
    std::vector<int>::iterator i = mBreaks.begin();
 
    PList * outlist = new PList();
    while(i != mBreaks.end())
        {
            outlist->PushBack(*i);
            i++;
        }
 
 
    counted_ptr<PEBLObjectBase> newList2 = counted_ptr<PEBLObjectBase>(outlist);
 
    PComplexData * PCD =(new PComplexData(newList2));
    Variant tmp = Variant(PCD);
    delete PCD;
    PCD=NULL;
    return tmp;
 
}

References mBreaks, NULL, and PList::PushBack().

Referenced by PEBLObjects::GetLineBreaks().

◆ GetLineBreaks() [2/2]

virtual Variant PlatformTextBox::GetLineBreaks ( )

inlinevirtual

Definition at line 43 of file validator/PlatformTextBox.h.

43{ return Variant(0); } // Stub for validator

◆ GetProperty()

Variant PlatformTextBox::GetProperty ( std::string name ) const

virtual

Reimplemented from PWidget.

Definition at line 655 of file sdl/PlatformTextBox.cpp.

{
    if(name == "NUMTEXTLINES")
    {
        return Variant((int)mBreaks.size());
    }
    else
    {
        return PTextBox::GetProperty(name);
    }
}

References PTextBox::GetProperty(), and mBreaks.

◆ HandleKeyPress()

void PlatformTextBox::HandleKeyPress	(	int	keycode,
		int	modkeys,
		Uint16	unicode
	)

virtual

Reimplemented from PTextBox.

Definition at line 1791 of file sdl/PlatformTextBox.cpp.

{
#if 0
    cerr << "handling keypress in PlatformTextBox: " << keycode << endl;
    cerr << "(" <<  PEBL_KEYCODE_RETURN << "|" << PEBL_KEYCODE_RETURN2 << "|" <<          PEBL_KEYCODE_KP_ENTER << ")"<< std::endl;
    cerr << "PEBL_KEYCODE_RIGHT:" << PEBL_KEYCODE_RIGHT << std::endl;
    cerr << "PEBL_KEYCODE_LEFT:" << PEBL_KEYCODE_LEFT << std::endl;
#endif
    
    switch(keycode)
        {
        case PEBL_KEYCODE_UP:
        case PEBL_KEYCODE_DOWN:
            {
                int change;
                if(keycode == PEBL_KEYCODE_UP) change = -1;
                else change = 1;
 
                //Find x and y of position.
                int x = 0;
                int y = 0;
 
                int height=GetPlatformFont()->GetTextHeight(mText);
                unsigned int i = 0;
                int linestart = 0;
 
 
                while(i < mBreaks.size())
                    {
                        if(mBreaks[i] > mCursorPos)
                            {
                                y = i * height;
 
                                // Calculate x position (visual position from left edge of textbox)
                                std::string text_before_cursor = mText.substr(linestart, mCursorPos - linestart);
 
                                // Get the full line to check justification
                                int line_end = mBreaks[i];
                                std::string full_line = mText.substr(linestart, line_end - linestart);
 
                                if (is_line_right_justified(full_line, mJustify)) {
                                    // Right-justified: text starts at (width - line_width)
                                    // Cursor is at distance (line_width - text_before_cursor_width) from right edge of text
                                    // Visual x = text_start + (line_width - text_before_cursor_width)
                                    //          = (width - line_width) + (line_width - text_before_cursor_width)
                                    //          = width - text_before_cursor_width
                                    int text_before_cursor_width = GetPlatformFont()->GetTextWidth(text_before_cursor);
                                    x = mWidth - text_before_cursor_width;
                                } else {
                                    // Left-justified: x is simply width of text before cursor
                                    x = GetPlatformFont()->GetTextWidth(text_before_cursor);
                                }
                                break;
                            }
                        linestart = mBreaks[i];
                        i++;
                    }
 
 
                mCursorPos = FindCursorPosition(x, y + change * height);
                mCursorChanged = true;
                break;
            }
        case PEBL_KEYCODE_RETURN:
        case PEBL_KEYCODE_RETURN2:
        case PEBL_KEYCODE_KP_ENTER:
            {
 
                std::string lb =  std::string()  + (char(10));
 
                InsertText(lb);
                //mCursorPos++;
                if(mCursorPos > (int) (mText.length()))
                    mCursorPos = mText.length();
 
            }
            break;
        case PEBL_KEYCODE_DELETE:
 
            DeleteText(1);
            break;
        case PEBL_KEYCODE_BACKSPACE:
 
            DeleteText(-1);
            break;
 
        case PEBL_KEYCODE_LEFT:
        case PEBL_KEYCODE_RIGHT:
            {
                // For RTL text, LEFT/RIGHT arrows should move in visual direction, not logical
                // Find which line the cursor is on to check if it's RTL
                bool isRTLLine = false;
 
                if (mBreaks.size() > 0 && mText.length() > 0) {
                    unsigned int i = 0;
                    int linestart = 0;
 
                    while(i < mBreaks.size()) {
                        if(mBreaks[i] >= mCursorPos) {
                            // Found the current line
                            int line_end = mBreaks[i];
                            std::string current_line = mText.substr(linestart, line_end - linestart);
                            isRTLLine = has_rtl_text(current_line);
                            break;
                        }
                        linestart = mBreaks[i];
                        i++;
                    }
                }
 
                // In RTL text, swap the behavior:
                // - LEFT arrow moves visually left (logically forward) = IncrementCursor
                // - RIGHT arrow moves visually right (logically backward) = DecrementCursor
                if (isRTLLine) {
                    if (keycode == PEBL_KEYCODE_LEFT) {
                        IncrementCursor();
                    } else {
                        DecrementCursor();
                    }
                } else {
                    // LTR text: normal behavior
                    if (keycode == PEBL_KEYCODE_LEFT) {
                        DecrementCursor();
                    } else {
                        IncrementCursor();
                    }
                }
            }
            break;
 
 
            //case PEBL_KEYCODE_BACKSLASH:
            //InsertText("\\");
            //cerr << "backslash\n";
            // InsertText(PEBLUtility::TranslateKeycode((PEBL_Keycode)keycode, modkeys));
            //break;
 
        default:
            //cerr << "----------------------\n" << keycode << endl;
            //cerr << "["<< (PEBLUtility::TranslateKeyCode(PEBLKey(keycode), modkeys))<<"]"<<endl;
            //cerr << "----------------------\n";
 
 
            //    InsertText(SDL_GetKeyName(keycode));
            ;
        }
    mCursorChanged=true;
    //PTextBox::HandleKeyPress(keycode, modkeys, unicode);
}

References PTextBox::DecrementCursor(), PTextBox::DeleteText(), FindCursorPosition(), PlatformFont::GetTextHeight(), PlatformFont::GetTextWidth(), PTextBox::IncrementCursor(), PTextBox::InsertText(), mBreaks, PTextBox::mCursorChanged, PTextBox::mCursorPos, PTextBox::mJustify, PTextObject::mText, PWidget::mWidth, PEBL_KEYCODE_BACKSPACE, PEBL_KEYCODE_DELETE, PEBL_KEYCODE_DOWN, PEBL_KEYCODE_KP_ENTER, PEBL_KEYCODE_LEFT, PEBL_KEYCODE_RETURN, PEBL_KEYCODE_RETURN2, PEBL_KEYCODE_RIGHT, and PEBL_KEYCODE_UP.

Referenced by PEBLEnvironment::GetInput0().

◆ HandleTextInput()

void PlatformTextBox::HandleTextInput ( std::string input )

virtual

Reimplemented from PTextBox.

Definition at line 1945 of file sdl/PlatformTextBox.cpp.

{
 
    PTextBox::HandleTextInput(input);
}

References PTextBox::HandleTextInput().

Referenced by PEBLEnvironment::GetInput0().

◆ ObjectName() [1/2]

virtual std::string PlatformTextBox::ObjectName ( ) const

inlinevirtual

Reimplemented from PWidget.

Definition at line 86 of file sdl/PlatformTextBox.h.

86{return "PlatformTextBox";} ;

◆ ObjectName() [2/2]

virtual std::string PlatformTextBox::ObjectName ( ) const

inlinevirtual

Reimplemented from PWidget.

Definition at line 41 of file validator/PlatformTextBox.h.

41{ return "PlatformTextBox (validator)"; }

◆ RenderText()

bool PlatformTextBox::RenderText ( )

virtual

This method should be called when the font is initialized or the text is changed. It will make the mSurface pointer hold the appropriate image.

Definition at line 190 of file sdl/PlatformTextBox.cpp.

{
 
    //free the memory if it is currently pointing at something.
    //#ifdef SDL2_DELETE
    if(mSurface)  SDL_FreeSurface(mSurface);
    //#endif
 
    //create a new surface on which to render the text.
 
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
 
    Uint32 rmask = 0xff000000;
    Uint32 gmask = 0x00ff0000;
    Uint32 bmask = 0x0000ff00;
    Uint32 amask = 0x00000000;
 
#else
 
    Uint32 rmask = 0x000000ff;
    Uint32 gmask = 0x0000ff00;
    Uint32 bmask = 0x00ff0000;
    Uint32 amask = 0x00000000;
 
#endif
 
    //we might get a Draw() command before the renderer is set,
    //such as if the text is set before the object is added to a
    //parent that has a renderer.
 
 
    if(!mRenderer)
        {
            //cerr << "No renderer " << SDL_GetTicks() << endl;
           
            return  false;
        }
 
    //cerr << "creating new surface in platformtextbox::rendertext\n";
 
    //Make a surface of the prescribed size.
    mSurface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                    (int)mTextureWidth,
                                    (int)mTextureHeight, 32,
                                    rmask, gmask, bmask, amask);
    if(!mSurface)  PError::SignalFatalError("Surface not created in TextBox::RenderText.");
 
    //cerr << "fillingbackground rec platformtextbox::rendertext\n";
    //Fill the box with the background color of the font (from property system in case it was modified)
    PColor bgcolor = GetPlatformFont()->GetBackgroundColor();  // Gets current color from font property system
    SDL_FillRect(mSurface, NULL, SDL_MapRGBA(mSurface->format,
                                             bgcolor.GetRed(),
                                             bgcolor.GetGreen(),
                                             bgcolor.GetBlue(),
                                             bgcolor.GetAlpha()));
 
 
    //First, find the height of the text when rendered with the font.
    int height = GetPlatformFont()->GetTextHeight(mText);
 
    //Now, go through the text letter by letter and word by word until it won't fit on a line any longer.
    unsigned int linestart = 0;
    unsigned int linelength = 0;
    unsigned int totalheight = 0;
 
    SDL_Surface * tmpSurface=NULL;
    std::vector<int>::iterator i = mBreaks.begin();
    linestart  = 0;
 
    //cerr << "Textbox: "<< mHeight << " " <<totalheight << endl;
 
    // Check if formatted text mode is enabled
    Variant formattedVar = PEBLObjectBase::GetProperty("FORMATTED");
    bool isFormatted = (formattedVar.GetInteger() != 0);
 
    // Parse formatted text once if needed
    std::vector<FormatParser::FormatSegment> segments;
    if (isFormatted) {
        // Calculate character width for indent calculations
        int charWidth = GetPlatformFont()->GetTextWidth("M");  // Use 'M' as average char width
        segments = FormatParser::ParseFormattedText(mText, charWidth);
    }
 
    while(i != mBreaks.end() && totalheight < (unsigned int) mHeight)
        {
 
 
            //mBreaks holds the 'starting' positions of each line.
            linelength = *i - linestart;
            if(linelength>0)
                {
 
                     SDL_Rect to;
 
                    // Auto-detect RTL for THIS LINE and adjust justification
                    // For formatted text, use stripped text for line extraction
                    std::string line_text;
                    if (isFormatted) {
                        line_text = mStrippedText.substr(linestart, linelength);
                    } else {
                        line_text = mText.substr(linestart, linelength);
                    }
                    bool isLineRTL = has_rtl_text(line_text);
 
                    // Determine effective justification: RTL overrides mJustify
                    Variant effectiveJustify;
                    if (isLineRTL) {
                        effectiveJustify = "RIGHT";
                    } else {
                        effectiveJustify = mJustify;
                    }
 
                    if (isFormatted) {
                        // Cache fonts for this line to avoid repeated creation/deletion
                        // Key: (style, size, color_as_int) -> Value: PlatformFont*
                        std::map<std::tuple<int, int, unsigned int>, PlatformFont*> fontCache;
 
                        // FIRST PASS: Find maximum ascent, total width, justification for baseline alignment
                        int maxAscent = 0;
                        int maxLineHeight = 0;  // Track maximum font height on this line
                        unsigned int segmentTextPos = 0;
                        bool hasHorizontalRule = false;
                        int lineIndent = 0;  // Track indent for this line
                        int totalLineWidth = 0;  // Total width of all segments on this line
                        FormatParser::Justification lineJustification = FormatParser::JUSTIFY_NONE;  // Line justification
 
                        // Get base font properties once
                        PlatformFont* baseFont = GetPlatformFont();
                        std::string fontFileName = baseFont->GetFontFileName();
                        int baseFontSize = baseFont->GetFontSize();
                        PColor baseFgColor = baseFont->GetFontColor();
                        PColor baseBgColor = baseFont->GetBackgroundColor();
                        bool antiAliased = baseFont->GetAntiAliased();
 
                        for (const FormatParser::FormatSegment& seg : segments) {
                            unsigned int segStart = segmentTextPos;
                            unsigned int segEnd = segmentTextPos + seg.text.length();
 
                            if (segEnd > linestart && segStart < linestart + linelength) {
                                // Check for horizontal rule
                                if (seg.isHorizontalRule) {
                                    hasHorizontalRule = true;
                                }
 
                                // Track indent (accumulates across segments on same line)
                                if (seg.indentPixels > 0) {
                                    lineIndent = seg.indentPixels;
                                }
 
                                // Track justification (use first non-NONE justification found on line)
                                if (lineJustification == FormatParser::JUSTIFY_NONE && seg.justification != FormatParser::JUSTIFY_NONE) {
                                    lineJustification = seg.justification;
                                }
 
                                unsigned int overlapStart = std::max(segStart, (unsigned int)linestart);
                                unsigned int overlapEnd = std::min(segEnd, (unsigned int)(linestart + linelength));
                                std::string segmentText = seg.text.substr(overlapStart - segStart, overlapEnd - overlapStart);
 
                                if (!segmentText.empty()) {
                                    int segStyle = seg.style;
                                    // Calculate proportional size: sizeOverride is now a percentage (100 = base font)
                                    int segSize = baseFontSize;
                                    if (seg.hasSizeOverride) {
                                        segSize = (baseFontSize * seg.sizeOverride) / 100;
                                        // Sanity check: ensure size is reasonable
                                        if (segSize < 1) segSize = 1;
                                        if (segSize > 200) segSize = 200;
                                    }
                                    PColor segFgColor = seg.hasColorOverride ? seg.colorOverride : baseFgColor;
 
                                    // Create cache key (color encoded as R*256*256 + G*256 + B)
                                    unsigned int colorKey = segFgColor.GetRed() * 65536 +
                                                           segFgColor.GetGreen() * 256 +
                                                           segFgColor.GetBlue();
                                    auto cacheKey = std::make_tuple(segStyle, segSize, colorKey);
 
                                    // Get or create font
                                    PlatformFont* renderFont;
                                    auto it = fontCache.find(cacheKey);
                                    if (it != fontCache.end()) {
                                        renderFont = it->second;
                                    } else {
                                        renderFont = new PlatformFont(
                                            fontFileName, segStyle, segSize,
                                            segFgColor, baseBgColor, antiAliased);
                                        fontCache[cacheKey] = renderFont;
                                    }
 
                                    // Get the ascent (height above baseline) for this font
                                    int ascent = TTF_FontAscent(renderFont->GetTTFFont());
                                    if (ascent > maxAscent) maxAscent = ascent;
 
                                    // Get the full line height (ascent + descent) for this font
                                    int lineHeight = TTF_FontHeight(renderFont->GetTTFFont());
                                    if (lineHeight > maxLineHeight) maxLineHeight = lineHeight;
 
                                    // Calculate width for this segment
                                    totalLineWidth += renderFont->GetTextWidth(segmentText);
                                }
                            }
                            segmentTextPos += seg.text.length();
                        }
 
                        // Calculate justification offset
                        // Use HTML alignment if specified, otherwise fall back to
                        // the textbox .justify property (mJustify)
                        int justifyOffset = 0;
                        if (lineJustification == FormatParser::JUSTIFY_CENTER) {
                            justifyOffset = (mWidth - totalLineWidth) / 2;
                        } else if (lineJustification == FormatParser::JUSTIFY_RIGHT) {
                            justifyOffset = mWidth - totalLineWidth;
                        } else if (lineJustification == FormatParser::JUSTIFY_NONE) {
                            // No HTML alignment — fall back to .justify property
                            if (effectiveJustify == "CENTER") {
                                justifyOffset = (mWidth - totalLineWidth) / 2;
                            } else if (is_line_right_justified(line_text, effectiveJustify)) {
                                justifyOffset = mWidth - totalLineWidth;
                            }
                        }
 
                        // SECOND PASS: Render segments with baseline alignment and justification
                        int xOffset = justifyOffset;  // Start with justification offset
                        segmentTextPos = 0;
 
                        // Render horizontal rule if present
                        if (hasHorizontalRule) {
                            // Draw a horizontal line across the textbox width
                            PColor lineColor = GetPlatformFont()->GetFontColor();
                            int lineY = static_cast<int>(totalheight) + maxAscent / 2;
                            int lineWidth = mWidth - (lineIndent * 2);  // Leave margins
 
                            // Draw horizontal line (simple rectangle)
                            SDL_Rect hrRect = {lineIndent, lineY, lineWidth, 2};
                            SDL_FillRect(mSurface, &hrRect,
                                        SDL_MapRGBA(mSurface->format,
                                                   lineColor.GetRed(),
                                                   lineColor.GetGreen(),
                                                   lineColor.GetBlue(),
                                                   255));
                        }
 
                        for (const FormatParser::FormatSegment& seg : segments) {
                            unsigned int segStart = segmentTextPos;
                            unsigned int segEnd = segmentTextPos + seg.text.length();
 
                            if (segEnd > linestart && segStart < linestart + linelength) {
                                unsigned int overlapStart = std::max(segStart, (unsigned int)linestart);
                                unsigned int overlapEnd = std::min(segEnd, (unsigned int)(linestart + linelength));
 
                                std::string segmentText = seg.text.substr(
                                    overlapStart - segStart,
                                    overlapEnd - overlapStart);
 
                                if (!segmentText.empty()) {
                                    // If this segment has an indent, use it as absolute x-position (but only if greater than current xOffset)
                                    if (seg.indentPixels > xOffset) {
                                        xOffset = seg.indentPixels;
                                    }
 
                                    int segStyle = seg.style;
                                    // Calculate proportional size: sizeOverride is now a percentage (100 = base font)
                                    int segSize = baseFontSize;
                                    if (seg.hasSizeOverride) {
                                        segSize = (baseFontSize * seg.sizeOverride) / 100;
                                        // Sanity check: ensure size is reasonable
                                        if (segSize < 1) segSize = 1;
                                        if (segSize > 200) segSize = 200;
                                    }
                                    PColor segFgColor = seg.hasColorOverride ? seg.colorOverride : baseFgColor;
 
                                    // Create cache key (same as first pass)
                                    unsigned int colorKey = segFgColor.GetRed() * 65536 +
                                                           segFgColor.GetGreen() * 256 +
                                                           segFgColor.GetBlue();
                                    auto cacheKey = std::make_tuple(segStyle, segSize, colorKey);
 
                                    // Get font from cache (should always exist since we created it in first pass)
                                    PlatformFont* renderFont = fontCache[cacheKey];
 
                                    tmpSurface = renderFont->RenderText(segmentText.c_str());
 
                                    // Get ascent for this specific font
                                    int thisAscent = TTF_FontAscent(renderFont->GetTTFFont());
 
                                    // Calculate y-offset to align baseline with max baseline
                                    int yOffset = maxAscent - thisAscent;
 
                                    // Position segment with baseline alignment
                                    SDL_Rect segRect = {xOffset, static_cast<int>(totalheight) + yOffset,
                                                       tmpSurface->w, tmpSurface->h};
 
                                    SDL_BlitSurface(tmpSurface, NULL, mSurface, &segRect);
                                    SDL_FreeSurface(tmpSurface);
 
                                    xOffset += segRect.w;
                                }
                            }
 
                            segmentTextPos += seg.text.length();
                        }
 
                        // Clean up cached fonts for this line
                        for (auto& pair : fontCache) {
                            delete pair.second;
                        }
 
                        // For formatted text, use the maximum line height found on this line
                        // instead of the base font height
                        totalheight += maxLineHeight;
                    } else {
                        // Normal (non-formatted) rendering
                        if(effectiveJustify == "RIGHT")
                            {
                                //right flush
                                tmpSurface = GetPlatformFont()->RenderText(line_text.c_str());
                                SDL_Rect tmprect = {mSurface->w - tmpSurface->w,
                                                    static_cast<int>(totalheight),
                                                    tmpSurface->w,tmpSurface->h};
                                to = tmprect;
                            }
                        else if (effectiveJustify == "CENTER"){
                            //centered
                                tmpSurface = GetPlatformFont()->RenderText(line_text.c_str());
                                int xval = (mSurface->w - tmpSurface->w)/2;
                                SDL_Rect tmprect = {xval,static_cast<int>(totalheight),
                                                    tmpSurface->w,tmpSurface->h};
                                to = tmprect;
                            }
                        else{
                            // LEFT justification (default)
                                tmpSurface = GetPlatformFont()->RenderText(line_text.c_str());
                                SDL_Rect tmprect = {0,static_cast<int>(totalheight),tmpSurface->w,tmpSurface->h};
                                to = tmprect;
                            }
 
 
                        if(0)
                            {
                            //This was originally used for international right-to-left font layout, but
                            //it never worked.
                                std::string tmptext = mText.substr(linestart,linelength);
 
                                //
                                std::string rtext = PEBLUtility::strrev_utf8(tmptext);
 
 
 
                                //Re-render the text using the associated font.
                                tmpSurface = GetPlatformFont()->RenderText(rtext.c_str());
 
 
                                SDL_Rect tmprect = {(mSurface->w - tmpSurface->w),static_cast<int>(totalheight),
                                                    tmpSurface->w, tmpSurface->h};
                                to = tmprect;
 
                            }
 
 
                        SDL_BlitSurface(tmpSurface, NULL, mSurface,&to);
                        SDL_FreeSurface(tmpSurface);
 
                        // For normal text, use the base font height
                        totalheight += height;
                    }
                }
            else
                {
                    // No line content, still need to increment height for empty lines
                    totalheight += height;
                }
 
            linestart = *i;
            i++;
 
        }
 
    if(mTexture)
        {
 
 
            SDL_DestroyTexture(mTexture);
            mTexture = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
                                         (int)mTextureWidth,
                                         (int)mTextureHeight);
            // Enable best quality filtering (anisotropic) for zoomed textures
            SDL_SetTextureScaleMode(mTexture, SDL_ScaleModeBest);
            SDL_SetTextureBlendMode(mTexture, SDL_BLENDMODE_BLEND);
        }
    else
        {
 
            mTexture = SDL_CreateTexture(mRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
                                         (int)mTextureWidth,(int)mTextureHeight);
            // Enable best quality filtering (anisotropic) for zoomed textures
            SDL_SetTextureScaleMode(mTexture, SDL_ScaleModeBest);
            SDL_SetTextureBlendMode(mTexture, SDL_BLENDMODE_BLEND);
 
        }
 
 
 
 
    //This will work except for drawing the cursor line on it. instead, create
    //a texture from the surface, then copy it to mtexture.
    //mTexture  = SDL_CreateTextureFromSurface(mRenderer, mSurface);
 
    SDL_Texture * tmp = SDL_CreateTextureFromSurface(mRenderer, mSurface);
    SDL_FreeSurface(mSurface);
    mSurface = NULL;
    SDL_SetRenderTarget(mRenderer, mTexture);
    SDL_RenderCopy(mRenderer, tmp, NULL, NULL);
    SDL_SetRenderTarget(mRenderer,NULL);
    SDL_DestroyTexture(tmp);
 
    if(mEditable)
        {
            DrawCursor();
        }
 
 
    //If mTexture is null, then rendering failed.
    if(mTexture)
        {
 
            mChanged = false;
            return true;
        }
    else
        {
 
            mChanged = true;
            return false;
        }
}

References PColor::GetAlpha(), PFont::GetAntiAliased(), PFont::GetBackgroundColor(), PColor::GetBlue(), PFont::GetFontColor(), PFont::GetFontFileName(), PFont::GetFontSize(), PColor::GetGreen(), Variant::GetInteger(), PEBLObjectBase::GetProperty(), PColor::GetRed(), PlatformFont::GetTextHeight(), PlatformFont::GetTextWidth(), PlatformFont::GetTTFFont(), FormatParser::JUSTIFY_CENTER, FormatParser::JUSTIFY_NONE, FormatParser::JUSTIFY_RIGHT, mBreaks, PTextObject::mChanged, PTextBox::mEditable, PWidget::mHeight, PTextBox::mJustify, PlatformWidget::mRenderer, PlatformWidget::mSurface, PTextObject::mText, PlatformWidget::mTexture, PlatformWidget::mTextureHeight, PlatformWidget::mTextureWidth, PWidget::mWidth, NULL, FormatParser::ParseFormattedText(), PlatformFont::RenderText(), PError::SignalFatalError(), and PEBLUtility::strrev_utf8().

Referenced by Draw().

◆ SendToStream() [1/2]

std::ostream & PlatformTextBox::SendToStream ( std::ostream & out ) const

protectedvirtual

An inheritable printing class used by PEBLObjectBase::operator<<.

Reimplemented from PlatformWidget.

Definition at line 44 of file validator/PlatformTextBox.cpp.

                                                               {
    out << "PlatformTextBox (validator)";
    return out;
}

◆ SendToStream() [2/2]

virtual std::ostream & PlatformTextBox::SendToStream ( std::ostream & out ) const

protectedvirtual

An inheritable printing class used by PEBLObjectBase::operator<<.

Reimplemented from PlatformWidget.

◆ SetEditable()

void PlatformTextBox::SetEditable ( bool val )

virtual

Reimplemented from PTextBox.

Definition at line 739 of file sdl/PlatformTextBox.cpp.

{
    // Check if this is a formatted textbox
    Variant formattedVar = PEBLObjectBase::GetProperty("FORMATTED");
    bool isFormatted = (formattedVar.GetInteger() != 0);
 
    if (val && isFormatted) {
        // Disable formatted mode to allow editing of raw markdown text
        // Tags will become visible as literal text for editing
        std::cerr << "INFO: Disabling formatted mode for editing." << std::endl;
        std::cerr << "  Formatting tags will be visible as text and can be edited directly." << std::endl;
 
        PEBLObjectBase::SetProperty("FORMATTED", Variant(0));
        mChanged = true;  // Force re-render to show raw tags
    }
 
    // Call parent implementation
    PTextBox::SetEditable(val);
 
    // When making a textbox editable, position cursor at end of text
    // This works for all justifications - the rendering code handles visual positioning
    if (val) {
        mCursorPos = mText.length();
        mCursorChanged = true;
    }
}

References Variant::GetInteger(), PEBLObjectBase::GetProperty(), PTextObject::mChanged, PTextBox::mCursorChanged, PTextBox::mCursorPos, PTextObject::mText, PTextBox::SetEditable(), and PEBLObjectBase::SetProperty().

Referenced by PEBLEnvironment::GetInput0(), and PEBLObjects::SetEditable().

◆ SetFont() [1/2]

void PlatformTextBox::SetFont ( counted_ptr< PEBLObjectBase > font )

virtual

Definition at line 691 of file sdl/PlatformTextBox.cpp.

{
 
    mFontObject = font;
 
    // Update the FONT property so nested access works correctly
    PComplexData * pcd = new PComplexData(mFontObject);
    PEBLObjectBase::SetProperty("FONT", Variant(pcd));
    delete pcd;
 
    // Set requestedFontSize when font is set (needed for adaptive textbox scaling)
    // Only set it if it hasn't been set before (is 0)
    Variant currentRequestedSize = PEBLObjectBase::GetProperty("REQUESTEDFONTSIZE");
    if (currentRequestedSize.GetInteger() == 0) {
        int fontSize = GetPlatformFont()->GetFontSize();
        PEBLObjectBase::SetProperty("REQUESTEDFONTSIZE", Variant(fontSize));
    }
 
    PWidget::SetBackgroundColor(GetPlatformFont()->GetBackgroundColor());
    mChanged = true;
    //Re-render the text onto mSurface
    //if(!RenderText()) cerr << "Unable to render text.\n";
 
}

References PWidget::GetBackgroundColor(), PFont::GetFontSize(), Variant::GetInteger(), PEBLObjectBase::GetProperty(), PTextObject::mChanged, PWidget::SetBackgroundColor(), and PEBLObjectBase::SetProperty().

Referenced by PlatformTextBox(), PEBLObjects::SetFont(), and SetProperty().

◆ SetFont() [2/2]

virtual void PlatformTextBox::SetFont ( counted_ptr< PEBLObjectBase > font )

inlinevirtual

Definition at line 44 of file validator/PlatformTextBox.h.

44{} // Stub for validator

◆ SetHeight()

void PlatformTextBox::SetHeight ( int h )

virtual

Reimplemented from PTextBox.

Definition at line 669 of file sdl/PlatformTextBox.cpp.

{
    mTextureHeight = h;
    PTextBox::SetHeight(h);
 
    // CRITICAL: Clear cached stripped text when height changes
    // This ensures FindBreaksFormatted() recalculates line breaks with new height
    mStrippedText.clear();
}

References PlatformWidget::mTextureHeight, and PTextBox::SetHeight().

Referenced by SetProperty().

◆ SetPosition()

virtual void PlatformTextBox::SetPosition	(	pInt	x,
		pInt	y
	)

inlinevirtual

This sets the widget's position on its parent widget.

Sets the location of the upper left-hand corner of the image on the parent widget; unless overridden

Reimplemented from PWidget.

Definition at line 58 of file validator/PlatformTextBox.h.

58{ PTextBox::SetPosition(x, y); }

PWidget::SetPosition

virtual void SetPosition(pInt x, pInt y)

This sets the widget's position on its parent widget.

Definition PWidget.cpp:220

References PWidget::SetPosition().

Referenced by PEBLObjects::MakeTextBox().

◆ SetProperty() [1/2]

virtual bool PlatformTextBox::SetProperty	(	std::string	name,
		Variant	v
	)

inlinevirtual

Reimplemented from PWidget.

Definition at line 47 of file validator/PlatformTextBox.h.

                                                        {
        return PTextBox::SetProperty(name, v);
    }

References PTextBox::SetProperty().

◆ SetProperty() [2/2]

bool PlatformTextBox::SetProperty	(	std::string	name,
		Variant	v
	)

virtual

Reimplemented from PWidget.

Definition at line 626 of file sdl/PlatformTextBox.cpp.

{
 
    if(name == "TEXT")
        {
            SetText(v);
        }
    else if(PTextBox::SetProperty(name,v))
    {
        // If we set it at higher level, don't worry.
        // This includes FORMATTED property which is handled in PTextBox
    }
    else if (name == "FONT")
        {
            SetFont(v.GetComplexData()->GetObject());
        }
    else if(name=="WIDTH")
        {
            SetWidth(v);
                }
    else if(name=="HEIGHT")
        {
            SetHeight(v);
        }
    else return false;
 
    return true;
}

References Variant::GetComplexData(), PComplexData::GetObject(), SetFont(), SetHeight(), PTextBox::SetProperty(), SetText(), and SetWidth().

Referenced by PEBLObjects::MakeTextBox().

◆ SetText()

void PlatformTextBox::SetText ( std::string text )

virtual

Definition at line 718 of file sdl/PlatformTextBox.cpp.

{
 
 
    //Chain up to parent method.
    PTextObject::SetText(text);
    mIsUTF8=  utf8::is_valid(text.begin(),text.end());
 
    //mCursorPos = 0;
    mCursorChanged = true;
    mChanged = true;
 
    // Don't call Draw() here - it will be called when the object is actually drawn
    // Calling Draw() during SetText() can cause crashes if the renderer isn't ready
    // or if this is called during object construction/destruction
 
    //Re-render the text onto mSurface
    //    if(!RenderText()) cerr << "Unable to render text.\n";
 
}

References PTextObject::mChanged, PTextBox::mCursorChanged, and PTextObject::SetText().

Referenced by SetProperty(), and PEBLObjects::SetText().

◆ SetWidth()

void PlatformTextBox::SetWidth ( int w )

virtual

Reimplemented from PTextBox.

Definition at line 679 of file sdl/PlatformTextBox.cpp.

{
    mTextureWidth = w;
    PTextBox::SetWidth(w);
 
    // CRITICAL: Clear cached stripped text when width changes
    // This forces FindBreaksFormatted() to recalculate line breaks with new width
    // Without this, changing width after textbox creation causes incorrect line wrapping
    mStrippedText.clear();
}

References PlatformWidget::mTextureWidth, and PTextBox::SetWidth().

Referenced by SetProperty().

◆ ValidateProperty() [1/2]

virtual ObjectValidationError PlatformTextBox::ValidateProperty ( std::string name ) const

inlinevirtual

Reimplemented from PWidget.

Definition at line 53 of file validator/PlatformTextBox.h.

                                                                         {
        return PTextBox::ValidateProperty(name);
    }

References PTextBox::ValidateProperty().

◆ ValidateProperty() [2/2]

virtual ObjectValidationError PlatformTextBox::ValidateProperty	(	std::string	name,
		Variant	v
	)		const

inlinevirtual

Reimplemented from PWidget.

Definition at line 50 of file validator/PlatformTextBox.h.

                                                                                    {
        return PTextBox::ValidateProperty(name, v);
    }

References PTextBox::ValidateProperty().

Member Data Documentation

◆ mBreaks

std::vector<int> PlatformTextBox::mBreaks

protected

Definition at line 94 of file sdl/PlatformTextBox.h.

Referenced by FindCursorPosition(), GetLineBreaks(), GetProperty(), HandleKeyPress(), and RenderText().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PlatformTextBox() [1/4]

◆ PlatformTextBox() [2/4]

◆ ~PlatformTextBox() [1/2]

◆ PlatformTextBox() [3/4]

◆ PlatformTextBox() [4/4]

◆ ~PlatformTextBox() [2/2]

Member Function Documentation

◆ Draw() [1/2]

◆ Draw() [2/2]

◆ FindCursorPosition() [1/2]

◆ FindCursorPosition() [2/2]

◆ GetFont()

◆ GetLineBreaks() [1/2]

◆ GetLineBreaks() [2/2]

◆ GetProperty()

◆ HandleKeyPress()

◆ HandleTextInput()

◆ ObjectName() [1/2]

◆ ObjectName() [2/2]

◆ RenderText()

◆ SendToStream() [1/2]

◆ SendToStream() [2/2]

◆ SetEditable()

◆ SetFont() [1/2]

◆ SetFont() [2/2]

◆ SetHeight()

◆ SetPosition()

◆ SetProperty() [1/2]

◆ SetProperty() [2/2]

◆ SetText()

◆ SetWidth()

◆ ValidateProperty() [1/2]

◆ ValidateProperty() [2/2]

Member Data Documentation

◆ mBreaks