KSG_SMP/SMP/Programm/Version/Version.cpp

#include "Version.h"
#include <Datei.h>
#include <Zeit.h>
#include <iostream>

// Inhalt der Version Klasse aus Version.h
// Konstruktor
Version::Version( Schrift *s, MSKlient *msc, RessourceBild *rb, AdminAccount *acc, Bildschirm *b )
    : Abschnitt( b )
{
    fenster = 0;
    this->msc = msc;
    account = acc;
    schrift = s;
    psc = 0;

    Array< ServerData * > list;
    if( msc->getPatchServerListe( &list ) )
    {
        int anz = list.getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
        {
            ServerData *server = list.get( i );
            if( !psc )
            {
                psc = new PSKlient( server->ip, server->adminPort );
                if( !psc->verbinden() )
                    psc = (PSKlient *)psc->release();
            }
            delete server;
        }
    }
    if( !psc )
        WMessageBox( 0, new Text( "Warnung" ), new Text( "Es wurde kein erreichbarer Patch Server gefunden. Es kann keine neue Version des Clients veröffentlicht werden." ), MB_ICONERROR );
    else
        psc->login( acc->zName()->getText(), acc->zPasswort()->getText() );
    f = new Fenster();
    f->setStyle( Fenster::Style::Sichtbar | Fenster::Style::Erlaubt | Fenster::Style::Rahmen | Fenster::Style::Titel | Fenster::Style::TitelBuffered );
    f->setRFarbe( 0xFFFFFFFF );
    f->setRBreite( 1 );
    f->setTitel( "Version" );
    f->setTSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    f->setTSFarbe( 0xFFFFFFFF );
    f->setTSSize( 12 );
    f->setTAfFarbe( 0x1000FF00 );
    f->setTAfStrength( -15 );
    f->setTRFarbe( 0xFFFFFFFF );
    f->setTRBreite( 1 );
    f->zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
    f->zTTextFeld()->setSize( 0, 20 );
    f->setSize( 700, 700 );

    gruppeF = new Fenster();
    gruppeF->setStyle( Fenster::Style::Sichtbar | Fenster::Style::Erlaubt );
    gruppeF->setSize( 680, 640 );
    gruppeF->setPosition( 10, 10 );
    f->addMember( dynamic_cast<Zeichnung *>( gruppeF->getThis() ) );

    gruppeT = new ObjTabelle();
    gruppeT->setStyle( ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::Rahmen | ObjTabelle::Style::VScroll );
    gruppeT->setVertikalKlickScroll( 10 );
    gruppeT->setMausEreignis( _ret1ME );
    gruppeT->setRahmenFarbe( 0xFFFFFFFF );
    gruppeT->setSize( 680, 600 );
    gruppeT->addSpalte( "Name" );
    gruppeT->addSpalte( "Pfad" );
    gruppeT->addSpalte( "Version" );
    gruppeT->addSpalte( "Auswahl" );
    gruppeT->setSpaltenBreite( 0, 285 );
    gruppeT->setSpaltenBreite( 1, 285 );
    gruppeT->setSpaltenBreite( 2, 68 );
    gruppeT->setSpaltenBreite( 3, 22 );
    gruppeT->addZeile( "Titel" );
    gruppeT->setZeilenHeight( 0, 20 );
    TextFeld *gTN = new TextFeld();
    gTN->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    gTN->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    gTN->setSchriftFarbe( 0xFFFFFFFF );
    gTN->setSchriftSize( 12 );
    gTN->setRahmenFarbe( 0xFFFFFFFF );
    gTN->setText( "Name" );
    gruppeT->setZeichnungZ( 0, 0, gTN );
    TextFeld *gTP = new TextFeld();
    gTP->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    gTP->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    gTP->setSchriftFarbe( 0xFFFFFFFF );
    gTP->setSchriftSize( 12 );
    gTP->setRahmenFarbe( 0xFFFFFFFF );
    gTP->setText( "Pfad" );
    gruppeT->setZeichnungZ( 1, 0, gTP );
    TextFeld *gTV = new TextFeld();
    gTV->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    gTV->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    gTV->setSchriftFarbe( 0xFFFFFFFF );
    gTV->setSchriftSize( 12 );
    gTV->setRahmenFarbe( 0xFFFFFFFF );
    gTV->setText( "Version" );
    gruppeT->setZeichnungZ( 2, 0, gTV );
    gruppeT->setMausEreignis( _ret1ME );
    gruppeT->setTastaturEreignis( _ret1TE );
    gruppeF->addMember( dynamic_cast<Zeichnung *>( gruppeT->getThis() ) );

    neuGruppeName = new TextFeld();
    neuGruppeName->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Buffered | TextFeld::Style::VCenter );
    neuGruppeName->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    neuGruppeName->setSchriftFarbe( 0xFFFFFFFF );
    neuGruppeName->setSchriftSize( 12 );
    neuGruppeName->setRahmenBreite( 1 );
    neuGruppeName->setRahmenFarbe( 0xFFFFFFFF );
    neuGruppeName->setAlphaFeldFarbe( 0x1000FF00 );
    neuGruppeName->setAlphaFeldStrength( -5 );
    neuGruppeName->setSize( 285, 20 );
    neuGruppeName->setPosition( 40, 610 );
    neuGruppeName->setMausEreignis( _ret1ME );
    neuGruppeName->setTastaturEreignis( _ret1TE );
    neuGruppeName->setText( "" );
    gruppeF->addMember( dynamic_cast<Zeichnung *>( neuGruppeName->getThis() ) );

    neuGruppePfad = new TextFeld();
    neuGruppePfad->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Buffered | TextFeld::Style::VCenter );
    neuGruppePfad->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    neuGruppePfad->setSchriftFarbe( 0xFFFFFFFF );
    neuGruppePfad->setSchriftSize( 12 );
    neuGruppePfad->setRahmenBreite( 1 );
    neuGruppePfad->setRahmenFarbe( 0xFFFFFFFF );
    neuGruppePfad->setAlphaFeldFarbe( 0x1000FF00 );
    neuGruppePfad->setAlphaFeldStrength( -5 );
    neuGruppePfad->setSize( 285, 20 );
    neuGruppePfad->setPosition( 330, 610 );
    neuGruppePfad->setMausEreignis( _ret1ME );
    neuGruppePfad->setTastaturEreignis( _ret1TE );
    neuGruppePfad->setText( "" );
    gruppeF->addMember( dynamic_cast<Zeichnung *>( neuGruppePfad->getThis() ) );

    neuGruppeK = new Knopf();
    neuGruppeK->setText( "" );
    neuGruppeK->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    neuGruppeK->setHintergrundBildZ( rb ? rb->get( "neu.png" ) : 0 );
    neuGruppeK->setPosition( 625, 610 );
    neuGruppeK->setSize( 20, 20 );
    neuGruppeK->setMausEreignisParameter( this );
    neuGruppeK->setMausEreignis( versionNeuGruppeKMausEreignis );
    gruppeF->addMember( dynamic_cast<Zeichnung *>( neuGruppeK->getThis() ) );

    systemF = new Fenster();
    systemF->setStyle( Fenster::Style::Erlaubt );
    systemF->setSize( 680, 640 );
    systemF->setPosition( 10, 10 );
    f->addMember( dynamic_cast<Zeichnung *>( systemF->getThis() ) );

    systemInit = new InitDatei();

    systemT = new ObjTabelle();
    systemT->setStyle( ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::Rahmen | ObjTabelle::Style::VScroll );
    systemT->setVertikalKlickScroll( 10 );
    systemT->setMausEreignis( _ret1ME );
    systemT->setRahmenFarbe( 0xFFFFFFFF );
    systemT->setSize( 680, 600 );
    systemT->addSpalte( "Name" );
    systemT->addSpalte( "Pfad" );
    systemT->addSpalte( "Auswahl" );
    systemT->setSpaltenBreite( 0, 150 );
    systemT->setSpaltenBreite( 1, 490 );
    systemT->setSpaltenBreite( 2, 22 );
    systemT->addZeile( "Titel" );
    systemT->setZeilenHeight( 0, 20 );
    TextFeld *sTN = new TextFeld();
    sTN->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    sTN->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    sTN->setSchriftFarbe( 0xFFFFFFFF );
    sTN->setSchriftSize( 12 );
    sTN->setRahmenFarbe( 0xFFFFFFFF );
    sTN->setText( "Name" );
    systemT->setZeichnungZ( 0, 0, sTN );
    TextFeld *sTP = new TextFeld();
    sTP->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    sTP->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    sTP->setSchriftFarbe( 0xFFFFFFFF );
    sTP->setSchriftSize( 12 );
    sTP->setRahmenFarbe( 0xFFFFFFFF );
    sTP->setText( "Pfad" );
    systemT->setZeichnungZ( 1, 0, sTP );
    systemT->setMausEreignis( _ret1ME );
    systemT->setTastaturEreignis( _ret1TE );
    systemF->addMember( dynamic_cast<Zeichnung *>( systemT->getThis() ) );

    neuSystemName = new TextFeld();
    neuSystemName->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Buffered | TextFeld::Style::VCenter );
    neuSystemName->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    neuSystemName->setSchriftFarbe( 0xFFFFFFFF );
    neuSystemName->setSchriftSize( 12 );
    neuSystemName->setRahmenBreite( 1 );
    neuSystemName->setRahmenFarbe( 0xFFFFFFFF );
    neuSystemName->setAlphaFeldFarbe( 0x1000FF00 );
    neuSystemName->setAlphaFeldStrength( -5 );
    neuSystemName->setSize( 490, 20 );
    neuSystemName->setPosition( 80, 610 );
    neuSystemName->setMausEreignis( _ret1ME );
    neuSystemName->setTastaturEreignis( _ret1TE );
    neuSystemName->setText( "" );
    systemF->addMember( dynamic_cast<Zeichnung *>( neuSystemName->getThis() ) );

    neuSystemK = new Knopf();
    neuSystemK->setText( "" );
    neuSystemK->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    neuSystemK->setHintergrundBildZ( rb ? rb->get( "neu.png" ) : 0 );
    neuSystemK->setPosition( 580, 610 );
    neuSystemK->setSize( 20, 20 );
    neuSystemK->setMausEreignisParameter( this );
    neuSystemK->setMausEreignis( versionNeuSystemKMausEreignis );
    systemF->addMember( dynamic_cast<Zeichnung *>( neuSystemK->getThis() ) );

    dateiF = new Fenster();
    dateiF->setStyle( Fenster::Style::Erlaubt );
    dateiF->setSize( 680, 640 );
    dateiF->setPosition( 10, 10 );
    f->addMember( dynamic_cast<Zeichnung *>( dateiF->getThis() ) );

    dateiT = new ObjTabelle();
    dateiT->setStyle( ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::Rahmen | ObjTabelle::Style::VScroll );
    dateiT->setVertikalKlickScroll( 10 );
    dateiT->setMausEreignis( _ret1ME );
    dateiT->setRahmenFarbe( 0xFFFFFFFF );
    dateiT->setSize( 680, 600 );
    dateiT->addSpalte( "Pfad" );
    dateiT->addSpalte( "Version" );
    dateiT->addSpalte( "Status" );
    dateiT->setSpaltenBreite( 0, 510 );
    dateiT->setSpaltenBreite( 1, 50 );
    dateiT->setSpaltenBreite( 2, 100 );
    dateiT->addZeile( "Titel" );
    dateiT->setZeilenHeight( 0, 20 );
    TextFeld *dTP = new TextFeld();
    dTP->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    dTP->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    dTP->setSchriftFarbe( 0xFFFFFFFF );
    dTP->setSchriftSize( 12 );
    dTP->setRahmenFarbe( 0xFFFFFFFF );
    dTP->setText( "Pfad" );
    dateiT->setZeichnungZ( 0, 0, dTP );
    TextFeld *dTV = new TextFeld();
    dTV->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    dTV->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    dTV->setSchriftFarbe( 0xFFFFFFFF );
    dTV->setSchriftSize( 12 );
    dTV->setRahmenFarbe( 0xFFFFFFFF );
    dTV->setText( "Version" );
    dateiT->setZeichnungZ( 1, 0, dTV );
    TextFeld *dTS = new TextFeld();
    dTS->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
    dTS->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    dTS->setSchriftFarbe( 0xFFFFFFFF );
    dTS->setSchriftSize( 12 );
    dTS->setRahmenFarbe( 0xFFFFFFFF );
    dTS->setText( "Status" );
    dateiT->setZeichnungZ( 2, 0, dTS );
    dateiF->addMember( dynamic_cast<Zeichnung *>( dateiT->getThis() ) );

    commit = new Knopf();
    commit->setStyle( Knopf::Style::Normal );
    commit->setText( "Veröffentlichen" );
    commit->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    commit->setMausEreignisParameter( this );
    commit->setMausEreignis( versionCommitMausEreignis );
    commit->setSize( 100, 20 );
    commit->setPosition( 290, 610 );
    dateiF->addMember( dynamic_cast<Zeichnung *>( commit->getThis() ) );

    fehlerF = new Fenster();
    fehlerF->setStyle( Fenster::Style::Erlaubt );
    fehlerF->setSize( 680, 640 );
    fehlerF->setPosition( 10, 10 );
    f->addMember( dynamic_cast<Zeichnung *>( fehlerF->getThis() ) );

    fehlerText = new TextFeld();
    fehlerText->setStyle( TextFeld::Style::Text );
    fehlerText->setSchriftZ( s ? dynamic_cast<Schrift *>( s->getThis() ) : 0 );
    fehlerText->setSchriftFarbe( 0xFFFFFFFF );
    fehlerText->setSchriftSize( 12 );
    fehlerText->setText( "" );
    fehlerText->setSize( 680, 650 );
    fehlerF->addMember( dynamic_cast<Zeichnung *>( fehlerText->getThis() ) );

    zurück = new Knopf();
    zurück->setText( "" );
    zurück->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    zurück->setHintergrundBildZ( rb ? rb->get( "zurück.png" ) : 0 );
    zurück->setPosition( 295, 650 );
    zurück->setSize( 20, 20 );
    zurück->setMausEreignisParameter( this );
    zurück->setMausEreignis( versionZurückMausEreignis );
    f->addMember( dynamic_cast<Zeichnung *>( zurück->getThis() ) );

    aktualisieren = new Knopf();
    aktualisieren->setText( "" );
    aktualisieren->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    aktualisieren->setHintergrundBildZ( rb ? rb->get( "neuladen.png" ) : 0 );
    aktualisieren->setPosition( 325, 650 );
    aktualisieren->setSize( 20, 20 );
    aktualisieren->setMausEreignisParameter( this );
    aktualisieren->setMausEreignis( versionAktualisierenMausEreignis );
    f->addMember( dynamic_cast<Zeichnung *>( aktualisieren->getThis() ) );

    speichern = new Knopf();
    speichern->setText( "" );
    speichern->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    speichern->setHintergrundBildZ( rb ? rb->get( "speichern.png" ) : 0 );
    speichern->setPosition( 355, 650 );
    speichern->setSize( 20, 20 );
    speichern->setMausEreignisParameter( this );
    speichern->setMausEreignis( versionSpeichernMausEreignis );
    f->addMember( dynamic_cast<Zeichnung *>( speichern->getThis() ) );

    weiter = new Knopf();
    weiter->setText( "" );
    weiter->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Hintergrund | Knopf::Style::HBild | Knopf::Style::HAlpha | Knopf::Style::KlickBuffer );
    weiter->setHintergrundBildZ( rb ? rb->get( "weiter.png" ) : 0 );
    weiter->setPosition( 385, 650 );
    weiter->setSize( 20, 20 );
    weiter->setMausEreignisParameter( this );
    weiter->setMausEreignis( versionWeiterMausEreignis );
    f->addMember( dynamic_cast<Zeichnung *>( weiter->getThis() ) );

    sName = new Text( "" );
    system = 0;

    if( rb )
        rb->release();
}

