#include "../KSGKlient.h"
#include "../KSGServer.h"
#include <Datei.h>
#include "../../Global/Variablen.h"
#include <GSLDateiV.h>

typedef GSL::GSLDateiV *( *GetGSLDatei )( );

class DownloadSound : public GSL::GSLSoundV
{
private:
    bool istM;
    int sample;
    __int64 län;
    Klient *k;
    FBalken *f;
    int ref;

public:
    // Konstruktor
    DownloadSound( Klient *zK, FBalken *zF )
    {
        k = zK;
        f = zF;
        ref = 1;
    }
    // nicht constant
    // GSL
    void playSound() override
    {}
    void setPause( bool p ) override
    {}
    void stopSound() override
    {}
    void warteAufSound( int zeit ) override
    {}
    // Lautstärke: 0 - 0xFFFF
    void setLautstärke( unsigned int links, unsigned int rechts ) override
    {}
    // zum Speichern
    void öffnen() override
    {
        char m = 0;
        k->getNachrichtVerschlüsselt( &m, 1 );
        istM = ( m == 1 );
        sample = 0;
        k->getNachrichtVerschlüsselt( (char*)&sample, 4 );
        län = 0;
        k->getNachrichtVerschlüsselt( (char*)&län, 8 );
        f->setAktionAnzahl( län );
    }
    int getDaten( char *buffer, int län ) override
    {
        int l = län < this->län ? län : ( int )this->län;
        if( !l )
            return -1;
        k->getNachricht( buffer, l );
        this->län -= l;
        f->aktionPlus( l );
        return l;
    }
    void schließen() override
    {}
    bool istMono() const override
    {
        return istM;
    }
    int getSampleRate() const override
    {
        return sample;
    }
    __int64 getDatLänge() const override
    {
        return län;
    }
    // Reference Counting
    GSL::GSLSoundV *getThis() override
    {
        ref++;
        return this;
    }
    GSL::GSLSoundV *release() override
    {
        ref--;
        if( !ref )
            delete this;
        return 0;
    }
};

// Inhalt der EditorKlient Klasse aus KSGKlient.h
// Konstruktor
EditorKlient::EditorKlient()
{
    verbunden = 0;
    klient = 0;
    fehler = new Text( "" );
    klientId = getKlientId();
    ref = 1;
    InitializeCriticalSection( &cs );
}

// Destruktor
EditorKlient::~EditorKlient()
{
    LOCK( &cs );
    if( verbunden )
        trenne();
    fehler = fehler->release();
    UNLOCK( &cs );
    DeleteCriticalSection( &cs );
}

// nicht constant
bool EditorKlient::verbinde( unsigned short port, char *ip ) // verbindet ich mit dem Editor Server
{
    if( klient && verbunden && klient->getServerPort() == port && Text( ip ).istGleich( klient->getServerIp() ) )
        return 1;
    if( klient || verbunden )
        trenne();
    klient = new Klient();
    unsigned char schlüssel[ 20 ] = { 55, 124, 19, 204, 23, 5, 59, 75, 247, 138, 119, 111, 57, 250, 206, 187, 165, 6, 247, 151 };
    klient->setSendeSchlüssel( (char*)schlüssel, 20 );
    klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
    if( !klient->verbinde( (unsigned short)port, ip ) )
    {
        klient = klient->release();
        fehler->setText( "Fehler beim verbinden mit dem Editor Server." );
        return 0;
    }
    klient->sendeVerschlüsselt( "\1", 1 );
    klient->sendeVerschlüsselt( (char*)&klientId, 4 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 3 )
    {
        char län = 0;
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtVerschlüsselt( nachricht, län );
        fehler->setText( nachricht );
        delete[]nachricht;
        trenne();
        return 0;
    }
    if( ret == 1 )
    {
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeSchlüssel( sl, slLän );
        klient->setEmpfangSchlüssel( sl, slLän );
        delete[] sl;
        verbunden = 1;
    }
    return 1;
}

