KSG-Script/ksgScript/Editor/Editor.cpp

#include "Editor.h"

#include <Schrift.h>
#include "Parser\ColorParser.h"
#include <Bild.h>
#include <Scroll.h>
#include <Globals.h>
#include <Rahmen.h>
#include <ToolTip.h>

using namespace KSGScript;

// Inhalt der Editor Klasse
// Konstructor
Editor::Editor()
    : ZeichnungHintergrund(),
    begF( 0 ),
    cPos( 0 ),
    tickVal( 0 ),
    mausKlick( 0 )
{
    textRd = 0;
    script = 0;
    errorDetection = 1;
    warningDetection = 1;
    setTextColor( 0xFFFFFFFF, ColorType::NORMAL_TEXT );
    setTextColor( 0xFF4040FF, ColorType::KEYWORD );
    setTextColor( 0xFFA0A040, ColorType::PARAMETER_VARIABLE );
    setTextColor( 0xFFA0A0A0, ColorType::INSTANCE_VARIABLE );
    setTextColor( 0xFF40FF70, ColorType::TYPENAME );
    setTextColor( 0xFFFFA000, ColorType::STRING );
    setTextColor( 0xFF20FFFF, ColorType::KOMMENTAR );
    setTextColor( 0xFFFF4040, ColorType::ERROR_UNDERLINE );
    parser = 0;
    reloadCounter = 10;
}

// Destructor
Editor::~Editor()
{
    if( textRd )
        textRd->release();
    if( script )
        script->release();
    if( parser )
        parser->release();
}

// Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
//  me: Das Ereignis
void Editor::doMausEreignis( MausEreignis &me, bool userRet )
{
    if( hatStyleNicht( Style::Erlaubt ) || !userRet )
    {
        int rbr = 0;
        if( rahmen )
            rbr = rahmen->getRBreite();
        if( ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ||
              ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ) &&
            me.mx > rbr && me.mx < gr.x - rbr &&
            me.my > rbr && me.my < gr.y - rbr )
        {
            me.verarbeitet |= vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me );
            me.verarbeitet |= horizontalScrollBar->doMausMessage( rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? 15 : 0 ), 15, me );
        }
        mausKlick = 0;
        return;
    }
    if( !me.verarbeitet )
    {
        if( me.id == ME_Betritt )
            mausKlick = 0;
        int rbr = 0;
        if( rahmen )
            rbr = rahmen->getRBreite();
        if( vertikalScrollBar && hatStyle( Style::VScroll ) )
        {
            if( vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me ) )
            {
                me.verarbeitet = 1;
                return;
            }
        }
        if( horizontalScrollBar && hatStyle( Style::HScroll ) )
        {
            if( horizontalScrollBar->doMausMessage( rbr, gr.y - rbr - 15, gr.x - rbr * 2 - ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? 15 : 0 ), 15, me ) )
            {
                me.verarbeitet = 1;
                return;
            }
        }
        if( me.mx < gr.x - rbr - 15 )
        {
            if( textRd )
            {
                textRd->setSchriftSize( 12 );
                bool shift = getTastenStand( T_Shift );
                if( me.id == Framework::ME_PLinks )
                {
                    int tbr = textRd->getTextBreite( script->getText() );
                    int thi = textRd->getTextHeight( script->getText() );
                    int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
                    int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
                    int xxx = me.mx - rbr + scrollBr;
                    int yyy = me.my - rbr + scrollHi;
                    int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
                    int pos = textRd->textPos( script->getText(), xxx, yyy );
                    if( pos != -1 )
                    {
                        if( shift )
                            begF = pos;
                        else
                        {
                            cPos = pos;
                            begF = pos;
                        }
                        rend = 1;
                        if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                            updateVScroll( begF );
                        if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                            updateHScroll( begF );
                    }
                    mausKlick = 1;
                }
                if( me.id == ME_Bewegung && mausKlick )
                {
                    int tbr = textRd->getTextBreite( script->getText() );
                    int thi = textRd->getTextHeight( script->getText() );
                    int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
                    int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
                    int xxx = me.mx - rbr + scrollBr;
                    int yyy = me.my - rbr + scrollHi;
                    int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
                    int scrollHeight = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) * 15;
                    int pos = textRd->textPos( script->getText(), xxx, yyy );
                    if( pos != -1 )
                    {
                        if( begF != pos )
                            rend = 1;
                        begF = pos;
                        if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                            updateVScroll( begF );
                        if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                            updateHScroll( begF );
                    }
                }
                if( me.id == ME_RLinks )
                {
                    if( !shift )
                    {
                        int tbr = textRd->getTextBreite( script->getText() );
                        int thi = textRd->getTextHeight( script->getText() );
                        int scrollHi = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
                        int scrollBr = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
                        int xxx = me.mx - rbr + scrollBr;
                        int yyy = me.my - rbr + scrollHi;
                        int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
                        int scrollHeight = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) * 15;
                        int pos = textRd->textPos( script->getText(), xxx, yyy );
                        if( pos != -1 )
                        {
                            begF = pos;
                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                                updateVScroll( begF );
                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                                updateHScroll( begF );
                        }
                        rend = 1;
                    }
                    mausKlick = 0;
                }
            }
        }
    }
    me.verarbeitet = 1;
}