// Destruktor
Version::~Version()
{
    if( fenster )
    {
        fenster->removeMember( f );
        fenster->release();
    }
    account->release();
    msc->release();
    if( psc )
        psc->release();
    f->release();
    gruppeF->release();
    gruppeT->release();
    neuGruppeName->release();
    neuGruppePfad->release();
    neuGruppeK->release();
    systemF->release();
    systemInit->release();
    systemT->release();
    neuSystemName->release();
    neuSystemK->release();
    speichern->release();
    weiter->release();
    dateiF->release();
    dateiT->release();
    commit->release();
    aktualisieren->release();
    fehlerF->release();
    fehlerText->release();
    zurück->release();
    if( schrift )
        schrift->release();
    sName->release();
}

// privat
void Version::sucheDateien( const char *pfad, Array< FileInfo > &list )
{
    Datei *d = new Datei();
    d->setDatei( pfad );
    if( d->istOrdner() )
    {
        RCArray< Text > *liste = d->getDateiListe();
        int anzahl = d->getUnterdateiAnzahl();
        for( int i = 0; i < anzahl; i++ )
        {
            Text *p = new Text( pfad );
            p->append( "/" );
            p->append( liste->z( i )->getText() );
            sucheDateien( p->getText(), list );
            p->release();
        }
        liste->release();
    }
    d->release();
    Text *pf = new Text( pfad );
    pf->remove( systemInit->zWert( sName->getText() )->getText() );
    pf->remove( 0, 1 );
    if( !pf->getLength() )
    {
        pf->release();
        return;
    }
    bool gefunden = 0;
    int anz = list.getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        if( pf->istGleich( list.get( i ).path ) )
        {
            gefunden = 1;
            break;
        }
    }
    if( !gefunden )
    {
        dateiT->addZeile( "0" );
        TextFeld *pfad = new TextFeld();
        pfad->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
        pfad->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
        pfad->setSchriftFarbe( 0xFFFFFFFF );
        pfad->setSchriftSize( 12 );
        pfad->setRahmenFarbe( 0xFFFFFFFF );
        pfad->setText( pf->getText() );
        dateiT->setZeichnungZ( 0, dateiT->getZeilenAnzahl() - 1, pfad );
        TextFeld *version = new TextFeld();
        version->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
        version->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
        version->setSchriftFarbe( 0xFFFFFFFF );
        version->setSchriftSize( 12 );
        version->setRahmenFarbe( 0xFFFFFFFF );
        version->setText( "0" );
        dateiT->setZeichnungZ( 1, dateiT->getZeilenAnzahl() - 1, version );
        TextFeld *status = new TextFeld();
        status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
        status->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
        status->setSchriftFarbe( 0xFFFFFFFF );
        status->setSchriftSize( 12 );
        status->setRahmenFarbe( 0xFFFFFFFF );
        status->setText( "Neu" );
        dateiT->setZeichnungZ( 2, dateiT->getZeilenAnzahl() - 1, status );
    }
    pf->release();
}

