KSG-Client/KSGClient/NachLogin/Chat/ChatLeiste.cpp

#include "ChatLeiste.h"
#include "..\..\Global\Initialisierung.h"
#include <Bild.h>
#include <Rahmen.h>
#include <Punkt.h>
#include "..\..\Global\Variablen.h"
#include <DateiSystem.h>
#include <ToolTip.h>
#include <GSLDateiV.h>
#include <Globals.h>
#include <InitDatei.h>

typedef GSL::GSLDateiV* (*GetGSLDatei)();

// Inhalt der Chat Klasse aus ChatLeiste.h
// Konstruktor
Chat::Chat()
	: ReferenceCounter()
{
	Bild* minimierenBild = bilder->get("data/client/bilder/chat.ltdb/minimieren.png");
	Bild* closeBild = bilder->get("data/client/bilder/chat.ltdb/entfernen.png");
	rahmen = new LRahmen();
	rahmen->setAlpha(1);
	rahmen->setFarbe(0xFFFFFFFF);
	rahmen->setRamenBreite(1);
	verlauf = initTextFeld(7, 7, 184, 210, TextFeld::Style::TextGebiet, "");
	verlauf->removeStyle(TextFeld::Style::Erlaubt);
	verlauf->updateVScroll();
	nachricht = initTextFeld(1, 220, 198, 20, TextFeld::Style::TextFeld, "");
	initToolTip(nachricht, "Nachricht senden.");
	name = initTextFeld(1, 250, 198, 29, TextFeld::Style::Text | TextFeld::Style::VCenter, "");
	minimieren = initKnopf(159, 255, 20, 20, 0, "");
	minimieren->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	minimieren->setHintergrundBildZ(minimierenBild);
	initToolTip(minimieren, "Fenster einklappen.");
	close = initKnopf(179, 255, 20, 20, 0, "");
	close->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	close->setHintergrundBildZ(closeBild);
	initToolTip(close, "Fenster schließen.");
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	admin = 0;
	tickVal = 0;
	sichtbar = 1;
	breite = 0;
	höhe = 30;
	animation = 1;
	rend = 0;
	msgSound = 0;
	HMODULE dll = Framework::getDLLRegister()->ladeDLL("GSL.dll", "data/bin/GSL.dll");
	if (dll)
	{
		GetGSLDatei getGSLDatei = (GetGSLDatei)GetProcAddress(dll, "getGSLDatei");
		if (getGSLDatei)
		{
			GSL::GSLDateiV* sDat = getGSLDatei();
			sDat->setDatei("data/sounds/popup.gsl");
			sDat->leseDaten();
			msgSound = sDat->getSound("chat.wav");
			sDat->release();
			if (msgSound)
				msgSound->setVolume(0xFFFF, 0xFFFF);
		}
		if (!msgSound)
			Framework::getDLLRegister()->releaseDLL("GSL.dll");
	}
}

// Destruktor
Chat::~Chat()
{
	if (msgSound)
	{
		msgSound->release();
		Framework::getDLLRegister()->releaseDLL("GSL.dll");
	}
	rahmen->release();
	verlauf = (TextFeld*)verlauf->release();
	nachricht = (TextFeld*)nachricht->release();
	name = (TextFeld*)name->release();
	minimieren = (Knopf*)minimieren->release();
	close = (Knopf*)close->release();
}

// nicht constant
void Chat::setSichtbar(bool sichtbar)
{
	if (sichtbar)
		animation = 2;
	else
		animation = 3;
	this->sichtbar = sichtbar;
}

void Chat::entfernen()
{
	animation = 4;
}

void Chat::addNachricht(const char* txt)
{
	int sound = userOptions->wertExistiert("GUISound") ? (int)*userOptions->zWert("GUISound") : 100;
	if (msgSound)
	{
		msgSound->setVolume((int)((sound / 100.0) * 0xFFFF), (int)((sound / 100.0) * 0xFFFF));
		msgSound->playSound();
	}
	Text* n = new Text(txt);
	verlauf->zTextRenderer()->textFormatieren(n, verlauf->getBreite() - 20);
	if (n->getText()[n->getLength() - 1] != '\n')
		n->append("\n");
	verlauf->zText()->append(dynamic_cast<Text*>(n->getThis()));
	verlauf->setSchriftFarbe(verlauf->zText()->getLength() - n->getLength(), verlauf->zText()->getLength(), 0xFFFFFFFF);
	n->release();
	if (animation != 4)
		animation = 2;
	verlauf->updateVScroll();
	rend = 1;
}

void Chat::setAdmin()
{
	admin = 1;
	rend = 1;
}

void Chat::addSpieler(int accountId)
{
	// nur bei chatroom
}

