KSG_SMP/SMP/Programm/Version/Version.cpp

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

// 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->getThis() );
	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( 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->getThis() );
	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->getThis() );
	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->getThis() );
	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( 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->getThis() );
	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( 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->getThis() );
	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( 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->get( "neu.png" ) );
	neuGruppeK->setPosition( 625, 610 );
	neuGruppeK->setSize( 20, 20 );
	neuGruppeK->setMausEreignisParameter( this );
	neuGruppeK->setMausEreignis( versionNeuGruppeKMausEreignis );
	gruppeF->addMember( neuGruppeK->getThis() );

	systemF = new Fenster();
	systemF->setStyle( Fenster::Style::Erlaubt );
	systemF->setSize( 680, 640 );
	systemF->setPosition( 10, 10 );
	f->addMember( 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->getThis() );
	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->getThis() );
	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( 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->getThis() );
	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( 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->get( "neu.png" ) );
	neuSystemK->setPosition( 580, 610 );
	neuSystemK->setSize( 20, 20 );
	neuSystemK->setMausEreignisParameter( this );
	neuSystemK->setMausEreignis( versionNeuSystemKMausEreignis );
	systemF->addMember( neuSystemK->getThis() );

	dateiF = new Fenster();
	dateiF->setStyle( Fenster::Style::Erlaubt );
	dateiF->setSize( 680, 640 );
	dateiF->setPosition( 10, 10 );
	f->addMember( 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->getThis() );
	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->getThis() );
	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->getThis() );
	dTS->setSchriftFarbe( 0xFFFFFFFF );
	dTS->setSchriftSize( 12 );
	dTS->setRahmenFarbe( 0xFFFFFFFF );
	dTS->setText( "Status" );
	dateiT->setZeichnungZ( 2, 0, dTS );
	dateiF->addMember( dateiT->getThis() );

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

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

	fehlerText = new TextFeld();
	fehlerText->setStyle( TextFeld::Style::Text );
	fehlerText->setSchriftZ( s->getThis() );
	fehlerText->setSchriftFarbe( 0xFFFFFFFF );
	fehlerText->setSchriftSize( 12 );
	fehlerText->setText( "" );
	fehlerText->setSize( 680, 650 );
	fehlerF->addMember( 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->get( "zurück.png" ) );
	zurück->setPosition( 295, 650 );
	zurück->setSize( 20, 20 );
	zurück->setMausEreignisParameter( this );
	zurück->setMausEreignis( versionZurückMausEreignis );
	f->addMember( 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->get( "neuladen.png" ) );
	aktualisieren->setPosition( 325, 650 );
	aktualisieren->setSize( 20, 20 );
	aktualisieren->setMausEreignisParameter( this );
	aktualisieren->setMausEreignis( versionAktualisierenMausEreignis );
	f->addMember( 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->get( "speichern.png" ) );
	speichern->setPosition( 355, 650 );
	speichern->setSize( 20, 20 );
	speichern->setMausEreignisParameter( this );
	speichern->setMausEreignis( versionSpeichernMausEreignis );
	f->addMember( 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->get( "weiter.png" ) );
	weiter->setPosition( 385, 650 );
	weiter->setSize( 20, 20 );
	weiter->setMausEreignisParameter( this );
	weiter->setMausEreignis( versionWeiterMausEreignis );
	f->addMember( weiter->getThis() );

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

	rb->release();
	ref = 1;
}

// 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();
	schrift->release();
	sName->release();
}

// privat
void Version::sucheDateien( const char *pfad, RCArray< ReferenceCounting< 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.z( 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->getThis() );
		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->getThis() );
		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->getThis() );
		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( 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->getThis() );
				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->getThis() );
				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->getThis() );
				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 );
            RCArray< ReferenceCounting< std::pair< int, Text > > > list;
			psc->getSystemInfoList( &list );
            int anz = list.getEintragAnzahl();
			for( int i = 0; i < anz; i++ )
			{
                ReferenceCounting< std::pair< int, Text > > *system = list.z( i );
				Text *zeile = new Text( "" );
				zeile->append( system->first );
				systemT->addZeile( i + 1, zeile );
				TextFeld *name = new TextFeld();
				name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VCenter );
				name->setSchriftZ( schrift->getThis() );
				name->setSchriftFarbe( 0xFFFFFFFF );
				name->setSchriftSize( 12 );
				name->setRahmenFarbe( 0xFFFFFFFF );
				name->setText( system->second );
				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->getThis() );
				pfad->setText( "" );
				if( systemInit->wertExistiert( system->second ) )
					pfad->setText( systemInit->zWert( (char*)system->second )->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 );
            RCArray< ReferenceCounting< FileInfo > > list;
            psc->getFileInfoList( system, gruppe, &list );
            int anz = list.getEintragAnzahl();
			for( int i = 0; i < anz; i++ )
			{
                ReferenceCounting< FileInfo > *info = list.z( 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->getThis() );
				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->getThis() );
				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->getThis() );
				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->getThis() ) )
				{
					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;
}

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

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

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


// 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 );
}