// nicht constant
void Version::setFenster( Fenster *f )
{
    if( fenster )
        fenster->release();
    this->f->setPosition( f->getBreite() / 2 - this->f->getBreite() / 2, f->getHeight() / 2 - this->f->getHeight() / 2 );
    fenster = f;
}

void Version::setSichtbar( bool s )
{
    sichtbar = s;
    if( s )
        fenster->addMember( dynamic_cast<Zeichnung *>( f->getThis() ) );
    else
        fenster->removeMember( f );
}

bool Version::neuGruppeKMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        if( neuGruppeName->zText()->getLength() )
        {
            /*if( !pgDb->neueDateiGruppeErstellen( neuGruppeName->zText()->getText(), neuGruppePfad->zText()->getText() ) )
            {
                fehlerText->setText( "Es ist ein Fehler aufgetreten. Siehe in den Logdateien nach für nähere\nInformationen." );
                gruppeF->removeStyle( Fenster::Style::Sichtbar );
                weiter->removeStyle( Knopf::Style::Erlaubt );
                zurück->addStyle( Knopf::Style::Erlaubt );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                speichern->removeStyle( Knopf::Style::Erlaubt );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
            }
            else
            {
                neuGruppeName->setText( "" );
                neuGruppeName->setAuswahl( 0, 0 );
                neuGruppePfad->setText( "" );
                neuGruppePfad->setAuswahl( 0, 0 );
                aktualisierenMausEreignis( 0, me );
            }*/
            WMessageBox( 0, new Text( "Warnung" ), new Text( "Diese Funktion ist momentan nicht implementiert. Nehmen sie die Änderungen manuell in der Datenbank vor." ), MB_ICONERROR );
        }
    }
    return 1;
}

