KSG-Client/KSGClient/NachLogin/Account/Historie/AccountHistorie.cpp

#include "AccountHistorie.h"
#include "../../../Global/Initialisierung.h"
#include "../../../Leser/KartenLeser.h"
#include "../../../Global/Variablen.h"
#include <Text.h>
#include <Rahmen.h>
#include <DateiSystem.h>
#include <Zeit.h>
#include <Punkt.h>
#include <Globals.h>

typedef AccountHistorieStatistikV *( *AHSSDLLStart )( void );
typedef AufzeichnungV *( *AHSADLLStart )( void );

// Inahlt der AHSpielStatistik Klasse aus AccountHistorie.h
// Konstruktor
AHSpielStatistik::AHSpielStatistik()
    : Thread()
{
    statistikF = initFenster( 10, 40, 780, 450, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Rahmen, "Spiel Ergebnis" );
    laden = (Animation2D *)ladeAnimation->dublizieren();
    laden->setSichtbar( 0 );
    laden->setPosition( 380, 245 );
    dllName = new Text( "" );
    dllHandle = 0;
    alpha = 0;
    sichtbar = 0;
    statistik = 0;
    tickVal = 0;
}

// Destruktor
AHSpielStatistik::~AHSpielStatistik()
{
    statistikF->release();
    if( dllHandle )
        reset();
    dllName->release();
    laden->release();
}

// nicht constant
void AHSpielStatistik::reset()
{
    if( run )
        warteAufThread( INFINITE );
    if( dllHandle )
    {
        if( statistik )
            statistik = (AccountHistorieStatistikV *)statistik->release();
        Framework::getDLLRegister()->releaseDLL( *dllName );
        dllHandle = 0;
    }
}

bool AHSpielStatistik::ladeDaten( int spielId, int karteId )
{
    if( dllHandle )
        reset();
    KartenLeser *reader = KartenLeser::getInstance();
    reader->lock();
    reader->setKarteId( karteId );
    Text *pfad = reader->getSpielPfad();
    if( !pfad )
    {
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( reader->getLetzterFehler() ), new Text( "Ok" ) );
        reader->unlock();
        reader->release();
        return 0;
    }
    pfad->append( "bin/" );
    Text *spielArtName = reader->getSpielName();
    if( !spielArtName )
    {
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( reader->getLetzterFehler() ), new Text( "Ok" ) );
        reader->unlock();
        reader->release();
        pfad->release();
        return 0;
    }
    pfad->append( spielArtName->getText() );
    pfad->append( ".dll" );
    reader->unlock();
    reader->release();
    dllName->setText( "Spiele/" );
    dllName->append( spielArtName->getText() );
    dllName->append( ".dll" );
    spielArtName->release();
    dllHandle = Framework::getDLLRegister()->ladeDLL( *dllName, *pfad );
    if( !dllHandle )
    {
        Text *msg = new Text( "Die DLL Datei '" );
        msg->append( pfad->getText() );
        msg->append( "' konnte nicht geladen werden." );
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), msg, new Text( "Ok" ) );
        pfad->release();
        return 0;
    }
    AHSSDLLStart startFunk = (AHSSDLLStart)GetProcAddress( dllHandle, "GetAccountHistorieStatistik" );
    if( !startFunk )
    {
        if( dllHandle )
        {
            Framework::getDLLRegister()->releaseDLL( *dllName );
            dllHandle = 0;
        }
        Text *msg = new Text( "Die Funktion 'GetAccountHistorieStatistik' konnte in der DLL Datei '" );
        msg->append( pfad->getText() );
        msg->append( "' nicht gefunden werden." );
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), msg, new Text( "Ok" ) );
        pfad->release();
        return 0;
    }
    pfad->release();
    statistik = startFunk();
    if( !statistik )
    {
        if( dllHandle )
        {
            Framework::getDLLRegister()->releaseDLL( *dllName );
            dllHandle = 0;
        }
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Für diese Spielart ist keine genauere Ansicht der Spiel Ergebnisse verfügbar." ), new Text( "Ok" ) );
        return 0;
    }
    this->spielId = spielId;
    statistik->setUIFactory( uiFactory );
    start();
    return 1;
}

void AHSpielStatistik::thread()
{
    laden->setSichtbar( 1 );
    KSGClient::HistorieServerClient *historieClient = infoClient->createHistorieServerClient( spielId );
    if( !historieClient )
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( infoClient->getLetzterFehler() ), new Text( "Ok" ) );
    else
    {
        if( !historieClient->downloadSpielHistorie() )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( historieClient->getLetzterFehler() ), new Text( "Ok" ) );
        else
        {
            statistik->ladeDaten( spielId );
            if( sichtbar )
                statistik->setSichtbar( 1 );
            laden->setSichtbar( 0 );
            historieClient->release();
            return;
        }
        historieClient->release();
    }
    laden->setSichtbar( 0 );
    setSichtbar( 0 );
}

void AHSpielStatistik::setPosition( int x, int y )
{
    statistikF->setPosition( x, y );
}

void AHSpielStatistik::setSichtbar( bool sichtbar )
{
    if( !statistik )
        return;
    if( !run )
        statistik->setSichtbar( sichtbar );
    this->sichtbar = sichtbar;
    if( sichtbar && !alpha )
        alpha = 1;
}

void AHSpielStatistik::doPublicMausEreignis( MausEreignis &me )
{
    if( !statistik || alpha != 255 )
        return;
    me.mx -= 1 + statistikF->getX();
    me.my -= 20 + statistikF->getY();
    statistik->doPublicMausEreignis( me );
    if( statistik->wurdeGeschlossen() )
        setSichtbar( 0 );
    me.mx += 1 + statistikF->getX();
    me.my += 20 + statistikF->getY();
}