bool EditorKlient::karteErstellen( Text *zName, int spielArt ) // Erstellt eine neue Karte
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xA", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        char l = (char)zName->getLänge();
        klient->sendeVerschlüsselt( &l, 1 );
        klient->sendeVerschlüsselt( zName->getText(), l );
        klient->sendeVerschlüsselt( (char*)&spielArt, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::ladeKarte( int id ) // lädt eine bestimmte Karte
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x6", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

int EditorKlient::getAbbildListe( RCArray< Text > *name, RCArray< Zeit > *datum )
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x5", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char l = 0;
                klient->getNachrichtVerschlüsselt( &l, 1 );
                char *n = new char[ l + 1 ];
                n[ l ] = 0;
                klient->getNachrichtVerschlüsselt( n, l );
                name->set( new Text( n ), i );
                delete[] n;
                Zeit *dat = new Zeit();
                int d = 0;
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setJahr( d );
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setMonat( d );
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setTag( d );
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setStunde( d );
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setMinute( d );
                klient->getNachrichtVerschlüsselt( (char*)&d, 4 );
                dat->setSekunde( d );
                datum->set( dat, i );
            }
            UNLOCK( &cs );
            return anz;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::abbildErstellen( char *name )
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x1", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            char l = (char)textLänge( name );
            klient->sendeVerschlüsselt( &l, 1 );
            if( l )
                klient->sendeVerschlüsselt( name, l );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool EditorKlient::abbildLöschen( char *name )
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x2", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            char l = (char)textLänge( name );
            klient->sendeVerschlüsselt( &l, 1 );
            if( l )
                klient->sendeVerschlüsselt( name, l );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool EditorKlient::abbildHerstellen( char *name )
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x3", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            char l = (char)textLänge( name );
            klient->sendeVerschlüsselt( &l, 1 );
            if( l )
                klient->sendeVerschlüsselt( name, l );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