bool Version::auswahlKnopfMausEreignis( void *o, MausEreignis me )
{
    if( !o )
        return 0;
    if( me.id == ME_RLinks )
    {
        if( gruppeF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            for( int i = 1; i < gruppeT->getZeilenAnzahl(); i++ )
                ( (KontrollKnopf *)gruppeT->zZeichnung( 3, i ) )->removeStyle( KontrollKnopf::Style::Selected );
            weiter->addStyle( Knopf::Style::Erlaubt );
        }
        else if( systemF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            for( int i = 1; i < systemT->getZeilenAnzahl(); i++ )
                ( (KontrollKnopf *)systemT->zZeichnung( 2, i ) )->removeStyle( KontrollKnopf::Style::Selected );
            weiter->addStyle( Knopf::Style::Erlaubt );
        }
    }
    return 1;
}

bool Version::neuSystemKMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        if( neuSystemName->zText()->getLength() )
        {
            /*if( !pgDb->neuesSystemErstellen( neuSystemName->zText()->getText() ) )
            {
                fehlerText->setText( "Es ist ein Fehler aufgetreten. Siehe in den Logdateien nach für nähere\nInformationen." );
                systemF->removeStyle( Fenster::Style::Sichtbar );
                weiter->removeStyle( Knopf::Style::Erlaubt );
                zurück->addStyle( Knopf::Style::Erlaubt );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                speichern->removeStyle( Knopf::Style::Erlaubt );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
            }
            else
            {
                neuSystemName->setText( "" );
                neuSystemName->setAuswahl( 0, 0 );
                aktualisierenMausEreignis( 0, me );
            }*/
            WMessageBox( 0, new Text( "Warnung" ), new Text( "Diese Funktion ist momentan nicht implementiert. Nehmen sie die Änderungen manuell in der Datenbank vor." ), MB_ICONERROR );
        }
    }
    return 1;
}