void AHSpielStatistik::doTastaturEreignis( TastaturEreignis &te )
{
    if( !statistik || alpha != 255 )
        return;
    statistik->doTastaturEreignis( te );
}

bool AHSpielStatistik::tick( double tickVal )
{
    if( !statistik || !alpha )
        return 0;
    bool ret = statistik->tick( tickVal );
    ret |= laden->tick( tickVal );
    this->tickVal += tickVal * 150;
    int val = (int)this->tickVal;
    this->tickVal -= val;
    if( val )
    {
        if( sichtbar && alpha != 255 )
        {
            if( alpha + val > 255 )
                alpha = 255;
            else
                alpha += (unsigned char)val;
            ret = 1;
        }
        if( !sichtbar && alpha )
        {
            if( alpha - val < 0 )
                alpha = 0;
            else
                alpha -= (unsigned char)val;
            if( !alpha && statistik->istNochSichtbar() )
                alpha = 1;
            ret = 1;
        }
    }
    return ret;
}

void AHSpielStatistik::render( Bild &zRObj )
{
    if( !statistik || !alpha )
        return;
    zRObj.setAlpha( alpha );
    statistikF->render( zRObj );
    if( !zRObj.setDrawOptions( statistikF->getX() + 1, statistikF->getY() + 21, statistikF->getBreite() - 2, statistikF->getHeight() - 22 ) )
    {
        zRObj.releaseAlpha();
        return;
    }
    statistik->render( zRObj );
    zRObj.releaseDrawOptions();
    laden->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
bool AHSpielStatistik::istNochSichtbar() const
{
    if( alpha )
        return 1;
    return statistik ? statistik->istNochSichtbar() : 0;
}


// Inahlt der AHSpielVideo Klasse aus AccountHistorie.h
// Konstruktor
AHSpielVideo::AHSpielVideo()
    : Thread()
{
    videoF = initFenster( 10, 40, 780, 450, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Rahmen, "Spiel Aufzeichnung" );
    laden = (Animation2D *)ladeAnimation->dublizieren();
    laden->setSichtbar( 0 );
    laden->setPosition( 380, 245 );
    dllName = new Text( "" );
    dllHandle = 0;
    alpha = 0;
    sichtbar = 0;
    video = 0;
    tickVal = 0;
}

// Destruktor
AHSpielVideo::~AHSpielVideo()
{
    videoF->release();
    if( dllHandle )
        reset();
    dllName->release();
    laden->release();
}

// nicht constant
void AHSpielVideo::reset()
{
    if( run )
        warteAufThread( INFINITE );
    if( dllHandle )
    {
        if( video )
            video = (AufzeichnungV *)video->release();
        Framework::getDLLRegister()->releaseDLL( *dllName );
        dllHandle = 0;
    }
}

bool AHSpielVideo::ladeDaten( int spielId, int karteId )
{
    if( dllHandle )
        reset();
    KartenLeser *reader = KartenLeser::getInstance();
    reader->lock();
    reader->setKarteId( karteId );
    Text *pfad = reader->getSpielPfad();
    if( !pfad )
    {
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( reader->getLetzterFehler() ), new Text( "Ok" ) );
        reader->unlock();
        reader->release();
        return 0;
    }
    pfad->append( "bin/" );
    Text *spielArtName = reader->getSpielName();
    if( !spielArtName )
    {
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( reader->getLetzterFehler() ), new Text( "Ok" ) );
        reader->unlock();
        reader->release();
        pfad->release();
        return 0;
    }
    pfad->append( spielArtName->getText() );
    pfad->append( ".dll" );
    reader->unlock();
    reader->release();
    dllName->setText( "Spiele/" );
    dllName->append( spielArtName->getText() );
    dllName->append( ".dll" );
    spielArtName->release();
    dllHandle = Framework::getDLLRegister()->ladeDLL( *dllName, *pfad );
    if( !dllHandle )
    {
        Text *msg = new Text( "Die DLL Datei '" );
        msg->append( pfad->getText() );
        msg->append( "' konnte nicht geladen werden." );
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), msg, new Text( "Ok" ) );
        pfad->release();
        return 0;
    }
    AHSADLLStart startFunk = (AHSADLLStart)GetProcAddress( dllHandle, "GetAufzeichnung" );
    if( !startFunk )
    {
        if( dllHandle )
        {
            Framework::getDLLRegister()->releaseDLL( *dllName );
            dllHandle = 0;
        }
        Text *msg = new Text( "Die Funktion 'GetAufzeichnung' konnte in der DLL Datei '" );
        msg->append( pfad->getText() );
        msg->append( "' nicht gefunden werden." );
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), msg, new Text( "Ok" ) );
        pfad->release();
        return 0;
    }
    pfad->release();
    video = startFunk();
    if( !video )
    {
        if( dllHandle )
        {
            Framework::getDLLRegister()->releaseDLL( *dllName );
            dllHandle = 0;
        }
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Für diese Spielart ist keine Aufzeichnung verfügbar." ), new Text( "Ok" ) );
        return 0;
    }
    this->spielId = spielId;
    video->setUIFactory( uiFactory );
    start();
    return 1;
}