void Chat::removeSpieler(int accountId)
{
	// nur bei chatroom
}

bool Chat::tick(double tickVal)
{
	// virtual
	return 0;
}

void Chat::doPublicMausEreignis(MausEreignis& me)
{
	// virtual
}

void Chat::doTastaturEreignis(TastaturEreignis& te)
{
	// virtual
}

void Chat::render(int x, Bild& zRObj)
{
	// virtual
}

// constant
TextFeld* Chat::getName() const
{
	return dynamic_cast<TextFeld*>(name->getThis());
}

TextFeld* Chat::zName() const
{
	return name;
}

int Chat::getAccountId() const
{
	// nur bei chat
	return 0;
}

int Chat::getChatroomId() const
{
	// nur bei chatroom
	return 0;
}

int Chat::getBreite() const
{
	return breite;
}

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

// Inhalt der ChatFenster Klasse aus ChatLeiste.h
// Konstruktor
ChatFenster::ChatFenster(int accountId)
	: Chat()
{
	this->accountId = accountId;
	name->setTextZ(infoClient->getSpielerName(accountId));
}

// Destruktor
ChatFenster::~ChatFenster()
{

}

// nicht constant
bool ChatFenster::tick(double tickVal)
{
	rend |= close->tick(tickVal);
	rend |= minimieren->tick(tickVal);
	rend |= verlauf->tick(tickVal);
	rend |= nachricht->tick(tickVal);
	if (!animation)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	this->tickVal += tickVal * 300;
	int val = (int)this->tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	if (val > 10)
		val = 10;
	this->tickVal -= val;
	switch (animation)
	{
	case 1: // erstellen
	case 2: // ausfahren
		if (breite == 200)
		{
			höhe += val;
			if (höhe > 280)
			{
				höhe = 280;
				animation = 0;
			}
		}
		else
		{
			breite += val;
			if (breite > 200)
				breite = 200;
		}
		rend = 1;
		break;
	case 3: // einfahren
		if (höhe == 30)
		{
			breite -= val;
			if (breite < 100)
			{
				breite = 100;
				animation = 0;
			}
		}
		else
		{
			höhe -= val;
			if (höhe < 30)
				höhe = 30;
		}
		rend = 1;
		break;
	case 4: // close
		if (höhe == 30)
		{
			breite -= val;
			if (breite < 0)
			{
				nachLogin->zChatLeiste()->removeChat(this); // delete this
				return 1;
			}
		}
		else
		{
			höhe -= val;
			if (höhe < 30)
				höhe = 30;
		}
		rend = 1;
		break;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void ChatFenster::doPublicMausEreignis(MausEreignis& me)
{
	bool tmp = me.verarbeitet;
	if (me.mx < 0 || me.mx > breite || me.my < 280 - höhe || animation)
		me.verarbeitet = 1;
	verlauf->doPublicMausEreignis(me);
	bool vera = me.verarbeitet;
	minimieren->doPublicMausEreignis(me);
	int aktion = me.verarbeitet && !vera ? 1 : 0;
	close->doPublicMausEreignis(me);
	if (!aktion)
		aktion = me.verarbeitet && !vera ? 2 : 0;
	nachricht->doPublicMausEreignis(me);
	if (me.mx < 0 || me.mx > breite || me.my < 280 - höhe || animation)
	{
		me.verarbeitet = tmp;
		return;
	}
	if (!aktion && !sichtbar && !vera)
	{
		if (me.mx < breite && me.mx > 0 && me.my > 250 && me.my < 280)
			aktion = 3;
	}
	switch (aktion)
	{
	case 1: // einfahren
		if (me.id == ME_RLinks)
			this->setSichtbar(0);
		break;
	case 2: // close
		if (me.id == ME_RLinks)
			animation = 4;
		break;
	case 3: // ausfahren
		if (me.id == ME_RLinks)
			this->setSichtbar(1);
		break;
	}
}

void ChatFenster::doTastaturEreignis(TastaturEreignis& te)
{
	bool tmp = te.verarbeitet;
	if (animation)
		te.verarbeitet = 1;
	nachricht->doTastaturEreignis(te);
	int aktion = te.verarbeitet && !tmp ? 1 : 0;
	if (animation)
	{
		te.verarbeitet = tmp;
		return;
	}
	switch (aktion)
	{
	case 1:
		if (te.id == TE_Release && te.taste == T_Enter)
		{
			if (!nachricht->zText()->getLength())
				break;
			nachricht->zText()->remove("\n");
			if (chatClient->chatNachricht(accountId, nachricht->zText()->getText()))
			{
				Text* n = new Text(nachricht->zText()->getText());
				verlauf->zTextRenderer()->textFormatieren(n, verlauf->getBreite() - 15);
				if (n->getText()[n->getLength() - 1] != '\n')
					n->append("\n");
				verlauf->zText()->append(n->getText());
				verlauf->setSchriftFarbe(verlauf->zText()->getLength() - n->getLength(), verlauf->zText()->getLength(), 0xFF00FF00);
				n->release();
				verlauf->updateVScroll();
				nachricht->setText("");
				nachricht->setAuswahl(0, 0);
				rend = 1;
			}
		}
		break;
	}
}

void ChatFenster::render(int xPos, Bild& zRObj)
{
	int x = xPos;
	int y = 280 - höhe;
	int br = breite;
	int hö = höhe;
	if (!zRObj.setDrawOptions(x, y, br, hö))
		return;
	zRObj.alphaRegion(0, 0, br, hö, 0xA0000000);
	rahmen->setSize(br, hö);
	rahmen->render(zRObj);
	zRObj.addScrollOffset(0, 280 - höhe);
	verlauf->render(zRObj);
	nachricht->render(zRObj);
	name->render(zRObj);
	minimieren->render(zRObj);
	close->render(zRObj);
	zRObj.releaseDrawOptions();
}

// constant
int ChatFenster::getAccountId() const
{
	return accountId;
}

// Inhalt der ChatroomFenster Klasse aus ChatLeiste.h
// Konstruktor
ChatroomFenster::ChatroomFenster(int chatroomId)
	: Chat()
{
	Bild* maximierenBild = bilder->get("data/client/bilder/chat.ltdb/maximieren.png");
	this->chatroomId = chatroomId;
	spielerName = initTextFeld(200, 5, 120, 0, TextFeld::Style::TextFeld, "");
	initToolTip(spielerName, "Name des Spielers der eingeladen werden soll.");
	einladen = initKnopf(325, 5, 20, 0, 0, "");
	einladen->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	einladen->setHintergrundBildZ(maximierenBild);
	initToolTip(einladen, "Spieler ins Chatroom einladen.");
	spieler = new ObjTabelle();
	spieler->setMausEreignis(_ret1ME);
	spieler->setStyle(ObjTabelle::Style::Sichtbar | ObjTabelle::Style::Rahmen | ObjTabelle::Style::VScroll | ObjTabelle::Style::Erlaubt | ObjTabelle::Style::VScroll | ObjTabelle::Style::Raster);
	spieler->setVertikalKlickScroll(5);
	spieler->setPosition(200, 1);
	spieler->setSize(149, 240);
	spieler->setRasterFarbe(0xFF555555);
	spieler->setRahmenFarbe(0xFFFFFFFF);
	spieler->addSpalte(0, "Name");
	spieler->addSpalte(1, "Freund");
	spieler->addSpalte(2, "Kick");
	spieler->setSpaltenBreite(0, 110);
	spieler->setSpaltenBreite(1, 20);
	spieler->setSpaltenBreite(2, 0);
	name->setTextZ(infoClient->getChatroomName(chatroomId));
	close->setPosition(close->getX() + 150, close->getY());
	minimieren->setPosition(minimieren->getX() + 150, minimieren->getY());
	neueSpieler = new Array< int >();
	alteSpieler = new Array< int >();
	neueSpielerAnzahl = 0;
	alteSpielerAnzahl = 0;
}

// Destruktor
ChatroomFenster::~ChatroomFenster()
{
	chatClient->chatroomVerlassen(chatroomId);
	neueSpieler->release();
	alteSpieler->release();
	spieler = (ObjTabelle*)spieler->release();
	spielerName = (TextFeld*)spielerName->release();
	einladen = (Knopf*)einladen->release();
}

// nicht constant
void ChatroomFenster::addSpieler(int accountId)
{
	Text* zeile = new Text();
	zeile->append(accountId);
	if (spieler->getZeilenNummer(zeile->getText()) >= 0)
		return;
	Bild* einladenBild = bilder->get("data/client/bilder/chat.ltdb/maximieren.png");
	Bild* closeBild = bilder->get("data/client/bilder/chat.ltdb/entfernen.png");
	spieler->addZeile(zeile->getText());
	spieler->setZeilenHeight(zeile->getText(), 0);
	Text* name = infoClient->getSpielerName(accountId);
	TextFeld* sName = initTextFeld(0, 0, 110, 20, TextFeld::Style::Sichtbar | TextFeld::Style::Text | TextFeld::Style::Center, name->getText());
	name->release();
	spieler->setZeichnungZ("Name", zeile->getText(), sName);
	Knopf* freund = initKnopf(0, 0, 20, 20, 0, "");
	freund->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	freund->setHintergrundBildZ(einladenBild);
	freund->setMausEreignisParameter(this);
	freund->setMausEreignis(chatroomFensterFreundME);
	initToolTip(freund, "Freundeseinladung an den Spieler schicken.");
	spieler->setZeichnungZ("Freund", zeile->getText(), freund);
	Knopf* entfernen = initKnopf(0, 0, 0, 20, 0, "");
	entfernen->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	entfernen->setHintergrundBildZ(closeBild);
	entfernen->setMausEreignisParameter(this);
	entfernen->setMausEreignis(chatroomFensterEntfernenME);
	initToolTip(entfernen, "Spieler aus Chatroom entfernen.");
	spieler->setZeichnungZ("Kick", zeile->getText(), entfernen);
	neueSpieler->add(accountId, neueSpielerAnzahl);
	neueSpielerAnzahl++;
	zeile->release();
	rend = 1;
}

void ChatroomFenster::removeSpieler(int accountId)
{
	Text* zeile = new Text();
	zeile->append(accountId);
	if (spieler->getZeilenNummer(zeile) >= 0)
	{
		alteSpieler->add(accountId, alteSpielerAnzahl);
		alteSpielerAnzahl++;
		rend = 1;
	}
}

bool ChatroomFenster::tick(double tickVal)
{
	rend |= close->tick(tickVal);
	rend |= minimieren->tick(tickVal);
	rend |= einladen->tick(tickVal);
	rend |= spieler->tick(tickVal);
	rend |= spielerName->tick(tickVal);
	rend |= verlauf->tick(tickVal);
	rend |= nachricht->tick(tickVal);
	this->tickVal += tickVal * 300;
	int val = (int)this->tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	if (val > 10)
		val = 10;
	this->tickVal -= val;
	switch (animation)
	{
	case 1: // erstellen
	case 2: // ausfahren
		if (breite == 350)
		{
			höhe += val;
			if (höhe > 280)
			{
				höhe = 280;
				animation = 0;
			}
		}
		else
		{
			breite += val;
			if (breite > 350)
				breite = 350;
		}
		rend = 1;
		break;
	case 3: // einfahren
		if (höhe == 30)
		{
			breite -= val;
			if (breite < 100)
			{
				breite = 100;
				animation = 0;
			}
		}
		else
		{
			höhe -= val;
			if (höhe < 30)
				höhe = 30;
		}
		rend = 1;
		break;
	case 4: // close
		if (höhe == 30)
		{
			breite -= val;
			if (breite < 0)
			{
				nachLogin->zChatLeiste()->removeChat(this); // delete this
				return 1;
			}
		}
		else
		{
			höhe -= val;
			if (höhe < 30)
				höhe = 30;
		}
		rend = 1;
		break;
	}
	Text* zeile = new Text("");
	for (int i = 0; i < neueSpielerAnzahl; i++)
	{
		int id = neueSpieler->hat(i) ? neueSpieler->get(i) : 0;
		zeile->append(id);
		int z = spieler->getZeilenNummer(zeile->getText());
		spieler->setZeilenHeight(z, spieler->getZeilenHeight(z) + val / 2);
		if (spieler->getZeilenHeight(z) > 20)
		{
			spieler->setZeilenHeight(z, 20);
			neueSpieler->remove(i);
			neueSpielerAnzahl--;
			i--;
		}
		zeile->setText("");
		rend = 1;
	}
	for (int i = 0; i < alteSpielerAnzahl; i++)
	{
		int id = alteSpieler->hat(i) ? alteSpieler->get(i) : 0;
		zeile->append(id);
		int z = spieler->getZeilenNummer(zeile->getText());
		spieler->setZeilenHeight(z, spieler->getZeilenHeight(z) - val / 2);
		if (spieler->getZeilenHeight(z) <= 0)
		{
			spieler->removeZeile(z);
			alteSpieler->remove(i);
			alteSpielerAnzahl--;
			i--;
		}
		zeile->setText("");
		rend = 1;
	}
	zeile->release();
	if (admin)
	{
		if (spielerName->getHeight() != 20)
		{
			spielerName->setSize(spielerName->getBreite(), spielerName->getHeight() + val / 2);
			einladen->setSize(einladen->getBreite(), einladen->getHeight() + val / 2);
			spieler->setPosition(spieler->getX(), spieler->getY() + val / 2);
			spieler->setSize(spieler->getBreite(), spieler->getHeight() - val / 2);
			if (spielerName->getHeight() >= 20)
			{
				spielerName->setSize(spielerName->getBreite(), 20);
				einladen->setSize(einladen->getBreite(), 20);
				spieler->setPosition(spieler->getX(), 30);
				spieler->setSize(spieler->getBreite(), 210);
			}
			rend = 1;
		}
		if (spieler->getSpaltenBreite(2) != 20)
		{
			spieler->setSpaltenBreite(2, spieler->getSpaltenBreite(2) + val / 2);
			spieler->setSpaltenBreite(0, spieler->getSpaltenBreite(0) - val / 2);
			if (spieler->getSpaltenBreite(2) > 20)
			{
				spieler->setSpaltenBreite(2, 20);
				spieler->setSpaltenBreite(0, 90);
			}
			rend = 1;
		}
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

void ChatroomFenster::doPublicMausEreignis(MausEreignis& me)
{
	bool tmp = me.verarbeitet;
	if (me.mx < 0 || me.mx > breite || me.my < 280 - höhe || animation)
		me.verarbeitet = 1;
	verlauf->doPublicMausEreignis(me);
	bool vera = me.verarbeitet;
	minimieren->doPublicMausEreignis(me);
	int aktion = me.verarbeitet && !vera ? 1 : 0;
	close->doPublicMausEreignis(me);
	if (!aktion)
		aktion = me.verarbeitet && !vera ? 2 : 0;
	einladen->doPublicMausEreignis(me);
	if (!aktion)
		aktion = me.verarbeitet && !vera ? 4 : 0;
	nachricht->doPublicMausEreignis(me);
	spielerName->doPublicMausEreignis(me);
	spieler->doPublicMausEreignis(me);
	if (me.mx < 0 || me.mx > breite || me.my < 280 - höhe || animation)
	{
		me.verarbeitet = tmp;
		return;
	}
	if (!aktion && !sichtbar && !vera)
	{
		if (me.mx < breite && me.mx > 0 && me.my > 250 && me.my < 280)
			aktion = 3;
	}
	switch (aktion)
	{
	case 1: // einfahren
		if (me.id == ME_RLinks)
			this->setSichtbar(0);
		break;
	case 2: // close
		if (me.id == ME_RLinks)
			animation = 4;
		break;
	case 3: // ausfahren
		if (me.id == ME_RLinks)
			this->setSichtbar(1);
		break;
	case 4: // einladen
		if (me.id != ME_RLinks)
			break;
		if (spielerName->zText()->getLength())
		{
			int accountId = infoClient->getAccountId(spielerName->zText()->getText());
			if (accountId)
			{
				if (chatClient->chatroomEinladung(accountId, chatroomId))
				{
					nachLogin->zNachrichtenListe()->addNachricht(new Text("Chatroom Einladung"), new Text("Es wurde eine Chatroom Einladung an den Spieler gesendet."),
						new Text("Ok"), 0);
					spielerName->setText("");
					spielerName->setAuswahl(0, 0);
					rend = 1;
				}
			}
			else
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"), new Text("Der Spieler wurde nicht gefunden."),
					new Text("Ok"), 0);
			}
		}
		break;
	}
}

void ChatroomFenster::doTastaturEreignis(TastaturEreignis& te)
{
	bool tmp = te.verarbeitet;
	if (animation)
		te.verarbeitet = 1;
	nachricht->doTastaturEreignis(te);
	int aktion = te.verarbeitet && !tmp ? 1 : 0;
	if (admin)
	{
		spielerName->doTastaturEreignis(te);
		if (!aktion)
			aktion = te.verarbeitet && !tmp ? 2 : 0;
	}
	if (animation)
	{
		te.verarbeitet = tmp;
		return;
	}
	switch (aktion)
	{
	case 1:
		if (te.id == TE_Release && te.taste == T_Enter)
		{
			nachricht->zText()->remove("\n");
			chatClient->chatroomNachricht(chatroomId, nachricht->zText()->getText());
			nachricht->setText("");
			nachricht->setAuswahl(0, 0);
			rend = 1;
		}
		break;
	case 2:
		if (te.id == TE_Release && te.taste == T_Enter)
		{
			if (!spielerName->zText()->getLength())
				break;
			int accountId = infoClient->getAccountId(spielerName->zText()->getText());
			if (accountId)
			{
				if (chatClient->chatroomEinladung(accountId, chatroomId))
				{
					nachLogin->zNachrichtenListe()->addNachricht(new Text("Chatroom Einladung"), new Text("Es wurde eine Chatroom Einladung an den Spieler gesendet."),
						new Text("Ok"), 0);
					spielerName->setText("");
					spielerName->setAuswahl(0, 0);
					rend = 1;
				}
			}
			else
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"), new Text("Der Spieler wurde nicht gefunden."),
					new Text("Ok"), 0);
			}
		}
		break;
	}
}

