KSG-uebernehmen/übernehmen/Text.cpp

//---Include---
#include "Text.h"
#include <sstream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <Windows.h>

using namespace Framework;

// inhalt der Text Klasse aus Text.h
// Konstruktor 
Text::Text()
{
	txt = 0;
	ref = 1;
}

Text::Text( const char *t )
{
	txt = 0;
	setText( t ); // Text setzen
	ref = 1;
}

// Destruktor 
Text::~Text()
{
	delete []txt;
}

// nicht constant 
void Text::setText( const char *t ) // ersetzt den Text
{
	delete []txt; // alter Text löschen
	int l = (int)strlen( t ); // Länge des neuen Textes ermitteln
	txt = new char[ 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
{
	delete []txt; // alter Text löschen
	txt = new char[ 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 )
{
	setText( t->getText() ); // Text setzen
	t = t->release(); // übergabe loslassen
}

void Text::anhängen( const char *t ) // hängt an den Text an
{
	int tl = (int)strlen( t ); // länge der übergabe
	int txl = getLänge(); // länge des Textes
	char *res = new char[ 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::anhängen( const char *t, int l ) // hängt an den Text an
{
	int txl = getLänge(); // länge des Textes
	char *res = new char[ 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::anhängen( Text *t )
{
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		anhängen( t->getText() ); // Text anhängen
	t = t->release(); // Übergabe loslassen
}

void Text::anhängen( int num )
{
	std::stringstream ss;
	ss << num;
	anhängen( ss.str().c_str() );
}

void Text::anhängen( unsigned int num )
{
	std::stringstream ss;
	ss << num;
	anhängen( ss.str().c_str() );
}

void Text::einfügen( int p, char c ) // Fügt an stelle p ein
{
	if( p > getLänge() || p < 0 ) // Auf unsinnige übergabe prüfen
		return;
	int txl = getLänge(); // Länge des Textes
	char *res = new char[ 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::einfügen( int p, const char *t ) // Fügt an stelle p ein
{
	if( p >= getLänge() || p < 0 || strlen( t ) <= 0 ) // Auf unsinnige übergabe prüfen
		return;
	int tl = (int)strlen( t ); // Länge der übergabe
	int txl = getLänge(); // Länge des Textes
	char *res = new char[ 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::einfügen( int p, Text *t )
{
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		einfügen( p, t->getText() ); // Text einfügen
	t = 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;
	}
	löschen( p1, p2 ); // Textabschnitt von p1 zu p2 löschen
	einfügen( p1, t ); // Übergabe bei p1 einfügen
}

void Text::ersetzen( int p1, int p2, Text *t )
{
	if( t->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( p1, p2, t->getText() ); // Text ersetzen
	t = 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 = getLänge(); // Text Länge
	for( int i = 0; i < l; i++ ) // Text durchsuchen
		if( txt[ i ] == c1 )
			txt[ i ] = c2; // Text ersetzen
}

void Text::ersetzen( const char *t1, const char *t2 ) // ersetzt jedes t1 durch t2
{
	int txl = getLänge(); // Text Länge
	int t1l = (int)strlen( t1 ); // Länge der Übergaben
	int t2l = (int)strlen( 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( last == begin[ rep ] ) // Text ersetzen
		{
			last = end[ rep ];
			rep++;
			for( int ii = 0; ii < t2l; ii++ )
			{
				res[ neu ] = t2[ ii ];
				neu++;
			}
			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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( t1->getText(), t2 ); // ersetzen
	t1 = t1->release(); // Übergabe loslassen
}

void Text::ersetzen( const char *t1, Text *t2 )
{
	if( t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( t1, t2->getText() ); // ersetzen
	t2 = t2->release(); // Übergabe loslassen
}

void Text::ersetzen( Text *t1, Text *t2 )
{
	if( t1->getLänge() > 0 && t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( t1->getText(), t2->getText() ); // ersetzen
	t1 = t1->release(); // Übergaben loslassen
	t2 = 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 l = getLänge(); // Text Länge
	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 = getLänge(); // Text Länge
	int t1l = (int)strlen( t1 ); // Länge der Übergaben
	int t2l = (int)strlen( t2 );
	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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( i, t1->getText(), t2 ); // ersetzen
	t1 = t1->release(); // Übergabe loslassen
}

void Text::ersetzen( int i, const char *t1, Text *t2 )
{
	if( t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( i, t1, t2->getText() ); // ersetzen
	t2 = t2->release(); // Übergabe loslassen
}

void Text::ersetzen( int i, Text *t1, Text *t2 )
{
	if( t1->getLänge() > 0 || t2->getLänge() >= 0 ) // Auf unsinnige übergabe prüfen
		ersetzen( i, t1->getText(), t2->getText() ); // ersetzen
	t1 = t1->release(); // Übergaben loslassen
	t2 = t2->release();
}

void Text::füllText( char c, int län ) // setzt den Text zu so vielen c wie län groß ist
{
	char *res = new char[ län + 1 ];
	for( int i = 0; i < län; i++ )
		res[ i ] = c;
	res[ län ] = '\0';
	setText( res );
	delete []res;
}

void Text::löschen( int p ) // löscht p
{
	int l = getLänge(); // 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 ++ ) // 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::löschen( int p1, int p2 ) // löscht von p1 zu p2 ( p2 bleibt )
{
	if( p1 > p2 ) // p1 und p2 tauschen
	{
		int x = p1;
		p1 = p2;
		p2 = x;
	}
	int l = getLänge(); // Länge des Testes
	if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
		return;
	int resl = l - ( p2 - p1 ); // Länge vom Ergebnis
	char *res = new char[ 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::löschen( char c ) // löscht jetes c
{
	if( !hat( c ) ) // prüfen ob c vorhanden
		return;
	int l = getLänge(); // Länge des Textes
	int anz = anzahlVon( c ); // Anzahl von c
	char *res = new char[ l - anz + 1 ]; // neuen Text erstellen
	anz = 0;
	for( int i = 0; i < l; i++ ) // Text befüllen
		if( txt[ i ] == c )
			anz++;
		else
			res[ i - anz ] = txt[ i ];
	res[ l - anz ] = '\0'; // Textende festlegen
	setText( res ); // Text setzen
	delete []res; // Speicher freigeben
}

void Text::löschen( const char *t ) // löscht jetes t
{
	int tl = (int)strlen( t ); // Länge der Übergabe
	int txl = getLänge(); // 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[ resl + 1 ]; // neuen Text erzeugen
	int del = 0;
	for( int i = 0; i < txl; i++ ) // Text befüllen
	{
		if( 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::löschen( Text *t )
{
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		löschen( t->getText() ); // löschen
	t = t->release(); // Übergabe loslassen
}

void Text::löschen( 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
	int l = getLänge(); // Länge des Textes
	char *res = new char[ l ]; // neuen Text erzeugen
	for( int i = 0; i < pos; 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::löschen( int index, const char *t ) // löscht das i-te t
{
	int tl = (int)strlen( 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
	int l = getLänge(); // Länge des Textes
	char *res = new char[ l - tl + 1 ]; // neuen Text erzeugen
	for( int i = 0; i < pos; i++ ) // Text befüllen
		res[ i ] = txt[ i ];
	for( int i = pos + tl; i < l; i++ )
		res[ i - 1 ] = txt[ i ];
	res[ l - tl ] = '\0'; // Text ende festlegen
	setText( res ); // Text setzen
	delete []res; // Speicher freigeben
}

void Text::löschen( int i, Text *t )
{
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		löschen( i, t->getText() ); // löschen
	t = t->release(); // Übergabe loslassen
}

// constant 
int Text::getLänge() const // gibt die Text länge zurück
{
	if( !txt )
		return -1;
	int ret = 0;
	for( ; txt[ ret ] != '\0'; ret++ ); // zählen
	return ret;
}

int Text::getLKick( int pos )
{
	if( txt[ pos - 1 ] == ' ' )
	{
		int ret = 1;
		for( ; ret < pos && txt[ pos - ret - 1 ] == ' ' && txt[ pos + ret ] != '\n'; ret++ );
		return pos - ret;
	}
	else
	{
		int ret = 1;
		for( ; ret < pos && txt[ pos - ret - 1 ] != ' ' && txt[ pos + ret ] != '\n'; ret++ );
		return pos - ret;
	}
}

int Text::getOKick( int pos )
{
	if( !hat( '\n' ) )
		return 0;
	int lpos = 1;
	while( txt[ pos - lpos ] != '\n' && pos - lpos >= 0 )
		lpos++;
	int vllän = 0;
	while( txt[ pos - lpos - vllän - 1 ] != '\n' && pos - lpos - vllän - 1 >= 0 )
		vllän++;
	if( !vllän ||vllän < lpos )
		return pos - lpos;
	return pos - lpos - ( vllän - lpos ) - 1;
}

int Text::getRKick( int pos )
{
	int tl = getLänge();
	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 )
{
	if( !hat( '\n' ) )
		return getLänge();
	int lpos = 0;
	while( txt[ pos - lpos - 1 ] != '\n' && pos - lpos >= 0 )
		lpos++;
	int llän = 0;
	while( txt[ pos + llän ] != '\n' && pos + llän < getLänge() )
		llän++;
	int vllän = 0;
	while( txt[ pos + llän + vllän + 1 ] != '\n' && pos + llän + vllän + 1 < getLänge() )
		vllän++;
	if( !vllän )
		return pos + llän;
	if( vllän < lpos )
		return pos + llän + vllän + 1;
	return pos + llän + lpos;
}

bool Text::hat( Text *t ) const // enthält der Text t
{
	bool ret = 0;
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		ret = hat( t->getText() ); // prüfen
	t = t->release(); // Übergabe loslassen
	return ret;
}

bool Text::hat( const char *t ) const
{
	int tl = (int)strlen( t ); // Länge der Übergabe
	int txl = getLänge(); // Länge des Textes
	if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
		return 0;
	for( int i = 0; i + tl <= txl; i++ ) // Text durchsuchen
	{
		bool b = 1;
		for( int ii = 0; ii < tl; ii++ ) // Text überprüfen
			if( b )
				b = txt[ i + ii ] == t[ ii ];
		if( b )
			return 1;
	}
	return 0;
}

bool Text::hat( char c ) const // enthält c
{
	int l = getLänge(); // Text Länge
	bool ret = 0;
	for( int i = 0; i < l; i++ ) // suchen
		if( !ret ) // ü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 = getLänge(); // Text Länge
	int tl = (int)strlen( 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
		if( ret )
			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 = getLänge(); // Text Länge
	for( int i = 0; i < l; i++ ) // suchen
		if( txt[ i ] == c ) // überprüfen
			ret++; // zählen
	return ret;
}

int Text::anzahlVon( const char *t ) const // gibt die Anzahl von t im Text zurück
{
	int tl = (int)strlen( t ); // Länge der Übergabe
	int txl = getLänge(); // Länge des Textes
	if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
		return 0;
	int ret = 0;
	for( int i = 0; i + tl <= txl; i++ ) // suchen
	{
		bool b = 1;
		for( int ii = 0; ii < tl; ii++ ) // überprüfen
			if( b )
				b = txt[ i + ii ] == t[ ii ];
		if( b )
			ret++; // zählen
	}
	return ret;
}

int Text::anzahlVon( Text *t ) const
{
	int ret = 0;
	if( t->getLänge() > 0 )  // Auf unsinnige übergabe prüfen
		ret = anzahlVon( t->getText() ); // zählen
	t = t->release(); // Übergabe loslassen
	return ret;
}

int Text::positionVon( char c ) const // gibt die Position des ersten c zurück
{
	int l = getLänge(); // Text Länge
	for( int i = 0; i < l; i++ ) // suchen
		if( txt[ i ] == c ) // überprüfen
			return i;
	return -1;
}

int Text::positionVon( const char *t ) const // gibt die Position des ersten t zurück
{
	int tl = (int)strlen( t ); // Länge der Übergabe
	int txl = getLänge(); // 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 = txt[ i + ii ] == t[ ii ];
		if( b )
			return i;
	}
	return -1;
}

int Text::positionVon( Text *t ) const
{
	int ret = 0;
	if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		ret = positionVon( t->getText() ); // position ermitteln
	t = 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 = getLänge(); // Text Länge
	int ii = 0;
	for( int i = 0; i < l; i++ ) // suchen
		if( txt[ i ] == c ) // ü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)strlen( t ); // Länge der Übergabe
	int txl = getLänge(); // Länge des Textes
	if( tl <= 0 || tl > txl ) // Auf unsinnige übergabe prüfen
		return 0;
	int i2 = 0;
	for( int i = 0; i + tl <= txl; i++ ) // suchen
	{
		bool b = 1;
		for( int ii = 0; ii < tl; ii++ ) // überprüfen
			if( b )
				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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
		ret = positionVon( t->getText(), i ); // position ermitteln
	t = 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 = getLänge(); // Text Länge
	if( p1 < 0 || p2 > l ) // Auf unsinnige übergabe prüfen
		return new Text( "" );
	char *cp = new char[ 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, getLänge() ); // Text zurückgeben
}

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

Text *Text::release()
{
	ref--;
	if( ref < 1 )
		delete this;
	return 0;
}

// inhalt der TextArray Klasse aus Text.h
// konstruktor 
TextArray::TextArray()
{
	This = 0;
	next = 0;
	index = 0;
}

// destruktor 
TextArray::~TextArray()
{
	if( next )
		delete next;
}

// nicht constant 
void TextArray::addText( Text *txt ) // fügt einen Text hinzu
{
	if( !This )
	{
		This = txt;
		return;
	}
	if( !next )
		next = new TextArray();
	next->addText( txt );
}

void TextArray::addText( const char *txt )
{
	Text *text = new Text( txt );
	addText( text );
}

bool TextArray::löscheText( Text *txt, bool eins ) // löscht einen Text
{
	if( This == txt )
	{
		This = This->release();
		txt->release();
		if( eins && next )
		{
			This = next->getThis();
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
		return 1;
	}
	if( next )
	{
		if( next->löscheText( txt, 0 ) )
		{
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
	}
	return 0;
}

bool TextArray::löscheText( unsigned char *txt, bool eins )
{
	if( This->istGleich( (const char *)&txt ) )
	{
		This = This->release();
		if( eins && next )
		{
			This = next->getThis();
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
		return 1;
	}
	if( next )
	{
		if( next->löscheText( txt, 0 ) )
		{
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
	}
	return 0;
}

bool TextArray::löscheText( int index, bool eins )
{
	if( this->index == index )
	{
		This = This->release();
		if( eins && next )
		{
			This = next->getThis();
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
		return 1;
	}
	if( next )
	{
		next->setIndex( this->index + 1 );
		if( next->löscheText( index, 0 ) )
		{
			TextArray *tmp = next->getNext();
			next->setNext0();
			delete next;
			next = tmp;
		}
	}
	return 0;
}

void TextArray::setNext0() // setzt den next Zeiger auf null
{
	next = 0;
}

void TextArray::setIndex( int i ) // setzt den index
{
	index = i;
}

// constant 
Text *TextArray::getText( int index ) const // gibt den i-ten Text zurück
{
	if( this->index == index )
		return This->getThis();
	if( next )
	{
		next->setIndex( this->index + 1 );
		return next->getText( index );
	}
	return 0;
}

Text *TextArray::zText( int index ) const
{
	if( this->index == index )
		return This;
	if( next )
	{
		next->setIndex( this->index + 1 );
		return next->getText( index );
	}
	return 0;
}

TextArray *TextArray::getNext() const // gibt den next Zeiger zurück
{
	return next;
}

Text *TextArray::getThis() const // gibt den This zeiger zurück
{
	return This;
}

//---Andere Funktionen---
void Framework::ZuWCharT( const char *txt, wchar_t *res ) // wandelt in wchar_t um
{
	for( unsigned int i = 0; i < strlen( txt ); i++ )
	{
		switch( txt[ i ] )
		{
		case 'ü':
			res[ i ] = L'ü';
			break;
		case 'ö':
			res[ i ] = L'ö';
			break;
		case 'ä':
			res[ i ] = L'ä';
			break;
		case 'ß':
			res[ i ] = L'ß';
			break;
		default:
			res[ i ] = ( wchar_t )txt[ i ];
		}
	}
	res[ strlen( txt ) ] = '\0';
}

void Framework::ZuChar( const wchar_t *txt, char *res ) // wandelt in char um
{
	for( unsigned int i = 0; i < wcslen( txt ); i++ )
	{
		switch( txt[ i ] )
		{
		case L'ü':
			res[ i ] = 'ü';
			break;
		case L'ö':
			res[ i ] = 'ö';
			break;
		case L'ä':
			res[ i ] = 'ä';
			break;
		case L'ß':
			res[ i ] = 'ß';
			break;
		default:
			res[ i ] = ( char )txt[ i ];
		}
	}
	res[ wcslen( txt ) ] = '\0';
}

char Framework::KleinOrGroß( 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 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 == ' ' )
		return 1;
	return 0;
}

unsigned int Framework::TextZuInt( char *c, int system ) // Konvertiert c zu int
{
	return strtol( c, 0, system );
}

unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
{
	return strtol( c, c_ende, system );
}

char *Framework::convert( char *txt, int *error, int *len ) // konvertiert den Text
{
	*len = 0;
	*error = 0;
	int l = (int)strlen( txt );
	int ll = ( ( l * 5 ) / 9 ) == ( ( l * 5.0 ) / 9.0 ) ? ( ( l * 5 ) / 9 ) : ( ( l * 5 ) / 9 + 1 );
	char *ret = new char[ ll + 1 ];
	int bbeg = 0;
	for( int i = 0; i < 15; i++ )
	{
		char c = txt[ i + *error ];
		if( c == '\0' )
			break;
		if( c > 96 && c < 123 )
			c -= 96;
		else if( c > 64 && c < 91 )
			c -= 64;
		else if( c == 'ü' || c == 'Ü' )
			c = 27;
		else if( c == 'ö' || c == 'Ö' )
			c = 28;
		else if( c == 'ä' || c == 'Ä' )
			c = 29;
		else if( c == 'ß' )
			c = 30;
		else if( c == '.' )
			c = 31;
		else
		{
			*error++;
			i--;
			continue;
		}
		*len++;
		switch( i )
		{
		case 0:
			ret[ 0 ] = c << 3;
			break;
		case 1:
			ret[ 0 ] |= c >> 2;
			ret[ 1 ] = c << 6;
			break;
		case 2:
			ret[ 1 ] |= c << 1;
			break;
		case 3:
			ret[ 1 ] |= c >> 4;
			ret[ 2 ] = c << 5;
			break;
		case 4:
			ret[ 2 ] |= c;
			break;
		case 5:
			ret[ 3 ] = c << 3;
			break;
		case 6:
			ret[ 3 ] |= c >> 2;
			ret[ 4 ] = c << 6;
			break;
		case 7:
			ret[ 4 ] |= c << 1;
			break;
		case 8:
			ret[ 4 ] |= c >> 4;
			ret[ 5 ] = c << 5;
			break;
		case 9:
			ret[ 5 ] |= c;
			break;
		case 10:
			ret[ 6 ] = c << 3;
			break;
		case 11:
			ret[ 6 ] |= c >> 2;
			ret[ 7 ] = c << 6;
			break;
		case 12:
			ret[ 7 ] |= c << 1;
			break;
		case 13:
			ret[ 7 ] |= c >> 4;
			ret[ 8 ] = c << 5;
			break;
		case 14:
			ret[ 8 ] |= c;
			break;
		}
		bbeg += 5;
	}
	ll = ( bbeg / 8 ) == ( bbeg / 8.0 ) ? ( bbeg / 8 ) : ( bbeg / 8 + 1 );
	ret[ ll ] = '\0';
	return ret;
}

char *Framework::deConvert( char *txt ) // dekonvertiert den Text
{
	int l = (int)strlen( txt );
	int ll = ( l * 8 ) / 5;
	char *ret = new char[ ll + 1 ];
	for( int i = 0; i < ll; i++ )
	{
		char c;
		switch( i )
		{
		case 0:
			c = ( ret[ 0 ] >> 3 ) & 0x1F;
			break;
		case 1:
			c = ( ret[ 0 ] << 2 ) & 0x1F;
			c |= ( ret[ 1 ] >> 6 ) & 0x03;
			break;
		case 2:
			c = ( ret[ 1 ] >> 1 ) & 0x1F;
			break;
		case 3:
			c = ( ret[ 1 ] << 4 ) & 0x1F;
			c |= ( ret[ 2 ] >> 5 ) & 0x07;
			break;
		case 4:
			c = ret[ 2 ] & 0x1F;
			break;
		case 5:
			c = ( ret[ 3 ] >> 3 ) & 0x1F;
			break;
		case 6:
			c = ( ret[ 3 ] << 2 ) & 0x1F;
			c |= ( ret[ 4 ] >> 6 ) & 0x03;
			break;
		case 7:
			c = ( ret[ 4 ] >> 1 ) & 0x1F;
			break;
		case 8:
			c = ( ret[ 4 ] << 4 ) & 0x1F;
			c |= ( ret[ 5 ] >> 5 ) & 0x07;
			break;
		case 9:
			c = ret[ 5 ];
			break;
		case 10:
			c = ( ret[ 6 ] >> 3 ) & 0x1F;
			break;
		case 11:
			c = ( ret[ 6 ] << 2 ) & 0x1F;
			c |= ( ret[ 7 ] >> 6 ) & 0x03;
			break;
		case 12:
			c = ret[ 7 ] |= c << 1 & 0x1F;
			break;
		case 13:
			c = ret[ 7 ] |= c >> 4 & 0x1F;
			c |= ret[ 8 ] = c << 5 & 0x07;
			break;
		case 14:
			c = ret[ 8 ] & 0x1F;
			break;
		}
		if( c == 27 )
			c = 'ü';
		else if( c == 28 )
			c = 'ö';
		else if( c == 29 )
			c = 'ä';
		else if( c == 30 )
			c = 'ß';
		else if( c == 31 )
			c = '.';
		else 
			c += 96;
	}
	ret[ ll ] = '\0';
	return ret;
}

int Framework::textLänge( const char *txt ) // gibt die Länge von txt zurück
{
	int ret = 0;
	for( ; txt[ ret ] != 0; ret++ );
	return ret;
}