KSG-Client/KSGClient/NachLogin/Account/SpielPartner/AccountSpielPartner.cpp

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

#define HATSTYLE( b )  ( daten->style | (b) ) == daten->style

// Inhalt der AccountSPListeEintrag Klasse aus AccountSpielPartner.h
// Konstruktor
AccountSPListeEintrag::AccountSPListeEintrag( AccountSPListeEintragDaten *daten )
    : ReferenceCounter(),
    daten( daten ),
    ram( new LRahmen() ),
    members( new RCArray< AccountSPListeEintrag >() ),
    name( initTextFeld( 5, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Name" ) ),
    anzahl( initTextFeld( 110, 0, 100, 20, TextFeld::Style::Text | TextFeld::Style::Center, "Spiele: " ) ),
    prozent( initFBalken( 220, 0, 400, 20, FBalken::Style::normal ) ),
    details( initKnopf( 580, 0, 20, 20, 0, "" ) ),
    ausklappen( bilder->get( "data/client/bilder/account.ltdb/ausklappen.png" ) ),
    einklappen( bilder->get( "data/client/bilder/account.ltdb/einklappen.png" ) ),
    sortSpalte( new Text( "Name" ) ),
    sortAbsteigend( 0 ),
    tickVal( 0 ),
    rend( 0 )
{
    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, "Details anzeigen." );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setRamenBreite( 1 );
    ram->setSize( 0, 20 );
    if( daten->name )
        name->setText( daten->name->getText() );
    anzahl->zText()->append( daten->anzahl );
    TextRenderer rd( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
    rd.setSchriftSize( 12 );
    name->setSize( rd.getTextBreite( name->zText()->getText() ) + 5, name->getHeight() );
    anzahl->setPosition( ( name->getX() + name->getBreite() + 10 ) < 100 ? 100 : ( name->getX() + name->getBreite() + 10 ), anzahl->getY() );
    anzahl->setSize( rd.getTextBreite( anzahl->zText()->getText() ) + 5, anzahl->getHeight() );
    prozent->setPosition( ( anzahl->getX() + anzahl->getBreite() + 10 ) < 200 ? 200 : ( anzahl->getX() + anzahl->getBreite() + 10 ), prozent->getY() );
    prozent->setAktionAnzahl( 100 );
    prozent->aktionPlus( daten->prozent );
}

// Destruktor
AccountSPListeEintrag::~AccountSPListeEintrag()
{
    ram->release();
    members->release();
    name->release();
    anzahl->release();
    prozent->release();
    details->release();
    ausklappen->release();
    einklappen->release();
    sortSpalte->release();
    daten->name->release();
    delete daten;
}

// privat
int AccountSPListeEintrag::getReihenfolge( int *arr )
{
    int anz = members->getEintragAnzahl();
    if( !anz || !HATSTYLE( ASPLEDStyle::Ausklappbar ) )
        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++ )
        {
            AccountSPListeEintrag *tmp = members->z( j );
            if( sortSpalte->istGleich( "Name" ) && !fertig[ j ] && ( index < 0 ||
                                                                     ( sortAbsteigend && *tmp->zDaten()->name > minMaxT ) || ( !sortAbsteigend && *tmp->zDaten()->name < minMaxT ) ) )
            {
                minMaxT = tmp->zDaten()->name->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Spiele" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && tmp->zDaten()->anzahl > minMax ) || ( !sortAbsteigend && tmp->zDaten()->anzahl < minMax ) ) )
            {
                minMax = tmp->zDaten()->anzahl;
                index = j;
            }
            else if( sortSpalte->istGleich( "Prozent" ) && !fertig[ j ] && ( index < 0 ||
                                                                             ( sortAbsteigend && tmp->zDaten()->prozent > minMax ) || ( !sortAbsteigend && tmp->zDaten()->prozent < minMax ) ) )
            {
                minMax = tmp->zDaten()->prozent;
                index = j;
            }
        }
        if( index < 0 )
            break;
        fertig[ index ] = 1;
        arr[ ret ] = index;
        ret++;
    }
    delete[] fertig;
    return ret;
}

// nicht constant
void AccountSPListeEintrag::addMember( AccountSPListeEintrag *e )
{
    members->add( e );
    rend = 1;
}

void AccountSPListeEintrag::setSortSpalte( char *sp )
{
    sortSpalte->setText( sp );
    if( HATSTYLE( ASPLEDStyle::Ausklappbar ) )
    {
        int anz = members->getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
            members->z( i )->setSortSpalte( sp );
    }
    rend = 1;
}

void AccountSPListeEintrag::setSortRichtung( bool absteigend )
{
    sortAbsteigend = absteigend;
    if( HATSTYLE( ASPLEDStyle::Ausklappbar ) )
    {
        int anz = members->getEintragAnzahl();
        for( int i = 0; i < anz; i++ )
            members->z( i )->setSortRichtung( absteigend );
    }
    rend = 1;
}

bool AccountSPListeEintrag::tick( double tickVal )
{
    rend |= details->tick( tickVal );
    int anz = members->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        rend |= members->z( i )->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;
            for( int i = 0; i < anz; i++ )
                maxHö += 5 + members->z( i )->getHeight();
            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 AccountSPListeEintrag::doPublicMausEreignis( MausEreignis &me )
{
    int mx = me.mx;
    int my = me.my;
    bool vera = 0;
    if( me.mx < 0 || me.my < 0 || me.mx > ram->getBreite() || me.my > ram->getHeight() )
    {
        vera = 1;
        me.verarbeitet = 1;
    }
    if( HATSTYLE( ASPLEDStyle::Ausklappbar ) )
    {
        bool ok = me.verarbeitet;
        details->doPublicMausEreignis( me );
        if( !ok && 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." );
            }
        }
    }
    if( ram->getHeight() > 20 )
    {
        int anz = members->getEintragAnzahl();
        int *rf = new int[ anz ];
        int rfAnz = getReihenfolge( rf );
        me.my -= 25;
        for( int i = 0; i < rfAnz; i++ )
        {
            members->z( rf[ i ] )->doPublicMausEreignis( me );
            me.my -= members->z( rf[ i ] )->getHeight() + 5;
        }
        delete[] rf;
    }
    me.mx = mx;
    me.my = my;
    if( vera )
        me.verarbeitet = 0;
}

void AccountSPListeEintrag::render( int xOff, int yOff, int breite, Bild &zRObj )
{
    ram->setSize( breite, ram->getHeight() );
    details->setPosition( ram->getBreite() - 20, details->getY() );
    if( !zRObj.setDrawOptions( xOff, yOff, breite, ram->getHeight() ) )
        return;
    name->render( zRObj );
    anzahl->render( zRObj );
    prozent->render( zRObj );
    if( HATSTYLE( ASPLEDStyle::Ausklappbar ) )
        details->render( zRObj );
    ram->render( zRObj );
    if( ram->getHeight() > 20 )
    {
        zRObj.drawLinieH( 0, 20, ram->getBreite(), ram->getFarbe() );
        int anz = members->getEintragAnzahl();
        int *rf = new int[ anz ];
        int rfAnz = getReihenfolge( rf );
        yOff = 0;
        for( int i = 0; i < rfAnz; i++ )
        {
            members->z( rf[ i ] )->render( 5, yOff + 25, breite - 10, zRObj );
            yOff += 5 + members->z( rf[ i ] )->getHeight();
        }
        delete[] rf;
    }
    zRObj.releaseDrawOptions();
}

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

AccountSPListeEintragDaten *AccountSPListeEintrag::zDaten() const
{
    return daten;
}


// Inhalt der AccountSPListe Klasse aus AccountSpielPartner.h
// Konstruktor
AccountSPListe::AccountSPListe()
    : Zeichnung(),
    ram( new LRahmen() ),
    scroll( new VScrollBar() ),
    skp( new RCArray< AccountSPListeEintrag >() ),
    spk( new RCArray< AccountSPListeEintrag >() ),
    psk( new RCArray< AccountSPListeEintrag >() ),
    gruppierung( new Text( "Spieler/Spiel/Karte" ) ),
    sortSpalte( new Text( "Name" ) ),
    sortAbsteigend( 0 ),
    rend( 0 )
{
    pos = Punkt( 10, 40 );
    ram->setSize( 760, 380 );
    ram->setFarbe( 0xFFFFFFFF );
    ram->setRamenBreite( 1 );
}

// Destruktor
AccountSPListe::~AccountSPListe()
{
    ram->release();
    scroll->release();
    skp->release();
    spk->release();
    psk->release();
    gruppierung->release();
    sortSpalte->release();
}

// privat
int AccountSPListe::getReihenfolge( int *arr )
{
    RCArray< AccountSPListeEintrag > *members = 0;
    if( gruppierung->istGleich( "Spiel/Karte/Spieler" ) )
        members = skp;
    if( gruppierung->istGleich( "Spiel/Spieler/Karte" ) )
        members = spk;
    if( gruppierung->istGleich( "Spieler/Spiel/Karte" ) )
        members = psk;
    if( !members )
        return 0;
    int anz = members->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++ )
        {
            AccountSPListeEintrag *tmp = members->z( j );
            if( sortSpalte->istGleich( "Name" ) && !fertig[ j ] && ( index < 0 ||
                                                                     ( sortAbsteigend && *tmp->zDaten()->name > minMaxT ) || ( !sortAbsteigend && *tmp->zDaten()->name < minMaxT ) ) )
            {
                minMaxT = tmp->zDaten()->name->getText();
                index = j;
            }
            else if( sortSpalte->istGleich( "Spiele" ) && !fertig[ j ] && ( index < 0 ||
                                                                            ( sortAbsteigend && tmp->zDaten()->anzahl > minMax ) || ( !sortAbsteigend && tmp->zDaten()->anzahl < minMax ) ) )
            {
                minMax = tmp->zDaten()->anzahl;
                index = j;
            }
            else if( sortSpalte->istGleich( "Prozent" ) && !fertig[ j ] && ( index < 0 ||
                                                                             ( sortAbsteigend && tmp->zDaten()->prozent > minMax ) || ( !sortAbsteigend && tmp->zDaten()->prozent < minMax ) ) )
            {
                minMax = tmp->zDaten()->prozent;
                index = j;
            }
        }
        if( index < 0 )
            break;
        fertig[ index ] = 1;
        arr[ ret ] = index;
        ret++;
    }
    delete[] fertig;
    return ret;
}

