KSG-Framework/TextFeld.cpp

#include "TextFeld.h"
#include "Schrift.h"
#include "Text.h"
#include "AlphaFeld.h"
#include "Rahmen.h"
#include "Bild.h"
#include "TastaturEreignis.h"
#include "MausEreignis.h"
#include "Fenster.h"
#include "Scroll.h"
#include <math.h>
#include "Globals.h"
#include "ToolTip.h"
#include "Scroll.h"

using namespace Framework;

template<typename T, typename... U>
size_t getAddress( std::function<T( U... )> f )
{
    typedef T( fnType )( U... );
    fnType ** fnPointer = f.template target<fnType*>();
    if( !fnPointer )
        return 0;
    return (size_t)*fnPointer;
}

bool TextFeld::TextStyle::operator==( const TextStyle& rhs )
{
    return fontSize == rhs.fontSize && fontColor == rhs.fontColor &&
        selectedColor == rhs.selectedColor && selectedBackcroundColor == rhs.selectedBackcroundColor &&
        underlined == rhs.underlined && selected == rhs.selected && getAddress( onClick ) == getAddress( rhs.onClick ) && rendererIndex == rhs.rendererIndex;
}


TextFeld::TextStyleManager::TextStyleManager()
    : renderer( new RCArray< TextRenderer >() ),
    index( 0 ),
    styleIndex( 0 ),
    text( 0 ),
    ref( 1 )
{
    current.beginIndex = 0;
    current.fontColor = 0xFFFFFFFF;
    current.fontSize = 12;
    current.selected = 0;
    current.selectedColor = 0xFFFFFFFF;
    current.selectedBackcroundColor = 0xFF0000FF;
    current.underlined = 0;
    current.onClick = 0;
    current.rendererIndex = 0;
    textStyle.add( current );
}

TextFeld::TextStyleManager::~TextStyleManager()
{
    if( renderer )
        renderer->release();
    if( text )
        text->release();
}

// Setzt den Style eines Textabschnittes
//  begin: die startposition des Abschnittes
//  end: die endposition des Abschnittes (nicht enthalten)
void TextFeld::TextStyleManager::setTextStyle( int begin, int end, TextFeld::TextStyle style )
{
    if( begin < 0 || begin > end || begin > text->getLength() )
        return;
    int sc = textStyle.getEintragAnzahl();
    int index = -1;
    TextStyle s = textStyle.get( 0 );
    // suche bis zur richtigen stelle im stylearray
    for( int i = 0; i < sc; i++ )
    {
        if( textStyle.get( i ).beginIndex >= begin )
        {
            index = i;
            if( textStyle.get( i ).beginIndex > begin )
                s = textStyle.get( i - 1 );
            else
            {
                s = textStyle.get( i );
                textStyle.remove( i );
                sc--;
            }
            break;
        }
    }
    style.beginIndex = begin;
    s.beginIndex = end;
    if( index < 0 )
    { // hinten an styles anfügen
        textStyle.add( style );
        textStyle.add( s );
    }
    else
    { // in die mitte des style arrays einfügen
        textStyle.add( style, index );
        for( int i = index + 1; i < sc + 1; i++ )
        { // styles entfernen die überschrieben wurden
            if( textStyle.get( i ).beginIndex <= end && textStyle.get( i ).beginIndex > begin )
            {
                s = textStyle.get( i );
                textStyle.remove( i );
                i--;
                sc--;
            }
        }
        s.beginIndex = end;
        textStyle.add( s, index + 1 );
    }
    cleanupStyles();
}

// Entfernt einen Textabschnitt
//  begin: der index des ersten betroffenen zeichens
//  end: der index des ersten zeichens nach dem abschnitt
void TextFeld::TextStyleManager::removeText( int begin, int end )
{
    int sc = textStyle.getEintragAnzahl();
    for( int i = 0; i < sc; i++ )
    {
        TextStyle s = textStyle.get( i );
        if( s.beginIndex >= begin && s.beginIndex < end )
        {
            textStyle.remove( i );
            i--;
            sc--;
        }
        if( s.beginIndex >= end )
        {
            s.beginIndex -= end - begin;
            textStyle.set( s, i );
        }
    }
    text->remove( begin, end );
    cleanupStyles();
}

// Fügt ein Text an einer bestimmten Position ein
//  pos: die position des neuen Textausschnitts
//  text: der neue Text
void TextFeld::TextStyleManager::insertText( int pos, const char *text )
{
    int len = textLength( text );
    this->text->insert( pos, text );
    int sc = textStyle.getEintragAnzahl();
    for( int i = 0; i < sc; i++ )
    {
        TextStyle s = textStyle.get( i );
        if( s.beginIndex > pos )
        {
            s.beginIndex += len;
            textStyle.set( s, i );
        }
    }
    cleanupStyles();
}

// Entfernt nicht benötiegte gleiche styles
void TextFeld::TextStyleManager::cleanupStyles()
{
    int sc = textStyle.getEintragAnzahl();
    TextStyle last = textStyle.get( 0 );
    for( int i = 1; i < sc; i++ )
    {
        if( textStyle.get( i ) == last || ( text && textStyle.get( i ).beginIndex > text->getLength() ) )
        {
            textStyle.remove( i );
            i--;
            sc--;
        }
        else
            last = textStyle.get( i );
    }
}

// gibt eine referenz auf das style objekt zurück
TextFeld::TextStyle &TextFeld::TextStyleManager::currentStyle()
{
    return current;
}

// gibt den aktuellen text renderer zurück
TextRenderer *TextFeld::TextStyleManager::zCurrentRenderer()
{
    TextRenderer *tr = renderer->z( current.rendererIndex );
    if( !tr )
        tr = renderer->z( 0 );
    if( tr )
        tr->setSchriftSize( current.fontSize );
    return tr;
}

