xeditbox.cpp

Go to the documentation of this file.

#include "SdlArs.h"

namespace Ars
{
XEditBox::XEditBox( void )
: m_SelStart( 0 ) , m_SelLength( 0 ) , m_DragStart( 0 ) 
, m_ScrollOffset( 0 ) , m_bMouseDown( false ) , m_bLastMouseMoveInside( false  )
{
}

XEditBox::~XEditBox( void )
{
}

const bool XEditBox::SetupWindow( const Message &msg )
{
        XBox::SetupWindow( msg );

        SetReadOnly( (GetFlags() & F_EDITABLE) != F_EDITABLE );
        SetPassBox( (GetFlags() & F_PASSWORD) == F_PASSWORD );

        MessageServer::Instance().RegisterMessageClient(this, Message::KEYBOARD_KEYDOWN);
        MessageServer::Instance().RegisterMessageClient(this, Message::MOUSE_BUTTONDOWN);
        MessageServer::Instance().RegisterMessageClient(this, Message::MOUSE_BUTTONUP);
        MessageServer::Instance().RegisterMessageClient(this, Message::MOUSE_MOVE);
        MessageServer::Instance().RegisterMessageClient(this, Message::LOST_FOCUS);

        return true;
}

void XEditBox::SetReadOnly( const bool bReadOnly )
{
        if( bReadOnly )
                SetBgColor( GetBgColor().FadeColor( -32 ) );
        m_bReadOnly = bReadOnly;
        SetDirty();
}

void XEditBox::SetWndText( const std::string &sText )
{
        m_SelStart = 0;
        m_SelLength = 0;
        XBox::SetWndText( sText );
}

std::string XEditBox::GetSelText( void ) 
{
        if( !IsPassBox() )
                if( m_SelLength != 0 )
                {
                        unsigned int SelStartNorm = 0, SelLenNorm = 0;
                        if (m_SelLength < 0)
                        {
                                SelStartNorm = m_SelLength + m_SelStart;
                                SelLenNorm = abs(m_SelLength);
                        }
                        else
                        {
                                SelStartNorm = m_SelStart;
                                SelLenNorm = m_SelLength;
                        }
                        return  GetWindowText().substr( SelStartNorm, SelLenNorm );
                }

        return "";
}


void XEditBox::SelDelete( std::string *psString )
{
        //This means we've selected something, therefore, should replace it
        if (m_SelLength > 0)
        {
                unsigned int SelStartNorm=0, SelLenNorm=0;
                if (m_SelLength < 0)
                {
                        SelStartNorm = m_SelLength + m_SelStart;
                        SelLenNorm = abs(m_SelLength);
                }
                else
                {
                        SelStartNorm = m_SelStart;
                        SelLenNorm = m_SelLength;
                }
                psString->erase(SelStartNorm, SelLenNorm);
                m_SelLength = 0;
        }
}

void XEditBox::Draw( void )
{
        XBox::Draw();

        XRect SubRect( *this );
        XRect DrawRct( *this );
        DrawRct.Grow( -3 );
        SubRect.Grow( -3 );

        XPoint FontCenterPoint = Center();

        if( IsPassBox() )
                SetMaskChar( '*' );
        else
                SetMaskChar( ' ' );

        if( ArsApplication::GetInstance()->GetKeyFocus() == dynamic_cast<MessageClient *>( this ) && !m_bReadOnly )
        {

                XPoint Offset;
                std::vector<XRect> CharRects;
                GetMetrics( GetWindowText() , 0 , &Offset , &CharRects );
                int     l = CharRects.size();
                int SelStartNorm = 0;
                int SelLenNorm = abs(m_SelLength);
                if (m_SelLength < 0)
                        SelStartNorm  = m_SelStart + m_SelLength;
                else
                        SelStartNorm  = m_SelStart;
        
                SelStartNorm = SelStartNorm;
                // Handle scrolling
                // Patch        for "Scrolling while selecting to left in editbox" by Oldrich Dlouhy
                if( !m_bMouseDown )
                {
                        int RightBorder = CharRects[max( 0 , SelStartNorm + SelLenNorm - 1 )].Right() + Offset.x + SubRect.x + m_ScrollOffset;
                        int LeftBorder = CharRects[SelStartNorm].x + Offset.x + m_ScrollOffset;
                        if( GetWindowText().empty() )
                                RightBorder = LeftBorder;

                        if (m_SelLength < 0)
                        {
                                if (LeftBorder <= 0)
                                {
                                        m_ScrollOffset = -(CharRects[SelStartNorm].x + Offset.x);
                                }
                                else if (RightBorder > SubRect.Right())
                                {
                                        m_ScrollOffset = SubRect.Right() - (CharRects[max( 0 , SelStartNorm + SelLenNorm - 1 )].Right() + Offset.x + SubRect.x);
                                }
                        }
                        else
                        {
                                if (RightBorder >= SubRect.Right())
                                {
                                        m_ScrollOffset = SubRect.Right() - (CharRects[max( 0 , SelStartNorm + SelLenNorm - 1 )].Right() + Offset.x + SubRect.x);
                                }
                                else if (LeftBorder < 0)
                                {
                                        m_ScrollOffset = -(CharRects[SelStartNorm].x + Offset.x);
                                }
                        }

                        if (m_ScrollOffset != 0 && (CharRects[GetWindowText().length()].Right() + Offset.x + SubRect.x + m_ScrollOffset < SubRect.Right()))
                        {
                                m_ScrollOffset = SubRect.Right() - (CharRects[GetWindowText().length()].Right() + Offset.x + SubRect.x);
                                if (m_ScrollOffset > 0)
                                {
                                        m_ScrollOffset = 0;
                                }
                        }
                }

                // Selection
                if (m_SelLength != 0)
                {
                        XRect SelRect;
                        SelRect.y = SubRect.y;
                        SelRect.SetBottom( SubRect.Bottom() );
                        SelRect.x = CharRects[SelStartNorm].x + Offset.x + SubRect.x + m_ScrollOffset;
                        SelRect.SetRight(CharRects[max( 0 , SelStartNorm + SelLenNorm - 1)].Right() + Offset.x + SubRect.x + m_ScrollOffset);
                        SelRect.ClipTo( SubRect );
                        DrawRect( SelRect , true , GetBgColor() , GetBgColor().FadeColor( -32 ) );
                }
                else
                {
                        //RenderStringWithCursor
                        int CursorPos;
                        CursorPos = CharRects[m_SelStart].x + Offset.x + SubRect.x + m_ScrollOffset;
                        if (CursorPos >= SubRect.x && CursorPos <= SubRect.Right())
                                DrawVLine(SubRect.y, SubRect.Bottom(), CursorPos, GetBgColor().FadeColor( -64 ) );
                }
        }
        DrawRct.x += m_ScrollOffset;
        DrawRct.w -= m_ScrollOffset;
        int HeightDiff = GetFontSize()/4;
        DrawRct.y -= HeightDiff;
        DrawRct.SetBottom( DrawRct.Bottom() - HeightDiff );
        SubRect.x += m_ScrollOffset;
        SubRect.w -= m_ScrollOffset;
        TextOutStr( SubRect ,  GetWindowText() , GetFgColor() );
}

const bool XEditBox::evMouseButtonDown( const MouseMessage &msg )
{
        bool    ans = XBox::evMouseButtonDown( msg );

        if( msg.Button == MouseMessage::LEFT && FindWindow( &msg.Point ) == this && !IsReadOnly() )
        {
                XRect SubRect( *this );
                SubRect.Grow(-3);
                XRect ClientRect( GetClientRect() );

                XPoint Offset;
                std::vector<XRect> CharRects;
                GetMetrics( GetWindowText() , 0, &Offset, &CharRects);

                int xDelta = abs( msg.Point.x - (CharRects[0].x + Offset.x + SubRect.x));
                m_SelStart = 0;
                for (unsigned int i = 0; i < GetWindowText().length() ; ++i)
                {
                        if (abs( msg.Point.x - (CharRects[i].Right() + Offset.x + SubRect.x + m_ScrollOffset)) < xDelta)
                        {
                                xDelta = abs( msg.Point.x - (CharRects[i].Right() + Offset.x + SubRect.x + m_ScrollOffset));
                                m_SelStart = i + 1;
                        }
                }

                m_DragStart = m_SelStart;
                m_SelLength = 0;
                m_bMouseDown = true;
                SetDirty();
                ans = true;
        }
        return ans;
}

const bool XEditBox::evMouseButtonUp( const MouseMessage &msg )
{
        bool    ans = XBox::evMouseButtonDown( msg );
        m_bMouseDown = false;
        return ans;
}

const bool XEditBox::evMouseMove( const MouseMessage &msg )
{
        bool    ans = XBox::evMouseMove( msg );

        //If the cursor is within the control then check to see if we've already
        // set the cursor to the I Beam, if we have, don't do anything.  If we
        // havent, set it to the ibeam.
        //Else if it's outside the control and the I Beam cursor is set, set it
        // back to a normal cursor.
        if( FindWindow( &msg.Point ) == this && !m_bLastMouseMoveInside)
        {
                m_bLastMouseMoveInside = true;
                Graf::SetMouse( WGRES_IBEAM_CURSOR );
        }
        else if( HitTest( msg.Point ) != RELPOS_INSIDE && m_bLastMouseMoveInside )
        { 
                m_bLastMouseMoveInside= false;
                Graf::SetMouse( 0 );
        }

        if( !IsReadOnly() && m_bMouseDown )
        {
                XRect SubRect( *this );
                SubRect.Grow(-3);
                XRect ClientRect( GetClientRect() );

                XPoint Offset;
                std::vector<XRect> CharRects;
                GetMetrics(GetWindowText() , 0, &Offset, &CharRects);

                int xDelta = abs( msg.Point.x - (CharRects[0].x + Offset.x + SubRect.x + m_ScrollOffset));
                unsigned int CursorPos = 0;
                for (unsigned int i = 0; i < GetWindowText().length() ; ++i)
                {
                        if (abs(msg.Point.x - (CharRects[i].Right() + Offset.x + SubRect.x + m_ScrollOffset)) < xDelta)
                        {
                                xDelta = abs( msg.Point.x - (CharRects[i].x + Offset.x + SubRect.x + m_ScrollOffset));
                                CursorPos = i + 1;
                        }
                }

                if (CursorPos < m_DragStart)
                {
                        m_SelLength = m_DragStart - CursorPos;
                        m_SelStart = CursorPos;
                }
                else
                {
                        m_SelStart = m_DragStart;
                        m_SelLength = CursorPos - m_SelStart;
                }
                SetDirty();
        }
        if( FindWindow( &msg.Point ) == this && !IsReadOnly() )
                SetState( S_HIGHLIGHT );
        else
                ResetState( S_HIGHLIGHT );

        return ans;
}

const bool XEditBox::evKeyDown( const KeyboardMessage &msg )
{
        bool ans = XBox::evKeyDown( msg );
        if( msg.Destination() == this && !m_bReadOnly )
        {
                std::string sBuffer = GetWindowText();

                switch( msg.Key )
                {
                        case SDLK_BACKSPACE:
                                if( m_SelStart > 0 )
                                        if (m_SelLength > 0)
                                                SelDelete( &sBuffer );
                                        else
                                                sBuffer.erase( --m_SelStart, 1 );
                                break;

                        case SDLK_DELETE:
                                if( static_cast<unsigned int>(m_SelStart) < sBuffer.length() )
                                        if( m_SelLength > 0 )
                                                SelDelete( &sBuffer );
                                        else
                                                sBuffer.erase( m_SelStart , 1 );
                                break;

                        case SDLK_LEFT:
                                if ((msg.Modifiers & KMOD_LSHIFT) || (msg.Modifiers & KMOD_RSHIFT)) //Shift modifier
                                {
                                        if (m_SelStart > 0)
                                        {
                                                if (m_SelLength > 0)
                                                        m_SelLength--;
                                                else
                                                        if ((m_SelStart - abs(m_SelLength)) > 0) //Prevent us from selecting past the beginning of the text
                                                                m_SelLength--;
                                        }
                                }
                                else if (m_SelLength != 0)
                                {
                                        if (m_SelLength < 0)
                                                m_SelStart = m_SelStart + m_SelLength;
                                        m_SelLength = 0;

                                }
                                else if (m_SelStart > 0)
                                {
                                        --m_SelStart;
                                        m_SelLength = 0;
                                }
                                break;

                        case SDLK_RIGHT:
                                if (static_cast<unsigned int>(m_SelStart) <= sBuffer.length())
                                {
                                        if ((msg.Modifiers & KMOD_LSHIFT) || (msg.Modifiers & KMOD_RSHIFT))
                                        {
                                                if (m_SelStart + m_SelLength < sBuffer.length())
                                                        m_SelLength++; //We WANT to select something, so we'll just increase the selection length
                                        }
                                        else if(m_SelLength == 0 && static_cast<unsigned int>(m_SelStart) < sBuffer.length())
                                                ++m_SelStart; //We don't have anything selected, so we'll just incriment the start position
                                        else
                                        {
                                                if (m_SelLength > 0)
                                                        m_SelStart = m_SelStart + m_SelLength; //Reset cursor position to the end of the selection
                                                m_SelLength = 0; //Set selection length to zero
                                        }
                                }
                                break;
                        
                        case SDLK_END:
                                if ((msg.Modifiers & KMOD_LSHIFT) || (msg.Modifiers & KMOD_RSHIFT))
                                        m_SelLength = static_cast<unsigned int>(sBuffer.length()) - m_SelStart;
                                else
                                {
                                        m_SelLength = 0;
                                        m_SelStart = static_cast<unsigned int>(sBuffer.length());
                                }
                                break;

                        case SDLK_HOME:
                                if ((msg.Modifiers & KMOD_LSHIFT) || (msg.Modifiers & KMOD_RSHIFT))
                                {
                                        m_SelLength = m_SelStart;
                                        m_SelStart = 0;
                                }
                                else
                                {
                                        m_SelLength = 0;
                                        m_SelStart = 0;
                                }
                                break;
                        default:
                                if (msg.Unicode)
                                {
                                        if ((msg.Unicode & 0xFF80) == 0)
                                        {
                                                SelDelete(&sBuffer);
                                                sBuffer.insert(m_SelStart++, 1, static_cast<char>(msg.Unicode & 0x7F));
                                        }
                                        else
                                                tron << "CEditBox::HandleMessage : CEditBox can't handle Unicode characters yet.\n";
                                }
                                break;
                }

                if( GetWindowText() != sBuffer )
                {
                        ArsPostMessage( CtrlMessage( Message::CTRL_VALUECHANGE, GetParent(), this, 0 ) );
                        ArsPostMessage( CtrlMessage( Message::CTRL_VALUECHANGE, this , this, 0 ) );
                }
                XBox::SetWndText( sBuffer );
                GetTextSize( sBuffer );
                SetDirty();
                ans = true;
        }

        return ans;
}

}

---