// nicht constant
void AccountSPListe::reset()
{
    lockZeichnung();
    skp->leeren();
    spk->leeren();
    psk->leeren();
    unlockZeichnung();
}

void AccountSPListe::ladeDaten( int accId )
{
    Array< int > *spieler = new Array< int >();
    Array< int > *karten = new Array< int >();
    Array< int > *anzahl = new Array< int >();
    if( infoClient->getSpielPartnerListe( accId, spieler, karten, anzahl ) )
    {
        int anz = spieler->getEintragAnzahl();
        int spielerAnzahl = 0;
        int spielArtAnzahl = 0;
        int anzahlGesammt = 0;
        Array< int > *spielerUnique = new Array< int >();
        Array< int > *spielArt = new Array< int >();
        for( int i = 0; i < anz; i++ )
        { // Spiel Art Ids ermitteln
            anzahlGesammt += anzahl->get( i );
            if( spieler->hat( i ) && spielerUnique->getWertIndex( spieler->get( i ) ) < 0 )
            {
                spielerUnique->set( spieler->get( i ), spielerAnzahl );
                spielerAnzahl++;
            }
            if( !spielArt->hat( i ) )
            {
                spielArtAnzahl++;
                int id = infoClient->getSpielId( karten->get( i ) );
                for( int j = i; j < anz; j++ )
                {
                    if( karten->get( j ) == karten->get( i ) )
                        spielArt->set( id, j );
                }
            }
        }
        spielerUnique->release();
        // Spiel/Karte/Spieler Tabelle initialisieren
        Array< int > *spielArtVera = new Array< int >();
        for( int i = 0; i < spielArtAnzahl; i++ )
        { // Spiel Arten Einträge
            int id = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spielArtVera->getWertIndex( spielArt->get( j ) ) < 0 )
                {
                    id = spielArt->get( j );
                    spielArtVera->add( id );
                    break;
                }
            }
            if( !id )
                break;
            AccountSPListeEintragDaten *tmp = new AccountSPListeEintragDaten();
            tmp->id = id;
            tmp->name = infoClient->getSpielName( tmp->id );
            tmp->style = ASPLEDStyle::SpielArt | ASPLEDStyle::Ausklappbar;
            tmp->anzahl = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spielArt->get( j ) == tmp->id )
                    tmp->anzahl += anzahl->get( j );
            }
            tmp->prozent = tmp->anzahl * 100 / anzahlGesammt;
            AccountSPListeEintrag *spielE = new AccountSPListeEintrag( tmp );
            skp->add( spielE );
            Array< int > *kartenVera = new Array< int >();
            for( int j = 0; j < anz; j++ )
            { // Karten Einträge
                int id = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( spielArt->get( k ) == tmp->id )
                    {
                        if( kartenVera->getWertIndex( karten->get( k ) ) < 0 )
                        {
                            id = karten->get( k );
                            kartenVera->add( id );
                            break;
                        }
                    }
                }
                if( !id )
                    break;
                AccountSPListeEintragDaten *tmpk = new AccountSPListeEintragDaten();
                tmpk->id = id;
                tmpk->name = infoClient->getKarteName( tmpk->id );
                tmpk->style = ASPLEDStyle::Ausklappbar | ASPLEDStyle::Karte;
                tmpk->anzahl = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( karten->get( k ) == tmpk->id )
                        tmpk->anzahl += anzahl->get( k );
                }
                tmpk->prozent = tmpk->anzahl * 100 / tmp->anzahl;
                AccountSPListeEintrag *karteE = new AccountSPListeEintrag( tmpk );
                spielE->addMember( karteE );
                Array< int > *spielerVera = new Array< int >();
                for( int k = 0; k < anz; k++ )
                { // Spieler Einträge
                    int id = 0;
                    int gAnz = 0;
                    for( int l = 0; l < anz; l++ )
                    {
                        if( karten->get( l ) == tmpk->id )
                        {
                            if( spielerVera->getWertIndex( spieler->get( l ) ) < 0 )
                            {
                                id = spieler->get( l );
                                spielerVera->add( id );
                                gAnz = anzahl->get( l );
                                break;
                            }
                        }
                    }
                    if( !id )
                        break;
                    AccountSPListeEintragDaten *tmps = new AccountSPListeEintragDaten();
                    tmps->id = id;
                    tmps->name = infoClient->getSpielerName( tmps->id );
                    tmps->style = ASPLEDStyle::Spieler;
                    tmps->anzahl = gAnz;
                    tmps->prozent = tmps->anzahl * 100 / tmpk->anzahl;
                    karteE->addMember( new AccountSPListeEintrag( tmps ) );
                }
                spielerVera->release();
            }
            kartenVera->release();
        }
        spielArtVera->leeren();
        // Spiel/Spieler/Karte Tabelle initialisieren
        for( int i = 0; i < spielArtAnzahl; i++ )
        { // Spiel Arten Einträge
            int id = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spielArtVera->getWertIndex( spielArt->get( j ) ) < 0 )
                {
                    id = spielArt->get( j );
                    spielArtVera->add( id );
                    break;
                }
            }
            if( !id )
                break;
            AccountSPListeEintragDaten *tmp = new AccountSPListeEintragDaten();
            tmp->id = id;
            tmp->name = infoClient->getSpielName( tmp->id );
            tmp->style = ASPLEDStyle::SpielArt | ASPLEDStyle::Ausklappbar;
            tmp->anzahl = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spielArt->get( j ) == tmp->id )
                    tmp->anzahl += anzahl->get( j );
            }
            tmp->prozent = tmp->anzahl * 100 / anzahlGesammt;
            AccountSPListeEintrag *spielE = new AccountSPListeEintrag( tmp );
            spk->add( spielE );
            Array< int > *spielerVera = new Array< int >();
            for( int j = 0; j < anz; j++ )
            { // Spieler Einträge
                int id = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( spielArt->get( k ) == tmp->id )
                    {
                        if( spielerVera->getWertIndex( spieler->get( k ) ) < 0 )
                        {
                            id = spieler->get( k );
                            spielerVera->add( id );
                            break;
                        }
                    }
                }
                if( !id )
                    break;
                AccountSPListeEintragDaten *tmps = new AccountSPListeEintragDaten();
                tmps->id = id;
                tmps->name = infoClient->getSpielerName( tmps->id );
                tmps->style = ASPLEDStyle::Ausklappbar | ASPLEDStyle::Spieler;
                tmps->anzahl = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( spieler->get( k ) == tmps->id && spielArt->get( k ) == tmp->id )
                        tmps->anzahl += anzahl->get( k );
                }
                tmps->prozent = tmps->anzahl * 100 / tmp->anzahl;
                AccountSPListeEintrag *spielerE = new AccountSPListeEintrag( tmps );
                spielE->addMember( spielerE );
                Array< int > *karteVera = new Array< int >();
                for( int k = 0; k < anz; k++ )
                { // Karten Einträge
                    int id = 0;
                    int gAnz = 0;
                    for( int l = 0; l < anz; l++ )
                    {
                        if( spieler->get( l ) == tmps->id && spielArt->get( l ) == tmp->id )
                        {
                            if( karteVera->getWertIndex( karten->get( l ) ) < 0 )
                            {
                                id = karten->get( l );
                                karteVera->add( id );
                                gAnz = anzahl->get( l );
                                break;
                            }
                        }
                    }
                    if( !id )
                        break;
                    AccountSPListeEintragDaten *tmpk = new AccountSPListeEintragDaten();
                    tmpk->id = id;
                    tmpk->name = infoClient->getKarteName( tmpk->id );
                    tmpk->style = ASPLEDStyle::Karte;
                    tmpk->anzahl = gAnz;
                    tmpk->prozent = tmpk->anzahl * 100 / tmps->anzahl;
                    spielerE->addMember( new AccountSPListeEintrag( tmpk ) );
                }
                karteVera->release();
            }
            spielerVera->release();
        }
        spielArtVera->release();
        // Spieler/Spiel/Karte Tabelle initialisieren
        Array< int > *spielerVera = new Array< int >();
        for( int i = 0; i < spielerAnzahl; i++ )
        { // Spieler Einträge
            int id = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spielerVera->getWertIndex( spieler->get( j ) ) < 0 )
                {
                    id = spieler->get( j );
                    spielerVera->add( id );
                    break;
                }
            }
            if( !id )
                break;
            AccountSPListeEintragDaten *tmp = new AccountSPListeEintragDaten();
            tmp->id = id;
            tmp->name = infoClient->getSpielerName( tmp->id );
            tmp->style = ASPLEDStyle::Spieler | ASPLEDStyle::Ausklappbar;
            tmp->anzahl = 0;
            for( int j = 0; j < anz; j++ )
            {
                if( spieler->get( j ) == tmp->id )
                    tmp->anzahl += anzahl->get( j );
            }
            tmp->prozent = tmp->anzahl * 100 / anzahlGesammt;
            AccountSPListeEintrag *spielerE = new AccountSPListeEintrag( tmp );
            psk->add( spielerE );
            Array< int > *spielVera = new Array< int >();
            for( int j = 0; j < anz; j++ )
            { // Spiel Einträge
                int id = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( spieler->get( k ) == tmp->id )
                    {
                        if( spielVera->getWertIndex( spielArt->get( k ) ) < 0 )
                        {
                            id = spielArt->get( k );
                            spielVera->add( id );
                            break;
                        }
                    }
                }
                if( !id )
                    break;
                AccountSPListeEintragDaten *tmps = new AccountSPListeEintragDaten();
                tmps->id = id;
                tmps->name = infoClient->getSpielName( tmps->id );
                tmps->style = ASPLEDStyle::Ausklappbar | ASPLEDStyle::SpielArt;
                tmps->anzahl = 0;
                for( int k = 0; k < anz; k++ )
                {
                    if( spieler->get( k ) == tmp->id && spielArt->get( k ) == tmps->id )
                        tmps->anzahl += anzahl->get( k );
                }
                tmps->prozent = tmps->anzahl * 100 / tmp->anzahl;
                AccountSPListeEintrag *spielE = new AccountSPListeEintrag( tmps );
                spielerE->addMember( spielE );
                Array< int > *karteVera = new Array< int >();
                for( int k = 0; k < anz; k++ )
                { // Karte Einträge
                    int id = 0;
                    int gAnz = 0;
                    for( int l = 0; l < anz; l++ )
                    {
                        if( spieler->get( l ) == tmp->id && spielArt->get( l ) == tmps->id )
                        {
                            if( karteVera->getWertIndex( karten->get( l ) ) < 0 )
                            {
                                id = karten->get( l );
                                karteVera->add( id );
                                gAnz = anzahl->get( l );
                                break;
                            }
                        }
                    }
                    if( !id )
                        break;
                    AccountSPListeEintragDaten *tmpk = new AccountSPListeEintragDaten();
                    tmpk->id = id;
                    tmpk->name = infoClient->getKarteName( tmpk->id );
                    tmpk->style = ASPLEDStyle::Karte;
                    tmpk->anzahl = gAnz;
                    tmpk->prozent = tmpk->anzahl * 100 / tmps->anzahl;
                    spielE->addMember( new AccountSPListeEintrag( tmpk ) );
                }
                karteVera->release();
            }
            spielVera->release();
        }
        spielerVera->release();
        spielArt->release();
    }
    else
        nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Spielpartner dieses Spielers konnten nicht ermittelt werden." ), new Text( "Ok" ) );
    spieler->release();
    karten->release();
    anzahl->release();
}