void Editor::updateHScroll( int pos )
{
    if( pos == -1 )
        pos = cPos;
    if( horizontalScrollBar && script && textRd )
    {
        textRd->setSchriftSize( 12 );
        int br = gr.x;
        if( hatStyle( Style::Rahmen ) && rahmen )
            br -= rahmen->getRBreite() * 2;
        if( hatStyle( Style::VScroll ) && vertikalScrollBar )
            br -= 15;
        int maxBr = textRd->getTextBreite( script->getText() ) + 12;
        horizontalScrollBar->update( maxBr, br );
        if( hatStyle( Style::Erlaubt ) && maxBr > br && pos > 0 && pos < script->getLength() )
        {
            int p1 = 0;
            char *tmp = script->getText();
            for( int i = 0; i < pos; i++, tmp++ )
            {
                if( *tmp == '\n' )
                    p1 = i + 1;
            }
            Text *t = script->getTeilText( p1, pos );
            int cbr = textRd->getTextBreite( t->getText() );
            t->release();
            if( cbr + 12 > horizontalScrollBar->getScroll() + horizontalScrollBar->getScrollData()->anzeige )
                horizontalScrollBar->scroll( cbr + 12 - br );
            if( cbr - 12 < horizontalScrollBar->getScroll() )
                horizontalScrollBar->scroll( cbr - 12 );
        }
    }
}

void Editor::updateVScroll( int pos )
{
    if( pos == -1 )
        pos = cPos;
    if( vertikalScrollBar )
    {
        int sPos = 0;
        int hi = 0;
        if( script && textRd )
        {
            textRd->setSchriftSize( 12 );
            hi = gr.y;
            if( hatStyle( Style::Rahmen ) && rahmen )
                hi -= rahmen->getRBreite() * 2;
            if( hatStyle( Style::HScroll ) && horizontalScrollBar )
                hi -= 15;
            vertikalScrollBar->update( textRd->getTextHeight( script->getText() ) + 12 + textRd->getTextHeight( "a" ), hi );
            Text t;
            int zh = textRd->getTextHeight( t ) + textRd->getZeilenabstand();
            int l = script->getLength();
            for( int i = 0; i < l && ( i < pos || hatStyleNicht( Style::Erlaubt ) ); ++i )
            {
                if( script->getText()[ i ] == '\n' )
                    sPos += zh;
            }
        }
        if( textRd )
        {
            if( sPos - textRd->getZeilenabstand() - textRd->getTextHeight( Text( "a" ) ) < vertikalScrollBar->getScroll() )
                vertikalScrollBar->scroll( sPos - textRd->getZeilenabstand() - textRd->getTextHeight( Text( "a" ) ) );
            if( sPos + textRd->getZeilenabstand() + textRd->getTextHeight( Text( "a" ) ) > vertikalScrollBar->getScroll() + vertikalScrollBar->getScrollData()->anzeige )
                vertikalScrollBar->scroll( sPos + ( textRd->getZeilenabstand() + textRd->getTextHeight( Text( "a" ) ) ) * 2 - hi );
        }
        rend = 1;
    }
}

// Setzt die zu verwendende Schrift
//  s: Die Schrift
void Editor::setSchriftZ( Schrift *s )
{
    if( !textRd )
        textRd = new TextRenderer( s );
    else
        textRd->setSchriftZ( s );
}

// Setzt den zu verwendenden Text Renderer
//  t: Der Text Renderer
void Editor::setTextRendererZ( TextRenderer *t )
{
    if( textRd )
        textRd->release();
    textRd = t;
}

// Setzt den Text (das Script was verändert werden soll)
//  txt: Der Text
void Editor::setText( Text *txt )
{
    lockZeichnung();
    if( script )
        script->release();
    if( parser )
        parser->release();
    script = new Text( txt->getText() );
    parser = new ColorParser( script );
    txt->release();
    updateHScroll( -1 );
    updateVScroll( -1 );
    unlockZeichnung();
}