void ChatroomFenster::render(int xPos, Bild& zRObj)
{
	int x = xPos;
	int y = 280 - höhe;
	int br = breite;
	int hö = höhe;
	if (!zRObj.setDrawOptions(x, y, br, hö))
		return;
	zRObj.alphaRegion(0, 0, br, hö, 0x88000000);
	rahmen->setSize(br, hö);
	rahmen->render(zRObj);
	zRObj.addScrollOffset(0, 280 - höhe);
	verlauf->render(zRObj);
	nachricht->render(zRObj);
	spieler->render(zRObj);
	name->render(zRObj);
	minimieren->render(zRObj);
	close->render(zRObj);
	if (spielerName->getHeight())
	{
		spielerName->render(zRObj);
		einladen->render(zRObj);
	}
	zRObj.releaseDrawOptions();
}

bool ChatroomFenster::druckFreund(void* obj, MausEreignis& me)
{
	if (me.id == ME_RLinks)
	{
		Punkt p = spieler->getZeichnungPosition((Zeichnung*)obj);
		if (p.y >= 0)
		{
			int accountId = TextZuInt(spieler->zZeilenName(p.y)->getText(), 10);
			if (chatClient->freundesAnfrage(accountId))
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Freundes Einladung"), new Text("Es wurde eine Freundesanfrage an den Spieler gesendet."),
					new Text("Ok"), 0);
			}
		}
		return 0;
	}
	return 1;
}