// ändert den inhalt des style objektes auf den style des nächsten zeichens
bool TextFeld::TextStyleManager::nextStyle()
{
    index++;
    if( textStyle.getEintragAnzahl() > styleIndex + 1 && index >= textStyle.get( styleIndex + 1 ).beginIndex )
        current = textStyle.get( styleIndex++ + 1 );
    return text && index < text->getLength();
}

// ändert den inhalt des style objektes auf den style des ersten zeichens
void TextFeld::TextStyleManager::resetIteration()
{
    index = 0;
    styleIndex = 0;
    current = textStyle.get( 0 );
}

// Gibt den Style eines bestimmten zeichens zurück
//  index: Der index des Zeichensf
TextFeld::TextStyle TextFeld::TextStyleManager::getTextStyle( int index ) const
{
    TextStyle last = textStyle.get( 0 );
    int ind = 0;
    for( auto i = textStyle.getIterator(); i && ind <= index; ind++ )
    {
        if( i._.beginIndex <= ind )
        {
            last = i;
            i++;
        }
    }
    return last;
}

// Erhöht den Reference Counting Zähler.
//  return: this.
TextFeld::TextStyleManager *TextFeld::TextStyleManager::getThis()
{
    ref++;
    return this;
}

// Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
//  return: 0.
TextFeld::TextStyleManager *TextFeld::TextStyleManager::release()
{
    if( !--ref )
        delete this;
    return 0;
}


// Inhalt der TextFeld Klasse aus TextFeld.h 
// Konstruktor 
TextFeld::TextFeld()
    : ZeichnungHintergrund(),
    tm( new TextStyleManager() ),
    showChar( 0 ),
    cpos( 0 ),
    tickVal( 0 ),
    mausKlick( 0 )
{
    horizontalScrollBar = new HScrollBar();
    vertikalScrollBar = new VScrollBar();
    this->setMausEreignis( _ret1ME );
    this->setTastaturEreignis( _ret1TE );
}

// Destruktor 
TextFeld::~TextFeld()
{
    tm->release();
}

int TextFeld::getTextHeight() const
{
    tm->resetIteration();
    int th = 0;
    int len = tm->text->getLength();
    char *text = tm->text->getText();
    int max = 0;
    for( int i = 0; i < len; i++ )
    {
        if( text[ i ] == '\n' )
        {
            th += max;
            max = 0;
            tm->nextStyle();
            continue;
        }
        TextRenderer *r = tm->zCurrentRenderer();
        if( r )
        {
            int tmp = r->getZeilenabstand() + r->getZeilenHeight();
            max = max >= tmp ? max : tmp;
        }
        tm->nextStyle();
    }
    if( max > 0 )
        th += max;
    return th;
}

int TextFeld::getTextWidth() const
{
    int maxBr = 0;
    int len = tm->text->getLength();
    char *text = tm->text->getText();
    int lineBr = 0;
    char buff[] = { 0,0 };
    for( int i = 0; i < len; i++ )
    {
        buff[ 0 ] = text[ i ];
        if( text[ i ] == '\n' )
        {
            maxBr = maxBr >= lineBr ? maxBr : lineBr;
            lineBr = 0;
            tm->nextStyle();
            continue;
        }
        TextRenderer *r = tm->zCurrentRenderer();
        if( r )
            lineBr += r->getTextBreite( buff );
        tm->nextStyle();
    }
    if( lineBr > 0 )
        maxBr = maxBr >= lineBr ? maxBr : lineBr;
    return maxBr;
}

void TextFeld::setText( Text *txt ) // setzt den angezeigten Text
{
    lockZeichnung();
    if( !tm->text )
        tm->text = new Text();
    tm->text->setText( txt );
    if( hatStyle( Style::VScroll ) )
        updateVScroll();
    if( hatStyle( Style::HScroll ) )
        updateHScroll();
    unlockZeichnung();
    rend = 1;
}

void TextFeld::setTextZ( Text *txt ) // setzt einen Zeiger zum angezeigten Text
{
    lockZeichnung();
    if( tm->text )
        tm->text->release();
    tm->text = txt;
    if( hatStyle( Style::VScroll ) )
        updateVScroll();
    if( hatStyle( Style::HScroll ) )
        updateHScroll();
    rend = 1;
    unlockZeichnung();
}

void TextFeld::setText( const char *txt ) // setzt den angezeigten Text
{
    lockZeichnung();
    if( !tm->text )
        tm->text = new Text();
    tm->text->setText( txt );
    if( hatStyle( Style::VScroll ) )
        updateVScroll();
    if( hatStyle( Style::HScroll ) )
        updateHScroll();
    rend = 1;
    unlockZeichnung();
}

// Setzt den Style eines Textabschnittes
//  begin: die startposition des Abschnittes
//  end: die endposition des Abschnittes (nicht enthalten)
void TextFeld::setTextStyle( int begin, int end, TextStyle style )
{
    tm->setTextStyle( begin, end, style );
}

void TextFeld::addZeile( const char *zeile ) // fügt Zeile An
{
    if( tm->text )
    {
        Text *txt = new Text( zeile );
        txt->append( "\n" );
        TextRenderer *r = tm->renderer->z( 0 );
        if( tm->textStyle.get( tm->textStyle.getEintragAnzahl() - 1 ).rendererIndex < tm->renderer->getEintragAnzahl() )
            r = tm->renderer->z( tm->textStyle.get( tm->textStyle.getEintragAnzahl() - 1 ).rendererIndex );
        if( r )
        {
            bool vs = vertikalScrollBar && hatStyle( Style::VScroll );
            int rbr = ( rahmen && hatStyle( Style::Rahmen ) ) ? rahmen->getRBreite() : 0;
            r->setSchriftSize( tm->textStyle.get( tm->textStyle.getEintragAnzahl() - 1 ).fontSize );
            r->textFormatieren( txt, gr.x - ( (int)vs * 15 ) - rbr * 2 );
        }
        lockZeichnung();
        tm->text->append( txt->getText() );
        unlockZeichnung();
        txt->release();
        if( hatStyle( Style::VScroll ) )
            updateVScroll();
        if( hatStyle( Style::HScroll ) )
            updateHScroll();
        rend = 1;
    }
}