bool Version::speichernMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        systemInit->removeAlle();
        for( int i = 1; i < systemT->getZeilenAnzahl(); i++ )
        {
            systemInit->addWert( ( (TextFeld *)systemT->zZeichnung( 0, i ) )->zText()->getText(),
                                 ( (TextFeld *)systemT->zZeichnung( 1, i ) )->zText()->getText() );
            systemInit->speichern();
        }
    }
    return 1;
}

bool Version::weiterMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        if( gruppeF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            for( int i = 1; i < gruppeT->getZeilenAnzahl(); i++ )
            {
                if( ( (KontrollKnopf *)gruppeT->zZeichnung( 3, i ) )->hatStyle( KontrollKnopf::Style::Selected ) )
                {
                    gruppe = TextZuInt( gruppeT->zZeilenName( i )->getText(), 10 );
                    Text *pfad = new Text( "data/" );
                    pfad->append( ( (TextFeld *)gruppeT->zZeichnung( 0, i ) )->getText() );
                    pfad->append( ".ini" );
                    systemInit->setPfad( pfad );
                    systemInit->removeAlle();
                    systemInit->laden();
                    gruppeF->removeStyle( Fenster::Style::Sichtbar );
                    systemF->addStyle( Fenster::Style::Sichtbar );
                    speichern->addStyle( Knopf::Style::Erlaubt );
                    aktualisieren->addStyle( Knopf::Style::Erlaubt );
                    weiter->removeStyle( Knopf::Style::Erlaubt );
                    zurück->addStyle( Knopf::Style::Erlaubt );
                    aktualisierenMausEreignis( 0, me );
                    return 1;
                }
            }
        }
        else if( systemF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            for( int i = 1; i < systemT->getZeilenAnzahl(); i++ )
            {
                if( ( (KontrollKnopf *)systemT->zZeichnung( 2, i ) )->hatStyle( KontrollKnopf::Style::Selected ) )
                {
                    sName->setText( ( (TextFeld *)systemT->zZeichnung( 0, i ) )->zText()->getText() );
                    system = TextZuInt( systemT->zZeilenName( i )->getText(), 10 );
                    systemF->removeStyle( Fenster::Style::Sichtbar );
                    speichern->removeStyle( Knopf::Style::Erlaubt );
                    aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                    weiter->removeStyle( Knopf::Style::Erlaubt );
                    zurück->addStyle( Knopf::Style::Erlaubt );
                    if( !systemInit->wertExistiert( sName->getText() ) )
                    {
                        fehlerText->setText( "Der Pfad wurde für dieses System noch nicht gesetzt." );
                        fehlerF->addStyle( Fenster::Style::Sichtbar );
                        return 1;
                    }
                    if( !DateiExistiert( systemInit->getWert( sName->getText() ) ) || !DateiIstVerzeichnis( systemInit->getWert( sName->getText() ) ) )
                    {
                        fehlerText->setText( "Unter dem angegebenem Pfad wurde keine Datei gefunden." );
                        fehlerF->addStyle( Fenster::Style::Sichtbar );
                        return 1;
                    }
                    aktualisieren->addStyle( Knopf::Style::Erlaubt );
                    dateiF->addStyle( Fenster::Style::Sichtbar );
                    aktualisierenMausEreignis( 0, me );
                    return 1;
                }
            }
        }
    }
    return 1;
}