void AccountSPListe::setGruppierung( char *gp )
{
    lockZeichnung();
    gruppierung->setText( gp );
    rend = 1;
    unlockZeichnung();
}

void AccountSPListe::setSortSpalte( char *sp )
{
    lockZeichnung();
    sortSpalte->setText( sp );
    int anz = skp->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        skp->z( i )->setSortSpalte( sp );
    anz = spk->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        spk->z( i )->setSortSpalte( sp );
    anz = psk->getEintragAnzahl();
    for( int i = 0; i < anz; i++ )
        psk->z( i )->setSortSpalte( sp );
    rend = 1;
    unlockZeichnung();
}

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

bool AccountSPListe::tick( double tickVal )
{
    lockZeichnung();
    RCArray< AccountSPListeEintrag > *members = 0;
    if( gruppierung->istGleich( "Spiel/Karte/Spieler" ) )
        members = skp;
    if( gruppierung->istGleich( "Spiel/Spieler/Karte" ) )
        members = spk;
    if( gruppierung->istGleich( "Spieler/Spiel/Karte" ) )
        members = psk;
    if( members )
    {
        int anz = members->getEintragAnzahl();
        int *rf = new int[ anz ];
        int rfAnz = getReihenfolge( rf );
        for( int i = 0; i < rfAnz; i++ )
            rend |= members->z( rf[ i ] )->tick( tickVal );
        delete[] rf;
    }
    unlockZeichnung();
    rend |= scroll->getRend();
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountSPListe::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();
    RCArray< AccountSPListeEintrag > *members = 0;
    if( gruppierung->istGleich( "Spiel/Karte/Spieler" ) )
        members = skp;
    if( gruppierung->istGleich( "Spiel/Spieler/Karte" ) )
        members = spk;
    if( gruppierung->istGleich( "Spieler/Spiel/Karte" ) )
        members = psk;
    if( members )
    {
        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() + 10;
        }
        delete[] rf;
    }
    unlockZeichnung();
    me.mx = mx, me.my = my;
    if( vera )
        me.verarbeitet = 0;
}