bool ChatroomFenster::druckEntfernen(void* obj, MausEreignis& me)
{
	if (me.id == ME_RLinks && admin)
	{
		Punkt p = spieler->getZeichnungPosition((Zeichnung*)obj);
		if (p.y >= 0)
		{
			int accountId = TextZuInt(spieler->zZeilenName(p.y)->getText(), 10);
			if (chatClient->chatroomKick(chatroomId, accountId))
			{
				nachLogin->zNachrichtenListe()->addNachricht(new Text("Kick"), new Text("Der Spieler musste das Chatroom verlassen."),
					new Text("Ok"), 0);
			}
		}
		return 0;
	}
	return 1;
}

// constant
int ChatroomFenster::getChatroomId() const
{
	return chatroomId;
}

// Inhalt der ChatLeisteObj Klasse aus ChatLeiste.h
// Konstruktor
ChatLeisteObj::ChatLeisteObj()
	: Zeichnung()
{
	chats = new RCArray< Chat >();
	hsb = new HScrollBar();
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	anzahl = 0;
	nowME = -1;
}

// Destruktor
ChatLeisteObj::~ChatLeisteObj()
{
	chats->release();
	hsb = (HScrollBar*)hsb->release();
}

// nicht constant
void ChatLeisteObj::chatNachricht(int vonAccount, const char* txt)
{
	if (!vonAccount)
		return;
	lockZeichnung();
	bool gefunden = 0;
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		if (tmp->getAccountId() == vonAccount)
		{
			tmp->addNachricht(txt);
			gefunden = 1;
			break;
		}
	}
	if (!gefunden)
	{
		addChat(vonAccount, 0);
		chatNachricht(vonAccount, txt);
	}
	unlockZeichnung();
}