// Deselectiert alle textabschnitte
void TextFeld::deselectAuswahl()
{
    for( int i = 0; i < tm->textStyle.getEintragAnzahl(); i++ )
    {
        TextStyle s = tm->textStyle.get( i );
        if( s.selected )
        {
            s.selected = 0;
            tm->textStyle.set( s, i );
        }
    }
    tm->cleanupStyles();
}

void TextFeld::setAuswahl( int pos1, int pos2 ) // setzt den Ausgewählten Text
{
    deselectAuswahl();
    TextStyle s = tm->getTextStyle( pos1 );
    s.selected = 1;
    tm->setTextStyle( pos1, pos2, s );
}

void TextFeld::setAuswahl( Punkt &auswahl )
{
    deselectAuswahl();
    TextStyle s = tm->getTextStyle( auswahl.x );
    s.selected = 1;
    tm->setTextStyle( auswahl.x, auswahl.y, s );
    rend = 1;
}

void TextFeld::addAuswahl( int pos1, int pos2 )
{
    TextStyle s = tm->getTextStyle( pos1 );
    s.selected = 1;
    tm->setTextStyle( pos1, pos2, s );
}

void TextFeld::addAuswahl( Punkt &auswahl )
{
    TextStyle s = tm->getTextStyle( auswahl.x );
    s.selected = 1;
    tm->setTextStyle( auswahl.x, auswahl.y, s );
    rend = 1;
}

// Setzt den ausgewählten textabschnitt fest
//  begin: Die Cursorposition im Text
//  end: Die Position im Text, bis zu der der Text eingefärbt werden soll
void TextFeld::invertAuswahl( int begin, int end )
{
    for( int i = begin; i < end; i++ )
    {
        TextStyle s = tm->getTextStyle( i );
        s.selected = !s.selected;
        tm->setTextStyle( i, i + 1, s );
        rend = 1;
    }
}

// ersetzt alle ausgewählten Textabschnitte mit einem text
//  text: der neue Text
void TextFeld::replaceAuswahl( const char *text )
{
    tm->cleanupStyles();
    int sa = tm->textStyle.getEintragAnzahl();
    int last = tm->text->getLength();
    for( int i = sa - 1; i >= 0; i-- )
    {
        TextStyle s = tm->textStyle.get( i );
        if( s.selected )
        {
            if( ( i > 0 && !tm->textStyle.get( i - 1 ).selected ) || i == 0 )
            {
                tm->removeText( s.beginIndex, last );
                tm->insertText( s.beginIndex, text );
            }
        }
        else
            last = s.beginIndex;
    }
}

void TextFeld::setTextRendererZ( TextRenderer *textRd )
{
    if( tm->renderer )
        tm->renderer->leeren();
    else
        tm->renderer = new RCArray< TextRenderer >();
    tm->renderer->add( textRd );
    rend = 1;
}

// Fügt einen TextRenderer hinzu
//  textRd: Der Textrenderer
void TextFeld::addTextRendererZ( TextRenderer *textRd )
{
    if( !tm->renderer )
        tm->renderer = new RCArray< TextRenderer >();
    tm->renderer->add( textRd );
}

// Setzt die verwendeten TextRenderer
//  textRd: Die Textrenderer
void TextFeld::setTextRendererZ( RCArray< TextRenderer > *textRd )
{
    if( tm->renderer )
        tm->renderer->release();
    tm->renderer = textRd;
}

void TextFeld::setSchriftZ( Schrift *schrift ) // setzt einen Zeiger zur Schrift
{
    if( !tm->renderer )
        tm->renderer = new RCArray< TextRenderer >();
    if( !tm->renderer->getEintragAnzahl() )
        tm->renderer->add( new TextRenderer( schrift ) );
    else
        tm->renderer->z( 0 )->setSchriftZ( schrift );
    rend = 1;
}

// Setzt einen Zeiger zur Schrift
//  rendererIndex: Der Index des Renderers dessen Schrift gesetzt werden soll
//  schrift: Die Schrift, die zum Textzeichnen verwendet werden soll.
void TextFeld::setSchriftZ( int rendererIndex, Schrift *schrift )
{
    if( !tm->renderer )
        tm->renderer = new RCArray< TextRenderer >();
    if( tm->renderer->getEintragAnzahl() <= rendererIndex )
        tm->renderer->add( new TextRenderer( schrift ), rendererIndex );
    else
        tm->renderer->z( rendererIndex )->setSchriftZ( schrift );
}

void TextFeld::setSchriftSize( unsigned char gr ) // setzt die Schriftgröße
{
    TextStyle s = tm->textStyle.get( 0 );
    s.fontSize = gr;
    tm->textStyle.set( s, 0 );
    rend = 1;
}

// Setzt die Schriftgröße (Standart: 12)
//  begin: Der Index des ersten betroffenen Zeichens
//  end: Der Index des ersten nicht betroffenen Zeichens
//  gr: Die Schriftgröße, die zum Textzeichnen verwendet werden soll
void TextFeld::setSchriftSize( int begin, int end, unsigned char gr )
{
    TextStyle s = tm->getTextStyle( begin );
    s.fontSize = gr;
    tm->setTextStyle( begin, end, s );
    rend = 1;
}

void TextFeld::setSchriftFarbe( int fc ) // setzt die Schrift Farbe
{
    TextStyle s = tm->textStyle.get( 0 );
    s.fontColor = fc;
    tm->textStyle.set( s, 0 );
    rend = 1;
}

