#include "EditorKlient.h"
#include <Klient.h>
#include "../Karte/EditorKarte.h"
#include <DateiSystem.h>
#include <M2Datei.h>

using namespace Network;
using namespace Editor;

SpielerTeamStruktur::SpielerTeamStruktur()
{
	spielerAnzahl = 0;
	teamAnzahl = 0;
	spielerFarbe = new Array< int >();
	teamFarbe = new Array< int >();
	teamName = new RCArray< Text >();
	teamSize = new Array< int >();
	ref = 1;
}

SpielerTeamStruktur::~SpielerTeamStruktur()
{
	spielerFarbe->release();
	teamFarbe->release();
	teamName->release();
	teamSize->release();
}

SpielerTeamStrukturV* SpielerTeamStruktur::getThis()
{
	ref++;
	return this;
}

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


// Inhalt der EditorKlient Klasse aus EditorKlient.h
// Konstruktor
//  k: Der zu verwendende Klient
EditorKlient::EditorKlient(KSGClient::EditorServerClient* k)
	: ReferenceCounter()
{
	klient = k;
}

// Destruktor
EditorKlient::~EditorKlient()
{
	klient->release();
}

// Initialisiert den Server
//  return: 1, falls erfolgreich
//          2, falls bereits eine Sitzung existiert
//          0, sonnst
int EditorKlient::init()
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	k->sendeEncrypted("\x0", 1);
	char ret;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
		k->getNachrichtEncrypted(&ret, 1);
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret;
}

// Verwirft die vorhandene Sitzung und erstellt eine neue
bool EditorKlient::sitzungVerwerfen()
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x1", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

// Speichert Sitzung und beendet Editor
bool EditorKlient::sitzungBeenden()
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x2", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::saveTeam(const TeamDaten* team)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x7", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&team->id, 4);
		k->sendeEncrypted((char*)&team->maxPunkte, 4);
		k->sendeEncrypted((char*)&team->beschleunigung, 8);
		k->sendeEncrypted((char*)&team->maxStabilität, 4);
		k->sendeEncrypted((char*)&team->maxEnergie, 4);
		k->sendeEncrypted((char*)&team->reparatur, 8);
		k->sendeEncrypted((char*)&team->akkuLeistung, 8);
		k->sendeEncrypted((char*)&team->laserIntensität, 4);
		k->sendeEncrypted((char*)&team->laserEffizienz, 4);
		k->sendeEncrypted((char*)&team->laserTempo, 4);
		k->sendeEncrypted((char*)&team->wendigkeit, 8);
		k->sendeEncrypted((char*)&team->antriebEffizienz, 8);
		k->sendeEncrypted((char*)&team->energieSchild, 8);
		k->sendeEncrypted((char*)&team->energieSchildEffizienz, 8);
		k->sendeEncrypted((char*)&team->punkte, 4);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::saveSpieler(const SpielerDaten* spieler)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x6", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&spieler->id, 4);
		k->sendeEncrypted((char*)&spieler->pos.x, 4);
		k->sendeEncrypted((char*)&spieler->pos.y, 4);
		k->sendeEncrypted((char*)&spieler->rot, 8);
		k->sendeEncrypted((char*)&spieler->beschleunigung, 8);
		k->sendeEncrypted((char*)&spieler->maxStabilität, 4);
		k->sendeEncrypted((char*)&spieler->maxEnergie, 4);
		k->sendeEncrypted((char*)&spieler->reparatur, 8);
		k->sendeEncrypted((char*)&spieler->akkuLeistung, 8);
		k->sendeEncrypted((char*)&spieler->laserIntensität, 4);
		k->sendeEncrypted((char*)&spieler->laserEffizienz, 4);
		k->sendeEncrypted((char*)&spieler->laserTempo, 4);
		k->sendeEncrypted((char*)&spieler->wendigkeit, 8);
		k->sendeEncrypted((char*)&spieler->antriebEffizienz, 8);
		k->sendeEncrypted((char*)&spieler->energieSchild, 8);
		k->sendeEncrypted((char*)&spieler->energieSchildEffizienz, 8);
		k->sendeEncrypted((char*)&spieler->netzwerk, 4);
		k->sendeEncrypted((char*)&spieler->skillPunkte, 4);
		k->sendeEncrypted((char*)&spieler->m2d, 4);
		k->sendeEncrypted((char*)&spieler->bild, 4);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::saveObjekt(const ObjektDaten* objekt)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x8", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&objekt->pos.x, 4);
		k->sendeEncrypted((char*)&objekt->pos.y, 4);
		k->sendeEncrypted((char*)&objekt->rot, 4);
		k->sendeEncrypted((char*)&objekt->scale, 4);
		k->sendeEncrypted((char*)&objekt->id, 4);
		k->sendeEncrypted((char*)&objekt->m2d, 4);
		k->sendeEncrypted((char*)&objekt->bild, 4);
		k->sendeEncrypted((char*)&objekt->style, 4);
		k->sendeEncrypted((char*)&objekt->maxStabilität, 4);
		k->sendeEncrypted((char*)&objekt->maxEnergie, 4);
		k->sendeEncrypted((char*)&objekt->energieRadius, 4);
		k->sendeEncrypted((char*)&objekt->reparatur, 8);
		k->sendeEncrypted((char*)&objekt->akkuLeistung, 8);
		k->sendeEncrypted((char*)&objekt->team, 1);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::deleteObjekt(int id)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x9", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::loadResources(Array< ResourceDaten* >& resources)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\xA", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		for (int i = 0; i < anz; i++)
		{
			ResourceDaten* resource = new ResourceDaten();
			k->getNachrichtEncrypted((char*)&resource->id, 4);
			char len = 0;
			k->getNachrichtEncrypted((char*)&len, 1);
			char* path = new char[len + 1];
			path[len] = 0;
			k->getNachrichtEncrypted(path, len);
			resource->path = path;
			delete[] path;
			resources.add(resource);
		}
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