void ChatLeisteObj::chatroomNachricht(int chatroomId, const char* txt)
{
	lockZeichnung();
	bool gefunden = 0;
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		if (tmp->getChatroomId() == chatroomId)
		{
			tmp->addNachricht(txt);
			gefunden = 1;
			break;
		}
	}
	if (!gefunden)
	{
		addChat(0, chatroomId);
		chatroomNachricht(chatroomId, txt);
	}
	unlockZeichnung();
}

void ChatLeisteObj::addChat(int accountId, int chatroomId)
{
	lockZeichnung();
	bool gefunden = 0;
	if (accountId)
	{
		for (int i = 0; i < anzahl; i++)
		{
			Chat* tmp = chats->z(i);
			if (tmp->getAccountId() == accountId)
			{
				tmp->setSichtbar(1);
				gefunden = 1;
				break;
			}
		}
		if (!gefunden)
		{
			ChatFenster* neu = new ChatFenster(accountId);
			chats->add(neu, anzahl);
			anzahl++;
			rend = 1;
		}
	}
	else if (chatroomId)
	{
		for (int i = 0; i < anzahl; i++)
		{
			Chat* tmp = chats->z(i);
			if (tmp->getChatroomId() == chatroomId)
			{
				tmp->setSichtbar(1);
				gefunden = 1;
				break;
			}
		}
		if (!gefunden)
		{
			ChatroomFenster* neu = new ChatroomFenster(chatroomId);
			chats->add(neu, anzahl);
			anzahl++;
			rend = 1;
		}
	}
	unlockZeichnung();
}