// Setzt die Schrift Farbe
//  begin: Der Index des ersten betroffenen Zeichens
//  end: Der Index des ersten nicht betroffenen Zeichens
//  fc: Die Farbe, die zum Textzeichnen verwendet werden soll
void TextFeld::setSchriftFarbe( int begin, int end, int fc )
{
    TextStyle s = tm->getTextStyle( begin );
    s.fontColor = fc;
    tm->setTextStyle( begin, end, s );
    rend = 1;
}

void TextFeld::setSchowChar( unsigned char c ) // bei Passwortfeld *
{
    showChar = c;
    rend = 1;
}

void TextFeld::setVScrollZuZeile( int zeile ) // scrollt zur Zeile
{
    if( vertikalScrollBar && tm->renderer && tm->renderer->getEintragAnzahl() && tm->text && hatStyle( Style::Mehrzeilig ) )
    {
        lockZeichnung();
        tm->resetIteration();
        int len = tm->text->getLength();
        int y = 0;
        int lnum = 0;
        char *text = tm->text->getText();
        int max = 0;
        for( int i = 0; i < len && lnum < zeile; i++ )
        {
            if( text[ i ] == '\n' )
            {
                lnum++;
                y += max;
                max = 0;
                tm->nextStyle();
                continue;
            }
            TextRenderer *r = tm->zCurrentRenderer();
            if( r )
            {
                int tmp = r->getZeilenabstand() + r->getZeilenHeight();
                max = max >= tmp ? max : tmp;
            }
            tm->nextStyle();
        }
        unlockZeichnung();
        vertikalScrollBar->scroll( y );
        rend = 1;
    }
}

void TextFeld::updateVScroll( int pos ) // scrollt nach unten
{
    if( pos == -1 )
        pos = cpos;
    if( vertikalScrollBar )
    {
        int sPos = 0;
        int hi = 0;
        int sPosZH = 0;
        if( tm->text && tm->renderer )
        {
            if( hatStyleNicht( Style::Mehrzeilig ) )
                tm->text->remove( '\n' );
            hi = gr.y;
            if( hatStyle( Style::Rahmen ) && rahmen )
                hi -= rahmen->getRBreite() * 2;
            if( hatStyle( Style::HScroll ) && horizontalScrollBar )
                hi -= 15;
            int th = 0;
            lockZeichnung();
            tm->resetIteration();
            int len = tm->text->getLength();
            char *text = tm->text->getText();
            int max = 0;
            int lastMax = 0;
            for( int i = 0; i < len; i++ )
            {
                if( text[ i ] == '\n' )
                {
                    if( i <= pos )
                    {
                        sPos += max;
                        sPosZH = max;
                    }
                    th += max;
                    lastMax = max;
                    max = 0;
                    tm->nextStyle();
                    continue;
                }
                TextRenderer *r = tm->zCurrentRenderer();
                if( r )
                {
                    int tmp = r->getZeilenabstand() + r->getZeilenHeight();
                    max = max >= tmp ? max : tmp;
                }
                tm->nextStyle();
            }
            if( max != lastMax && max > 0 )
            {
                th += max;
                lastMax = max;
            }
            th += lastMax;
            unlockZeichnung();
            vertikalScrollBar->update( th, hi );
        }
        if( sPos - sPosZH < vertikalScrollBar->getScroll() )
            vertikalScrollBar->scroll( sPos - sPosZH );
        if( sPos + sPosZH > vertikalScrollBar->getScroll() + vertikalScrollBar->getScrollData()->anzeige )
            vertikalScrollBar->scroll( sPos + sPosZH * 2 - hi );
        rend = 1;
    }
}

void TextFeld::updateHScroll( int pos ) // scrollt zur Curser Position
{
    if( pos == -1 )
        pos = cpos;
    if( horizontalScrollBar && tm->text && tm->renderer )
    {
        if( hatStyleNicht( Style::Mehrzeilig ) )
            tm->text->remove( '\n' );
        int br = gr.x;
        if( hatStyle( Style::Rahmen ) && rahmen )
            br -= rahmen->getRBreite() * 2;
        if( hatStyle( Style::VScroll ) && vertikalScrollBar )
            br -= 15;
        int maxBr = 0;
        int len = tm->text->getLength();
        char *text = tm->text->getText();
        int lineBr = 0;
        char buff[] = { 0,0 };
        int cbr = 0;
        for( int i = 0; i < len; i++ )
        {
            buff[ 0 ] = text[ i ];
            if( text[ i ] == '\n' )
            {
                maxBr = maxBr >= lineBr ? maxBr : lineBr;
                lineBr = 0;
                tm->nextStyle();
                continue;
            }
            TextRenderer *r = tm->zCurrentRenderer();
            if( r )
            {
                lineBr += r->getTextBreite( buff );
                if( i <= pos )
                    cbr = lineBr;
            }
            tm->nextStyle();
        }
        horizontalScrollBar->update( maxBr, br );
        if( cbr > horizontalScrollBar->getScroll() + horizontalScrollBar->getScrollData()->anzeige )
            horizontalScrollBar->scroll( cbr - br );
        if( cbr < horizontalScrollBar->getScroll() )
            horizontalScrollBar->scroll( cbr );
    }
}

bool TextFeld::tick( double tickval ) // tick
{
    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 )
            tickVal -= 1;
    }
    return ZeichnungHintergrund::tick( tickval );
}