int EditorKlient::addResource(const char* path)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\xC", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		unsigned char len = (unsigned char)strlen(path);
		k->sendeEncrypted((char*)&len, 1);
		k->sendeEncrypted(path, len);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int id = 0;
			k->getNachrichtEncrypted((char*)&id, 4);
			klient->endEditorMessage();
			return id;
		}
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return 0;
}

bool EditorKlient::loadSpieler(Array< SpielerDaten* >& spieler)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x3", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		for (int i = 0; i < anz; i++)
		{
			SpielerDaten* player = new SpielerDaten();
			k->getNachrichtEncrypted((char*)&player->id, 4);
			k->getNachrichtEncrypted((char*)&player->pos.x, 4);
			k->getNachrichtEncrypted((char*)&player->pos.y, 4);
			k->getNachrichtEncrypted((char*)&player->rot, 8);
			k->getNachrichtEncrypted((char*)&player->beschleunigung, 8);
			k->getNachrichtEncrypted((char*)&player->maxStabilität, 4);
			k->getNachrichtEncrypted((char*)&player->maxEnergie, 4);
			k->getNachrichtEncrypted((char*)&player->reparatur, 8);
			k->getNachrichtEncrypted((char*)&player->akkuLeistung, 8);
			k->getNachrichtEncrypted((char*)&player->laserIntensität, 4);
			k->getNachrichtEncrypted((char*)&player->laserEffizienz, 4);
			k->getNachrichtEncrypted((char*)&player->laserTempo, 4);
			k->getNachrichtEncrypted((char*)&player->wendigkeit, 8);
			k->getNachrichtEncrypted((char*)&player->antriebEffizienz, 8);
			k->getNachrichtEncrypted((char*)&player->energieSchild, 8);
			k->getNachrichtEncrypted((char*)&player->energieSchildEffizienz, 8);
			k->getNachrichtEncrypted((char*)&player->netzwerk, 4);
			k->getNachrichtEncrypted((char*)&player->skillPunkte, 4);
			k->getNachrichtEncrypted((char*)&player->m2d, 4);
			k->getNachrichtEncrypted((char*)&player->bild, 4);
			spieler.add(player);
		}
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::loadTeams(Array< TeamDaten* >& teams)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x4", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		for (int i = 0; i < anz; i++)
		{
			TeamDaten* team = new TeamDaten();
			k->getNachrichtEncrypted((char*)&team->id, 4);
			k->getNachrichtEncrypted((char*)&team->maxPunkte, 4);
			k->getNachrichtEncrypted((char*)&team->beschleunigung, 8);
			k->getNachrichtEncrypted((char*)&team->maxStabilität, 4);
			k->getNachrichtEncrypted((char*)&team->maxEnergie, 4);
			k->getNachrichtEncrypted((char*)&team->reparatur, 8);
			k->getNachrichtEncrypted((char*)&team->akkuLeistung, 8);
			k->getNachrichtEncrypted((char*)&team->laserIntensität, 4);
			k->getNachrichtEncrypted((char*)&team->laserEffizienz, 4);
			k->getNachrichtEncrypted((char*)&team->laserTempo, 4);
			k->getNachrichtEncrypted((char*)&team->wendigkeit, 8);
			k->getNachrichtEncrypted((char*)&team->antriebEffizienz, 8);
			k->getNachrichtEncrypted((char*)&team->energieSchild, 8);
			k->getNachrichtEncrypted((char*)&team->energieSchildEffizienz, 8);
			k->getNachrichtEncrypted((char*)&team->punkte, 4);
			teams.add(team);
		}
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