// Gibt den aktuellen Text zurück
Text *Editor::zText() const
{
    return script;
}

// Schaltet die Fehlererkennung ein oder aus
//  on: 1, um die Fehlererkennung einzuschalten, 0 um sie auszuschalten
void Editor::setErrorDetection( bool on )
{
    errorDetection = on;
}

// Schaltet die Warnungserkennung ein oder aus
//  on: 1, um die Warnungserkennung einzuschalten, 0 um sie auszuschalten
void Editor::setWarningDetection( bool on )
{
    warningDetection = on;
}

// gibt 1 zurück, wenn die Fehlererkennung eingeschaltet ist
bool Editor::getErrorDetection() const
{
    return errorDetection;
}

// gibt 1 zurück, wenn die Warnungserkennung eingeschaltet ist
bool Editor::getWarningDetection() const
{
    return warningDetection;
}

// Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
//  te: Das Ereignis
void Editor::doTastaturEreignis( TastaturEreignis &te )
{
    bool ntakc = !te.verarbeitet;
    if( te.verarbeitet || hatStyleNicht( Style::Fokus ) )
        return;
    if( !tak )
        return;
    getThis();
    if( tak( takParam, this, te ) )
    {
        if( hatStyleNicht( Style::Erlaubt ) )
        {
            release();
            return;
        }
        if( te.id == TE_Press )
        {
            bool shift = getTastenStand( T_Shift );
            bool strg = getTastenStand( T_Strg );
            switch( te.taste )
            {
            case T_Entf:
                if( cPos != begF )
                    script->remove( cPos, begF );
                else
                    script->remove( cPos, cPos + 1 );
                begF = cPos;
                rend = 1;
                break;
            case T_BackSpace:
                if( cPos != begF )
                {
                    script->remove( cPos, begF );
                    if( cPos > begF )
                        cPos -= cPos - begF;
                }
                else
                {
                    script->remove( cPos - 1, cPos );
                    --cPos;
                }
                begF = cPos;
                rend = 1;
                break;
            case T_Enter:
                if( cPos != begF )
                {
                    script->remove( begF, cPos );
                    if( cPos > begF )
                        cPos -= cPos - begF;
                }
                script->insert( cPos, '\n' );
                ++cPos;
                begF = cPos;
                rend = 1;
                break;
            case T_Links:
                if( shift )
                {
                    if( strg )
                        begF = script->getLKick( begF );
                    else
                        --begF;
                }
                else
                {
                    if( strg )
                        cPos = script->getLKick( cPos );
                    else
                        --cPos;
                    begF = cPos;
                }
                rend = 1;
                break;
            case T_Oben:
                if( shift )
                {
                    begF = script->getOKick( begF );
                }
                else
                {
                    cPos = script->getOKick( cPos );
                    begF = cPos;
                }
                rend = 1;
                break;
            case T_Rechts:
                if( shift )
                {
                    if( strg )
                        begF = script->getRKick( begF );
                    else
                        ++begF;
                }
                else
                {
                    if( strg )
                        cPos = script->getRKick( cPos );
                    else
                        ++cPos;
                    begF = cPos;
                }
                rend = 1;
                break;
            case T_Unten:
                if( shift )
                {
                    begF = script->getUKick( begF );
                }
                else
                {
                    cPos = script->getUKick( cPos );
                    begF = cPos;
                }
                rend = 1;
                break;
            default:
                if( strg && te.id == TE_Press )
                {
                    if( te.taste == 'c' || te.taste == 'C' )
                    {
                        if( begF != cPos )
                        {
                            int len = begF - cPos;
                            if( len < 0 )
                                len = -len;
                            char *txt = new char[ len + 1 ];
                            txt[ len ] = 0;
                            int beg = begF < cPos ? begF : cPos;
                            for( int i = beg; i < beg + len; ++i )
                                txt[ i - beg ] = script->getText()[ i ];
                            TextKopieren( txt );
                            delete[] txt;
                        }
                        else
                            TextKopieren( script->getText() );
                    }
                    if( te.taste == 'v' || te.taste == 'V' )
                    {
                        if( begF != cPos )
                        {
                            script->remove( begF, cPos );
                            if( cPos > begF )
                                cPos = begF;
                        }
                        char *txt = TextInsert();
                        script->insert( cPos, txt );
                        cPos += textLength( txt );
                        begF = cPos;
                        rend = 1;
                    }
                    break;
                }
                if( istSchreibbar( te.taste ) )
                {
                    if( begF != cPos )
                    {
                        script->remove( begF, cPos );
                        if( cPos > begF )
                            cPos = begF;
                    }
                    script->insert( cPos, (char)te.taste );
                    ++cPos;
                    begF = cPos;
                    rend = 1;
                }
                break;
            }
        }
        if( cPos < 0 )
            cPos = 0;
        if( cPos > script->getLength() )
            cPos = script->getLength();
        if( begF < 0 )
            begF = 0;
        if( begF > script->getLength() )
            begF = script->getLength();
        if( hatStyle( Style::VScroll ) )
            updateVScroll( begF );
        if( hatStyle( Style::HScroll ) )
            updateHScroll( begF );
        te.verarbeitet = 1;
    }
    lockZeichnung();
    if( !--reloadCounter )
    {
        zm.messungStart();
        parser->reload();
        zm.messungEnde();
        reloadCounter = (int)( zm.getSekunden() * 100 );
    }
    unlockZeichnung();
    if( ntakc && te.verarbeitet && nTak )
        te.verarbeitet = nTak( ntakParam, this, te );
    release();
}