void TextFeld::doMausEreignis( MausEreignis &me ) // Maus Ereignis
{
    bool nmakc = !me.verarbeitet;
    if( hatStyleNicht( Style::Erlaubt ) || hatStyleNicht( Style::Sichtbar ) )
    {
        if( toolTip )
            toolTip->setMausIn( 0 );
        me.mx -= pos.x, me.my -= pos.y;
        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 )
        {
            vertikalScrollBar->doMausMessage( gr.x - rbr - 15, rbr, 15, gr.y - rbr * 2, me );
            horizontalScrollBar->doMausMessage( rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? 15 : 0 ), 15, me );
            me.verarbeitet = 1;
        }
        me.mx += pos.x, me.my += pos.y;
        mausKlick = 0;
        return;
    }
    bool removeFokus = 0;
    if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
    {
        if( mausIn )
        {
            mausIn = 0;
            if( toolTip )
                toolTip->setMausIn( 0 );
            MausEreignis me2;
            me2.id = ME_Leaves;
            me2.mx = me.mx;
            me2.my = me.my;
            me2.verarbeitet = 0;
            doMausEreignis( me2 );
            return;
        }
        removeFokus = 1;
    }
    if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Leaves )
    {
        if( removeFokus && me.id == ME_RLinks )
        {
            me.mx -= pos.x, me.my -= pos.y;
            if( hatStyle( Style::Fokus ) && mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
                removeStyle( Style::Fokus );
            if( nmakc && me.verarbeitet && nMak )
                me.verarbeitet = nMak( nmakParam, this, me );
            me.mx += pos.x, me.my += pos.y;
        }
        if( toolTip )
            toolTip->setMausIn( 0 );
        return;
    }
    if( !mausIn && me.id != ME_Leaves )
    {
        mausIn = 1;
        if( toolTip )
            toolTip->setMausIn( 1 );
        MausEreignis me2;
        me2.id = ME_Betritt;
        me2.mx = me.mx;
        me2.my = me.my;
        me2.verarbeitet = 0;
        doMausEreignis( me2 );
    }
    me.mx -= pos.x, me.my -= pos.y;
    if( mak && ( me.verarbeitet || mak( makParam, this, me ) ) )
    {
        if( removeFokus && me.id == ME_RLinks )
            removeStyle( Style::Fokus );
        if( !me.verarbeitet )
        {
            if( hatStyleNicht( Style::Fokus ) )
            {
                mausKlick = 0;
                if( me.id == Framework::ME_PLinks )
                    addStyle( Style::Fokus );
            }
            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 ) )
                {
                    if( nmakc && me.verarbeitet && nMak )
                        me.verarbeitet = nMak( nmakParam, this, me );
                    me.mx += pos.x, me.my += pos.y;
                    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 ) )
                {
                    if( nmakc && me.verarbeitet && nMak )
                        me.verarbeitet = nMak( nmakParam, this, me );
                    me.mx += pos.x, me.my += pos.y;
                    return;
                }
            }
            bool shift = TastenStand[ T_Shift ];
            bool strg = TastenStand[ T_Strg ];
            int tbr = getTextWidth();
            int thi = getTextHeight();
            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 mausChar = getTextIndexAt( xxx, yyy );
            int scrollBreite = ( vertikalScrollBar && hatStyle( Style::VScroll ) ) * 15;
            int scrollHeight = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) * 15;
            if( hatStyle( Style::HCenter ) )
                xxx -= ( ( ( gr.x - scrollBreite ) / 2 ) - tbr / 2 ) - rbr;
            if( hatStyle( Style::VCenter ) && hatStyleNicht( Style::VScroll ) )
                yyy -= ( ( ( gr.y - scrollHeight ) / 2 ) - thi / 2 ) - rbr;
            if( mausChar >= 0 )
            {
                TextStyle s = tm->getTextStyle( mausChar );
                if( s.onClick )
                    s.onClick( 0, this, me );
            }
            if( me.mx < gr.x - rbr - 15 )
            {
                if( tm->renderer )
                {
                    int ncpos = getCurserPosAt( xxx, yyy );
                    if( me.id == Framework::ME_PLinks )
                    {
                        if( ncpos != -1 )
                        {
                            if( shift && cpos != ncpos )
                                addAuswahl( MIN( cpos, ncpos ), MAX( cpos, ncpos ) );
                            else if( !shift && !mausKlick && !strg )
                                deselectAuswahl();
                            cpos = ncpos;
                            rend = 1;
                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                                updateVScroll();
                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                                updateHScroll();
                        }
                        mausKlick = 1;
                    }
                    if( me.id == ME_Bewegung && mausKlick )
                    {
                        if( ncpos != -1 )
                        {
                            rend = 1;
                            if( cpos != ncpos )
                                invertAuswahl( MIN( cpos, ncpos ), MAX( cpos, ncpos ) );
                            cpos = ncpos;
                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                                updateVScroll( cpos );
                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                                updateHScroll( cpos );
                        }
                    }
                    if( me.id == ME_RLinks )
                    {
                        if( ncpos != -1 )
                        {
                            rend = 1;
                            if( cpos != ncpos )
                                invertAuswahl( MIN( cpos, ncpos ), MAX( cpos, ncpos ) );
                            cpos = ncpos;
                            if( vertikalScrollBar && hatStyle( Style::VScroll ) )
                                updateVScroll( cpos );
                            if( horizontalScrollBar && hatStyle( Style::HScroll ) )
                                updateHScroll( cpos );
                        }
                        mausKlick = 0;
                    }
                }
            }
        }
        me.verarbeitet = 1;
    }
    if( nmakc && me.verarbeitet && nMak )
        me.verarbeitet = nMak( nmakParam, this, me );
    me.mx += pos.x, me.my += pos.y;
}