bool EditorKlient::veröffentlichen()
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x4", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
            klient->getNachrichtVerschlüsselt( &ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::shopSeiteVeröffentlichen() // Veröffentlicht die Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x6", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
            klient->getNachrichtVerschlüsselt( &ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ladeShopSeiteVorschau() // Läht die Vorschau der Shop Seite herrunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x8", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            Text pf = "data/tmp/ke/ssv";
            for( int i = 0; i < anz; i++ )
            {
                char l = 0;
                klient->getNachrichtVerschlüsselt( &l, 1 );
                char *pfad = new char[ l + 1 ];
                pfad[ l ] = 0;
                klient->getNachrichtVerschlüsselt( pfad, l );
                Text p = pf.getText();
                p += pfad;
                delete[] pfad;
                Datei d;
                d.setDatei( p );
                d.erstellen();
                d.öffnen( Datei::Style::schreiben );
                __int64 größe = 0;
                klient->getNachrichtVerschlüsselt( (char*)&größe, 8 );
                char *buffer = new char[ 2048 ];
                while( größe > 0 )
                {
                    int l = größe > 2048 ? 2048 : (int)größe;
                    klient->getNachricht( buffer, l );
                    d.schreibe( buffer, l );
                    größe -= l;
                }
                delete[] buffer;
                d.schließen();
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ssDateiErstellen( char *name, int typ ) // Erstellt eine neue Shop Seiten Datei (typ:0=Ordner,1=Bild,2=Text)
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x1", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char t = typ;
                klient->sendeVerschlüsselt( &t, 1 );
                char l = (char)textLänge( name );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( name, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ssOrdnerÖffnen( char *name ) // Öffnet einen Ordner der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x2", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( name );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( name, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

Bild *EditorKlient::ssBildLaden( char *datei, char *bild ) // Läht das ein Bild der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x3", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( datei );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( datei, l );
                l = (char)textLänge( bild );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( bild, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    Bild *ret = new Bild();
                    int br = 0;
                    int hö = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&br, 4 );
                    klient->getNachrichtVerschlüsselt( (char*)&hö, 4 );
                    ret->neuBild( br, hö, 0 );
                    char *buffer = (char*)ret->getBuffer();
                    __int64 län = br * hö * 4;
                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
                    {
                        klient->getNachricht( &( buffer[ i ] ), l );
                        i += l;
                        län -= l;
                    }
                    UNLOCK( &cs );
                    return ret;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::ssDateiLöschen( char *name ) // Löscht eine Datei der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x4", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( name );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( name, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

Text *EditorKlient::ssTextLaden( char *datei ) // Läd eine KSGS Datei der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xA", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( datei );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( datei, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int län = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&län, 4 );
                    char *txt = new char[ län + 1 ];
                    txt[ län ] = 0;
                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
                        klient->getNachricht( &( txt[ i ] ), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                    if( ret == 1 )
                    {
                        Text *t = new Text( txt );
                        delete[] txt;
                        UNLOCK( &cs );
                        return t;
                    }
                    delete[] txt;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::ssTextSpeichern( char *datei, Text *zText ) // Spechert eine KSGS Datei der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x5", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( datei );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( datei, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int län = zText->getLänge();
                    klient->sendeVerschlüsselt( (char*)&län, 4 );
                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
                        klient->sende( &( zText->getText()[ i ] ), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ssBildLöschen( char *datei, char *bild ) // Löscht ein Bild der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x6", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( datei );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( datei, l );
                l = (char)textLänge( bild );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( bild, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ssBildSpeichern( char *datei, char *name, Bild *zBild ) // Speichert ein Bild einer ShopSeite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x7", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( datei );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( datei, l );
                l = (char)textLänge( name );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( name, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int br = zBild->getBreite();
                    int hö = zBild->getHöhe();
                    klient->sendeVerschlüsselt( (char*)&br, 4 );
                    klient->sendeVerschlüsselt( (char*)&hö, 4 );
                    __int64 län = br * hö * 4;
                    char *buffer = (char*)zBild->getBuffer();
                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
                        klient->sende( &( buffer[ i ] ), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int EditorKlient::ssGetDateiListe( RCArray< Text > *zList ) // Läd die Datei Liste der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x8", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int anz = 0;
                klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                for( int i = 0; i < anz; i++ )
                {
                    char l = 0;
                    klient->getNachrichtVerschlüsselt( &l, 1 );
                    char *n = new char[ l + 1 ];
                    n[ l ] = 0;
                    klient->getNachrichtVerschlüsselt( n, l );
                    zList->add( new Text( n ) );
                    delete[] n;
                }
                UNLOCK( &cs );
                return anz;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return -1;
    }
    UNLOCK( &cs );
    return 0;
}

int EditorKlient::ssGetBildListe( char *name, RCArray< Text > *zList ) // Läd die Bild Liste einer Bild Datei der Shop Seite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x7", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x9", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)textLänge( name );
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( name, l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int anz = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                    for( int i = 0; i < anz; i++ )
                    {
                        l = 0;
                        klient->getNachrichtVerschlüsselt( &l, 1 );
                        char *n = new char[ l + 1 ];
                        n[ l ] = 0;
                        klient->getNachrichtVerschlüsselt( n, l );
                        zList->add( new Text( n ) );
                        delete[] n;
                    }
                    UNLOCK( &cs );
                    return anz;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return -1;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::getShopDaten( int &es, int &tp, int &vp ) // Läht die Shop Daten
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\x9", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->getNachrichtVerschlüsselt( (char*)&es, 4 );
            klient->getNachrichtVerschlüsselt( (char*)&tp, 4 );
            klient->getNachrichtVerschlüsselt( (char*)&vp, 4 );
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::setShopDaten( int es, int tp, int vp ) // Setzt die Shop Daten
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xA", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( (char*)&es, 4 );
            klient->sendeVerschlüsselt( (char*)&tp, 4 );
            klient->sendeVerschlüsselt( (char*)&vp, 4 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                UNLOCK( &cs );
                return 1;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Text *EditorKlient::beschreibungLaden() // läht die Kartenbeschreibung
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x1", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int län = 0;
                klient->getNachrichtVerschlüsselt( (char*)&län, 4 );
                char *txt = new char[ län + 1 ];
                txt[ län ] = 0;
                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
                    klient->getNachricht( &( txt[ i ] ), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    Text *t = new Text( txt );
                    delete[] txt;
                    UNLOCK( &cs );
                    return t;
                }
                delete[] txt;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Bild *EditorKlient::titelbildLaden() // läht das Titelbild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x2", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                Bild *ret = new Bild();
                int br = 0;
                int hö = 0;
                klient->getNachrichtVerschlüsselt( (char*)&br, 4 );
                klient->getNachrichtVerschlüsselt( (char*)&hö, 4 );
                ret->neuBild( br, hö, 0 );
                char *buffer = (char*)ret->getBuffer();
                __int64 län = br * hö * 4;
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
                {
                    klient->getNachricht( &( buffer[ i ] ), l );
                    i += l;
                    län -= l;
                }
                UNLOCK( &cs );
                return ret;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Bild *EditorKlient::minimapLaden() // läht das Minimapbild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x3", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                Bild *ret = new Bild();
                int br = 0;
                int hö = 0;
                klient->getNachrichtVerschlüsselt( (char*)&br, 4 );
                klient->getNachrichtVerschlüsselt( (char*)&hö, 4 );
                ret->neuBild( br, hö, 0 );
                char *buffer = (char*)ret->getBuffer();
                __int64 län = br * hö * 4;
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
                {
                    klient->getNachricht( &( buffer[ i ] ), l );
                    i += l;
                    län -= l;
                }
                UNLOCK( &cs );
                return ret;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Bild *EditorKlient::ladebildLaden() // läht das Ladebild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x4", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                Bild *ret = new Bild();
                int br = 0;
                int hö = 0;
                klient->getNachrichtVerschlüsselt( (char*)&br, 4 );
                klient->getNachrichtVerschlüsselt( (char*)&hö, 4 );
                ret->neuBild( br, hö, 0 );
                char *buffer = (char*)ret->getBuffer();
                __int64 län = br * hö * 4;
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
                {
                    klient->getNachricht( &( buffer[ i ] ), l );
                    i += l;
                    län -= l;
                }
                UNLOCK( &cs );
                return ret;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::beschreibungSpeichern( Text *zText ) // speichert die Kartenbeschreibung
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x5", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int län = zText->getLänge();
                klient->sendeVerschlüsselt( (char*)&län, 4 );
                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
                    klient->sende( &( zText->getText()[ i ] ), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::titelbildSpeichern( Bild *zBild ) // speichert das Titelbild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x6", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int br = zBild->getBreite();
                int hö = zBild->getHöhe();
                klient->sendeVerschlüsselt( (char*)&br, 4 );
                klient->sendeVerschlüsselt( (char*)&hö, 4 );
                __int64 län = br * hö * 4;
                char *buffer = (char*)zBild->getBuffer();
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
                    klient->sende( &( buffer[ i ] ), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::minimapSpeichern( Bild *zBild ) // speichert das Minimapbild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x7", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int br = zBild->getBreite();
                int hö = zBild->getHöhe();
                klient->sendeVerschlüsselt( (char*)&br, 4 );
                klient->sendeVerschlüsselt( (char*)&hö, 4 );
                __int64 län = br * hö * 4;
                char *buffer = (char*)zBild->getBuffer();
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
                    klient->sende( &( buffer[ i ] ), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ladebildSpeichern( Bild *zBild ) // speichert das Ladebild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xB", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x8", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int br = zBild->getBreite();
                int hö = zBild->getHöhe();
                klient->sendeVerschlüsselt( (char*)&br, 4 );
                klient->sendeVerschlüsselt( (char*)&hö, 4 );
                __int64 län = br * hö * 4;
                char *buffer = (char*)zBild->getBuffer();
                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
                    klient->sende( &( buffer[ i ] ), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::ladeTeamDaten( SpielerTeamStruktur *sts ) // läht die Team Daten
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xC", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x1", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                klient->getNachrichtVerschlüsselt( (char*)&sts->spielerAnzahl, 4 );
                klient->getNachrichtVerschlüsselt( (char*)&sts->teamAnzahl, 4 );
                for( int i = 0; i < sts->spielerAnzahl; i++ )
                {
                    int f = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&f, 4 );
                    sts->spielerFarbe->set( f, i );
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    int f = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&f, 4 );
                    sts->teamFarbe->set( f, i );
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    char l = 0;
                    klient->getNachrichtVerschlüsselt( &l, 1 );
                    char *n = new char[ l + 1 ];
                    n[ l ] = 0;
                    klient->getNachrichtVerschlüsselt( n, l );
                    sts->teamName->set( new Text( n ), i );
                    delete[] n;
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    int g = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&g, 4 );
                    sts->teamGröße->set( g, i );
                }
                UNLOCK( &cs );
                return 1;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::speicherTeamDaten( SpielerTeamStruktur *sts ) // speichert die Team Daten
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xC", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x2", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                klient->sendeVerschlüsselt( (char*)&sts->spielerAnzahl, 4 );
                klient->sendeVerschlüsselt( (char*)&sts->teamAnzahl, 4 );
                for( int i = 0; i < sts->spielerAnzahl; i++ )
                {
                    int f = sts->spielerFarbe->get( i );
                    klient->sendeVerschlüsselt( (char*)&f, 4 );
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    int f = sts->teamFarbe->get( i );
                    klient->sendeVerschlüsselt( (char*)&f, 4 );
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    char l = (char)sts->teamName->z( i )->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( sts->teamName->z( i )->getText(), l );
                }
                for( int i = 0; i < sts->teamAnzahl; i++ )
                {
                    int g = sts->teamGröße->get( i );
                    klient->sendeVerschlüsselt( (char*)&g, 4 );
                }
                UNLOCK( &cs );
                return 1;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::deNeueDatei( char typ, Text *zName ) // DateienEditor: Erstellt neue Datei (typ: 0=ordner 1=bild 2=modell2d 3=sound
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x1", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                klient->sendeVerschlüsselt( &typ, 1 );
                char l = (char)zName->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( zName->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deOrdnerÖffnen( Text *zName ) // DateienEditor: Öffnet Ordner
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x2", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char län = (char)zName->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zName->getText(), län );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

Bild *EditorKlient::deBildLaden( Text *zDatei, Text *zBild, FBalken *zF ) // DateienEditor: Bild laden
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    Bild *retB = 0;
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x3", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char län = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zDatei->getText(), län );
                län = (char)zBild->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zBild->getText(), län );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int br = 0;
                    int hö = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&br, 4 );
                    klient->getNachrichtVerschlüsselt( (char*)&hö, 4 );
                    retB = new Bild();
                    retB->neuBild( br, hö, 0 );
                    char *buffer = (char*)retB->getBuffer();
                    __int64 län = br * hö * 4;
                    zF->setAktionAnzahl( län );
                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
                    {
                        klient->getNachricht( &( buffer[ i ] ), l );
                        i += l;
                        län -= l;
                        zF->aktionPlus( l );
                    }
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    if( !ret && retB )
        retB = retB->release();
    return retB;
}

bool EditorKlient::deDateiLöschen( Text *zName ) // DateienEditor: Löscht Datei
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x4", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char län = (char)zName->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zName->getText(), län );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deBildLöschen( Text *zDatei, Text *zBild ) // DateienEditor: Löscht Bild aus Datei
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x5", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( zDatei->getText(), l );
                l = (char)zBild->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                if( l )
                    klient->sendeVerschlüsselt( zBild->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deBildSpeichern( Text *zDatei, Text *zName, Bild *zBild, FBalken *zF ) // DateienEditor: Speichert Bild
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x6", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char län = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zDatei->getText(), län );
                län = (char)zName->getLänge();
                klient->sendeVerschlüsselt( &län, 1 );
                if( län )
                    klient->sendeVerschlüsselt( zName->getText(), län );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int br = zBild->getBreite();
                    int hö = zBild->getHöhe();
                    klient->sendeVerschlüsselt( (char*)&br, 4 );
                    klient->sendeVerschlüsselt( (char*)&hö, 4 );
                    char *buffer = (char*)zBild->getBuffer();
                    __int64 gr = br * hö * 4;
                    zF->setAktionAnzahl( gr );
                    for( int i = 0, l = gr > 2048 ? 2048 : (int)gr; gr > 0; i += l, gr -= l, l = gr > 2048 ? 2048 : (int)gr )
                    {
                        klient->sende( &( buffer[ i ] ), l );
                        zF->aktionPlus( l );
                    }
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int EditorKlient::deGetDateiListe( RCArray< Text > *zNamen ) // DateienEditor: Datei Liste herunterladen
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x7", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                int anz = 0;
                klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                for( int i = 0; i < anz; i++ )
                {
                    char l = 0;
                    klient->getNachrichtVerschlüsselt( &l, 1 );
                    char *n = new char[ l + 1 ];
                    n[ l ] = 0;
                    if( l )
                        klient->getNachrichtVerschlüsselt( n, l );
                    zNamen->add( new Text( n ) );
                    delete[] n;
                }
                UNLOCK( &cs );
                return anz;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return -1;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int EditorKlient::deGetBildListe( Text *zDatei, RCArray< Text > *zNamen ) // DateienEditor: Liste mit in der Datei gespeicherten Bildern
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x8", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int anz = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                    for( int i = 0; i < anz; i++ )
                    {
                        klient->getNachrichtVerschlüsselt( &l, 1 );
                        char *n = new char[ l + 1 ];
                        n[ l ] = 0;
                        if( l )
                            klient->getNachrichtVerschlüsselt( n, l );
                        zNamen->add( new Text( n ) );
                        delete[] n;
                    }
                    UNLOCK( &cs );
                    return anz;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int EditorKlient::deGetModelListe( Text *zDatei, RCArray< Text > *zNamen ) // DateienEditor Liste mit in der Datei gespeicherten Modellen
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x9", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int anz = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                    for( int i = 0; i < anz; i++ )
                    {
                        klient->getNachrichtVerschlüsselt( &l, 1 );
                        char *n = new char[ l + 1 ];
                        n[ l ] = 0;
                        if( l )
                            klient->getNachrichtVerschlüsselt( n, l );
                        zNamen->add( new Text( n ) );
                        delete[] n;
                    }
                    UNLOCK( &cs );
                    return anz;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int EditorKlient::deGetSoundListe( Text *zDatei, RCArray< Text > *zNamen ) // DateienEditor: Liste mit in der Datei gespeicherten Tönen
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xA", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    int anz = 0;
                    klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                    for( int i = 0; i < anz; i++ )
                    {
                        klient->getNachrichtVerschlüsselt( &l, 1 );
                        char *n = new char[ l + 1 ];
                        n[ l ] = 0;
                        if( l )
                            klient->getNachrichtVerschlüsselt( n, l );
                        zNamen->add( new Text( n ) );
                        delete[] n;
                    }
                    UNLOCK( &cs );
                    return anz;
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deModelLöschen( Text *zDatei, Text *zModel ) // DateienEditor: Löscht Modell
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xB", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zModel->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zModel->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deSoundLöschen( Text *zDatei, Text *zSound ) // DateienEditor: Löscht Ton
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xC", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zSound->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zSound->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

Model2DData *EditorKlient::deModelLaden( Text *zDatei, Text *zModel, FBalken *zF ) // DateienEditor: läd ein Model herunter
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xD", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zModel->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zModel->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                    if( ret == 1 )
                    {
                        int anz = 0;
                        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
                        zF->setAktionAnzahl( anz );
                        Array< Polygon2D > *pol = new Array< Polygon2D >();
                        for( int i = 0; i < anz; i++ )
                        {
                            Polygon2D p;
                            p.vertex = new Array< Vertex >();
                            p.tKordinaten = new Array< Punkt >();
                            int anz2 = 0;
                            klient->getNachrichtVerschlüsselt( (char*)&anz2, 4 );
                            for( int j = 0; j < anz2; j++ )
                            {
                                Vertex v;
                                klient->getNachrichtVerschlüsselt( (char*)&v.x, 4 );
                                klient->getNachrichtVerschlüsselt( (char*)&v.y, 4 );
                                Punkt t;
                                klient->getNachrichtVerschlüsselt( (char*)&t.x, 4 );
                                klient->getNachrichtVerschlüsselt( (char*)&t.y, 4 );
                                p.vertex->add( v );
                                p.tKordinaten->add( t );
                            }
                            pol->add( p );
                            zF->aktionPlus();
                        }
                        Model2DData *data = new Model2DData();
                        data->erstelleModell( pol );
                        UNLOCK( &cs );
                        return data;
                    }
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

GSL::GSLSoundV *EditorKlient::deSoundLaden( Text *zDatei, Text *zSound, FBalken *zF ) // DateienEditor: läd Sound herunter
{
    HMODULE gslDll = dllDateien->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
    if( !gslDll )
    {
        fehler->setText( "Die DLL Datei 'data/bin/GSL.dll' wurde nicht gefunden." );
        return 0;
    }
    GetGSLDatei getGSLDatei = (GetGSLDatei)GetProcAddress( gslDll, "getGSLDatei" );
    if( !getGSLDatei )
    {
        fehler->setText( "Der Einstiegspunkt 'getGSLDatei' wurde in der Datei 'data/bin/GSL.dll' nicht gefunden." );
        return 0;
    }
    DateiLöschen( "data/tmp/editor/dateien/sounds/tmp.gsl" );
    DateiPfadErstellen( "data/tmp/editor/dateien/sounds/tmp.gsl" );
    GSL::GSLDateiV *gslDatei = getGSLDatei();
    gslDatei->setDatei( "data/tmp/editor/dateien/sounds/tmp.gsl" );
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        gslDatei->release();
        dllDateien->releaseDLL( "GSL.dll" );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xE", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zSound->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zSound->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                    if( ret == 1 )
                    {
                        DownloadSound dws( klient, zF );
                        gslDatei->speicherSound( &dws, zSound->getText() );
                        GSL::GSLSoundV *s = gslDatei->getSound( zSound->getText() );
                        gslDatei->release();
                        dllDateien->releaseDLL( "GSL.dll" );
                        UNLOCK( &cs );
                        return s;
                    }
                }
            }
        }
    }
    gslDatei->release();
    dllDateien->releaseDLL( "GSL.dll" );
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool EditorKlient::deModelSpeichern( Text *zDatei, Text *zModel, Model2DData *zData, FBalken *zF ) // DateienEditor: Speichert Modell
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\xF", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zModel->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zModel->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                    if( ret == 1 )
                    {
                        int anz = zData->polygons ? zData->polygons->getEintragAnzahl() : 0;
                        zF->setAktionAnzahl( anz );
                        klient->sendeVerschlüsselt( (char*)&anz, 4 );
                        for( int i = 0; i < anz; i++ )
                        {
                            Polygon2D pol = zData->polygons->get( i );
                            int anz2 = pol.vertex->getEintragAnzahl();
                            klient->sendeVerschlüsselt( (char*)&anz2, 4 );
                            for( int j = 0; j < anz2; j++ )
                            {
                                Vertex v = pol.vertex->get( j );
                                Punkt p;
                                if( pol.tKordinaten )
                                    p = pol.tKordinaten->hat( j ) ? pol.tKordinaten->get( j ) : Punkt( 0, 0 );
                                klient->sendeVerschlüsselt( (char*)&v.x, 4 );
                                klient->sendeVerschlüsselt( (char*)&v.y, 4 );
                                klient->sendeVerschlüsselt( (char*)&p.x, 4 );
                                klient->sendeVerschlüsselt( (char*)&p.y, 4 );
                            }
                            zF->aktionPlus();
                        }
                        klient->getNachrichtVerschlüsselt( &ret, 1 );
                    }
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::deSoundSpeichern( Text *zDatei, Text *zSound, GSL::GSLSoundV *zData, FBalken *zF ) // DateienEditor: Speichert Sound
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xD", 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->sendeVerschlüsselt( "\x10", 1 );
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            if( ret == 1 )
            {
                char l = (char)zDatei->getLänge();
                klient->sendeVerschlüsselt( &l, 1 );
                klient->sendeVerschlüsselt( zDatei->getText(), l );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
                if( ret == 1 )
                {
                    l = (char)zSound->getLänge();
                    klient->sendeVerschlüsselt( &l, 1 );
                    klient->sendeVerschlüsselt( zSound->getText(), l );
                    klient->getNachrichtVerschlüsselt( &ret, 1 );
                    if( ret == 1 )
                    {
                        char channels = zData->istMono() ? 1 : 2;
                        klient->sendeVerschlüsselt( &channels, 1 );
                        int sample = zData->getSampleRate();
                        klient->sendeVerschlüsselt( (char*)&sample, 4 );
                        __int64 slän = zData->getDatLänge();
                        klient->sendeVerschlüsselt( (char*)&slän, 8 );
                        zF->setAktionAnzahl( slän );
                        zData->öffnen();
                        char *buffer = new char[ 2048 ];
                        while( slän > 0 )
                        {
                            int l = slän > 2048 ? 2048 : (int)slän;
                            zData->getDaten( buffer, l );
                            klient->sende( buffer, l );
                            slän -= l;
                            zF->aktionPlus( l );
                        }
                        delete[] buffer;
                        zData->schließen();
                    }
                }
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::initEditor() // Initialisiert den Editor auf Serverseite
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x7", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( "\xE", 1 );
        char ret = 0;
        klient->getNachrichtVerschlüsselt( &ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return ret == 1;
}

bool EditorKlient::keepAlive() // Erhält die Verbindung aufrecht
{
    if( !TryEnterCriticalSection( &cs ) )
        return 1;
    if( !verbunden || !klient )
    {
        UNLOCK( &cs );
        return 0;
    }
    char res = 0;
    klient->sendeVerschlüsselt( "\x5", 1 );
    klient->getNachrichtVerschlüsselt( &res, 1 );
    UNLOCK( &cs );
    if( res != 1 )
    {
        trenne();
        fehler->setText( "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich." );
    }
    return res == 1;
}

bool EditorKlient::trenne() // trennt sich von dem Editor Server
{
    LOCK( &cs );
    if( !klient || !verbunden )
    {
        if( klient )
            klient = klient->release();
        UNLOCK( &cs );
        return 1;
    }
    char serverReturn;
    klient->sendeVerschlüsselt( "\4", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtVerschlüsselt( nachricht, län );
        delete[]nachricht;
    }
    klient->sendeVerschlüsselt( "\3", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    klient->trenne();
    klient = klient->release();
    verbunden = 0;
    UNLOCK( &cs );
    return 1;
}

void EditorKlient::lock()
{
    LOCK( &cs );
}

void EditorKlient::unlock()
{
    UNLOCK( &cs );
}

Klient *EditorKlient::zKlient() // gibt den Klient zurück
{
    if( cs.LockCount && cs.OwningThread == GetCurrentThread() )
        return klient;
    return 0;
}

// constant
bool EditorKlient::istVerbunden() const // prüft, ob mit Editor Server verbunden
{
    return verbunden;
}

char *EditorKlient::getLetzterFehler() const // gibt den Letzten Fehlertext zuück
{
    return fehler->getText();
}

// Reference Counting
EditorKlientV *EditorKlient::getThis()
{
    ref++;
    return this;
}

EditorKlientV *EditorKlient::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}