improved util classes

Datei.cpp

@@ -29,6 +29,20 @@ Datei::Datei()
 	key(0)
 {}
 
+//! Konstruktor 
+Datei::Datei(const char* pfad)
+	: Datei()
+{
+	setDatei(pfad);
+}
+
+//! Konstruktor 
+Datei::Datei(Text* pfad)
+	: Datei()
+{
+	setDatei(pfad);
+}
+
 // Destruktor 
 Datei::~Datei()
 {

Datei.h

@@ -8,185 +8,189 @@
 
 namespace Framework
 {
-    class Text; //! Text.h
-    class Zeit; //! Zeit.h
+	class Text; //! Text.h
+	class Zeit; //! Zeit.h
 	namespace Encryption
 	{
 		class Key; //! Schlüssel.h
 	}
-    class Datei; //! aus dieser Datei
+	class Datei; //! aus dieser Datei
 
-    //! Ließt und schreibt in eine Datei
-    class Datei : public Reader, public Writer, public virtual ReferenceCounter
-    {
-    public:
-        class Style
-        {
-        public:
-            const static int lesen = 0x01; //! datei wird zum lesen geöffnet
-            const static int schreiben = 0x02; //! datei wirt zum schreiben geöffnet
-            const static int ende = 0x04; //! setzt dateizeiger ans Ende der Datei
-        };
-    private:
-        std::fstream *stream;
-        Text *pfad;
-        __int64 gr;
-        char tmpLByte;
-        char tmpLBPos;
-        char tmpSByte;
-        char tmpSBPos;
-		Encryption::Key *key;
+	//! Ließt und schreibt in eine Datei
+	class Datei : public Reader, public Writer, public virtual ReferenceCounter
+	{
+	public:
+		class Style
+		{
+		public:
+			const static int lesen = 0x01; //! datei wird zum lesen geöffnet
+			const static int schreiben = 0x02; //! datei wirt zum schreiben geöffnet
+			const static int ende = 0x04; //! setzt dateizeiger ans Ende der Datei
+		};
+	private:
+		std::fstream* stream;
+		Text* pfad;
+		__int64 gr;
+		char tmpLByte;
+		char tmpLBPos;
+		char tmpSByte;
+		char tmpSBPos;
+		Encryption::Key* key;
 
-    public:
-        //! Konstruktor 
-        DLLEXPORT Datei();
-        //! Destruktor 
-        DLLEXPORT virtual ~Datei();
-        //! Setzt den Pfad zur Datei
-        //! \param pfad Der Pfad
-        DLLEXPORT void setDatei( const char *pfad );
-        //! Setzt den Pfad zur Datei
-        //! \param pfad Der Pfad
-        DLLEXPORT void setDatei( Text *pfad );
-        //! Benennt die Datei um oder verschiebt sie
-        //! \param pfad Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
-        //! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
-        DLLEXPORT bool umbenennen( const char *pfad );
-        //! Benennt die Datei um oder verschiebt sie
-        //! \param pfad Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
-        //! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
-        DLLEXPORT bool umbenennen( Text *pfad );
-        //! Löscht die Datei
-        //! \return 1, wenn das löschen erfolgreich war. 0 sonst
-        DLLEXPORT bool remove();
-        //! Erstellt die Datei neu. Wenn im Pfad Ordner vorkommen, die nicht existieren, so werden sie erstellt
-        //!  return 1: wenn das erstellen erfolgreich war. 0, sonst
-        DLLEXPORT bool erstellen();
-        //! Öffnet die Datei
-        //! \param style Legt fest, ob die Datei zum lesen und/oder schreiben geöffnet wird. Alle Elemente aus Datei::Style:: sin möglich
-        //!  return 1: wenn die datei erfolgreich geöffnet werden konnte. 0 sonnst
-        DLLEXPORT bool open( int style );
-        //! Setzt die Position des Bytes, das als nächstes gelesen werden soll
-        //! \param pos Der Index des Bytes
-        //! \param ende 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
-        DLLEXPORT void setLPosition( __int64 pos, bool ende ) override;
-        //! Setzt die Position des Bytes, das als nächstes überschrieben wird
-        //! \param pos Der Index des Bytes
-        //! \param ende 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
-        DLLEXPORT void setSPosition( __int64 pos, bool ende ) override;
-        //! Schreibt in die Datei
-        //! \param bytes Ein Array von bytes, die geschrieben werden sollen.
-        //! \param len Wie viele Bytes in die Datei geschrieben werden sollen
-        DLLEXPORT void schreibe( const char *bytes, int len ) override;
-        //! Ließt aus der Datei
-        //! \param bytes Ein Array, der mit Bytes aus der Datei gefüllt werden soll
-        //! \param len Wie viele Bytes aus der Datei gelesen werden sollen
-        DLLEXPORT void lese( char *bytes, int len ) override;
-        //! Ließt die nächste zeile der Datei ein
-        //! \return Die gelesene Zeile als Text mit zeilenumbruch
-        DLLEXPORT Text *leseZeile() override;
-        //! Schließt die datei
-        DLLEXPORT void close();
+	public:
+		//! Konstruktor 
+		DLLEXPORT Datei();
+		//! Konstruktor 
+		DLLEXPORT Datei(const char* pfad);
+		//! Konstruktor 
+		DLLEXPORT Datei(Text* pfad);
+		//! Destruktor 
+		DLLEXPORT virtual ~Datei();
+		//! Setzt den Pfad zur Datei
+		//! \param pfad Der Pfad
+		DLLEXPORT void setDatei(const char* pfad);
+		//! Setzt den Pfad zur Datei
+		//! \param pfad Der Pfad
+		DLLEXPORT void setDatei(Text* pfad);
+		//! Benennt die Datei um oder verschiebt sie
+		//! \param pfad Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
+		//! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
+		DLLEXPORT bool umbenennen(const char* pfad);
+		//! Benennt die Datei um oder verschiebt sie
+		//! \param pfad Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
+		//! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
+		DLLEXPORT bool umbenennen(Text* pfad);
+		//! Löscht die Datei
+		//! \return 1, wenn das löschen erfolgreich war. 0 sonst
+		DLLEXPORT bool remove();
+		//! Erstellt die Datei neu. Wenn im Pfad Ordner vorkommen, die nicht existieren, so werden sie erstellt
+		//!  return 1: wenn das erstellen erfolgreich war. 0, sonst
+		DLLEXPORT bool erstellen();
+		//! Öffnet die Datei
+		//! \param style Legt fest, ob die Datei zum lesen und/oder schreiben geöffnet wird. Alle Elemente aus Datei::Style:: sin möglich
+		//!  return 1: wenn die datei erfolgreich geöffnet werden konnte. 0 sonnst
+		DLLEXPORT bool open(int style);
+		//! Setzt die Position des Bytes, das als nächstes gelesen werden soll
+		//! \param pos Der Index des Bytes
+		//! \param ende 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
+		DLLEXPORT void setLPosition(__int64 pos, bool ende) override;
+		//! Setzt die Position des Bytes, das als nächstes überschrieben wird
+		//! \param pos Der Index des Bytes
+		//! \param ende 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
+		DLLEXPORT void setSPosition(__int64 pos, bool ende) override;
+		//! Schreibt in die Datei
+		//! \param bytes Ein Array von bytes, die geschrieben werden sollen.
+		//! \param len Wie viele Bytes in die Datei geschrieben werden sollen
+		DLLEXPORT void schreibe(const char* bytes, int len) override;
+		//! Ließt aus der Datei
+		//! \param bytes Ein Array, der mit Bytes aus der Datei gefüllt werden soll
+		//! \param len Wie viele Bytes aus der Datei gelesen werden sollen
+		DLLEXPORT void lese(char* bytes, int len) override;
+		//! Ließt die nächste zeile der Datei ein
+		//! \return Die gelesene Zeile als Text mit zeilenumbruch
+		DLLEXPORT Text* leseZeile() override;
+		//! Schließt die datei
+		DLLEXPORT void close();
 		//! Setzt den Schlüssel für die Datei
-		DLLEXPORT void setKey( char *s, int l );
+		DLLEXPORT void setKey(char* s, int l);
 #ifdef WIN32
-        //! Setzt den Zeitpunkt der letzten Änderung der Datei (nur für Windows)
-        //! \param zeit den Zeitpunkt der letzten Änderung
-        //! \return 1, wenn der Zeitpunkt gesetzt wurde. 0 sonst
-        DLLEXPORT bool setLetzteÄnderung( Zeit *zeit );
+		//! Setzt den Zeitpunkt der letzten Änderung der Datei (nur für Windows)
+		//! \param zeit den Zeitpunkt der letzten Änderung
+		//! \return 1, wenn der Zeitpunkt gesetzt wurde. 0 sonst
+		DLLEXPORT bool setLetzteÄnderung(Zeit* zeit);
 #endif
-        //! Ließt das nächste Bit aus der Datei
-        //! \param bit Eine Referenz auf deinen bool, in dem das Bit gespeichert wird
-        //!  return 1, falls das lesen erfolgreich war. 0, sonst
-        DLLEXPORT bool getNextBit( bool &bit );
-        //! Speichert ein einzelnes Bit in der Datei
-        //! \param bit Das bit, welches gespeichert werden soll
-        //!  return 1, falls das speichern erfolgreich war
-        DLLEXPORT bool setNextBit( bool bit );
-        //! Prüft, ob die Datei ein Verzeichnis ist
-        //!  return 1, falls die Datei ein Verzeichnis ist. 0, sonst
-        DLLEXPORT bool istOrdner() const;
-        //! Prüft, ob die Datei bereits geöffnet wurde
-        //! \return 1, wenn die Datei geöffnet ist. 0 sonnst
-        DLLEXPORT bool istOffen() const;
-        //! Gibt die Anzahl an Unterdateien von dem Verzeichnis zurück
-        //! \return 0, falls die Datei kein Verzeichnis ist. Sonst die Anzahl der Unterdateien
-        DLLEXPORT int getUnterdateiAnzahl() const;
-        //! Gibt eine Liste mit unterdateien zurück
-        //!  return 0, falls die Datei kein Verzeichnis ist. Eine Liste mit den Namen der Unterdateien
-        DLLEXPORT RCArray< Text > *getDateiListe() const;
-        //! Gibt die Größe der Datei zurück
-        //! return -1, falls die Datei ein Verzeichnis ist oder ein Fehler auftrat. Sonst die größe der Datei
-        DLLEXPORT __int64 getSize() const;
-        //! Gibt den Zeitpunkt der letzten änderung zurück
-        //! \return 0, falls ein Fehler aufgetreten ist. Der Zeitpunkt der letzten Änderung sonst
-        DLLEXPORT Zeit *getLastChange() const;
-        //! Prüft, ob die Datei existiert
-        //! \return 1, falls die Datei existiert. 0 sonnst
-        DLLEXPORT bool existiert() const;
-        //! Gibt den Index des Bytes aus der Datei zurück, welches als nächstes gelesen werden würde
-        //! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
-        DLLEXPORT __int64 getLPosition() const override;
-        //! Gibt den Index des Bytes aus der Datei zurück, welches als nächstes überschrieben werden würde
-        //! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Schreibzeigers
-        DLLEXPORT __int64 getSPosition() const override;
-        //! Prüft, ob die Datei vollständig gelesen wurde
-        //!  return 1, wenn die Datei vollständig gelesen wurde. 0, sonst
-        DLLEXPORT bool istEnde() const override;
-        //! Gibt den Pfad zur Datei zurück
-        DLLEXPORT Text *getPfad() const;
-        //! Gibt den Pfad zur Datei ohne erhöhten Reference Counter zurück
-        DLLEXPORT Text *zPfad() const;
-    };
+		//! Ließt das nächste Bit aus der Datei
+		//! \param bit Eine Referenz auf deinen bool, in dem das Bit gespeichert wird
+		//!  return 1, falls das lesen erfolgreich war. 0, sonst
+		DLLEXPORT bool getNextBit(bool& bit);
+		//! Speichert ein einzelnes Bit in der Datei
+		//! \param bit Das bit, welches gespeichert werden soll
+		//!  return 1, falls das speichern erfolgreich war
+		DLLEXPORT bool setNextBit(bool bit);
+		//! Prüft, ob die Datei ein Verzeichnis ist
+		//!  return 1, falls die Datei ein Verzeichnis ist. 0, sonst
+		DLLEXPORT bool istOrdner() const;
+		//! Prüft, ob die Datei bereits geöffnet wurde
+		//! \return 1, wenn die Datei geöffnet ist. 0 sonnst
+		DLLEXPORT bool istOffen() const;
+		//! Gibt die Anzahl an Unterdateien von dem Verzeichnis zurück
+		//! \return 0, falls die Datei kein Verzeichnis ist. Sonst die Anzahl der Unterdateien
+		DLLEXPORT int getUnterdateiAnzahl() const;
+		//! Gibt eine Liste mit unterdateien zurück
+		//!  return 0, falls die Datei kein Verzeichnis ist. Eine Liste mit den Namen der Unterdateien
+		DLLEXPORT RCArray< Text >* getDateiListe() const;
+		//! Gibt die Größe der Datei zurück
+		//! return -1, falls die Datei ein Verzeichnis ist oder ein Fehler auftrat. Sonst die größe der Datei
+		DLLEXPORT __int64 getSize() const;
+		//! Gibt den Zeitpunkt der letzten änderung zurück
+		//! \return 0, falls ein Fehler aufgetreten ist. Der Zeitpunkt der letzten Änderung sonst
+		DLLEXPORT Zeit* getLastChange() const;
+		//! Prüft, ob die Datei existiert
+		//! \return 1, falls die Datei existiert. 0 sonnst
+		DLLEXPORT bool existiert() const;
+		//! Gibt den Index des Bytes aus der Datei zurück, welches als nächstes gelesen werden würde
+		//! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
+		DLLEXPORT __int64 getLPosition() const override;
+		//! Gibt den Index des Bytes aus der Datei zurück, welches als nächstes überschrieben werden würde
+		//! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Schreibzeigers
+		DLLEXPORT __int64 getSPosition() const override;
+		//! Prüft, ob die Datei vollständig gelesen wurde
+		//!  return 1, wenn die Datei vollständig gelesen wurde. 0, sonst
+		DLLEXPORT bool istEnde() const override;
+		//! Gibt den Pfad zur Datei zurück
+		DLLEXPORT Text* getPfad() const;
+		//! Gibt den Pfad zur Datei ohne erhöhten Reference Counter zurück
+		DLLEXPORT Text* zPfad() const;
+	};
 
-    //! Datei Funktionen
+	//! Datei Funktionen
 
-    //! Sucht einen unbenutzten Dateinamen
-    //! \param zPfad Ein Zeiger zu dem Pfad, in dem ein unbenutzter Dateiname gefunden werden soll. Ohne erhöhten Reference Counter.
-    //!          Wird auch als rückgabewert benutzt
-    DLLEXPORT void GetFreePfad( Text *zPfad );
-    //! Erstellt den vollständigen Pfad mit Datei
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, falls das erstellen erfolgreich war.
-    DLLEXPORT bool DateiPfadErstellen( Text* pfad );
-    //! Löscht die angegebene Datei
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, falls die Datei gelöscht wurde
-    DLLEXPORT bool DateiRemove( Text *pfad );
-    //! Benennt eine Datei um oder verschiebt sie
-    //!  pfad_alt: Der Pfad zur Datei, die umbenannt werden soll.
-    //!  pfad_neu: Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
-    //! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
-    DLLEXPORT bool DateiUmbenennen( Text *pfad_alt, Text *pfad_neu );
-    //! Prüft, ob Datei existiert
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
-    DLLEXPORT bool DateiExistiert( Text *pfad );
-    //! prüft, ob pfad ein Verzeichnis ist
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, wenn die Datei ein Verzeichnis ist. 0 sonst
-    DLLEXPORT bool DateiIstVerzeichnis( Text *pfad );
-    //! Erstellt den vollständigen Pfad mit Datei
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, falls das erstellen erfolgreich war.
-    DLLEXPORT bool DateiPfadErstellen( const char *pfad );
-    //! Löscht die angegebene Datei
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, falls die Datei gelöscht wurde
-    DLLEXPORT bool DateiRemove( const char *pfad );
-    //! Benennt eine Datei um oder verschiebt sie
-    //!  pfad_alt: Der Pfad zur Datei, die umbenannt werden soll.
-    //!  pfad_neu: Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
-    //! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
-    DLLEXPORT bool DateiUmbenennen( const char *pfad_alt, const char *pfad_neu );
-    //! Prüft, ob Datei existiert
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
-    DLLEXPORT bool DateiExistiert( const char *pfad );
-    //! prüft, ob pfad ein Verzeichnis ist
-    //! \param pfad Der Pfad zur Datei
-    //! \return 1, wenn die Datei ein Verzeichnis ist. 0 sonst
-    DLLEXPORT bool DateiIstVerzeichnis( const char *pfad );
+	//! Sucht einen unbenutzten Dateinamen
+	//! \param zPfad Ein Zeiger zu dem Pfad, in dem ein unbenutzter Dateiname gefunden werden soll. Ohne erhöhten Reference Counter.
+	//!          Wird auch als rückgabewert benutzt
+	DLLEXPORT void GetFreePfad(Text* zPfad);
+	//! Erstellt den vollständigen Pfad mit Datei
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, falls das erstellen erfolgreich war.
+	DLLEXPORT bool DateiPfadErstellen(Text* pfad);
+	//! Löscht die angegebene Datei
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, falls die Datei gelöscht wurde
+	DLLEXPORT bool DateiRemove(Text* pfad);
+	//! Benennt eine Datei um oder verschiebt sie
+	//!  pfad_alt: Der Pfad zur Datei, die umbenannt werden soll.
+	//!  pfad_neu: Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
+	//! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
+	DLLEXPORT bool DateiUmbenennen(Text* pfad_alt, Text* pfad_neu);
+	//! Prüft, ob Datei existiert
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
+	DLLEXPORT bool DateiExistiert(Text* pfad);
+	//! prüft, ob pfad ein Verzeichnis ist
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, wenn die Datei ein Verzeichnis ist. 0 sonst
+	DLLEXPORT bool DateiIstVerzeichnis(Text* pfad);
+	//! Erstellt den vollständigen Pfad mit Datei
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, falls das erstellen erfolgreich war.
+	DLLEXPORT bool DateiPfadErstellen(const char* pfad);
+	//! Löscht die angegebene Datei
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, falls die Datei gelöscht wurde
+	DLLEXPORT bool DateiRemove(const char* pfad);
+	//! Benennt eine Datei um oder verschiebt sie
+	//!  pfad_alt: Der Pfad zur Datei, die umbenannt werden soll.
+	//!  pfad_neu: Der neue Pfad zur Datei. Wenn sich nur der Name ändert, wird sie nur umbenannt
+	//! \return 1, wenn das umbenennen erfolgreich war. 0, sonst
+	DLLEXPORT bool DateiUmbenennen(const char* pfad_alt, const char* pfad_neu);
+	//! Prüft, ob Datei existiert
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
+	DLLEXPORT bool DateiExistiert(const char* pfad);
+	//! prüft, ob pfad ein Verzeichnis ist
+	//! \param pfad Der Pfad zur Datei
+	//! \return 1, wenn die Datei ein Verzeichnis ist. 0 sonst
+	DLLEXPORT bool DateiIstVerzeichnis(const char* pfad);
 }
 
 #endif

Text.cpp

@@ -12,1637 +12,1653 @@ using namespace Framework;
 // inhalt der Text Klasse aus Text.h
 // Konstruktor 
 Text::Text()
-    : ReferenceCounter(),
-    txt( 0 ),
-    suchGBeg( 0 ),
-    suchGEnd( 0 ),
-    precision( 0 )
+	: ReferenceCounter(),
+	txt(0),
+	suchGBeg(0),
+	suchGEnd(0),
+	precision(0)
 {
-    setText( "" );
+	setText("");
 }
 
-Text::Text( const Text &txt )
-    : Text()
+Text::Text(const Text& txt)
+	: Text()
 {
-    setText( txt );
+	setText(txt);
 }
 
-Text::Text( const char *t )
-    : Text()
+Text::Text(const char* t)
+	: Text()
 {
-    setText( t ); // Text setzen
+	setText(t); // Text setzen
 }
 
-Text::Text( int zahl )
-    : Text()
+Text::Text(int zahl)
+	: Text()
 {
-    *this = zahl;
+	*this = zahl;
 }
 
 // Erstellt ein neues Text Objekt mit einer zahl als text
 //  num: Die Zahl, die im Text sein soll
-Text::Text( double num )
-    : Text()
+Text::Text(double num)
+	: Text()
 {
-    *this = num;
+	*this = num;
 }
 
 // Erstellt ein neues Text Objekt mit einer zahl als text
 //  num: Die Zahl, die im Text sein soll
-Text::Text( float num )
-    : Text()
+Text::Text(float num)
+	: Text()
 {
-    *this = num;
+	*this = num;
 }
 
 // Destruktor 
 Text::~Text()
 {
-    delete[]txt;
+	delete[]txt;
 }
 
 void Text::toUpperCase()
 {
-    if( !txt )
-        return;
-    int len = textLength( txt );
-    for( int i = 0; i < len; i++ )
-    {
-        if( txt[ i ] >= 'a' && txt[ i ] <= 'z' )
-            txt[ i ] = (char)( txt[ i ] - 32 );
-        switch( txt[ i ] )
-        {
-        case 'ü':
-            txt[ i ] = 'Ü';
-            break;
-        case 'ö':
-            txt[ i ] = 'Ö';
-            break;
-        case 'ä':
-            txt[ i ] = 'Ä';
-            break;
-        }
-    }
+	if (!txt)
+		return;
+	int len = textLength(txt);
+	for (int i = 0; i < len; i++)
+	{
+		if (txt[i] >= 'a' && txt[i] <= 'z')
+			txt[i] = (char)(txt[i] - 32);
+		switch (txt[i])
+		{
+		case 'ü':
+			txt[i] = 'Ü';
+			break;
+		case 'ö':
+			txt[i] = 'Ö';
+			break;
+		case 'ä':
+			txt[i] = 'Ä';
+			break;
+		}
+	}
 }
 
 void Text::toLowerCase()
 {
-    if( !txt )
-        return;
-    int len = textLength( txt );
-    for( int i = 0; i < len; i++ )
-    {
-        if( txt[ i ] >= 'A' && txt[ i ] <= 'Z' )
-            txt[ i ] = (char)( txt[ i ] + 32 );
-        switch( txt[ i ] )
-        {
-        case 'Ü':
-            txt[ i ] = 'ü';
-            break;
-        case 'Ö':
-            txt[ i ] = 'ö';
-            break;
-        case 'Ä':
-            txt[ i ] = 'ä';
-            break;
-        }
-    }
+	if (!txt)
+		return;
+	int len = textLength(txt);
+	for (int i = 0; i < len; i++)
+	{
+		if (txt[i] >= 'A' && txt[i] <= 'Z')
+			txt[i] = (char)(txt[i] + 32);
+		switch (txt[i])
+		{
+		case 'Ü':
+			txt[i] = 'ü';
+			break;
+		case 'Ö':
+			txt[i] = 'ö';
+			break;
+		case 'Ä':
+			txt[i] = 'ä';
+			break;
+		}
+	}
 }
 
 // nicht constant
-void Text::setSuchGrenzen( char gBeg, char gEnd ) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
+void Text::setSuchGrenzen(char gBeg, char gEnd) // sucht bei jeder suchfunktion nicht zwischen den Zeichen gBeg und gEnd
 {
-    suchGBeg = gBeg;
-    suchGEnd = gEnd;
+	suchGBeg = gBeg;
+	suchGEnd = gEnd;
 }
 
-void Text::setText( const char *t ) // ersetzt den Text
+void Text::setText(const char* t) // ersetzt den Text
 {
-    delete[]txt; // alter Text löschen
-    int l = (int)textLength( t ); // Länge des neuen Textes ermitteln
-    txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
-    for( int i = 0; i < l; ++i ) // Text befüllen
-        txt[ i ] = t[ i ];
-    txt[ l ] = '\0'; // Textende Festlegen
+	delete[]txt; // alter Text löschen
+	int l = (int)textLength(t); // Länge des neuen Textes ermitteln
+	txt = new char[(__int64)l + 1]; // neuen Text erstellen
+	for (int i = 0; i < l; ++i) // Text befüllen
+		txt[i] = t[i];
+	txt[l] = '\0'; // Textende Festlegen
 }
 
 // unconstant 
-void Text::setText( const char *t, int l ) // ersetzt den Text
+void Text::setText(const char* t, int l) // ersetzt den Text
 {
-    delete[]txt; // alter Text löschen
-    txt = new char[ (__int64)l + 1 ]; // neuen Text erstellen
-    for( int i = 0; i < l; ++i ) // Text befüllen
-        txt[ i ] = t[ i ];
-    txt[ l ] = '\0'; // Textende Festlegen
+	delete[]txt; // alter Text löschen
+	txt = new char[(__int64)l + 1]; // neuen Text erstellen
+	for (int i = 0; i < l; ++i) // Text befüllen
+		txt[i] = t[i];
+	txt[l] = '\0'; // Textende Festlegen
 }
 
-void Text::setText( Text *t )
+void Text::setText(Text* t)
 {
-    setText( t->getText() ); // Text setzen
-    t->release(); // übergabe loslassen
+	setText(t->getText()); // Text setzen
+	t->release(); // übergabe loslassen
 }
 
-void Text::append( char c ) // hängt an den Text an
+void Text::append(char c) // hängt an den Text an
 {
-    append( &c, 1 );
+	append(&c, 1);
 }
 
-void Text::append( const char *t ) // hängt an den Text an
+void Text::append(const char* t) // hängt an den Text an
 {
-    int tl = (int)textLength( t ); // länge der übergabe
-    int txl = getLength(); // länge des Textes
-    char *res = new char[ (__int64)tl + txl + 1 ]; // neuen Text erstellen
-    for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
-        res[ i ] = txt[ i ];
-    for( int i = 0; i < tl; ++i ) // Übergabe anhängen
-        res[ txl + i ] = t[ i ];
-    res[ txl + tl ] = '\0'; // Textende festlegen
-    setText( res ); // Test setzen
-    delete[] res; // Speicher freigeben
+	int tl = (int)textLength(t); // länge der übergabe
+	int txl = getLength(); // länge des Textes
+	char* res = new char[(__int64)tl + txl + 1]; // neuen Text erstellen
+	for (int i = 0; i < txl; ++i) // mit jetzigem Text füllen
+		res[i] = txt[i];
+	for (int i = 0; i < tl; ++i) // Übergabe anhängen
+		res[txl + i] = t[i];
+	res[txl + tl] = '\0'; // Textende festlegen
+	setText(res); // Test setzen
+	delete[] res; // Speicher freigeben
 }
 
-void Text::appendHex( int num ) // hängt die zahl in hex anden Text an
+void Text::appendHex(int num) // hängt die zahl in hex anden Text an
 {
-    int l = getLength();
-    char *res = new char[ (__int64)l + 9 ];
-    for( int i = 0; i < l; ++i )
-        res[ i ] = txt[ i ];
-    std::stringstream stream;
-    stream << std::setfill( '0' ) << std::setw( (int)sizeof( int ) * 2 ) << std::hex << num;
-    std::string str = stream.str();
-    for( int i = l; i < l + 8; ++i )
-        res[ i ] = str.c_str()[ i - l ];
-    res[ l + 8 ] = 0;
-    setText( res );
-    delete[] res;
+	int l = getLength();
+	char* res = new char[(__int64)l + 9];
+	for (int i = 0; i < l; ++i)
+		res[i] = txt[i];
+	std::stringstream stream;
+	stream << std::setfill('0') << std::setw((int)sizeof(int) * 2) << std::hex << num;
+	std::string str = stream.str();
+	for (int i = l; i < l + 8; ++i)
+		res[i] = str.c_str()[i - l];
+	res[l + 8] = 0;
+	setText(res);
+	delete[] res;
 }
 
-void Text::append( const char *t, int l ) // hängt an den Text an
+void Text::appendHex(__int64 num) // hängt die zahl in hex anden Text an
 {
-    int txl = getLength(); // länge des Textes
-    char *res = new char[ (__int64)l + txl + 1 ]; // neuen Text erstellen
-    for( int i = 0; i < txl; ++i ) // mit jetzigem Text füllen
-        res[ i ] = txt[ i ];
-    for( int i = 0; i < l; ++i ) // Übergabe anhängen
-        res[ txl + i ] = t[ i ];
-    res[ txl + l ] = '\0'; // Textende festlegen
-    setText( res, txl + l ); // Test setzen
-    delete[] res; // Speicher freigeben
+	int l = getLength();
+	char* res = new char[(__int64)l + 17];
+	for (int i = 0; i < l; ++i)
+		res[i] = txt[i];
+	std::stringstream stream;
+	stream << std::setfill('0') << std::setw((int)sizeof(__int64) * 2) << std::hex << num;
+	std::string str = stream.str();
+	for (int i = l; i < l + 16; ++i)
+		res[i] = str.c_str()[i - l];
+	res[l + 16] = 0;
+	setText(res);
+	delete[] res;
 }
 
-void Text::append( Text *t )
+void Text::append(const char* t, int l) // hängt an den Text an
 {
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        append( t->getText() ); // Text anhängen
-    t->release(); // Übergabe loslassen
+	int txl = getLength(); // länge des Textes
+	char* res = new char[(__int64)l + txl + 1]; // neuen Text erstellen
+	for (int i = 0; i < txl; ++i) // mit jetzigem Text füllen
+		res[i] = txt[i];
+	for (int i = 0; i < l; ++i) // Übergabe anhängen
+		res[txl + i] = t[i];
+	res[txl + l] = '\0'; // Textende festlegen
+	setText(res, txl + l); // Test setzen
+	delete[] res; // Speicher freigeben
 }
 
-void Text::append( int num )
+void Text::append(Text* t)
 {
-    std::stringstream ss;
-    ss << num;
-    append( ss.str().c_str() );
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		append(t->getText()); // Text anhängen
+	t->release(); // Übergabe loslassen
+}
+
+void Text::append(int num)
+{
+	std::stringstream ss;
+	ss << num;
+	append(ss.str().c_str());
 }
 
 // Hängt eine Zahl ans Ende Des Textes an
 //  num: Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
-void Text::append( __int64 num )
+void Text::append(__int64 num)
 {
-    std::stringstream ss;
-    ss << num;
-    append( ss.str().c_str() );
+	std::stringstream ss;
+	ss << num;
+	append(ss.str().c_str());
 }
 
-void Text::append( unsigned int num )
+void Text::append(unsigned int num)
 {
-    std::stringstream ss;
-    ss << num;
-    append( ss.str().c_str() );
+	std::stringstream ss;
+	ss << num;
+	append(ss.str().c_str());
 }
 
-void Text::append( double num )
+void Text::append(double num)
 {
-    std::stringstream ss;
-    ss.precision( precision );
-    ss << std::fixed << num;
-    append( ss.str().c_str() );
+	std::stringstream ss;
+	ss.precision(precision);
+	ss << std::fixed << num;
+	append(ss.str().c_str());
 }
 
-void Text::append( float num )
+void Text::append(float num)
 {
-    std::stringstream ss;
-    ss.precision( precision );
-    ss << std::fixed << num;
-    append( ss.str().c_str() );
-}
-
-void Text::insert( int p, char c ) // Fügt an stelle p ein
-{
-    if( p > getLength() || p < 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    int txl = getLength(); // Länge des Textes
-    char *res = new char[ (__int64)txl + 2 ]; // neuer Text erstellen
-    for( int i = 0; i < p; ++i ) // Text füllen
-        res[ i ] = txt[ i ];
-    res[ p ] = c;
-    for( int i = p; i < txl; ++i ) // Text füllen
-        res[ i + 1 ] = txt[ i ];
-    res[ txl + 1 ] = '\0'; // Text ende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::insert( int p, const char *t ) // Fügt an stelle p ein
-{
-    if( p > getLength() || p < 0 || textLength( t ) <= 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    int tl = (int)textLength( t ); // Länge der übergabe
-    int txl = getLength(); // Länge des Textes
-    char *res = new char[ (__int64)tl + txl + 1 ]; // neuer Text erstellen
-    for( int i = 0; i < p; ++i ) // Text füllen
-        res[ i ] = txt[ i ];
-    for( int i = 0; i < tl; ++i ) // Text einfügen
-        res[ i + p ] = t[ i ];
-    for( int i = p; i < txl; ++i ) // Text füllen
-        res[ i + tl ] = txt[ i ];
-    res[ tl + txl ] = '\0'; // Text ende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::insert( int p, Text *t )
-{
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        insert( p, t->getText() ); // Text einfügen
-    t->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( int p1, int p2, const char *t ) // Ersetzt den Text von p1 bis p2
-{
-    if( p1 > p2 )
-    {
-        int x = p1; // p1 und p2 tauschen
-        p1 = p2;
-        p2 = x;
-    }
-    remove( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
-    insert( p1, t ); // Übergabe bei p1 einfügen
-}
-
-void Text::ersetzen( int p1, int p2, Text *t )
-{
-    if( t->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( p1, p2, t->getText() ); // Text ersetzen
-    t->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( char c1, char c2 ) // ersetzt jedes c1 durch c2
-{
-    if( c1 == '\0' || c2 == '\0' ) // Auf unsinnige übergabe prüfen
-        return;
-    if( !hat( c1 ) ) // prüfen ob c1 vorhanden
-        return;
-    int l = getLength(); // Text Länge
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // Text durchsuchen
-    {
-        bool b = suchGCount != 0;
-        if( txt[ i ] == c1 && !suchGCount )
-            txt[ i ] = c2; // Text ersetzen
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( txt[ i ] == c1 && !suchGCount && b )
-            txt[ i ] = c2; // Text ersetzen
-    }
-}
-
-void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
-{
-    int txl = getLength(); // Text Länge
-    int t1l = (int)textLength( t1 ); // Länge der Übergaben
-    int t2l = (int)textLength( t2 );
-    if( t1l > txl || t1l <= 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    if( !hat( t1 ) ) // prüfen ob t1 vorhanden
-        return;
-    int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
-    int *begin = new int[ anz ];
-    int *end = new int[ anz ];
-    for( int i = 0; i < anz; ++i ) // Positionen von t1 speichern
-    {
-        begin[ i ] = positionVon( t1, i );
-        end[ i ] = begin[ i ] + t1l;
-    }
-    int resl = ( txl - ( anz * t1l ) ) + ( anz * t2l ) + 1; // Länge des Ergebneses
-    char *res = new char[ resl ]; // neuer Text erstellen
-    int rep = 0; // Speichert bei welchen t1 man sich befindet
-    int last = 0; // Füllposition von txt
-    int neu = 0; // Füllporition von res
-    for( ; neu < resl; ++neu ) // Text befüllen
-    {
-        if( rep < anz && last == begin[ rep ] ) // Text ersetzen
-        {
-            last = end[ rep ];
-            ++rep;
-            for( int ii = 0; ii < t2l; ++ii )
-            {
-                if( neu >= resl )
-                    break;
-                res[ neu ] = t2[ ii ];
-                ++neu;
-            }
-            if( neu >= resl )
-                break;
-            --neu;
-        }
-        else // Text Kopieren
-        {
-            res[ neu ] = txt[ last ];
-            ++last;
-        }
-    }
-    res[ resl - 1 ] = '\0'; // Textende festlegen
-    setText( res ); // Text setzen
-    delete[]begin; // Speicher freigeben
-    delete[]end;
-    delete[] res;
-}
-
-void Text::ersetzen( Text *t1, const char *t2 )
-{
-    if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( t1->getText(), t2 ); // ersetzen
-    t1->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( const char *t1, Text *t2 )
-{
-    if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( t1, t2->getText() ); // ersetzen
-    t2->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( Text *t1, Text *t2 )
-{
-    if( t1->getLength() > 0 && t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( t1->getText(), t2->getText() ); // ersetzen
-    t1->release(); // Übergaben loslassen
-    t2->release();
-}
-
-void Text::ersetzen( int index, char c1, char c2 ) // ersetzt das i-te c1 durch c2
-{
-    if( c1 == '\0' || c2 == '\0' || index < 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    if( !hat( c1 ) ) // prüfen ob c1 vorhanden
-        return;
-    int anz = anzahlVon( c1 );
-    if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
-        return;
-    txt[ positionVon( c1, index ) ] = c2;
-}
-
-void Text::ersetzen( int index, const char *t1, const char *t2 ) // ersetzt das i-te t1 durch t2
-{
-    int txl = getLength(); // Text Länge
-    int t1l = (int)textLength( t1 ); // Länge der Übergaben
-    if( t1l >= txl || t1l <= 0 || index < 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    if( !hat( t1 ) ) // prüfen ob t1 vorhanden
-        return;
-    int anz = anzahlVon( t1 ); // Anzahl von t1 im Text
-    if( index >= anz ) // prüfen ob es ein i-tes t1 gibt
-        return;
-    int begin = positionVon( t1, index );
-    int end = begin + t1l;
-    ersetzen( begin, end, t2 ); // ersetzen
-}
-
-void Text::ersetzen( int i, Text *t1, const char *t2 )
-{
-    if( t1->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( i, t1->getText(), t2 ); // ersetzen
-    t1->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( int i, const char *t1, Text *t2 )
-{
-    if( t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( i, t1, t2->getText() ); // ersetzen
-    t2->release(); // Übergabe loslassen
-}
-
-void Text::ersetzen( int i, Text *t1, Text *t2 )
-{
-    if( t1->getLength() > 0 || t2->getLength() >= 0 ) // Auf unsinnige übergabe prüfen
-        ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
-    t1->release(); // Übergaben loslassen
-    t2->release();
-}
-
-void Text::fillText( char c, int len ) // setzt den Text zu so vielen c wie län groß ist
-{
-    char *res = new char[ (__int64)len + 1 ];
-    for( int i = 0; i < len; ++i )
-        res[ i ] = c;
-    res[ len ] = '\0';
-    setText( res );
-    delete[] res;
-}
-
-void Text::remove( int p ) // löscht p
-{
-    int l = getLength(); // Text Länge
-    if( p < 0 || p >= l ) // Auf unsinnige übergabe prüfen
-        return;
-    char *res = new char[ l ]; // neuen Text anlegen
-    for( int i = 0; i < p && i < l; ++i ) // Text befüllen
-        res[ i ] = txt[ i ];
-    for( int i = p + 1; i < l; ++i )
-        res[ i - 1 ] = txt[ i ];
-    res[ l - 1 ] = 0;
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
-{
-    if( p1 == p2 )
-        return;
-    if( p1 > p2 ) // p1 und p2 tauschen
-    {
-        int x = p1;
-        p1 = p2;
-        p2 = x;
-    }
-    int l = getLength(); // Länge des Testes
-    if( p1 < 0 ) // Auf unsinnige übergabe prüfen
-        p1 = 0;
-    if( p2 > l )
-        p2 = l;
-    int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
-    char *res = new char[ (__int64)resl + 1 ]; // Neuen Text erstellen
-    for( int i = 0; i < p1; ++i ) // Text füllen
-        res[ i ] = txt[ i ];
-    for( int i = p2; i < l; ++i )
-        res[ i - ( p2 - p1 ) ] = txt[ i ];
-    res[ resl ] = '\0'; // Testende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( char c ) // löscht jetes c
-{
-    if( !hat( c ) ) // prüfen ob c vorhanden
-        return;
-    int l = getLength(); // Länge des Textes
-    int anz = anzahlVon( c ); // Anzahl von c
-    char *res = new char[ (__int64)l - anz + 1 ]; // neuen Text erstellen
-    int anz2 = 0;
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // Text befüllen
-    {
-        bool b = suchGCount != 0;
-        if( txt[ i ] == c && !suchGCount )
-            ++anz2;
-        else
-            res[ i - anz2 ] = txt[ i ];
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( b )
-        {
-            if( txt[ i ] == c && !suchGCount )
-                ++anz2;
-            else
-                res[ i - anz2 ] = txt[ i ];
-        }
-    }
-    res[ l - anz ] = '\0'; // Textende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( const char *t ) // löscht jetes t
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return;
-    if( !hat( t ) ) // prüfen ob Text ein t enthält
-        return;
-    int anz = anzahlVon( t ); // anzahl von t
-    int *begin = new int[ anz ];
-    for( int i = 0; i < anz; ++i ) // begin aller t-s finden
-        begin[ i ] = positionVon( t, i );
-    int resl = txl - ( anz * tl ); // Länge vom Ergebnes
-    char *res = new char[ (__int64)resl + 1 ]; // neuen Text erzeugen
-    int del = 0;
-    for( int i = 0; i < txl; ++i ) // Text befüllen
-    {
-        if( del < anz && i == begin[ del ] ) // Text auslassen
-        {
-            i += tl - 1;
-            ++del;
-        }
-        else
-            res[ i - ( del * tl ) ] = txt[ i ]; // Text befüllen
-    }
-    res[ resl ] = '\0'; // Text ende festlegen
-    setText( res ); // Text setzen
-    delete[]begin;
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( Text *t )
-{
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        remove( t->getText() ); // löschen
-    t->release(); // Übergabe loslassen
-}
-
-void Text::remove( int index, char c )
-{
-    if( index < 0 || !hat( c ) ) // Auf unsinnige übergabe prüfen
-        return;
-    int anz = anzahlVon( c ); // anzahl der i-s
-    if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
-        return;
-    int pos = positionVon( c, index ); // Position vom i-ten c
-    if( pos < 0 )
-        return;
-    int l = getLength(); // Länge des Textes
-    if( !l )
-        return;
-    char *res = new char[ l ]; // neuen Text erzeugen
-    for( int i = 0; i < pos && i < l; ++i ) // Text befüllen
-        res[ i ] = txt[ i ];
-    for( int i = pos + 1; i < l; ++i )
-        res[ i - 1 ] = txt[ i ];
-    res[ l - 1 ] = '\0'; // Text ende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( int index, const char *t ) // löscht das i-te t
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    if( index < 0 || !hat( t ) || tl <= 0 ) // Auf unsinnige übergabe prüfen
-        return;
-    int anz = anzahlVon( t ); // anzahl der i-s
-    if( index >= anz ) // prüfen ob ein i-tes c vorhanden ist
-        return;
-    int pos = positionVon( t, index ); // Position vom i-ten c
-    if( pos < 0 )
-        return;
-    int l = getLength(); // Länge des Textes
-    if( !l )
-        return;
-    char *res = new char[ (__int64)l - tl + 1 ]; // neuen Text erzeugen
-    for( int i = 0; i < pos && i < l - tl + 1; ++i ) // Text befüllen
-        res[ i ] = txt[ i ];
-    for( int i = pos + tl; i < l; ++i )
-        res[ i - tl ] = txt[ i ];
-    res[ l - tl ] = '\0'; // Text ende festlegen
-    setText( res ); // Text setzen
-    delete[] res; // Speicher freigeben
-}
-
-void Text::remove( int i, Text *t )
-{
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        remove( i, t->getText() ); // löschen
-    t->release(); // Übergabe loslassen
+	std::stringstream ss;
+	ss.precision(precision);
+	ss << std::fixed << num;
+	append(ss.str().c_str());
+}
+
+void Text::insert(int p, char c) // Fügt an stelle p ein
+{
+	if (p > getLength() || p < 0) // Auf unsinnige übergabe prüfen
+		return;
+	int txl = getLength(); // Länge des Textes
+	char* res = new char[(__int64)txl + 2]; // neuer Text erstellen
+	for (int i = 0; i < p; ++i) // Text füllen
+		res[i] = txt[i];
+	res[p] = c;
+	for (int i = p; i < txl; ++i) // Text füllen
+		res[i + 1] = txt[i];
+	res[txl + 1] = '\0'; // Text ende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::insert(int p, const char* t) // Fügt an stelle p ein
+{
+	if (p > getLength() || p < 0 || textLength(t) <= 0) // Auf unsinnige übergabe prüfen
+		return;
+	int tl = (int)textLength(t); // Länge der übergabe
+	int txl = getLength(); // Länge des Textes
+	char* res = new char[(__int64)tl + txl + 1]; // neuer Text erstellen
+	for (int i = 0; i < p; ++i) // Text füllen
+		res[i] = txt[i];
+	for (int i = 0; i < tl; ++i) // Text einfügen
+		res[i + p] = t[i];
+	for (int i = p; i < txl; ++i) // Text füllen
+		res[i + tl] = txt[i];
+	res[tl + txl] = '\0'; // Text ende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::insert(int p, Text* t)
+{
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		insert(p, t->getText()); // Text einfügen
+	t->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(int p1, int p2, const char* t) // Ersetzt den Text von p1 bis p2
+{
+	if (p1 > p2)
+	{
+		int x = p1; // p1 und p2 tauschen
+		p1 = p2;
+		p2 = x;
+	}
+	remove(p1, p2); // Textabschnitt von p1 zu p2 löschen
+	insert(p1, t); // Übergabe bei p1 einfügen
+}
+
+void Text::ersetzen(int p1, int p2, Text* t)
+{
+	if (t->getLength() >= 0) // Auf unsinnige übergabe prüfen
+		ersetzen(p1, p2, t->getText()); // Text ersetzen
+	t->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(char c1, char c2) // ersetzt jedes c1 durch c2
+{
+	if (c1 == '\0' || c2 == '\0') // Auf unsinnige übergabe prüfen
+		return;
+	if (!hat(c1)) // prüfen ob c1 vorhanden
+		return;
+	int l = getLength(); // Text Länge
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // Text durchsuchen
+	{
+		bool b = suchGCount != 0;
+		if (txt[i] == c1 && !suchGCount)
+			txt[i] = c2; // Text ersetzen
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (txt[i] == c1 && !suchGCount && b)
+			txt[i] = c2; // Text ersetzen
+	}
+}
+
+void Text::ersetzen(const char* t1, const char* t2) // ersetzt jedes t1 durch t2
+{
+	int txl = getLength(); // Text Länge
+	int t1l = (int)textLength(t1); // Länge der Übergaben
+	int t2l = (int)textLength(t2);
+	if (t1l > txl || t1l <= 0) // Auf unsinnige übergabe prüfen
+		return;
+	if (!hat(t1)) // prüfen ob t1 vorhanden
+		return;
+	int anz = anzahlVon(t1); // Anzahl von t1 im Text
+	int* begin = new int[anz];
+	int* end = new int[anz];
+	for (int i = 0; i < anz; ++i) // Positionen von t1 speichern
+	{
+		begin[i] = positionVon(t1, i);
+		end[i] = begin[i] + t1l;
+	}
+	int resl = (txl - (anz * t1l)) + (anz * t2l) + 1; // Länge des Ergebneses
+	char* res = new char[resl]; // neuer Text erstellen
+	int rep = 0; // Speichert bei welchen t1 man sich befindet
+	int last = 0; // Füllposition von txt
+	int neu = 0; // Füllporition von res
+	for (; neu < resl; ++neu) // Text befüllen
+	{
+		if (rep < anz && last == begin[rep]) // Text ersetzen
+		{
+			last = end[rep];
+			++rep;
+			for (int ii = 0; ii < t2l; ++ii)
+			{
+				if (neu >= resl)
+					break;
+				res[neu] = t2[ii];
+				++neu;
+			}
+			if (neu >= resl)
+				break;
+			--neu;
+		}
+		else // Text Kopieren
+		{
+			res[neu] = txt[last];
+			++last;
+		}
+	}
+	res[resl - 1] = '\0'; // Textende festlegen
+	setText(res); // Text setzen
+	delete[]begin; // Speicher freigeben
+	delete[]end;
+	delete[] res;
+}
+
+void Text::ersetzen(Text* t1, const char* t2)
+{
+	if (t1->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ersetzen(t1->getText(), t2); // ersetzen
+	t1->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(const char* t1, Text* t2)
+{
+	if (t2->getLength() >= 0) // Auf unsinnige übergabe prüfen
+		ersetzen(t1, t2->getText()); // ersetzen
+	t2->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(Text* t1, Text* t2)
+{
+	if (t1->getLength() > 0 && t2->getLength() >= 0) // Auf unsinnige übergabe prüfen
+		ersetzen(t1->getText(), t2->getText()); // ersetzen
+	t1->release(); // Übergaben loslassen
+	t2->release();
+}
+
+void Text::ersetzen(int index, char c1, char c2) // ersetzt das i-te c1 durch c2
+{
+	if (c1 == '\0' || c2 == '\0' || index < 0) // Auf unsinnige übergabe prüfen
+		return;
+	if (!hat(c1)) // prüfen ob c1 vorhanden
+		return;
+	int anz = anzahlVon(c1);
+	if (index >= anz) // prüfen ob es ein i-tes c1 gibt
+		return;
+	txt[positionVon(c1, index)] = c2;
+}
+
+void Text::ersetzen(int index, const char* t1, const char* t2) // ersetzt das i-te t1 durch t2
+{
+	int txl = getLength(); // Text Länge
+	int t1l = (int)textLength(t1); // Länge der Übergaben
+	if (t1l >= txl || t1l <= 0 || index < 0) // Auf unsinnige übergabe prüfen
+		return;
+	if (!hat(t1)) // prüfen ob t1 vorhanden
+		return;
+	int anz = anzahlVon(t1); // Anzahl von t1 im Text
+	if (index >= anz) // prüfen ob es ein i-tes t1 gibt
+		return;
+	int begin = positionVon(t1, index);
+	int end = begin + t1l;
+	ersetzen(begin, end, t2); // ersetzen
+}
+
+void Text::ersetzen(int i, Text* t1, const char* t2)
+{
+	if (t1->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ersetzen(i, t1->getText(), t2); // ersetzen
+	t1->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(int i, const char* t1, Text* t2)
+{
+	if (t2->getLength() >= 0) // Auf unsinnige übergabe prüfen
+		ersetzen(i, t1, t2->getText()); // ersetzen
+	t2->release(); // Übergabe loslassen
+}
+
+void Text::ersetzen(int i, Text* t1, Text* t2)
+{
+	if (t1->getLength() > 0 || t2->getLength() >= 0) // Auf unsinnige übergabe prüfen
+		ersetzen(i, t1->getText(), t2->getText()); // ersetzen
+	t1->release(); // Übergaben loslassen
+	t2->release();
+}
+
+void Text::fillText(char c, int len) // setzt den Text zu so vielen c wie län groß ist
+{
+	char* res = new char[(__int64)len + 1];
+	for (int i = 0; i < len; ++i)
+		res[i] = c;
+	res[len] = '\0';
+	setText(res);
+	delete[] res;
+}
+
+void Text::remove(int p) // löscht p
+{
+	int l = getLength(); // Text Länge
+	if (p < 0 || p >= l) // Auf unsinnige übergabe prüfen
+		return;
+	char* res = new char[l]; // neuen Text anlegen
+	for (int i = 0; i < p && i < l; ++i) // Text befüllen
+		res[i] = txt[i];
+	for (int i = p + 1; i < l; ++i)
+		res[i - 1] = txt[i];
+	res[l - 1] = 0;
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(int p1, int p2) // löscht von p1 zu p2 ( p2 bleibt )
+{
+	if (p1 == p2)
+		return;
+	if (p1 > p2) // p1 und p2 tauschen
+	{
+		int x = p1;
+		p1 = p2;
+		p2 = x;
+	}
+	int l = getLength(); // Länge des Testes
+	if (p1 < 0) // Auf unsinnige übergabe prüfen
+		p1 = 0;
+	if (p2 > l)
+		p2 = l;
+	int resl = l - (p2 - p1); // Länge vom Ergebnis
+	char* res = new char[(__int64)resl + 1]; // Neuen Text erstellen
+	for (int i = 0; i < p1; ++i) // Text füllen
+		res[i] = txt[i];
+	for (int i = p2; i < l; ++i)
+		res[i - (p2 - p1)] = txt[i];
+	res[resl] = '\0'; // Testende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(char c) // löscht jetes c
+{
+	if (!hat(c)) // prüfen ob c vorhanden
+		return;
+	int l = getLength(); // Länge des Textes
+	int anz = anzahlVon(c); // Anzahl von c
+	char* res = new char[(__int64)l - anz + 1]; // neuen Text erstellen
+	int anz2 = 0;
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // Text befüllen
+	{
+		bool b = suchGCount != 0;
+		if (txt[i] == c && !suchGCount)
+			++anz2;
+		else
+			res[i - anz2] = txt[i];
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (b)
+		{
+			if (txt[i] == c && !suchGCount)
+				++anz2;
+			else
+				res[i - anz2] = txt[i];
+		}
+	}
+	res[l - anz] = '\0'; // Textende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(const char* t) // löscht jetes t
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return;
+	if (!hat(t)) // prüfen ob Text ein t enthält
+		return;
+	int anz = anzahlVon(t); // anzahl von t
+	int* begin = new int[anz];
+	for (int i = 0; i < anz; ++i) // begin aller t-s finden
+		begin[i] = positionVon(t, i);
+	int resl = txl - (anz * tl); // Länge vom Ergebnes
+	char* res = new char[(__int64)resl + 1]; // neuen Text erzeugen
+	int del = 0;
+	for (int i = 0; i < txl; ++i) // Text befüllen
+	{
+		if (del < anz && i == begin[del]) // Text auslassen
+		{
+			i += tl - 1;
+			++del;
+		}
+		else
+			res[i - (del * tl)] = txt[i]; // Text befüllen
+	}
+	res[resl] = '\0'; // Text ende festlegen
+	setText(res); // Text setzen
+	delete[]begin;
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(Text* t)
+{
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		remove(t->getText()); // löschen
+	t->release(); // Übergabe loslassen
+}
+
+void Text::remove(int index, char c)
+{
+	if (index < 0 || !hat(c)) // Auf unsinnige übergabe prüfen
+		return;
+	int anz = anzahlVon(c); // anzahl der i-s
+	if (index >= anz) // prüfen ob ein i-tes c vorhanden ist
+		return;
+	int pos = positionVon(c, index); // Position vom i-ten c
+	if (pos < 0)
+		return;
+	int l = getLength(); // Länge des Textes
+	if (!l)
+		return;
+	char* res = new char[l]; // neuen Text erzeugen
+	for (int i = 0; i < pos && i < l; ++i) // Text befüllen
+		res[i] = txt[i];
+	for (int i = pos + 1; i < l; ++i)
+		res[i - 1] = txt[i];
+	res[l - 1] = '\0'; // Text ende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(int index, const char* t) // löscht das i-te t
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	if (index < 0 || !hat(t) || tl <= 0) // Auf unsinnige übergabe prüfen
+		return;
+	int anz = anzahlVon(t); // anzahl der i-s
+	if (index >= anz) // prüfen ob ein i-tes c vorhanden ist
+		return;
+	int pos = positionVon(t, index); // Position vom i-ten c
+	if (pos < 0)
+		return;
+	int l = getLength(); // Länge des Textes
+	if (!l)
+		return;
+	char* res = new char[(__int64)l - tl + 1]; // neuen Text erzeugen
+	for (int i = 0; i < pos && i < l - tl + 1; ++i) // Text befüllen
+		res[i] = txt[i];
+	for (int i = pos + tl; i < l; ++i)
+		res[i - tl] = txt[i];
+	res[l - tl] = '\0'; // Text ende festlegen
+	setText(res); // Text setzen
+	delete[] res; // Speicher freigeben
+}
+
+void Text::remove(int i, Text* t)
+{
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		remove(i, t->getText()); // löschen
+	t->release(); // Übergabe loslassen
 }
 
 // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
 //  pos: Die Position des ersten zeichens
-void Text::removeWhitespaceAfter( int pos )
+void Text::removeWhitespaceAfter(int pos)
 {
-    int length = 0;
-    int len = textLength( txt );
-    for( int i = pos; i < len; i++ )
-    {
-        if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
-            length++;
-        else
-            break;
-    }
-    remove( pos, pos + length );
+	int length = 0;
+	int len = textLength(txt);
+	for (int i = pos; i < len; i++)
+	{
+		if (txt[i] == ' ' || txt[i] == '\n' || txt[i] == '\r' || txt[i] == '\t')
+			length++;
+		else
+			break;
+	}
+	remove(pos, pos + length);
 }
 
 // Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
 //  pos: Die Position des ersten zeichens (beginnt bei pos-1)
-void Text::removeWhitespaceBefore( int pos )
+void Text::removeWhitespaceBefore(int pos)
 {
-    int length = 0;
-    for( int i = pos - 1; i >= 0; i-- )
-    {
-        if( txt[ i ] == ' ' || txt[ i ] == '\n' || txt[ i ] == '\r' || txt[ i ] == '\t' )
-            length++;
-        else
-            break;
-    }
-    remove( pos - length, pos );
+	int length = 0;
+	for (int i = pos - 1; i >= 0; i--)
+	{
+		if (txt[i] == ' ' || txt[i] == '\n' || txt[i] == '\r' || txt[i] == '\t')
+			length++;
+		else
+			break;
+	}
+	remove(pos - length, pos);
 }
 
-void Text::setPrecision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
+void Text::setPrecision(int p) // setzt die Anzahl der Nachkommastellen bei doubles
 {
-    precision = p;
+	precision = p;
 }
 
 // constant 
 int Text::getLength() const // gibt die Text länge zurück
 {
-    if( !txt )
-        return -1;
-    return textLength( txt );
-}
-
-int Text::getLKick( int pos ) const
-{
-    if( txt[ pos - 1 ] == ' ' )
-    {
-        int ret = 1;
-        for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
-        return pos - ret;
-    }
-    else
-    {
-        int ret = 1;
-        for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos - ret - 1 ] != '\n'; ++ret );
-        return pos - ret;
-    }
-}
-
-int Text::getOKick( int pos ) const
-{
-    if( !hat( '\n' ) )
-        return 0;
-    int lpos = 0;
-    while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
-        ++lpos;
-    int vllen = 1;
-    while( pos - lpos - vllen - 1 >= 0 && txt[ pos - lpos - vllen - 1 ] != '\n' )
-        ++vllen;
-    if( vllen > lpos )
-        return pos - vllen;
-    else
-        return pos - lpos - 1;
-}
-
-int Text::getRKick( int pos ) const
-{
-    int tl = getLength();
-    if( txt[ pos ] == ' ' )
-    {
-        int ret = 1;
-        for( ; ret + pos < tl && txt[ pos + ret ] == ' ' && txt[ pos + ret ] != '\n'; ++ret );
-        return pos + ret;
-    }
-    else
-    {
-        int ret = 1;
-        for( ; ret + pos < tl && txt[ pos + ret ] != ' ' && txt[ pos + ret ] != '\n'; ++ret );
-        return pos + ret;
-    }
-}
-
-int Text::getUKick( int pos ) const
-{
-    if( !hat( '\n' ) )
-        return getLength();
-    int lpos = 0;
-    while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
-        ++lpos;
-    int llen = 1;
-    while( pos + llen - 1 < getLength() && txt[ pos + llen - 1 ] != '\n' )
-        ++llen;
-    int vllen = 1;
-    while( pos + llen + vllen - 1 < getLength() && txt[ pos + llen + vllen - 1 ] != '\n' )
-        ++vllen;
-    if( vllen == 1 )
-        return pos + llen < getLength() ? pos + llen : getLength();
-    if( vllen < lpos )
-        return pos + llen + vllen - 1;
-    return pos + llen + lpos;
-}
-
-bool Text::hat( Text *t ) const // enthält der Text t
-{
-    bool ret = 0;
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ret = hat( t->getText() ); // prüfen
-    t->release(); // Übergabe loslassen
-    return ret;
-}
-
-bool Text::hat( const char *t ) const
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return 0;
-    int suchGCount = 0;
-    for( int i = 0; i + tl <= txl; ++i ) // Text durchsuchen
-    {
-        if( !suchGCount )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                return 1;
-        }
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( !suchGCount )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // Text überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                return 1;
-        }
-    }
-    return 0;
+	if (!txt)
+		return -1;
+	return textLength(txt);
+}
+
+int Text::getLKick(int pos) const
+{
+	if (txt[pos - 1] == ' ')
+	{
+		int ret = 1;
+		for (; ret < pos && txt[pos - ret - 1] == ' ' && txt[pos - ret - 1] != '\n'; ++ret);
+		return pos - ret;
+	}
+	else
+	{
+		int ret = 1;
+		for (; ret < pos && txt[pos - ret - 1] != ' ' && txt[pos - ret - 1] != '\n'; ++ret);
+		return pos - ret;
+	}
+}
+
+int Text::getOKick(int pos) const
+{
+	if (!hat('\n'))
+		return 0;
+	int lpos = 0;
+	while (pos - lpos - 1 > 0 && txt[pos - lpos - 1] != '\n')
+		++lpos;
+	int vllen = 1;
+	while (pos - lpos - vllen - 1 >= 0 && txt[pos - lpos - vllen - 1] != '\n')
+		++vllen;
+	if (vllen > lpos)
+		return pos - vllen;
+	else
+		return pos - lpos - 1;
+}
+
+int Text::getRKick(int pos) const
+{
+	int tl = getLength();
+	if (txt[pos] == ' ')
+	{
+		int ret = 1;
+		for (; ret + pos < tl && txt[pos + ret] == ' ' && txt[pos + ret] != '\n'; ++ret);
+		return pos + ret;
+	}
+	else
+	{
+		int ret = 1;
+		for (; ret + pos < tl && txt[pos + ret] != ' ' && txt[pos + ret] != '\n'; ++ret);
+		return pos + ret;
+	}
+}
+
+int Text::getUKick(int pos) const
+{
+	if (!hat('\n'))
+		return getLength();
+	int lpos = 0;
+	while (pos - lpos > 0 && txt[pos - lpos - 1] != '\n')
+		++lpos;
+	int llen = 1;
+	while (pos + llen - 1 < getLength() && txt[pos + llen - 1] != '\n')
+		++llen;
+	int vllen = 1;
+	while (pos + llen + vllen - 1 < getLength() && txt[pos + llen + vllen - 1] != '\n')
+		++vllen;
+	if (vllen == 1)
+		return pos + llen < getLength() ? pos + llen : getLength();
+	if (vllen < lpos)
+		return pos + llen + vllen - 1;
+	return pos + llen + lpos;
+}
+
+bool Text::hat(Text* t) const // enthält der Text t
+{
+	bool ret = 0;
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ret = hat(t->getText()); // prüfen
+	t->release(); // Übergabe loslassen
+	return ret;
+}
+
+bool Text::hat(const char* t) const
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return 0;
+	int suchGCount = 0;
+	for (int i = 0; i + tl <= txl; ++i) // Text durchsuchen
+	{
+		if (!suchGCount)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // Text überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				return 1;
+		}
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (!suchGCount)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // Text überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				return 1;
+		}
+	}
+	return 0;
 }
 
 // Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
 //  t: Der Text, nach dessen Inhalt gesucht werden soll
 //  return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
 //  pos: die position an der die zeichenkette im string beginnen soll
-bool Text::hatAt( int pos, Text *t ) const
+bool Text::hatAt(int pos, Text* t) const
 {
-    bool ret = 0;
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ret = hatAt( pos, t->getText() ); // prüfen
-    t->release(); // Übergabe loslassen
-    return ret;
+	bool ret = 0;
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ret = hatAt(pos, t->getText()); // prüfen
+	t->release(); // Übergabe loslassen
+	return ret;
 }
 
 // Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
 //  t: Die Zeichenkette, nach der gesucht werden soll
 //  return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
 //  pos: die position an der die zeichenkette im string beginnen soll
-bool Text::hatAt( int pos, const char *t ) const
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl + pos > txl ) // Auf unsinnige übergabe prüfen
-        return 0;
-    bool b = 1;
-    for( int i = 0; i < tl; ++i ) // Text überprüfen
-        b &= txt[ pos + i ] == t[ i ];
-    return b;
-}
-
-bool Text::hat( char c ) const // enthält c
-{
-    int l = getLength(); // Text Länge
-    bool ret = 0;
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( !suchGCount ) // überprüfen
-            ret |= txt[ i ] == c;
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( !suchGCount && b ) // überprüfen
-            ret |= txt[ i ] == c;
-    }
-    return ret;
-}
-
-bool Text::istGleich( const char *t ) const // prüft ob det Text gleich t ist
-{
-    int txl = getLength(); // Text Länge
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    if( txl != tl ) // Auf unsinniege Übergabe prüfen
-        return 0;
-    if( txl == -1 )
-        return 1;
-    bool ret = true;
-    for( int i = 0; i < tl; ++i ) // prüfen
-        ret &= txt[ i ] == t[ i ];
-    return ret;
-}
-
-bool Text::istGleich( Text *t ) const
-{
-    bool ret = istGleich( t->getText() ); // prüfen
-    t->release(); // Übergabe loslassen
-    return ret;
-}
-
-char *Text::getText() const // gibt Text zurück
-{
-    return txt;
-}
-
-int Text::anzahlVon( char c ) const // gibt die Anzahl von c im Text zurück
-{
-    int ret = 0;
-    int l = getLength(); // Text Länge
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        ret += txt[ i ] == c && !suchGCount; // zählen
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        ret += txt[ i ] == c && !suchGCount && b; // zählen
-    }
-    return ret;
-}
-
-int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return 0;
-    int ret = 0;
-    int suchGCount = 0;
-    for( int i = 0; i + tl <= txl; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( !suchGCount )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                ++ret; // zählen
-        }
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( !suchGCount && b )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                ++ret; // zählen
-        }
-    }
-    return ret;
-}
-
-int Text::anzahlVon( Text *t ) const
-{
-    int ret = 0;
-    if( t->getLength() > 0 )  // Auf unsinnige übergabe prüfen
-        ret = anzahlVon( t->getText() ); // zählen
-    t->release(); // Übergabe loslassen
-    return ret;
-}
-
-int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
-{
-    int l = getLength(); // Text Länge
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( txt[ i ] == c && !suchGCount ) // überprüfen
-            return i;
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( txt[ i ] == c && !suchGCount && b ) // überprüfen
-            return i;
-    }
-    return -1;
-}
-
-int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return -1;
-    int suchGCount = 0;
-    for( int i = 0; i + tl <= txl; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( !suchGCount )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                return i;
-        }
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( !suchGCount && b )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-                return i;
-        }
-    }
-    return -1;
-}
-
-int Text::positionVon( Text *t ) const
-{
-    int ret = 0;
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ret = positionVon( t->getText() ); // position ermitteln
-    t->release(); // Übergabe loslassen
-    return ret;
-}
-
-int Text::positionVon( char c, int index ) const // gibt die Position des i-ten c zurück
-{
-    int l = getLength(); // Text Länge
-    int ii = 0;
-    int suchGCount = 0;
-    for( int i = 0; i < l; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( txt[ i ] == c && !suchGCount ) // überprüfen
-        {
-            if( ii == index )
-                return i;
-            else
-                ++ii;
-        }
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( txt[ i ] == c && !suchGCount && b ) // überprüfen
-        {
-            if( ii == index )
-                return i;
-            else
-                ++ii;
-        }
-    }
-    return -1;
-}
-
-int Text::positionVon( const char *t, int index ) const // gibt die Position des i-ten t zurück
-{
-    int tl = (int)textLength( t ); // Länge der Übergabe
-    int txl = getLength(); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return 0;
-    int i2 = 0;
-    int suchGCount = 0;
-    for( int i = 0; i + tl <= txl; ++i ) // suchen
-    {
-        bool b = suchGCount != 0;
-        if( !suchGCount )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-            {
-                if( i2 == index )
-                    return i;
-                else
-                    ++i2;
-            }
-        }
-        if( txt[ i ] == suchGBeg )
-            ++suchGCount;
-        if( txt[ i ] == suchGEnd )
-            --suchGCount;
-        if( !suchGCount && b )
-        {
-            bool b = 1;
-            for( int ii = 0; ii < tl; ++ii ) // überprüfen
-                b &= txt[ i + ii ] == t[ ii ];
-            if( b )
-            {
-                if( i2 == index )
-                    return i;
-                else
-                    ++i2;
-            }
-        }
-    }
-    return -1;
-}
-
-int Text::positionVon( Text *t, int i ) const
-{
-    int ret = 0;
-    if( t->getLength() > 0 ) // Auf unsinnige übergabe prüfen
-        ret = positionVon( t->getText(), i ); // position ermitteln
-    t->release(); // Übergabe loslassen
-    return ret;
-}
-
-Text *Text::getTeilText( int p1, int p2 ) const // gibt den Text von p1 bis p2 zurück
-{
-    if( p1 > p2 ) // p1 und p2 tauschen
-    {
-        int x = p1;
-        p1 = p2;
-        p2 = x;
-    }
-    int l = getLength(); // Text Länge
-    if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
-        return new Text( "" );
-    char *cp = new char[ (__int64)p2 - p1 + 1 ]; // neuen Text erstellen
-    for( int i = p1; i < p2; ++i ) // Text befüllen
-    {
-        cp[ i - p1 ] = txt[ i ];
-    }
-    cp[ p2 - p1 ] = '\0';
-    Text *t = new Text( cp ); // Text zurückgeben
-    delete[]cp;
-    return t;
-}
-
-Text *Text::getTeilText( int p ) const // gibt den Text von p bis zum Ende zurück
-{
-    return getTeilText( p, getLength() ); // Text zurückgeben
+bool Text::hatAt(int pos, const char* t) const
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl + pos > txl) // Auf unsinnige übergabe prüfen
+		return 0;
+	bool b = 1;
+	for (int i = 0; i < tl; ++i) // Text überprüfen
+		b &= txt[pos + i] == t[i];
+	return b;
+}
+
+bool Text::hat(char c) const // enthält c
+{
+	int l = getLength(); // Text Länge
+	bool ret = 0;
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (!suchGCount) // überprüfen
+			ret |= txt[i] == c;
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (!suchGCount && b) // überprüfen
+			ret |= txt[i] == c;
+	}
+	return ret;
+}
+
+bool Text::istGleich(const char* t) const // prüft ob det Text gleich t ist
+{
+	int txl = getLength(); // Text Länge
+	int tl = (int)textLength(t); // Länge der Übergabe
+	if (txl != tl) // Auf unsinniege Übergabe prüfen
+		return 0;
+	if (txl == -1)
+		return 1;
+	bool ret = true;
+	for (int i = 0; i < tl; ++i) // prüfen
+		ret &= txt[i] == t[i];
+	return ret;
+}
+
+bool Text::istGleich(Text* t) const
+{
+	bool ret = istGleich(t->getText()); // prüfen
+	t->release(); // Übergabe loslassen
+	return ret;
+}
+
+char* Text::getText() const // gibt Text zurück
+{
+	return txt;
+}
+
+int Text::anzahlVon(char c) const // gibt die Anzahl von c im Text zurück
+{
+	int ret = 0;
+	int l = getLength(); // Text Länge
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		ret += txt[i] == c && !suchGCount; // zählen
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		ret += txt[i] == c && !suchGCount && b; // zählen
+	}
+	return ret;
+}
+
+int Text::anzahlVon(const char* t) const // gibt die Anzahl von t im Text zurück
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return 0;
+	int ret = 0;
+	int suchGCount = 0;
+	for (int i = 0; i + tl <= txl; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (!suchGCount)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				++ret; // zählen
+		}
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (!suchGCount && b)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				++ret; // zählen
+		}
+	}
+	return ret;
+}
+
+int Text::anzahlVon(Text* t) const
+{
+	int ret = 0;
+	if (t->getLength() > 0)  // Auf unsinnige übergabe prüfen
+		ret = anzahlVon(t->getText()); // zählen
+	t->release(); // Übergabe loslassen
+	return ret;
+}
+
+int Text::positionVon(char c) const // gibt die Position des ersten c zurück
+{
+	int l = getLength(); // Text Länge
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (txt[i] == c && !suchGCount) // überprüfen
+			return i;
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (txt[i] == c && !suchGCount && b) // überprüfen
+			return i;
+	}
+	return -1;
+}
+
+int Text::positionVon(const char* t) const // gibt die Position des ersten t zurück
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return -1;
+	int suchGCount = 0;
+	for (int i = 0; i + tl <= txl; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (!suchGCount)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				return i;
+		}
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (!suchGCount && b)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+				return i;
+		}
+	}
+	return -1;
+}
+
+int Text::positionVon(Text* t) const
+{
+	int ret = 0;
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ret = positionVon(t->getText()); // position ermitteln
+	t->release(); // Übergabe loslassen
+	return ret;
+}
+
+int Text::positionVon(char c, int index) const // gibt die Position des i-ten c zurück
+{
+	int l = getLength(); // Text Länge
+	int ii = 0;
+	int suchGCount = 0;
+	for (int i = 0; i < l; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (txt[i] == c && !suchGCount) // überprüfen
+		{
+			if (ii == index)
+				return i;
+			else
+				++ii;
+		}
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (txt[i] == c && !suchGCount && b) // überprüfen
+		{
+			if (ii == index)
+				return i;
+			else
+				++ii;
+		}
+	}
+	return -1;
+}
+
+int Text::positionVon(const char* t, int index) const // gibt die Position des i-ten t zurück
+{
+	int tl = (int)textLength(t); // Länge der Übergabe
+	int txl = getLength(); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return 0;
+	int i2 = 0;
+	int suchGCount = 0;
+	for (int i = 0; i + tl <= txl; ++i) // suchen
+	{
+		bool b = suchGCount != 0;
+		if (!suchGCount)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+			{
+				if (i2 == index)
+					return i;
+				else
+					++i2;
+			}
+		}
+		if (txt[i] == suchGBeg)
+			++suchGCount;
+		if (txt[i] == suchGEnd)
+			--suchGCount;
+		if (!suchGCount && b)
+		{
+			bool b = 1;
+			for (int ii = 0; ii < tl; ++ii) // überprüfen
+				b &= txt[i + ii] == t[ii];
+			if (b)
+			{
+				if (i2 == index)
+					return i;
+				else
+					++i2;
+			}
+		}
+	}
+	return -1;
+}
+
+int Text::positionVon(Text* t, int i) const
+{
+	int ret = 0;
+	if (t->getLength() > 0) // Auf unsinnige übergabe prüfen
+		ret = positionVon(t->getText(), i); // position ermitteln
+	t->release(); // Übergabe loslassen
+	return ret;
+}
+
+Text* Text::getTeilText(int p1, int p2) const // gibt den Text von p1 bis p2 zurück
+{
+	if (p1 > p2) // p1 und p2 tauschen
+	{
+		int x = p1;
+		p1 = p2;
+		p2 = x;
+	}
+	int l = getLength(); // Text Länge
+	if (p1 < 0 || p2 > l) // Auf unsinnige übergabe prüfen
+		return new Text("");
+	char* cp = new char[(__int64)p2 - p1 + 1]; // neuen Text erstellen
+	for (int i = p1; i < p2; ++i) // Text befüllen
+	{
+		cp[i - p1] = txt[i];
+	}
+	cp[p2 - p1] = '\0';
+	Text* t = new Text(cp); // Text zurückgeben
+	delete[]cp;
+	return t;
+}
+
+Text* Text::getTeilText(int p) const // gibt den Text von p bis zum Ende zurück
+{
+	return getTeilText(p, getLength()); // Text zurückgeben
 }
 
 // berechnet den Hash code des textes
 int Text::hashCode() const
 {
-    int result = 0;
-    int len = getLength();
-    for( int i = 0; i < len; i++ )
-        result += (int)pow( txt[ i ] * 31, len - 1 - i );
-    return result;
+	int result = 0;
+	int len = getLength();
+	for (int i = 0; i < len; i++)
+		result += (int)pow(txt[i] * 31, len - 1 - i);
+	return result;
 }
 
 // Operatoren
-Text &Text::operator+=( const int num )
+Text& Text::operator+=(const int num)
 {
-    append( num );
-    return *this;
+	append(num);
+	return *this;
 }
 
 // Hängt eine Zahl ans Ende des Textes an
-Text &Text::operator+=( const __int64 num )
+Text& Text::operator+=(const __int64 num)
 {
-    append( num );
-    return *this;
+	append(num);
+	return *this;
 }
 
-Text &Text::operator+=( const double num )
+Text& Text::operator+=(const double num)
 {
-    append( num );
-    return *this;
+	append(num);
+	return *this;
 }
 
-Text &Text::operator+=( const float num )
+Text& Text::operator+=(const float num)
 {
-    append( num );
-    return *this;
+	append(num);
+	return *this;
 }
 
-Text &Text::operator+=( const char *txt )
+Text& Text::operator+=(const char* txt)
 {
-    append( txt );
-    return *this;
+	append(txt);
+	return *this;
 }
 
-Text &Text::operator+=( const Text &txt )
+Text& Text::operator+=(const Text& txt)
 {
-    append( txt.getText() );
-    return *this;
+	append(txt.getText());
+	return *this;
 }
 
-Text &Text::operator=( const int num )
+Text& Text::operator=(const int num)
 {
-    setText( "" );
-    append( num );
-    return *this;
+	setText("");
+	append(num);
+	return *this;
 }
 
-Text &Text::operator=( const double num )
+Text& Text::operator=(const double num)
 {
-    setText( "" );
-    append( num );
-    return *this;
+	setText("");
+	append(num);
+	return *this;
 }
 
-Text &Text::operator=( const float num )
+Text& Text::operator=(const float num)
 {
-    setText( "" );
-    append( num );
-    return *this;
+	setText("");
+	append(num);
+	return *this;
 }
 
-Text &Text::operator=( const char *txt )
+Text& Text::operator=(const char* txt)
 {
-    setText( txt );
-    return *this;
+	setText(txt);
+	return *this;
 }
 
-Text &Text::operator=( const Text &txt )
+Text& Text::operator=(const Text& txt)
 {
-    setText( txt.getText() );
-    return *this;
+	setText(txt.getText());
+	return *this;
 }
 
-Text::operator char *( ) const
+Text::operator char* () const
 {
-    return txt;
+	return txt;
 }
 
 Text::operator int() const
 {
-    if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
-        return TextZuInt( ( txt + 2 ), 16 );
-    return TextZuInt( txt, 10 );
+	if (getLength() > 2 && txt[0] == '0' && txt[1] == 'x')
+		return TextZuInt((txt + 2), 16);
+	return TextZuInt(txt, 10);
 }
 
 Text::operator __int64() const
 {
-    if( getLength() > 2 && txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
-        return TextZuInt64( ( txt + 2 ), 16 );
-    return TextZuInt64( txt, 10 );
+	if (getLength() > 2 && txt[0] == '0' && txt[1] == 'x')
+		return TextZuInt64((txt + 2), 16);
+	return TextZuInt64(txt, 10);
 }
 
 Text::operator double() const
 {
-    return TextZuDouble( txt );
+	return TextZuDouble(txt);
 }
 
 Text::operator float() const
 {
-    return TextZuFloat( txt );
+	return TextZuFloat(txt);
 }
 
-bool Text::operator>( Text &t ) const
+bool Text::operator>(Text& t) const
 {
-    int len1 = getLength();
-    int len2 = t.getLength();
-    char *txt2 = t;
-    for( int i = 0; i < len1 && i < len2; ++i )
-    {
-        if( txt[ i ] > txt2[ i ] )
-            return 1;
-        if( txt[ i ] < txt2[ i ] )
-            return 0;
-    }
-    if( len1 > len2 )
-        return 1;
-    return 0;
+	int len1 = getLength();
+	int len2 = t.getLength();
+	char* txt2 = t;
+	for (int i = 0; i < len1 && i < len2; ++i)
+	{
+		if (txt[i] > txt2[i])
+			return 1;
+		if (txt[i] < txt2[i])
+			return 0;
+	}
+	if (len1 > len2)
+		return 1;
+	return 0;
 }
 
-bool Text::operator<( Text &t ) const
+bool Text::operator<(Text& t) const
 {
-    int len1 = getLength();
-    int len2 = t.getLength();
-    char *txt2 = t;
-    for( int i = 0; i < len1 && i < len2; ++i )
-    {
-        if( txt[ i ] < txt2[ i ] )
-            return 1;
-        if( txt[ i ] > txt2[ i ] )
-            return 0;
-    }
-    if( len1 < len2 )
-        return 1;
-    return 0;
+	int len1 = getLength();
+	int len2 = t.getLength();
+	char* txt2 = t;
+	for (int i = 0; i < len1 && i < len2; ++i)
+	{
+		if (txt[i] < txt2[i])
+			return 1;
+		if (txt[i] > txt2[i])
+			return 0;
+	}
+	if (len1 < len2)
+		return 1;
+	return 0;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und t2
-Text Text::operator+( const Text &t2 ) const
+Text Text::operator+(const Text& t2) const
 {
-    return Text( *this ) += t2;
+	return Text(*this) += t2;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und t2
-Text Text::operator+( const char *t2 ) const
+Text Text::operator+(const char* t2) const
 {
-    return Text( *this ) += t2;
+	return Text(*this) += t2;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und num
-Text Text::operator+( const int num ) const
+Text Text::operator+(const int num) const
 {
-    return Text( *this ) += num;
+	return Text(*this) += num;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und num
-Text Text::operator+( const __int64 num ) const
+Text Text::operator+(const __int64 num) const
 {
-    return Text( *this ) += num;
+	return Text(*this) += num;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und num
-Text Text::operator+( const double num ) const
+Text Text::operator+(const double num) const
 {
-    return Text( *this ) += num;
+	return Text(*this) += num;
 }
 
 // Erstellt einen neuen Text bestehend aus diesem und num
-Text Text::operator+( const float num ) const
+Text Text::operator+(const float num) const
 {
-    return Text( *this ) += num;
+	return Text(*this) += num;
 }
 
-bool Text::operator==( const Text &right ) const
+bool Text::operator==(const Text& right) const
 {
-    return istGleich( right );
+	return istGleich(right);
 }
 
 
 // Inhalt der TextReader Klasse
 // Konstructor
 //  txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
-TextReader::TextReader( Text *txt )
-    : ReferenceCounter()
+TextReader::TextReader(Text* txt)
+	: ReferenceCounter()
 {
-    this->txt = txt;
-    lPos = 0;
+	this->txt = txt;
+	lPos = 0;
 }
 
 // Destructor
 TextReader::~TextReader()
 {
-    txt->release();
+	txt->release();
 }
 
 // Setzt die Position des Bytes, das als nächstes gelesen werden soll
 //  pos: Der Index des Bytes
 //  ende: 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
-void TextReader::setLPosition( __int64 pos, bool ende )
+void TextReader::setLPosition(__int64 pos, bool ende)
 {
-    int l = txt->getLength();
-    lPos = ende ? l - pos : pos;
-    if( lPos < 0 )
-        lPos = 0;
-    if( lPos > l )
-        lPos = l;
+	int l = txt->getLength();
+	lPos = ende ? l - pos : pos;
+	if (lPos < 0)
+		lPos = 0;
+	if (lPos > l)
+		lPos = l;
 }
 
 // Ließt aus der Datei
 //  bytes: Ein Array, der mit Bytes aus dem Text gefüllt werden soll
 //  len: Wie viele Bytes aus dem Text gelesen werden sollen
-void TextReader::lese( char *bytes, int len )
+void TextReader::lese(char* bytes, int len)
 {
-    int l = txt->getLength();
-    len = (int)MIN( l - lPos, len );
-    for( __int64 i = lPos; i < lPos + len; i++ )
-        bytes[ i - lPos ] = txt->getText()[ i ];
-    lPos += len;
+	int l = txt->getLength();
+	len = (int)MIN(l - lPos, len);
+	for (__int64 i = lPos; i < lPos + len; i++)
+		bytes[i - lPos] = txt->getText()[i];
+	lPos += len;
 }
 
 // Ließt die nächste zeile des Textes ein
 //  return: Die gelesene Zeile als Text mit zeilenumbruch
-Text *TextReader::leseZeile()
+Text* TextReader::leseZeile()
 {
-    if( istEnde() )
-        return 0;
-    Text *ret = new Text( "" );
-    __int64 len = txt->getLength();
-    for( char c = 0; c != '\n' && lPos < len; )
-    {
-        lese( &c, 1 );
-        if( c )
-            ret->append( (const char *)&c, 1 );
-    }
-    return ret;
+	if (istEnde())
+		return 0;
+	Text* ret = new Text("");
+	__int64 len = txt->getLength();
+	for (char c = 0; c != '\n' && lPos < len; )
+	{
+		lese(&c, 1);
+		if (c)
+			ret->append((const char*)&c, 1);
+	}
+	return ret;
 }
 
 // Prüft, ob die Resource vollständig gelesen wurde
 //  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
 bool TextReader::istEnde() const
 {
-    return lPos >= txt->getLength();
+	return lPos >= txt->getLength();
 }
 
 // Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
 // return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
 __int64 TextReader::getLPosition() const
 {
-    return lPos;
+	return lPos;
 }
 
 //! Gibt die Anzahl der zu lesenden Bytes zurück
 __int64 TextReader::getSize() const
 {
-    return txt->getLength();
+	return txt->getLength();
 }
 
 // char* operationen
-int Framework::stringPositionVonChar( char *string, char c, int num ) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
-{
-    int gef = 0;
-    int p = 0;
-    for( char cc = *string; *string; ++string )
-    {
-        if( cc == c )
-        {
-            if( gef == num )
-                return p;
-            else
-                ++gef;
-        }
-        ++p;
-    }
-    return -1;
-}
-
-int Framework::stringPositionVonString( char *string, char *suche, int sBegPos ) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
-{
-    for( int i = 0; i < sBegPos; ++i )
-    {
-        if( !*string )
-            return -1;
-        ++string;
-    }
-    int tl = textLength( suche ); // Länge der Übergabe
-    int txl = textLength( string ); // Länge des Textes
-    if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
-        return -1;
-    for( int i = 0; i + tl <= txl; ++i ) // suchen
-    {
-        bool b = 1;
-        for( int ii = 0; ii < tl; ++ii ) // überprüfen
-            if( b )
-                b = string[ i + ii ] == suche[ ii ];
-        if( b )
-            return i + sBegPos;
-    }
-    return -1;
+int Framework::stringPositionVonChar(char* string, char c, int num) // sucht die position des num-ten c-s in string, -1 bei nicht gefunden
+{
+	int gef = 0;
+	int p = 0;
+	for (char cc = *string; *string; ++string)
+	{
+		if (cc == c)
+		{
+			if (gef == num)
+				return p;
+			else
+				++gef;
+		}
+		++p;
+	}
+	return -1;
+}
+
+int Framework::stringPositionVonString(char* string, char* suche, int sBegPos) // sucht die position von 'suche' in 'string' ab der Position 'sBegPos', -1 bei nicht gefunden
+{
+	for (int i = 0; i < sBegPos; ++i)
+	{
+		if (!*string)
+			return -1;
+		++string;
+	}
+	int tl = textLength(suche); // Länge der Übergabe
+	int txl = textLength(string); // Länge des Textes
+	if (tl <= 0 || tl > txl) // Auf unsinnige übergabe prüfen
+		return -1;
+	for (int i = 0; i + tl <= txl; ++i) // suchen
+	{
+		bool b = 1;
+		for (int ii = 0; ii < tl; ++ii) // überprüfen
+			if (b)
+				b = string[i + ii] == suche[ii];
+		if (b)
+			return i + sBegPos;
+	}
+	return -1;
 }
 
 //---Andere Funktionen---
-void Framework::TextKopieren( const char *txt ) // kopiert den Text in den Zwischenspeicher
+void Framework::TextKopieren(const char* txt) // kopiert den Text in den Zwischenspeicher
 {
 #ifdef WIN32
-    int län = textLength( txt ) + 1;
-    if( län == 1 )
-        return;
-    HGLOBAL hMem = GlobalAlloc( GMEM_MOVEABLE, län );
-    if( !hMem )
-        return;
-    memcpy( GlobalLock( hMem ), txt, län );
-    GlobalUnlock( hMem );
-    OpenClipboard( 0 );
-    EmptyClipboard();
-    SetClipboardData( CF_TEXT, hMem );
-    CloseClipboard();
+	int län = textLength(txt) + 1;
+	if (län == 1)
+		return;
+	HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, län);
+	if (!hMem)
+		return;
+	memcpy(GlobalLock(hMem), txt, län);
+	GlobalUnlock(hMem);
+	OpenClipboard(0);
+	EmptyClipboard();
+	SetClipboardData(CF_TEXT, hMem);
+	CloseClipboard();
 #endif
 }
 
-char *Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
+char* Framework::TextInsert() // gibt den Text aus der Zwischenablage zurück
 {
 #ifdef WIN32
-    if( !OpenClipboard( 0 ) )
-        return "";
-    HANDLE hClipData = GetClipboardData( CF_TEXT );
-    char *cBuffer = (char *)GlobalLock( hClipData );
-    GlobalUnlock( hClipData );
-    CloseClipboard();
-    return cBuffer;
+	if (!OpenClipboard(0))
+		return "";
+	HANDLE hClipData = GetClipboardData(CF_TEXT);
+	char* cBuffer = (char*)GlobalLock(hClipData);
+	GlobalUnlock(hClipData);
+	CloseClipboard();
+	return cBuffer;
 #else
-    return 0;
+	return 0;
 #endif
 }
 
-char Framework::smallOrBig( char c, bool gr )
-{
-    int ret = c;
-    if( gr )
-    {
-        if( c >= 'a' && c <= 'z' )
-            ret -= 32;
-        else
-        {
-            switch( c )
-            {
-            case '^':
-                return '°';
-            case '1':
-                return '!';
-            case '<':
-                return '>';
-            case '2':
-                return '\"';
-            case '3':
-                return '§';
-            case '4':
-                return '$';
-            case '5':
-                return '%';
-            case '6':
-                return '&';
-            case '7':
-                return '/';
-            case '8':
-                return '(';
-            case '9':
-                return ')';
-            case '0':
-                return '=';
-            case ',':
-                return ';';
-            case '.':
-                return ':';
-            case 'ß':
-                return '?';
-            case '-':
-                return '_';
-            case '´':
-                return '`';
-            case '+':
-                return '*';
-            case '#':
-                return '\'';
-            case 'ü':
-                return 'Ü';
-            case 'ö':
-                return 'Ö';
-            case 'ä':
-                return 'Ä';
-            }
-        }
-    }
-    else
-    {
-        if( c >= 'A' && c <= 'Z' )
-            ret += 32;
-        else
-        {
-            switch( c )
-            {
-            case '°':
-                return '^';
-            case '!':
-                return '1';
-            case '>':
-                return '<';
-            case '\"':
-                return '2';
-            case '§':
-                return '3';
-            case '$':
-                return '4';
-            case '%':
-                return '5';
-            case '&':
-                return '6';
-            case '/':
-                return '7';
-            case '(':
-                return '8';
-            case ')':
-                return '9';
-            case '=':
-                return '0';
-            case ';':
-                return ',';
-            case ':':
-                return '.';
-            case '?':
-                return 'ß';
-            case '_':
-                return '-';
-            case '`':
-                return '´';
-            case '*':
-                return '+';
-            case '\'':
-                return '#';
-            case 'Ü':
-                return 'ü';
-            case 'Ö':
-                return 'ö';
-            case 'Ä':
-                return 'ä';
-            }
-        }
-    }
-    return (char)ret;
-}
-
-bool Framework::istSchreibbar( unsigned char zeichen ) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
-{
-    if( zeichen > 32 && zeichen < 127 )
-        return 1;
-    if( zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179 )
-        return 1;
-    if( zeichen > 191 && zeichen < 198 )
-        return 1;
-    if( zeichen > 199 && zeichen < 208 )
-        return 1;
-    if( zeichen > 209 && zeichen < 215 )
-        return 1;
-    if( zeichen > 216 && zeichen < 221 )
-        return 1;
-    if( zeichen > 222 && zeichen < 230 )
-        return 1;
-    if( zeichen > 231 && zeichen < 240 )
-        return 1;
-    if( zeichen > 241 && zeichen < 247 )
-        return 1;
-    if( zeichen > 248 && zeichen < 253 )
-        return 1;
-    if( zeichen == ' ' || zeichen == '\t' )
-        return 1;
-    return 0;
-}
-
-unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
-{
-    if( system == 16 )
-        return (unsigned int)strtoul( c, 0, system );
-    return (unsigned int)strtol( c, 0, system );
-}
-
-unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
-{
-    if( system == 16 )
-        return (unsigned int)strtoul( c, c_ende, system );
-    return (unsigned int)strtol( c, c_ende, system );
-}
-
-unsigned __int64 Framework::TextZuInt64( char *c, int system )
-{
-    if( system == 16 )
-        return strtoull( c, 0, system );
-    return (unsigned __int64)strtoll( c, 0, system );
-}
-
-unsigned __int64 Framework::TextZuInt64( char *c, char **c_ende, int system )
-{
-    if( system == 16 )
-        return strtoull( c, c_ende, system );
-    return (unsigned __int64)strtoll( c, c_ende, system );
-}
-
-double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
-{
-    return strtod( c, 0 );
-}
-
-float Framework::TextZuFloat( char *c ) // Konvertiert c zu double
-{
-    return strtof( c, 0 );
-}
-
-double Framework::TextZuDouble( char *c, char **c_ende )
-{
-    return strtod( c, c_ende );
-}
-
-float Framework::TextZuFloat( char *c, char **c_ende )
-{
-    return strtof( c, c_ende );
-}
-
-int Framework::textLength( const char *txt ) // gibt die Länge von txt zurück
-{
-    if( !txt )
-        return 0;
-    int ret = 0;
-    for( ; ; ++ret )
-    {
-        bool br = 0;
-        switch( txt[ ret ] )
-        {
-        case 0:
-            br = 1;
-            break;
-        case 2:
-        case 6:
-            ++ret;
-            break;
-        case 3:
-        case 4:
-        case 5:
-            ret += 4;
-            break;
-        case 8:
-            ret += 4;
-            break;
-        }
-        if( br )
-            break;
-    }
-    return ret;
+char Framework::smallOrBig(char c, bool gr)
+{
+	int ret = c;
+	if (gr)
+	{
+		if (c >= 'a' && c <= 'z')
+			ret -= 32;
+		else
+		{
+			switch (c)
+			{
+			case '^':
+				return '°';
+			case '1':
+				return '!';
+			case '<':
+				return '>';
+			case '2':
+				return '\"';
+			case '3':
+				return '§';
+			case '4':
+				return '$';
+			case '5':
+				return '%';
+			case '6':
+				return '&';
+			case '7':
+				return '/';
+			case '8':
+				return '(';
+			case '9':
+				return ')';
+			case '0':
+				return '=';
+			case ',':
+				return ';';
+			case '.':
+				return ':';
+			case 'ß':
+				return '?';
+			case '-':
+				return '_';
+			case '´':
+				return '`';
+			case '+':
+				return '*';
+			case '#':
+				return '\'';
+			case 'ü':
+				return 'Ü';
+			case 'ö':
+				return 'Ö';
+			case 'ä':
+				return 'Ä';
+			}
+		}
+	}
+	else
+	{
+		if (c >= 'A' && c <= 'Z')
+			ret += 32;
+		else
+		{
+			switch (c)
+			{
+			case '°':
+				return '^';
+			case '!':
+				return '1';
+			case '>':
+				return '<';
+			case '\"':
+				return '2';
+			case '§':
+				return '3';
+			case '$':
+				return '4';
+			case '%':
+				return '5';
+			case '&':
+				return '6';
+			case '/':
+				return '7';
+			case '(':
+				return '8';
+			case ')':
+				return '9';
+			case '=':
+				return '0';
+			case ';':
+				return ',';
+			case ':':
+				return '.';
+			case '?':
+				return 'ß';
+			case '_':
+				return '-';
+			case '`':
+				return '´';
+			case '*':
+				return '+';
+			case '\'':
+				return '#';
+			case 'Ü':
+				return 'ü';
+			case 'Ö':
+				return 'ö';
+			case 'Ä':
+				return 'ä';
+			}
+		}
+	}
+	return (char)ret;
+}
+
+bool Framework::istSchreibbar(unsigned char zeichen) // prüft, ob zeichen ein Schreibbarer Buchstabe ist
+{
+	if (zeichen > 32 && zeichen < 127)
+		return 1;
+	if (zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179)
+		return 1;
+	if (zeichen > 191 && zeichen < 198)
+		return 1;
+	if (zeichen > 199 && zeichen < 208)
+		return 1;
+	if (zeichen > 209 && zeichen < 215)
+		return 1;
+	if (zeichen > 216 && zeichen < 221)
+		return 1;
+	if (zeichen > 222 && zeichen < 230)
+		return 1;
+	if (zeichen > 231 && zeichen < 240)
+		return 1;
+	if (zeichen > 241 && zeichen < 247)
+		return 1;
+	if (zeichen > 248 && zeichen < 253)
+		return 1;
+	if (zeichen == ' ' || zeichen == '\t')
+		return 1;
+	return 0;
+}
+
+unsigned int Framework::TextZuInt(char* c, int system) // Konvertiert c zu int
+{
+	if (system == 16)
+		return (unsigned int)strtoul(c, 0, system);
+	return (unsigned int)strtol(c, 0, system);
+}
+
+unsigned int Framework::TextZuInt(char* c, char** c_ende, int system)
+{
+	if (system == 16)
+		return (unsigned int)strtoul(c, c_ende, system);
+	return (unsigned int)strtol(c, c_ende, system);
+}
+
+unsigned __int64 Framework::TextZuInt64(char* c, int system)
+{
+	if (system == 16)
+		return strtoull(c, 0, system);
+	return (unsigned __int64)strtoll(c, 0, system);
+}
+
+unsigned __int64 Framework::TextZuInt64(char* c, char** c_ende, int system)
+{
+	if (system == 16)
+		return strtoull(c, c_ende, system);
+	return (unsigned __int64)strtoll(c, c_ende, system);
+}
+
+double Framework::TextZuDouble(char* c) // Konvertiert c zu double
+{
+	return strtod(c, 0);
+}
+
+float Framework::TextZuFloat(char* c) // Konvertiert c zu double
+{
+	return strtof(c, 0);
+}
+
+double Framework::TextZuDouble(char* c, char** c_ende)
+{
+	return strtod(c, c_ende);
+}
+
+float Framework::TextZuFloat(char* c, char** c_ende)
+{
+	return strtof(c, c_ende);
+}
+
+int Framework::textLength(const char* txt) // gibt die Länge von txt zurück
+{
+	if (!txt)
+		return 0;
+	int ret = 0;
+	for (; ; ++ret)
+	{
+		bool br = 0;
+		switch (txt[ret])
+		{
+		case 0:
+			br = 1;
+			break;
+		case 2:
+		case 6:
+			++ret;
+			break;
+		case 3:
+		case 4:
+		case 5:
+			ret += 4;
+			break;
+		case 8:
+			ret += 4;
+			break;
+		}
+		if (br)
+			break;
+	}
+	return ret;
 }

Text.h

@@ -6,446 +6,449 @@
 
 namespace Framework
 {
-    class Text; //! aus dieser Datei
+	class Text; //! aus dieser Datei
 
-    //! Ein ersatz für String
-    class Text : public virtual ReferenceCounter
-    {
-    private:
-        char *txt;
-        char suchGBeg;
-        char suchGEnd;
-        int precision;
+	//! Ein ersatz für String
+	class Text : public virtual ReferenceCounter
+	{
+	private:
+		char* txt;
+		char suchGBeg;
+		char suchGEnd;
+		int precision;
 
-    public:
-        //! Erstellt ein neues Text Objekt mit dem Wert ""
-        DLLEXPORT Text();
-        //! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
-        //! \param txt Der Text, der kopiert werden soll
-        DLLEXPORT Text( const Text &txt );
-        //! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
-        //! \param txt Die Zeichenkette, die kopiert werden soll
-        DLLEXPORT Text( const char *txt );
-        //! Erstellt ein neues Text Objekt mit einer zahl als text
-        //! \param zahl Die Zahl, die im Text sein soll
-        DLLEXPORT Text( int zahl );
-        //! Erstellt ein neues Text Objekt mit einer zahl als text
-        //! \param num Die Zahl, die im Text sein soll
-        DLLEXPORT Text( double num );
-        //! Erstellt ein neues Text Objekt mit einer zahl als text
-        //! \param num Die Zahl, die im Text sein soll
-        DLLEXPORT Text( float num );
-        //! Löscht den Text
-        DLLEXPORT ~Text();
-        //! Wandelt alle buchstaben in großbuchstaben um
-        DLLEXPORT void toUpperCase();
-        //! Wandelt alle buchstaben in kleinbuchstaben um
-        DLLEXPORT void toLowerCase();
-        //! Legt die Suchgrenzen fest, die von den Suchfunktionen verwendet werden.
-        //! \param gBeg Das Zeichen, bei dem die Suche beginnen soll
-        //! \param gEnd Das Zeichen, bei dem die Suche enden soll
-        DLLEXPORT void setSuchGrenzen( char gBeg, char gEnd );
-        //! Setzt den Text, den das Zeichnung speichert
-        //! \param t Eine Zeichenkette, deren Inhalt kopiert wird
-        DLLEXPORT void setText( const char *t );
-        //! Setzt den Text, den das Zeichnung speichert
-        //! \param t Eine Zeichenkette, deren Inhalt kopiert wird
-        //! \param l Die Länge des Textes, der aus (t) kopiert werden soll
-        DLLEXPORT void setText( const char *t, int l );
-        //! Setzt den Text, den das Zeichnung speichert
-        //! \param t Das TextZeichnung, dessen Inahlt kopiert werden soll
-        DLLEXPORT void setText( Text *t );
-        //! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
-        //! \param num Die Zahl, die ins Hex System umgewandelt und angehängt werden soll
-        DLLEXPORT void appendHex( int num );
-        //! Fügt den übergebenen Buchtaben der Zeichenkette hinzu
-        //! \param c Der Buchstabe, der angehängt werden soll
-        DLLEXPORT void append( char c );
-        //! Hängt die übergebene Zeichenkette ans Ende des Textes an
-        //! \param t Die Zeichenkette, deren Kopie ans Ende des Textes angehängt werden soll
-        DLLEXPORT void append( const char *t );
-        //! Hängt einen Teil der übergebenen Zeichenkette ans Ende des Textes an
-        //! \param t Die Zeichenkette, deren Kopie angehängt werden soll
-        //! \param l Die Länge des Textabschnittes der angehängt werden soll
-        DLLEXPORT void append( const char *t, int l );
-        //! Hängt den Inhalt des eines Textes ans Ende des Textes an
-        //! \param t Der Text, dessen Kopie ans Ende des Textes angehängt werden soll
-        DLLEXPORT void append( Text *t );
-        //! Hängt eine Zahl ans Ende Des Textes an
-        //! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
-        DLLEXPORT void append( int num );
-        //! Hängt eine Zahl ans Ende Des Textes an
-        //! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
-        DLLEXPORT void append( __int64 num );
-        //! Hängt eine Zahl ohne Vorzeichenbit am Ende des Textes an
-        //! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
-        DLLEXPORT void append( unsigned int num );
-        //! Hängt eine Kommazahl am Ende des Textes an
-        //! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
-        DLLEXPORT void append( double num );
-        //! Hängt eine Kommazahl am Ende des Textes an
-        //! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
-        DLLEXPORT void append( float num );
-        //! Fügt an einer Bestimmten Stelle ein Zeichen in den Text ein
-        //! \param p Die position im Text bei der das Zeichen eingefügt werden soll
-        //! \param c Das Zeichen, das eingefügt werden soll
-        DLLEXPORT void insert( int p, char c );
-        //! Fügt an einer Bestimmten Stelle im Text eine Zeichenkette ein
-        //! \param p Die position im Text bei der die Zeichenkette eingefügt werden soll
-        //! \param t Die Zeichenkette, deren Kopie an eingefügt werden soll
-        DLLEXPORT void insert( int p, const char *t );
-        //! Fügt den Inhalt eines Textes an einer Bestimmten Stelle im Text ein
-        //! \param p Die Position im Text, bei der der inhalt des Textest eingefügt werden soll
-        //! \param t Der Text, dessen Kopie an der Stelle eingefügt werden soll
-        DLLEXPORT void insert( int p, Text *t );
-        //! Ersetzt einen bestimmten Textabschnitt mit einer anderen Zeichenkette
-        //!  p1: Die Startposition des zu ersetzenden Textabschnittes
-        //!  p2: Die Endposition des zu ersetzenden Textabschnittes
-        //! \param t Die Zeichenkette, die an die entsprechende Stelle kopiert werden soll
-        //! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, "lt" ); ergibt: "Halt Welt"
-        DLLEXPORT void ersetzen( int p1, int p2, const char *t );
-        //! Ersetzt einen bestimmten Textabschnitt mit dem Inhalt eines anderen Textes
-        //!  p1: Die Startposition des zu ersetzenden Textabschnittes
-        //!  p2: Die Endposition des zu ersetzenden Textabschnittes
-        //! \param t Der Text, dessen Inhalt an die entsprechende Stelle kopiert werden soll
-        //! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, new Text( "lt" ) ); ergibt: "Halt Welt"
-        DLLEXPORT void ersetzen( int p1, int p2, Text *t );
-        //! Sucht und erstetzt jedes Vorkommen eines bestimmten Buchstaben durch einen anderen
-        //!  c1: Der Buchstabe der ersetzt werden soll
-        //!  c2: Der Buchstabe, durch den der Andere ersetzt werden soll
-        DLLEXPORT void ersetzen( char c1, char c2 );
-        //! Sucht und erstetzt jedes Vorkommen einer bestimmten Zeichenkette durch eine andere
-        //!  t1: Die Zeichenkette, die ersetzt werden soll
-        //!  t2: Die Zeichenkette, durch welche die Andere ersetzt werden soll
-        DLLEXPORT void ersetzen( const char *t1, const char *t2 );
-        //! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch eine andere Zeichenkette
-        //!  t1: Der Text, dessen Inhalt gesucht und ersetzt wird
-        //!  t2: Die Zeichenkette, durch welche das Vorkommen des Textes ersetzt werden soll
-        DLLEXPORT void ersetzen( Text *t1, const char *t2 );
-        //! Sucht und erstetzt jedes Vorkommen einer Zeichenkette durch den Inhalt eines Textes
-        //!  t1: Die Zeichenkette, die ersetzt werden soll
-        //!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
-        DLLEXPORT void ersetzen( const char *t1, Text *t2 );
-        //! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch den Inhalt eines anderen Textes
-        //!  t1: Der Text, dessen Vorkommen ersetzt werden sollen
-        //!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
-        DLLEXPORT void ersetzen( Text *t1, Text *t2 );
-        //! Ersetzt das i-te auftreten eines bestimmten Buchstaben mit einem anderen Buchstaben
-        //! \param i Das wie vielte Auftreten des Buchstabens ersetzt werden soll
-        //!  c1: Der Buchstabe, dessen i-tes Auftreten erstetzt werden soll
-        //!  c2: Der Buchstabe, der das i-te Auftreten des anderen Buchstabens ersetzen soll
-        DLLEXPORT void ersetzen( int i, char c1, char c2 );
-        //! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit einer anderen Zeichenkette
-        //! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
-        //!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
-        //!  c2: Die Zeichenkette, die das i-te Auftreten der anderen Zeichenkette ersetzen soll
-        DLLEXPORT void ersetzen( int i, const char *t1, const char *t2 );
-        //! Ersetzt das i-te auftreten des Inhalts eines Textes mit einer Zeichenkette
-        //! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
-        //!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
-        //!  c2: Die Zeichenkette, die das i-te Auftreten des Textes ersetzen soll
-        DLLEXPORT void ersetzen( int i, Text *t1, const char *t2 );
-        //! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit dem Inhalt eines Textes
-        //! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
-        //!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
-        //!  c2: Der Text, dessen Inhalt das i-te Auftreten der Zeichenkette ersetzen soll
-        DLLEXPORT void ersetzen( int i, const char *t1, Text *t2 );
-        //! Ersetzt das i-te auftreten eines bestimmten Textes mit dem Inhalt eines anderen Textes
-        //! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
-        //!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
-        //!  c2: Der Text, dessen Inhalt das i-te Auftreten des anderen Textes ersetzen soll
-        DLLEXPORT void ersetzen( int i, Text *t1, Text *t2 );
-        //! Löscht den bisherigen Text und erzeugt einen Text, der aus einem Bestimten Buchstaben besteht, mit einer bestimmten Länge
-        //! \param c Der Buchstabe, aus dem der Text bestehen soll
-        //! \param length Die Länge des Textes
-        DLLEXPORT void fillText( char c, int length );
-        //! Löscht ein Bestimmtes Zeichen aus dem Text
-        //! \param p Die Position des zu löschenden Zeichens
-        DLLEXPORT void remove( int p );
-        //! Löscht einen Bestimmten Textabschnitt
-        //!  p1: Die Startposition des zu löschenden Abschnittes
-        //!  p2: Die Endposition des zu löschenden Abschnittes (Das Zeichen bei p2 bleibt erhalten)
-        DLLEXPORT void remove( int p1, int p2 );
-        //! Löscht jedes Vorkommen eines bestimmten Buchsaben
-        //! \param c Der Buchstabe, dessen Vorkommen gelöscht werden soll
-        DLLEXPORT void remove( char c );
-        //! Löscht jedes Vorkommen einer bestimmten Zeichenkette
-        //! \param t Die Zeichenkette, deren Vorkommen entfernt werden sollen
-        DLLEXPORT void remove( const char *t );
-        //! Löscht jedes Vorkommen des Inhalts eines Textes
-        //! \param t Der text, dessen Inhalt gelöscht werden soll
-        DLLEXPORT void remove( Text *t );
-        //! Löscht das i-te Vorkommen eines bestimmten Buchstaben
-        //! \param i Das wie vielte Vorkommen des Buchstabens gelöscht werden soll
-        //! \param c Der Buchstabe, dessen i-tes Vorkommen gelöscht werden soll
-        DLLEXPORT void remove( int i, char c );
-        //! Löscht das i-te Vorkommen einer bestimmten Zechenkette
-        //! \param i Das wie vielte Vorkommen der Zeichenkette gelöscht werden soll
-        //! \param t Die Zeichenkette, dessen i-tes Vorkommen gelöscht werden soll
-        DLLEXPORT void remove( int i, const char *t );
-        //! Löscht das i-te Vorkommen eines bestimmten Textinhaltes
-        //! \param i Das wie vielte Vorkommen des Textinhaltes gelöscht werden soll
-        //! \param t Der Text, dessen i-tes Vorkommen gelöscht werden soll
-        DLLEXPORT void remove( int i, Text *t );
-        //! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
-        //! \param pos Die Position des ersten zeichens
-        DLLEXPORT void removeWhitespaceAfter( int pos );
-        //! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
-        //! \param pos Die Position des ersten zeichens (beginnt bei pos-1)
-        DLLEXPORT void removeWhitespaceBefore( int pos );
-        //! Setzt die Anzahl der Nachkommastellen beim Anhängen von Kommazahlen
-        //! \param p Die Anzahl der Stellen nach dem Komma
-        DLLEXPORT void setPrecision( int p );
-        //! Gibt die Länge des Textes zurück
-        DLLEXPORT int getLength() const;
-        //! Ermittelt die neue Curserposition nachdem Drücken der 'Links' Pfeiltaste
-        //! \param pos Die alte Curserposition
-        DLLEXPORT int getLKick( int pos ) const;
-        //! Ermittelt die neue Curserposition nachdem Drücken der 'Oben' Pfeiltaste
-        //! \param pos Die alte Curserposition
-        DLLEXPORT int getOKick( int pos ) const;
-        //! Ermittelt die neue Curserposition nachdem Drücken der 'Rechts' Pfeiltaste
-        //! \param pos Die alte Curserposition
-        DLLEXPORT int getRKick( int pos ) const;
-        //! Ermittelt die neue Curserposition nachdem Drücken der 'Unten' Pfeiltaste
-        //! \param pos Die alte Curserposition
-        DLLEXPORT int getUKick( int pos ) const;
-        //! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
-        //! \param t Der Text, nach dessen Inhalt gesucht werden soll
-        //! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
-        DLLEXPORT bool hat( Text *t ) const;
-        //! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
-        //! \param t Die Zeichenkette, nach der gesucht werden soll
-        //! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
-        DLLEXPORT bool hat( const char *t ) const;
-        //! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
-        //! \param t Der Text, nach dessen Inhalt gesucht werden soll
-        //! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
-        //! \param pos die position an der die zeichenkette im string beginnen soll
-        DLLEXPORT bool hatAt( int pos, Text *t ) const;
-        //! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
-        //! \param t Die Zeichenkette, nach der gesucht werden soll
-        //! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
-        //! \param pos die position an der die zeichenkette im string beginnen soll
-        DLLEXPORT bool hatAt( int pos, const char *t ) const;
-        //! Überprüft, ob im Text ein bestimmtes Zeichen vorkommt
-        //! \param c Das Zeichen, nach dem gesucht werden soll
-        //! \return (true), wenn das Zeichen vorkommt. (false) sonnst
-        DLLEXPORT bool hat( char c ) const;
-        //! Überprft, ob der Text den selben Inhalt wie eine Zeichenkette hat
-        //! \param t Die Zeichenkette, die verglichen werden soll
-        //! \return (true), wenn der Inhalt des Textes gleich der Zeichenkette ist. (false) sonst
-        DLLEXPORT bool istGleich( const char *t ) const;
-        //! Überprft, ob der Text den selben Inhalt wie ein anderer Text hat
-        //! \param t Der Text, dessen Inhalt verglichen werden soll
-        //! \return (true), wenn die Inhalte der Texte übereinstimmen. (false) sonst
-        DLLEXPORT bool istGleich( Text *t ) const;
-        //! Gibt den Inhalt des Textes als Zeichenkette zurück
-        DLLEXPORT char *getText() const;
-        //! Zählt, wie oft ein bestimmter Buchstabe im Text vorkomt
-        //! \param c Der Buchstabe, der gezählt werden soll
-        //! \return Die Anzahl des Buchstabens im Text
-        DLLEXPORT int anzahlVon( char c ) const;
-        //! Zählt, wie oft eine bestimmte Zeichenkette im Text vorkommt
-        //! \param t Die Zeichenkette, die gezählt werden soll
-        //! \return Die Anzahl der Zeichenkette im Text
-        DLLEXPORT int anzahlVon( const char *t ) const;
-        //! Zählt, wie oft der Inhalt eines Textest im Text vorkommt
-        //! \param t Der Text, dessen Inhalt gezählt werden soll
-        //! \return Die Anzahl des Textinhaltes im Text
-        DLLEXPORT int anzahlVon( Text *t ) const;
-        //! Gibt die erste Position eines bestimmten Buchstabens im Text zurück
-        //! \param c Der Buchstabe, der gefunden werden soll
-        //! \return Die Position des ersten Vorkommens des Buchstabens
-        DLLEXPORT int positionVon( char c ) const;
-        //! Gibt die erste Position einer bestimmten Zeichenkette im Text zurück
-        //! \param t Die Zeichenkette, die gefunden werden soll
-        //! \return Die Position des ersten Vorkommens der Zeichenkette
-        DLLEXPORT int positionVon( const char *t ) const;
-        //! Gibt die erste Position eines Textinhaltes im Text zurück
-        //! \param t Der Text, dessen Inhalt gefunden werden soll
-        //! \return Die Position des ersten Vorkommens des Textinhaltes
-        DLLEXPORT int positionVon( Text *t ) const;
-        //! Gibt die i-te Position eines bestimmten Buchstabens im Text zurück
-        //! \param c Der Buchstabe, der gefunden werden soll
-        //! \param i Das wievielte Vorkommen gefunden werden soll
-        //! \return Die Position des i-ten Vorkommens des Buchstabens
-        DLLEXPORT int positionVon( char c, int i ) const;
-        //! Gibt die i-te Position einer bestimmten Zeichenkette im Text zurück
-        //! \param t Die Zeichenkette, die gefunden werden soll
-        //! \param i Das wievielte Vorkommen gefunden werden soll
-        //! \return Die Position des i-ten Vorkommens der Zeichenkette
-        DLLEXPORT int positionVon( const char *t, int i ) const;
-        //! Gibt die i-te Position eines Textinhaltes im Text zurück
-        //! \param t Der Text, dessen Inhalt gefunden werden soll
-        //! \param i Das wievielte Vorkommen gefunden werden soll
-        //! \return Die Position des i-ten Vorkommens des Textinhaltes
-        DLLEXPORT int positionVon( Text *t, int i ) const;
-        //! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
-        //!  p1: Die Startposition des Textabschnittes
-        //!  p2: Die Endposition des Textabschnittes (nicht enthalten)
-        DLLEXPORT Text *getTeilText( int p1, int p2 ) const;
-        //! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
-        //!  p1: Die Startposition des Textabschnittes (Der Textabschnitt geht bis ans Ende des Textes)
-        DLLEXPORT Text *getTeilText( int p ) const;
-        // berechnet den Hash code des textes
-        DLLEXPORT int hashCode() const;
-        //! Hängt eine Zahl ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const int num );
-        //! Hängt eine Zahl ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const __int64 num );
-        //! Hängt eine Kommazahl ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const double num );
-        //! Hängt eine Kommazahl ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const float num );
-        //! Hängt eine Zeichenkette ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const char *txt );
-        //! Hängt eine Kopie des Inhalts eines Textes ans Ende des Textes an
-        DLLEXPORT Text &operator+=( const Text &txt );
-        //! Setzt den Inhalt des Textes gleich einer Zahl
-        DLLEXPORT Text &operator=( const int num );
-        //! Setzt den Inhalt des Textes gleich einer Kommazahl
-        DLLEXPORT Text &operator=( const double num );
-        //! Setzt den Inhalt des Textes gleich einer Kommazahl
-        DLLEXPORT Text &operator=( const float num );
-        //! Setzt den Inahlt des Textes gleich einer Zeichenkette
-        DLLEXPORT Text &operator=( const char *txt );
-        //! Setzt den Inhalt des Textes gleich einer Kopie des Inhalts eines anderen Textes
-        DLLEXPORT Text &operator=( const Text &txt );
-        //! Gibt den Inhalt des Textes als Zeichenkette zurück
-        DLLEXPORT operator char *( ) const;
-        //! Konviertiert den Inhalt des Textes zu einer Zahl
-        DLLEXPORT operator int() const;
-        //! Konviertiert den Inhalt des Textes zu einer Zahl
-        DLLEXPORT operator __int64() const;
-        //! Konviertiert den Inhalt des Textes zu einer Kommazahl
-        DLLEXPORT operator double() const;
-        //! Konviertiert den Inhalt des Textes zu einer Kommazahl
-        DLLEXPORT operator float() const;
-        //! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung später kommt als der Inhalt eines anderen Textes
-        DLLEXPORT bool operator>( Text &t ) const;
-        //! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung früher kommt als der Inhalt eines anderen Textes
-        DLLEXPORT bool operator<( Text &t ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und t2
-        DLLEXPORT Text operator+( const Text &t2 ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und t2
-        DLLEXPORT Text operator+( const char *t2 ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und num
-        DLLEXPORT Text operator+( const int num ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und num
-        DLLEXPORT Text operator+( const __int64 num ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und num
-        DLLEXPORT Text operator+( const double num ) const;
-        //! Erstellt einen neuen Text bestehend aus diesem und num
-        DLLEXPORT Text operator+( const float num ) const;
-        //! Prüft ob der Text mit dem anderen Text übereinstimmt
-        DLLEXPORT bool operator==( const Text &right ) const;
-    };
+	public:
+		//! Erstellt ein neues Text Objekt mit dem Wert ""
+		DLLEXPORT Text();
+		//! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
+		//! \param txt Der Text, der kopiert werden soll
+		DLLEXPORT Text(const Text& txt);
+		//! Erstellt ein neues Text Objekt indem der Wert aus (txt) kopiert wird
+		//! \param txt Die Zeichenkette, die kopiert werden soll
+		DLLEXPORT Text(const char* txt);
+		//! Erstellt ein neues Text Objekt mit einer zahl als text
+		//! \param zahl Die Zahl, die im Text sein soll
+		DLLEXPORT Text(int zahl);
+		//! Erstellt ein neues Text Objekt mit einer zahl als text
+		//! \param num Die Zahl, die im Text sein soll
+		DLLEXPORT Text(double num);
+		//! Erstellt ein neues Text Objekt mit einer zahl als text
+		//! \param num Die Zahl, die im Text sein soll
+		DLLEXPORT Text(float num);
+		//! Löscht den Text
+		DLLEXPORT ~Text();
+		//! Wandelt alle buchstaben in großbuchstaben um
+		DLLEXPORT void toUpperCase();
+		//! Wandelt alle buchstaben in kleinbuchstaben um
+		DLLEXPORT void toLowerCase();
+		//! Legt die Suchgrenzen fest, die von den Suchfunktionen verwendet werden.
+		//! \param gBeg Das Zeichen, bei dem die Suche beginnen soll
+		//! \param gEnd Das Zeichen, bei dem die Suche enden soll
+		DLLEXPORT void setSuchGrenzen(char gBeg, char gEnd);
+		//! Setzt den Text, den das Zeichnung speichert
+		//! \param t Eine Zeichenkette, deren Inhalt kopiert wird
+		DLLEXPORT void setText(const char* t);
+		//! Setzt den Text, den das Zeichnung speichert
+		//! \param t Eine Zeichenkette, deren Inhalt kopiert wird
+		//! \param l Die Länge des Textes, der aus (t) kopiert werden soll
+		DLLEXPORT void setText(const char* t, int l);
+		//! Setzt den Text, den das Zeichnung speichert
+		//! \param t Das TextZeichnung, dessen Inahlt kopiert werden soll
+		DLLEXPORT void setText(Text* t);
+		//! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
+		//! \param num Die Zahl, die ins Hex System umgewandelt und angehängt werden soll
+		DLLEXPORT void appendHex(int num);
+		//! Hängt die übergebene Zahl als Hex Text (0-F) ans Ende des Textes an.
+		//! \param num Die Zahl, die ins Hex System umgewandelt und angehängt werden soll
+		DLLEXPORT void appendHex(__int64 num);
+		//! Fügt den übergebenen Buchtaben der Zeichenkette hinzu
+		//! \param c Der Buchstabe, der angehängt werden soll
+		DLLEXPORT void append(char c);
+		//! Hängt die übergebene Zeichenkette ans Ende des Textes an
+		//! \param t Die Zeichenkette, deren Kopie ans Ende des Textes angehängt werden soll
+		DLLEXPORT void append(const char* t);
+		//! Hängt einen Teil der übergebenen Zeichenkette ans Ende des Textes an
+		//! \param t Die Zeichenkette, deren Kopie angehängt werden soll
+		//! \param l Die Länge des Textabschnittes der angehängt werden soll
+		DLLEXPORT void append(const char* t, int l);
+		//! Hängt den Inhalt des eines Textes ans Ende des Textes an
+		//! \param t Der Text, dessen Kopie ans Ende des Textes angehängt werden soll
+		DLLEXPORT void append(Text* t);
+		//! Hängt eine Zahl ans Ende Des Textes an
+		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
+		DLLEXPORT void append(int num);
+		//! Hängt eine Zahl ans Ende Des Textes an
+		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
+		DLLEXPORT void append(__int64 num);
+		//! Hängt eine Zahl ohne Vorzeichenbit am Ende des Textes an
+		//! \param num Die Zahl, die in einen Text umgewandelt und am Ende angehängt werden soll
+		DLLEXPORT void append(unsigned int num);
+		//! Hängt eine Kommazahl am Ende des Textes an
+		//! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
+		DLLEXPORT void append(double num);
+		//! Hängt eine Kommazahl am Ende des Textes an
+		//! \param num Die Kommazahl, die am Ende des Textes angehängt werden soll
+		DLLEXPORT void append(float num);
+		//! Fügt an einer Bestimmten Stelle ein Zeichen in den Text ein
+		//! \param p Die position im Text bei der das Zeichen eingefügt werden soll
+		//! \param c Das Zeichen, das eingefügt werden soll
+		DLLEXPORT void insert(int p, char c);
+		//! Fügt an einer Bestimmten Stelle im Text eine Zeichenkette ein
+		//! \param p Die position im Text bei der die Zeichenkette eingefügt werden soll
+		//! \param t Die Zeichenkette, deren Kopie an eingefügt werden soll
+		DLLEXPORT void insert(int p, const char* t);
+		//! Fügt den Inhalt eines Textes an einer Bestimmten Stelle im Text ein
+		//! \param p Die Position im Text, bei der der inhalt des Textest eingefügt werden soll
+		//! \param t Der Text, dessen Kopie an der Stelle eingefügt werden soll
+		DLLEXPORT void insert(int p, Text* t);
+		//! Ersetzt einen bestimmten Textabschnitt mit einer anderen Zeichenkette
+		//!  p1: Die Startposition des zu ersetzenden Textabschnittes
+		//!  p2: Die Endposition des zu ersetzenden Textabschnittes
+		//! \param t Die Zeichenkette, die an die entsprechende Stelle kopiert werden soll
+		//! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, "lt" ); ergibt: "Halt Welt"
+		DLLEXPORT void ersetzen(int p1, int p2, const char* t);
+		//! Ersetzt einen bestimmten Textabschnitt mit dem Inhalt eines anderen Textes
+		//!  p1: Die Startposition des zu ersetzenden Textabschnittes
+		//!  p2: Die Endposition des zu ersetzenden Textabschnittes
+		//! \param t Der Text, dessen Inhalt an die entsprechende Stelle kopiert werden soll
+		//! Beispiel: ( "Hallo Welt" ).ersetzen( 2, 5, new Text( "lt" ) ); ergibt: "Halt Welt"
+		DLLEXPORT void ersetzen(int p1, int p2, Text* t);
+		//! Sucht und erstetzt jedes Vorkommen eines bestimmten Buchstaben durch einen anderen
+		//!  c1: Der Buchstabe der ersetzt werden soll
+		//!  c2: Der Buchstabe, durch den der Andere ersetzt werden soll
+		DLLEXPORT void ersetzen(char c1, char c2);
+		//! Sucht und erstetzt jedes Vorkommen einer bestimmten Zeichenkette durch eine andere
+		//!  t1: Die Zeichenkette, die ersetzt werden soll
+		//!  t2: Die Zeichenkette, durch welche die Andere ersetzt werden soll
+		DLLEXPORT void ersetzen(const char* t1, const char* t2);
+		//! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch eine andere Zeichenkette
+		//!  t1: Der Text, dessen Inhalt gesucht und ersetzt wird
+		//!  t2: Die Zeichenkette, durch welche das Vorkommen des Textes ersetzt werden soll
+		DLLEXPORT void ersetzen(Text* t1, const char* t2);
+		//! Sucht und erstetzt jedes Vorkommen einer Zeichenkette durch den Inhalt eines Textes
+		//!  t1: Die Zeichenkette, die ersetzt werden soll
+		//!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
+		DLLEXPORT void ersetzen(const char* t1, Text* t2);
+		//! Sucht und erstetzt jedes Vorkommen des Inhalts eines Textes durch den Inhalt eines anderen Textes
+		//!  t1: Der Text, dessen Vorkommen ersetzt werden sollen
+		//!  t2: Der Text, dessen Inhalt das Vorkommen der Zeichenkette ersetzten soll
+		DLLEXPORT void ersetzen(Text* t1, Text* t2);
+		//! Ersetzt das i-te auftreten eines bestimmten Buchstaben mit einem anderen Buchstaben
+		//! \param i Das wie vielte Auftreten des Buchstabens ersetzt werden soll
+		//!  c1: Der Buchstabe, dessen i-tes Auftreten erstetzt werden soll
+		//!  c2: Der Buchstabe, der das i-te Auftreten des anderen Buchstabens ersetzen soll
+		DLLEXPORT void ersetzen(int i, char c1, char c2);
+		//! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit einer anderen Zeichenkette
+		//! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
+		//!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
+		//!  c2: Die Zeichenkette, die das i-te Auftreten der anderen Zeichenkette ersetzen soll
+		DLLEXPORT void ersetzen(int i, const char* t1, const char* t2);
+		//! Ersetzt das i-te auftreten des Inhalts eines Textes mit einer Zeichenkette
+		//! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
+		//!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
+		//!  c2: Die Zeichenkette, die das i-te Auftreten des Textes ersetzen soll
+		DLLEXPORT void ersetzen(int i, Text* t1, const char* t2);
+		//! Ersetzt das i-te auftreten einer bestimmten Zeichenkette mit dem Inhalt eines Textes
+		//! \param i Das wie vielte Auftreten der Zeichenkette ersetzt werden soll
+		//!  c1: Die Zeichenkette, dessen i-tes Auftreten erstetzt werden soll
+		//!  c2: Der Text, dessen Inhalt das i-te Auftreten der Zeichenkette ersetzen soll
+		DLLEXPORT void ersetzen(int i, const char* t1, Text* t2);
+		//! Ersetzt das i-te auftreten eines bestimmten Textes mit dem Inhalt eines anderen Textes
+		//! \param i Das wie vielte Auftreten des Textes ersetzt werden soll
+		//!  c1: Der Text, dessen i-tes Auftreten erstetzt werden soll
+		//!  c2: Der Text, dessen Inhalt das i-te Auftreten des anderen Textes ersetzen soll
+		DLLEXPORT void ersetzen(int i, Text* t1, Text* t2);
+		//! Löscht den bisherigen Text und erzeugt einen Text, der aus einem Bestimten Buchstaben besteht, mit einer bestimmten Länge
+		//! \param c Der Buchstabe, aus dem der Text bestehen soll
+		//! \param length Die Länge des Textes
+		DLLEXPORT void fillText(char c, int length);
+		//! Löscht ein Bestimmtes Zeichen aus dem Text
+		//! \param p Die Position des zu löschenden Zeichens
+		DLLEXPORT void remove(int p);
+		//! Löscht einen Bestimmten Textabschnitt
+		//!  p1: Die Startposition des zu löschenden Abschnittes
+		//!  p2: Die Endposition des zu löschenden Abschnittes (Das Zeichen bei p2 bleibt erhalten)
+		DLLEXPORT void remove(int p1, int p2);
+		//! Löscht jedes Vorkommen eines bestimmten Buchsaben
+		//! \param c Der Buchstabe, dessen Vorkommen gelöscht werden soll
+		DLLEXPORT void remove(char c);
+		//! Löscht jedes Vorkommen einer bestimmten Zeichenkette
+		//! \param t Die Zeichenkette, deren Vorkommen entfernt werden sollen
+		DLLEXPORT void remove(const char* t);
+		//! Löscht jedes Vorkommen des Inhalts eines Textes
+		//! \param t Der text, dessen Inhalt gelöscht werden soll
+		DLLEXPORT void remove(Text* t);
+		//! Löscht das i-te Vorkommen eines bestimmten Buchstaben
+		//! \param i Das wie vielte Vorkommen des Buchstabens gelöscht werden soll
+		//! \param c Der Buchstabe, dessen i-tes Vorkommen gelöscht werden soll
+		DLLEXPORT void remove(int i, char c);
+		//! Löscht das i-te Vorkommen einer bestimmten Zechenkette
+		//! \param i Das wie vielte Vorkommen der Zeichenkette gelöscht werden soll
+		//! \param t Die Zeichenkette, dessen i-tes Vorkommen gelöscht werden soll
+		DLLEXPORT void remove(int i, const char* t);
+		//! Löscht das i-te Vorkommen eines bestimmten Textinhaltes
+		//! \param i Das wie vielte Vorkommen des Textinhaltes gelöscht werden soll
+		//! \param t Der Text, dessen i-tes Vorkommen gelöscht werden soll
+		DLLEXPORT void remove(int i, Text* t);
+		//! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
+		//! \param pos Die Position des ersten zeichens
+		DLLEXPORT void removeWhitespaceAfter(int pos);
+		//! Löscht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
+		//! \param pos Die Position des ersten zeichens (beginnt bei pos-1)
+		DLLEXPORT void removeWhitespaceBefore(int pos);
+		//! Setzt die Anzahl der Nachkommastellen beim Anhängen von Kommazahlen
+		//! \param p Die Anzahl der Stellen nach dem Komma
+		DLLEXPORT void setPrecision(int p);
+		//! Gibt die Länge des Textes zurück
+		DLLEXPORT int getLength() const;
+		//! Ermittelt die neue Curserposition nachdem Drücken der 'Links' Pfeiltaste
+		//! \param pos Die alte Curserposition
+		DLLEXPORT int getLKick(int pos) const;
+		//! Ermittelt die neue Curserposition nachdem Drücken der 'Oben' Pfeiltaste
+		//! \param pos Die alte Curserposition
+		DLLEXPORT int getOKick(int pos) const;
+		//! Ermittelt die neue Curserposition nachdem Drücken der 'Rechts' Pfeiltaste
+		//! \param pos Die alte Curserposition
+		DLLEXPORT int getRKick(int pos) const;
+		//! Ermittelt die neue Curserposition nachdem Drücken der 'Unten' Pfeiltaste
+		//! \param pos Die alte Curserposition
+		DLLEXPORT int getUKick(int pos) const;
+		//! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
+		//! \param t Der Text, nach dessen Inhalt gesucht werden soll
+		//! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
+		DLLEXPORT bool hat(Text* t) const;
+		//! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
+		//! \param t Die Zeichenkette, nach der gesucht werden soll
+		//! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
+		DLLEXPORT bool hat(const char* t) const;
+		//! Überprüft, ob im Text der Inhalt eines anderen Textes vorkommt
+		//! \param t Der Text, nach dessen Inhalt gesucht werden soll
+		//! \return (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
+		//! \param pos die position an der die zeichenkette im string beginnen soll
+		DLLEXPORT bool hatAt(int pos, Text* t) const;
+		//! Überprüft, ob im Text eine bestimmte Zeichenkette vorkommt
+		//! \param t Die Zeichenkette, nach der gesucht werden soll
+		//! \return (true), wenn die Zeichenkette vorkommt. (false) sonnst
+		//! \param pos die position an der die zeichenkette im string beginnen soll
+		DLLEXPORT bool hatAt(int pos, const char* t) const;
+		//! Überprüft, ob im Text ein bestimmtes Zeichen vorkommt
+		//! \param c Das Zeichen, nach dem gesucht werden soll
+		//! \return (true), wenn das Zeichen vorkommt. (false) sonnst
+		DLLEXPORT bool hat(char c) const;
+		//! Überprft, ob der Text den selben Inhalt wie eine Zeichenkette hat
+		//! \param t Die Zeichenkette, die verglichen werden soll
+		//! \return (true), wenn der Inhalt des Textes gleich der Zeichenkette ist. (false) sonst
+		DLLEXPORT bool istGleich(const char* t) const;
+		//! Überprft, ob der Text den selben Inhalt wie ein anderer Text hat
+		//! \param t Der Text, dessen Inhalt verglichen werden soll
+		//! \return (true), wenn die Inhalte der Texte übereinstimmen. (false) sonst
+		DLLEXPORT bool istGleich(Text* t) const;
+		//! Gibt den Inhalt des Textes als Zeichenkette zurück
+		DLLEXPORT char* getText() const;
+		//! Zählt, wie oft ein bestimmter Buchstabe im Text vorkomt
+		//! \param c Der Buchstabe, der gezählt werden soll
+		//! \return Die Anzahl des Buchstabens im Text
+		DLLEXPORT int anzahlVon(char c) const;
+		//! Zählt, wie oft eine bestimmte Zeichenkette im Text vorkommt
+		//! \param t Die Zeichenkette, die gezählt werden soll
+		//! \return Die Anzahl der Zeichenkette im Text
+		DLLEXPORT int anzahlVon(const char* t) const;
+		//! Zählt, wie oft der Inhalt eines Textest im Text vorkommt
+		//! \param t Der Text, dessen Inhalt gezählt werden soll
+		//! \return Die Anzahl des Textinhaltes im Text
+		DLLEXPORT int anzahlVon(Text* t) const;
+		//! Gibt die erste Position eines bestimmten Buchstabens im Text zurück
+		//! \param c Der Buchstabe, der gefunden werden soll
+		//! \return Die Position des ersten Vorkommens des Buchstabens
+		DLLEXPORT int positionVon(char c) const;
+		//! Gibt die erste Position einer bestimmten Zeichenkette im Text zurück
+		//! \param t Die Zeichenkette, die gefunden werden soll
+		//! \return Die Position des ersten Vorkommens der Zeichenkette
+		DLLEXPORT int positionVon(const char* t) const;
+		//! Gibt die erste Position eines Textinhaltes im Text zurück
+		//! \param t Der Text, dessen Inhalt gefunden werden soll
+		//! \return Die Position des ersten Vorkommens des Textinhaltes
+		DLLEXPORT int positionVon(Text* t) const;
+		//! Gibt die i-te Position eines bestimmten Buchstabens im Text zurück
+		//! \param c Der Buchstabe, der gefunden werden soll
+		//! \param i Das wievielte Vorkommen gefunden werden soll
+		//! \return Die Position des i-ten Vorkommens des Buchstabens
+		DLLEXPORT int positionVon(char c, int i) const;
+		//! Gibt die i-te Position einer bestimmten Zeichenkette im Text zurück
+		//! \param t Die Zeichenkette, die gefunden werden soll
+		//! \param i Das wievielte Vorkommen gefunden werden soll
+		//! \return Die Position des i-ten Vorkommens der Zeichenkette
+		DLLEXPORT int positionVon(const char* t, int i) const;
+		//! Gibt die i-te Position eines Textinhaltes im Text zurück
+		//! \param t Der Text, dessen Inhalt gefunden werden soll
+		//! \param i Das wievielte Vorkommen gefunden werden soll
+		//! \return Die Position des i-ten Vorkommens des Textinhaltes
+		DLLEXPORT int positionVon(Text* t, int i) const;
+		//! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
+		//!  p1: Die Startposition des Textabschnittes
+		//!  p2: Die Endposition des Textabschnittes (nicht enthalten)
+		DLLEXPORT Text* getTeilText(int p1, int p2) const;
+		//! Gibt einen Text zurück, der eine Kopie eines bestimmten Textabschnittes enthält
+		//!  p1: Die Startposition des Textabschnittes (Der Textabschnitt geht bis ans Ende des Textes)
+		DLLEXPORT Text* getTeilText(int p) const;
+		// berechnet den Hash code des textes
+		DLLEXPORT int hashCode() const;
+		//! Hängt eine Zahl ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const int num);
+		//! Hängt eine Zahl ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const __int64 num);
+		//! Hängt eine Kommazahl ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const double num);
+		//! Hängt eine Kommazahl ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const float num);
+		//! Hängt eine Zeichenkette ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const char* txt);
+		//! Hängt eine Kopie des Inhalts eines Textes ans Ende des Textes an
+		DLLEXPORT Text& operator+=(const Text& txt);
+		//! Setzt den Inhalt des Textes gleich einer Zahl
+		DLLEXPORT Text& operator=(const int num);
+		//! Setzt den Inhalt des Textes gleich einer Kommazahl
+		DLLEXPORT Text& operator=(const double num);
+		//! Setzt den Inhalt des Textes gleich einer Kommazahl
+		DLLEXPORT Text& operator=(const float num);
+		//! Setzt den Inahlt des Textes gleich einer Zeichenkette
+		DLLEXPORT Text& operator=(const char* txt);
+		//! Setzt den Inhalt des Textes gleich einer Kopie des Inhalts eines anderen Textes
+		DLLEXPORT Text& operator=(const Text& txt);
+		//! Gibt den Inhalt des Textes als Zeichenkette zurück
+		DLLEXPORT operator char* () const;
+		//! Konviertiert den Inhalt des Textes zu einer Zahl
+		DLLEXPORT operator int() const;
+		//! Konviertiert den Inhalt des Textes zu einer Zahl
+		DLLEXPORT operator __int64() const;
+		//! Konviertiert den Inhalt des Textes zu einer Kommazahl
+		DLLEXPORT operator double() const;
+		//! Konviertiert den Inhalt des Textes zu einer Kommazahl
+		DLLEXPORT operator float() const;
+		//! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung später kommt als der Inhalt eines anderen Textes
+		DLLEXPORT bool operator>(Text& t) const;
+		//! Prüft, ob der Inhalt des Textes nach alphabetischer Ordnung früher kommt als der Inhalt eines anderen Textes
+		DLLEXPORT bool operator<(Text& t) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und t2
+		DLLEXPORT Text operator+(const Text& t2) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und t2
+		DLLEXPORT Text operator+(const char* t2) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und num
+		DLLEXPORT Text operator+(const int num) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und num
+		DLLEXPORT Text operator+(const __int64 num) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und num
+		DLLEXPORT Text operator+(const double num) const;
+		//! Erstellt einen neuen Text bestehend aus diesem und num
+		DLLEXPORT Text operator+(const float num) const;
+		//! Prüft ob der Text mit dem anderen Text übereinstimmt
+		DLLEXPORT bool operator==(const Text& right) const;
+	};
 
-    class TextReader : public Reader, public virtual ReferenceCounter
-    {
-    private:
-        Text *txt;
-        __int64 lPos;
+	class TextReader : public Reader, public virtual ReferenceCounter
+	{
+	private:
+		Text* txt;
+		__int64 lPos;
 
-    public:
-        //! Konstructor
-        //! \param txt Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
-        DLLEXPORT TextReader( Text *txt );
-        //! Destructor
-        DLLEXPORT virtual ~TextReader();
-        //! Setzt die Position des Bytes, das als nächstes gelesen werden soll
-        //! \param pos Der Index des Bytes
-        //! \param ende 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
-        DLLEXPORT void setLPosition( __int64 pos, bool ende ) override;
-        //! Ließt aus der Datei
-        //! \param bytes Ein Array, der mit Bytes aus dem Text gefüllt werden soll
-        //! \param len Wie viele Bytes aus dem Text gelesen werden sollen
-        DLLEXPORT void lese( char *bytes, int len ) override;
-        //! Ließt die nächste zeile des Textes ein
-        //! \return Die gelesene Zeile als Text mit zeilenumbruch
-        DLLEXPORT Text *leseZeile() override;
-        //! Prüft, ob die Resource vollständig gelesen wurde
-        //!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
-        DLLEXPORT bool istEnde() const override;
-        //! Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
-        //! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
-        DLLEXPORT __int64 getLPosition() const override;
-        //! Gibt die Anzahl der zu lesenden Bytes zurück
-        DLLEXPORT __int64 getSize() const override;
-    };
+	public:
+		//! Konstructor
+		//! \param txt Der Text der gelesen werden soll. Er wird nicht kopiert sondern direkt gelesen.
+		DLLEXPORT TextReader(Text* txt);
+		//! Destructor
+		DLLEXPORT virtual ~TextReader();
+		//! Setzt die Position des Bytes, das als nächstes gelesen werden soll
+		//! \param pos Der Index des Bytes
+		//! \param ende 1, wenn der Index vom ende des Textes zählt. 0, wenn der Index vom Beginn des Textes zählt
+		DLLEXPORT void setLPosition(__int64 pos, bool ende) override;
+		//! Ließt aus der Datei
+		//! \param bytes Ein Array, der mit Bytes aus dem Text gefüllt werden soll
+		//! \param len Wie viele Bytes aus dem Text gelesen werden sollen
+		DLLEXPORT void lese(char* bytes, int len) override;
+		//! Ließt die nächste zeile des Textes ein
+		//! \return Die gelesene Zeile als Text mit zeilenumbruch
+		DLLEXPORT Text* leseZeile() override;
+		//! Prüft, ob die Resource vollständig gelesen wurde
+		//!  return 1, wenn die Resource vollständig gelesen wurde. 0, sonst
+		DLLEXPORT bool istEnde() const override;
+		//! Gibt den Index des Bytes aus dem Text zurück, welches als nächstes gelesen werden würde
+		//! return -1, falls ein Fehler aufgetreten ist. Sonst die Position des Lesezeigers
+		DLLEXPORT __int64 getLPosition() const override;
+		//! Gibt die Anzahl der zu lesenden Bytes zurück
+		DLLEXPORT __int64 getSize() const override;
+	};
 
-    //! Durchsucht eine Zeichenkette nach dem num-ten Vorkommen eines bestimmten Buchstabens
-    //! \param string Die zu durchsuchende Zeichenkette
-    //! \param c Der zu suchende Buchstabe
-    //! \param num Das wievielte Vorkommen des Buchtaben gefunden werden soll
-    //! \return (-1), wenn es kein num-tes Vorkommen des Buchstaben gibt. Sonst die Position des num-ten Vorkommens in der Zeichenkette
-    DLLEXPORT int stringPositionVonChar( char *string, char c, int num ); //! sucht die position des num-ten c-s in string, -1 bei nicht gefunden
-    //! Durchsucht eine Zeichenkette nach einer Anderen Zeichenkette
-    //! \param string Die zu durchsuchende Zeichenkette
-    //! \param suche Die Zeichenkette, nach der gesucht werden soll
-    //! \param sBegPos Die Position, ab der die Suche begonnen werden soll
-    //! \return Die Position, an der die zu suchende Zeichenkette erstmals gefunden wurde. (-1) Wenn nichts gefunden wurde.
-    DLLEXPORT int stringPositionVonString( char *string, char *suche, int sBegPos );
+	//! Durchsucht eine Zeichenkette nach dem num-ten Vorkommen eines bestimmten Buchstabens
+	//! \param string Die zu durchsuchende Zeichenkette
+	//! \param c Der zu suchende Buchstabe
+	//! \param num Das wievielte Vorkommen des Buchtaben gefunden werden soll
+	//! \return (-1), wenn es kein num-tes Vorkommen des Buchstaben gibt. Sonst die Position des num-ten Vorkommens in der Zeichenkette
+	DLLEXPORT int stringPositionVonChar(char* string, char c, int num); //! sucht die position des num-ten c-s in string, -1 bei nicht gefunden
+	//! Durchsucht eine Zeichenkette nach einer Anderen Zeichenkette
+	//! \param string Die zu durchsuchende Zeichenkette
+	//! \param suche Die Zeichenkette, nach der gesucht werden soll
+	//! \param sBegPos Die Position, ab der die Suche begonnen werden soll
+	//! \return Die Position, an der die zu suchende Zeichenkette erstmals gefunden wurde. (-1) Wenn nichts gefunden wurde.
+	DLLEXPORT int stringPositionVonString(char* string, char* suche, int sBegPos);
 
-    //! Kopiert eine bestimmte Zeichenkette in die Zwischenablage des Betriebssystems
-    //! \param txt Die Zeichenkette, die kopiert werden soll
-    DLLEXPORT void TextKopieren( const char *txt );
-    //! Ermittelt, ob in der Zwischenablage des Betriebssystems eine Zeichenkette steht.
-    //! \return Die Zeichenkette aus der Zwischenablage. Wenn keine Zeichenkette kopiert wurde, wird eine lehre Zeichenkette zurückgegeben.
-    DLLEXPORT char *TextInsert();
-    //! Wandelt einen bestimmten schreibbaren Buchstaben in einen Groß- oder Kleinbuchstaben um
-    //! \param c Der Buchstabe, der umgewandelt werden soll
-    //! \param groß Wenn (true), so wird der Buchstabe in einen Großbuchstaben umgewandelt. Wenn (false), wird er in einen Kleinbuchstaben umgewandelt.
-    //! \return Den umgewandelten Buchstaben
-    DLLEXPORT char smallOrBig( char c, bool big );
-    //! Ermittelt, ob ein Buchstabe ein schreibbares Zeichen ist
-    //! \param zeichen Der Buchstabe, der geprüft werden soll
-    //! \return (true), wenn der Buchstabe gezeichnet werden kann. (false) sonnst
-    DLLEXPORT bool istSchreibbar( unsigned char zeichen );
-    //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
-    //! \param c Die Zeichenkette, in der Die Zahl steht
-    //! \param system Die Basis der Zahl
-    //! \return Die Zahl, die im Text stand
-    DLLEXPORT unsigned int TextZuInt( char *c, int system );
-    //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
-    //! \param c Die Zeichenkette, in der Die Zahl steht
-    //!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
-    //! \param system Die Basis der Zahl
-    //! \return Die Zahl, die im Text stand
-    DLLEXPORT unsigned int TextZuInt( char *c, char **c_ende, int system );
-    //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
-    //! \param c Die Zeichenkette, in der Die Zahl steht
-    //! \param system Die Basis der Zahl
-    //! \return Die Zahl, die im Text stand
-    DLLEXPORT unsigned __int64 TextZuInt64( char *c, int system );
-    //! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
-    //! \param c Die Zeichenkette, in der Die Zahl steht
-    //!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
-    //! \param system Die Basis der Zahl
-    //! \return Die Zahl, die im Text stand
-    DLLEXPORT unsigned __int64 TextZuInt64( char *c, char **c_ende, int system );
-    //! Konvertiert eine Zeichenkette zu einem Double
-    //! \param c Die Zeichenkette, die konvertiert werden soll
-    //! \return Das double, was in der Zeichenkette stand
-    DLLEXPORT double TextZuDouble( char *c );
-    //! Konvertiert eine Zeichenkette zu einem Float
-    //! \param c Die Zeichenkette, die konvertiert werden soll
-    //! \return Das float, was in der Zeichenkette stand
-    DLLEXPORT float TextZuFloat( char *c );
-    //! Konvertiert eine Zeichenkette zu einem Double
-    //! \param c Die Zeichenkette, die konvertiert werden soll
-    //!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem Double in der Zeichenkette
-    //! \return Das double, was in der Zeichenkette stand
-    DLLEXPORT double TextZuDouble( char *c, char **c_ende );
-    //! Konvertiert eine Zeichenkette zu einem float
-    //! \param c Die Zeichenkette, die konvertiert werden soll
-    //!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem float in der Zeichenkette
-    //! \return Das float, was in der Zeichenkette stand
-    DLLEXPORT float TextZuFloat( char *c, char **c_ende );
-    //! Ermittelt die Länge einer bestimmten Zeichenkette
-    //! \param txt Die Zeichenkette, deren Länge ermittelt werden soll
-    //! \return Die Länge der Zeichenkette
-    DLLEXPORT int textLength( const char *txt );
+	//! Kopiert eine bestimmte Zeichenkette in die Zwischenablage des Betriebssystems
+	//! \param txt Die Zeichenkette, die kopiert werden soll
+	DLLEXPORT void TextKopieren(const char* txt);
+	//! Ermittelt, ob in der Zwischenablage des Betriebssystems eine Zeichenkette steht.
+	//! \return Die Zeichenkette aus der Zwischenablage. Wenn keine Zeichenkette kopiert wurde, wird eine lehre Zeichenkette zurückgegeben.
+	DLLEXPORT char* TextInsert();
+	//! Wandelt einen bestimmten schreibbaren Buchstaben in einen Groß- oder Kleinbuchstaben um
+	//! \param c Der Buchstabe, der umgewandelt werden soll
+	//! \param groß Wenn (true), so wird der Buchstabe in einen Großbuchstaben umgewandelt. Wenn (false), wird er in einen Kleinbuchstaben umgewandelt.
+	//! \return Den umgewandelten Buchstaben
+	DLLEXPORT char smallOrBig(char c, bool big);
+	//! Ermittelt, ob ein Buchstabe ein schreibbares Zeichen ist
+	//! \param zeichen Der Buchstabe, der geprüft werden soll
+	//! \return (true), wenn der Buchstabe gezeichnet werden kann. (false) sonnst
+	DLLEXPORT bool istSchreibbar(unsigned char zeichen);
+	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
+	//! \param c Die Zeichenkette, in der Die Zahl steht
+	//! \param system Die Basis der Zahl
+	//! \return Die Zahl, die im Text stand
+	DLLEXPORT unsigned int TextZuInt(char* c, int system);
+	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
+	//! \param c Die Zeichenkette, in der Die Zahl steht
+	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
+	//! \param system Die Basis der Zahl
+	//! \return Die Zahl, die im Text stand
+	DLLEXPORT unsigned int TextZuInt(char* c, char** c_ende, int system);
+	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
+	//! \param c Die Zeichenkette, in der Die Zahl steht
+	//! \param system Die Basis der Zahl
+	//! \return Die Zahl, die im Text stand
+	DLLEXPORT unsigned __int64 TextZuInt64(char* c, int system);
+	//! Konvertiert eine Zahl aus einer Zeichenkette in belibiger Basis zu einer Zahl
+	//! \param c Die Zeichenkette, in der Die Zahl steht
+	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Zeigt auf das nächste Zeichen in der Zeichenkette, das nach der Zah steht
+	//! \param system Die Basis der Zahl
+	//! \return Die Zahl, die im Text stand
+	DLLEXPORT unsigned __int64 TextZuInt64(char* c, char** c_ende, int system);
+	//! Konvertiert eine Zeichenkette zu einem Double
+	//! \param c Die Zeichenkette, die konvertiert werden soll
+	//! \return Das double, was in der Zeichenkette stand
+	DLLEXPORT double TextZuDouble(char* c);
+	//! Konvertiert eine Zeichenkette zu einem Float
+	//! \param c Die Zeichenkette, die konvertiert werden soll
+	//! \return Das float, was in der Zeichenkette stand
+	DLLEXPORT float TextZuFloat(char* c);
+	//! Konvertiert eine Zeichenkette zu einem Double
+	//! \param c Die Zeichenkette, die konvertiert werden soll
+	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem Double in der Zeichenkette
+	//! \return Das double, was in der Zeichenkette stand
+	DLLEXPORT double TextZuDouble(char* c, char** c_ende);
+	//! Konvertiert eine Zeichenkette zu einem float
+	//! \param c Die Zeichenkette, die konvertiert werden soll
+	//!  c_ende: Wird duch die Funktion gesetzt und darf 0 sein. Ein Zeiger auf das nächste Zeichen nach dem float in der Zeichenkette
+	//! \return Das float, was in der Zeichenkette stand
+	DLLEXPORT float TextZuFloat(char* c, char** c_ende);
+	//! Ermittelt die Länge einer bestimmten Zeichenkette
+	//! \param txt Die Zeichenkette, deren Länge ermittelt werden soll
+	//! \return Die Länge der Zeichenkette
+	DLLEXPORT int textLength(const char* txt);
 }
 #endif