bool Version::commitMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        /*if( !pgDb->adminHatRecht( account->getId(), Admin_Recht::LTCUpdate ) )
        {
            dateiF->removeStyle( Fenster::Style::Sichtbar );
            aktualisieren->removeStyle( Knopf::Style::Erlaubt );
            fehlerText->setText( "Du hast keine Berechtigung für diesen Vorgang." );
            fehlerF->addStyle( Fenster::Style::Sichtbar );
            zurück->addStyle( Knopf::Style::Erlaubt );
            return 1;
        }
        if( pgDb->sindPatchServerOnline() )
        {
            dateiF->removeStyle( Fenster::Style::Sichtbar );
            aktualisieren->removeStyle( Knopf::Style::Erlaubt );
            fehlerText->setText( "Es müssen zunächst alle Patchserver herunterfahren." );
            fehlerF->addStyle( Fenster::Style::Sichtbar );
            zurück->addStyle( Knopf::Style::Erlaubt );
            return 1;
        }*/
        aktualisierenMausEreignis( 0, me );
        bool gU = 0;
        for( int i = 1; i < dateiT->getZeilenAnzahl(); i++ )
        {
            if( ( (TextFeld *)dateiT->zZeichnung( 2, i ) )->zText()->istGleich( "Veraltet" ) )
            { // datei ist Veraltet
                Text *pfad = new Text( systemInit->zWert( sName->getText() )->getText() );
                pfad->append( "/" );
                pfad->append( ( (TextFeld *)dateiT->zZeichnung( 0, i ) )->zText()->getText() );
                Datei *d = new Datei();
                d->setDatei( pfad );
                Zeit *zeit = d->getLastChange();
                if( !psc || !psc->updateFile( ( (TextFeld *)dateiT->zZeichnung( 0, i ) )->zText()->getText(), 1, zeit, system, gruppe ) )
                {
                    dateiF->removeStyle( Fenster::Style::Sichtbar );
                    aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                    if( !psc )
                        fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                    else
                        fehlerText->setText( psc->getLetzterFehler() );
                    fehlerF->addStyle( Fenster::Style::Sichtbar );
                    zurück->addStyle( Knopf::Style::Erlaubt );
                    if( zeit )
                        zeit->release();
                    d->release();
                    return 1;
                }
                if( zeit )
                    zeit->release();
                d->release();
                gU = 1;
            }
            else if( ( (TextFeld *)dateiT->zZeichnung( 2, i ) )->zText()->istGleich( "Gelöscht" ) )
            { // datei ist Gelöscht
                if( !psc || !psc->updateFile( ( (TextFeld *)dateiT->zZeichnung( 0, i ) )->zText()->getText(), 0, 0, system, gruppe ) )
                {
                    dateiF->removeStyle( Fenster::Style::Sichtbar );
                    aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                    if( !psc )
                        fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                    else
                        fehlerText->setText( psc->getLetzterFehler() );
                    fehlerF->addStyle( Fenster::Style::Sichtbar );
                    zurück->addStyle( Knopf::Style::Erlaubt );
                    return 1;
                }
                gU = 1;
            }
            else if( ( (TextFeld *)dateiT->zZeichnung( 2, i ) )->zText()->istGleich( "Neu" ) )
            { // datei ist Neu
                Text *pfad = new Text( systemInit->zWert( sName->getText() )->getText() );
                pfad->append( "/" );
                pfad->append( ( (TextFeld *)dateiT->zZeichnung( 0, i ) )->zText()->getText() );
                Datei *d = new Datei();
                d->setDatei( pfad );
                Zeit *zeit = d->getLastChange();
                if( !psc || !psc->updateFile( ( (TextFeld *)dateiT->zZeichnung( 0, i ) )->zText()->getText(), 2, zeit, system, gruppe ) )
                {
                    dateiF->removeStyle( Fenster::Style::Sichtbar );
                    aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                    if( !psc )
                        fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                    else
                        fehlerText->setText( psc->getLetzterFehler() );
                    fehlerF->addStyle( Fenster::Style::Sichtbar );
                    zurück->addStyle( Knopf::Style::Erlaubt );
                    if( zeit )
                        zeit->release();
                    d->release();
                    return 1;
                }
                if( zeit )
                    zeit->release();
                d->release();
                gU = 1;
            }
        }
        if( gU )
        {
            if( !psc || !psc->dateiGruppeUpdate( gruppe ) )
            {
                dateiF->removeStyle( Fenster::Style::Sichtbar );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                if( !psc )
                    fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                else
                    fehlerText->setText( psc->getLetzterFehler() );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
                zurück->addStyle( Knopf::Style::Erlaubt );
                return 1;
            }
        }
        aktualisierenMausEreignis( 0, me );
    }
    return 1;
}