bool EditorKlient::loadObjekte(Array< ObjektDaten* >& objekte)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\x5", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		for (int i = 0; i < anz; i++)
		{
			ObjektDaten* objekt = new ObjektDaten();
			k->getNachrichtEncrypted((char*)&objekt->pos.x, 4);
			k->getNachrichtEncrypted((char*)&objekt->pos.y, 4);
			k->getNachrichtEncrypted((char*)&objekt->rot, 4);
			k->getNachrichtEncrypted((char*)&objekt->scale, 4);
			k->getNachrichtEncrypted((char*)&objekt->id, 4);
			k->getNachrichtEncrypted((char*)&objekt->m2d, 4);
			k->getNachrichtEncrypted((char*)&objekt->bild, 4);
			k->getNachrichtEncrypted((char*)&objekt->style, 4);
			k->getNachrichtEncrypted((char*)&objekt->maxStabilität, 4);
			k->getNachrichtEncrypted((char*)&objekt->maxEnergie, 4);
			k->getNachrichtEncrypted((char*)&objekt->energieRadius, 4);
			k->getNachrichtEncrypted((char*)&objekt->reparatur, 8);
			k->getNachrichtEncrypted((char*)&objekt->akkuLeistung, 8);
			k->getNachrichtEncrypted((char*)&objekt->team, 1);
			objekte.add(objekt);
		}
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

Bild* EditorKlient::loadBild(const char* templatePath)
{
	Text txt(templatePath);
	Text pfad;
	if (txt.positionVon("spiel:") == 0)
	{
		pfad = "data/spiele/Asteroids";
		pfad.append(txt.getTeilText(6));
		if (pfad.hat(".ltdb/"))
		{
			int pos = pfad.positionVon(".ltdb/", pfad.anzahlVon(".ltdb/") - 1);
			LTDBDatei datei;
			datei.setDatei(pfad.getTeilText(0, pos + 5));
			datei.leseDaten(0);
			return datei.laden(0, pfad.getTeilText(pos + 6));
		}
	}
	if (txt.positionVon("map:") == 0)
	{
		pfad.append(txt.getTeilText(5));
		if (pfad.hat(".ltdb/"))
		{
			cs.lock();
			if (klient->deResetPath())
			{
				while (pfad.anzahlVon("/") > 1)
				{
					Text* name = pfad.getTeilText(0, pfad.positionVon("/"));
					klient->deOrdnerÖffnen(name);
					pfad.remove(0, name->getLength() + 1);
					name->release();
				}
				Text* datei = pfad.getTeilText(0, pfad.positionVon(".ltdb/") + 5);
				Text* bild = pfad.getTeilText(pfad.positionVon(".ltdb/") + 6);
				Bild* res = klient->deBildLaden(datei, bild, 0);
				datei->release();
				bild->release();
				cs.unlock();
				return res;
			}
			cs.unlock();
		}
	}
	error = klient->getLetzterFehler();
	return 0;
}

