KSG-Client/KSGClient/NachLogin/Account/Spiele_Karten/AccountSpieleUndKarten.cpp

#include "AccountSpieleUndKarten.h"
#include "../../../Global/Initialisierung.h"
#include "../../../Global/Variablen.h"
#include <Rahmen.h>
#include <DateiSystem.h>
#include <Punkt.h>
#include <ToolTip.h>
#include <AuswahlBox.h>

// Inhalt der AccountSUKListeKarte Klasse aus AccountSpieleUndKarten.h
// Konstruktor
AccountSUKListeKarte::AccountSUKListeKarte( int id, int account )
    : ReferenceCounter(),
    ram( new LRahmen() ),
    name( initTextFeld( 5, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Karte: " ) ),
    spiele( initTextFeld( 165, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Spiele: " ) ),
    gewonnen( initTextFeld( 325, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Gewonnen: " ) ),
    status( initTextFeld( 485, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Status: " ) ),
    st( new Text() ),
    karteId( id ),
    rend( 0 )
{
    na = infoClient->getKarteName( id );
    if( na )
        name->zText()->append( na->getText() );
    sp = infoClient->getAccountKarteSpiele( account, id );
    spiele->zText()->append( sp );
    gw = infoClient->getAccountKarteSpieleGewonnen( account, id );
    gewonnen->zText()->append( gw );
    if( infoClient->hatAccountKarte( account, id ) )
        st->setText( "Im Besitz" );
    else
        st->setText( "Nicht im Besitz" );
    status->zText()->append( st->getText() );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setSize( 715, 20 );
    ram->setRamenBreite( 1 );
}

// Destruktor
AccountSUKListeKarte::~AccountSUKListeKarte()
{
    ram->release();
    name->release();
    spiele->release();
    gewonnen->release();
    status->release();
    if( na )
        na->release();
    st->release();
}

// nicht constant
void AccountSUKListeKarte::render( int yOff, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 5, yOff, ram->getBreite(), ram->getHeight() ) )
        return;
    name->render( zRObj );
    spiele->render( zRObj );
    gewonnen->render( zRObj );
    status->render( zRObj );
    ram->render( zRObj );
    zRObj.releaseDrawOptions();
}

// constant
Text *AccountSUKListeKarte::zName() const
{
    return na;
}

int AccountSUKListeKarte::getSpiele() const
{
    return sp;
}

int AccountSUKListeKarte::getGewonnen() const
{
    return gw;
}

Text *AccountSUKListeKarte::zStatus() const
{
    return st;
}


// Inhalt der AccountSUKListeSpiel Klasse aus AccountSpieleUndKarten.h
// Konstruktor
AccountSUKListeSpiel::AccountSUKListeSpiel( int id, int account )
    : ReferenceCounter(),
    ram( new LRahmen() ),
    nameTF( initTextFeld( 5, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Name: " ) ),
    spieleTF( initTextFeld( 165, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Spiele: " ) ),
    gewonnenTF( initTextFeld( 325, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Gewonnen: " ) ),
    punkteTF( initTextFeld( 435, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Punkte: " ) ),
    statusTF( initTextFeld( 545, 0, 150, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Status: " ) ),
    details( initKnopf( 705, 0, 20, 20, 0, "" ) ),
    karten( new RCArray< AccountSUKListeKarte >() ),
    einklappen( bilder->get( "data/client/bilder/account.ltdb/einklappen.png" ) ),
    ausklappen( bilder->get( "data/client/bilder/account.ltdb/ausklappen.png" ) ),
    status( new Text() ),
    statusFilter( new Text( "Alle" ) ),
    sortSpalte( new Text( "Name" ) ),
    sortAbsteigend( 0 ),
    spielId( id ),
    tickVal( 0 ),
    rend( 0 )
{
    ram->setFarbe( 0xFFFFFFFF );
    ram->setRamenBreite( 1 );
    ram->setSize( 725, 20 );
    details->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
    details->setHintergrundBildZ( dynamic_cast<Bild *>( ausklappen->getThis() ) );
    initToolTip( details, "Karten anzeigen." );
    name = infoClient->getSpielName( id );
    if( name )
        nameTF->zText()->append( name->getText() );
    Array< int > *stat = new Array< int >();
    if( infoClient->getSpielStatistik( account, id, stat ) )
    {
        spiele = stat->get( 0 );
        gewonnen = stat->get( 1 );
        punkte = stat->get( 3 );
    }
    stat->release();
    spieleTF->zText()->append( spiele );
    gewonnenTF->zText()->append( gewonnen );
    punkteTF->zText()->append( punkte );
    if( infoClient->hatAccountSpiel( account, id ) )
        status->setText( "Im Besitz" );
    else
        status->setText( "Nicht im Besitz" );
    statusTF->zText()->append( status->getText() );
    Array< int > *maps = infoClient->getAccountKarteGespieltListe( account, id );
    if( maps )
    {
        int anz = maps->getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
            karten->set( new AccountSUKListeKarte( maps->get( i ), account ), i );
        maps->release();
    }
}

// Destruktor
AccountSUKListeSpiel::~AccountSUKListeSpiel()
{
    ram->release();
    nameTF->release();
    spieleTF->release();
    gewonnenTF->release();
    punkteTF->release();
    statusTF->release();
    details->release();
    karten->release();
    einklappen->release();
    ausklappen->release();
    if( name )
        name->release();
    status->release();
    statusFilter->release();
    sortSpalte->release();
}

// privat
int AccountSUKListeSpiel::getReihenfolge( int *arr )
{
    int anz = karten->getEintragAnzahl();
    if( !anz )
        return 0;
    int ret = 0;
    bool *fertig = new bool[ anz ];
    ZeroMemory( fertig, anz );
    for( int i = 0; i < anz; i++ )
    {
        int index = -1;
        int minMax = 0;
        Text minMaxT;
        for( int j = 0; j < anz; j++ )
        {
            AccountSUKListeKarte *tmp = karten->z( j );
            if( !statusFilter->istGleich( "Alle" ) && !tmp->zStatus()->istGleich( statusFilter->getText() ) )
                continue;
            if( sortSpalte->istGleich( "Name" ) && !fertig[ j ] && ( index < 0 ||
                                                                     ( sortAbsteigend && *tmp->zName() > minMaxT ) || ( !sortAbsteigend && *tmp->zName() < minMaxT ) ) )
            {
                minMaxT = tmp->zName()->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Spiele" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && tmp->getSpiele() > minMax ) || ( !sortAbsteigend && tmp->getSpiele() < minMax ) ) )
            {
                minMax = tmp->getSpiele();
                index = j;
            }
            else if( sortSpalte->istGleich( "Gewonnen" ) && !fertig[ j ] && ( index < 0 ||
                                                                              ( sortAbsteigend && tmp->getGewonnen() > minMax ) || ( !sortAbsteigend && tmp->getGewonnen() < minMax ) ) )
            {
                minMax = tmp->getGewonnen();
                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;
            }
            else if( sortSpalte->istGleich( "Punkte" ) && !fertig[ j ] )
            {
                index = j;
                break;
            }
        }
        if( index < 0 )
            break;
        fertig[ index ] = 1;
        arr[ ret ] = index;
        ret++;
    }
    delete[] fertig;
    return ret;
}

// nicht constant
void AccountSUKListeSpiel::setStatusAusw( char *status )
{
    statusFilter->setText( status );
    rend = 1;
}

void AccountSUKListeSpiel::setSortSpalte( char *spalte )
{
    sortSpalte->setText( spalte );
    rend = 1;
}

void AccountSUKListeSpiel::setSortRichtung( bool absteigend )
{
    sortAbsteigend = absteigend;
    rend = 1;
}

bool AccountSUKListeSpiel::tick( double tickVal )
{
    rend |= details->tick( tickVal );
    this->tickVal += tickVal * 150;
    int val = (int)this->tickVal;
    this->tickVal -= val;
    if( val )
    {
        if( details->zHintergrundBild() == ausklappen && ram->getHeight() != 20 )
        {
            if( ram->getHeight() - val < 20 )
                ram->setSize( ram->getBreite(), 20 );
            else
                ram->setSize( ram->getBreite(), ram->getHeight() - val );
            rend = 1;
        }
        if( details->zHintergrundBild() == einklappen )
        {
            int maxHö = 20;
            int anz = karten->getEintragAnzahl();
            for( int i = 0; i < anz; i++ )
            {
                AccountSUKListeKarte *tmp = karten->z( i );
                if( !statusFilter->istGleich( "Alle" ) && !tmp->zStatus()->istGleich( statusFilter->getText() ) )
                    continue;
                maxHö += 25;
            }
            if( maxHö > 20 )
                maxHö += 5;
            if( ram->getHeight() > maxHö )
            {
                if( ram->getHeight() - val < maxHö )
                    ram->setSize( ram->getBreite(), maxHö );
                else
                    ram->setSize( ram->getBreite(), ram->getHeight() - val );
                rend = 1;
            }
            if( ram->getHeight() < maxHö )
            {
                if( ram->getHeight() + val > maxHö )
                    ram->setSize( ram->getBreite(), maxHö );
                else
                    ram->setSize( ram->getBreite(), ram->getHeight() + val );
                rend = 1;
            }
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountSUKListeSpiel::doPublicMausEreignis( MausEreignis &me )
{
    bool vera = me.verarbeitet;
    details->doPublicMausEreignis( me );
    if( !vera && me.verarbeitet && me.id == ME_RLinks )
    {
        if( details->zHintergrundBild() == ausklappen )
        {
            details->setHintergrundBildZ( dynamic_cast<Bild *>( einklappen->getThis() ) );
            // TODO: details->zToolTip()->setText( "Karten verbergen." );
        }
        else
        {
            details->setHintergrundBildZ( dynamic_cast<Bild *>( ausklappen->getThis() ) );
            // TODO: details->zToolTip()->setText( "Karten anzeigen." );
        }
    }
}

void AccountSUKListeSpiel::render( int yOff, Bild &zRObj )
{
    if( !zRObj.setDrawOptions( 10, yOff, ram->getBreite(), ram->getHeight() ) )
        return;
    nameTF->render( zRObj );
    spieleTF->render( zRObj );
    gewonnenTF->render( zRObj );
    punkteTF->render( zRObj );
    statusTF->render( zRObj );
    details->render( zRObj );
    ram->render( zRObj );
    if( ram->getHeight() > 20 )
    {
        zRObj.drawLinieH( 0, 20, ram->getBreite(), ram->getFarbe() );
        if( !zRObj.setDrawOptions( 1, 25, ram->getBreite() - 2, ram->getHeight() - 2 ) )
        {
            zRObj.releaseDrawOptions();
            return;
        }
        int anz = karten->getEintragAnzahl();
        int *arr = new int[ anz ];
        anz = getReihenfolge( arr );
        yOff = 0;
        for( int i = 0; i < anz; i++ )
        {
            karten->z( arr[ i ] )->render( yOff, zRObj );
            yOff += 25;
        }
        delete[]arr;
        zRObj.releaseDrawOptions();
    }
    zRObj.releaseDrawOptions();
}

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

Text *AccountSUKListeSpiel::zName() const
{
    return name;
}

int AccountSUKListeSpiel::getSpiele() const
{
    return spiele;
}

int AccountSUKListeSpiel::getGewonnen() const
{
    return gewonnen;
}

int AccountSUKListeSpiel::getPunkte() const
{
    return punkte;
}

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


// Inhalt der AccountSUKListe Klasse aus AccountSpieleUndKarten.h
// Konstruktor
AccountSUKListe::AccountSUKListe()
    : Zeichnung(),
    ram( new LRahmen() ),
    scroll( new VScrollBar() ),
    spiele( new RCArray< AccountSUKListeSpiel >() ),
    status( new Text() ),
    statusFilter( new Text( "Alle" ) ),
    sortSpalte( new Text( "Name" ) ),
    sortAbsteigend( 0 ),
    rend( 0 )
{
    pos = Punkt( 10, 40 );
    ram->setSize( 760, 380 );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setRamenBreite( 1 );
}

// Destruktor
AccountSUKListe::~AccountSUKListe()
{
    ram->release();
    scroll->release();
    spiele->release();
    status->release();
    statusFilter->release();
    sortSpalte->release();
}

// privat
int AccountSUKListe::getReihenfolge( int *arr )
{
    int anz = spiele->getEintragAnzahl();
    if( !anz )
        return 0;
    int ret = 0;
    bool *fertig = new bool[ anz ];
    ZeroMemory( fertig, anz );
    for( int i = 0; i < anz; i++ )
    {
        int index = -1;
        int minMax = 0;
        Text minMaxT;
        for( int j = 0; j < anz; j++ )
        {
            AccountSUKListeSpiel *tmp = spiele->z( j );
            if( !statusFilter->istGleich( "Alle" ) && !tmp->zStatus()->istGleich( statusFilter->getText() ) )
                continue;
            if( sortSpalte->istGleich( "Name" ) && !fertig[ j ] && ( index < 0 ||
                                                                     ( sortAbsteigend && *tmp->zName() > minMaxT ) || ( !sortAbsteigend && *tmp->zName() < minMaxT ) ) )
            {
                minMaxT = tmp->zName()->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Spiele" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && tmp->getSpiele() > minMax ) || ( !sortAbsteigend && tmp->getSpiele() < minMax ) ) )
            {
                minMax = tmp->getSpiele();
                index = j;
            }
            else if( sortSpalte->istGleich( "Gewonnen" ) && !fertig[ j ] && ( index < 0 ||
                                                                              ( sortAbsteigend && tmp->getGewonnen() > minMax ) || ( !sortAbsteigend && tmp->getGewonnen() < minMax ) ) )
            {
                minMax = tmp->getGewonnen();
                index = j;
            }
            else if( sortSpalte->istGleich( "Punkte" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && tmp->getPunkte() > minMax ) || ( !sortAbsteigend && tmp->getPunkte() < minMax ) ) )
            {
                minMax = tmp->getPunkte();
                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;
    return ret;
}

// nicht constant
void AccountSUKListe::reset()
{
    lockZeichnung();
    spiele->leeren();
    unlockZeichnung();
}

void AccountSUKListe::addSpiel( AccountSUKListeSpiel *spiel )
{
    lockZeichnung();
    spiel->setSortRichtung( sortAbsteigend );
    spiel->setSortSpalte( sortSpalte->getText() );
    spiel->setStatusAusw( statusFilter->getText() );
    spiele->add( spiel );
    unlockZeichnung();
}

void AccountSUKListe::setStatusAusw( char *status )
{
    lockZeichnung();
    this->statusFilter->setText( status );
    int anz = spiele->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        spiele->z( i )->setStatusAusw( status );
    unlockZeichnung();
    rend = 1;
}

void AccountSUKListe::setSortSpalte( char *spalte )
{
    lockZeichnung();
    this->sortSpalte->setText( spalte );
    int anz = spiele->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        spiele->z( i )->setSortSpalte( spalte );
    unlockZeichnung();
    rend = 1;
}

void AccountSUKListe::setSortRichtung( bool absteigend )
{
    lockZeichnung();
    sortAbsteigend = absteigend;
    int anz = spiele->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        spiele->z( i )->setSortRichtung( absteigend );
    unlockZeichnung();
    rend = 1;
}

bool AccountSUKListe::tick( double tickVal )
{
    lockZeichnung();
    int anz = spiele->getEintragAnzahl();
    if( anz > 0 )
    {
        int *rf = new int[ anz ];
        int rfAnz = getReihenfolge( rf );
        for( int i = 0; i < rfAnz; i++ )
            rend |= spiele->z( rf[ i ] )->tick( tickVal );
        delete[] rf;
    }
    unlockZeichnung();
    rend |= scroll->getRend();
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountSUKListe::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 -= 10;
    me.my -= 10 - scroll->getScroll();
    lockZeichnung();
    int anz = spiele->getEintragAnzahl();
    int *rf = new int[ anz ];
    int rfAnz = getReihenfolge( rf );
    for( int i = 0; i < rfAnz; i++ )
    {
        spiele->z( rf[ i ] )->doPublicMausEreignis( me );
        me.my -= spiele->z( rf[ i ] )->getHeight() + 10;
    }
    delete[] rf;
    unlockZeichnung();
    me.mx = mx, me.my = my;
    if( vera )
        me.verarbeitet = 0;
}

void AccountSUKListe::render( Bild &zRObj )
{
    if( !zRObj.setDrawOptions( pos.x, pos.y, ram->getBreite(), ram->getBreite() ) )
        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 y = -scroll->getScroll();
    int anzHö = 10;
    lockZeichnung();
    int anz = spiele->getEintragAnzahl();
    int *rf = new int[ anz ];
    int rfAnz = getReihenfolge( rf );
    for( int i = 0; i < rfAnz; i++ )
    {
        spiele->z( rf[ i ] )->render( anzHö, zRObj );
        anzHö += spiele->z( rf[ i ] )->getHeight() + 10;
    }
    delete[] rf;
    unlockZeichnung();
    scroll->update( anzHö, ram->getHeight() - 2 );
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}

#define ABSTYLE AuswahlBox::Style::Sichtbar | AuswahlBox::Style::Erlaubt | AuswahlBox::Style::Rahmen | AuswahlBox::Style::AuswahlBuffer | AuswahlBox::Style::MausBuffer | AuswahlBox::Style::MaxHeight | AuswahlBox::Style::Hintergrund | AuswahlBox::Style::VScroll

// Inhalt der AccountSpieleUndKarten Klasse aus AccountSpieleUndKarten.h
// Konstruktor
AccountSpieleUndKarten::AccountSpieleUndKarten()
    : Thread(),
    spieleUndKartenF( initFenster( 810, 40, 780, 450, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Rahmen | Fenster::Style::Erlaubt, "Spiele und Karten von " ) ),
    statusAusw( initAuswahlBox( 10, 10, 150, 20, ABSTYLE, { "Alle", "Im Besitz", "Nicht im Besitz" } ) ),
    sortSpalte( initAuswahlBox( 170, 10, 150, 20, ABSTYLE, { "Name", "Spiele", "Gewonnen", "Punkte", "Status" } ) ),
    sortRichtung( initAuswahlBox( 330, 10, 150, 20, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
    liste( new AccountSUKListe() ),
    status( 0 ),
    accId( 0 ),
    animation( 0 ),
    alpha( 255 ),
    tickVal( 0 ),
    rend( 0 )
{
    initToolTip( statusAusw, "Wähle den Status der anzuzeigenden Spiele und Karten aus." );
    initToolTip( sortSpalte, "Wähle aus, nach welcher Spalte die\nTabelle sortiert werden soll." );
    initToolTip( sortRichtung, "Wähle aus, Ob Aufwärts oder Abwärts sortiert werden soll." );
    spieleUndKartenF->addMember( dynamic_cast<Zeichnung *>( liste->getThis() ) );
    spieleUndKartenF->addMember( dynamic_cast<Zeichnung *>( statusAusw->getThis() ) );
    spieleUndKartenF->addMember( dynamic_cast<Zeichnung *>( sortSpalte->getThis() ) );
    spieleUndKartenF->addMember( dynamic_cast<Zeichnung *>( sortRichtung->getThis() ) );
    spieleUndKartenF->setMausEreignis( _ret1ME );
}

// Destruktor
AccountSpieleUndKarten::~AccountSpieleUndKarten()
{
    spieleUndKartenF->release();
    statusAusw->release();
    sortSpalte->release();
    sortRichtung->release();
    liste->release();
}

// nicht constant
void AccountSpieleUndKarten::reset()
{
    liste->reset();
}

void AccountSpieleUndKarten::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 AccountSpieleUndKarten::thread()
{
    Text *name = infoClient->getSpielerName( accId );
    if( name )
    {
        name->insert( 0, "Spiele und Karten von " );
        spieleUndKartenF->setTitel( *name );
        name->release();
    }
    Array< int > *spiele = infoClient->getAccountSpielGespieltListe( accId );
    if( spiele )
    {
        int anz = spiele->getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
        {
            AccountSUKListeSpiel *s = new AccountSUKListeSpiel( spiele->get( i ), accId );
            liste->addSpiel( s );
        }
        spiele->release();
    }
    else
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Fehler beim laden der Daten." ), new Text( "Ok" ) );
    animation &= ~0x4;
    status = 2;
    run = 0;
}

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

bool AccountSpieleUndKarten::tick( double zeit )
{
    rend |= spieleUndKartenF->tick( zeit );
    tickVal += zeit;
    int valA = (int)( tickVal * 150 );
    int valB = (int)( tickVal * 500 );
    tickVal -= valA / 150.0;
    if( valA )
    {
        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( spieleUndKartenF->getX() != 10 )
                {
                    if( spieleUndKartenF->getX() + valB > 10 )
                        spieleUndKartenF->setPosition( 10, spieleUndKartenF->getY() );
                    else
                        spieleUndKartenF->setPosition( spieleUndKartenF->getX() + valB, spieleUndKartenF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( spieleUndKartenF->getX() != 10 )
                {
                    if( spieleUndKartenF->getX() - valB < 10 )
                        spieleUndKartenF->setPosition( 10, spieleUndKartenF->getY() );
                    else
                        spieleUndKartenF->setPosition( spieleUndKartenF->getX() - valB, spieleUndKartenF->getY() );
                    rend = 1;
                }
            }
        }
        else
        { // Unsichtbar
            if( ( animation | 0x2 ) == animation )
            { // Nach Rechts
                if( spieleUndKartenF->getX() != 810 )
                {
                    if( spieleUndKartenF->getX() + valB > 810 )
                        spieleUndKartenF->setPosition( 810, spieleUndKartenF->getY() );
                    else
                        spieleUndKartenF->setPosition( spieleUndKartenF->getX() + valB, spieleUndKartenF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( spieleUndKartenF->getX() != -810 )
                {
                    if( spieleUndKartenF->getX() - valB < -810 )
                        spieleUndKartenF->setPosition( -810, spieleUndKartenF->getY() );
                    else
                        spieleUndKartenF->setPosition( spieleUndKartenF->getX() - valB, spieleUndKartenF->getY() );
                    rend = 1;
                }
            }
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountSpieleUndKarten::doPublicMausEreignis( MausEreignis &me )
{
    int statusAuswS = statusAusw->getAuswahl();
    int sortSpalteS = sortSpalte->getAuswahl();
    int sortRichtungS = sortRichtung->getAuswahl();
    spieleUndKartenF->doPublicMausEreignis( me );
    if( statusAusw->getAuswahl() != statusAuswS )
    {
        liste->setStatusAusw( statusAusw->zEintrag( statusAusw->getAuswahl() )->zText()->getText() );
        statusAusw->einklappen();
    }
    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();
    }
}

void AccountSpieleUndKarten::render( Bild &zRObj )
{
    zRObj.setAlpha( alpha );
    spieleUndKartenF->render( zRObj );
    zRObj.releaseAlpha();
}

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