bool Version::aktualisierenMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        if( gruppeF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            if( !psc )
            {
                gruppeF->removeStyle( Fenster::Style::Sichtbar );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
                zurück->addStyle( Knopf::Style::Erlaubt );
                return 1;
            }
            for( int i = 1; i < gruppeT->getZeilenAnzahl(); )
                gruppeT->removeZeile( i );
            Array< FileGroupInfo * > list;
            psc->getFileGroupInfoList( &list );
            int anz = list.getEintragAnzahl();
            for( int i = 0; i < anz; i++ )
            {
                FileGroupInfo *fileGroup = list.get( i );
                Text *zeile = new Text( "" );
                zeile->append( fileGroup->id );
                gruppeT->addZeile( i + 1, zeile );
                TextFeld *name = new TextFeld();
                name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                name->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                name->setSchriftFarbe( 0xFFFFFFFF );
                name->setSchriftSize( 12 );
                name->setRahmenFarbe( 0xFFFFFFFF );
                name->setText( fileGroup->name );
                gruppeT->setZeichnungZ( 0, i + 1, name );
                TextFeld *pfad = new TextFeld();
                pfad->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                pfad->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                pfad->setSchriftFarbe( 0xFFFFFFFF );
                pfad->setSchriftSize( 12 );
                pfad->setRahmenFarbe( 0xFFFFFFFF );
                pfad->setText( fileGroup->path );
                gruppeT->setZeichnungZ( 1, i + 1, pfad );
                TextFeld *version = new TextFeld();
                version->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                version->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                version->setSchriftFarbe( 0xFFFFFFFF );
                version->setSchriftSize( 12 );
                version->setRahmenFarbe( 0xFFFFFFFF );
                version->setText( Text( fileGroup->version ) );
                gruppeT->setZeichnungZ( 2, i + 1, version );
                KontrollKnopf *auswahl = new KontrollKnopf();
                auswahl->setStyle( KontrollKnopf::Style::Sichtbar | KontrollKnopf::Style::Erlaubt | KontrollKnopf::Style::KlickBuffer | KontrollKnopf::Style::Rahmen );
                auswahl->loadData( "data/bilder/icons.ltdb" );
                auswahl->setMausEreignisParameter( this );
                auswahl->setMausEreignis( versionAuswahlKnopfMausEreignis );
                auswahl->setRahmenFarbe( 0xFFFFFFFF );
                gruppeT->setZeichnungZ( 3, i + 1, auswahl );
                delete fileGroup;
            }
        }
        else if( systemF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            if( !psc )
            {
                gruppeF->removeStyle( Fenster::Style::Sichtbar );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
                zurück->addStyle( Knopf::Style::Erlaubt );
                return 1;
            }
            for( int i = 1; i < systemT->getZeilenAnzahl(); )
                systemT->removeZeile( i );
            Array< SystemInfo > list;
            psc->getSystemInfoList( &list );
            int anz = list.getEintragAnzahl();
            for( int i = 0; i < anz; i++ )
            {
                SystemInfo system = list.get( i );
                Text *zeile = new Text( "" );
                zeile->append( system.id );
                systemT->addZeile( i + 1, zeile );
                TextFeld *name = new TextFeld();
                name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                name->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                name->setSchriftFarbe( 0xFFFFFFFF );
                name->setSchriftSize( 12 );
                name->setRahmenFarbe( 0xFFFFFFFF );
                name->setText( system.name );
                systemT->setZeichnungZ( 0, i + 1, name );
                TextFeld *pfad = new TextFeld();
                pfad->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                pfad->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                pfad->setText( "" );
                if( systemInit->wertExistiert( system.name ) )
                    pfad->setText( systemInit->zWert( (char *)system.name )->getText() );
                pfad->setSchriftFarbe( 0xFFFFFFFF );
                pfad->setSchriftSize( 12 );
                pfad->setRahmenFarbe( 0xFFFFFFFF );
                systemT->setZeichnungZ( 1, i + 1, pfad );
                KontrollKnopf *auswahl = new KontrollKnopf();
                auswahl->setStyle( KontrollKnopf::Style::Sichtbar | KontrollKnopf::Style::Erlaubt | KontrollKnopf::Style::KlickBuffer | KontrollKnopf::Style::Rahmen );
                auswahl->loadData( "data/bilder/icons.ltdb" );
                auswahl->setMausEreignisParameter( this );
                auswahl->setMausEreignis( versionAuswahlKnopfMausEreignis );
                auswahl->setRahmenFarbe( 0xFFFFFFFF );
                systemT->setZeichnungZ( 2, i + 1, auswahl );
            }
        }
        else if( dateiF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            if( !psc )
            {
                gruppeF->removeStyle( Fenster::Style::Sichtbar );
                aktualisieren->removeStyle( Knopf::Style::Erlaubt );
                fehlerText->setText( "Es wurde kein erreichbarer Patch Server gefunden." );
                fehlerF->addStyle( Fenster::Style::Sichtbar );
                zurück->addStyle( Knopf::Style::Erlaubt );
                return 1;
            }
            for( int i = 1; i < dateiT->getZeilenAnzahl(); )
                dateiT->removeZeile( i );
            Array< FileInfo > list;
            psc->getFileInfoList( system, gruppe, &list );
            int anz = list.getEintragAnzahl();
            for( int i = 0; i < anz; i++ )
            {
                FileInfo info = list.get( i );
                Text *zeile = new Text( "" );
                zeile->append( info.id );
                dateiT->addZeile( i + 1, zeile );
                TextFeld *pfad = new TextFeld();
                pfad->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
                pfad->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                pfad->setSchriftFarbe( 0xFFFFFFFF );
                pfad->setSchriftSize( 12 );
                pfad->setRahmenFarbe( 0xFFFFFFFF );
                pfad->setText( info.path );
                dateiT->setZeichnungZ( 0, i + 1, pfad );
                TextFeld *version = new TextFeld();
                version->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
                version->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                version->setSchriftFarbe( 0xFFFFFFFF );
                version->setSchriftSize( 12 );
                version->setRahmenFarbe( 0xFFFFFFFF );
                version->setText( Text( info.version ) );
                dateiT->setZeichnungZ( 1, i + 1, version );
                TextFeld *status = new TextFeld();
                status->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Center );
                status->setSchriftZ( schrift ? dynamic_cast<Schrift *>( schrift->getThis() ) : 0 );
                status->setSchriftSize( 12 );
                status->setRahmenFarbe( 0xFFFFFFFF );
                status->setText( "Aktuell" );
                status->setSchriftFarbe( 0xFF00FF00 );
                Text *pf = new Text( systemInit->zWert( sName->getText() )->getText() );
                if( pf->getText()[ pf->getLength() - 1 ] != '/' )
                    pf->append( "/" );
                pf->append( (char *)info.path );
                if( !DateiExistiert( pf->getText() ) )
                {
                    status->setText( "Gelöscht" );
                    status->setSchriftFarbe( 0xFFFF0000 );
                }
                else
                {
                    Datei *d = new Datei();
                    d->setDatei( pf->getText() );
                    if( !d->istOrdner() )
                    {
                        Zeit *lä = d->getLastChange();
                        if( !lä->istGleich( "y-m-d h:i:s", info.time ) )
                        {
                            status->setText( "Veraltet" );
                            status->setSchriftFarbe( 0xFFFFFF00 );
                        }
                        lä->release();
                    }
                    d->release();
                }
                pf->release();
                dateiT->setZeichnungZ( 2, i + 1, status );
            }
            sucheDateien( systemInit->zWert( sName->getText() )->getText(), list );
        }
    }
    return 1;
}