void ChatLeisteObj::removeChat(int accountId, int chatroomId)
{
	lockZeichnung();
	if (accountId)
	{
		for (int i = 0; i < anzahl; i++)
		{
			Chat* tmp = chats->z(i);
			if (tmp->getAccountId() == accountId)
				tmp->entfernen();
		}
	}
	else if (chatroomId)
	{
		for (int i = 0; i < anzahl; i++)
		{
			Chat* tmp = chats->z(i);
			if (tmp->getChatroomId() == chatroomId)
				tmp->entfernen();
		}
	}
	rend = 1;
	unlockZeichnung();
}

void ChatLeisteObj::removeChat(Chat* zChat)
{
	lockZeichnung();
	for (int i = 0; i < anzahl; i++)
	{
		if (chats->z(i) == zChat)
		{
			chats->remove(i);
			anzahl--;
			rend = 1;
			break;
		}
	}
	unlockZeichnung();
}

void ChatLeisteObj::removeAll()
{
	lockZeichnung();
	chats->leeren();
	anzahl = 0;
	rend = 1;
	unlockZeichnung();
}

void ChatLeisteObj::addSpieler(int chatroomId, int accountId)
{
	if (!chatroomId || !accountId)
		return;
	lockZeichnung();
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		if (tmp->getChatroomId() == chatroomId)
		{
			tmp->addSpieler(accountId);
			break;
		}
	}
	unlockZeichnung();
}

