KSG-Client/KSGClient/NachLogin/Editor/Auswahl/Auswahl.cpp

#include "Auswahl.h"

#include <DateiSystem.h>
#include <KSGTDatei.h>

#include "../../../Global/Initialisierung.h"
#include "../../../Global/Variablen.h"

// Inhalt der Auswahl Klasse aus Auswahl.h
// Konstruktor
Auswahl::Auswahl(KartenEditor* kEditor)
    : Thread()
{
    this->kEditor = kEditor;
    alpha = 255;
    sichtbar = 0;
    suchFilterT = initTextFeld(10,
        10,
        70,
        20,
        TextFeld::Style::Text | TextFeld::Style::VCenter,
        "Suchfilter:");
    suchFilter = initTextFeld(90, 10, 210, 20, TextFeld::Style::TextFeld, "");
    initToolTip(
        suchFilter, "Gebe etwas vom Namen der Karte ein, nach der du suchst.");
    suchen = initKnopf(310, 10, 100, 20, Knopf::Style::Sichtbar, "suchen");
    sortSpalte = initAuswahlBox(640,
        10,
        120,
        20,
        ABSTYLE,
        {"Name", "Spielart", "Preis (Kupfer)", "Verkauft", "Spieleranzahl"});
    sortRichtung = initAuswahlBox(
        770, 10, 120, 20, ABSTYLE, {"Aufsteigend", "Absteigend"});
    karten = initObjTabelle(10,
        40,
        880,
        520,
        OTSTYLE,
        {
            {"Name",          220, 220, 220},
            {"Spielart",      220, 220, 220},
            {"Kupfer",        130, 130, 130},
            {"Verkauft",      125, 125, 125},
            {"Spieleranzahl", 140, 140, 140},
            {"",              20,  20,  20 }
    },
        20);
    neuKarteName
        = initTextFeld(10, 570, 195, 20, TextFeld::Style::TextFeld, "");
    initToolTip(neuKarteName, "Name einer neuen Karte");
    neuKarteSpielArt = initAuswahlBox(215, 570, 195, 20, ABSTYLE, {});
    neuKarte = initKnopf(
        420, 570, 120, 20, Knopf::Style::Sichtbar, "Karte Erstellen");
    laden = (Framework::Animation2D*)ladeAnimation->dublizieren();
    laden->setPosition(425, 275);
    laden->setSichtbar(0);
    aktion = 0;
    tickVal = 0;
    rend = 0;
}

// Destruktor
Auswahl::~Auswahl()
{
    laden->release();
    suchFilterT->release();
    suchFilter->release();
    suchen->release();
    sortSpalte->release();
    sortRichtung->release();
    karten->release();
    neuKarteName->release();
    neuKarteSpielArt->release();
    neuKarte->release();
    kEditor->release();
}

// nicht constant
void Auswahl::setSichtbar(bool sicht)
{
    sichtbar = sicht;
    if (sichtbar)
    {
        MausEreignis me;
        me.id = ME_RLinks;
        me.verarbeitet = 0;
        me.mx = suchen->getX() + 1;
        me.my = suchen->getY() + 1;
        doPublicMausEreignis(me);
    }
}