Model2DData* EditorKlient::loadModel(const char* templatePath)
{
	Text txt(templatePath);
	Text pfad;
	if (txt.positionVon("spiel:") == 0)
	{
		pfad = "data/spiele/Asteroids";
		pfad.append(txt.getTeilText(6));
		if (pfad.hat(".m2/"))
		{
			int pos = pfad.positionVon(".m2/", pfad.anzahlVon(".m2/") - 1);
			M2Datei datei;
			Text* file = pfad.getTeilText(0, pos + 3);
			datei.setPfad(file->getText());
			file->release();
			datei.leseDaten();
			return datei.ladeModel(pfad.getTeilText(pos + 4));
		}
	}
	if (txt.positionVon("map:") == 0)
	{
		pfad.append(txt.getTeilText(5));
		if (pfad.hat(".m2/"))
		{
			cs.lock();
			if (klient->deResetPath())
			{
				while (pfad.anzahlVon("/") > 1)
				{
					Text* name = pfad.getTeilText(0, pfad.positionVon("/"));
					klient->deOrdnerÖffnen(name);
					pfad.remove(0, name->getLength() + 1);
					name->release();
				}
				Text* datei = pfad.getTeilText(0, pfad.positionVon(".m2/") + 3);
				Text* model = pfad.getTeilText(pfad.positionVon(".m2/") + 4);
				Model2DData* res = klient->deModelLaden(datei, model, 0);
				datei->release();
				model->release();
				cs.unlock();
				return res;
			}
			cs.unlock();
		}
	}
	error = klient->getLetzterFehler();
	return 0;
}

RCArray< Text >* EditorKlient::getAllMapResourcePaths()
{
	cs.lock();
	klient->deResetPath();
	RCArray< Text >* result = new RCArray< Text >();
	loadMapResourcePathsFromFolder("map:", result);
	cs.unlock();
	return result;
}

void EditorKlient::loadMapResourcePathsFromFolder(const char* folderPath, RCArray< Text >* zPaths)
{
	RCArray< Text >* files = new RCArray< Text >();
	klient->deGetDateiListe(files);
	for (auto f : *files)
	{
		Text path(folderPath);
		path += Text("/") + *f;
		if (!f->hat("."))
		{
			klient->deOrdnerÖffnen(f);
			loadMapResourcePathsFromFolder(path, zPaths);
			Text back = "..";
			klient->deOrdnerÖffnen(&back);
		}
		else if (f->hat(".ltdb"))
		{
			RCArray< Text >* bilder = new RCArray< Text >();
			klient->deGetBildListe(f, bilder);
			for (auto n : *bilder)
				zPaths->add(new Text(path + "/" + *n));
			bilder->release();
		}
		else if (f->hat(".m2"))
		{
			RCArray< Text >* models = new RCArray< Text >();
			klient->deGetModelListe(f, models);
			for (auto n : *models)
				zPaths->add(new Text(path + "/" + *n));
			models->release();
		}
		else if (f->hat(".gsl"))
		{
			RCArray< Text >* sounds = new RCArray< Text >();
			klient->deGetSoundListe(f, sounds);
			for (auto n : *sounds)
				zPaths->add(new Text(path + "/" + *n));
			sounds->release();
		}
	}
	files->release();
}

// Lädt die Spieler Team Struktur
bool EditorKlient::getSpielerTeamStruktur(SpielerTeamStrukturV* sts)
{
	return klient->ladeTeamDaten(sts);
}

bool EditorKlient::loadMapSize(Punkt& size)
{
	Network::Klient* k = klient->beginEditorMessage();
	if (!k)
	{
		error = klient->getLetzterFehler();
		return 0;
	}
	error = "";
	char ret;
	k->sendeEncrypted("\xB", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->getNachrichtEncrypted((char*)&size.x, 4);
		k->getNachrichtEncrypted((char*)&size.y, 4);
	}
	if (ret == 3)
	{
		unsigned char l = 0;
		k->getNachrichtEncrypted((char*)&l, 1);
		char* err = new char[l + 1];
		err[l] = 0;
		k->getNachrichtEncrypted(err, l);
		error = err;
		delete[] err;
		ret = 0;
	}
	klient->endEditorMessage();
	return ret == 1;
}

// Gibt den Letzten Fehler zurück
const char* EditorKlient::getLastError() const
{
	return error;
}