void TextFeld::doTastaturEreignis( TastaturEreignis &te )
{
    bool ntakc = !te.verarbeitet;
    if( te.verarbeitet || hatStyleNicht( Style::Fokus ) )
        return;
    if( !tak )
        return;
    ++ref;
    if( tak( takParam, this, te ) )
    {
        if( hatStyleNicht( Style::Erlaubt ) )
        {
            --ref;
            if( !ref )
                delete this;
            return;
        }
        if( te.id == TE_Press )
        {
            bool shift = TastenStand[ T_Shift ];
            bool strg = TastenStand[ T_Strg ];
            switch( te.taste )
            {
            case T_Entf:
                if( !tm->getTextStyle( cpos ).selected )
                    tm->removeText( cpos, cpos + 1 );
                else
                {
                    cpos = tm->getTextStyle( cpos ).beginIndex;
                    while( cpos > 0 && tm->getTextStyle( cpos - 1 ).selected )
                        cpos = tm->getTextStyle( cpos - 1 ).beginIndex;
                }
                replaceAuswahl( "" );
                deselectAuswahl();
                rend = 1;
                break;
            case T_BackSpace:
                if( !tm->getTextStyle( cpos ).selected )
                {
                    tm->removeText( cpos - 1, cpos );
                    cpos--;
                }
                else
                {
                    cpos = tm->getTextStyle( cpos ).beginIndex;
                    while( cpos > 0 && tm->getTextStyle( cpos - 1 ).selected )
                        cpos = tm->getTextStyle( cpos - 1 ).beginIndex;
                }
                replaceAuswahl( "" );
                deselectAuswahl();
                rend = 1;
                break;
            case T_Enter:
                if( !tm->getTextStyle( cpos ).selected )
                    tm->insertText( cpos, "\n" );
                else
                {
                    cpos = tm->getTextStyle( cpos ).beginIndex;
                    while( cpos > 0 && tm->getTextStyle( cpos - 1 ).selected )
                        cpos = tm->getTextStyle( cpos - 1 ).beginIndex;
                }
                replaceAuswahl( "\n" );
                ++cpos;
                rend = 1;
                break;
            case T_Links:
                if( shift )
                {
                    if( strg )
                    {
                        int tmp = tm->text->getLKick( cpos );
                        invertAuswahl( tmp, cpos );
                        cpos = tmp;
                    }
                    else
                    {
                        invertAuswahl( cpos - 1, cpos );
                        --cpos;
                    }
                }
                else
                {
                    if( strg )
                        cpos = tm->text->getLKick( cpos );
                    else
                        --cpos;
                    deselectAuswahl();
                }
                rend = 1;
                break;
            case T_Oben:
            {
                int tmp = tm->text->getOKick( cpos );
                invertAuswahl( tmp, cpos );
                cpos = tmp;
                if( !shift )
                    deselectAuswahl();
                rend = 1;
                break;
            }
            case T_Rechts:
                if( shift )
                {
                    if( strg )
                    {
                        int tmp = tm->text->getRKick( cpos );
                        invertAuswahl( cpos, tmp );
                        cpos = tmp;
                    }
                    else
                    {
                        invertAuswahl( cpos, cpos + 1 );
                        ++cpos;
                    }
                }
                else
                {
                    if( strg )
                        cpos = tm->text->getRKick( cpos );
                    else
                        ++cpos;
                    deselectAuswahl();
                }
                rend = 1;
                break;
            case T_Unten:
            {
                int tmp = tm->text->getUKick( cpos );
                invertAuswahl( cpos, tmp );
                cpos = tmp;
                if( !shift )
                    deselectAuswahl();
                rend = 1;
                break;
            }
            default:
                if( strg && te.id == TE_Press )
                {
                    if( te.taste == 'c' || te.taste == 'C' )
                    {
                        int sa = tm->textStyle.getEintragAnzahl();
                        int length = 0;
                        for( int i = 0; i < sa; i++ )
                        {
                            TextStyle s = tm->textStyle.get( i );
                            if( s.selected )
                            {
                                int max = tm->text->getLength();
                                if( i < sa - 1 )
                                    max = tm->textStyle.get( i + 1 ).beginIndex;
                                length += max - s.beginIndex;
                            }
                        }
                        if( length )
                        {
                            char *txt = new char[ length + 1 ];
                            txt[ length ] = 0;
                            int index = 0;
                            for( int i = 0; i < sa; i++ )
                            {
                                TextStyle s = tm->textStyle.get( i );
                                if( s.selected )
                                {
                                    int max = tm->text->getLength();
                                    if( i < sa - 1 )
                                        max = tm->textStyle.get( i + 1 ).beginIndex;
                                    memcpy( txt + index, tm->text->getText() + s.beginIndex, max - s.beginIndex );
                                    index += max - s.beginIndex;
                                }
                            }
                            TextKopieren( txt );
                            delete[] txt;
                        }
                        else
                            TextKopieren( tm->text->getText() );
                    }
                    if( te.taste == 'v' || te.taste == 'V' )
                    {
                        char *txt = TextInsert();
                        if( !tm->getTextStyle( cpos ).selected )
                            tm->insertText( cpos, txt );
                        else
                        {
                            cpos = tm->getTextStyle( cpos ).beginIndex;
                            while( cpos > 0 && tm->getTextStyle( cpos - 1 ).selected )
                                cpos = tm->getTextStyle( cpos - 1 ).beginIndex;
                        }
                        replaceAuswahl( txt );
                        cpos += textLength( txt );
                        rend = 1;
                    }
                    break;
                }
                if( istSchreibbar( te.taste ) )
                {
                    char buff[] = { (char)te.taste, 0 };
                    if( !tm->getTextStyle( cpos ).selected )
                        tm->insertText( cpos, buff );
                    else
                    {
                        cpos = tm->getTextStyle( cpos ).beginIndex;
                        while( cpos > 0 && tm->getTextStyle( cpos - 1 ).selected )
                            cpos = tm->getTextStyle( cpos - 1 ).beginIndex;
                    }
                    replaceAuswahl( buff );
                    ++cpos;
                    rend = 1;
                }
                break;
            }
        }
        if( cpos < 0 )
            cpos = 0;
        if( cpos > tm->text->getLength() )
            cpos = tm->text->getLength();
        if( hatStyle( Style::VScroll ) )
            updateVScroll( cpos );
        if( hatStyle( Style::HScroll ) )
            updateHScroll( cpos );
        te.verarbeitet = 1;
    }
    --ref;
    if( ntakc && te.verarbeitet && nTak )
        te.verarbeitet = nTak( ntakParam, this, te );
    if( !ref )
        delete this;
}