void AHSpielVideo::thread()
{
    laden->setSichtbar( 1 );
    KSGClient::HistorieServerClient *historieClient = infoClient->createHistorieServerClient( spielId );
    if( !historieClient )
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Daten für dieses Spiel können zur Zeit nicht abgerufen werden." ), new Text( "Ok" ) );
    else
    {
        if( !historieClient->downloadSpielHistorie() )
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( historieClient->getLetzterFehler() ), new Text( "Ok" ) );
        historieClient->release();
    }
    video->ladeSpiel( spielId );
    laden->setSichtbar( 0 );
    if( sichtbar )
    {
        nachLogin->setSpielAufzeichnung( dynamic_cast<AufzeichnungV *>( video->getThis() ) );
        aktion = 7; // Aufzeichnung betreten
    }
    run = 0;
}

void AHSpielVideo::setSichtbar( bool sichtbar )
{
    if( !video )
        return;
    if( sichtbar && !run )
    {
        nachLogin->setSpielAufzeichnung( dynamic_cast<AufzeichnungV *>( video->getThis() ) );
        aktion = 7; // Aufzeichnung betreten
    }
    this->sichtbar = sichtbar;
    if( sichtbar && !alpha )
        alpha = 1;
}

bool AHSpielVideo::tick( double tickVal )
{
    if( !video || !alpha )
        return 0;
    if( video->hatVerlassen( 0 ) && sichtbar )
        setSichtbar( 0 );
    bool ret = laden->tick( tickVal );
    this->tickVal += tickVal * 150;
    int val = (int)this->tickVal;
    this->tickVal -= val;
    if( val )
    {
        if( sichtbar && alpha != 255 )
        {
            if( alpha + val > 255 )
                alpha = 255;
            else
                alpha += (unsigned char)val;
            ret = 1;
        }
        if( !sichtbar && alpha )
        {
            if( alpha - val < 0 )
                alpha = 0;
            else
                alpha -= (unsigned char)val;
            ret = 1;
        }
    }
    return ret;
}

void AHSpielVideo::render( Bild &zRObj )
{
    if( !video || !alpha )
        return;
    if( !zRObj.setDrawOptions( 0, 0, videoF->getBreite() + 10, videoF->getHeight() + 40 ) )
        return;
    zRObj.setAlpha( alpha );
    videoF->render( zRObj );
    laden->render( zRObj );
    zRObj.releaseAlpha();
    zRObj.releaseDrawOptions();
}

// constant
bool AHSpielVideo::istNochSichtbar() const
{
    return alpha != 0;
}