void ChatLeisteObj::removeSpieler(int chatroomId, int accountId)
{
	lockZeichnung();
	if (!chatroomId || !accountId)
		return;
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		if (tmp->getChatroomId() == chatroomId)
		{
			tmp->removeSpieler(accountId);
			break;
		}
	}
	unlockZeichnung();
}

void ChatLeisteObj::setChatroomAdmin(int chatroomId)
{
	lockZeichnung();
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		if (tmp->getChatroomId() == chatroomId)
		{
			tmp->setAdmin();
			break;
		}
	}
	unlockZeichnung();
}

bool ChatLeisteObj::tick(double tickVal)
{
	rend |= hsb->getRend();
	rend |= nachLogin->zChatLeiste()->tick(tickVal);
	for (int i = 0; i < anzahl; i++)
		rend |= chats->z(i)->tick(tickVal);
	bool ret = rend;
	rend = 0;
	return ret;
}

void ChatLeisteObj::doTastaturEreignis(TastaturEreignis& te)
{
	for (int i = 0; i < anzahl; i++)
		chats->z(i)->doTastaturEreignis(te);
}

void ChatLeisteObj::doPublicMausEreignis(MausEreignis& me)
{
	int mx = me.mx;
	int my = me.my;
	me.my += 250;
	me.mx += hsb->getScroll();
	bool insideParent = me.insideParent;
	me.insideParent = 1;
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		nowME = i;
		tmp->doPublicMausEreignis(me);
		nowME = -1;
		me.mx -= tmp->getBreite();
	}
	me.mx = mx;
	me.my = my;
	hsb->doMausMessage(1, 30, bildschirmGröße.x - 20, 20, me);
	me.insideParent = insideParent;
}

void ChatLeisteObj::render(Bild& zRObj)
{
	int x = pos.x;
	int y = pos.y;
	int br = bildschirmGröße.x - 20;
	int hö = 300;
	if (!zRObj.setDrawOptionsErzwingen(x, y - 250, br, hö))
		return;
	int breite = 0;
	for (int i = 0; i < anzahl; i++)
	{
		Chat* tmp = chats->z(i);
		tmp->render(breite - (hsb ? hsb->getScroll() : 0), zRObj);
		breite += tmp->getBreite();
	}
	if (hsb)
	{
		hsb->update(breite, bildschirmGröße.x - 22);
		hsb->render(0, 280, bildschirmGröße.x - 22, 20, zRObj);
	}
	zRObj.releaseDrawOptions();
}