void TextFeld::render( Bild &zRObj ) // zeichenet nach zRObj
{
    if( hatStyleNicht( Style::Sichtbar ) )
        return;
    ZeichnungHintergrund::render( zRObj );
    if( !tm->text || !tm->renderer )
        return;
    lockZeichnung();
    if( !zRObj.setDrawOptions( innenPosition, innenSize ) )
    {
        unlockZeichnung();
        return;
    }
    if( hatStyleNicht( Style::Mehrzeilig ) )
        tm->text->remove( '\n' );
    int tbr = getTextWidth();
    int thi = getTextHeight();
    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();
    if( hatStyle( Style::HCenter ) && !hs )
        xxx = ( breite / 2 ) - tbr / 2;
    if( hatStyle( Style::VCenter ) && !vs )
        yyy = ( height / 2 ) - thi / 2;
    int x = xxx;
    int y = yyy;
    int len = tm->text->getLength();
    char *text = tm->text->getText();
    lockZeichnung();
    tm->resetIteration();
    TextStyle &style = tm->currentStyle();
    int maxLH = 0;
    for( int i = 0; i <= len; i++ )
    {
        int oldX = x;
        if( i < len )
            tm->zCurrentRenderer()->renderChar( x, y, istSchreibbar( showChar ) ? showChar : text[ i ], zRObj, style.selected ? style.selectedColor : style.fontColor, style.underlined, style.selected, style.selectedBackcroundColor );
        if( i == cpos && tickVal <= 0.5 && hatStyle( Style::Fokus ) && hatStyle( Style::Erlaubt ) )
            zRObj.drawLinieV( oldX, y, tm->zCurrentRenderer()->getZeilenHeight(), 0xFFFF5555 );
        int tmp = tm->zCurrentRenderer()->getZeilenHeight() + tm->zCurrentRenderer()->getZeilenAbstand();
        maxLH = tmp > maxLH ? tmp : maxLH;
        if( i < len && text[ i ] == '\n' )
        {
            x = xxx;
            y += maxLH;
        }
        tm->nextStyle();
    }
    unlockZeichnung();
    zRObj.releaseDrawOptions();
    unlockZeichnung();
}

// Konstant 
Text *TextFeld::getText() const // gibt vom Text zurück
{
    if( !tm->text )
        return 0;
    return tm->text->getThis();
}

Text *TextFeld::zText() const // gibt den Text zurück
{
    return tm->text;
}

Schrift *TextFeld::getSchrift() const// gint getThis der Schrift Zurück
{
    tm->resetIteration();
    return tm->zCurrentRenderer()->getSchrift();
}

Schrift *TextFeld::zSchrift() const// gibt die Schrift zurück
{
    tm->resetIteration();
    return tm->zCurrentRenderer()->zSchrift();
}

// Gibt die Schrift zurück.
//  rendererIndex: Der Index des Renderers dessen Schrift zurückgegeben werden soll
//  return: 0, falls die Schrift nicht gesetzt wurde
Schrift *TextFeld::getSchrift( int rendererIndex ) const
{
    if( tm->renderer && tm->renderer->z( rendererIndex ) )
        return tm->renderer->z( rendererIndex )->getSchrift();
    return 0;
}

// Gibt die Schrift ohne erhöhten Reference Counter zurük
//  rendererIndex: Der Index des Renderers dessen Schrift zurückgegeben werden soll
//  return: 0, falls die Schrift nicht gesetzt wurde
Schrift *TextFeld::zSchrift( int rendererIndex ) const
{
    if( tm->renderer && tm->renderer->z( rendererIndex ) )
        return tm->renderer->z( rendererIndex )->zSchrift();
    return 0;
}

TextRenderer *TextFeld::getTextRenderer() const
{
    tm->resetIteration();
    return tm->zCurrentRenderer()->getThis();
}

TextRenderer *TextFeld::zTextRenderer() const
{
    tm->resetIteration();
    return tm->zCurrentRenderer();
}

// Gibt den TextRenderer zurück.
//  index: Der Index des Renderers der zurückgegeben werden soll
//  return: 0, falls der TextRenderer nicht gesetzt wurde
TextRenderer *TextFeld::getTextRenderer( int index ) const
{
    if( tm->renderer && tm->renderer->z( index ) )
        return tm->renderer->get( index );
    return 0;
}

// Gibt dien TextRenderer ohne erhöhten Reference Counter zurük
//  index: Der Index des Renderers der zurückgegeben werden soll
//  return: 0, falls der TextRenderer nicht gesetzt wurde
TextRenderer *TextFeld::zTextRenderer( int index ) const
{
    if( tm->renderer && tm->renderer->z( index ) )
        return tm->renderer->z( index );
    return 0;
}

unsigned char TextFeld::getSchriftSize() const // gibt die Schriftgröße zurück
{
    tm->resetIteration();
    return tm->current.fontSize;
}

// Gibt die Schriftgröße zurück
//  index: Der Index des Zeichens
unsigned char TextFeld::getSchriftSize( int index ) const
{
    tm->resetIteration();
    return tm->current.fontSize;
}

int TextFeld::getSchriftFarbe() const// gibt getThis der Schriftfarbe zurück
{
    tm->resetIteration();
    return tm->current.fontColor;
}

// Gibt die Schriftfarbe im A8R8G8B8 Format zurück
//  index: Der Index des Zeichens
int TextFeld::getSchriftFarbe( int index ) const
{
    return tm->getTextStyle( index ).fontColor;
}

unsigned char TextFeld::getShowChar() const // gibt den Anzeige Char zurück
{
    return showChar;
}

int TextFeld::getCursorPos() const
{
    return cpos;
}