// Inhalt der AHSLETeamListeSpieler Klasse aus AccountHistorie.h
// Konstruktor
AHSLETeamListeSpieler::AHSLETeamListeSpieler( char *name, int punkte, char *status, int farbe, int br )
    : ReferenceCounter(),
    nameTF( initTextFeld( 5, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, name ) ),
    punkteTF( initTextFeld( 110, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Punkte: " ) += punkte ) ),
    statusTF( initTextFeld( 215, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, status ) ),
    ram( new LRahmen() )
{
    TextRenderer tr( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
    tr.setSchriftSize( 12 );
    nameTF->setSize( tr.getTextBreite( nameTF->zText()->getText() ) + 5, 20 );
    punkteTF->setSize( tr.getTextBreite( punkteTF->zText()->getText() ) + 5, 20 );
    statusTF->setSize( tr.getTextBreite( statusTF->zText()->getText() ) + 5, 20 );
    if( nameTF->getBreite() > 100 )
        punkteTF->setPosition( 10 + nameTF->getBreite(), 0 );
    if( punkteTF->getX() + punkteTF->getBreite() > 210 )
        statusTF->setPosition( punkteTF->getX() + punkteTF->getBreite() + 5, 0 );
    ram->setFarbe( farbe );
    ram->setSize( br, 20 );
    ram->setRamenBreite( 1 );
}

// Destruktor
AHSLETeamListeSpieler::~AHSLETeamListeSpieler()
{
    nameTF->release();
    punkteTF->release();
    statusTF->release();
    ram->release();
}

// nicht constant
void AHSLETeamListeSpieler::render( int yOff, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 2, yOff, ram->getBreite(), ram->getHeight() ) )
        return;
    nameTF->render( zRObj );
    punkteTF->render( zRObj );
    statusTF->render( zRObj );
    ram->render( zRObj );
    zRObj.releaseDrawOptions();
}


// Inhalt der AHSLETeamListeTeam Klasse aus AccountHistorie.h
// Konstruktor
AHSLETeamListeTeam::AHSLETeamListeTeam( char *name, int sAnz, char *status, int farbe, int br )
    : ReferenceCounter(),
    nameTF( initTextFeld( 5, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, name ) ),
    sAnzahlTF( initTextFeld( 110, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Spieleranzahl: " ) += sAnz ) ),
    statusTF( initTextFeld( 215, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, status ) ),
    ram( new LRahmen() ),
    members( new RCArray< AHSLETeamListeSpieler >() )
{
    TextRenderer tr( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
    tr.setSchriftSize( 12 );
    nameTF->setSize( tr.getTextBreite( nameTF->zText()->getText() ) + 5, 20 );
    sAnzahlTF->setSize( tr.getTextBreite( sAnzahlTF->zText()->getText() ) + 5, 20 );
    statusTF->setSize( tr.getTextBreite( statusTF->zText()->getText() ) + 5, 20 );
    if( nameTF->getBreite() > 100 )
        sAnzahlTF->setPosition( 10 + nameTF->getBreite(), 0 );
    if( sAnzahlTF->getX() + sAnzahlTF->getBreite() > 210 )
        statusTF->setPosition( sAnzahlTF->getX() + sAnzahlTF->getBreite() + 5, 0 );
    ram->setFarbe( farbe );
    ram->setSize( br, 20 );
    ram->setRamenBreite( 1 );
}

// Destruktor
AHSLETeamListeTeam::~AHSLETeamListeTeam()
{
    nameTF->release();
    sAnzahlTF->release();
    statusTF->release();
    ram->release();
    members->release();
}

// nicht constant
void AHSLETeamListeTeam::addSpieler( AHSLETeamListeSpieler *s )
{
    members->add( s );
    int maxHö = 20;
    int anz = members->getEintragAnzahl();
    if( anz )
        maxHö += 4 + 20 * anz;
    ram->setSize( ram->getBreite(), maxHö );
}

void AHSLETeamListeTeam::render( int xOff, int yOff, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( xOff, yOff, ram->getBreite(), ram->getHeight() ) )
        return;
    nameTF->render( zRObj );
    sAnzahlTF->render( zRObj );
    statusTF->render( zRObj );
    ram->render( zRObj );
    yOff = 22;
    int anz = members->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        members->z( i )->render( yOff, zRObj );
        yOff += 20;
    }
    zRObj.releaseDrawOptions();
}

// constant
int AHSLETeamListeTeam::getHeight() const
{
    return ram->getHeight();
}


// Inhalt der AHSLETeamListe Klasse aus AccountHistorie.h
// Konstruktor
AHSLETeamListe::AHSLETeamListe( int xPos )
    : ReferenceCounter(),
    members( new RCArray< AHSLETeamListeTeam >() ),
    xPos( xPos )
{}

// Destruktor
AHSLETeamListe::~AHSLETeamListe()
{
    members->release();
}

// nicht constant
void AHSLETeamListe::addTeam( AHSLETeamListeTeam *t )
{
    members->add( t );
}

void AHSLETeamListe::render( Bild &zRObj )
{
    int y = 25;
    int anz = members->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        members->z( i )->render( xPos, y, zRObj );
        y += members->z( i )->getHeight();
    }
}

// constant
int AHSLETeamListe::getHeight() const
{
    int anz = members->getEintragAnzahl();
    int hö = 0;
    for( int i = 0; i < anz; i++ )
        hö += members->z( i )->getHeight();
    return hö;
}

int AHSLETeamListe::getBreite() const
{
    return 730 - xPos;
}


// Inhalt der AHSpielListeEintrag Klasse aus AccountHistorie.h
// Konstruktor
AHSpielListeEintrag::AHSpielListeEintrag( int id, int karteId, char *spiel, char *karte, char *datum, char *status,
                                          char *dauer, char *spielStatus, char *gewinner, int sAnzahl )
    : ReferenceCounter(),
    spielTF( initTextFeld( 5, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Spiel: " ) += spiel ) ),
    karteTF( initTextFeld( 110, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Karte: " ) += karte ) ),
    datumTF( initTextFeld( 215, 0, 180, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Datum: " ) += datum ) ),
    statusTF( initTextFeld( 400, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, Text( "Status: " ) += status ) ),
    spiel( new Text( spiel ) ),
    karte( new Text( karte ) ),
    datum( new Text( datum ) ),
    status( new Text( status ) ),
    detailsK( initKnopf( 715, 0, 20, 20, 0, "" ) ),
    dauerTF( initTextFeld( 5, 25, 100, 20, TextFeld::Style::Text, Text( "Dauer: " ) += dauer ) ),
    spielStatusTF( initTextFeld( 5, 45, 100, 20, TextFeld::Style::Text, Text( "Status: " ) += spielStatus ) ),
    gewinnerTF( initTextFeld( 5, 65, 100, 20, TextFeld::Style::Text, Text( "Gewinner: " ) += gewinner ) ),
    sAnzahlTF( initTextFeld( 5, 85, 100, 20, TextFeld::Style::Text, Text( "Spieleranzahl: " ) += sAnzahl ) ),
    statistikK( initKnopf( 5, 105, 100, 20, Knopf::Style::Sichtbar, "Statistik" ) ),
    videoK( initKnopf( 5, 130, 100, 20, Knopf::Style::Sichtbar, "Aufzeichnung" ) ),
    liste( 0 ),
    ram( new LRahmen() ),
    ausklappen( bilder->get( "data/client/bilder/account.ltdb/ausklappen.png" ) ),
    einklappen( bilder->get( "data/client/bilder/account.ltdb/einklappen.png" ) ),
    id( id ),
    karteId( karteId ),
    tickVal( 0 ),
    aktion( 0 ),
    maxHö( 155 )
{
    detailsK->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    detailsK->setHintergrundBildZ( dynamic_cast<Bild *>( ausklappen->getThis() ) );
    initToolTip( detailsK, "Details anzeigen." );
    TextRenderer tr( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
    tr.setSchriftSize( 12 );
    spielTF->setSize( tr.getTextBreite( spielTF->zText()->getText() ) + 5, 20 );
    karteTF->setSize( tr.getTextBreite( karteTF->zText()->getText() ) + 5, 20 );
    datumTF->setSize( tr.getTextBreite( datumTF->zText()->getText() ) + 5, 20 );
    statusTF->setSize( tr.getTextBreite( statusTF->zText()->getText() ) + 5, 20 );
    dauerTF->setSize( tr.getTextBreite( dauerTF->zText()->getText() ), 20 );
    spielStatusTF->setSize( tr.getTextBreite( spielStatusTF->zText()->getText() ), 20 );
    gewinnerTF->setSize( tr.getTextBreite( gewinnerTF->zText()->getText() ), 20 );
    sAnzahlTF->setSize( tr.getTextBreite( sAnzahlTF->zText()->getText() ), 20 );
    if( spielTF->getBreite() > 100 )
        karteTF->setPosition( 10 + spielTF->getBreite(), 0 );
    if( karteTF->getX() + karteTF->getBreite() > 210 )
        datumTF->setPosition( karteTF->getX() + karteTF->getBreite() + 5, 0 );
    if( datumTF->getX() + datumTF->getBreite() > 395 )
        statusTF->setPosition( datumTF->getX() + datumTF->getBreite() + 5, 0 );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setSize( 735, 20 );
    ram->setRamenBreite( 1 );
    int br = dauerTF->getBreite();
    br = br > spielStatusTF->getBreite() ? br : spielStatusTF->getBreite();
    br = br > gewinnerTF->getBreite() ? br : gewinnerTF->getBreite();
    br = br > sAnzahlTF->getBreite() ? br : sAnzahlTF->getBreite();
    statistikK->setSize( br, statistikK->getHeight() );
    videoK->setSize( br, videoK->getHeight() );
    liste = new AHSLETeamListe( br + 10 );
}

// Destruktor
AHSpielListeEintrag::~AHSpielListeEintrag()
{
    spielTF->release();
    karteTF->release();
    datumTF->release();
    statusTF->release();
    spiel->release();
    karte->release();
    datum->release();
    status->release();
    detailsK->release();
    dauerTF->release();
    spielStatusTF->release();
    gewinnerTF->release();
    sAnzahlTF->release();
    statistikK->release();
    videoK->release();
    liste->release();
    ram->release();
    einklappen->release();
    ausklappen->release();
}

// nicht constant
void AHSpielListeEintrag::addTeam( AHSLETeamListeTeam *t )
{
    liste->addTeam( t );
    maxHö = liste->getHeight();
    maxHö = 155 > maxHö + 30 ? 155 : maxHö + 30;
}

bool AHSpielListeEintrag::tick( double tickVal )
{
    bool ret = detailsK->tick( tickVal );
    ret |= statistikK->tick( tickVal );
    ret |= videoK->tick( tickVal );
    this->tickVal += tickVal * 150;
    int val = (int)this->tickVal;
    this->tickVal -= val;
    if( val )
    {
        if( detailsK->zHintergrundBild() == ausklappen && ram->getHeight() != 20 )
        {
            if( ram->getHeight() - val < 20 )
                ram->setSize( ram->getBreite(), 20 );
            else
                ram->setSize( ram->getBreite(), ram->getHeight() - val );
            ret = 1;
        }
        if( detailsK->zHintergrundBild() == einklappen )
        {
            if( ram->getHeight() > maxHö )
            {
                if( ram->getHeight() - val < maxHö )
                    ram->setSize( ram->getBreite(), maxHö );
                else
                    ram->setSize( ram->getBreite(), ram->getHeight() - val );
                ret = 1;
            }
            if( ram->getHeight() < maxHö )
            {
                if( ram->getHeight() + val > maxHö )
                    ram->setSize( ram->getBreite(), maxHö );
                else
                    ram->setSize( ram->getBreite(), ram->getHeight() + val );
                ret = 1;
            }
        }
    }
    return ret;
}

void AHSpielListeEintrag::doPublicMausEreignis( MausEreignis &me )
{
    bool meVera = 0;
    bool meVeraTmp = 0;
    if( me.mx < 0 || me.my < 0 || me.mx >= ram->getBreite() || me.my >= ram->getHeight() )
    {
        meVeraTmp = me.verarbeitet;
        me.verarbeitet = 1;
        meVera = 1;
    }
    int vera = me.verarbeitet;
    detailsK->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        if( detailsK->zHintergrundBild() == einklappen )
            detailsK->setHintergrundBildZ( dynamic_cast<Bild *>( ausklappen->getThis() ) );
        else
            detailsK->setHintergrundBildZ( dynamic_cast<Bild *>( einklappen->getThis() ) );
    }
    vera = me.verarbeitet;
    statistikK->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 1;
    vera = me.verarbeitet;
    videoK->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
        aktion = 2;
    if( meVera )
        me.verarbeitet = meVeraTmp;
}

void AHSpielListeEintrag::render( int yOff, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 5, yOff, ram->getBreite(), ram->getHeight() ) )
        return;
    ram->render( zRObj );
    if( ram->getHeight() > 20 )
        zRObj.drawLinieH( 1, 20, ram->getBreite() - 2, ram->getFarbe() );
    if( !zRObj.setDrawOptions( 1, 1, ram->getBreite() - 2, ram->getHeight() - 2 ) )
    {
        zRObj.releaseDrawOptions();
        return;
    }
    spielTF->render( zRObj );
    karteTF->render( zRObj );
    datumTF->render( zRObj );
    statusTF->render( zRObj );
    detailsK->render( zRObj );
    dauerTF->render( zRObj );
    spielStatusTF->render( zRObj );
    gewinnerTF->render( zRObj );
    sAnzahlTF->render( zRObj );
    statistikK->render( zRObj );
    videoK->render( zRObj );
    liste->render( zRObj );
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

int AHSpielListeEintrag::getAktion()
{
    int ret = aktion;
    aktion = 0;
    return ret;
}

// constant
int AHSpielListeEintrag::getKarteId() const
{
    return karteId;
}

int AHSpielListeEintrag::getHeight() const
{
    return ram->getHeight();
}

int AHSpielListeEintrag::getId() const
{
    return id;
}

int AHSpielListeEintrag::getListeBreite() const
{
    return liste->getBreite();
}

Text *AHSpielListeEintrag::zSpiel() const
{
    return spiel;
}

Text *AHSpielListeEintrag::zKarte() const
{
    return karte;
}

Text *AHSpielListeEintrag::zDatum() const
{
    return datum;
}

Text *AHSpielListeEintrag::zStatus() const
{
    return status;
}


// Inhalt der AHSpielListe Klasse aus AccountHistorie.h
// Konstruktor
AHSpielListe::AHSpielListe()
    : Zeichnung(),
    ram( new LRahmen() ),
    scroll( new VScrollBar() ),
    members( new RCArray< AHSpielListeEintrag >() ),
    sortSpalte( new Text( "Spiel" ) ),
    sortAbsteigend( 0 )
{
    pos = Punkt( 10, 40 );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setRamenBreite( 1 );
    ram->setSize( 760, 380 );
    scroll->update( 0, 380 );
}

// Destruktor
AHSpielListe::~AHSpielListe()
{
    ram->release();
    scroll->release();
    members->release();
    sortSpalte->release();
}

// privat
int AHSpielListe::getReihenfolge( int *arr )
{
    lockZeichnung();
    int anz = members->getEintragAnzahl();
    if( !anz )
    {
        unlockZeichnung();
        return 0;
    }
    int ret = 0;
    bool *fertig = new bool[ anz ];
    ZeroMemory( fertig, anz );
    for( int i = 0; i < anz; i++ )
    {
        int index = -1;
        Text minMaxT;
        Zeit minMaxZ;
        for( int j = 0; j < anz; j++ )
        {
            AHSpielListeEintrag *tmp = members->z( j );
            if( sortSpalte->istGleich( "Spiel" ) && !fertig[ j ] && ( index < 0 ||
                                                                      ( sortAbsteigend && *tmp->zSpiel() > minMaxT ) || ( !sortAbsteigend && *tmp->zSpiel() < minMaxT ) ) )
            {
                minMaxT = tmp->zSpiel()->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Karte" ) && !fertig[ j ] && ( index < 0 ||
                                                                           ( sortAbsteigend && *tmp->zKarte() > minMaxT ) || ( !sortAbsteigend && *tmp->zKarte() < minMaxT ) ) )
            {
                minMaxT = tmp->zKarte()->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Datum" ) && !fertig[ j ] && ( index < 0 ||
                                                                           ( sortAbsteigend && minMaxZ.istKleiner( "y-m-d h:i", tmp->zDatum()->getText() ) ) ||
                                                                           ( !sortAbsteigend && minMaxZ.istLater( "y-m-d h:i", tmp->zDatum()->getText() ) ) ) )
            {
                minMaxZ.setZeit( "y-m-d h:i", tmp->zDatum()->getText() );
                index = j;
            }
            else if( sortSpalte->istGleich( "Status" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && *tmp->zStatus() > minMaxT ) || ( !sortAbsteigend && *tmp->zStatus() < minMaxT ) ) )
            {
                minMaxT = tmp->zStatus()->getText();
                index = j;
            }
        }
        if( index < 0 )
            break;
        fertig[ index ] = 1;
        arr[ ret ] = index;
        ret++;
    }
    delete[] fertig;
    unlockZeichnung();
    return ret;
}

// nicht constant
void AHSpielListe::setSortSpalte( char *sp )
{
    lockZeichnung();
    sortSpalte->setText( sp );
    unlockZeichnung();
}

void AHSpielListe::setSortRichtung( bool absteigend )
{
    sortAbsteigend = absteigend;
}

void AHSpielListe::reset()
{
    lockZeichnung();
    members->leeren();
    unlockZeichnung();
}

void AHSpielListe::addSpiel( AHSpielListeEintrag *s )
{
    lockZeichnung();
    members->add( s );
    unlockZeichnung();
}

bool AHSpielListe::tick( double tickVal )
{
    bool ret = scroll->getRend();
    lockZeichnung();
    int anz = members->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        ret |= members->z( i )->tick( tickVal );
    unlockZeichnung();
    return ret;
}

void AHSpielListe::doPublicMausEreignis( MausEreignis &me )
{
    bool vera = 0;
    if( me.mx - pos.x <= 0 || me.mx - pos.x >= ram->getBreite() || me.my - pos.y <= 0 || me.my - pos.y >= ram->getHeight() )
    {
        vera = 1;
        me.verarbeitet = 1;
    }
    int mx = me.mx, my = me.my;
    me.mx -= pos.x;
    me.my -= pos.y;
    scroll->doMausMessage( ram->getBreite() - 16, 1, 15, ram->getHeight() - 2, me );
    me.mx -= 5;
    me.my -= 5 - scroll->getScroll();
    lockZeichnung();
    int anz = members->getEintragAnzahl();
    int *rf = new int[ anz ];
    int rfAnz = getReihenfolge( rf );
    for( int i = 0; i < rfAnz; i++ )
    {
        members->z( rf[ i ] )->doPublicMausEreignis( me );
        me.my -= members->z( rf[ i ] )->getHeight() + 5;
    }
    delete[] rf;
    unlockZeichnung();
    me.mx = mx, me.my = my;
    if( vera )
        me.verarbeitet = 0;
}

void AHSpielListe::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( pos, ram->getSize() ) )
        return;
    ram->render( zRObj );
    scroll->render( ram->getBreite() - 16, 1, 15, ram->getHeight() - 2, zRObj );
    if( !zRObj.setDrawOptions( 1, 1, ram->getBreite() - 15, ram->getHeight() - 2 ) )
    {
        zRObj.releaseDrawOptions();
        return;
    }
    int anzHö = 5;
    lockZeichnung();
    int anz = members->getEintragAnzahl();
    int *rf = new int[ anz ];
    int rfAnz = getReihenfolge( rf );
    for( int i = 0; i < rfAnz; i++ )
    {
        members->z( rf[ i ] )->render( anzHö - scroll->getScroll(), zRObj );
        anzHö += members->z( rf[ i ] )->getHeight() + 5;
    }
    delete[] rf;
    unlockZeichnung();
    scroll->update( anzHö, ram->getHeight() - 2 );
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

// constant
int AHSpielListe::getAktion( int *spielId, int *karteId ) const
{
    int anz = members->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        int ak = members->z( i )->getAktion();
        if( ak )
        {
            *spielId = members->z( i )->getId();
            *karteId = members->z( i )->getKarteId();
            return ak;
        }
    }
    return 0;
}


// Inhalt der AccountHistorie Klasse aus AccountHistorie.h
// Konstruktor
AccountHistorie::AccountHistorie()
    : Thread(),
    historieF( initFenster( 810, 40, 780, 450, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Rahmen | Fenster::Style::Erlaubt, "Historie von " ) ),
    sortSpalte( initAuswahlBox( 10, 10, 150, 20, ABSTYLE, { "Spiel", "Karte", "Datum", "Status" } ) ),
    sortRichtung( initAuswahlBox( 170, 10, 150, 20, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
    liste( new AHSpielListe() ),
    statistik( new AHSpielStatistik() ),
    video( new AHSpielVideo() ),
    status( 0 ),
    accId( 0 ),
    animation( 0 ),
    alpha( 255 ),
    alpha2( 255 ),
    alpha3( 255 ),
    tickVal( 0 ),
    rend( 0 )
{
    initToolTip( sortSpalte, "Wähle aus, nach welcher Spalte die\nTabelle sortiert werden soll." );
    initToolTip( sortRichtung, "Wähle aus, ob Aufwärts oder Abwärts\nsortiert werden soll." );
    historieF->addMember( dynamic_cast<Zeichnung *>( liste->getThis() ) );
    historieF->addMember( dynamic_cast<Zeichnung *>( sortSpalte->getThis() ) );
    historieF->addMember( dynamic_cast<Zeichnung *>( sortRichtung->getThis() ) );
    historieF->setMausEreignis( _ret1ME );
}

// Destruktor
AccountHistorie::~AccountHistorie()
{
    statistik->warteAufThread( 10000 );
    statistik->ende();
    video->warteAufThread( 10000 );
    video->ende();
    historieF->release();
    sortSpalte->release();
    sortRichtung->release();
    statistik->release();
    liste->release();
    video->release();
}

// nicht constant
void AccountHistorie::reset()
{
    liste->reset();
    statistik->reset();
    video->reset();
}

void AccountHistorie::ladeStatistik( int accId )
{
    if( this->accId == accId )
        return;
    this->status = 0;
    if( run )
    {
        warteAufThread( 1000 );
        ende();
    }
    if( ( animation | 0x1 ) == animation )
    {
        animation |= 0x4;
        this->accId = accId;
        this->status = 1;
        return;
    }
    if( this->accId )
        reset();
    this->accId = accId;
    start();
    this->status = 1;
}

void AccountHistorie::thread()
{
    Text *name = infoClient->getSpielerName( accId );
    if( name )
    {
        name->insert( 0, "Historie von " );
        historieF->setTitel( *name );
        name->release();
    }
    Array< KSGClient::SpielHistorieDaten > *daten = infoClient->getSpielHistorieDaten( accId );
    int anz = daten->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
    {
        KSGClient::SpielHistorieDaten spiel = daten->get( i );
        AHSpielListeEintrag *spielE = new AHSpielListeEintrag( spiel.id, spiel.karteId, spiel.spiel, spiel.karte,
                                                               spiel.datum, spiel.status, spiel.dauer,
                                                               spiel.spielStatus, spiel.gewinner, spiel.sAnzahl );
        int tAnz = spiel.teams.getEintragAnzahl();
        for( int j = 0; j < tAnz; j++ )
        {
            KSGClient::SpielHistorieTeamDaten team = spiel.teams.get( j );
            AHSLETeamListeTeam *teamE = new AHSLETeamListeTeam( team.name, team.sAnzahl, team.status,
                                                                team.farbe, spielE->getListeBreite() );
            int sAnz = team.spieler.getEintragAnzahl();
            for( int k = 0; k < sAnz; k++ )
            {
                KSGClient::SpielHistorieSpielerDaten spieler = team.spieler.get( k );
                AHSLETeamListeSpieler *spielerE = new AHSLETeamListeSpieler( spieler.name, spieler.punkte, spieler.status,
                                                                             spieler.farbe, spielE->getListeBreite() - 4 );
                teamE->addSpieler( spielerE );
            }
            spielE->addTeam( teamE );
        }
        liste->addSpiel( spielE );
    }
    daten->release();
    animation &= ~0x4;
    status = 2;
    run = 0;
}

void AccountHistorie::setSichtbar( bool sichtbar, bool nachRechts )
{
    if( sichtbar )
    {
        if( ( animation | 0x1 ) != animation || ( ( nachRechts && ( animation | 0x2 ) != animation ) || !nachRechts && ( animation | 0x2 ) == animation ) )
        {
            if( nachRechts )
                historieF->setPosition( -810, 40 );
            else
                historieF->setPosition( 810, 40 );
        }
        animation |= 0x1;
    }
    else
        animation &= ~0x1;
    if( nachRechts )
        animation |= 0x2;
    else
        animation &= ~0x2;
}

bool AccountHistorie::tick( double zeit )
{
    if( !statistik->istNochSichtbar() && !video->istNochSichtbar() )
        rend |= historieF->tick( zeit );
    rend |= statistik->tick( zeit );
    rend |= video->tick( zeit );
    tickVal += zeit;
    int valA = (int)( tickVal * 150 );
    int valB = (int)( tickVal * 500 );
    tickVal -= valA / 150.0;
    if( valA )
    {
        if( ( animation | 0x8 ) == animation && alpha2 )
        {
            if( alpha2 - valA <= 0 )
            {
                alpha2 = 0;
                statistik->setSichtbar( 1 );
            }
            else
                alpha2 -= valA;
            rend = 1;
        }
        if( ( animation | 0x8 ) != animation && alpha2 != 255 )
        {
            if( alpha2 + valA >= 255 )
                alpha2 = 255;
            else
                alpha2 += valA;
            rend = 1;
        }
        if( ( animation | 0x10 ) == animation && alpha3 )
        {
            if( alpha3 - valA <= 0 )
            {
                alpha3 = 0;
                video->setSichtbar( 1 );
            }
            else
                alpha3 -= valA;
            rend = 1;
        }
        if( ( animation | 0x10 ) != animation && alpha3 != 255 )
        {
            if( alpha3 + valA >= 255 )
                alpha3 = 255;
            else
                alpha3 += valA;
            rend = 1;
        }
        if( ( animation | 0x4 ) == animation && alpha )
        {
            if( alpha - valA <= 0 )
                alpha = 0;
            else
                alpha -= valA;
            rend = 1;
            if( !alpha )
            {
                reset();
                start();
            }
        }
        if( ( animation | 0x4 ) != animation && alpha != 255 )
        {
            if( alpha + valA >= 255 )
                alpha = 255;
            else
                alpha += valA;
            rend = 1;
        }
    }
    if( valB )
    {
        if( ( animation | 0x1 ) == animation )
        { // Sichtbar
            if( ( animation | 0x2 ) == animation )
            { // Nach Rechts
                if( historieF->getX() != 10 )
                {
                    if( historieF->getX() + valB > 10 )
                        historieF->setPosition( 10, historieF->getY() );
                    else
                        historieF->setPosition( historieF->getX() + valB, historieF->getY() );
                    statistik->setPosition( historieF->getX(), historieF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( historieF->getX() != 10 )
                {
                    if( historieF->getX() - valB < 10 )
                        historieF->setPosition( 10, historieF->getY() );
                    else
                        historieF->setPosition( historieF->getX() - valB, historieF->getY() );
                    statistik->setPosition( historieF->getX(), historieF->getY() );
                    rend = 1;
                }
            }
        }
        else
        { // Unsichtbar
            if( ( animation | 0x2 ) == animation )
            { // Nach Rechts
                if( historieF->getX() != 810 )
                {
                    if( historieF->getX() + valB > 810 )
                        historieF->setPosition( 810, historieF->getY() );
                    else
                        historieF->setPosition( historieF->getX() + valB, historieF->getY() );
                    statistik->setPosition( historieF->getX(), historieF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( historieF->getX() != -810 )
                {
                    if( historieF->getX() - valB < -810 )
                        historieF->setPosition( -810, historieF->getY() );
                    else
                        historieF->setPosition( historieF->getX() - valB, historieF->getY() );
                    statistik->setPosition( historieF->getX(), historieF->getY() );
                    rend = 1;
                }
            }
        }
    }
    if( !alpha2 && !statistik->istNochSichtbar() )
    {
        animation &= ~0x8;
        statistik->reset();
    }
    if( !alpha3 && !video->istNochSichtbar() )
    {
        animation &= ~0x10;
        video->reset();
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountHistorie::doPublicMausEreignis( MausEreignis &me )
{
    if( !statistik->istNochSichtbar() && !video->istNochSichtbar() && alpha == 255 && alpha2 == 255 && alpha3 == 255 )
    {
        int sortSpalteS = sortSpalte->getAuswahl();
        int sortRichtungS = sortRichtung->getAuswahl();
        historieF->doPublicMausEreignis( me );
        if( sortSpalte->getAuswahl() != sortSpalteS )
        {
            liste->setSortSpalte( sortSpalte->zEintrag( sortSpalte->getAuswahl() )->zText()->getText() );
            sortSpalte->einklappen();
        }
        if( sortRichtung->getAuswahl() != sortRichtungS )
        {
            liste->setSortRichtung( sortRichtung->getAuswahl() != 0 );
            sortRichtung->einklappen();
        }
        int spielId = 0;
        int karteId = 0;
        int ak = liste->getAktion( &spielId, &karteId );
        if( ak == 1 )
        { // Statistik anzeigen
            if( statistik->ladeDaten( spielId, karteId ) )
                animation |= 0x8;
        }
        if( ak == 2 )
        { // Aufzeichnung abspielen
            if( video->ladeDaten( spielId, karteId ) )
                animation |= 0x10;
        }
    }
    if( statistik->istNochSichtbar() )
        statistik->doPublicMausEreignis( me );
}

void AccountHistorie::doTastaturEreignis( TastaturEreignis &te )
{
    if( statistik->istNochSichtbar() )
        statistik->doTastaturEreignis( te );
}

void AccountHistorie::render( Bild &zRObj )
{
    zRObj.setAlpha( alpha );
    if( alpha2 && alpha3 )
    {
        zRObj.setAlpha( alpha2 );
        zRObj.setAlpha( alpha3 );
        historieF->render( zRObj );
        zRObj.releaseAlpha();
        zRObj.releaseAlpha();
    }
    if( statistik->istNochSichtbar() )
        statistik->render( zRObj );
    if( video->istNochSichtbar() )
        video->render( zRObj );
    zRObj.releaseAlpha();
}

// constant
int AccountHistorie::getStatus() const
{
    return status;
}