bool Version::zurückMausEreignis( void *o, MausEreignis me )
{
    if( me.id == ME_RLinks )
    {
        if( fehlerF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            fehlerF->removeStyle( Fenster::Style::Sichtbar );
            dateiF->removeStyle( Fenster::Style::Sichtbar );
            systemF->removeStyle( Fenster::Style::Sichtbar );
            zurück->removeStyle( Knopf::Style::Erlaubt );
            speichern->removeStyle( Knopf::Style::Erlaubt );
            weiter->removeStyle( Knopf::Style::Erlaubt );
            aktualisieren->addStyle( Knopf::Style::Erlaubt );
            gruppeF->addStyle( Fenster::Style::Sichtbar );
            aktualisierenMausEreignis( 0, me );
        }
        else if( dateiF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            fehlerF->removeStyle( Fenster::Style::Sichtbar );
            dateiF->removeStyle( Fenster::Style::Sichtbar );
            gruppeF->removeStyle( Fenster::Style::Sichtbar );
            weiter->removeStyle( Knopf::Style::Erlaubt );
            zurück->addStyle( Knopf::Style::Erlaubt );
            speichern->addStyle( Knopf::Style::Erlaubt );
            aktualisieren->addStyle( Knopf::Style::Erlaubt );
            systemF->addStyle( Fenster::Style::Sichtbar );
            aktualisierenMausEreignis( 0, me );
        }
        else if( systemF->hatStyle( Fenster::Style::Sichtbar ) )
        {
            fehlerF->removeStyle( Fenster::Style::Sichtbar );
            dateiF->removeStyle( Fenster::Style::Sichtbar );
            systemF->removeStyle( Fenster::Style::Sichtbar );
            zurück->removeStyle( Knopf::Style::Erlaubt );
            speichern->removeStyle( Knopf::Style::Erlaubt );
            weiter->removeStyle( Knopf::Style::Erlaubt );
            aktualisieren->addStyle( Knopf::Style::Erlaubt );
            gruppeF->addStyle( Fenster::Style::Sichtbar );
            aktualisierenMausEreignis( 0, me );
        }
    }
    return 1;
}

void Version::commitAll()
{
    MausEreignis me;
    me.id = ME_RLinks;
    me.verarbeitet = 0;
    aktualisierenMausEreignis( aktualisieren, me );
    for( int i = 1; i < gruppeT->getZeilenAnzahl(); i++ )
    {
        std::cout << "Gruppe: " << ( (TextFeld *)gruppeT->zZeichnung( 0, i ) )->zText()->getText() << ": \n";
        Zeichnung *z = gruppeT->zZeichnung( 3, i ); // auswahl knopf
        me.mx = z->getX();
        me.my = z->getY();
        me.verarbeitet = 0;
        z->doPublicMausEreignis( me );
        me.verarbeitet = 0;
        weiterMausEreignis( weiter, me );
        aktualisierenMausEreignis( aktualisieren, me );
        for( int j = 1; j < systemT->getZeilenAnzahl(); j++ )
        {
            std::cout << ( (TextFeld *)systemT->zZeichnung( 0, j ) )->zText()->getText() << ": ";
            Zeichnung *z = systemT->zZeichnung( 2, j ); // auswahl knopf
            me.mx = z->getX();
            me.my = z->getY();
            me.verarbeitet = 0;
            z->doPublicMausEreignis( me );
            me.verarbeitet = 0;
            weiterMausEreignis( weiter, me );
            aktualisierenMausEreignis( aktualisieren, me );
            bool needCommit = 0;
            for( int k = 1; k < dateiT->getZeilenAnzahl(); k++ )
                needCommit |= !( (TextFeld *)dateiT->zZeichnung( 2, k ) )->zText()->istGleich( "Aktuell" );
            if( needCommit )
            {
                commitMausEreignis( commit, me );
                std::cout << "Commit successfull\n";
            }
            else
                std::cout << "Unchanged\n";
            zurückMausEreignis( zurück, me );
        }
        zurückMausEreignis( zurück, me );
    }
}

// constant
InitDatei *Version::getSystemInit() const
{
    return dynamic_cast<InitDatei *>( systemInit->getThis() );
}


// Ereignisse
bool versionNeuGruppeKMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->neuGruppeKMausEreignis( o, me );
}

bool versionAuswahlKnopfMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->auswahlKnopfMausEreignis( o, me );
}

bool versionNeuSystemKMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->neuSystemKMausEreignis( o, me );
}

bool versionSpeichernMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->speichernMausEreignis( o, me );
}

bool versionWeiterMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->weiterMausEreignis( o, me );
}

bool versionCommitMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->commitMausEreignis( o, me );
}

bool versionAktualisierenMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->aktualisierenMausEreignis( o, me );
}

bool versionZurückMausEreignis( void *p, void *o, MausEreignis me )
{
    if( !p )
        return 0;
    return ( (Version *)p )->zurückMausEreignis( o, me );
}