KSG-Client/KSGClient/NachLogin/Editor/Karte/Dateien/KEDEditor.cpp

#include "KEDEditor.h"
#include "../../../../Global/Initialisierung.h"
#include <MausEreignis.h>
#include "../../../../Global/Variablen.h"
#include <Model2D.h>
#include <Globals.h>
#include <InitDatei.h>

// Inhalt der KEDBildSeite Klasse aus KEDEditor.h
// Konstruktor
KEDBildSeite::KEDBildSeite( Schrift *zSchrift, Knopf *zNeueDatei, Knopf *zDateiRemove )
{
    bilder = initAuswahlListe( 220, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    bildObj = initBildZ( 430, 10, 440, 440, BildZ::Style::normal | BildZ::Style::Alpha, 0 );
    bildLöschen = initKnopf( 430, 460, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Bild Löschen" );
    importieren = initKnopf( 430, 490, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Importieren" );
    dateiLöschen = (Knopf *)zDateiRemove->getThis();
    neueDatei = (Knopf *)zNeueDatei->getThis();
    importDialog = 0;
    importPfad = 0;
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KEDBildSeite::~KEDBildSeite()
{
    bilder->release();
    bildObj->release();
    bildLöschen->release();
    importieren->release();
    dateiLöschen->release();
    neueDatei->release();
    if( importDialog )
        importDialog->release();
    if( importPfad )
        importPfad->release();
}

// nicht constant
int KEDBildSeite::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KEDBildSeite::setBildListe( RCArray< Text > * list )
{
    hauptScreen->lock();
    Text txt = bilder->zEintrag( bilder->getAuswahl() ) ? bilder->zEintrag( bilder->getAuswahl() )->zText()->getText() : "";
    while( bilder->getEintragAnzahl() )
        bilder->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    int ausw = -1;
    for( int i = 0; i < anz; i++ )
    {
        if( list->z( i )->istGleich( txt ) )
            ausw = i;
        bilder->addEintrag( list->get( i ) );
    }
    if( ausw >= 0 )
        bilder->setAuswahl( ausw );
    else
        bilder->deSelect();
    list->release();
    hauptScreen->unlock();
}

void KEDBildSeite::setBild( Bild * b )
{
    hauptScreen->lock();
    bildObj->setBild( b );
    hauptScreen->unlock();
}

void KEDBildSeite::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KEDBildSeite::tick( double tv )
{
    if( importDialog )
    {
        if( !importDialog->isRunning() )
        {
            if( importPfad )
                importPfad->release();
            importPfad = importDialog->getPfad();
            importDialog = (DateiDialogTh *)importDialog->release();
            if( sichtbar &&importPfad )
                aktion = 3;
        }
    }
    bool ret = bilder->tick( tv );
    ret |= bildObj->tick( tv );
    ret |= bildLöschen->tick( tv );
    ret |= importieren->tick( tv );
    ret |= dateiLöschen->tick( tv );
    ret |= neueDatei->tick( tv );
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    if( sichtbar && bilder->getAuswahl() >= 0 && alpha2 != 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( ( !sichtbar || bilder->getAuswahl() < 0 ) && alpha2 != 0 )
    {
        if( alpha2 - val < 0 )
            alpha2 = 0;
        else
            alpha2 -= val;
        ret = 1;
    }
    return ret;
}

void KEDBildSeite::doPublicMausEreignis( MausEreignis & me )
{
    if( !sichtbar )
        return;
    int ausw = bilder->getAuswahl();
    bilder->doPublicMausEreignis( me );
    if( ausw != bilder->getAuswahl() && me.id == ME_RLinks )
    {
        if( bilder->getAuswahl() >= 0 )
            aktion = 1;
        else
            bilder->setAuswahl( ausw );
    }
    bool vera = me.verarbeitet;
    dateiLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 4;
    vera = me.verarbeitet;
    neueDatei->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 5;
    vera = me.verarbeitet;
    importieren->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        if( !importDialog )
        {
            importDialog = new DateiDialogTh();
            importDialog->setOpen( 1 );
            importDialog->setDateiTypAuswahl( 4 );
            importDialog->addDateiTyp( "JPEG-Bild", "*.jpg;*.jpeg;*.jpe" );
            importDialog->addDateiTyp( "GIF-Bild", "*.gif" );
            importDialog->addDateiTyp( "PNG-Bild", "*.png" );
            importDialog->addDateiTyp( "Alle Dateien", "*.*" );
            importDialog->start();
        }
    }
    if( bilder->getAuswahl() < 0 )
        return;
    bildObj->doPublicMausEreignis( me );
    vera = me.verarbeitet;
    bildLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 2;
}

void KEDBildSeite::render( Bild & zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    bilder->render( zRObj );
    neueDatei->setPosition( 540, 490 );
    neueDatei->render( zRObj );
    dateiLöschen->setPosition( 540, 460 );
    dateiLöschen->render( zRObj );
    importieren->render( zRObj );
    zRObj.setAlpha( alpha2 );
    bildObj->render( zRObj );
    bildLöschen->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseAlpha();
}

// constant
Text *KEDBildSeite::zBildImportPfad() const
{
    return importPfad;
}

Text *KEDBildSeite::zBildAuswahl() const
{
    if( !bilder->zEintrag( bilder->getAuswahl() ) )
        return 0;
    return bilder->zEintrag( bilder->getAuswahl() )->zText();
}

// Reference Counting
KEDBildSeite *KEDBildSeite::getThis()
{
    ref++;
    return this;
}

KEDBildSeite *KEDBildSeite::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}


bool kEDEditorNeuModelOkME( void *p, void *obj, MausEreignis me )
{
    if( p )
        return ( (KEDModellSeite *)p )->neuModelOkME( me );
    else if( me.id == ME_RLinks )
        ( (Fenster *)obj )->removeStyle( Fenster::Style::Sichtbar );
    return 1;
}


// Inhalt der KEDModellSeite Klasse aus KEDEditor.h
// Konstruktor
KEDModellSeite::KEDModellSeite( Schrift * zSchrift, Knopf * zNeueDatei, Knopf * zDateiRemove, AuswahlListe * datL )
{
    dateien = datL;
    modelle = initAuswahlListe( 220, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    modelObj = new M2DVorschau();
    modelObj->setPosition( 430, 10 );
    modelObj->setSize( 440, 440 );
    modelObj->setStyle( M2DVorschau::Style::Rahmen | M2DVorschau::Style::Erlaubt | M2DVorschau::Style::Sichtbar | M2DVorschau::Style::UsrMove | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrScale );
    modelObj->setRahmenFarbe( 0xFFFFFFFF );
    modelObj->setMausEreignis( _ret1ME );
    modelObj->setModel2DZ( new Model2D() );
    modelObj->zModel()->setStyle( Model2D::Style::Erlaubt | Model2D::Style::Mesh | Model2D::Style::Sichtbar );
    modelObj->zModel()->setFarbe( 0xFFFFFFFF );
    modelLöschen = initKnopf( 430, 460, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Modell2D Löschen" );
    neuesModel = initKnopf( 430, 490, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Neues Modell2D" );
    bearbeiten = initKnopf( 550, 490, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Bearbeiten" );
    dateiLöschen = (Knopf *)zDateiRemove->getThis();
    neueDatei = (Knopf *)zNeueDatei->getThis();
    editor = new Model2DEditor::GUI( zSchrift );
    neuModelF = initFenster( 365, 160, 150, 90, zSchrift, Fenster::Style::Erlaubt | Fenster::Style::BodyHintergrund | Fenster::Style::BodyHAlpha |
                             Fenster::Style::Rahmen | Fenster::Style::Closable | Fenster::Style::ClosingKlickBuffer | Fenster::Style::ClosingHintergrund |
                             Fenster::Style::ClosingHAlpha | Fenster::Style::Titel | Fenster::Style::TitelHintergrund | Fenster::Style::TitelHAlpha | Fenster::Style::TitelBuffered, "Neues Modell" );
    neuModelF->setKBgFarbe( 0xC0000000 );
    neuModelF->setSBgFarbe( 0xC0000000 );
    neuModelF->setTBgFarbe( 0xC0000000 );
    neuModelF->setClosingMe( kEDEditorNeuModelOkME );
    neuModelName = initTextFeld( 10, 10, 130, 20, zSchrift, TextFeld::Style::TextFeld, "Name" );
    neuModelOk = initKnopf( 25, 40, 100, 20, zSchrift, Knopf::Style::Normal | Knopf::Style::Sichtbar, "Erstellen" );
    neuModelOk->setMausEreignisParameter( this );
    neuModelOk->setMausEreignis( kEDEditorNeuModelOkME );
    neuModelF->addMember( neuModelName->getThis() );
    neuModelF->addMember( neuModelOk->getThis() );
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    alpha3 = 0;
    tickVal = 0;
    ref = 1;
}

// Destruktor
KEDModellSeite::~KEDModellSeite()
{
    dateien->release();
    modelle->release();
    modelObj->release();
    modelLöschen->release();
    neuesModel->release();
    dateiLöschen->release();
    neueDatei->release();
    bearbeiten->release();
    editor->release();
    neuModelF->release();
    neuModelName->release();
    neuModelOk->release();
}

// nicht constant
int KEDModellSeite::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

bool KEDModellSeite::neuModelOkME( MausEreignis & me )
{
    if( me.id == ME_RLinks )
    {
        neuModelF->removeStyle( Fenster::Style::Sichtbar );
        aktion = 4;
    }
    return 1;
}

void KEDModellSeite::setModelListe( RCArray< Text > * list )
{
    hauptScreen->lock();
    Text txt = modelle->zEintrag( modelle->getAuswahl() ) ? modelle->zEintrag( modelle->getAuswahl() )->zText()->getText() : "";
    while( modelle->getEintragAnzahl() )
        modelle->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    int ausw = -1;
    for( int i = 0; i < anz; i++ )
    {
        if( list->z( i )->istGleich( txt ) )
            ausw = i;
        modelle->addEintrag( list->get( i ) );
    }
    if( ausw >= 0 )
        modelle->setAuswahl( ausw );
    else
        modelle->deSelect();
    list->release();
    hauptScreen->unlock();
}

void KEDModellSeite::setModel( Model2DData * mdl )
{
    modelObj->setModel2D( mdl->getThis() );
    editor->setModel( mdl );
}

void KEDModellSeite::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KEDModellSeite::tick( double tv )
{
    bool ret = modelle->tick( tv );
    ret |= modelObj->tick( tv );
    ret |= modelLöschen->tick( tv );
    ret |= neuesModel->tick( tv );
    ret |= dateiLöschen->tick( tv );
    ret |= neueDatei->tick( tv );
    ret |= bearbeiten->tick( tv );
    ret |= editor->tick( tv );
    ret |= neuModelF->tick( tv );
    int a = editor->getAktion();
    if( a == 1 || a == 2 )
    {
        editor->setSichtbar( 0 );
        modelObj->addStyle( Model2D::Style::Sichtbar );
        modelle->addStyle( Model2D::Style::Sichtbar );
        dateien->addStyle( AuswahlListe::Style::Sichtbar );
        dateiLöschen->addStyle( Knopf::Style::Sichtbar );
        neueDatei->addStyle( Knopf::Style::Sichtbar );
        neuesModel->addStyle( Knopf::Style::Sichtbar );
        modelLöschen->addStyle( Knopf::Style::Sichtbar );
        bearbeiten->addStyle( Knopf::Style::Sichtbar );
    }
    if( a == 1 )
        aktion = 3;
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    if( sichtbar && modelle->getAuswahl() >= 0 && alpha2 != 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( ( !sichtbar || modelle->getAuswahl() < 0 ) && alpha2 != 0 )
    {
        if( alpha2 - val < 0 )
            alpha2 = 0;
        else
            alpha2 -= val;
        ret = 1;
    }
    if( sichtbar && neuModelF->hatStyle( Fenster::Style::Sichtbar ) && alpha3 > 100 )
    {
        if( alpha3 - val < 100 )
            alpha3 = 100;
        else
            alpha3 -= val;
        ret = 1;
    }
    if( sichtbar &&neuModelF->hatStyleNicht( Fenster::Style::Sichtbar ) && alpha3 < 255 )
    {
        if( alpha3 + val > 255 )
            alpha3 = 255;
        else
            alpha3 += val;
        ret = 1;
    }
    return ret;
}

void KEDModellSeite::doPublicMausEreignis( MausEreignis & me )
{
    if( !sichtbar )
        return;
    if( neuModelF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuModelF->doPublicMausEreignis( me );
        return;
    }
    int ausw = modelle->getAuswahl();
    modelle->doPublicMausEreignis( me );
    if( ausw != modelle->getAuswahl() && me.id == ME_RLinks )
    {
        if( modelle->getAuswahl() >= 0 )
            aktion = 1;
        else
            modelle->setAuswahl( ausw );
    }
    bool vera = me.verarbeitet;
    dateiLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 5;
    vera = me.verarbeitet;
    neueDatei->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 6;
    vera = me.verarbeitet;
    neuesModel->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        neuModelF->addStyle( Fenster::Style::Sichtbar );
    vera = me.verarbeitet;
    if( modelle->getAuswahl() < 0 )
        return;
    bearbeiten->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
    {
        editor->setSichtbar( 1 );
        modelObj->removeStyle( Model2D::Style::Sichtbar );
        modelle->removeStyle( Model2D::Style::Sichtbar );
        dateien->removeStyle( AuswahlListe::Style::Sichtbar );
        dateiLöschen->removeStyle( Knopf::Style::Sichtbar );
        neueDatei->removeStyle( Knopf::Style::Sichtbar );
        neuesModel->removeStyle( Knopf::Style::Sichtbar );
        bearbeiten->removeStyle( Knopf::Style::Sichtbar );
        modelLöschen->removeStyle( Knopf::Style::Sichtbar );
    }
    modelObj->doPublicMausEreignis( me );
    editor->doPublicMausEreignis( me );
    vera = me.verarbeitet;
    modelLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 2;
}

void KEDModellSeite::doTastaturEreignis( TastaturEreignis & te )
{
    if( neuModelF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuModelF->doTastaturEreignis( te );
        return;
    }
    editor->doTastaturEreignis( te );
}

void KEDModellSeite::render( Bild & zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    zRObj.setAlpha( alpha3 );
    modelle->render( zRObj );
    neuesModel->render( zRObj );
    neueDatei->setPosition( 670, 490 );
    neueDatei->render( zRObj );
    dateiLöschen->setPosition( 670, 460 );
    dateiLöschen->render( zRObj );
    if( modelle->getAuswahl() >= 0 )
    {
        bearbeiten->render( zRObj );
        modelLöschen->render( zRObj );
        zRObj.setAlpha( alpha2 );
        modelObj->render( zRObj );
        editor->render( zRObj );
        zRObj.releaseAlpha();
    }
    zRObj.releaseAlpha();
    neuModelF->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
Text *KEDModellSeite::zModelAuswahl() const
{
    if( !modelle->zEintrag( modelle->getAuswahl() ) )
        return 0;
    return modelle->zEintrag( modelle->getAuswahl() )->zText();
}

Text *KEDModellSeite::zNeuModelName() const
{
    return neuModelName->zText();
}

Model2DData *KEDModellSeite::getModelData() const
{
    return editor->getM2Data();
}

// Reference Counting
KEDModellSeite *KEDModellSeite::getThis()
{
    ref++;
    return this;
}

KEDModellSeite *KEDModellSeite::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}


// Inhalt der KEDSoundSeite Klasse aus KEDEditor.h
// Konstruktor
KEDSoundSeite::KEDSoundSeite( Schrift * zSchrift, Knopf * zNeueDatei, Knopf * zDateiRemove )
{
    Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
    sounds = initAuswahlListe( 220, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    play = initKnopf( 430, 430, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Play" );
    soundLöschen = initKnopf( 430, 460, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Bild Löschen" );
    importieren = initKnopf( 430, 490, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Importieren" );
    dateiLöschen = (Knopf *)zDateiRemove->getThis();
    neueDatei = (Knopf *)zNeueDatei->getThis();
    importDialog = 0;
    importPfad = 0;
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    tickVal = 0;
    sound = 0;
    ref = 1;
}

// Destruktor
KEDSoundSeite::~KEDSoundSeite()
{
    if( sound )
    {
        sound->stopSound();
        sound->release();
    }
    Framework::getDLLRegister()->releaseDLL( "GSL.dll" );
    sounds->release();
    play->release();
    soundLöschen->release();
    importieren->release();
    dateiLöschen->release();
    neueDatei->release();
    if( importDialog )
        importDialog->release();
    if( importPfad )
        importPfad->release();
}

// nicht constant
int KEDSoundSeite::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

void KEDSoundSeite::setSoundListe( RCArray< Text > * list )
{
    hauptScreen->lock();
    Text txt = sounds->zEintrag( sounds->getAuswahl() ) ? sounds->zEintrag( sounds->getAuswahl() )->zText()->getText() : "";
    while( sounds->getEintragAnzahl() )
        sounds->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    int ausw = -1;
    for( int i = 0; i < anz; i++ )
    {
        if( list->z( i )->istGleich( txt ) )
            ausw = i;
        sounds->addEintrag( list->get( i ) );
    }
    if( ausw >= 0 )
        sounds->setAuswahl( ausw );
    else
        sounds->deSelect();
    list->release();
    hauptScreen->unlock();
}

void KEDSoundSeite::setSound( GSL::GSLSoundV * b )
{
    if( sound )
    {
        sound->stopSound();
        sound->release();
    }
    sound = b;
    int vol = userOptions->wertExistiert( "GUISound" ) ? *userOptions->zWert( "GUISound" ) : 100;
    sound->setVolume( (int)( ( vol / 100.0 ) * 0xFFFF ), (int)( ( vol / 100.0 ) * 0xFFFF ) );
    sound->playSound();
}

void KEDSoundSeite::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KEDSoundSeite::tick( double tv )
{
    if( importDialog )
    {
        if( !importDialog->isRunning() )
        {
            if( importPfad )
                importPfad->release();
            importPfad = importDialog->getPfad();
            importDialog = (DateiDialogTh *)importDialog->release();
            if( sichtbar &&importPfad )
                aktion = 3;
        }
    }
    bool ret = sounds->tick( tv );
    ret |= play->tick( tv );
    ret |= soundLöschen->tick( tv );
    ret |= importieren->tick( tv );
    ret |= dateiLöschen->tick( tv );
    ret |= neueDatei->tick( tv );
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
        val = (int)tickVal;
    else
        return ret;
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    if( sichtbar && sounds->getAuswahl() >= 0 && alpha2 != 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( ( !sichtbar || sounds->getAuswahl() < 0 ) && alpha2 != 0 )
    {
        if( alpha2 - val < 0 )
            alpha2 = 0;
        else
            alpha2 -= val;
        ret = 1;
    }
    return ret;
}

void KEDSoundSeite::doPublicMausEreignis( MausEreignis & me )
{
    if( !sichtbar )
        return;
    int ausw = sounds->getAuswahl();
    sounds->doPublicMausEreignis( me );
    if( ausw != sounds->getAuswahl() && me.id == ME_RLinks )
    {
        if( sounds->getAuswahl() >= 0 )
        {
            if( sound )
                sound->stopSound();
        }
        else
            sounds->setAuswahl( ausw );
    }
    bool vera = me.verarbeitet;
    dateiLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 4;
    vera = me.verarbeitet;
    neueDatei->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 5;
    vera = me.verarbeitet;
    importieren->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        if( !importDialog )
        {
            importDialog = new DateiDialogTh();
            importDialog->setOpen( 1 );
            importDialog->setDateiTypAuswahl( 4 );
            importDialog->addDateiTyp( "WAV-Sound", "*.wav" );
            importDialog->addDateiTyp( "Alle Dateien", "*.*" );
            importDialog->start();
        }
    }
    if( sounds->getAuswahl() < 0 )
        return;
    vera = me.verarbeitet;
    play->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
    {
        if( sound )
            sound->stopSound();
        aktion = 1;
    }
    vera = me.verarbeitet;
    soundLöschen->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet &&me.id == ME_RLinks )
        aktion = 2;
}

void KEDSoundSeite::render( Bild & zRObj )
{
    if( !alpha )
        return;
    zRObj.setAlpha( alpha );
    sounds->render( zRObj );
    neueDatei->setPosition( 540, 490 );
    neueDatei->render( zRObj );
    dateiLöschen->setPosition( 540, 460 );
    dateiLöschen->render( zRObj );
    importieren->render( zRObj );
    zRObj.setAlpha( alpha2 );
    play->render( zRObj );
    soundLöschen->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseAlpha();
}

// constant
Text *KEDSoundSeite::zSoundImportPfad() const
{
    return importPfad;
}

Text *KEDSoundSeite::zSoundAuswahl() const
{
    if( !sounds->zEintrag( sounds->getAuswahl() ) )
        return 0;
    return sounds->zEintrag( sounds->getAuswahl() )->zText();
}

// Reference Counting
KEDSoundSeite *KEDSoundSeite::getThis()
{
    ref++;
    return this;
}

KEDSoundSeite *KEDSoundSeite::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}


bool kEDEditorNeuDateiOkME( void *p, void *obj, MausEreignis me )
{
    if( p )
        return ( (KEDEditor *)p )->neuDateiOkME( me );
    else if( me.id == ME_RLinks )
        ( (Fenster *)obj )->removeStyle( Fenster::Style::Sichtbar );
    return 1;
}


// Inhalt der KEDEditor Klasse aus KEDEditor.h
// Konstruktor
KEDEditor::KEDEditor( Schrift * zSchrift )
    : Zeichnung()
{
    neueDatei = initKnopf( 0, 0, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Neue Datei" );
    dateiLöschen = initKnopf( 0, 0, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Datei Löschen" );
    dateien = initAuswahlListe( 10, 10, 200, 510, zSchrift, AuswahlListe::Style::Normal, {} );
    bildSeite = new KEDBildSeite( zSchrift, neueDatei, dateiLöschen );
    modelSeite = new KEDModellSeite( zSchrift, neueDatei, dateiLöschen, (AuswahlListe *)dateien->getThis() );
    soundSeite = new KEDSoundSeite( zSchrift, neueDatei, dateiLöschen );
    neuDateiF = initFenster( 365, 145, 150, 120, zSchrift, Fenster::Style::Erlaubt | Fenster::Style::BodyHintergrund | Fenster::Style::BodyHAlpha |
                             Fenster::Style::Rahmen | Fenster::Style::Closable | Fenster::Style::ClosingKlickBuffer | Fenster::Style::ClosingHintergrund |
                             Fenster::Style::ClosingHAlpha | Fenster::Style::Titel | Fenster::Style::TitelHintergrund | Fenster::Style::TitelHAlpha | Fenster::Style::TitelBuffered, "Neue Datei" );
    neuDateiF->setKBgFarbe( 0xC0000000 );
    neuDateiF->setSBgFarbe( 0xC0000000 );
    neuDateiF->setTBgFarbe( 0xC0000000 );
    neuDateiF->setClosingMe( kEDEditorNeuDateiOkME );
    neuDateiTyp = initAuswahlBox( 10, 10, 130, 20, zSchrift, ABSTYLE, { "Ordner", "Bild (.ltdb)", "Modell 2D (.m2)", "Sound (.gsl)" } );
    neuDateiName = initTextFeld( 10, 40, 130, 20, zSchrift, TextFeld::Style::TextFeld, "Datei Name" );
    neuDateiOk = initKnopf( 25, 70, 100, 20, zSchrift, Knopf::Style::Normal | Knopf::Style::Sichtbar, "Erstellen" );
    neuDateiOk->setMausEreignisParameter( this );
    neuDateiOk->setMausEreignis( kEDEditorNeuDateiOkME );
    neuDateiF->addMember( neuDateiName->getThis() );
    neuDateiF->addMember( neuDateiOk->getThis() );
    neuDateiF->addMember( neuDateiTyp->getThis() );
    aktion = 0;
    sichtbar = 0;
    alpha = 0;
    alpha2 = 0;
    tickVal = 0;
}

// Destruktor
KEDEditor::~KEDEditor()
{
    dateien->release();
    bildSeite->release();
    modelSeite->release();
    soundSeite->release();
    neuDateiF->release();
    neuDateiTyp->release();
    neuDateiName->release();
    neuDateiOk->release();
    neueDatei->release();
    dateiLöschen->release();
}

// nicht constant
int KEDEditor::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

bool KEDEditor::neuDateiOkME( MausEreignis & me )
{
    if( me.id == ME_RLinks )
    {
        neuDateiF->removeStyle( Fenster::Style::Sichtbar );
        aktion = 1;
    }
    return 1;
}

void KEDEditor::setDateiListe( RCArray< Text > * list )
{
    hauptScreen->lock();
    dateien->deSelect();
    while( dateien->getEintragAnzahl() )
        dateien->removeEintrag( 0 );
    int anz = list->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        dateien->addEintrag( list->get( i ) );
    bildSeite->setSichtbar( 0 );
    soundSeite->setSichtbar( 0 );
    modelSeite->setSichtbar( 0 );
    neuDateiF->removeStyle( Fenster::Style::Sichtbar );
    list->release();
    hauptScreen->unlock();
}

void KEDEditor::setBildListe( RCArray< Text > * list )
{
    soundSeite->setSichtbar( 0 );
    modelSeite->setSichtbar( 0 );
    bildSeite->setBildListe( list );
    bildSeite->setSichtbar( 1 );
}

void KEDEditor::setSoundListe( RCArray< Text > * list )
{
    modelSeite->setSichtbar( 0 );
    bildSeite->setSichtbar( 0 );
    soundSeite->setSoundListe( list );
    soundSeite->setSichtbar( 1 );
}

void KEDEditor::setModel2dListe( RCArray< Text > * list )
{
    bildSeite->setSichtbar( 0 );
    soundSeite->setSichtbar( 0 );
    modelSeite->setModelListe( list );
    modelSeite->setSichtbar( 1 );
}

void KEDEditor::setBild( Bild * b )
{
    bildSeite->setBild( b );
}

void KEDEditor::setSound( GSL::GSLSoundV * s )
{
    soundSeite->setSound( s );
}

void KEDEditor::setModel2d( Model2DData * d )
{
    modelSeite->setModel( d );
}

void KEDEditor::setSichtbar( bool s )
{
    sichtbar = s;
}

bool KEDEditor::tick( double tv )
{
    int ak = bildSeite->getAktion();
    switch( ak )
    {
    case 1: // Bild Auswählen
        aktion = 4;
        break;
    case 2: // Bild Löschen
        aktion = 5;
        break;
    case 3: // Importieren
        aktion = 6;
        break;
    case 4: // Datei Löschen
        aktion = 3;
        break;
    case 5: // Neue Datei
        neuDateiF->addStyle( Fenster::Style::Sichtbar );
        break;
    }
    ak = modelSeite->getAktion();
    switch( ak )
    {
    case 1: // Model Auswählen
        aktion = 7;
        break;
    case 2: // Model Löschen
        aktion = 8;
        break;
    case 3: // Model speichern
        aktion = 9;
        break;
    case 4: // Neues Modell
        aktion = 10;
        break;
    case 5: // Datei Löschen
        aktion = 3;
        break;
    case 6: // Neue Datei
        neuDateiF->addStyle( Fenster::Style::Sichtbar );
        break;
    }
    ak = soundSeite->getAktion();
    switch( ak )
    {
    case 1: // Sound Abspielen
        aktion = 11;
        break;
    case 2: // Sound Löschen
        aktion = 12;
        break;
    case 3: // Importieren
        aktion = 13;
        break;
    case 4: // Datei Löschen
        aktion = 3;
        break;
    case 5: // Neue Datei
        neuDateiF->addStyle( Fenster::Style::Sichtbar );
        break;
    }
    bool ret = dateien->tick( tv );
    ret |= bildSeite->tick( tv );
    ret |= soundSeite->tick( tv );
    ret |= modelSeite->tick( tv );
    ret |= neuDateiF->tick( tv );
    if( dateien->getAuswahl() < 0 )
    {
        ret |= neueDatei->tick( tv );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
            ret |= dateiLöschen->tick( tv );
    }
    tickVal += tv * 150;
    int val = 0;
    if( tickVal > 1 )
    {
        val = (int)tickVal;
        tickVal -= val;
    }
    else
        return ret;
    if( sichtbar && neuDateiF->hatStyle( Fenster::Style::Sichtbar ) && alpha2 > 100 )
    {
        if( alpha2 - val < 100 )
            alpha2 = 100;
        else
            alpha2 -= val;
        ret = 1;
    }
    if( sichtbar && neuDateiF->hatStyleNicht( Fenster::Style::Sichtbar ) && alpha2 < 255 )
    {
        if( alpha2 + val > 255 )
            alpha2 = 255;
        else
            alpha2 += val;
        ret = 1;
    }
    if( sichtbar && alpha != 255 )
    {
        if( alpha + val > 255 )
            alpha = 255;
        else
            alpha += val;
        ret = 1;
    }
    if( !sichtbar && alpha != 0 )
    {
        if( alpha - val < 0 )
            alpha = 0;
        else
            alpha -= val;
        ret = 1;
    }
    return ret;
}

void KEDEditor::doPublicMausEreignis( MausEreignis & me )
{
    if( !sichtbar )
        return;
    if( neuDateiF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuDateiF->doPublicMausEreignis( me );
        return;
    }
    int ausw = dateien->getAuswahl();
    dateien->doPublicMausEreignis( me );
    if( ausw != dateien->getAuswahl() && me.id == ME_RLinks )
    {
        if( dateien->getAuswahl() >= 0 )
            aktion = 2;
        else
            dateien->setAuswahl( ausw );
    }
    bildSeite->doPublicMausEreignis( me );
    soundSeite->doPublicMausEreignis( me );
    modelSeite->doPublicMausEreignis( me );
    if( dateien->getAuswahl() < 0 )
    {
        bool vera = me.verarbeitet;
        neueDatei->doPublicMausEreignis( me );
        if( !vera && me.verarbeitet &&me.id == ME_RLinks )
            neuDateiF->addStyle( Fenster::Style::Sichtbar );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
        {
            vera = me.verarbeitet;
            dateiLöschen->doPublicMausEreignis( me );
            if( !vera && me.verarbeitet &&me.id == ME_RLinks )
                aktion = 3;
        }
    }
}

void KEDEditor::doTastaturEreignis( TastaturEreignis & te )
{
    if( neuDateiF->hatStyle( Fenster::Style::Sichtbar ) )
    {
        neuDateiF->doTastaturEreignis( te );
        return;
    }
    modelSeite->doTastaturEreignis( te );
}

void KEDEditor::render( Bild & zRObj )
{
    zRObj.setAlpha( alpha );
    zRObj.setAlpha( alpha2 );
    dateien->render( zRObj );
    bildSeite->render( zRObj );
    modelSeite->render( zRObj );
    soundSeite->render( zRObj );
    if( dateien->getAuswahl() < 0 )
    {
        neueDatei->setPosition( 770, 440 );
        neueDatei->render( zRObj );
        if( dateien->getEintragAnzahl() > 0 && dateien->zEintrag( 0 )->zText()->istGleich( ".." ) )
        {
            dateiLöschen->setPosition( 770, 410 );
            dateiLöschen->render( zRObj );
        }
    }
    zRObj.releaseAlpha();
    neuDateiF->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
Text *KEDEditor::zBildImportPfad() const
{
    return bildSeite->zBildImportPfad();
}

Text *KEDEditor::zSoundImportPfad() const
{
    return soundSeite->zSoundImportPfad();
}

Text *KEDEditor::zDateiAuswahl() const
{
    if( !dateien->zEintrag( dateien->getAuswahl() ) )
        return 0;
    return dateien->zEintrag( dateien->getAuswahl() )->zText();
}

Text *KEDEditor::zSoundAuswahl() const
{
    return soundSeite->zSoundAuswahl();
}

Text *KEDEditor::zModel2dAuswahl() const
{
    return modelSeite->zModelAuswahl();
}

Model2DData *KEDEditor::getModelData() const
{
    return modelSeite->getModelData();
}

Text *KEDEditor::zNeuModelName() const
{
    return modelSeite->zNeuModelName();
}

Text *KEDEditor::zBildAuswahl() const
{
    return bildSeite->zBildAuswahl();
}

int KEDEditor::getNeuDateiTyp() const
{
    return neuDateiTyp->getAuswahl();
}

Text *KEDEditor::zNeuDateiName() const
{
    return neuDateiName->zText();
}

bool KEDEditor::istSichtbar() const
{
    return sichtbar;
}