void Auswahl::thread()
{
    laden->setSichtbar(1);
    if (aktion < 0)
    {
        int port = 0;
        Text ip = "";
        KSGClient::EditorServerClient* editorClient
            = infoClient->createEditorServerClient(0);
        if (!editorClient)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(infoClient->getLetzterFehler()),
                new Text("Ok"));
            aktion = 0;
            laden->setSichtbar(0);
            run = 0;
            return;
        }
        bool ok = 0;
        if (editorClient->verbinde())
        {
            if (editorClient->karteErstellen(neuKarteName->zText()->getText(),
                    infoClient->getSpielId(
                        neuKarteSpielArt
                            ->zEintrag(neuKarteSpielArt->getAuswahl())
                            ->zText()
                            ->getText())))
                ok = 1;
            editorClient->trenne(1);
        }
        if (!ok)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(editorClient->getLetzterFehler()),
                new Text("Ok"));
            aktion = 0;
            laden->setSichtbar(0);
            run = 0;
            editorClient->release();
            return;
        }
        aktion = 0;
        laden->setSichtbar(0);
        run = 0;
        editorClient->release();
        return;
    }
    if (aktion)
    {
        int port = 0;
        Text ip = "";
        if (editorClient)
            editorClient
                = (KSGClient::EditorServerClient*)editorClient->release();
        editorClient = infoClient->createEditorServerClient(aktion);
        if (!editorClient)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(infoClient->getLetzterFehler()),
                new Text("Ok"));
            aktion = 0;
            laden->setSichtbar(0);
            run = 0;
            return;
        }
        bool ok = 0;
        if (editorClient->verbinde())
        {
            if (editorClient->ladeKarte(aktion)) ok = 1;
        }
        if (!ok)
        {
            nachLogin->zNachrichtenListe()->addNachricht(new Text("Fehler"),
                new Text(editorClient->getLetzterFehler()),
                new Text("Ok"));
            aktion = 0;
            laden->setSichtbar(0);
            run = 0;
            return;
        }
        kEditor->setKarte(aktion);
        aktion = 0;
        setSichtbar(0);
        while (alpha != 0)
            Sleep(100);
        laden->setSichtbar(0);
        run = 0;
        return;
    }
    Array<int>* saList = infoClient->getAccountSpielArtListe();
    if (saList)
    {
        RCArray<Text>* saNamen = new RCArray<Text>();
        int anz = saList->getEintragAnzahl();
        for (int i = 0; i < anz; i++)
        {
            if (!saList->hat(i)) continue;
            Text* name
                = infoClient->getSpielName(saList->hat(i) ? saList->get(i) : 0);
            if (name) saNamen->add(name);
        }
        neuKarteSpielArt->lockZeichnung();
        neuKarteSpielArt->setAuswahl(0);
        anz = neuKarteSpielArt->getEintragAnzahl();
        for (int i = 0; i < anz; i++)
            neuKarteSpielArt->removeEintrag(0);
        anz = saNamen->getEintragAnzahl();
        for (int i = 0; i < anz; i++)
        {
            if (saNamen->z(i))
                neuKarteSpielArt->addEintrag(saNamen->z(i)->getText());
        }
        neuKarteSpielArt->unlockZeichnung();
        saNamen->release();
        saList->release();
    }
    karten->lockZeichnung();
    int anz = karten->getZeilenAnzahl();
    for (int i = 1; i < anz; i++)
        karten->removeZeile(1);
    karten->unlockZeichnung();
    Bild* shopWeiter = bilder->get("data/client/bilder/shop.ltdb/weiter.png");
    Array<int>* kId = new Array<int>();
    RCArray<Text>* kName = new RCArray<Text>();
    RCArray<Text>* saName = new RCArray<Text>();
    Array<int>* kupfer = new Array<int>();
    Array<int>* verkauft = new Array<int>();
    Array<int>* maxSpieler = new Array<int>();
    int kAnz = infoClient->getKartenListe(suchFilter->zText()->getText(),
        (char)sortSpalte->getAuswahl(),
        (char)sortRichtung->getAuswahl(),
        kId,
        kName,
        saName,
        kupfer,
        verkauft,
        maxSpieler);
    for (int i = 0; i < kAnz; i++)
    {
        Text zeile;
        zeile = kId->get(i);
        karten->addZeile(zeile);
        karten->setZeichnungZ(0,
            i + 1,
            initTextFeld(0,
                0,
                0,
                0,
                TextFeld::Style::Text | TextFeld::Style::VCenter,
                kName->z(i)->getText()));
        karten->setZeichnungZ(1,
            i + 1,
            initTextFeld(0,
                0,
                0,
                0,
                TextFeld::Style::Text | TextFeld::Style::VCenter,
                saName->z(i)->getText()));
        karten->setZeichnungZ(2,
            i + 1,
            initTextFeld(0,
                0,
                0,
                0,
                TextFeld::Style::Text | TextFeld::Style::VCenter,
                Text() += kupfer->get(i)));
        karten->setZeichnungZ(3,
            i + 1,
            initTextFeld(0,
                0,
                0,
                0,
                TextFeld::Style::Text | TextFeld::Style::VCenter,
                Text() += verkauft->get(i)));
        karten->setZeichnungZ(4,
            i + 1,
            initTextFeld(0,
                0,
                0,
                0,
                TextFeld::Style::Text | TextFeld::Style::VCenter,
                Text() += maxSpieler->get(i)));
        Knopf* weiter = initKnopf(0, 0, 0, 0, 0, "");
        weiter->setStyle(Knopf::Style::Sichtbar | Knopf::Style::Erlaubt
                         | Knopf::Style::Hintergrund | Knopf::Style::HBild
                         | Knopf::Style::KlickBuffer);
        weiter->setHintergrundBildZ(dynamic_cast<Bild*>(shopWeiter->getThis()));
        weiter->setMausEreignisParameter(this);
        weiter->setMausEreignis(auswahlWeiterME);
        karten->setZeichnungZ(5, i + 1, weiter);
    }
    kId->release();
    kName->release();
    saName->release();
    kupfer->release();
    verkauft->release();
    maxSpieler->release();
    shopWeiter->release();
    laden->setSichtbar(0);
    run = 0;
}