// Updated den Editor
//  tickVal: Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser Funktion verstrichen ist
//  return: 1, wenn das Bild neu gezeichnet werden muss. 0 sonnst
bool Editor::tick( double tickval )
{
    if( hatStyle( Style::Fokus ) )
    {
        if( tickVal < 0.5 && tickVal + tickval >= 0.5 )
            rend = 1;
        if( tickVal >= 0.5 && tickVal + tickval >= 1 )
            rend = 1;
        tickVal += tickval;
        if( tickVal >= 1 )
        {
            lockZeichnung();
            if( ( reloadCounter -= 2 ) <= 0 )
            {
                zm.messungStart();
                parser->reload();
                zm.messungEnde();
                reloadCounter = (int)( zm.getSekunden() * 100 );
            }
            unlockZeichnung();
            tickVal -= 1;
        }
    }
    return __super::tick( tickVal );
}

// Zeichnet den Editor nach rObj
void Editor::render( Bild &rObj )
{
    if( hatStyleNicht( Style::Sichtbar ) )
        return;
    __super::render( rObj );
    if( !script || !textRd )
        return;
    lockZeichnung();
    if( !rObj.setDrawOptions( innenPosition, innenSize ) )
    {
        unlockZeichnung();
        return;
    }
    textRd->setSchriftSize( 12 );
    int tbr = textRd->getTextBreite( script->getText() );
    int thi = textRd->getTextHeight( script->getText() );
    int xxx = 0;
    int yyy = 0;
    int breite = innenSize.x;
    int height = innenSize.y;
    bool hs = horizontalScrollBar && hatStyle( Style::HScroll );
    bool vs = vertikalScrollBar && hatStyle( Style::VScroll );
    if( vs )
        yyy -= vertikalScrollBar->getScroll();
    if( hs )
        xxx -= horizontalScrollBar->getScroll();
    parser->reset();
    auto colorF = [this, &rObj]( int x, int y, int pos ) -> int
    {
        if( !parser )
            return colors[ KSGScriptEditor::ColorType::NORMAL_TEXT ];
        int uC = -1;
        int tC = colors[ parser->getNextColor( pos, uC ) ];
        if( uC >= 0 )
            rObj.drawLinieH( x, y + 12, 12, colors[ uC ] );
        return tC;
    };
    if( hatStyle( Style::Fokus ) && hatStyle( Style::Erlaubt ) )
    {
        if( tickVal <= 0.5 )
            textRd->renderText( xxx, yyy, script->getText(), rObj, colorF, cPos, 0xFFFF5555, begF, 0xFF0000FF );
        else
            textRd->renderText( xxx, yyy, script->getText(), rObj, colorF, cPos, 0x00000000, begF, 0xFF0000FF );
    }
    else
    {
        textRd->renderText( xxx, yyy, script->getText(), rObj, colorF );
    }
    rObj.releaseDrawOptions();
    unlockZeichnung();
}

// Setzt die Farbe eines Bestimmten Codetyps
//  color: Die Farbe in 0xAARRGGBB Format
//  cType: Der Codetyp, der die Farbe bekommen soll

// Setzt die Farbe eines Bestimmten Codetyps
//  color: Die Farbe in 0xAARRGGBB Format
//  cType: Der Codetyp, der die Farbe bekommen soll
void Editor::setTextColor( int color, ColorType cType )
{
    if( cType >= 0 && cType < ColorType::COLOR_ANZAHL )
        colors[ cType ] = color;
}