void AccountSPListe::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ö = 10;
    lockZeichnung();
    RCArray< AccountSPListeEintrag > *members = 0;
    if( gruppierung->istGleich( "Spiel/Karte/Spieler" ) )
        members = skp;
    if( gruppierung->istGleich( "Spiel/Spieler/Karte" ) )
        members = spk;
    if( gruppierung->istGleich( "Spieler/Spiel/Karte" ) )
        members = psk;
    if( members )
    {
        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( 10, anzHö - scroll->getScroll(), ram->getBreite() - 36, zRObj );
            anzHö += members->z( rf[ i ] )->getHeight() + 10;
        }
        delete[] rf;
    }
    unlockZeichnung();
    scroll->update( anzHö, ram->getHeight() - 2 );
    zRObj.releaseDrawOptions();
    zRObj.releaseDrawOptions();
}


// Inhalt der AccountSpielPartner Klasse aus AccountSpielPartner.h
// Konstruktor
AccountSpielPartner::AccountSpielPartner()
    : Thread(),
    spielPartnerF( initFenster( 810, 40, 780, 450, Fenster::Style::Sichtbar | Fenster::Style::Titel | Fenster::Style::TitelBuffered | Fenster::Style::Rahmen | Fenster::Style::Erlaubt, "Spielpartner von " ) ),
    gruppAusw( initAuswahlBox( 10, 10, 150, 20, ABSTYLE, { "Spieler/Spiel/Karte", "Spiel/Karte/Spieler", "Spiel/Spieler/Karte" } ) ),
    sortSpalte( initAuswahlBox( 170, 10, 150, 20, ABSTYLE, { "Name", "Spiele", "Prozent" } ) ),
    sortRichtung( initAuswahlBox( 330, 10, 150, 20, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
    liste( new AccountSPListe() ),
    status( 0 ),
    accId( 0 ),
    animation( 0 ),
    alpha( 255 ),
    tickVal( 0 ),
    rend( 0 )
{
    initToolTip( gruppAusw, "Wähle Gruppierung aus, nach der die Daten angezeigt werden sollen." );
    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." );
    spielPartnerF->addMember( dynamic_cast<Zeichnung *>( liste->getThis() ) );
    spielPartnerF->addMember( dynamic_cast<Zeichnung *>( gruppAusw->getThis() ) );
    spielPartnerF->addMember( dynamic_cast<Zeichnung *>( sortSpalte->getThis() ) );
    spielPartnerF->addMember( dynamic_cast<Zeichnung *>( sortRichtung->getThis() ) );
    spielPartnerF->setMausEreignis( _ret1ME );
}

// Destruktor
AccountSpielPartner::~AccountSpielPartner()
{
    spielPartnerF->release();
    gruppAusw->release();
    sortSpalte->release();
    sortRichtung->release();
    liste->release();
}

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

void AccountSpielPartner::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 AccountSpielPartner::thread()
{
    Text *name = infoClient->getSpielerName( accId );
    if( name )
    {
        name->insert( 0, "Spielpartner von " );
        spielPartnerF->setTitel( *name );
        name->release();
    }
    liste->ladeDaten( accId );
    animation &= ~0x4;
    status = 2;
    run = 0;
}

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

bool AccountSpielPartner::tick( double zeit )
{
    rend |= spielPartnerF->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( spielPartnerF->getX() != 10 )
                {
                    if( spielPartnerF->getX() + valB > 10 )
                        spielPartnerF->setPosition( 10, spielPartnerF->getY() );
                    else
                        spielPartnerF->setPosition( spielPartnerF->getX() + valB, spielPartnerF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( spielPartnerF->getX() != 10 )
                {
                    if( spielPartnerF->getX() - valB < 10 )
                        spielPartnerF->setPosition( 10, spielPartnerF->getY() );
                    else
                        spielPartnerF->setPosition( spielPartnerF->getX() - valB, spielPartnerF->getY() );
                    rend = 1;
                }
            }
        }
        else
        { // Unsichtbar
            if( ( animation | 0x2 ) == animation )
            { // Nach Rechts
                if( spielPartnerF->getX() != 810 )
                {
                    if( spielPartnerF->getX() + valB > 810 )
                        spielPartnerF->setPosition( 810, spielPartnerF->getY() );
                    else
                        spielPartnerF->setPosition( spielPartnerF->getX() + valB, spielPartnerF->getY() );
                    rend = 1;
                }
            }
            else
            { // Nach Links
                if( spielPartnerF->getX() != -810 )
                {
                    if( spielPartnerF->getX() - valB < -810 )
                        spielPartnerF->setPosition( -810, spielPartnerF->getY() );
                    else
                        spielPartnerF->setPosition( spielPartnerF->getX() - valB, spielPartnerF->getY() );
                    rend = 1;
                }
            }
        }
    }
    bool ret = rend;
    rend = 0;
    return ret;
}

void AccountSpielPartner::doPublicMausEreignis( MausEreignis &me )
{
    int gruppAuswS = gruppAusw->getAuswahl();
    int sortSpalteS = sortSpalte->getAuswahl();
    int sortRichtungS = sortRichtung->getAuswahl();
    spielPartnerF->doPublicMausEreignis( me );
    if( gruppAusw->getAuswahl() != gruppAuswS )
    {
        liste->setGruppierung( gruppAusw->zEintrag( gruppAusw->getAuswahl() )->zText()->getText() );
        gruppAusw->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 AccountSpielPartner::render( Bild &zRObj )
{
    zRObj.setAlpha( alpha );
    spielPartnerF->render( zRObj );
    zRObj.releaseAlpha();
}

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