bool Auswahl::weiterME(Zeichnung* obj, MausEreignis& me)
{
    if (me.id != ME_RLinks) return 1;
    karten->lockZeichnung();
    int anz = karten->getZeilenAnzahl();
    for (int i = 1; i < anz; i++)
    {
        if (karten->zZeichnung(5, i) == obj)
        {
            aktion = (int)*karten->zZeilenName(i);
            start();
        }
    }
    karten->unlockZeichnung();
    return 1;
}

void Auswahl::doPublicMausEreignis(MausEreignis& me)
{
    if (!sichtbar || run) return;
    suchFilter->doPublicMausEreignis(me);
    bool vera = me.verarbeitet;
    suchen->doPublicMausEreignis(me);
    if (!vera && me.verarbeitet && me.id == ME_RLinks)
    {
        aktion = 0;
        start();
    }
    int ausw = sortSpalte->getAuswahl();
    sortSpalte->doPublicMausEreignis(me);
    if (ausw != sortSpalte->getAuswahl())
    {
        aktion = 0;
        start();
        sortSpalte->einklappen();
    }
    ausw = sortRichtung->getAuswahl();
    sortRichtung->doPublicMausEreignis(me);
    if (ausw != sortRichtung->getAuswahl())
    {
        aktion = 0;
        start();
        sortRichtung->einklappen();
    }
    karten->doPublicMausEreignis(me);
    neuKarteName->doPublicMausEreignis(me);
    neuKarteSpielArt->doPublicMausEreignis(me);
    vera = me.verarbeitet;
    neuKarte->doPublicMausEreignis(me);
    if (!vera && me.verarbeitet && me.id == ME_RLinks)
    {
        aktion = -1;
        start();
    }
}

void Auswahl::doTastaturEreignis(TastaturEreignis& te)
{
    if (!sichtbar || run) return;
    bool vera = te.verarbeitet;
    suchFilter->doTastaturEreignis(te);
    if (!vera && te.verarbeitet && te.virtualKey == T_Enter
        && te.id == TE_Release)
    {
        MausEreignis me;
        me.id = ME_RLinks;
        me.verarbeitet = 0;
        me.mx = suchen->getX() + 1;
        me.my = suchen->getY() + 1;
        doPublicMausEreignis(me);
    }
    neuKarteName->doTastaturEreignis(te);
}

bool Auswahl::tick(double zeit)
{
    tickVal += zeit * 250;
    int val = (int)tickVal;
    if (val < 1)
    {
        bool ret = rend;
        rend = 0;
        return ret;
    }
    if (val > 10) val = 10;
    rend |= sortSpalte->tick(zeit);
    rend |= sortRichtung->tick(zeit);
    rend |= neuKarteSpielArt->tick(zeit);
    rend |= laden->tick(zeit);
    rend |= suchFilterT->tick(zeit);
    rend |= suchFilter->tick(zeit);
    rend |= suchen->tick(zeit);
    rend |= karten->tick(zeit);
    rend |= neuKarteName->tick(zeit);
    rend |= neuKarte->tick(zeit);
    if (sichtbar && alpha != 255 && !run)
    {
        if (alpha + val > 255)
            alpha = 255;
        else
            alpha += val;
        rend = 1;
    }
    if (sichtbar && alpha != 125 && run)
    {
        if (alpha > 125)
        {
            if (alpha - val < 125)
                alpha = 125;
            else
                alpha -= val;
            rend = 1;
        }
        else
        {
            if (alpha + val > 125)
                alpha = 125;
            else
                alpha += 125;
            rend = 1;
        }
    }
    if (!sichtbar && alpha != 0)
    {
        if (alpha - val < 0)
            alpha = 0;
        else
            alpha -= val;
        rend = 1;
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void Auswahl::render(Bild& zRObj)
{
    if (!alpha) return;
    zRObj.setAlpha(alpha);
    suchFilterT->render(zRObj);
    suchFilter->render(zRObj);
    suchen->render(zRObj);
    karten->render(zRObj);
    neuKarteName->render(zRObj);
    neuKarte->render(zRObj);
    neuKarteSpielArt->render(zRObj);
    sortSpalte->render(zRObj);
    sortRichtung->render(zRObj);
    zRObj.releaseAlpha();
    laden->render(zRObj);
}

// constant
bool Auswahl::istSichtbar() const
{
    return sichtbar;
}

// Ereignisse
bool auswahlWeiterME(void* p, void* obj, MausEreignis me)
{
    if (p) return ((Auswahl*)p)->weiterME((Zeichnung*)obj, me);
    return 1;
}