// Gibt 1 zurück wenn das Zeichen ausgewählt ist
//  index: Der Index des Zeichens
bool TextFeld::isCharSelected( int index ) const
{
    return tm->getTextStyle( index ).selected;
}

// Gibt den Index des Zeichens zurück, das sich unter der Maus befindet
//  mx: die x position der maus relativ zur position des textfeldes
//  my: die y position der maus relativ zut position des textfeldes
//  return: -1, falls sich an der Position kein zeichen befindet
int TextFeld::getTextIndexAt( int mx, int my ) const
{
    int tbr = getTextWidth();
    int thi = getTextHeight();
    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();
    if( hatStyle( Style::HCenter ) && !hs )
        xxx = ( breite / 2 ) - tbr / 2;
    if( hatStyle( Style::VCenter ) && !vs )
        yyy = ( height / 2 ) - thi / 2;
    int x = xxx;
    int y = yyy;
    int len = tm->text->getLength();
    char *text = tm->text->getText();
    tm->resetIteration();
    int maxLH = 0;
    for( int i = 0; i < len; i++ )
    {
        int tmpx = tm->zCurrentRenderer()->getCharWidth( istSchreibbar( showChar ) ? showChar : text[ i ] );
        int tmpy = tm->zCurrentRenderer()->getZeilenHeight();
        if( mx >= x && mx < x + tmpx && my >= y && my < maxLH + tmpy )
            return i;
        if( mx < x + tmpx && my < maxLH + tmpy )
            return -1;
        x += tmpx + tm->zCurrentRenderer()->getZeichenAbstand();
        tmpy += tm->zCurrentRenderer()->getZeilenAbstand();
        maxLH = tmpy > maxLH ? tmpy : maxLH;
        if( text[ i ] == '\n' )
        {
            x = xxx;
            y += maxLH;
        }
        tm->nextStyle();
    }
    return -1;
}

// Gibt den Index des Zeichens zurück, vor dem der curser gesetzt wird, wenn mit der maus geklickt wird
//  mx: die x position der maus relativ zur position des textfeldes
//  my: die y position der maus relativ zut position des textfeldes
int TextFeld::getCurserPosAt( int mx, int my ) const
{
    int tbr = getTextWidth();
    int thi = getTextHeight();
    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();
    if( hatStyle( Style::HCenter ) && !hs )
        xxx = ( breite / 2 ) - tbr / 2;
    if( hatStyle( Style::VCenter ) && !vs )
        yyy = ( height / 2 ) - thi / 2;
    int x = xxx;
    int y = yyy;
    int len = tm->text->getLength();
    char *text = tm->text->getText();
    tm->resetIteration();
    int maxLH = 0;
    for( int i = 0; i < len; i++ )
    {
        int tmpx = tm->zCurrentRenderer()->getCharWidth( istSchreibbar( showChar ) ? showChar : text[ i ] );
        int tmpy = tm->zCurrentRenderer()->getZeilenHeight() + tm->zCurrentRenderer()->getZeilenAbstand();
        if( mx < x + tmpx / 2 && my < y + tmpy - tm->zCurrentRenderer()->getZeilenAbstand() / 2 )
            return i;
        x += tmpx + tm->zCurrentRenderer()->getZeichenAbstand();
        maxLH = tmpy > maxLH ? tmpy : maxLH;
        if( text[ i ] == '\n' )
        {
            if( my >= y - tm->zCurrentRenderer()->getZeilenAbstand() / 2 && my < y + maxLH - tm->zCurrentRenderer()->getZeilenAbstand() / 2 )
                return i;
            x = xxx;
            y += maxLH;
        }
        tm->nextStyle();
    }
    return tm->text->getLength();
}

// Gibt den Style eines bestimmten zeichens zurück
//  index: Der index des Zeichensf
TextFeld::TextStyle TextFeld::getTextStyle( int index ) const
{
    return tm->getTextStyle( index );
}

Zeichnung *TextFeld::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
{
    TextFeld *obj = new TextFeld();
    obj->setPosition( pos );
    obj->setSize( gr );
    obj->setMausEreignisParameter( makParam );
    obj->setTastaturEreignisParameter( takParam );
    obj->setMausEreignis( mak );
    obj->setTastaturEreignis( tak );
    if( toolTip )
        obj->setToolTipZ( (ToolTip*)toolTip->dublizieren() );
    obj->setStyle( style );
    obj->tm->renderer->release();
    obj->tm->renderer = tm->renderer->getThis();
    obj->tm->textStyle.leeren();
    for( auto i = tm->textStyle.getIterator(); i; i++ )
        obj->tm->textStyle.add( i._ );
    obj->tm->index = tm->index;
    obj->tm->styleIndex = tm->styleIndex;
    obj->tm->current = tm->current;
    if( tm->text )
        obj->setText( tm->text->getText() );
    obj->setHintergrundFarbe( hintergrundFarbe );
    if( hintergrundFeld )
        obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
    if( rahmen )
        obj->setRahmenZ( (Rahmen*)rahmen->dublizieren() );
    if( hintergrundBild )
        obj->setHintergrundBild( hintergrundBild->getThis() );
    if( vertikalScrollBar )
    {
        obj->setVertikalKlickScroll( vertikalScrollBar->getKlickScroll() );
        obj->setVertikalScrollPos( vertikalScrollBar->getScroll() );
        obj->setVertikalScrollFarbe( vertikalScrollBar->getFarbe(), vertikalScrollBar->getBgFarbe() );
    }
    if( horizontalScrollBar )
    {
        obj->setHorizontalKlickScroll( horizontalScrollBar->getKlickScroll() );
        obj->setHorizontalScrollPos( horizontalScrollBar->getScroll() );
        obj->setHorizontalScrollFarbe( horizontalScrollBar->getFarbe(), horizontalScrollBar->getBgFarbe() );
    }
    obj->setSchowChar( showChar );
    return obj;
}