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