#include "ChatLeiste.h"

#include <Bild.h>
#include <DateiSystem.h>
#include <Globals.h>
#include <GSLDateiV.h>
#include <InitDatei.h>
#include <Punkt.h>
#include <Rahmen.h>
#include <ToolTip.h>

#include "..\..\Global\Initialisierung.h"
#include "..\..\Global\Variablen.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.virtualKey == 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.virtualKey == 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.virtualKey == 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);
}