// Inhalt der ChatLeiste Klasse aus ChatLeiste.h
// Konstruktor
ChatLeiste::ChatLeiste(Fenster* zNachLoginFenster)
	: ReferenceCounter()
{
	minimierenBild = bilder->get("data/client/bilder/chat.ltdb/minimieren.png");
	maximierenBild = bilder->get("data/client/bilder/chat.ltdb/maximieren.png");
	bildschirmGröße = uiFactory.initParam.bildschirm->getBackBufferSize();
	fenster = initFenster(20 - bildschirmGröße.x, bildschirmGröße.y - 50, bildschirmGröße.x, 50, Fenster::Style::Sichtbar | Fenster::Style::Erlaubt | Fenster::Style::BodyHintergrund | Fenster::Style::Rahmen, "");
	fenster->setKBgFarbe(0xFF000000);
	minMax = initKnopf(bildschirmGröße.x - 21, 1, 20, 20, 0, "");
	minMax->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer);
	minMax->setHintergrundBildZ(dynamic_cast<Bild*>(minimierenBild->getThis()));
	minMax->setMausEreignisParameter(this);
	minMax->setMausEreignis(chatLeisteMinMaxME);
	initToolTip(minMax, "Chat Leiste minimieren.");
	fenster->addMember(dynamic_cast<Zeichnung*>(minMax->getThis()));
	chatLeiste = new ChatLeisteObj();
	fenster->addMember(dynamic_cast<Zeichnung*>(chatLeiste->getThis()));
	zNachLoginFenster->addMember(dynamic_cast<Zeichnung*>(fenster->getThis()));
	tickVal = 0;
	animation = 1;
	rend = 0;
	chatClient->chatNachrichtAnfrage();
}

// Destruktor
ChatLeiste::~ChatLeiste()
{
	minimierenBild->release();
	maximierenBild->release();
	fenster = (Fenster*)fenster->release();
	minMax = (Knopf*)minMax->release();
	chatLeiste = (ChatLeisteObj*)chatLeiste->release();
}

// nicht constant
void ChatLeiste::chatNachricht(int vonAccount, const char* txt)
{
	chatLeiste->chatNachricht(vonAccount, txt);
}

void ChatLeiste::chatroomNachricht(int chatroomId, int vonAccount, const char* txt)
{
	chatLeiste->chatroomNachricht(chatroomId, txt);
}

void ChatLeiste::addChat(int accountId, int chatroomId)
{
	chatLeiste->addChat(accountId, chatroomId);
}

void ChatLeiste::removeChat(int accountId, int chatroomId)
{
	chatLeiste->removeChat(accountId, chatroomId);
}

void ChatLeiste::removeChat(Chat* zChat)
{
	chatLeiste->removeChat(zChat);
}

void ChatLeiste::removeAll()
{
	chatLeiste->removeAll();
}

void ChatLeiste::addSpieler(int chatroomId, int accountId)
{
	chatLeiste->addSpieler(chatroomId, accountId);
}

void ChatLeiste::removeSpieler(int chatroomId, int accountId)
{
	chatLeiste->removeSpieler(chatroomId, accountId);
}

void ChatLeiste::setChatroomAdmin(int chatroomId)
{
	chatLeiste->setChatroomAdmin(chatroomId);
}

bool ChatLeiste::tick(double tickVal)
{
	this->tickVal += tickVal * 500;
	int val = (int)this->tickVal;
	if (val < 1)
	{
		bool ret = rend;
		rend = 0;
		return ret;
	}
	if (val > 16)
		val = 16;
	this->tickVal -= val;
	switch (animation)
	{
	case 1: // einfahren
		if (fenster->getX() < 0)
			fenster->setPosition(fenster->getX() + val, fenster->getY());
		else
		{
			fenster->setPosition(0, fenster->getY());
			animation = 0;
		}
		rend = 1;
		break;
	case 2: // ausfahren
		if (fenster->getX() + fenster->getBreite() > 21)
			fenster->setPosition(fenster->getX() - val, fenster->getY());
		else
		{
			fenster->setPosition(21 - fenster->getBreite(), fenster->getY());
			animation = 0;
		}
		rend = 1;
		break;
	}
	bool ret = rend;
	rend = 0;
	return ret;
}

bool ChatLeiste::druckMinMax(MausEreignis& me)
{
	if (animation)
		return 1;
	if (me.id == ME_RLinks)
	{
		if (minMax->zHintergrundBild() == minimierenBild)
		{
			animation = 2;
			minMax->setHintergrundBildZ(dynamic_cast<Bild*>(maximierenBild->getThis()));
			// TODO minMax->zToolTip()->setText( "Chat Leiste maximieren." );
		}
		else
		{
			animation = 1;
			minMax->setHintergrundBildZ(dynamic_cast<Bild*>(minimierenBild->getThis()));
			// TODO minMax->zToolTip()->setText( "Chat Leiste minimieren." );
		}
	}
	return 1;
}

// Nachrichten
bool chatLeisteMinMaxME(void* p, void* obj, MausEreignis me)
{
	return ((ChatLeiste*)p)->druckMinMax(me);
}

bool chatroomFensterFreundME(void* p, void* obj, MausEreignis me)
{
	return ((ChatroomFenster*)p)->druckFreund(obj, me);
}

bool chatroomFensterEntfernenME(void* p, void* obj, MausEreignis me)
{
	return ((ChatroomFenster*)p)->druckEntfernen(obj, me);
}