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

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

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

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

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

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

void KEDBildSeite::setBild(Bild* b)
{
	uiFactory.initParam.bildschirm->lock();
	bildObj->setBild(b);
	uiFactory.initParam.bildschirm->unlock();
}

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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