Quellcode Formatierung angepasst.

Zum Beispiel wurden alle Tabs durch 4 lehrzeichen ersetzt...

AlphaFeld.cpp

@@ -10,100 +10,99 @@ using namespace Framework;
 // Inhalt der AlphaFeld Klasse aus AlphaFeld.h
 // Konstruktor 
 AlphaFeld::AlphaFeld()
-	: Zeichnung(),
-  stärke( 5 ),
-  farbe( 0x9B000000 ),
-  ref( 1 )
-{
-}
+    : Zeichnung(),
+    stärke( 5 ),
+    farbe( 0x9B000000 ),
+    ref( 1 )
+{}
 
 // nicht constant 
 void AlphaFeld::setStärke( int st ) // setzt die Stärke
 {
-	stärke = st;
-	rend = 1;
+    stärke = st;
+    rend = 1;
 }
 
 void AlphaFeld::setFarbe( int f ) // setzt die Farbe
 {
-	farbe = f;
-	rend = 1;
+    farbe = f;
+    rend = 1;
 }
 
 void AlphaFeld::render( Bild &zRObj ) // zeichnet nach zRObj
 {
     __super::render( zRObj );
-	int br = gr.x - 1;
-	int hö = gr.y - 1;
-	int xp = pos.x, yp = pos.y;
-	int a = ( farbe >> 24 ) & 0xFF;
-	int index = ( br / 2 ) * ( br <= hö ) + ( hö / 2 ) * ( br > hö );
-	int fc = farbe & 0x00FFFFFF;
-	int fc2 = farbe;
-	if( stärke > 0 )
-		index = index > ( a / stärke ) ? a / stärke : index;
-	if( stärke < 0 )
-		index = index > ( ( 255 - a ) / -stärke ) ? ( ( 255 - a ) / -stärke ) : index;
-	for( int i = 0; i < index; ++i )
-	{
-		a -= stärke;
-		fc2 = ( a << 24 ) | fc;
-		int i2 = i << 1;
-		zRObj.drawLinieHAlpha( xp + i + 1, yp + i, br - i2, fc2 );		// oben links --- oben rechts
-		zRObj.drawLinieVAlpha( xp + br - i, yp + i + 1, hö - i2, fc2 );	// oben rechts -- unten rechts
-		zRObj.drawLinieHAlpha( xp + i, yp + hö - i, br - i2, fc2 );		// unten rechts - unten links
-		zRObj.drawLinieVAlpha( xp + i, yp + i, hö - i2, fc2 );			// unten links -- oben links
-	}
-	if( index == br / 2 )
-	{
-		for( int i = index; i <= index + ( br - index ) - index; ++i )
-			zRObj.drawLinieVAlpha( xp + i, yp + index, hö - ( index << 1 ) + 1, fc2 ); // rest Fläche senkrecht
-	}
-	else
-	{
-		for( int i = index; i <= index + ( hö - index ) - index; ++i )
-			zRObj.drawLinieHAlpha( xp + index, yp + i, br - ( index << 1 ) + 1, fc2 ); // rest Fläche waagerecht
-	}
+    int br = gr.x - 1;
+    int hö = gr.y - 1;
+    int xp = pos.x, yp = pos.y;
+    int a = ( farbe >> 24 ) & 0xFF;
+    int index = ( br / 2 ) * ( br <= hö ) + ( hö / 2 ) * ( br > hö );
+    int fc = farbe & 0x00FFFFFF;
+    int fc2 = farbe;
+    if( stärke > 0 )
+        index = index > ( a / stärke ) ? a / stärke : index;
+    if( stärke < 0 )
+        index = index > ( ( 255 - a ) / -stärke ) ? ( ( 255 - a ) / -stärke ) : index;
+    for( int i = 0; i < index; ++i )
+    {
+        a -= stärke;
+        fc2 = ( a << 24 ) | fc;
+        int i2 = i << 1;
+        zRObj.drawLinieHAlpha( xp + i + 1, yp + i, br - i2, fc2 );		// oben links --- oben rechts
+        zRObj.drawLinieVAlpha( xp + br - i, yp + i + 1, hö - i2, fc2 );	// oben rechts -- unten rechts
+        zRObj.drawLinieHAlpha( xp + i, yp + hö - i, br - i2, fc2 );		// unten rechts - unten links
+        zRObj.drawLinieVAlpha( xp + i, yp + i, hö - i2, fc2 );			// unten links -- oben links
+    }
+    if( index == br / 2 )
+    {
+        for( int i = index; i <= index + ( br - index ) - index; ++i )
+            zRObj.drawLinieVAlpha( xp + i, yp + index, hö - ( index << 1 ) + 1, fc2 ); // rest Fläche senkrecht
+    }
+    else
+    {
+        for( int i = index; i <= index + ( hö - index ) - index; ++i )
+            zRObj.drawLinieHAlpha( xp + index, yp + i, br - ( index << 1 ) + 1, fc2 ); // rest Fläche waagerecht
+    }
 }
 
 // constant 
 int AlphaFeld::getStärke() const // gibt die Stärke zurück
 {
-	return stärke;
+    return stärke;
 }
 
 int AlphaFeld::getFarbe() const // gibt die Farbe zurück
 {
-	return farbe;
+    return farbe;
 }
 
 Zeichnung *AlphaFeld::dublizieren() const // Kopiert das Zeichnung
 {
-	AlphaFeld *obj = new AlphaFeld();
-	obj->setPosition( pos );
-	obj->setGröße( gr );
-	obj->setMausEreignisParameter( makParam );
-	obj->setTastaturEreignisParameter( takParam );
-	obj->setMausEreignis( Mak );
-	obj->setTastaturEreignis( Tak );
-	if( toolTip )
-		obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	obj->setStärke( stärke );
-	obj->setFarbe( farbe );
-	return obj;
+    AlphaFeld *obj = new AlphaFeld();
+    obj->setPosition( pos );
+    obj->setGröße( gr );
+    obj->setMausEreignisParameter( makParam );
+    obj->setTastaturEreignisParameter( takParam );
+    obj->setMausEreignis( Mak );
+    obj->setTastaturEreignis( Tak );
+    if( toolTip )
+        obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    obj->setStärke( stärke );
+    obj->setFarbe( farbe );
+    return obj;
 }
 
 // Reference Counting 
 AlphaFeld *AlphaFeld::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 AlphaFeld *AlphaFeld::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

AlphaFeld.h

@@ -5,42 +5,42 @@
 
 namespace Framework
 {
-	class Bild; // Bild.h
-	class AlphaFeld; // Aus dieser Datei
+    class Bild; // Bild.h
+    class AlphaFeld; // Aus dieser Datei
 
     // Eine Zeichnung des 2D GUI Frameworks, die einen Farbübergang zu einem Rechteck darstellt
-	class AlphaFeld : public Zeichnung
-	{
-	private:
-		int stärke;
-		int farbe;
-		int ref;
+    class AlphaFeld : public Zeichnung
+    {
+    private:
+        int stärke;
+        int farbe;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) AlphaFeld();
-		// Setzt die Stärke des Übergangs. Dies ist der Wert um den der Alpha Wert der Farbe für jeden Pixel nach innen abnimmt
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) AlphaFeld();
+        // Setzt die Stärke des Übergangs. Dies ist der Wert um den der Alpha Wert der Farbe für jeden Pixel nach innen abnimmt
         //  st: Die Stärke
-		__declspec( dllexport ) void setStärke( int st );
+        __declspec( dllexport ) void setStärke( int st );
         // Setzt die Farbe des Alpha Feldes
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFarbe( int f );
+        __declspec( dllexport ) void setFarbe( int f );
         // Zeichnet die Zeihnung in ein bestimmtes Bild
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Stärke des Alpha Feldes zurück
-		__declspec( dllexport ) int getStärke() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Stärke des Alpha Feldes zurück
+        __declspec( dllexport ) int getStärke() const;
         // gibt die Farbe des Alpha Feldes im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getFarbe() const;
+        __declspec( dllexport ) int getFarbe() const;
         // Kopiert das Alpha Feld, so dass es ohne auswirkungen auf das Original verwendet werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) AlphaFeld *getThis();
+        __declspec( dllexport ) AlphaFeld *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) AlphaFeld *release();
-	};
+        __declspec( dllexport ) AlphaFeld *release();
+    };
 }
 
 #endif

Animation.cpp

@@ -11,442 +11,441 @@ using namespace Framework;
 // Inhalt der Animation2DData Klasse aus Animation.h
 // Konstruktor
 Animation2DData::Animation2DData()
-	: bilder( 0 ),
-	  bildAnzahl( 0 ),
-	  fps( 0 ),
-	  wiederhohlen( 0 ),
-	  transparent( 0 ),
-	  ref( 1 )
+    : bilder( 0 ),
+    bildAnzahl( 0 ),
+    fps( 0 ),
+    wiederhohlen( 0 ),
+    transparent( 0 ),
+    ref( 1 )
 {
-	InitializeCriticalSection( &cs );
+    InitializeCriticalSection( &cs );
 }
 
 // Destruktor
 Animation2DData::~Animation2DData()
 {
-	reset();
-	DeleteCriticalSection( &cs );
+    reset();
+    DeleteCriticalSection( &cs );
 }
 
 // nicht constant
 void Animation2DData::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void Animation2DData::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void Animation2DData::ladeAnimation( InitDatei *datei )
 {
-	if( !datei )
-		return;
-	reset();
-	int anz = datei->getWertAnzahl();
-	lock();
-	if( datei->wertExistiert( "fps" ) )
-	{
-		--anz;
-		fps = TextZuInt( datei->zWert( "fps" )->getText(), 10 );
-	}
-	if( datei->wertExistiert( "wiederhohlen" ) )
-	{
-		--anz;
-		wiederhohlen = datei->zWert( "wiederhohlen" )->istGleich( "true" );
-	}
-	if( datei->wertExistiert( "transparent" ) )
-	{
-		--anz;
-		transparent = datei->zWert( "transparent" )->istGleich( "true" );
-	}
-	Bild **bilder = new Bild*[ anz ];
-	int j = 0;
-	for( int i = 0; i < anz; ++i )
-	{
-		if( datei->zName( i )->istGleich( "fps" ) || 
-			datei->zName( i )->istGleich( "wiederhohlen" ) || 
-			datei->zName( i )->istGleich( "transparent" ) )
-			continue;
-		bilder[ j ] = 0;
-		Text pfad = datei->zWert( i )->getText();
-		if( pfad.hat( ".ltdb/" ) && pfad.getLänge() > 7 )
-		{
-			Text *name = pfad.getTeilText( pfad.positionVon( ".ltdb/", pfad.anzahlVon( ".ltdb/" ) - 1 ) + 6 );
-			pfad.setText( pfad.getTeilText( 0, pfad.getLänge() - name->getLänge() - 1 ) );
-			LTDBDatei *dat = new LTDBDatei();
-			dat->setDatei( pfad.getThis() );
-			dat->leseDaten( 0 );
-			bilder[ j ] = dat->laden( 0, name );
-			dat->release();
-		}
-		++j;
-	}
-	this->bilder = new Bild*[ bildAnzahl ];
-	j = 0;
-	for( int i = 0; i < anz; ++i )
-	{
-		if( !bilder[ i ] )
-			++j;
-		else
-			this->bilder[ i - j ] = bilder[ i ];
-	}
-	delete[] bilder;
-	unlock();
-	datei->release();
+    if( !datei )
+        return;
+    reset();
+    int anz = datei->getWertAnzahl();
+    lock();
+    if( datei->wertExistiert( "fps" ) )
+    {
+        --anz;
+        fps = TextZuInt( datei->zWert( "fps" )->getText(), 10 );
+    }
+    if( datei->wertExistiert( "wiederhohlen" ) )
+    {
+        --anz;
+        wiederhohlen = datei->zWert( "wiederhohlen" )->istGleich( "true" );
+    }
+    if( datei->wertExistiert( "transparent" ) )
+    {
+        --anz;
+        transparent = datei->zWert( "transparent" )->istGleich( "true" );
+    }
+    Bild **bilder = new Bild*[ anz ];
+    int j = 0;
+    for( int i = 0; i < anz; ++i )
+    {
+        if( datei->zName( i )->istGleich( "fps" ) ||
+            datei->zName( i )->istGleich( "wiederhohlen" ) ||
+            datei->zName( i )->istGleich( "transparent" ) )
+            continue;
+        bilder[ j ] = 0;
+        Text pfad = datei->zWert( i )->getText();
+        if( pfad.hat( ".ltdb/" ) && pfad.getLänge() > 7 )
+        {
+            Text *name = pfad.getTeilText( pfad.positionVon( ".ltdb/", pfad.anzahlVon( ".ltdb/" ) - 1 ) + 6 );
+            pfad.setText( pfad.getTeilText( 0, pfad.getLänge() - name->getLänge() - 1 ) );
+            LTDBDatei *dat = new LTDBDatei();
+            dat->setDatei( pfad.getThis() );
+            dat->leseDaten( 0 );
+            bilder[ j ] = dat->laden( 0, name );
+            dat->release();
+        }
+        ++j;
+    }
+    this->bilder = new Bild*[ bildAnzahl ];
+    j = 0;
+    for( int i = 0; i < anz; ++i )
+    {
+        if( !bilder[ i ] )
+            ++j;
+        else
+            this->bilder[ i - j ] = bilder[ i ];
+    }
+    delete[] bilder;
+    unlock();
+    datei->release();
 }
 
 void Animation2DData::ladeAnimation( LTDBDatei *datei )
 {
-	if( !datei )
-		return;
-	reset();
-	datei->leseDaten( 0 );
-	int anz = datei->getBildAnzahl();
-	RCArray< Text > *list = datei->zBildListe();
-	lock();
-	Bild **bilder = new Bild*[ anz ];
-	for( int i = 0; i < anz; ++i )
-	{
-		bilder[ i ] = datei->laden( 0, list->get( i ) );
-		if( bilder[ i ] )
-			++bildAnzahl;
-	}
-	this->bilder = new Bild*[ bildAnzahl ];
-	int j = 0;
-	for( int i = 0; i < anz; ++i )
-	{
-		if( !bilder[ i ] )
-			++j;
-		else
-			this->bilder[ i - j ] = bilder[ i ];
-	}
-	delete[] bilder;
-	unlock();
-	datei->release();
+    if( !datei )
+        return;
+    reset();
+    datei->leseDaten( 0 );
+    int anz = datei->getBildAnzahl();
+    RCArray< Text > *list = datei->zBildListe();
+    lock();
+    Bild **bilder = new Bild*[ anz ];
+    for( int i = 0; i < anz; ++i )
+    {
+        bilder[ i ] = datei->laden( 0, list->get( i ) );
+        if( bilder[ i ] )
+            ++bildAnzahl;
+    }
+    this->bilder = new Bild*[ bildAnzahl ];
+    int j = 0;
+    for( int i = 0; i < anz; ++i )
+    {
+        if( !bilder[ i ] )
+            ++j;
+        else
+            this->bilder[ i - j ] = bilder[ i ];
+    }
+    delete[] bilder;
+    unlock();
+    datei->release();
 }
 
 void Animation2DData::setFPS( int fps )
 {
-	this->fps = fps;
+    this->fps = fps;
 }
 
 void Animation2DData::setWiederhohlend( bool wh )
 {
-	wiederhohlen = wh;
+    wiederhohlen = wh;
 }
 
 void Animation2DData::setTransparent( bool trp )
 {
-	transparent = trp;
+    transparent = trp;
 }
 
 void Animation2DData::reset()
 {
-	lock();
-	for( int i = 0; i < bildAnzahl; ++i )
-		bilder[ i ] = bilder[ i ]->release();
-	delete[] bilder;
-	bilder = 0;
-	bildAnzahl = 0;
-	fps = 30;
-	wiederhohlen = 0;
-	transparent = 0;
-	unlock();
+    lock();
+    for( int i = 0; i < bildAnzahl; ++i )
+        bilder[ i ] = bilder[ i ]->release();
+    delete[] bilder;
+    bilder = 0;
+    bildAnzahl = 0;
+    fps = 30;
+    wiederhohlen = 0;
+    transparent = 0;
+    unlock();
 }
 
 // constant
 Bild *Animation2DData::getBild( int i ) const
 {
-	return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ]->getThis() : 0;
+    return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ]->getThis() : 0;
 }
 
 Bild *Animation2DData::zBild( int i ) const
 {
-	return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ] : 0;
+    return ( i >= 0 && i < bildAnzahl ) ? bilder[ i ] : 0;
 }
 
 int Animation2DData::getBildAnzahl() const
 {
-	return bildAnzahl;
+    return bildAnzahl;
 }
 
 int Animation2DData::getFPS() const
 {
-	return fps;
+    return fps;
 }
 
 bool Animation2DData::istWiederhohlend() const
 {
-	return wiederhohlen;
+    return wiederhohlen;
 }
 
 bool Animation2DData::istTransparent() const
 {
-	return transparent;
+    return transparent;
 }
 
 // Reference Counting
 Animation2DData *Animation2DData::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Animation2DData *Animation2DData::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der Animation2D Klasse aus Animation.h
 // Konstruktor
 Animation2D::Animation2D()
-	: Zeichnung(),
-	data( 0 ),
-	jetzt( 0 ),
-	ausgleich( 0 ),
-	alpha( 0 ),
-	maxAlpha( 255 ),
-	rahmen( 0 ),
-	ram( 0 ),
-	aps( 255 * 60 ),
-	sichtbar( 0 ),
-	ref( 1 )
-{
-}
+    : Zeichnung(),
+    data( 0 ),
+    jetzt( 0 ),
+    ausgleich( 0 ),
+    alpha( 0 ),
+    maxAlpha( 255 ),
+    rahmen( 0 ),
+    ram( 0 ),
+    aps( 255 * 60 ),
+    sichtbar( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor
 Animation2D::~Animation2D()
 {
-	if( data )
-		data->release();
-	if( ram )
-		ram->release();
+    if( data )
+        data->release();
+    if( ram )
+        ram->release();
 }
 
 // nicht constant
 void Animation2D::setRahmen( bool ram )
 {
-	rahmen = ram;
+    rahmen = ram;
 }
 
 void Animation2D::setRahmenZ( LRahmen *ram )
 {
-	if( this->ram )
-		this->ram->release();
-	this->ram = ram;
+    if( this->ram )
+        this->ram->release();
+    this->ram = ram;
 }
 
 void Animation2D::setRahmenBreite( int br )
 {
-	if( !ram )
-		ram = new LRahmen();
-	ram->setRamenBreite( br );
+    if( !ram )
+        ram = new LRahmen();
+    ram->setRamenBreite( br );
 }
 
 void Animation2D::setRahmenFarbe( int f )
 {
-	if( !ram )
-		ram = new LRahmen();
-	ram->setFarbe( f );
+    if( !ram )
+        ram = new LRahmen();
+    ram->setFarbe( f );
 }
 
 void Animation2D::setAnimationDataZ( Animation2DData *data )
 {
-	lockZeichnung();
-	if( this->data )
-		this->data->release();
-	this->data = data;
-	if( alpha )
-		rend = 1;
-	unlockZeichnung();
+    lockZeichnung();
+    if( this->data )
+        this->data->release();
+    this->data = data;
+    if( alpha )
+        rend = 1;
+    unlockZeichnung();
 }
 
 void Animation2D::setAlphaMaske( unsigned char alpha )
 {
-	maxAlpha = alpha;
+    maxAlpha = alpha;
 }
 
 void Animation2D::setAPS( int aps )
 {
-	this->aps = aps;
+    this->aps = aps;
 }
 
 void Animation2D::setSichtbar( bool sichtbar )
 {
-	this->sichtbar = sichtbar;
+    this->sichtbar = sichtbar;
 }
 
 bool Animation2D::tick( double zeit )
 {
-	lockZeichnung();
-	if( !data || ( !alpha && !sichtbar ) )
-	{
-		bool ret = rend;
-		rend = 0;
-		unlockZeichnung();
-		return ret;
-	}
-	if( sichtbar && alpha < maxAlpha )
-	{
-		if( alpha + aps * zeit >= maxAlpha )
-			alpha = maxAlpha;
-		else
-			alpha += (unsigned char)(aps * zeit);
-		rend = 1;
-	}
-	else if( !sichtbar && alpha > 0 )
-	{
-		if( alpha - aps * zeit <= 0 )
-			alpha = 0;
-		else
-			alpha -= (unsigned char)(aps * zeit);
-		rend = 1;
-	}
-	ausgleich += zeit;
-	int tmp = jetzt;
-	data->lock();
-	if( ausgleich >= 1.0 / data->getFPS() )
-	{
-		ausgleich -= 1.0 / data->getFPS();
-		++jetzt;
-		if( jetzt >= data->getBildAnzahl() )
-		{
-			if( data->istWiederhohlend() )
-				jetzt = 0;
-			else
-				jetzt = data->getBildAnzahl();
-		}
-	}
-	data->unlock();
-	if( tmp != jetzt )
-		rend = 1;
-	bool ret = rend;
-	rend = 0;
-	unlockZeichnung();
-	return ret;
+    lockZeichnung();
+    if( !data || ( !alpha && !sichtbar ) )
+    {
+        bool ret = rend;
+        rend = 0;
+        unlockZeichnung();
+        return ret;
+    }
+    if( sichtbar && alpha < maxAlpha )
+    {
+        if( alpha + aps * zeit >= maxAlpha )
+            alpha = maxAlpha;
+        else
+            alpha += (unsigned char)( aps * zeit );
+        rend = 1;
+    }
+    else if( !sichtbar && alpha > 0 )
+    {
+        if( alpha - aps * zeit <= 0 )
+            alpha = 0;
+        else
+            alpha -= (unsigned char)( aps * zeit );
+        rend = 1;
+    }
+    ausgleich += zeit;
+    int tmp = jetzt;
+    data->lock();
+    if( ausgleich >= 1.0 / data->getFPS() )
+    {
+        ausgleich -= 1.0 / data->getFPS();
+        ++jetzt;
+        if( jetzt >= data->getBildAnzahl() )
+        {
+            if( data->istWiederhohlend() )
+                jetzt = 0;
+            else
+                jetzt = data->getBildAnzahl();
+        }
+    }
+    data->unlock();
+    if( tmp != jetzt )
+        rend = 1;
+    bool ret = rend;
+    rend = 0;
+    unlockZeichnung();
+    return ret;
 }
 
 void Animation2D::render( Bild &zRObj )
 {
-	lockZeichnung();
-	if( !data )
-	{
-		unlockZeichnung();
-		return;
-	}
+    lockZeichnung();
+    if( !data )
+    {
+        unlockZeichnung();
+        return;
+    }
     __super::render( zRObj );
-	data->lock();
-	if( data->zBild( jetzt ) )
-	{
-		zRObj.setAlpha( alpha );
-		if( data->istTransparent() )
-			zRObj.alphaBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
-		else
-			zRObj.drawBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
-		if( ram && rahmen )
-		{
-			ram->setPosition( pos );
-			ram->setGröße( gr );
-			ram->render( zRObj );
-		}
-		zRObj.releaseAlpha();
-	}
-	data->unlock();
-	unlockZeichnung();
+    data->lock();
+    if( data->zBild( jetzt ) )
+    {
+        zRObj.setAlpha( alpha );
+        if( data->istTransparent() )
+            zRObj.alphaBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
+        else
+            zRObj.drawBild( pos.x, pos.y, gr.x, gr.y, *data->zBild( jetzt ) );
+        if( ram && rahmen )
+        {
+            ram->setPosition( pos );
+            ram->setGröße( gr );
+            ram->render( zRObj );
+        }
+        zRObj.releaseAlpha();
+    }
+    data->unlock();
+    unlockZeichnung();
 }
 
 // constant
 Animation2DData *Animation2D::getAnimationData() const
 {
-	return data ? data->getThis() : 0;
+    return data ? data->getThis() : 0;
 }
 
 Animation2DData *Animation2D::zAnimationData() const
 {
-	return data;
+    return data;
 }
 
 bool Animation2D::istSichtbar() const
 {
-	return sichtbar;
+    return sichtbar;
 }
 
 int Animation2D::getJetzt() const
 {
-	return jetzt;
+    return jetzt;
 }
 
 unsigned char Animation2D::getAlphaMaske() const
 {
-	return maxAlpha;
+    return maxAlpha;
 }
 
 bool Animation2D::hatRahmen() const
 {
-	return rahmen;
+    return rahmen;
 }
 
 LRahmen *Animation2D::getRahmen() const
 {
-	return ram ? ram->getThis() : 0;
+    return ram ? ram->getThis() : 0;
 }
 
 LRahmen *Animation2D::zRahmen() const
 {
-	return ram;
+    return ram;
 }
 
 int Animation2D::getRahmenBreite() const
 {
-	return ram ? ram->getRBreite() : 0;
+    return ram ? ram->getRBreite() : 0;
 }
 
 int Animation2D::getRahmenFarbe() const
 {
-	return ram ? ram->getFarbe() : 0;
+    return ram ? ram->getFarbe() : 0;
 }
 
 Zeichnung *Animation2D::dublizieren() const
 {
-	Animation2D *ret = new Animation2D();
-	ret->setPosition( pos );
-	ret->setGröße( gr );
-	ret->setMausEreignisParameter( makParam );
-	ret->setTastaturEreignisParameter( takParam );
-	ret->setMausEreignis( Mak );
-	ret->setTastaturEreignis( Tak );
-	if( toolTip )
-		ret->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	if( data )
-		ret->setAnimationDataZ( data->getThis() );
-	ret->setAPS( aps );
-	ret->setSichtbar( sichtbar );
-	ret->setAlphaMaske( maxAlpha );
-	ret->setRahmen( rahmen );
-	if( ram )
-	{
-		ret->setRahmenBreite( ram->getRBreite() );
-		ret->setRahmenFarbe( ram->getFarbe() );
-	}
-	return ret;
+    Animation2D *ret = new Animation2D();
+    ret->setPosition( pos );
+    ret->setGröße( gr );
+    ret->setMausEreignisParameter( makParam );
+    ret->setTastaturEreignisParameter( takParam );
+    ret->setMausEreignis( Mak );
+    ret->setTastaturEreignis( Tak );
+    if( toolTip )
+        ret->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    if( data )
+        ret->setAnimationDataZ( data->getThis() );
+    ret->setAPS( aps );
+    ret->setSichtbar( sichtbar );
+    ret->setAlphaMaske( maxAlpha );
+    ret->setRahmen( rahmen );
+    if( ram )
+    {
+        ret->setRahmenBreite( ram->getRBreite() );
+        ret->setRahmenFarbe( ram->getFarbe() );
+    }
+    return ret;
 }
 
 // Reference Counting
 Animation2D *Animation2D::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Animation2D *Animation2D::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Animation.h

@@ -5,157 +5,157 @@
 
 namespace Framework
 {
-	class Bild; // Bild.h
-	class LTDBDatei; // DateiSystem.h
-	class InitDatei; // InitDatei.h
-	class LRahmen; // Rahmen.h
+    class Bild; // Bild.h
+    class LTDBDatei; // DateiSystem.h
+    class InitDatei; // InitDatei.h
+    class LRahmen; // Rahmen.h
 
     // Enthält alle Bilder einer Video Animation
-	class Animation2DData
-	{
-	private:
-		Bild **bilder;
-		int bildAnzahl;
-		int fps;
-		bool wiederhohlen;
-		bool transparent;
-		CRITICAL_SECTION cs;
-		int ref;
+    class Animation2DData
+    {
+    private:
+        Bild **bilder;
+        int bildAnzahl;
+        int fps;
+        bool wiederhohlen;
+        bool transparent;
+        CRITICAL_SECTION cs;
+        int ref;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) Animation2DData();
-		// Destruktor
-		__declspec( dllexport ) ~Animation2DData();
+    public:
+        // Konstruktor
+        __declspec( dllexport ) Animation2DData();
+        // Destruktor
+        __declspec( dllexport ) ~Animation2DData();
         // Dies ist notwendig, falls mehrere Threads gleichzeitig dieses Objekt benutzen.
         // Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
-		__declspec( dllexport ) void lock();
+        __declspec( dllexport ) void lock();
         // Dies ist notwendig, falls mehrere Threads gleichzeitig dieses Objekt benutzen.
         // Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
-		__declspec( dllexport ) void unlock();
+        __declspec( dllexport ) void unlock();
         // Lädt alle Bilder aus einer InitDatei ein. Auch die Werte 'fps', 'wiederhohlen' (true, false), 'transparent' (true, false) werden interpretiert.
         // Die Bilder müssen in der richtiegen Reihenfolge in der Datei stehen. Der Name der Werte ist egal undder Wert ist der Pfad zur ltdb Datei mit /bildname hinten drann
         // Beispiel: fps=30
         //           x=a.ltdb\aaaa.jpg
         //           y=a.ltdb\aaab.jpg
         //  datei: Die bereits eingelesene InitDatei
-		__declspec( dllexport ) void ladeAnimation( InitDatei *datei );
+        __declspec( dllexport ) void ladeAnimation( InitDatei *datei );
         // Lädt alle Bilder aus einer LTDB Datei der reihenfolge nach ein, in der sie gespeichert sind.
         //  datei: Die LTDB Datei
-		__declspec( dllexport ) void ladeAnimation( LTDBDatei *datei );
+        __declspec( dllexport ) void ladeAnimation( LTDBDatei *datei );
         // Setzt die Bilder pro Sekunde der Video Animation
         //  fps: Die Anzahl an Bildern pro Sekunde
-		__declspec( dllexport ) void setFPS( int fps );
+        __declspec( dllexport ) void setFPS( int fps );
         // Legt fest, ob die Animation sich wiederhohlt, wenn sie am ende angelangt ist
         //  wh: 1, wenn sich die Animation wiederhohlen soll
-		__declspec( dllexport ) void setWiederhohlend( bool wh );
+        __declspec( dllexport ) void setWiederhohlend( bool wh );
         // Legt fest, ob beim Zeichnen der Bilder Alphablending benutzt werden soll
         //  trp: 1, wenn Alphablending benutzt werden soll
-		__declspec( dllexport ) void setTransparent( bool trp );
+        __declspec( dllexport ) void setTransparent( bool trp );
         // Löscht alle Bilder aus der Animation und setzt alle Werte auf die Standartwerte zurück
-		__declspec( dllexport ) void reset();
-		// Gibt ein Bestimmtes Bild der Animation zurück
+        __declspec( dllexport ) void reset();
+        // Gibt ein Bestimmtes Bild der Animation zurück
         //  i: Der Index des Bildes
-		__declspec( dllexport ) Bild *getBild( int i ) const;
+        __declspec( dllexport ) Bild *getBild( int i ) const;
         // Gibt ein Bestimmtes Bild der Animation ohne erhöhten Reference Counter zurück
         //  i: Der Index des Bildes
-		__declspec( dllexport ) Bild *zBild( int i ) const;
+        __declspec( dllexport ) Bild *zBild( int i ) const;
         // Gibt die Anzahl der Bilder in der Animation zurück
-		__declspec( dllexport ) int getBildAnzahl() const;
+        __declspec( dllexport ) int getBildAnzahl() const;
         // Gibt die Anzahl an Bildern pro Sekunde zurück
-		__declspec( dllexport ) int getFPS() const;
+        __declspec( dllexport ) int getFPS() const;
         // Gibt zurück, ob sich die Animation wiederhohlt, wenn sie beim letzten Bild angelangt ist
-		__declspec( dllexport ) bool istWiederhohlend() const;
+        __declspec( dllexport ) bool istWiederhohlend() const;
         // Gibt zurück, ob beim Zeichnen der Bilder Alphablending benutzt wird
-		__declspec( dllexport ) bool istTransparent() const;
+        __declspec( dllexport ) bool istTransparent() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Animation2DData *getThis();
+        __declspec( dllexport ) Animation2DData *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Animation2DData *release();
-	};
+        __declspec( dllexport ) Animation2DData *release();
+    };
 
     // Eine Zeichnung, die eine Video Animation zeichnet
-	class Animation2D : public Zeichnung
-	{
-	private:
-		Animation2DData *data;
-		int jetzt;
-		double ausgleich;
-		unsigned char alpha;
-		unsigned char maxAlpha;
-		bool rahmen;
-		LRahmen *ram;
-		int aps;
-		bool sichtbar;
-		bool rend;
-		int ref;
+    class Animation2D : public Zeichnung
+    {
+    private:
+        Animation2DData *data;
+        int jetzt;
+        double ausgleich;
+        unsigned char alpha;
+        unsigned char maxAlpha;
+        bool rahmen;
+        LRahmen *ram;
+        int aps;
+        bool sichtbar;
+        bool rend;
+        int ref;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) Animation2D();
-		// Destruktor
-		__declspec( dllexport ) ~Animation2D();
-		// Legt fest, ob ein Rahmen um die Animation gezeichnet werden soll
+    public:
+        // Konstruktor
+        __declspec( dllexport ) Animation2D();
+        // Destruktor
+        __declspec( dllexport ) ~Animation2D();
+        // Legt fest, ob ein Rahmen um die Animation gezeichnet werden soll
         //  ram: 1, wenn ein Rahmen gezeichnet werden soll
-		__declspec( dllexport ) void setRahmen( bool ram );
+        __declspec( dllexport ) void setRahmen( bool ram );
         // Setzt einen Zeiger auf den verfenteten Rahmen
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setRahmenZ( LRahmen *ram );
+        __declspec( dllexport ) void setRahmenZ( LRahmen *ram );
         // Setzt die Breite des Rahmens
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setRahmenBreite( int br );
+        __declspec( dllexport ) void setRahmenBreite( int br );
         // Setzt die Farbe des Rahmens
         //  fc: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setRahmenFarbe( int fc );
+        __declspec( dllexport ) void setRahmenFarbe( int fc );
         // Setzt die Animation, die Angezeigt werden soll
         //  data: Die Animationsdaten
-		__declspec( dllexport ) void setAnimationDataZ( Animation2DData *data );
+        __declspec( dllexport ) void setAnimationDataZ( Animation2DData *data );
         // Setzt die Transparenz der gesammten Animation
         //  alpha: Die Transparenz
-		__declspec( dllexport ) void setAlphaMaske( unsigned char alpha );
+        __declspec( dllexport ) void setAlphaMaske( unsigned char alpha );
         // Setzt die Geschwindigkeit, in der die Animation ein und ausgeblendet wird
         //  aps: Alpha pro sekunde
-		__declspec( dllexport ) void setAPS( int aps );
+        __declspec( dllexport ) void setAPS( int aps );
         // Setzt die Sichtbarkeit der Animation
         //  sichtbar: 1, wenn die Animation eingeblendet werden soll. 0, wenn sie ausgeblendet werden soll
-		__declspec( dllexport ) void setSichtbar( bool sichtbar );
+        __declspec( dllexport ) void setSichtbar( bool sichtbar );
         // Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion vergangen ist
         //  zeit: Die vergangene Zeit in Sekunden
-		__declspec( dllexport ) bool tick( double zeit ) override;
+        __declspec( dllexport ) bool tick( double zeit ) override;
         // Zeichnet die Animation in ein bestimmtes Bild
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Animationsdaten zurück
-		__declspec( dllexport ) Animation2DData *getAnimationData() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Animationsdaten zurück
+        __declspec( dllexport ) Animation2DData *getAnimationData() const;
         // Gibt die Animationsdaten ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Animation2DData *zAnimationData() const;
+        __declspec( dllexport ) Animation2DData *zAnimationData() const;
         // Gibt zurück ob die Animation sichtbar ist
-		__declspec( dllexport ) bool istSichtbar() const;
+        __declspec( dllexport ) bool istSichtbar() const;
         // Gibt den Index des aktuell angezeigten Bildes zurück
-		__declspec( dllexport ) int getJetzt() const;
+        __declspec( dllexport ) int getJetzt() const;
         // Gibt die Transparenz der Animation zurück
-		__declspec( dllexport ) unsigned char getAlphaMaske() const;
+        __declspec( dllexport ) unsigned char getAlphaMaske() const;
         // Gibt zurück, ob ein Rahmen um die Animation gezeichnet wird
-		__declspec( dllexport ) bool hatRahmen() const;
+        __declspec( dllexport ) bool hatRahmen() const;
         // Gibt den Rahmen der Animation zurück
-		__declspec( dllexport ) LRahmen *getRahmen() const;
+        __declspec( dllexport ) LRahmen *getRahmen() const;
         // Gibt den Rahmen der Animation ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) LRahmen *zRahmen() const;
+        __declspec( dllexport ) LRahmen *zRahmen() const;
         // Gibt die Breite des Rahmens in Pixeln zurück
-		__declspec( dllexport ) int getRahmenBreite() const;
+        __declspec( dllexport ) int getRahmenBreite() const;
         // Gibt die Farbe des Rahmens im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getRahmenFarbe() const;
+        __declspec( dllexport ) int getRahmenFarbe() const;
         // Kopiert die Animation, so dass sie ohne auswirkungen auf das Original verändert werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Animation2D *getThis();
+        __declspec( dllexport ) Animation2D *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Animation2D *release();
-	};
+        __declspec( dllexport ) Animation2D *release();
+    };
 }
 
 #endif

Array.h

@@ -7,273 +7,273 @@
 
 namespace Framework
 {
-	template< class TYP >
+    template< class TYP >
     // Ein Eintrag in einer Linked List
-	struct ArrayEintrag
-	{
-		TYP var;
-		bool set;
-		ArrayEintrag< TYP > *next;
-		
+    struct ArrayEintrag
+    {
+        TYP var;
+        bool set;
+        ArrayEintrag< TYP > *next;
+
         // Setzt den Eintrag auf die Werte des anderen Eintrages
-		ArrayEintrag &operator=( ArrayEintrag &r )
-		{
-			var = r.var;
-			set = r.set;
-			next = r.next;
-			return *this;
-		}
+        ArrayEintrag &operator=( ArrayEintrag &r )
+        {
+            var = r.var;
+            set = r.set;
+            next = r.next;
+            return *this;
+        }
         // Gibt den aktuell gespeicherten Wert zurück
-		operator TYP()
-		{
-			return var;
-		}
+        operator TYP()
+        {
+            return var;
+        }
         // inkrementiert durch die Linked List durch
-		ArrayEintrag< TYP > &operator++( ) // prefix
-		{
+        ArrayEintrag< TYP > &operator++() // prefix
+        {
             if( !next )
             {
                 *this = ArrayEintrag{ 0, 0, 0 };
                 return *this;
             }
-			*this = *next;
-			return *next;
-		}
+            *this = *next;
+            return *next;
+        }
         // inkrementiert durch die Linked List durch
-		ArrayEintrag< TYP > &operator++( int ) // postfix
-		{
+        ArrayEintrag< TYP > &operator++( int ) // postfix
+        {
             if( !next )
             {
                 *this = ArrayEintrag{ 0, 0, 0 };
                 return *this;
             }
-			*this = *next;
-			return *next;
-		}
-	};
+            *this = *next;
+            return *next;
+        }
+    };
 
-	template< class TYP >
+    template< class TYP >
     // Eine Linked List von Klassen, die kein Reference Counting berteiben
-	class Array
-	{
-	private:
-		ArrayEintrag< TYP > *einträge;
-		int ref;
-
-	public:
-		// Erstellt eine neue Linked List
-		Array()
-		{
-			einträge = new ArrayEintrag< TYP >();
-			einträge->set = 0;
-			einträge->next = 0;
-			ref = 1;
-		}
-
-		// Leert und löscht die Linked List 
-		~Array()
-		{
-			leeren();
-			delete einträge;
-		}
-
-		// Hängt ein Element ans Ende der Liste an
+    class Array
+    {
+    private:
+        ArrayEintrag< TYP > *einträge;
+        int ref;
+
+    public:
+        // Erstellt eine neue Linked List
+        Array()
+        {
+            einträge = new ArrayEintrag< TYP >();
+            einträge->set = 0;
+            einträge->next = 0;
+            ref = 1;
+        }
+
+        // Leert und löscht die Linked List 
+        ~Array()
+        {
+            leeren();
+            delete einträge;
+        }
+
+        // Hängt ein Element ans Ende der Liste an
         //  t: Das neue Element
-		void add( TYP t )
-		{
-			for( ArrayEintrag< TYP > *e = einträge; 1; e = e->next )
-			{
-				if( !e->set && !e->next )
-				{
-					e->var = t;
-					e->set = 1;
-					break;
-				}
-				if( !e->next )
-				{
-					e->next = new ArrayEintrag< TYP >();
-					e->next->set = 0;
-					e->next->next = 0;
-				}
-			}
-		}
+        void add( TYP t )
+        {
+            for( ArrayEintrag< TYP > *e = einträge; 1; e = e->next )
+            {
+                if( !e->set && !e->next )
+                {
+                    e->var = t;
+                    e->set = 1;
+                    break;
+                }
+                if( !e->next )
+                {
+                    e->next = new ArrayEintrag< TYP >();
+                    e->next->set = 0;
+                    e->next->next = 0;
+                }
+            }
+        }
 
         // Fügt ein Element bei einer bestimmten Position in die Liste ein
         //  t: das neue Element
         //  i: Die Position, wo das Element eingefügt wird (danach der Index des neuen Elementes)
-		void add( TYP t, int i )
-		{
-			if( i < 0 )
-				return;
-			ArrayEintrag< TYP > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-				{
-					ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
-					ne->set = 0;
-					ne->next = 0;
-					e->next = ne;
-				}
-				e = e->next;
-			}
-			ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
-			ne->var = e->var;
-			ne->set = e->set;
-			ne->next = e->next;
-			e->next = ne;
-			e->var = t;
-			e->set = 1;
-		}
+        void add( TYP t, int i )
+        {
+            if( i < 0 )
+                return;
+            ArrayEintrag< TYP > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                {
+                    ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
+                    ne->set = 0;
+                    ne->next = 0;
+                    e->next = ne;
+                }
+                e = e->next;
+            }
+            ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
+            ne->var = e->var;
+            ne->set = e->set;
+            ne->next = e->next;
+            e->next = ne;
+            e->var = t;
+            e->set = 1;
+        }
 
         // Setzt den Wert des i-ten Eintrags
         //  t: der Neue Wert
         //  i: Der Index des Eintrages der gesetzt werden soll
-		void set( TYP t, int i )
-		{
-			if( i < 0 )
-				return;
-			ArrayEintrag< TYP > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-				{
-					ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
-					ne->set = 0;
-					ne->next = 0;
-					e->next = ne;
-				}
-				e = e->next;
-			}
-			e->var = t;
-			e->set = 1;
-		}
+        void set( TYP t, int i )
+        {
+            if( i < 0 )
+                return;
+            ArrayEintrag< TYP > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                {
+                    ArrayEintrag< TYP > *ne = new ArrayEintrag< TYP >();
+                    ne->set = 0;
+                    ne->next = 0;
+                    e->next = ne;
+                }
+                e = e->next;
+            }
+            e->var = t;
+            e->set = 1;
+        }
 
         // Verändert die Position des i-ten Elementes in der Liste
         //  i: Der Index des Elementes, welches verschoben werden soll
         //  p: Die Zielposition des Elementes (danach der neue Index des Elementes)
-		void setPosition( int i, int p )
-		{
-			if( i < 0 || p < 0 || i == p )
-				return;
-			ArrayEintrag< TYP > *e = einträge;
-			ArrayEintrag< TYP > *ve = 0;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-					return;
-				ve = e;
-				e = e->next;
-			}
-			ArrayEintrag< TYP > *e2 = einträge == e ? e->next : einträge;
-			ArrayEintrag< TYP > *ve2 = 0;
-			for( int a = 0; a < p; ++a )
-			{
-				if( !e2 )
-					return;
-				ve2 = e2;
-				if( e2->next == e )
-					e2 = e->next;
-				else
-					e2 = e2->next;
-			}
-			if( !e )
-				return;
-			if( !ve2 )
-				einträge = e;
-			else
-				ve2->next = e;
-			if( ve )
-				ve->next = e->next;
-			else
-				einträge = e->next;
-			e->next = e2;
-		}
+        void setPosition( int i, int p )
+        {
+            if( i < 0 || p < 0 || i == p )
+                return;
+            ArrayEintrag< TYP > *e = einträge;
+            ArrayEintrag< TYP > *ve = 0;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                    return;
+                ve = e;
+                e = e->next;
+            }
+            ArrayEintrag< TYP > *e2 = einträge == e ? e->next : einträge;
+            ArrayEintrag< TYP > *ve2 = 0;
+            for( int a = 0; a < p; ++a )
+            {
+                if( !e2 )
+                    return;
+                ve2 = e2;
+                if( e2->next == e )
+                    e2 = e->next;
+                else
+                    e2 = e2->next;
+            }
+            if( !e )
+                return;
+            if( !ve2 )
+                einträge = e;
+            else
+                ve2->next = e;
+            if( ve )
+                ve->next = e->next;
+            else
+                einträge = e->next;
+            e->next = e2;
+        }
 
         // Löscht ein Bestimmtes Element
         //  i: Der Index des Elementes das gelöscht werden soll
-		void lösche( int i )
-		{
-			if( i < 0 )
-				return;
-			ArrayEintrag< TYP > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-					return;
-				e = e->next;
-			}
-			if( !e )
-				return;
-			if( e->next )
-			{
-				e->var = e->next->var;
-				e->set = e->next->set;
-			}
-			else
-				e->set = 0;
-			ArrayEintrag< TYP > *del = e->next;
-			if( e->next )
-				e->next = e->next->next;
-			else
-				e->next = 0;
-			if( del )
-			{
-				del->set = 0;
-				del->next = 0;
-				delete del;
-			}
-		}
+        void lösche( int i )
+        {
+            if( i < 0 )
+                return;
+            ArrayEintrag< TYP > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                    return;
+                e = e->next;
+            }
+            if( !e )
+                return;
+            if( e->next )
+            {
+                e->var = e->next->var;
+                e->set = e->next->set;
+            }
+            else
+                e->set = 0;
+            ArrayEintrag< TYP > *del = e->next;
+            if( e->next )
+                e->next = e->next->next;
+            else
+                e->next = 0;
+            if( del )
+            {
+                del->set = 0;
+                del->next = 0;
+                delete del;
+            }
+        }
 
         // Vertauscht zwei Elemente in der Liste
         //  vi: Der Index des ersten Elementes
         //  ni: Der Index des zweiten Elementes
         void tausch( int vi, int ni )
-		{
-			if( vi < 0 || ni < 0 )
-				return;
-			TYP tmp = get( ni );
-			set( get( vi ), ni );
-			set( tmp, vi );
-		}
+        {
+            if( vi < 0 || ni < 0 )
+                return;
+            TYP tmp = get( ni );
+            set( get( vi ), ni );
+            set( tmp, vi );
+        }
 
         // Löscht alle Elemente der Liste
-		void leeren()
-		{
-			ArrayEintrag< TYP > *e2 = 0;
-			for( ArrayEintrag< TYP > *e = einträge; e; e = e->next )
-			{
-				delete e2;
-				e2 = e;
-			}
-			delete e2;
-			einträge = new ArrayEintrag< TYP >();
-			einträge->set = 0;
-			einträge->next = 0;
-		}
+        void leeren()
+        {
+            ArrayEintrag< TYP > *e2 = 0;
+            for( ArrayEintrag< TYP > *e = einträge; e; e = e->next )
+            {
+                delete e2;
+                e2 = e;
+            }
+            delete e2;
+            einträge = new ArrayEintrag< TYP >();
+            einträge->set = 0;
+            einträge->next = 0;
+        }
 
         // Gibt das Erste Element der Liste zurück.
         // Mit ++ kann durch die Liste iteriert werden
-		ArrayEintrag< TYP > &getArray() 
-		{
-			return *einträge;
-		}
-
-		// Gibt zurück, wie viele Elemente in der Liste sind
-		int getEintragAnzahl() const
-		{
-			int i = 0;
-			for( ArrayEintrag< TYP > *e = einträge; e && ( e->set || e->next ); e = e->next )
-				++i;
-			return i;
-		}
+        ArrayEintrag< TYP > &getArray()
+        {
+            return *einträge;
+        }
+
+        // Gibt zurück, wie viele Elemente in der Liste sind
+        int getEintragAnzahl() const
+        {
+            int i = 0;
+            for( ArrayEintrag< TYP > *e = einträge; e && ( e->set || e->next ); e = e->next )
+                ++i;
+            return i;
+        }
 
         // Gibt den Wert des i-ten Elementes zurück
         //  i: Der index des gesuchten Elementes
         // throws:
         //  std::out_of_range wenn i < 0 oder i >= getEintragAnzahl()
-		TYP get( int i ) const
-		{
+        TYP get( int i ) const
+        {
             if( i < 0 )
             {
                 Text err = "Index out of Range Exception File: ";
@@ -284,11 +284,11 @@ namespace Framework
                 err += i;
                 throw std::out_of_range( err );
             }
-			ArrayEintrag< TYP > *e = einträge;
-			for( int a = 0; a < i && e; ++a )
-				e = e->next;
-			if( e && e->set )
-				return e->var;
+            ArrayEintrag< TYP > *e = einträge;
+            for( int a = 0; a < i && e; ++a )
+                e = e->next;
+            if( e && e->set )
+                return e->var;
             Text err = "Index out of Range Exception File: ";
             err += __FILE__;
             err += " Line: ";
@@ -296,340 +296,340 @@ namespace Framework
             err += " Index: ";
             err += i;
             throw std::out_of_range( err );
-		}
+        }
 
         // Überprüft, ob ein Element in der Liste enthalten ist
-		//  i: Der Index des gesuchten Elementes
+        //  i: Der Index des gesuchten Elementes
         //  return: (true), wenn der Index vorhanden ist. (false) sonnst
         bool hat( int i ) const
-		{
-			if( i < 0 )
-				return 0;
-			ArrayEintrag< TYP > *e = einträge;
-			for( int a = 0; a < i && e; ++a )
-				e = e->next;
-			if( e && e->set )
-				return 1;
-			return 0;
-		}
+        {
+            if( i < 0 )
+                return 0;
+            ArrayEintrag< TYP > *e = einträge;
+            for( int a = 0; a < i && e; ++a )
+                e = e->next;
+            if( e && e->set )
+                return 1;
+            return 0;
+        }
 
         // Gibt den Index eines Wertes zurück
         //  t: Der Wert, nach dem gesucht werden soll
-		int getWertIndex( TYP t ) const
-		{
-			int ret = 0;
-			for( ArrayEintrag< TYP > *e = einträge; e; e = e->next )
-			{
-				if( e->set && e->var == t )
-					return ret;
-				++ret;
-			}
-			return -1;
-		}
+        int getWertIndex( TYP t ) const
+        {
+            int ret = 0;
+            for( ArrayEintrag< TYP > *e = einträge; e; e = e->next )
+            {
+                if( e->set && e->var == t )
+                    return ret;
+                ++ret;
+            }
+            return -1;
+        }
 
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		Array< TYP > *getThis()
-		{
-			++ref;
-			return this;
-		}
+        Array< TYP > *getThis()
+        {
+            ++ref;
+            return this;
+        }
 
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		Array< TYP > *release()
-		{
-			--ref;
-			if( !ref )
-				delete this;
-			return 0;
-		}
-	};
-
-	template< class TYP >
+        Array< TYP > *release()
+        {
+            --ref;
+            if( !ref )
+                delete this;
+            return 0;
+        }
+    };
+
+    template< class TYP >
     // Eine Linked List von Zeigern auf Zeichnunge, die Reference Counting berteiben
-	class RCArray
-	{
-	private:
-		ArrayEintrag< TYP* > *einträge;
-		int ref;
+    class RCArray
+    {
+    private:
+        ArrayEintrag< TYP* > *einträge;
+        int ref;
 
-	public:
+    public:
         // Erstellt eine neue Linked List
-		RCArray()
-		{
-			einträge = new ArrayEintrag< TYP* >();
-			einträge->set = 0;
-			einträge->next = 0;
-			ref = 1;
-		}
+        RCArray()
+        {
+            einträge = new ArrayEintrag< TYP* >();
+            einträge->set = 0;
+            einträge->next = 0;
+            ref = 1;
+        }
 
         // Leert und löscht die Linked List 
-		~RCArray()
-		{
-			leeren();
-			delete einträge;
-		}
+        ~RCArray()
+        {
+            leeren();
+            delete einträge;
+        }
 
         // Hängt ein Element ans Ende der Liste an
         //  t: Das neue Element
-		void add( TYP* t )
-		{
-			for( ArrayEintrag< TYP* > *e = einträge; 1; e = e->next )
-			{
-				if( !e->set && !e->next )
-				{
-					e->var = t;
-					e->set = 1;
-					break;
-				}
-				if( !e->next )
-				{
-					e->next = new ArrayEintrag< TYP* >();
-					if( e->next->set && e->next->var )
-						e->next->var->release();
-					e->next->set = 0;
-					e->next->next = 0;
-				}
-			}
-		}
+        void add( TYP* t )
+        {
+            for( ArrayEintrag< TYP* > *e = einträge; 1; e = e->next )
+            {
+                if( !e->set && !e->next )
+                {
+                    e->var = t;
+                    e->set = 1;
+                    break;
+                }
+                if( !e->next )
+                {
+                    e->next = new ArrayEintrag< TYP* >();
+                    if( e->next->set && e->next->var )
+                        e->next->var->release();
+                    e->next->set = 0;
+                    e->next->next = 0;
+                }
+            }
+        }
 
         // Fügt ein Element bei einer bestimmten Position in die Liste ein
         //  t: das neue Element
         //  i: Die Position, wo das Element eingefügt wird (danach der Index des neuen Elementes)
-		void add( TYP* t, int i )
-		{
-			if( i < 0 )
-			{
-				if( t )
-					t->release();
-				return;
-			}
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-				{
-					ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
-					ne->set = 0;
-					ne->next = 0;
-					e->next = ne;
-				}
-				e = e->next;
-			}
-			ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
-			ne->var = e->var;
-			ne->set = e->set;
-			ne->next = e->next;
-			e->next = ne;
-			e->var = t;
-			e->set = 1;
-		}
+        void add( TYP* t, int i )
+        {
+            if( i < 0 )
+            {
+                if( t )
+                    t->release();
+                return;
+            }
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                {
+                    ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
+                    ne->set = 0;
+                    ne->next = 0;
+                    e->next = ne;
+                }
+                e = e->next;
+            }
+            ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
+            ne->var = e->var;
+            ne->set = e->set;
+            ne->next = e->next;
+            e->next = ne;
+            e->var = t;
+            e->set = 1;
+        }
 
         // Setzt den Wert des i-ten Eintrags
         //  t: der Neue Wert
         //  i: Der Index des Eintrages der gesetzt werden soll
-		void set( TYP* t, int i )
-		{
-			if( i < 0 )
-			{
-				if( t )
-					t->release();
-				return;
-			}
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-				{
-					ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
-					ne->set = 0;
-					ne->next = 0;
-					e->next = ne;
-				}
-				e = e->next;
-			}
-			if( e->set && e->var )
-				e->var->release();
-			e->var = t;
-			e->set = 1;
-		}
+        void set( TYP* t, int i )
+        {
+            if( i < 0 )
+            {
+                if( t )
+                    t->release();
+                return;
+            }
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                {
+                    ArrayEintrag< TYP* > *ne = new ArrayEintrag< TYP* >();
+                    ne->set = 0;
+                    ne->next = 0;
+                    e->next = ne;
+                }
+                e = e->next;
+            }
+            if( e->set && e->var )
+                e->var->release();
+            e->var = t;
+            e->set = 1;
+        }
 
         // Verändert die Position des i-ten Elementes in der Liste
         //  i: Der Index des Elementes, welches verschoben werden soll
         //  p: Die Zielposition des Elementes (danach der neue Index des Elementes)
-		void setPosition( int i, int p )
-		{
-			if( i < 0 || p < 0 || i == p )
-				return;
-			ArrayEintrag< TYP* > *ve = 0;
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-					return;
-				ve = e;
-				e = e->next;
-			}
-			ArrayEintrag< TYP* > *e2 = einträge == e ? e->next : einträge;
-			ArrayEintrag< TYP* > *ve2 = 0;
-			for( int a = 0; a < p; ++a )
-			{
-				if( !e2 )
-					return;
-				ve2 = e2;
-				if( e2->next == e )
-					e2 = e->next;
-				else
-					e2 = e2->next;
-			}
-			if( !e )
-				return;
-			if( !ve2 )
-				einträge = e;
-			else
-				ve2->next = e;
-			if( ve )
-				ve->next = e->next;
-			else
-				einträge = e->next;
-			e->next = e2;
-		}
+        void setPosition( int i, int p )
+        {
+            if( i < 0 || p < 0 || i == p )
+                return;
+            ArrayEintrag< TYP* > *ve = 0;
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                    return;
+                ve = e;
+                e = e->next;
+            }
+            ArrayEintrag< TYP* > *e2 = einträge == e ? e->next : einträge;
+            ArrayEintrag< TYP* > *ve2 = 0;
+            for( int a = 0; a < p; ++a )
+            {
+                if( !e2 )
+                    return;
+                ve2 = e2;
+                if( e2->next == e )
+                    e2 = e->next;
+                else
+                    e2 = e2->next;
+            }
+            if( !e )
+                return;
+            if( !ve2 )
+                einträge = e;
+            else
+                ve2->next = e;
+            if( ve )
+                ve->next = e->next;
+            else
+                einträge = e->next;
+            e->next = e2;
+        }
 
         // Löscht ein Bestimmtes Element
         //  i: Der Index des Elementes das gelöscht werden soll
-		void lösche( int i )
-		{
-			if( i < 0 )
-				return;
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i; ++a )
-			{
-				if( !e->next )
-					return;
-				e = e->next;
-			}
-			if( !e )
-				return;
-			if( e->next )
-			{
-				if( e->set && e->var )
-					e->var->release();
-				e->var = e->next->var;
-				e->set = e->next->set;
-			}
-			else
-			{
-				if( e->set && e->var )
-					e->var->release();
-				e->set = 0;
-			}
-			ArrayEintrag< TYP* > *del = e->next;
-			if( e->next )
-				e->next = e->next->next;
-			else
-				e->next = 0;
-			if( del )
-			{
-				del->set = 0;
-				del->next = 0;
-				delete del;
-			}
-		}
+        void lösche( int i )
+        {
+            if( i < 0 )
+                return;
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i; ++a )
+            {
+                if( !e->next )
+                    return;
+                e = e->next;
+            }
+            if( !e )
+                return;
+            if( e->next )
+            {
+                if( e->set && e->var )
+                    e->var->release();
+                e->var = e->next->var;
+                e->set = e->next->set;
+            }
+            else
+            {
+                if( e->set && e->var )
+                    e->var->release();
+                e->set = 0;
+            }
+            ArrayEintrag< TYP* > *del = e->next;
+            if( e->next )
+                e->next = e->next->next;
+            else
+                e->next = 0;
+            if( del )
+            {
+                del->set = 0;
+                del->next = 0;
+                delete del;
+            }
+        }
 
         // Vertauscht zwei Elemente in der Liste
         //  vi: Der Index des ersten Elementes
         //  ni: Der Index des zweiten Elementes
-		void tausch( int vi, int ni )
-		{
-			if( vi < 0 || ni < 0 )
-				return;
-			TYP* tmp = get( ni );
-			set( get( vi ), ni );
-			set( tmp, vi );
-		}
+        void tausch( int vi, int ni )
+        {
+            if( vi < 0 || ni < 0 )
+                return;
+            TYP* tmp = get( ni );
+            set( get( vi ), ni );
+            set( tmp, vi );
+        }
 
         // Löscht alle Elemente der Liste
-		void leeren()
-		{
-			ArrayEintrag< TYP* > *e2 = 0;
-			for( ArrayEintrag< TYP* > *e = einträge; e; e = e->next )
-			{
-				if( e2 && e2->var && e2->set )
-					e2->var->release();
-				delete e2;
-				e2 = e;
-			}
-			if( e2 && e2->var && e2->set )
-				e2->var->release();
-			delete e2;
-			einträge = new ArrayEintrag< TYP* >();
-			einträge->set = 0;
-			einträge->next = 0;
-		}
+        void leeren()
+        {
+            ArrayEintrag< TYP* > *e2 = 0;
+            for( ArrayEintrag< TYP* > *e = einträge; e; e = e->next )
+            {
+                if( e2 && e2->var && e2->set )
+                    e2->var->release();
+                delete e2;
+                e2 = e;
+            }
+            if( e2 && e2->var && e2->set )
+                e2->var->release();
+            delete e2;
+            einträge = new ArrayEintrag< TYP* >();
+            einträge->set = 0;
+            einträge->next = 0;
+        }
 
         // Gibt das Erste Element der Liste zurück.
         // Mit ++ kann durch die Liste iteriert werden
-		ArrayEintrag< TYP* > &getArray()
-		{
-			return *einträge;
-		}
+        ArrayEintrag< TYP* > &getArray()
+        {
+            return *einträge;
+        }
 
         // Gibt zurück, wie viele Elemente in der Liste sind
-		int getEintragAnzahl() const
-		{
-			int i = 0;
-			for( ArrayEintrag< TYP* > *e = einträge; e && ( e->set || e->next ); e = e->next )
-				++i;
-			return i;
-		}
+        int getEintragAnzahl() const
+        {
+            int i = 0;
+            for( ArrayEintrag< TYP* > *e = einträge; e && ( e->set || e->next ); e = e->next )
+                ++i;
+            return i;
+        }
 
         // Gibt den Wert des i-ten Elementes zurück mit erhöhtem Reference Counter
         //  i: Der index des gesuchten Elementes, (0) wenn der Index nicht existiert
-		TYP *get( int i ) const
-		{
-			if( i < 0 )
-				return (TYP*)0;
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i && e; ++a )
-				e = e->next;
-			if( e && e->set && e->var )
-				return (TYP*)e->var->getThis();
-			return (TYP*)0;
-		}
+        TYP *get( int i ) const
+        {
+            if( i < 0 )
+                return (TYP*)0;
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i && e; ++a )
+                e = e->next;
+            if( e && e->set && e->var )
+                return (TYP*)e->var->getThis();
+            return (TYP*)0;
+        }
 
         // Gibt den Wert des i-ten Elementes zurück ohne erhöhten Reference Counter
         //  i: Der index des gesuchten Elementes, (0) wenn der Index nicht existiert
-		TYP *z( int i ) const // gibt den index - ten T zurück
-		{
-			if( i < 0 )
-				return (TYP*)0;
-			ArrayEintrag< TYP* > *e = einträge;
-			for( int a = 0; a < i && e; ++a )
-				e = e->next;
-			if( e && e->set && e->var )
-				return (TYP*)e->var;
-			return (TYP*)0;
-		}
+        TYP *z( int i ) const // gibt den index - ten T zurück
+        {
+            if( i < 0 )
+                return (TYP*)0;
+            ArrayEintrag< TYP* > *e = einträge;
+            for( int a = 0; a < i && e; ++a )
+                e = e->next;
+            if( e && e->set && e->var )
+                return (TYP*)e->var;
+            return (TYP*)0;
+        }
 
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		RCArray< TYP > *getThis()
-		{
-			++ref;
-			return this;
-		}
+        RCArray< TYP > *getThis()
+        {
+            ++ref;
+            return this;
+        }
 
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		RCArray< TYP > *release()
-		{
-			--ref;
-			if( !ref )
-				delete this;
-			return 0;
-		}
-	};
+        RCArray< TYP > *release()
+        {
+            --ref;
+            if( !ref )
+                delete this;
+            return 0;
+        }
+    };
 }
 
 #endif

AuswahlBox.cpp

@@ -16,1056 +16,1056 @@ using namespace Framework;
 // Inhalt der AuswahlBox Klasse aus AuswahlBox.h
 // Konstruktor 
 AuswahlBox::AuswahlBox()
-	: ZeichnungHintergrund(),
-	schrift( 0 ),
-	msStyle( 0 ),
-	members( new RCArray< TextFeld >() ),
-	ausfahren( new Knopf() ),
-	auswRahmen( new LRahmen() ),
-	auswBgF( 0xFF000000 ),
-	auswBgB( 0 ),
-	auswAf( new AlphaFeld() ),
-	msAuswRahmen( 0 ),
-	msAuswBgF( 0 ),
-	msAuswBgB( 0 ),
-	msAuswAf( 0 ),
-	mausRahmen( new LRahmen() ),
-	mausBgF( 0xFF000000 ),
-	mausBgB( 0 ),
-	mausAf( new AlphaFeld() ),
-	msMausRahmen( 0 ),
-	msMausBgF( 0 ),
-	msMausBgB( 0 ),
-	msMausAf( 0 ),
-	anzahl( 0 ),
-	auswahl( 0 ),
-	ausgeklappt( 0 ),
-	ausklappHöhe( 0 ),
-	ausklapMaxHöhe( 200 ),
-	eintragHöhe( 15 ),
-	tickval( 0 ),
-	mausEintrag( 0 ),
-	scrollAnzeigen( 0 ),
-	eAkP( 0 ),
-	eAk( 0 ),
-	ref( 1 )
+    : ZeichnungHintergrund(),
+    schrift( 0 ),
+    msStyle( 0 ),
+    members( new RCArray< TextFeld >() ),
+    ausfahren( new Knopf() ),
+    auswRahmen( new LRahmen() ),
+    auswBgF( 0xFF000000 ),
+    auswBgB( 0 ),
+    auswAf( new AlphaFeld() ),
+    msAuswRahmen( 0 ),
+    msAuswBgF( 0 ),
+    msAuswBgB( 0 ),
+    msAuswAf( 0 ),
+    mausRahmen( new LRahmen() ),
+    mausBgF( 0xFF000000 ),
+    mausBgB( 0 ),
+    mausAf( new AlphaFeld() ),
+    msMausRahmen( 0 ),
+    msMausBgF( 0 ),
+    msMausBgB( 0 ),
+    msMausAf( 0 ),
+    anzahl( 0 ),
+    auswahl( 0 ),
+    ausgeklappt( 0 ),
+    ausklappHöhe( 0 ),
+    ausklapMaxHöhe( 200 ),
+    eintragHöhe( 15 ),
+    tickval( 0 ),
+    mausEintrag( 0 ),
+    scrollAnzeigen( 0 ),
+    eAkP( 0 ),
+    eAk( 0 ),
+    ref( 1 )
 {
     vertikalScrollBar = new VScrollBar();
     style = Style::Normal;
     rahmen = new LRahmen();
-	rahmen->setFarbe( 0xFFFFFFFF );
-	rahmen->setRamenBreite( 1 );
-	ausfahren->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::KlickBuffer );
-	ausfahren->setKBFarbe( 0xA0000000 );
-	ausfahren->setKBStärke( 10 );
-	ausfahren->setGröße( 18, 18 );
-	ausfahren->setSchriftFarbe( 0xFFFFFFFF );
-	ausfahren->setText( "\\/" );
-	auswRahmen->setFarbe( 0xFF00FF00 );
-	auswRahmen->setRamenBreite( 1 );
-	auswAf->setFarbe( 0xA000FF00 );
-	auswAf->setStärke( 7 );
-	mausRahmen->setFarbe( 0xFF00FF00 );
-	mausRahmen->setRamenBreite( 1 );
-	mausAf->setFarbe( 0x5000FF00 );
-	mausAf->setStärke( 7 );
-	gr.x = 20;
-	gr.y = 20;
+    rahmen->setFarbe( 0xFFFFFFFF );
+    rahmen->setRamenBreite( 1 );
+    ausfahren->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::KlickBuffer );
+    ausfahren->setKBFarbe( 0xA0000000 );
+    ausfahren->setKBStärke( 10 );
+    ausfahren->setGröße( 18, 18 );
+    ausfahren->setSchriftFarbe( 0xFFFFFFFF );
+    ausfahren->setText( "\\/" );
+    auswRahmen->setFarbe( 0xFF00FF00 );
+    auswRahmen->setRamenBreite( 1 );
+    auswAf->setFarbe( 0xA000FF00 );
+    auswAf->setStärke( 7 );
+    mausRahmen->setFarbe( 0xFF00FF00 );
+    mausRahmen->setRamenBreite( 1 );
+    mausAf->setFarbe( 0x5000FF00 );
+    mausAf->setStärke( 7 );
+    gr.x = 20;
+    gr.y = 20;
 }
 
 // Destruktor 
 AuswahlBox::~AuswahlBox()
 {
-	if( schrift )
-		schrift->release();
-	if( msStyle )
-		msStyle->release();
-	if( members )
-		members->release();
-	if( ausfahren )
-		ausfahren->release();
-	if( auswRahmen )
-		auswRahmen->release();
-	if( auswBgB )
-		auswBgB->release();
-	if( auswAf )
-		auswAf->release();
-	if( msAuswRahmen )
-		msAuswRahmen->release();
-	if( msAuswAf )
-		msAuswAf->release();
-	if( msAuswBgB )
-		msAuswBgB->release();
-	if( msAuswBgF )
-		msAuswBgF->release();
-	if( mausRahmen )
-		mausRahmen->release();
-	if( mausAf )
-		mausAf->release();
-	if( mausBgB )
-		mausBgB->release();
-	if( msMausRahmen )
-		msMausRahmen->release();
-	if( msMausAf )
-		msMausAf->release();
-	if( msMausBgB )
-		msMausBgB->release();
-	if( msMausBgF )
-		msMausBgF->release();
+    if( schrift )
+        schrift->release();
+    if( msStyle )
+        msStyle->release();
+    if( members )
+        members->release();
+    if( ausfahren )
+        ausfahren->release();
+    if( auswRahmen )
+        auswRahmen->release();
+    if( auswBgB )
+        auswBgB->release();
+    if( auswAf )
+        auswAf->release();
+    if( msAuswRahmen )
+        msAuswRahmen->release();
+    if( msAuswAf )
+        msAuswAf->release();
+    if( msAuswBgB )
+        msAuswBgB->release();
+    if( msAuswBgF )
+        msAuswBgF->release();
+    if( mausRahmen )
+        mausRahmen->release();
+    if( mausAf )
+        mausAf->release();
+    if( mausBgB )
+        mausBgB->release();
+    if( msMausRahmen )
+        msMausRahmen->release();
+    if( msMausAf )
+        msMausAf->release();
+    if( msMausBgB )
+        msMausBgB->release();
+    if( msMausBgF )
+        msMausBgF->release();
 }
 
 // nicht constant
 void AuswahlBox::setEventParam( void *p ) // setzt den Event Parameter
 {
-	eAkP = p;
+    eAkP = p;
 }
 
 void AuswahlBox::setEventAktion( void( *eAk )( void *p, AuswahlBox *, int, int ) ) // setzt die Event Funktion
 {
-	this->eAk = eAk;
+    this->eAk = eAk;
 }
 
 void AuswahlBox::setSchriftZ( Schrift *schrift ) // setzt die schrift
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
-	ausfahren->setSchriftZ( schrift->getThis() );
-	rend = 1;
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
+    ausfahren->setSchriftZ( schrift->getThis() );
+    rend = 1;
 }
 
 void AuswahlBox::addEintrag( const char *txt ) // Eintrag hinzufügen
 {
-	TextFeld *tf = new TextFeld();
-	if( schrift )
-		tf->setSchriftZ( schrift->getThis() );
-	tf->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
-	tf->setText( txt );
-	tf->setSchriftFarbe( 0xFFFFFFFF );
-	tf->setLinienRahmenFarbe( 0xFFFFFFFF );
-	tf->setGröße( 0, eintragHöhe );
-	members->add( tf, anzahl );
-	++anzahl;
-	rend = 1;
+    TextFeld *tf = new TextFeld();
+    if( schrift )
+        tf->setSchriftZ( schrift->getThis() );
+    tf->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
+    tf->setText( txt );
+    tf->setSchriftFarbe( 0xFFFFFFFF );
+    tf->setLinienRahmenFarbe( 0xFFFFFFFF );
+    tf->setGröße( 0, eintragHöhe );
+    members->add( tf, anzahl );
+    ++anzahl;
+    rend = 1;
 }
 
 void AuswahlBox::addEintrag( Text *txt )
 {
-	TextFeld *tf = new TextFeld();
-	if( schrift )
-		tf->setSchriftZ( schrift->getThis() );
-	tf->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
-	tf->setText( txt );
-	tf->setSchriftFarbe( 0xFFFFFFFF );
-	tf->setLinienRahmenFarbe( 0xFFFFFFFF );
-	tf->setGröße( 0, eintragHöhe );
-	members->add( tf, anzahl );
-	++anzahl;
-	rend = 1;
+    TextFeld *tf = new TextFeld();
+    if( schrift )
+        tf->setSchriftZ( schrift->getThis() );
+    tf->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
+    tf->setText( txt );
+    tf->setSchriftFarbe( 0xFFFFFFFF );
+    tf->setLinienRahmenFarbe( 0xFFFFFFFF );
+    tf->setGröße( 0, eintragHöhe );
+    members->add( tf, anzahl );
+    ++anzahl;
+    rend = 1;
 }
 
 void AuswahlBox::addEintragZ( TextFeld *txt )
 {
-	members->add( txt, anzahl );
-	++anzahl;
-	rend = 1;
+    members->add( txt, anzahl );
+    ++anzahl;
+    rend = 1;
 }
 
 void AuswahlBox::setEintrag( int i, const char *txt ) // Eintrag setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setText( txt );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setText( txt );
+    rend = 1;
 }
 
 void AuswahlBox::setEintrag( int i, Text *txt )
 {
-	if( members->z( i ) )
-		members->z( i )->setText( txt );
-	else
-		txt->release();
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setText( txt );
+    else
+        txt->release();
+    rend = 1;
 }
 
 void AuswahlBox::setEintragZ( int i, TextFeld *txt )
 {
-	if( i < anzahl )
-		members->set( txt, i );
-	else
-		txt->release();
-	rend = 1;
+    if( i < anzahl )
+        members->set( txt, i );
+    else
+        txt->release();
+    rend = 1;
 }
 
 void AuswahlBox::löscheEintrag( int i ) // Eintrag entfernen
 {
-	if( i < anzahl )
-	{
-		members->lösche( i );
-		if( msStyle )
-			msStyle->lösche( i );
-		if( msAuswRahmen )
-			msAuswRahmen->lösche( i );
-		if( msAuswBgF )
-			msAuswBgF->lösche( i );
-		if( msAuswBgB )
-			msAuswBgB->lösche( i );
-		if( msAuswAf )
-			msAuswAf->lösche( i );
-		if( msMausRahmen )
-			msMausRahmen->lösche( i );
-		if( msMausBgF )
-			msMausBgF->lösche( i );
-		if( msMausBgB )
-			msMausBgB->lösche( i );
-		if( msMausAf )
-			msMausAf->lösche( i );
-		if( auswahl > i )
-			--auswahl;
-		if( mausEintrag > i )
-			--mausEintrag;
-		--anzahl;
-		rend = 1;
-	}
+    if( i < anzahl )
+    {
+        members->lösche( i );
+        if( msStyle )
+            msStyle->lösche( i );
+        if( msAuswRahmen )
+            msAuswRahmen->lösche( i );
+        if( msAuswBgF )
+            msAuswBgF->lösche( i );
+        if( msAuswBgB )
+            msAuswBgB->lösche( i );
+        if( msAuswAf )
+            msAuswAf->lösche( i );
+        if( msMausRahmen )
+            msMausRahmen->lösche( i );
+        if( msMausBgF )
+            msMausBgF->lösche( i );
+        if( msMausBgB )
+            msMausBgB->lösche( i );
+        if( msMausAf )
+            msMausAf->lösche( i );
+        if( auswahl > i )
+            --auswahl;
+        if( mausEintrag > i )
+            --mausEintrag;
+        --anzahl;
+        rend = 1;
+    }
 }
 
 void AuswahlBox::setAusklappKnopfZ( Knopf *ausK ) // Ausklapp Knopf setzen
 {
-	if( ausfahren )
-		ausfahren->release();
-	ausfahren = ausK;
-	rend = 1;
+    if( ausfahren )
+        ausfahren->release();
+    ausfahren = ausK;
+    rend = 1;
 }
 
 void AuswahlBox::setEintragRahmenZ( int i, LRahmen *rahmen ) // Eintrag Rahmen setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setLinienRahmenZ( rahmen );
-	else
-		rahmen->release();
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setLinienRahmenZ( rahmen );
+    else
+        rahmen->release();
+    rend = 1;
 }
 
 void AuswahlBox::setEintragRahmenFarbe( int i, int f ) // Eintrag Rahmen Farbe setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setLinienRahmenFarbe( f );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setLinienRahmenFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setEintragRahmenBreite( int i, int rbr ) // Eintrag Rahmen Breite setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setLinienRahmenBreite( rbr );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setLinienRahmenBreite( rbr );
+    rend = 1;
 }
 
 void AuswahlBox::setEintragHintergrundFarbe( int i, int f ) // Eintrag Hintergrund farbe setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setHintergrundFarbe( f );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setHintergrundFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setEintragHintergrundBildZ( int i, Bild *bgB ) // Eintrag Hintergrund Bild setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setHintergrundBildZ( bgB );
-	else
-		bgB->release();
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setHintergrundBildZ( bgB );
+    else
+        bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setEintragHintergrundBild( int i, Bild *bgB )
 {
-	if( members->z( i ) )
-		members->z( i )->setHintergrundBild( bgB );
-	else
-		bgB->release();
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setHintergrundBild( bgB );
+    else
+        bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setEintragAlphaFeldZ( int i, AlphaFeld *af ) // Eintrag AlphaFeld setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setAlphaFeldZ( af );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setAlphaFeldZ( af );
+    rend = 1;
 }
 
 void AuswahlBox::setEintragAlphaFeldFarbe( int i, int afF ) // Eintrag AlphaFeld Farbe setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setAlphaFeldFarbe( afF );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setAlphaFeldFarbe( afF );
+    rend = 1;
 }
 
 void AuswahlBox::setEintragAlphaFeldStärke( int i, int afSt ) // Eintrag AlphaFeld Stärke setzen
 {
-	if( members->z( i ) )
-		members->z( i )->setAlphaFeldStärke( afSt );
-	rend = 1;
+    if( members->z( i ) )
+        members->z( i )->setAlphaFeldStärke( afSt );
+    rend = 1;
 }
 
 void AuswahlBox::setAuswRahmenZ( LRahmen *rahmen ) // Auswahl Rahmen setzen
 {
-	if( auswRahmen )
-		auswRahmen->release();
-	auswRahmen = rahmen;
-	rend = 1;
+    if( auswRahmen )
+        auswRahmen->release();
+    auswRahmen = rahmen;
+    rend = 1;
 }
 
 void AuswahlBox::setAuswRahmenFarbe( int f ) // Auswahl Rahmen Farbe setzen
 {
-	if( !auswRahmen )
-		auswRahmen = new LRahmen();
-	auswRahmen->setFarbe( f );
-	rend = 1;
+    if( !auswRahmen )
+        auswRahmen = new LRahmen();
+    auswRahmen->setFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setAuswRahmenBreite( int rbr ) // Auswahl Rahmen Breite setzen
 {
-	if( !auswRahmen )
-		auswRahmen = new LRahmen();
-	auswRahmen->setRamenBreite( rbr );
-	rend = 1;
+    if( !auswRahmen )
+        auswRahmen = new LRahmen();
+    auswRahmen->setRamenBreite( rbr );
+    rend = 1;
 }
 
 void AuswahlBox::setAuswHintergrundFarbe( int f ) // Auswahl Hintergrund Farbe setzen
 {
-	auswBgF = f;
-	rend = 1;
+    auswBgF = f;
+    rend = 1;
 }
 
 void AuswahlBox::setAuswHintergrundBildZ( Bild *bgB ) // Auswahl Hintergrund Bild setzen
 {
-	if( auswBgB )
-		auswBgB->release();
-	auswBgB = bgB;
-	rend = 1;
+    if( auswBgB )
+        auswBgB->release();
+    auswBgB = bgB;
+    rend = 1;
 }
 
 void AuswahlBox::setAuswHintergrundBild( Bild *bgB )
 {
-	if( !auswBgB )
-		auswBgB = new Bild();
-	auswBgB->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-	auswBgB->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-	bgB->release();
-	rend = 1;
+    if( !auswBgB )
+        auswBgB = new Bild();
+    auswBgB->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+    auswBgB->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+    bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setAuswAlphaFeldZ( AlphaFeld *af ) // Auswahl AlphaFeld setzen
 {
-	if( auswAf )
-		auswAf->release();
-	auswAf = af;
-	rend = 1;
+    if( auswAf )
+        auswAf->release();
+    auswAf = af;
+    rend = 1;
 }
 
 void AuswahlBox::setAuswAlphaFeldFarbe( int afF ) // Auswahl AlphaFeld Farbe setzen
 {
-	if( !auswAf )
-		auswAf = new AlphaFeld();
-	auswAf->setFarbe( afF );
-	rend = 1;
+    if( !auswAf )
+        auswAf = new AlphaFeld();
+    auswAf->setFarbe( afF );
+    rend = 1;
 }
 
 void AuswahlBox::setAuswAlphaFeldStärke( int afSt ) // Auswahl Alpha Feld stärke setzen
 {
-	if( !auswAf )
-		auswAf = new AlphaFeld();
-	auswAf->setStärke( afSt );
-	rend = 1;
+    if( !auswAf )
+        auswAf = new AlphaFeld();
+    auswAf->setStärke( afSt );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswRahmenZ( int i, LRahmen *rahmen ) // Multistyle Auswahl Rahmen setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		rahmen->release();
-		return;
-	}
-	if( !msAuswRahmen )
-		msAuswRahmen = new RCArray< LRahmen >();
-	msAuswRahmen->set( rahmen, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        rahmen->release();
+        return;
+    }
+    if( !msAuswRahmen )
+        msAuswRahmen = new RCArray< LRahmen >();
+    msAuswRahmen->set( rahmen, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswRahmenFarbe( int i, int f ) // Multistyle Auswahl Rahmen Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msAuswRahmen )
-		msAuswRahmen = new RCArray< LRahmen >();
-	if( !msAuswRahmen->z( i ) )
-		msAuswRahmen->set( new LRahmen(), i );
-	msAuswRahmen->z( i )->setFarbe( f );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msAuswRahmen )
+        msAuswRahmen = new RCArray< LRahmen >();
+    if( !msAuswRahmen->z( i ) )
+        msAuswRahmen->set( new LRahmen(), i );
+    msAuswRahmen->z( i )->setFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswRahmenBreite( int i, int rbr ) // Multistyle Auswahl Breite setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msAuswRahmen )
-		msAuswRahmen = new RCArray< LRahmen >();
-	if( !msAuswRahmen->z( i ) )
-		msAuswRahmen->set( new LRahmen(), i );
-	msAuswRahmen->z( i )->setRamenBreite( rbr );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msAuswRahmen )
+        msAuswRahmen = new RCArray< LRahmen >();
+    if( !msAuswRahmen->z( i ) )
+        msAuswRahmen->set( new LRahmen(), i );
+    msAuswRahmen->z( i )->setRamenBreite( rbr );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswHintergrundFarbe( int i, int f ) // Multistyle Auswahl Hintergrund Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msAuswBgF )
-		msAuswBgF = new Array< int >();
-	msAuswBgF->set( f, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msAuswBgF )
+        msAuswBgF = new Array< int >();
+    msAuswBgF->set( f, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswHintergrundBildZ( int i, Bild *bgB ) // Multistyle Auswahl Hintergrund Bild setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		bgB->release();
-		return;
-	}
-	if( !msAuswBgB )
-		msAuswBgB = new RCArray< Bild >();
-	msAuswBgB->set( bgB, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        bgB->release();
+        return;
+    }
+    if( !msAuswBgB )
+        msAuswBgB = new RCArray< Bild >();
+    msAuswBgB->set( bgB, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswHintergrundBild( int i, Bild *bgB )
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		bgB->release();
-		return;
-	}
-	if( !msAuswBgB )
-		msAuswBgB = new RCArray< Bild >();
-	if( !msAuswBgB->z( i ) )
-	{
-		Bild *z = new Bild;
-		z->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-		z->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-		msAuswBgB->set( z, i );
-	}
-	else
-	{
-		msAuswBgB->z( i )->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-		msAuswBgB->z( i )->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-	}
-	bgB->release();
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        bgB->release();
+        return;
+    }
+    if( !msAuswBgB )
+        msAuswBgB = new RCArray< Bild >();
+    if( !msAuswBgB->z( i ) )
+    {
+        Bild *z = new Bild;
+        z->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+        z->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+        msAuswBgB->set( z, i );
+    }
+    else
+    {
+        msAuswBgB->z( i )->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+        msAuswBgB->z( i )->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+    }
+    bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswAlphaFeldZ( int i, AlphaFeld *af ) // Multistyle Auswahl AlphaFeld setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		af->release();
-		return;
-	}
-	if( !msAuswAf )
-		msAuswAf = new RCArray< AlphaFeld >();
-	msAuswAf->set( af, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        af->release();
+        return;
+    }
+    if( !msAuswAf )
+        msAuswAf = new RCArray< AlphaFeld >();
+    msAuswAf->set( af, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswAlphaFeldFarbe( int i, int afF ) // Multistyle Auswahl AlphaFeld Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msAuswAf )
-		msAuswAf = new RCArray< AlphaFeld >();
-	if( !msAuswAf->z( i ) )
-		msAuswAf->set( new AlphaFeld(), i );
-	msAuswAf->z( i )->setFarbe( afF );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msAuswAf )
+        msAuswAf = new RCArray< AlphaFeld >();
+    if( !msAuswAf->z( i ) )
+        msAuswAf->set( new AlphaFeld(), i );
+    msAuswAf->z( i )->setFarbe( afF );
+    rend = 1;
 }
 
 void AuswahlBox::setMsAuswAlphaFeldStärke( int i, int afSt ) // Multistyle Auswahl AlphaFeld stärke setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msAuswAf )
-		msAuswAf = new RCArray< AlphaFeld >();
-	if( !msAuswAf->z( i ) )
-		msAuswAf->set( new AlphaFeld(), i );
-	msAuswAf->z( i )->setStärke( afSt );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msAuswAf )
+        msAuswAf = new RCArray< AlphaFeld >();
+    if( !msAuswAf->z( i ) )
+        msAuswAf->set( new AlphaFeld(), i );
+    msAuswAf->z( i )->setStärke( afSt );
+    rend = 1;
 }
 
 void AuswahlBox::setMausRahmenZ( LRahmen *rahmen ) // Maus Rahmen setzen
 {
-	if( mausRahmen )
-		mausRahmen->release();
-	mausRahmen = rahmen;
-	rend = 1;
+    if( mausRahmen )
+        mausRahmen->release();
+    mausRahmen = rahmen;
+    rend = 1;
 }
 
 void AuswahlBox::setMausRahmenFarbe( int f ) // Maus Rahmen Farbe setzen
 {
-	if( !mausRahmen )
-		mausRahmen = new LRahmen();
-	mausRahmen->setFarbe( f );
-	rend = 1;
+    if( !mausRahmen )
+        mausRahmen = new LRahmen();
+    mausRahmen->setFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setMausRahmenBreite( int rbr ) // Maus Rahmen breite setzen
 {
-	if( !mausRahmen )
-		mausRahmen = new LRahmen();
-	mausRahmen->setRamenBreite( rbr );
-	rend = 1;
+    if( !mausRahmen )
+        mausRahmen = new LRahmen();
+    mausRahmen->setRamenBreite( rbr );
+    rend = 1;
 }
 
 void AuswahlBox::setMausHintergrundFarbe( int f ) // Maus Hintergrund Farbe setzen
 {
-	mausBgF = f;
-	rend = 1;
+    mausBgF = f;
+    rend = 1;
 }
 
 void AuswahlBox::setMausHintergrundBildZ( Bild *bgB ) // Maus Hintergrund Bild setzen
 {
-	if( mausBgB )
-		mausBgB->release();
-	mausBgB = bgB;
-	rend = 1;
+    if( mausBgB )
+        mausBgB->release();
+    mausBgB = bgB;
+    rend = 1;
 }
 
 void AuswahlBox::setMausHintergrundBild( Bild *bgB )
 {
-	if( !mausBgB )
-		mausBgB = new Bild();
-	mausBgB->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-	mausBgB->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-	bgB->release();
-	rend = 1;
+    if( !mausBgB )
+        mausBgB = new Bild();
+    mausBgB->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+    mausBgB->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+    bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setMausAlphaFeldZ( AlphaFeld *af ) // Maus AlphaFeld setzen
 {
-	if( mausAf )
-		mausAf->release();
-	mausAf = af;
-	rend = 1;
+    if( mausAf )
+        mausAf->release();
+    mausAf = af;
+    rend = 1;
 }
 
 void AuswahlBox::setMausAlphaFeldFarbe( int afF ) // Maus AlphaFeld Farbe setzen
 {
-	if( !mausAf )
-		mausAf = new AlphaFeld();
-	mausAf->setFarbe( afF );
-	rend = 1;
+    if( !mausAf )
+        mausAf = new AlphaFeld();
+    mausAf->setFarbe( afF );
+    rend = 1;
 }
 
 void AuswahlBox::setMausAlphaFeldStärke( int afSt ) // Maus AlphaFeld stärke setzen
 {
-	if( !mausAf )
-		mausAf = new AlphaFeld();
-	mausAf->setStärke( afSt );
-	rend = 1;
+    if( !mausAf )
+        mausAf = new AlphaFeld();
+    mausAf->setStärke( afSt );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausRahmenZ( int i, LRahmen *rahmen ) // Multistyle Maus Rahmen setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		rahmen->release();
-		return;
-	}
-	if( !msMausRahmen )
-		msMausRahmen = new RCArray< LRahmen >();
-	msMausRahmen->set( rahmen, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        rahmen->release();
+        return;
+    }
+    if( !msMausRahmen )
+        msMausRahmen = new RCArray< LRahmen >();
+    msMausRahmen->set( rahmen, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausRahmenFarbe( int i, int f ) // Multistyle Maus Rahmen Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msMausRahmen )
-		msMausRahmen = new RCArray< LRahmen >();
-	if( !msMausRahmen->z( i ) )
-		msMausRahmen->set( new LRahmen(), i );
-	msMausRahmen->z( i )->setFarbe( f );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msMausRahmen )
+        msMausRahmen = new RCArray< LRahmen >();
+    if( !msMausRahmen->z( i ) )
+        msMausRahmen->set( new LRahmen(), i );
+    msMausRahmen->z( i )->setFarbe( f );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausRahmenBreite( int i, int rbr ) // Multistyle Maus Rahmen breite setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msMausRahmen )
-		msMausRahmen = new RCArray< LRahmen >();
-	if( !msMausRahmen->z( i ) )
-		msMausRahmen->set( new LRahmen(), i );
-	msMausRahmen->z( i )->setRamenBreite( rbr );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msMausRahmen )
+        msMausRahmen = new RCArray< LRahmen >();
+    if( !msMausRahmen->z( i ) )
+        msMausRahmen->set( new LRahmen(), i );
+    msMausRahmen->z( i )->setRamenBreite( rbr );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausHintergrundFarbe( int i, int f ) // Multistyle Maus Hintergrund Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msMausBgF )
-		msMausBgF = new Array< int >();
-	msMausBgF->set( f, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msMausBgF )
+        msMausBgF = new Array< int >();
+    msMausBgF->set( f, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausHintergrundBildZ( int i, Bild *bgB ) // Multistyle Maus Hintergrund Bild setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		bgB->release();
-		return;
-	}
-	if( !msMausBgB )
-		msMausBgB = new RCArray< Bild >();
-	msMausBgB->set( bgB, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        bgB->release();
+        return;
+    }
+    if( !msMausBgB )
+        msMausBgB = new RCArray< Bild >();
+    msMausBgB->set( bgB, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausHintergrundBild( int i, Bild *bgB )
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		bgB->release();
-		return;
-	}
-	if( !msMausBgB )
-		msMausBgB = new RCArray< Bild >();
-	if( !msMausBgB->z( i ) )
-	{
-		Bild *z = new Bild;
-		z->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-		z->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-		msMausBgB->set( z, i );
-	}
-	else
-	{
-		msMausBgB->z( i )->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
-		msMausBgB->z( i )->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
-	}
-	bgB->release();
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        bgB->release();
+        return;
+    }
+    if( !msMausBgB )
+        msMausBgB = new RCArray< Bild >();
+    if( !msMausBgB->z( i ) )
+    {
+        Bild *z = new Bild;
+        z->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+        z->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+        msMausBgB->set( z, i );
+    }
+    else
+    {
+        msMausBgB->z( i )->neuBild( bgB->getBreite(), bgB->getHöhe(), 0 );
+        msMausBgB->z( i )->drawBild( 0, 0, bgB->getBreite(), bgB->getHöhe(), *bgB );
+    }
+    bgB->release();
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausAlphaFeldZ( int i, AlphaFeld *af ) // Multistyle Maus AlphaFeld setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-	{
-		af->release();
-		return;
-	}
-	if( !msMausAf )
-		msMausAf = new RCArray< AlphaFeld >();
-	msMausAf->set( af, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+    {
+        af->release();
+        return;
+    }
+    if( !msMausAf )
+        msMausAf = new RCArray< AlphaFeld >();
+    msMausAf->set( af, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausAlphaFeldFarbe( int i, int afF ) // Multistyle Maus AlphaFeld Farbe setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msMausAf )
-		msMausAf = new RCArray< AlphaFeld >();
-	if( !msMausAf->z( i ) )
-		msMausAf->set( new AlphaFeld(), i );
-	msMausAf->z( i )->setFarbe( afF );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msMausAf )
+        msMausAf = new RCArray< AlphaFeld >();
+    if( !msMausAf->z( i ) )
+        msMausAf->set( new AlphaFeld(), i );
+    msMausAf->z( i )->setFarbe( afF );
+    rend = 1;
 }
 
 void AuswahlBox::setMsMausAlphaFeldStärke( int i, int afSt ) // Multistyle Maus AlphaFeld stärke setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msMausAf )
-		msMausAf = new RCArray< AlphaFeld >();
-	if( !msMausAf->z( i ) )
-		msMausAf->set( new AlphaFeld(), i );
-	msMausAf->z( i )->setStärke( afSt );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msMausAf )
+        msMausAf = new RCArray< AlphaFeld >();
+    if( !msMausAf->z( i ) )
+        msMausAf->set( new AlphaFeld(), i );
+    msMausAf->z( i )->setStärke( afSt );
+    rend = 1;
 }
 
 void AuswahlBox::setAuswahl( int i ) // Eintrag auswählen
 {
-	if( i < anzahl )
-	{
-		auswahl = i;
-		if( eAk )
-			eAk( eAkP, this, 0, auswahl );
-		rend = 1;
-	}
+    if( i < anzahl )
+    {
+        auswahl = i;
+        if( eAk )
+            eAk( eAkP, this, 0, auswahl );
+        rend = 1;
+    }
 }
 
 void AuswahlBox::ausklappen() // liste ausklappen
 {
-	ausgeklappt = 1;
+    ausgeklappt = 1;
 }
 
 void AuswahlBox::einklappen() // liste einklappen
 {
-	ausgeklappt = 0;
+    ausgeklappt = 0;
 }
 
 void AuswahlBox::scrollZuEintrag( int i ) // liste scrollen
 {
-	if( hatStyle( Style::VScroll ) && vertikalScrollBar && i < anzahl )
-	{
-		int scrollPos = 0;
-		if( hatStyle( Style::MultiStyled ) )
-		{
-			for( int j = 0; j < i; ++j )
-				scrollPos += members->z( j ) ? members->z( j )->getHöhe() : 0;
-		}
-		else
-			scrollPos += i * eintragHöhe;
+    if( hatStyle( Style::VScroll ) && vertikalScrollBar && i < anzahl )
+    {
+        int scrollPos = 0;
+        if( hatStyle( Style::MultiStyled ) )
+        {
+            for( int j = 0; j < i; ++j )
+                scrollPos += members->z( j ) ? members->z( j )->getHöhe() : 0;
+        }
+        else
+            scrollPos += i * eintragHöhe;
         vertikalScrollBar->scroll( scrollPos );
-		rend = 1;
-	}
+        rend = 1;
+    }
 }
 
 void AuswahlBox::setMaxAuskappHöhe( int maxHöhe ) // höhe der Liste beim ausklappen
 {
-	ausklapMaxHöhe = maxHöhe;
+    ausklapMaxHöhe = maxHöhe;
 }
 
 void AuswahlBox::setEintragHöhe( int höhe ) // setzt die Höhe der Einträge
 {
-	eintragHöhe = höhe;
+    eintragHöhe = höhe;
 }
 
 void AuswahlBox::addMsStyle( int i, __int64 abStyle ) // Multistyle style hinzufügen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msStyle )
-		msStyle = new Array< __int64 >();
-	msStyle->set( msStyle->get( i ) | abStyle, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msStyle )
+        msStyle = new Array< __int64 >();
+    msStyle->set( msStyle->get( i ) | abStyle, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsStyle( int i, __int64 abStyle, bool add ) // Multistyle style setzen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msStyle )
-		msStyle = new Array< __int64 >();
-	if( add )
-		msStyle->set( msStyle->get( i ) | abStyle, i );
-	else
-		msStyle->set( msStyle->get( i ) & ~abStyle, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msStyle )
+        msStyle = new Array< __int64 >();
+    if( add )
+        msStyle->set( msStyle->get( i ) | abStyle, i );
+    else
+        msStyle->set( msStyle->get( i ) & ~abStyle, i );
+    rend = 1;
 }
 
 void AuswahlBox::setMsStyle( int i, __int64 abStyle )
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msStyle )
-		msStyle = new Array< __int64 >();
-	msStyle->set( abStyle, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msStyle )
+        msStyle = new Array< __int64 >();
+    msStyle->set( abStyle, i );
+    rend = 1;
 }
 
 void AuswahlBox::löscheMsStyle( int i, __int64 abStyle ) // Multistyle style entfernen
 {
-	if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
-		return;
-	if( !msStyle )
-		msStyle = new Array< __int64 >();
-	msStyle->set( msStyle->get( i ) & ~abStyle, i );
-	rend = 1;
+    if( hatStyleNicht( Style::MultiStyled ) || i >= anzahl )
+        return;
+    if( !msStyle )
+        msStyle = new Array< __int64 >();
+    msStyle->set( msStyle->get( i ) & ~abStyle, i );
+    rend = 1;
 }
 
 bool AuswahlBox::tick( double tickVal ) // tick
 {
-	if( ausgeklappt && ausfahren && !ausfahren->zText()->istGleich( "/\\" ) )
-	{
-		ausfahren->setText( "/\\" );
-		rend = 1;
-	}
-	else if( !ausgeklappt && ausfahren && !ausfahren->zText()->istGleich( "\\/" ) )
-	{
-		ausfahren->setText( "\\/" );
-		rend = 1;
-	}
-	if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
-		ausgeklappt = 0;
-	rend |= ausfahren->tick( tickVal );
-	this->tickval += tickVal * 300;
-	int val = ( int )this->tickval;
-	if( val < 1 )
-		return __super::tick( tickVal );
-	this->tickval -= val;
-	int maxHöhe = rahmen ? rahmen->getRBreite() : 0;
-	if( hatStyleNicht( Style::MultiStyled ) )
-		maxHöhe += anzahl * eintragHöhe;
-	else
-	for( int i = 0; i < anzahl; ++i )
-		maxHöhe += members->z( i ) ? members->z( i )->getHöhe() : 0;
-	if( maxHöhe > ausklapMaxHöhe )
-	{
-		if( hatStyle( Style::VScroll ) && vertikalScrollBar )
-		{
-			scrollAnzeigen = 1;
+    if( ausgeklappt && ausfahren && !ausfahren->zText()->istGleich( "/\\" ) )
+    {
+        ausfahren->setText( "/\\" );
+        rend = 1;
+    }
+    else if( !ausgeklappt && ausfahren && !ausfahren->zText()->istGleich( "\\/" ) )
+    {
+        ausfahren->setText( "\\/" );
+        rend = 1;
+    }
+    if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
+        ausgeklappt = 0;
+    rend |= ausfahren->tick( tickVal );
+    this->tickval += tickVal * 300;
+    int val = ( int )this->tickval;
+    if( val < 1 )
+        return __super::tick( tickVal );
+    this->tickval -= val;
+    int maxHöhe = rahmen ? rahmen->getRBreite() : 0;
+    if( hatStyleNicht( Style::MultiStyled ) )
+        maxHöhe += anzahl * eintragHöhe;
+    else
+        for( int i = 0; i < anzahl; ++i )
+            maxHöhe += members->z( i ) ? members->z( i )->getHöhe() : 0;
+    if( maxHöhe > ausklapMaxHöhe )
+    {
+        if( hatStyle( Style::VScroll ) && vertikalScrollBar )
+        {
+            scrollAnzeigen = 1;
             vertikalScrollBar->update( maxHöhe, ausklapMaxHöhe );
-		}
-		maxHöhe = ausklapMaxHöhe;
-	}
-	else
-		scrollAnzeigen = 0;
-	if( ausgeklappt )
-	{
-		if( ausklappHöhe < maxHöhe )
-		{
-			ausklappHöhe += val;
-			if( ausklappHöhe > maxHöhe )
-				ausklappHöhe = maxHöhe;
-			rend = 1;
-		}
-	}
-	else
-	{
-		if( ausklappHöhe > 0 )
-		{
-			ausklappHöhe -= val;
-			if( ausklappHöhe < 0 )
-				ausklappHöhe = 0;
-			rend = 1;
-		}
-	}
-	for( int i = 0; i < anzahl; ++i )
-	{
-		if( i != auswahl )
-			rend |= members->z( i )->tick( tickVal );
-		else
-			members->z( i )->tick( tickVal );
-	}
+        }
+        maxHöhe = ausklapMaxHöhe;
+    }
+    else
+        scrollAnzeigen = 0;
+    if( ausgeklappt )
+    {
+        if( ausklappHöhe < maxHöhe )
+        {
+            ausklappHöhe += val;
+            if( ausklappHöhe > maxHöhe )
+                ausklappHöhe = maxHöhe;
+            rend = 1;
+        }
+    }
+    else
+    {
+        if( ausklappHöhe > 0 )
+        {
+            ausklappHöhe -= val;
+            if( ausklappHöhe < 0 )
+                ausklappHöhe = 0;
+            rend = 1;
+        }
+    }
+    for( int i = 0; i < anzahl; ++i )
+    {
+        if( i != auswahl )
+            rend |= members->z( i )->tick( tickVal );
+        else
+            members->z( i )->tick( tickVal );
+    }
     return __super::tick( tickVal );
 }
 
 void AuswahlBox::doMausEreignis( MausEreignis &me ) // Maus
 {
-	if( me.id == ME_DScroll )
-		int i = 0;
-	mausEintrag = -1;
-	if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
-	{
-		if( toolTip )
-			toolTip->setMausIn( 0 );
-		ausgeklappt = 0;
-		return;
-	}
-	bool removeFokus = 0;
+    if( me.id == ME_DScroll )
+        int i = 0;
+    mausEintrag = -1;
+    if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
+    {
+        if( toolTip )
+            toolTip->setMausIn( 0 );
+        ausgeklappt = 0;
+        return;
+    }
+    bool removeFokus = 0;
     bool nmakc = me.verarbeitet == 0;
-	if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y + ausklappHöhe ) )
-	{
-		if( mausIn )
-		{
-			if( toolTip )
-				toolTip->setMausIn( 0 );
-			mausIn = 0;
-			MausEreignis me2;
-			me2.id = ME_Verlässt;
-			me2.mx = me.mx;
-			me2.my = me.my;
-			me2.verarbeitet = 0;
-			doMausEreignis( me2 );
-			return;
-		}
-		removeFokus = 1;
-	}
-	if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y + ausklappHöhe ) && me.id != ME_Verlässt )
-	{
-		if( removeFokus && me.id == ME_RLinks )
-		{
-			if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
-				löscheStyle( Style::Fokus );
-			ausgeklappt = 0;
+    if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y + ausklappHöhe ) )
+    {
+        if( mausIn )
+        {
+            if( toolTip )
+                toolTip->setMausIn( 0 );
+            mausIn = 0;
+            MausEreignis me2;
+            me2.id = ME_Verlässt;
+            me2.mx = me.mx;
+            me2.my = me.my;
+            me2.verarbeitet = 0;
+            doMausEreignis( me2 );
+            return;
+        }
+        removeFokus = 1;
+    }
+    if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y + ausklappHöhe ) && me.id != ME_Verlässt )
+    {
+        if( removeFokus && me.id == ME_RLinks )
+        {
+            if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
+                löscheStyle( Style::Fokus );
+            ausgeklappt = 0;
             me.mx -= pos.x, me.my -= pos.y;
             if( nmakc && me.verarbeitet && nMak )
                 me.verarbeitet = nMak( nmakParam, this, me );
             me.mx += pos.x, me.my += pos.y;
-		}
-		if( toolTip )
-			toolTip->setMausIn( 0 );
-		return;
-	}
-	if( !mausIn && me.id != ME_Verlässt )
-	{
-		mausIn = 1;
-		if( toolTip )
-			toolTip->setMausIn( 1 );
-		MausEreignis me2;
-		me2.id = ME_Betritt;
-		me2.mx = me.mx;
-		me2.my = me.my;
-		me2.verarbeitet = 0;
-		doMausEreignis( me2 );
-	}
-	me.mx -= pos.x, me.my -= pos.y;
-	if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
-	{
-		bool vera = me.verarbeitet;
-		if( ausfahren )
-		{
-			int tmpMx = me.mx;
-			int tmpMy = me.my;
-			if( me.mx > 0 && me.my > 0 && me.mx < gr.x && me.my < gr.y )
-				me.mx = ausfahren->getX() + 1, me.my = ausfahren->getY() + 1;
-			else
-				me.mx = ausfahren->getX() - 1, me.my = ausfahren->getY() - 1;
-			ausfahren->doMausEreignis( me );
-			me.mx = tmpMx, me.my = tmpMy;
-		}
-		if( me.verarbeitet && !vera && me.id == ME_RLinks )
-		{
-			ausgeklappt = !ausgeklappt;
-			if( ausgeklappt )
-				mausEintrag = auswahl;
-			if( scrollAnzeigen )
-				scrollZuEintrag( mausEintrag );
-		}
-		if( removeFokus && me.id == ME_RLinks )
-			löscheStyle( Style::Fokus );
-		if( !me.verarbeitet && hatStyleNicht( Style::Fokus ) && me.id == ME_RLinks )
-			addStyle( Style::Fokus );
-		if( hatStyle( Style::VScroll ) && vertikalScrollBar && ausgeklappt && scrollAnzeigen )
-		{
-			int rbr = 0;
-			if( rahmen && hatStyle( Style::Rahmen ) )
-				rbr = rahmen->getRBreite();
-			if( ( ( me.mx > gr.x - 15 - rbr && me.my > gr.y ) || me.id == ME_UScroll || me.id == ME_DScroll ) && me.id != ME_Betritt && me.id != ME_Verlässt )
-			{
+        }
+        if( toolTip )
+            toolTip->setMausIn( 0 );
+        return;
+    }
+    if( !mausIn && me.id != ME_Verlässt )
+    {
+        mausIn = 1;
+        if( toolTip )
+            toolTip->setMausIn( 1 );
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx;
+        me2.my = me.my;
+        me2.verarbeitet = 0;
+        doMausEreignis( me2 );
+    }
+    me.mx -= pos.x, me.my -= pos.y;
+    if( Mak && ( me.verarbeitet || Mak( makParam, this, me ) ) )
+    {
+        bool vera = me.verarbeitet;
+        if( ausfahren )
+        {
+            int tmpMx = me.mx;
+            int tmpMy = me.my;
+            if( me.mx > 0 && me.my > 0 && me.mx < gr.x && me.my < gr.y )
+                me.mx = ausfahren->getX() + 1, me.my = ausfahren->getY() + 1;
+            else
+                me.mx = ausfahren->getX() - 1, me.my = ausfahren->getY() - 1;
+            ausfahren->doMausEreignis( me );
+            me.mx = tmpMx, me.my = tmpMy;
+        }
+        if( me.verarbeitet && !vera && me.id == ME_RLinks )
+        {
+            ausgeklappt = !ausgeklappt;
+            if( ausgeklappt )
+                mausEintrag = auswahl;
+            if( scrollAnzeigen )
+                scrollZuEintrag( mausEintrag );
+        }
+        if( removeFokus && me.id == ME_RLinks )
+            löscheStyle( Style::Fokus );
+        if( !me.verarbeitet && hatStyleNicht( Style::Fokus ) && me.id == ME_RLinks )
+            addStyle( Style::Fokus );
+        if( hatStyle( Style::VScroll ) && vertikalScrollBar && ausgeklappt && scrollAnzeigen )
+        {
+            int rbr = 0;
+            if( rahmen && hatStyle( Style::Rahmen ) )
+                rbr = rahmen->getRBreite();
+            if( ( ( me.mx > gr.x - 15 - rbr && me.my > gr.y ) || me.id == ME_UScroll || me.id == ME_DScroll ) && me.id != ME_Betritt && me.id != ME_Verlässt )
+            {
                 vertikalScrollBar->doMausMessage( gr.x - rbr - 15, gr.y, 15, vertikalScrollBar->getScrollData()->anzeige, me );
-				me.verarbeitet = 1;
-			}
-		}
-		if( !me.verarbeitet )
-		{
-			int eintr = -1;
-			int tmp = me.my - gr.y + ( vertikalScrollBar ? vertikalScrollBar->getScroll() : 0 );
-			if( hatStyle( Style::MultiStyled ) )
-			{
-				for( int i = 0; i < anzahl; ++i )
-				{
-					if( tmp > 0 && tmp < ( members->z( i ) ? members->z( i )->getHöhe() : 0 ) )
-					{
-						eintr = i;
-						break;
-					}
-					tmp -= members->z( i ) ? members->z( i )->getHöhe() : 0;
-				}
-			}
-			else
-			{
-				for( int i = 0; i < anzahl; ++i )
-				{
-					if( tmp > 0 && tmp < eintragHöhe )
-					{
-						eintr = i;
-						break;
-					}
-					tmp -= eintragHöhe;
-				}
-			}
-			if( ausgeklappt && me.mx > 0 && me.mx < gr.x && me.my > gr.y && me.my < gr.y + ausklappHöhe )
-			{
-				if( eintr >= 0 )
-				{
-					if( me.id == ME_RLinks )
-					{
-						if( auswahl != eintr )
-							rend = 1;
-						auswahl = eintr;
-						if( eAk )
-							eAk( eAkP, this, 0, auswahl );
-					}
-					if( mausEintrag != eintr )
-						rend = 1;
-					mausEintrag = eintr;
-				}
-			}
-		}
-		me.verarbeitet = 1;
-	}
+                me.verarbeitet = 1;
+            }
+        }
+        if( !me.verarbeitet )
+        {
+            int eintr = -1;
+            int tmp = me.my - gr.y + ( vertikalScrollBar ? vertikalScrollBar->getScroll() : 0 );
+            if( hatStyle( Style::MultiStyled ) )
+            {
+                for( int i = 0; i < anzahl; ++i )
+                {
+                    if( tmp > 0 && tmp < ( members->z( i ) ? members->z( i )->getHöhe() : 0 ) )
+                    {
+                        eintr = i;
+                        break;
+                    }
+                    tmp -= members->z( i ) ? members->z( i )->getHöhe() : 0;
+                }
+            }
+            else
+            {
+                for( int i = 0; i < anzahl; ++i )
+                {
+                    if( tmp > 0 && tmp < eintragHöhe )
+                    {
+                        eintr = i;
+                        break;
+                    }
+                    tmp -= eintragHöhe;
+                }
+            }
+            if( ausgeklappt && me.mx > 0 && me.mx < gr.x && me.my > gr.y && me.my < gr.y + ausklappHöhe )
+            {
+                if( eintr >= 0 )
+                {
+                    if( me.id == ME_RLinks )
+                    {
+                        if( auswahl != eintr )
+                            rend = 1;
+                        auswahl = eintr;
+                        if( eAk )
+                            eAk( eAkP, this, 0, auswahl );
+                    }
+                    if( mausEintrag != eintr )
+                        rend = 1;
+                    mausEintrag = eintr;
+                }
+            }
+        }
+        me.verarbeitet = 1;
+    }
     if( nmakc && me.verarbeitet && nMak )
         me.verarbeitet = nMak( nmakParam, this, me );
-	me.mx += pos.x, me.my += pos.y;
+    me.mx += pos.x, me.my += pos.y;
 }
 
 void AuswahlBox::doTastaturEreignis( TastaturEreignis &te ) // Tastatur
 {
-	if( te.verarbeitet || hatStyleNicht( Style::Fokus ) || hatStyleNicht( Style::Erlaubt ) )
-		return;
-	if( te.id == TE_Release )
-	{
-		switch( te.taste )
-		{
-		case T_Oben:
-			if( auswahl > 0 )
-				--auswahl;
-			else
-				auswahl = anzahl - 1;
-			if( eAk )
-				eAk( eAkP, this, 0, auswahl );
-			scrollZuEintrag( auswahl );
-			rend = 1;
-			break;
-		case T_Unten:
-			if( auswahl < anzahl - 1 )
-				++auswahl;
-			else
-				auswahl = 0;
-			if( eAk )
-				eAk( eAkP, this, 0, auswahl );
-			scrollZuEintrag( auswahl );
-			rend = 1;
-			break;
-		}
-	}
+    if( te.verarbeitet || hatStyleNicht( Style::Fokus ) || hatStyleNicht( Style::Erlaubt ) )
+        return;
+    if( te.id == TE_Release )
+    {
+        switch( te.taste )
+        {
+        case T_Oben:
+            if( auswahl > 0 )
+                --auswahl;
+            else
+                auswahl = anzahl - 1;
+            if( eAk )
+                eAk( eAkP, this, 0, auswahl );
+            scrollZuEintrag( auswahl );
+            rend = 1;
+            break;
+        case T_Unten:
+            if( auswahl < anzahl - 1 )
+                ++auswahl;
+            else
+                auswahl = 0;
+            if( eAk )
+                eAk( eAkP, this, 0, auswahl );
+            scrollZuEintrag( auswahl );
+            rend = 1;
+            break;
+        }
+    }
     if( te.verarbeitet && nTak )
         te.verarbeitet = nTak( ntakParam, this, te );
 }
 
 void AuswahlBox::render( Bild &zRObj ) // zeichnet nach zRObj
 {
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		lockZeichnung();
-		int br = gr.x;
-		int hö = gr.y + ausklappHöhe;
-		if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( pos.x, pos.y, br, hö ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( pos.x, pos.y, br, hö ) ) )
-		{
-			unlockZeichnung();
-			return;
-		}
-		int rbr = 0;
-		if( hatStyle( Style::Rahmen ) && rahmen ) // Rahmen zeichnen
-		{
-			rahmen->setGröße( br, hö );
-			rahmen->render( zRObj );
-			rbr = rahmen->getRBreite();
-		}
-		if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( rbr, rbr, br - rbr * 2, hö - rbr * 2 ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( rbr, rbr, br - rbr * 2, hö - rbr * 2 ) ) )
-		{
-			zRObj.releaseDrawOptions();
-			unlockZeichnung();
-			return;
-		}
-		if( hatStyle( Style::Hintergrund ) )
-		{
-			if( hatStyle( Style::HAlpha ) )
-				zRObj.alphaRegion( 0, 0, br, hö, hintergrundFarbe );
-			else
-				zRObj.füllRegion( 0, 0, br, hö, hintergrundFarbe );
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        lockZeichnung();
+        int br = gr.x;
+        int hö = gr.y + ausklappHöhe;
+        if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( pos.x, pos.y, br, hö ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( pos.x, pos.y, br, hö ) ) )
+        {
+            unlockZeichnung();
+            return;
+        }
+        int rbr = 0;
+        if( hatStyle( Style::Rahmen ) && rahmen ) // Rahmen zeichnen
+        {
+            rahmen->setGröße( br, hö );
+            rahmen->render( zRObj );
+            rbr = rahmen->getRBreite();
+        }
+        if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( rbr, rbr, br - rbr * 2, hö - rbr * 2 ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( rbr, rbr, br - rbr * 2, hö - rbr * 2 ) ) )
+        {
+            zRObj.releaseDrawOptions();
+            unlockZeichnung();
+            return;
+        }
+        if( hatStyle( Style::Hintergrund ) )
+        {
+            if( hatStyle( Style::HAlpha ) )
+                zRObj.alphaRegion( 0, 0, br, hö, hintergrundFarbe );
+            else
+                zRObj.füllRegion( 0, 0, br, hö, hintergrundFarbe );
             if( hatStyle( Style::HBild ) && hintergrundBild )
             {
                 if( hatStyle( Style::HAlpha ) )
@@ -1073,1138 +1073,1138 @@ void AuswahlBox::render( Bild &zRObj ) // zeichnet nach zRObj
                 else
                     zRObj.drawBild( 0, 0, br, hö, *hintergrundBild );
             }
-		}
-		if( hatStyle( Style::Buffered ) && hintergrundFeld )
-		{
+        }
+        if( hatStyle( Style::Buffered ) && hintergrundFeld )
+        {
             hintergrundFeld->setGröße( br - rbr * 2, hö - rbr * 2 );
             hintergrundFeld->render( zRObj );
-		}
-		if( ausfahren ) // Ausklapp Knopf zeichnen
-		{
-			ausfahren->setGröße( gr.y - rbr * 2, gr.y - rbr * 2 );
-			ausfahren->setPosition( gr.x - rbr - ausfahren->getBreite(), rbr );
-			ausfahren->render( zRObj );
-		}
-		if( members ) // Ausgewähtes TextFeld zeichnen
-		{
-			if( auswahl < 0 )
-			{
-				auswahl = 0;
-				if( eAk )
-					eAk( eAkP, this, 0, auswahl );
-			}
-			if( auswahl >= anzahl )
-			{
-				auswahl = anzahl - 1;
-				if( eAk )
-					eAk( eAkP, this, 0, auswahl );
-			}
-			TextFeld *tf = auswahl >= 0 ? members->z( auswahl ) : 0;
-			if( tf )
-			{
-				AlphaFeld *tmpBuffer = 0;
-				bool tmpB = 0;
-				int tmpHFarbe = 0;
-				bool tmpH = 0;
-				Bild *tmpHBild = 0;
-				bool tmpHB = 0;
-				bool tmpHAlpha = 0;
-				LRahmen *tmpRahmen = 0;
-				bool tmpR = 0;
-				if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-				{
-					if( hatStyle( Style::AuswahlBuffer ) )
-					{
-						tmpBuffer = tf->getAlphaFeld();
-						tf->setAlphaFeldZ( auswAf->getThis() );
-						tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-						tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::AuswahlBuffer ) );
-					}
-					if( hatStyle( Style::AuswahlHintergrund ) )
-					{
-						tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
-						tmpHFarbe = tf->getHintergrundFarbe();
-						tf->setHintergrundFarbe( auswBgF );
-						tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
-						if( hatStyle( Style::AuswahlHBild ) )
-						{
-							tmpHBild = tf->getHintergrundBild();
-							tf->setHintergrundBildZ( auswBgB->getThis() );
-							tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-							tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
-						}
-						if( hatStyle( Style::AuswahlHAlpha ) )
-						{
-							tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-							tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::AuswahlHAlpha ) );
-						}
-					}
-					if( hatStyle( Style::AuswahlRahmen ) )
-					{
-						tmpRahmen = tf->getLinienRahmen();
-						tf->setLinienRahmenZ( auswRahmen->getThis() );
-						tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-						tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::AuswahlRahmen ) );
-					}
-				}
-				else
-				{
-					if( hatMsStyle( auswahl, Style::AuswahlBuffer ) && msAuswAf )
-					{
-						tmpBuffer = tf->getAlphaFeld();
-						tf->setAlphaFeldZ( msAuswAf->get( auswahl ) );
-						tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-						tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( auswahl, Style::AuswahlBuffer ) );
-					}
-					if( hatMsStyle( auswahl, Style::AuswahlHintergrund ) )
-					{
-						tmpH = tf->hatStyle( Style::Hintergrund );
-						tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( auswahl, Style::AuswahlHintergrund ) );
-						if( msAuswBgF && msAuswBgF->hat( auswahl ) )
-						{
-							tmpHFarbe = tf->getHintergrundFarbe();
-							tf->setHintergrundFarbe( msAuswBgF->get( auswahl ) );
-						}
-						if( hatMsStyle( auswahl, Style::AuswahlHBild ) && msAuswBgB )
-						{
-							tmpHBild = tf->getHintergrundBild();
-							tf->setHintergrundBildZ( msAuswBgB->get( auswahl ) );
-							tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-							tf->setStyle( TextFeld::Style::HBild, hatMsStyle( auswahl, Style::HBild ) );
-						}
-						if( hatMsStyle( auswahl, Style::AuswahlHAlpha ) )
-						{
-							tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-							tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( auswahl, Style::AuswahlHAlpha ) );
-						}
-					}
-					if( hatMsStyle( auswahl, Style::AuswahlRahmen ) && msAuswRahmen )
-					{
-						tmpRahmen = tf->getLinienRahmen();
-						tf->setLinienRahmenZ( msAuswRahmen->get( auswahl ) );
-						tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-						tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( auswahl, Style::AuswahlRahmen ) );
-					}
-				}
-				int tmpHö = tf->getHöhe();
-				tf->setPosition( 0, 0 );
-				tf->setGröße( gr.x - rbr * 2 - ( ausfahren ? ausfahren->getBreite() : 0 ), gr.y - rbr * 2 );
-				tf->render( zRObj );
-				tf->setGröße( tf->getBreite(), tmpHö );
-				if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-				{
-					if( hatStyle( Style::AuswahlBuffer ) )
-					{
-						tf->setAlphaFeldZ( tmpBuffer );
-						tf->setStyle( TextFeld::Style::Buffered, tmpB );
-					}
-					if( hatStyle( Style::AuswahlHintergrund ) )
-					{
-						tf->setHintergrundFarbe( tmpHFarbe );
-						tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-						if( hatStyle( Style::AuswahlHBild ) )
-						{
-							tf->setHintergrundBildZ( tmpHBild );
-							tf->setStyle( TextFeld::Style::HBild, tmpHB );
-						}
-						if( hatStyle( Style::AuswahlHAlpha ) )
-							tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-					}
-					if( hatStyle( Style::AuswahlRahmen ) )
-					{
-						tf->setLinienRahmenZ( tmpRahmen );
-						tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-					}
-				}
-				else
-				{
-					if( hatMsStyle( auswahl, Style::AuswahlBuffer ) && msAuswAf )
-					{
-						tf->setAlphaFeldZ( tmpBuffer );
-						tf->setStyle( TextFeld::Style::Buffered, tmpB );
-					}
-					if( hatMsStyle( auswahl, Style::AuswahlHintergrund ) )
-					{
-						tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-						if( msAuswBgF && msAuswBgF->hat( auswahl ) )
-							tf->setHintergrundFarbe( tmpHFarbe );
-						if( hatMsStyle( auswahl, Style::AuswahlHBild ) && msAuswBgB )
-						{
-							tf->setHintergrundBildZ( tmpHBild );
-							tf->setStyle( TextFeld::Style::HBild, tmpHB );
-						}
-						if( hatMsStyle( auswahl, Style::AuswahlHAlpha ) )
-							tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-					}
-					if( hatMsStyle( auswahl, Style::AuswahlRahmen ) && msAuswRahmen )
-					{
-						tf->setLinienRahmenZ( tmpRahmen );
-						tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-					}
-				}
-			}
-		}
-		bool vsb = hatStyle( Style::VScroll ) && vertikalScrollBar; // Scroll bar zeichnen
-		if( auswahl >= anzahl )
-		{
-			auswahl = 0;
-			if( eAk )
-				eAk( eAkP, this, 0, auswahl );
-		}
-		if( members )
-		{
-			if( vsb && ausklappHöhe )
-			{
-				br -= 15;
+        }
+        if( ausfahren ) // Ausklapp Knopf zeichnen
+        {
+            ausfahren->setGröße( gr.y - rbr * 2, gr.y - rbr * 2 );
+            ausfahren->setPosition( gr.x - rbr - ausfahren->getBreite(), rbr );
+            ausfahren->render( zRObj );
+        }
+        if( members ) // Ausgewähtes TextFeld zeichnen
+        {
+            if( auswahl < 0 )
+            {
+                auswahl = 0;
+                if( eAk )
+                    eAk( eAkP, this, 0, auswahl );
+            }
+            if( auswahl >= anzahl )
+            {
+                auswahl = anzahl - 1;
+                if( eAk )
+                    eAk( eAkP, this, 0, auswahl );
+            }
+            TextFeld *tf = auswahl >= 0 ? members->z( auswahl ) : 0;
+            if( tf )
+            {
+                AlphaFeld *tmpBuffer = 0;
+                bool tmpB = 0;
+                int tmpHFarbe = 0;
+                bool tmpH = 0;
+                Bild *tmpHBild = 0;
+                bool tmpHB = 0;
+                bool tmpHAlpha = 0;
+                LRahmen *tmpRahmen = 0;
+                bool tmpR = 0;
+                if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                {
+                    if( hatStyle( Style::AuswahlBuffer ) )
+                    {
+                        tmpBuffer = tf->getAlphaFeld();
+                        tf->setAlphaFeldZ( auswAf->getThis() );
+                        tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                        tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::AuswahlBuffer ) );
+                    }
+                    if( hatStyle( Style::AuswahlHintergrund ) )
+                    {
+                        tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
+                        tmpHFarbe = tf->getHintergrundFarbe();
+                        tf->setHintergrundFarbe( auswBgF );
+                        tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
+                        if( hatStyle( Style::AuswahlHBild ) )
+                        {
+                            tmpHBild = tf->getHintergrundBild();
+                            tf->setHintergrundBildZ( auswBgB->getThis() );
+                            tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                            tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
+                        }
+                        if( hatStyle( Style::AuswahlHAlpha ) )
+                        {
+                            tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                            tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::AuswahlHAlpha ) );
+                        }
+                    }
+                    if( hatStyle( Style::AuswahlRahmen ) )
+                    {
+                        tmpRahmen = tf->getLinienRahmen();
+                        tf->setLinienRahmenZ( auswRahmen->getThis() );
+                        tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                        tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::AuswahlRahmen ) );
+                    }
+                }
+                else
+                {
+                    if( hatMsStyle( auswahl, Style::AuswahlBuffer ) && msAuswAf )
+                    {
+                        tmpBuffer = tf->getAlphaFeld();
+                        tf->setAlphaFeldZ( msAuswAf->get( auswahl ) );
+                        tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                        tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( auswahl, Style::AuswahlBuffer ) );
+                    }
+                    if( hatMsStyle( auswahl, Style::AuswahlHintergrund ) )
+                    {
+                        tmpH = tf->hatStyle( Style::Hintergrund );
+                        tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( auswahl, Style::AuswahlHintergrund ) );
+                        if( msAuswBgF && msAuswBgF->hat( auswahl ) )
+                        {
+                            tmpHFarbe = tf->getHintergrundFarbe();
+                            tf->setHintergrundFarbe( msAuswBgF->get( auswahl ) );
+                        }
+                        if( hatMsStyle( auswahl, Style::AuswahlHBild ) && msAuswBgB )
+                        {
+                            tmpHBild = tf->getHintergrundBild();
+                            tf->setHintergrundBildZ( msAuswBgB->get( auswahl ) );
+                            tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                            tf->setStyle( TextFeld::Style::HBild, hatMsStyle( auswahl, Style::HBild ) );
+                        }
+                        if( hatMsStyle( auswahl, Style::AuswahlHAlpha ) )
+                        {
+                            tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                            tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( auswahl, Style::AuswahlHAlpha ) );
+                        }
+                    }
+                    if( hatMsStyle( auswahl, Style::AuswahlRahmen ) && msAuswRahmen )
+                    {
+                        tmpRahmen = tf->getLinienRahmen();
+                        tf->setLinienRahmenZ( msAuswRahmen->get( auswahl ) );
+                        tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                        tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( auswahl, Style::AuswahlRahmen ) );
+                    }
+                }
+                int tmpHö = tf->getHöhe();
+                tf->setPosition( 0, 0 );
+                tf->setGröße( gr.x - rbr * 2 - ( ausfahren ? ausfahren->getBreite() : 0 ), gr.y - rbr * 2 );
+                tf->render( zRObj );
+                tf->setGröße( tf->getBreite(), tmpHö );
+                if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                {
+                    if( hatStyle( Style::AuswahlBuffer ) )
+                    {
+                        tf->setAlphaFeldZ( tmpBuffer );
+                        tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                    }
+                    if( hatStyle( Style::AuswahlHintergrund ) )
+                    {
+                        tf->setHintergrundFarbe( tmpHFarbe );
+                        tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                        if( hatStyle( Style::AuswahlHBild ) )
+                        {
+                            tf->setHintergrundBildZ( tmpHBild );
+                            tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                        }
+                        if( hatStyle( Style::AuswahlHAlpha ) )
+                            tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                    }
+                    if( hatStyle( Style::AuswahlRahmen ) )
+                    {
+                        tf->setLinienRahmenZ( tmpRahmen );
+                        tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                    }
+                }
+                else
+                {
+                    if( hatMsStyle( auswahl, Style::AuswahlBuffer ) && msAuswAf )
+                    {
+                        tf->setAlphaFeldZ( tmpBuffer );
+                        tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                    }
+                    if( hatMsStyle( auswahl, Style::AuswahlHintergrund ) )
+                    {
+                        tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                        if( msAuswBgF && msAuswBgF->hat( auswahl ) )
+                            tf->setHintergrundFarbe( tmpHFarbe );
+                        if( hatMsStyle( auswahl, Style::AuswahlHBild ) && msAuswBgB )
+                        {
+                            tf->setHintergrundBildZ( tmpHBild );
+                            tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                        }
+                        if( hatMsStyle( auswahl, Style::AuswahlHAlpha ) )
+                            tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                    }
+                    if( hatMsStyle( auswahl, Style::AuswahlRahmen ) && msAuswRahmen )
+                    {
+                        tf->setLinienRahmenZ( tmpRahmen );
+                        tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                    }
+                }
+            }
+        }
+        bool vsb = hatStyle( Style::VScroll ) && vertikalScrollBar; // Scroll bar zeichnen
+        if( auswahl >= anzahl )
+        {
+            auswahl = 0;
+            if( eAk )
+                eAk( eAkP, this, 0, auswahl );
+        }
+        if( members )
+        {
+            if( vsb && ausklappHöhe )
+            {
+                br -= 15;
                 vertikalScrollBar->getScrollData()->anzeige = ausklappHöhe - rbr;
                 vertikalScrollBar->render( br - rbr, gr.y, 15, ausklappHöhe - rbr, zRObj );
-			}
-			if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( 0, gr.y, br - rbr, hö - rbr - gr.y ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( 0, gr.y, br - rbr, hö - rbr - gr.y ) ) )
-			{
-				zRObj.releaseDrawOptions();
-				zRObj.releaseDrawOptions();
-				unlockZeichnung();
-				return;
-			}
-			int maxHöhe = 0;
-			int dy = 0;
-			if( vsb )
-				dy -= vertikalScrollBar->getScroll();
-			int mdy = hö - rbr;
-			RCArray< TextFeld > *tmpA = members;
-			anzahl = members->getEintragAnzahl();
-			for( int i = 0; i < anzahl; ++i )
-			{
-				TextFeld *tf = members->z( i );
-				if( dy >= mdy && !vsb )
-					break;
-				tf->setPosition( 0, dy );
-				tf->setGröße( br - rbr * 2, tf->getHöhe() );
-				maxHöhe += tf->getHöhe();
-				bool selected = auswahl == i;
-				AlphaFeld *tmpBuffer = 0;
-				bool tmpB = 0;
-				int tmpHFarbe = 0;
-				bool tmpH = 0;
-				Bild *tmpHBild = 0;
-				bool tmpHB = 0;
-				bool tmpHAlpha = 0;
-				LRahmen *tmpRahmen = 0;
-				bool tmpR = 0;
-				if( selected )
-				{
-					if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-					{
-						if( hatStyle( Style::AuswahlBuffer ) )
-						{
-							tmpBuffer = tf->getAlphaFeld();
-							tf->setAlphaFeldZ( auswAf->getThis() );
-							tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-							tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::AuswahlBuffer ) );
-						}
-						if( hatStyle( Style::AuswahlHintergrund ) )
-						{
-							tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
-							tmpHFarbe = tf->getHintergrundFarbe();
-							tf->setHintergrundFarbe( auswBgF );
-							tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
-							if( hatStyle( Style::AuswahlHBild ) )
-							{
-								tmpHBild = tf->getHintergrundBild();
-								tf->setHintergrundBildZ( auswBgB->getThis() );
-								tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-								tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
-							}
-							if( hatStyle( Style::AuswahlHAlpha ) )
-							{
-								tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-								tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::AuswahlHAlpha ) );
-							}
-						}
-						if( hatStyle( Style::AuswahlRahmen ) )
-						{
-							tmpRahmen = tf->getLinienRahmen();
-							tf->setLinienRahmenZ( auswRahmen->getThis() );
-							tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::AuswahlRahmen ) );
-						}
-					}
-					else
-					{
-						if( hatMsStyle( i, Style::AuswahlBuffer ) && msAuswAf )
-						{
-							tmpBuffer = tf->getAlphaFeld();
-							tf->setAlphaFeldZ( msAuswAf->get( i ) );
-							tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-							tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( i, Style::AuswahlBuffer ) );
-						}
-						if( hatMsStyle( i, Style::AuswahlHintergrund ) )
-						{
-							tmpH = tf->hatStyle( Style::Hintergrund );
-							tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( i, Style::AuswahlHintergrund ) );
-							if( msAuswBgF && msAuswBgF->hat( i ) )
-							{
-								tmpHFarbe = tf->getHintergrundFarbe();
-								tf->setHintergrundFarbe( msAuswBgF->get( i ) );
-							}
-							if( hatMsStyle( i, Style::AuswahlHBild ) && msAuswBgB )
-							{
-								tmpHBild = tf->getHintergrundBild();
-								tf->setHintergrundBildZ( msAuswBgB->get( i ) );
-								tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-								tf->setStyle( TextFeld::Style::HBild, hatMsStyle( i, Style::HBild ) );
-							}
-							if( hatMsStyle( i, Style::AuswahlHAlpha ) )
-							{
-								tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-								tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( i, Style::AuswahlHAlpha ) );
-							}
-						}
-						if( hatMsStyle( i, Style::AuswahlRahmen ) && msAuswRahmen )
-						{
-							tmpRahmen = tf->getLinienRahmen();
-							tf->setLinienRahmenZ( msAuswRahmen->get( i ) );
-							tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( i, Style::AuswahlRahmen ) );
-						}
-					}
-				}
-				else if( mausEintrag == i )
-				{
-					if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-					{
-						if( hatStyle( Style::MausBuffer ) )
-						{
-							tmpBuffer = tf->getAlphaFeld();
-							tf->setAlphaFeldZ( mausAf->getThis() );
-							tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-							tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::MausBuffer ) );
-						}
-						if( hatStyle( Style::MausHintergrund ) )
-						{
-							tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
-							tmpHFarbe = tf->getHintergrundFarbe();
-							tf->setHintergrundFarbe( mausBgF );
-							tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
-							if( hatStyle( Style::MausHBild ) )
-							{
-								tmpHBild = tf->getHintergrundBild();
-								tf->setHintergrundBildZ( mausBgB->getThis() );
-								tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-								tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
-							}
-							if( hatStyle( Style::MausHAlpha ) )
-							{
-								tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-								tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::MausHAlpha ) );
-							}
-						}
-						if( hatStyle( Style::MausRahmen ) )
-						{
-							tmpRahmen = tf->getLinienRahmen();
-							tf->setLinienRahmenZ( mausRahmen->getThis() );
-							tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::MausRahmen ) );
-						}
-					}
-					else
-					{
-						if( hatMsStyle( i, Style::MausBuffer ) && msAuswAf )
-						{
-							tmpBuffer = tf->getAlphaFeld();
-							tf->setAlphaFeldZ( msMausAf->get( i ) );
-							tmpB = tf->hatStyle( TextFeld::Style::Buffered );
-							tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( i, Style::MausBuffer ) );
-						}
-						if( hatMsStyle( i, Style::MausHintergrund ) )
-						{
-							tmpH = tf->hatStyle( Style::Hintergrund );
-							tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( i, Style::MausHintergrund ) );
-							if( msMausBgF && msMausBgF->hat( i ) )
-							{
-								tmpHFarbe = tf->getHintergrundFarbe();
-								tf->setHintergrundFarbe( msMausBgF->get( i ) );
-							}
-							if( hatMsStyle( i, Style::MausHBild ) && msMausBgB )
-							{
-								tmpHBild = tf->getHintergrundBild();
-								tf->setHintergrundBildZ( msMausBgB->get( i ) );
-								tmpHB = tf->hatStyle( TextFeld::Style::HBild );
-								tf->setStyle( TextFeld::Style::HBild, hatMsStyle( i, Style::HBild ) );
-							}
-							if( hatMsStyle( i, Style::MausHAlpha ) )
-							{
-								tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
-								tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( i, Style::MausHAlpha ) );
-							}
-						}
-						if( hatMsStyle( i, Style::MausRahmen ) && msMausRahmen )
-						{
-							tmpRahmen = tf->getLinienRahmen();
-							tf->setLinienRahmenZ( msMausRahmen->get( i ) );
-							tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( i, Style::MausRahmen ) );
-						}
-					}
-				}
-				tf->render( zRObj );
-				if( selected )
-				{
-					if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-					{
-						if( hatStyle( Style::AuswahlBuffer ) )
-						{
-							tf->setAlphaFeldZ( tmpBuffer );
-							tf->setStyle( TextFeld::Style::Buffered, tmpB );
-						}
-						if( hatStyle( Style::AuswahlHintergrund ) )
-						{
-							tf->setHintergrundFarbe( tmpHFarbe );
-							tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-							if( hatStyle( Style::AuswahlHBild ) )
-							{
-								tf->setHintergrundBildZ( tmpHBild );
-								tf->setStyle( TextFeld::Style::HBild, tmpHB );
-							}
-							if( hatStyle( Style::AuswahlHAlpha ) )
-								tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-						}
-						if( hatStyle( Style::AuswahlRahmen ) )
-						{
-							tf->setLinienRahmenZ( tmpRahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-						}
-					}
-					else
-					{
-						if( hatMsStyle( i, Style::AuswahlBuffer ) && msAuswAf )
-						{
-							tf->setAlphaFeldZ( tmpBuffer );
-							tf->setStyle( TextFeld::Style::Buffered, tmpB );
-						}
-						if( hatMsStyle( i, Style::AuswahlHintergrund ) )
-						{
-							tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-							if( msAuswBgF && msAuswBgF->hat( i ) )
-								tf->setHintergrundFarbe( tmpHFarbe );
-							if( hatMsStyle( i, Style::AuswahlHBild ) && msAuswBgB )
-							{
-								tf->setHintergrundBildZ( tmpHBild );
-								tf->setStyle( TextFeld::Style::HBild, tmpHB );
-							}
-							if( hatMsStyle( i, Style::AuswahlHAlpha ) )
-								tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-						}
-						if( hatMsStyle( i, Style::AuswahlRahmen ) && msAuswRahmen )
-						{
-							tf->setLinienRahmenZ( tmpRahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-						}
-					}
-				}
-				else if( mausEintrag == i )
-				{
-					if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
-					{
-						if( hatStyle( Style::MausBuffer ) )
-						{
-							tf->setAlphaFeldZ( tmpBuffer );
-							tf->setStyle( TextFeld::Style::Buffered, tmpB );
-						}
-						if( hatStyle( Style::MausHintergrund ) )
-						{
-							tf->setHintergrundFarbe( tmpHFarbe );
-							tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-							if( hatStyle( Style::MausHBild ) )
-							{
-								tf->setHintergrundBildZ( tmpHBild );
-								tf->setStyle( TextFeld::Style::HBild, tmpHB );
-							}
-							if( hatStyle( Style::MausHAlpha ) )
-								tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-						}
-						if( hatStyle( Style::MausRahmen ) )
-						{
-							tf->setLinienRahmenZ( tmpRahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-						}
-					}
-					else
-					{
-						if( hatMsStyle( i, Style::MausBuffer ) && msAuswAf )
-						{
-							tf->setAlphaFeldZ( tmpBuffer );
-							tf->setStyle( TextFeld::Style::Buffered, tmpB );
-						}
-						if( hatMsStyle( i, Style::MausHintergrund ) )
-						{
-							tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
-							if( msAuswBgF && msAuswBgF->hat( i ) )
-								tf->setHintergrundFarbe( tmpHFarbe );
-							if( hatMsStyle( i, Style::MausHBild ) && msAuswBgB )
-							{
-								tf->setHintergrundBildZ( tmpHBild );
-								tf->setStyle( TextFeld::Style::HBild, tmpHB );
-							}
-							if( hatMsStyle( i, Style::MausHAlpha ) )
-								tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
-						}
-						if( hatMsStyle( i, Style::MausRahmen ) && msAuswRahmen )
-						{
-							tf->setLinienRahmenZ( tmpRahmen );
-							tf->setStyle( TextFeld::Style::Rahmen, tmpR );
-						}
-					}
-				}
-				dy += tf->getHöhe();
-			}
-			if( vertikalScrollBar )
+            }
+            if( ( ausklappHöhe && !zRObj.setDrawOptionsErzwingen( 0, gr.y, br - rbr, hö - rbr - gr.y ) ) || ( !ausklappHöhe && !zRObj.setDrawOptions( 0, gr.y, br - rbr, hö - rbr - gr.y ) ) )
+            {
+                zRObj.releaseDrawOptions();
+                zRObj.releaseDrawOptions();
+                unlockZeichnung();
+                return;
+            }
+            int maxHöhe = 0;
+            int dy = 0;
+            if( vsb )
+                dy -= vertikalScrollBar->getScroll();
+            int mdy = hö - rbr;
+            RCArray< TextFeld > *tmpA = members;
+            anzahl = members->getEintragAnzahl();
+            for( int i = 0; i < anzahl; ++i )
+            {
+                TextFeld *tf = members->z( i );
+                if( dy >= mdy && !vsb )
+                    break;
+                tf->setPosition( 0, dy );
+                tf->setGröße( br - rbr * 2, tf->getHöhe() );
+                maxHöhe += tf->getHöhe();
+                bool selected = auswahl == i;
+                AlphaFeld *tmpBuffer = 0;
+                bool tmpB = 0;
+                int tmpHFarbe = 0;
+                bool tmpH = 0;
+                Bild *tmpHBild = 0;
+                bool tmpHB = 0;
+                bool tmpHAlpha = 0;
+                LRahmen *tmpRahmen = 0;
+                bool tmpR = 0;
+                if( selected )
+                {
+                    if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                    {
+                        if( hatStyle( Style::AuswahlBuffer ) )
+                        {
+                            tmpBuffer = tf->getAlphaFeld();
+                            tf->setAlphaFeldZ( auswAf->getThis() );
+                            tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                            tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::AuswahlBuffer ) );
+                        }
+                        if( hatStyle( Style::AuswahlHintergrund ) )
+                        {
+                            tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
+                            tmpHFarbe = tf->getHintergrundFarbe();
+                            tf->setHintergrundFarbe( auswBgF );
+                            tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
+                            if( hatStyle( Style::AuswahlHBild ) )
+                            {
+                                tmpHBild = tf->getHintergrundBild();
+                                tf->setHintergrundBildZ( auswBgB->getThis() );
+                                tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                                tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
+                            }
+                            if( hatStyle( Style::AuswahlHAlpha ) )
+                            {
+                                tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                                tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::AuswahlHAlpha ) );
+                            }
+                        }
+                        if( hatStyle( Style::AuswahlRahmen ) )
+                        {
+                            tmpRahmen = tf->getLinienRahmen();
+                            tf->setLinienRahmenZ( auswRahmen->getThis() );
+                            tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::AuswahlRahmen ) );
+                        }
+                    }
+                    else
+                    {
+                        if( hatMsStyle( i, Style::AuswahlBuffer ) && msAuswAf )
+                        {
+                            tmpBuffer = tf->getAlphaFeld();
+                            tf->setAlphaFeldZ( msAuswAf->get( i ) );
+                            tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                            tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( i, Style::AuswahlBuffer ) );
+                        }
+                        if( hatMsStyle( i, Style::AuswahlHintergrund ) )
+                        {
+                            tmpH = tf->hatStyle( Style::Hintergrund );
+                            tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( i, Style::AuswahlHintergrund ) );
+                            if( msAuswBgF && msAuswBgF->hat( i ) )
+                            {
+                                tmpHFarbe = tf->getHintergrundFarbe();
+                                tf->setHintergrundFarbe( msAuswBgF->get( i ) );
+                            }
+                            if( hatMsStyle( i, Style::AuswahlHBild ) && msAuswBgB )
+                            {
+                                tmpHBild = tf->getHintergrundBild();
+                                tf->setHintergrundBildZ( msAuswBgB->get( i ) );
+                                tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                                tf->setStyle( TextFeld::Style::HBild, hatMsStyle( i, Style::HBild ) );
+                            }
+                            if( hatMsStyle( i, Style::AuswahlHAlpha ) )
+                            {
+                                tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                                tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( i, Style::AuswahlHAlpha ) );
+                            }
+                        }
+                        if( hatMsStyle( i, Style::AuswahlRahmen ) && msAuswRahmen )
+                        {
+                            tmpRahmen = tf->getLinienRahmen();
+                            tf->setLinienRahmenZ( msAuswRahmen->get( i ) );
+                            tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( i, Style::AuswahlRahmen ) );
+                        }
+                    }
+                }
+                else if( mausEintrag == i )
+                {
+                    if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                    {
+                        if( hatStyle( Style::MausBuffer ) )
+                        {
+                            tmpBuffer = tf->getAlphaFeld();
+                            tf->setAlphaFeldZ( mausAf->getThis() );
+                            tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                            tf->setStyle( TextFeld::Style::Buffered, hatStyle( Style::MausBuffer ) );
+                        }
+                        if( hatStyle( Style::MausHintergrund ) )
+                        {
+                            tmpH = tf->hatStyle( TextFeld::Style::Hintergrund );
+                            tmpHFarbe = tf->getHintergrundFarbe();
+                            tf->setHintergrundFarbe( mausBgF );
+                            tf->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::Hintergrund ) );
+                            if( hatStyle( Style::MausHBild ) )
+                            {
+                                tmpHBild = tf->getHintergrundBild();
+                                tf->setHintergrundBildZ( mausBgB->getThis() );
+                                tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                                tf->setStyle( TextFeld::Style::HBild, hatStyle( Style::HBild ) );
+                            }
+                            if( hatStyle( Style::MausHAlpha ) )
+                            {
+                                tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                                tf->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::MausHAlpha ) );
+                            }
+                        }
+                        if( hatStyle( Style::MausRahmen ) )
+                        {
+                            tmpRahmen = tf->getLinienRahmen();
+                            tf->setLinienRahmenZ( mausRahmen->getThis() );
+                            tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, hatStyle( Style::MausRahmen ) );
+                        }
+                    }
+                    else
+                    {
+                        if( hatMsStyle( i, Style::MausBuffer ) && msAuswAf )
+                        {
+                            tmpBuffer = tf->getAlphaFeld();
+                            tf->setAlphaFeldZ( msMausAf->get( i ) );
+                            tmpB = tf->hatStyle( TextFeld::Style::Buffered );
+                            tf->setStyle( TextFeld::Style::Buffered, hatMsStyle( i, Style::MausBuffer ) );
+                        }
+                        if( hatMsStyle( i, Style::MausHintergrund ) )
+                        {
+                            tmpH = tf->hatStyle( Style::Hintergrund );
+                            tf->setStyle( TextFeld::Style::Hintergrund, hatMsStyle( i, Style::MausHintergrund ) );
+                            if( msMausBgF && msMausBgF->hat( i ) )
+                            {
+                                tmpHFarbe = tf->getHintergrundFarbe();
+                                tf->setHintergrundFarbe( msMausBgF->get( i ) );
+                            }
+                            if( hatMsStyle( i, Style::MausHBild ) && msMausBgB )
+                            {
+                                tmpHBild = tf->getHintergrundBild();
+                                tf->setHintergrundBildZ( msMausBgB->get( i ) );
+                                tmpHB = tf->hatStyle( TextFeld::Style::HBild );
+                                tf->setStyle( TextFeld::Style::HBild, hatMsStyle( i, Style::HBild ) );
+                            }
+                            if( hatMsStyle( i, Style::MausHAlpha ) )
+                            {
+                                tmpHAlpha = tf->hatStyle( TextFeld::Style::HAlpha );
+                                tf->setStyle( TextFeld::Style::HAlpha, hatMsStyle( i, Style::MausHAlpha ) );
+                            }
+                        }
+                        if( hatMsStyle( i, Style::MausRahmen ) && msMausRahmen )
+                        {
+                            tmpRahmen = tf->getLinienRahmen();
+                            tf->setLinienRahmenZ( msMausRahmen->get( i ) );
+                            tmpR = tf->hatStyle( TextFeld::Style::Rahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, hatMsStyle( i, Style::MausRahmen ) );
+                        }
+                    }
+                }
+                tf->render( zRObj );
+                if( selected )
+                {
+                    if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                    {
+                        if( hatStyle( Style::AuswahlBuffer ) )
+                        {
+                            tf->setAlphaFeldZ( tmpBuffer );
+                            tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                        }
+                        if( hatStyle( Style::AuswahlHintergrund ) )
+                        {
+                            tf->setHintergrundFarbe( tmpHFarbe );
+                            tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                            if( hatStyle( Style::AuswahlHBild ) )
+                            {
+                                tf->setHintergrundBildZ( tmpHBild );
+                                tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                            }
+                            if( hatStyle( Style::AuswahlHAlpha ) )
+                                tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                        }
+                        if( hatStyle( Style::AuswahlRahmen ) )
+                        {
+                            tf->setLinienRahmenZ( tmpRahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                        }
+                    }
+                    else
+                    {
+                        if( hatMsStyle( i, Style::AuswahlBuffer ) && msAuswAf )
+                        {
+                            tf->setAlphaFeldZ( tmpBuffer );
+                            tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                        }
+                        if( hatMsStyle( i, Style::AuswahlHintergrund ) )
+                        {
+                            tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                            if( msAuswBgF && msAuswBgF->hat( i ) )
+                                tf->setHintergrundFarbe( tmpHFarbe );
+                            if( hatMsStyle( i, Style::AuswahlHBild ) && msAuswBgB )
+                            {
+                                tf->setHintergrundBildZ( tmpHBild );
+                                tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                            }
+                            if( hatMsStyle( i, Style::AuswahlHAlpha ) )
+                                tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                        }
+                        if( hatMsStyle( i, Style::AuswahlRahmen ) && msAuswRahmen )
+                        {
+                            tf->setLinienRahmenZ( tmpRahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                        }
+                    }
+                }
+                else if( mausEintrag == i )
+                {
+                    if( hatStyleNicht( Style::MultiStyled ) || !msStyle )
+                    {
+                        if( hatStyle( Style::MausBuffer ) )
+                        {
+                            tf->setAlphaFeldZ( tmpBuffer );
+                            tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                        }
+                        if( hatStyle( Style::MausHintergrund ) )
+                        {
+                            tf->setHintergrundFarbe( tmpHFarbe );
+                            tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                            if( hatStyle( Style::MausHBild ) )
+                            {
+                                tf->setHintergrundBildZ( tmpHBild );
+                                tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                            }
+                            if( hatStyle( Style::MausHAlpha ) )
+                                tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                        }
+                        if( hatStyle( Style::MausRahmen ) )
+                        {
+                            tf->setLinienRahmenZ( tmpRahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                        }
+                    }
+                    else
+                    {
+                        if( hatMsStyle( i, Style::MausBuffer ) && msAuswAf )
+                        {
+                            tf->setAlphaFeldZ( tmpBuffer );
+                            tf->setStyle( TextFeld::Style::Buffered, tmpB );
+                        }
+                        if( hatMsStyle( i, Style::MausHintergrund ) )
+                        {
+                            tf->setStyle( TextFeld::Style::Hintergrund, tmpH );
+                            if( msAuswBgF && msAuswBgF->hat( i ) )
+                                tf->setHintergrundFarbe( tmpHFarbe );
+                            if( hatMsStyle( i, Style::MausHBild ) && msAuswBgB )
+                            {
+                                tf->setHintergrundBildZ( tmpHBild );
+                                tf->setStyle( TextFeld::Style::HBild, tmpHB );
+                            }
+                            if( hatMsStyle( i, Style::MausHAlpha ) )
+                                tf->setStyle( TextFeld::Style::HAlpha, tmpHAlpha );
+                        }
+                        if( hatMsStyle( i, Style::MausRahmen ) && msAuswRahmen )
+                        {
+                            tf->setLinienRahmenZ( tmpRahmen );
+                            tf->setStyle( TextFeld::Style::Rahmen, tmpR );
+                        }
+                    }
+                }
+                dy += tf->getHöhe();
+            }
+            if( vertikalScrollBar )
                 vertikalScrollBar->getScrollData()->max = maxHöhe;
-			zRObj.releaseDrawOptions();
-		}
-		zRObj.releaseDrawOptions();
-		zRObj.releaseDrawOptions();
-		unlockZeichnung();
-	}
+            zRObj.releaseDrawOptions();
+        }
+        zRObj.releaseDrawOptions();
+        zRObj.releaseDrawOptions();
+        unlockZeichnung();
+    }
 }
 
 // constant
 int AuswahlBox::getEintragPos( const char *txt ) const // gibt die Eintrag Position zurück
 {
-	for( int i = 0; i < anzahl; ++i )
-	if( members->z( i ) && members->z( i )->zText()->istGleich( txt ) )
-		return i;
-	return -1;
+    for( int i = 0; i < anzahl; ++i )
+        if( members->z( i ) && members->z( i )->zText()->istGleich( txt ) )
+            return i;
+    return -1;
 }
 
 int AuswahlBox::getEintragPos( Text *txt ) const
 {
-	for( int i = 0; i < anzahl; ++i )
-	{
-		if( members->z( i ) && members->z( i )->zText()->istGleich( txt->getText() ) )
-		{
-			txt->release();
-			return i;
-		}
-	}
-	txt->release();
-	return -1;
+    for( int i = 0; i < anzahl; ++i )
+    {
+        if( members->z( i ) && members->z( i )->zText()->istGleich( txt->getText() ) )
+        {
+            txt->release();
+            return i;
+        }
+    }
+    txt->release();
+    return -1;
 }
 
 Text *AuswahlBox::getEintragText( int i ) const // gibt den Eintrag Text zurück
 {
-	if( i >= anzahl )
-		return 0;
-	return members->z( i ) ? members->z( i )->getText() : 0;
+    if( i >= anzahl )
+        return 0;
+    return members->z( i ) ? members->z( i )->getText() : 0;
 }
 
 Text *AuswahlBox::zEintragText( int i ) const
 {
-	if( i >= anzahl )
-		return 0;
-	return members->z( i ) ? members->z( i )->zText() : 0;
+    if( i >= anzahl )
+        return 0;
+    return members->z( i ) ? members->z( i )->zText() : 0;
 }
 
 TextFeld *AuswahlBox::getEintrag( int i ) const // gibt den Eintrag zurück
 {
-	if( i >= anzahl )
-		return 0;
-	return members->get( i );
+    if( i >= anzahl )
+        return 0;
+    return members->get( i );
 }
 
 TextFeld *AuswahlBox::zEintrag( int i ) const
 {
-	if( i >= anzahl )
-		return 0;
-	return members->z( i );
+    if( i >= anzahl )
+        return 0;
+    return members->z( i );
 }
 
 int AuswahlBox::getAuswahl() const // gibt die Position des ausgewählten Eintrages zurück
 {
-	return auswahl;
+    return auswahl;
 }
 
 int AuswahlBox::getEintragAnzahl() const // gibt die Anzahl der Einträge zurück
 {
-	return anzahl;
+    return anzahl;
 }
 
 bool AuswahlBox::istAusgeklappt() const // prüft, ob die Liste ausgeklappt ist
 {
-	return ausgeklappt;
+    return ausgeklappt;
 }
 
 int AuswahlBox::getMaxHöhe() const // gibt die maximale Höhe der Liste zurück
 {
-	if( !hatStyle( Style::MaxHöhe ) )
-		return 0;
-	return ausklapMaxHöhe;
+    if( !hatStyle( Style::MaxHöhe ) )
+        return 0;
+    return ausklapMaxHöhe;
 }
 
 int AuswahlBox::getEintragHöhe() const // gibt die Höhe der Einträge zurück
 {
-	return eintragHöhe;
+    return eintragHöhe;
 }
 
 Knopf *AuswahlBox::getAusklappKnopf() const // gibt den aus-/einklapp Knopf zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return ausfahren ? ausfahren->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return ausfahren ? ausfahren->getThis() : 0;
 }
 
 Knopf *AuswahlBox::zAusklappKnopf() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return ausfahren;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return ausfahren;
 }
 
 LRahmen *AuswahlBox::getEintragRahmen( int i ) const // gibt den Eintrag Rahmen zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getLinienRahmen();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getLinienRahmen();
 }
 
 LRahmen *AuswahlBox::zEintragRahmen( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->zLinienRahmen();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->zLinienRahmen();
 }
 
 int AuswahlBox::getEintragRahmenFarbe( int i ) const // gibt die Eintrag Rahmen Frabe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getLinienRahmenFarbe();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getLinienRahmenFarbe();
 }
 
 int AuswahlBox::getEintragRahmenBreite( int i ) const // gibt die Eintrag Rahmen Breite zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getLinienRahmenBreite();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getLinienRahmenBreite();
 }
 
 AlphaFeld *AuswahlBox::getEintragAlphaFeld( int i ) const // gibt das Eintrag AlphaFeld zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getAlphaFeld();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getAlphaFeld();
 }
 
 AlphaFeld *AuswahlBox::zEintragAlphaFeld( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->zAlphaFeld();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->zAlphaFeld();
 }
 
 int AuswahlBox::getEintragAlphaFeldFarbe( int i ) const // gibt die Eintrag AlphaFeld Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getAlphaFeldFarbe();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getAlphaFeldFarbe();
 }
 
 int AuswahlBox::getEintragAlphaFeldStärke( int i ) const // gibt die Eintrag AlphaFeld stärke zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getAlphaFeldStärke();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getAlphaFeldStärke();
 }
 
 int AuswahlBox::getEintragHintergrundFarbe( int i ) const // gibt die Eintrag Hintergrund Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getHintergrundFarbe();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getHintergrundFarbe();
 }
 
 Bild *AuswahlBox::getEintragHintergrundBild( int i ) const // gibt das Eintrag Hintergrund Bild zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->getHintergrundBild();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->getHintergrundBild();
 }
 
 Bild *AuswahlBox::zEintragHintergrundBild( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !members->z( i ) )
-		return 0;
-	return members->z( i )->zHintergrundBild();
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !members->z( i ) )
+        return 0;
+    return members->z( i )->zHintergrundBild();
 }
 
 LRahmen *AuswahlBox::getAuswRahmen() const // gibt den Auswahl Rahmen zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswRahmen ? auswRahmen->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswRahmen ? auswRahmen->getThis() : 0;
 }
 
 LRahmen *AuswahlBox::zAuswRahmen() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswRahmen;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswRahmen;
 }
 
 int AuswahlBox::getAuswRahmenFarbe() const // gibt die Auswahl Rahmen Frabe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswRahmen ? auswRahmen->getFarbe() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswRahmen ? auswRahmen->getFarbe() : 0;
 }
 
 int AuswahlBox::getAuswRahmenBreite() const // gibt die Auswahl Rahmen Breite zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswRahmen ? auswRahmen->getRBreite() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswRahmen ? auswRahmen->getRBreite() : 0;
 }
 
 AlphaFeld *AuswahlBox::getAuswAlphaFeld() const // gibt das Auswahl AlphaFeld zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswAf ? auswAf->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswAf ? auswAf->getThis() : 0;
 }
 
 AlphaFeld *AuswahlBox::zAuswAlphaFeld() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswAf;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswAf;
 }
 
 int AuswahlBox::getAuswAlphaFeldFarbe() const // gibt die Auswahl AlphaFeld Farbe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswAf ? auswAf->getFarbe() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswAf ? auswAf->getFarbe() : 0;
 }
 
 int AuswahlBox::getAuswAlphaFeldStärke() const // gibt die Auswahl AlphaFeld stärke zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswAf ? auswAf->getStärke() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswAf ? auswAf->getStärke() : 0;
 }
 
 int AuswahlBox::getAuswHintergrundFarbe() const // gibt die Auswahl Hintergrund Farbe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswBgF;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswBgF;
 }
 
 Bild *AuswahlBox::getAuswHintergrundBild() const // gibt das Auswahl Hintergrund Bild zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswBgB ? auswBgB->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswBgB ? auswBgB->getThis() : 0;
 }
 
 Bild *AuswahlBox::zAuswHintergrundBild() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return auswBgB;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return auswBgB;
 }
 
 LRahmen *AuswahlBox::getMsAuswRahmen( int i ) const // gibt den Multistyle Auswahl Rahmen zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswRahmen )
-		return 0;
-	return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getThis() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswRahmen )
+        return 0;
+    return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getThis() : 0;
 }
 
 LRahmen *AuswahlBox::zMsAuswRahmen( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswRahmen )
-		return 0;
-	return msAuswRahmen->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswRahmen )
+        return 0;
+    return msAuswRahmen->z( i );
 }
 
 int AuswahlBox::getMsAuswRahmenFarbe( int i ) const // gibt die Multistyle Auswahl Rahmen Frabe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswRahmen )
-		return 0;
-	return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getFarbe() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswRahmen )
+        return 0;
+    return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getFarbe() : 0;
 }
 
 int AuswahlBox::getMsAuswRahmenBreite( int i ) const // gibt die Multistyle Auswahl Rahmen Breite zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswRahmen )
-		return 0;
-	return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getRBreite() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswRahmen )
+        return 0;
+    return msAuswRahmen->z( i ) ? msAuswRahmen->z( i )->getRBreite() : 0;
 }
 
 AlphaFeld *AuswahlBox::getMsAuswAlphaFeld( int i ) const // gibt das Multistyle Auswahl AlphaFeld zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswAf )
-		return 0;
-	return msAuswAf->z( i ) ? msAuswAf->z( i )->getThis() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswAf )
+        return 0;
+    return msAuswAf->z( i ) ? msAuswAf->z( i )->getThis() : 0;
 }
 
 AlphaFeld *AuswahlBox::zMsAuswAlphaFeld( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswAf )
-		return 0;
-	return msAuswAf->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswAf )
+        return 0;
+    return msAuswAf->z( i );
 }
 
 int AuswahlBox::getMsAuswAlphaFeldFarbe( int i ) const // gibt die Multistyle Auswahl AlphaFeld Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswAf )
-		return 0;
-	return msAuswAf->z( i ) ? msAuswAf->z( i )->getFarbe() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswAf )
+        return 0;
+    return msAuswAf->z( i ) ? msAuswAf->z( i )->getFarbe() : 0;
 }
 
 int AuswahlBox::getMsAuswAlphaFeldStärke( int i ) const // gibt die Multistyle Auswahl AlphaFeld stärke zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswAf )
-		return 0;
-	return msAuswAf->z( i ) ? msAuswAf->z( i )->getStärke() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswAf )
+        return 0;
+    return msAuswAf->z( i ) ? msAuswAf->z( i )->getStärke() : 0;
 }
 
 int AuswahlBox::getMsAuswHintergrundFarbe( int i ) const // gibt die Multistyle Auswahl Hintergrund Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswBgF || !msAuswBgF->hat( i ) )
-		return 0;
-	return msAuswBgF->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswBgF || !msAuswBgF->hat( i ) )
+        return 0;
+    return msAuswBgF->get( i );
 }
 
 Bild *AuswahlBox::getMsAuswHintergrundBild( int i ) const // gibt das Multistyle Auswahl Hintergrund Bild zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswBgB )
-		return 0;
-	return msAuswBgB->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswBgB )
+        return 0;
+    return msAuswBgB->get( i );
 }
 
 Bild *AuswahlBox::zMsAuswHintergrundBild( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msAuswBgB )
-		return 0;
-	return msAuswBgB->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msAuswBgB )
+        return 0;
+    return msAuswBgB->z( i );
 }
 
 LRahmen *AuswahlBox::getMausRahmen() const // gibt den Maus Rahmen zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausRahmen ? mausRahmen->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausRahmen ? mausRahmen->getThis() : 0;
 }
 
 LRahmen *AuswahlBox::zMausRahmen() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausRahmen;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausRahmen;
 }
 
 int AuswahlBox::getMausRahmenFarbe() const // gibt die Maus Rahmen Frabe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausRahmen ? mausRahmen->getFarbe() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausRahmen ? mausRahmen->getFarbe() : 0;
 }
 
 int AuswahlBox::getMausRahmenBreite() const // gibt die Maus Rahmen Breite zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausRahmen ? mausRahmen->getRBreite() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausRahmen ? mausRahmen->getRBreite() : 0;
 }
 
 AlphaFeld *AuswahlBox::getMausAlphaFeld() const // gibt das Maus AlphaFeld zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausAf ? mausAf->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausAf ? mausAf->getThis() : 0;
 }
 
 AlphaFeld *AuswahlBox::zMausAlphaFeld() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausAf;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausAf;
 }
 
 int AuswahlBox::getMausAlphaFeldFarbe() const // gibt die Maus AlphaFeld Farbe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausAf ? mausAf->getFarbe() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausAf ? mausAf->getFarbe() : 0;
 }
 
 int AuswahlBox::getMausAlphaFeldStärke() const // gibt die Maus AlphaFeld stärke zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausAf ? mausAf->getStärke() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausAf ? mausAf->getStärke() : 0;
 }
 
 int AuswahlBox::getMausHintergrundFarbe() const // gibt die Maus Hintergrund Farbe zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausBgF;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausBgF;
 }
 
 Bild *AuswahlBox::getMausHintergrundBild() const // gibt das Maus Hintergrund Bild zurück
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausBgB ? mausBgB->getThis() : 0;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausBgB ? mausBgB->getThis() : 0;
 }
 
 Bild *AuswahlBox::zMausHintergrundBild() const
 {
-	if( hatStyle( Style::MultiStyled ) )
-		return 0;
-	return mausBgB;
+    if( hatStyle( Style::MultiStyled ) )
+        return 0;
+    return mausBgB;
 }
 
 LRahmen *AuswahlBox::getMsMausRahmen( int i ) const // gibt den Multistyle Maus Rahmen zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausRahmen )
-		return 0;
-	return msMausRahmen->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausRahmen )
+        return 0;
+    return msMausRahmen->get( i );
 }
 
 LRahmen *AuswahlBox::zMsMausRahmen( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausRahmen )
-		return 0;
-	return msMausRahmen->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausRahmen )
+        return 0;
+    return msMausRahmen->z( i );
 }
 
 int AuswahlBox::getMsMausRahmenFarbe( int i ) const // gibt die Multistyle Maus Rahmen Frabe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausRahmen )
-		return 0;
-	return msMausRahmen->z( i ) ? msMausRahmen->z( i )->getFarbe() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausRahmen )
+        return 0;
+    return msMausRahmen->z( i ) ? msMausRahmen->z( i )->getFarbe() : 0;
 }
 
 int AuswahlBox::getMsMausRahmenBreite( int i ) const // gibt die Multistyle Maus Rahmen Breite zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausRahmen )
-		return 0;
-	return msMausRahmen->z( i ) ? msMausRahmen->z( i )->getRBreite() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausRahmen )
+        return 0;
+    return msMausRahmen->z( i ) ? msMausRahmen->z( i )->getRBreite() : 0;
 }
 
 AlphaFeld *AuswahlBox::getMsMausAlphaFeld( int i ) const // gibt das Multistyle Maus AlphaFeld zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausAf )
-		return 0;
-	return msMausAf->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausAf )
+        return 0;
+    return msMausAf->get( i );
 }
 
 AlphaFeld *AuswahlBox::zMsMausAlphaFeld( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausAf )
-		return 0;
-	return msMausAf->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausAf )
+        return 0;
+    return msMausAf->z( i );
 }
 
 int AuswahlBox::getMsMausAlphaFeldFarbe( int i ) const // gibt die Multistyle Maus AlphaFeld Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausAf )
-		return 0;
-	return msMausAf->z( i ) ? msMausAf->z( i )->getFarbe() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausAf )
+        return 0;
+    return msMausAf->z( i ) ? msMausAf->z( i )->getFarbe() : 0;
 }
 
 int AuswahlBox::getMsMausAlphaFeldStärke( int i ) const // gibt die Multistyle Maus AlphaFeld stärke zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausAf )
-		return 0;
-	return msMausAf->z( i ) ? msMausAf->z( i )->getStärke() : 0;
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausAf )
+        return 0;
+    return msMausAf->z( i ) ? msMausAf->z( i )->getStärke() : 0;
 }
 
 int AuswahlBox::getMsMausHintergrundFarbe( int i ) const // gibt die Multistyle Maus Hintergrund Farbe zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausBgF || !msMausBgF->hat( i ) )
-		return 0;
-	return msMausBgF->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausBgF || !msMausBgF->hat( i ) )
+        return 0;
+    return msMausBgF->get( i );
 }
 
 Bild *AuswahlBox::getMsMausHintergrundBild( int i ) const // gibt das Multistyle Maus Hintergrund Bild zurück
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausBgB )
-		return 0;
-	return msMausBgB->get( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausBgB )
+        return 0;
+    return msMausBgB->get( i );
 }
 
 Bild *AuswahlBox::zMsMausHintergrundBild( int i ) const
 {
-	if( !hatStyle( Style::MultiStyled ) )
-		return 0;
-	if( !msMausBgB )
-		return 0;
-	return msMausBgB->z( i );
+    if( !hatStyle( Style::MultiStyled ) )
+        return 0;
+    if( !msMausBgB )
+        return 0;
+    return msMausBgB->z( i );
 }
 
 bool AuswahlBox::hatMsStyle( int i, __int64 abStyle ) const // prüft ob Multistyle style vorhanden
 {
-	if( ( style | Style::MultiStyled ) != style || !msStyle || !msStyle->hat( i ) )
-		return 0;
-	return ( msStyle->get( i ) | abStyle ) == msStyle->get( i );
+    if( ( style | Style::MultiStyled ) != style || !msStyle || !msStyle->hat( i ) )
+        return 0;
+    return ( msStyle->get( i ) | abStyle ) == msStyle->get( i );
 }
 
 bool AuswahlBox::hatMsStyleNicht( int i, __int64 abStyle ) const // prüft ob Multistyle style nicht vorhanden
 {
-	if( ( style | Style::MultiStyled ) != style || !msStyle || !msStyle->hat( i ) )
-		return 1;
-	return ( msStyle->get( i ) | abStyle ) != msStyle->get( i );
+    if( ( style | Style::MultiStyled ) != style || !msStyle || !msStyle->hat( i ) )
+        return 1;
+    return ( msStyle->get( i ) | abStyle ) != msStyle->get( i );
 }
 
 Zeichnung *AuswahlBox::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
 {
-	AuswahlBox *obj = new AuswahlBox();
-	obj->setPosition( pos );
-	obj->setGröße( gr );
-	obj->setMausEreignisParameter( makParam );
-	obj->setTastaturEreignisParameter( takParam );
-	obj->setMausEreignis( Mak );
-	obj->setTastaturEreignis( Tak );
-	if( toolTip )
-		obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	obj->setStyle( style );
-	if( schrift )
-		obj->setSchriftZ( schrift->getThis() );
-	if( rahmen )
-		obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
-	if( ausfahren )
-		obj->setAusklappKnopfZ( (Knopf*)ausfahren->dublizieren() );
-	obj->setHintergrundFarbe( hintergrundFarbe );
-	if( hintergrundBild )
-		obj->setHintergrundBild( hintergrundBild->getThis() );
-	if( hintergrundFeld )
-		obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
-	if( auswRahmen )
-		obj->setAuswRahmenZ( (LRahmen*)auswRahmen->dublizieren() );
-	obj->setAuswHintergrundFarbe( auswBgF );
-	if( auswBgB )
-		obj->setAuswHintergrundBild( auswBgB->getThis() );
-	if( auswAf )
-		obj->setAuswAlphaFeldZ( (AlphaFeld*)auswAf->dublizieren() );
-	if( mausRahmen )
-		obj->setMausRahmenZ( (LRahmen*)mausRahmen->dublizieren() );
-	obj->setMausHintergrundFarbe( mausBgF );
-	if( mausBgB )
-		obj->setMausHintergrundBild( mausBgB->getThis() );
-	if( mausAf )
-		obj->setMausAlphaFeldZ( (AlphaFeld*)mausAf->dublizieren() );
-	obj->setMaxAuskappHöhe( ausklapMaxHöhe );
-	obj->setEintragHöhe( eintragHöhe );
-	for( int i = 0; i < anzahl; ++i )
-	{
-		if( members->z( i ) )
-		{
-			obj->addEintrag( "a" );
-			obj->setEintragZ( i, (TextFeld*)members->z( i )->dublizieren() );
-			if( msStyle && msStyle->hat( i ) )
-				obj->setMsStyle( i, msStyle->get( i ) );
-			if( msAuswRahmen && msAuswRahmen->z( i ) )
-				obj->setMsAuswRahmenZ( i, (LRahmen*)msAuswRahmen->z( i )->dublizieren() );
-			if( msAuswBgF && msAuswBgF->hat( i ) )
-				obj->setMsAuswHintergrundFarbe( i, msAuswBgF->get( i ) );
-			if( msAuswBgB && msAuswBgB->z( i ) )
-				obj->setMsAuswHintergrundBild( i, msAuswBgB->get( i ) );
-			if( msAuswAf && msAuswAf->z( i ) )
-				obj->setMsAuswAlphaFeldZ( i, (AlphaFeld*)msAuswAf->z( i )->dublizieren() );
-			if( msMausRahmen && msMausRahmen->z( i ) )
-				obj->setMsMausRahmenZ( i, (LRahmen*)msMausRahmen->z( i )->dublizieren() );
-			if( msMausBgF && msMausBgF->hat( i ) )
-				obj->setMsMausHintergrundFarbe( i, msMausBgF->get( i ) );
-			if( msMausBgB && msMausBgB->z( i ) )
-				obj->setMsMausHintergrundBild( i, msMausBgB->get( i ) );
-			if( msMausAf && msMausAf->z( i ) )
-				obj->setMsMausAlphaFeldZ( i, (AlphaFeld*)msMausAf->z( i )->dublizieren() );
-		}
-	}
-	obj->setAlphaFeldFarbe( auswahl );
-	return obj;
+    AuswahlBox *obj = new AuswahlBox();
+    obj->setPosition( pos );
+    obj->setGröße( gr );
+    obj->setMausEreignisParameter( makParam );
+    obj->setTastaturEreignisParameter( takParam );
+    obj->setMausEreignis( Mak );
+    obj->setTastaturEreignis( Tak );
+    if( toolTip )
+        obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    obj->setStyle( style );
+    if( schrift )
+        obj->setSchriftZ( schrift->getThis() );
+    if( rahmen )
+        obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
+    if( ausfahren )
+        obj->setAusklappKnopfZ( (Knopf*)ausfahren->dublizieren() );
+    obj->setHintergrundFarbe( hintergrundFarbe );
+    if( hintergrundBild )
+        obj->setHintergrundBild( hintergrundBild->getThis() );
+    if( hintergrundFeld )
+        obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
+    if( auswRahmen )
+        obj->setAuswRahmenZ( (LRahmen*)auswRahmen->dublizieren() );
+    obj->setAuswHintergrundFarbe( auswBgF );
+    if( auswBgB )
+        obj->setAuswHintergrundBild( auswBgB->getThis() );
+    if( auswAf )
+        obj->setAuswAlphaFeldZ( (AlphaFeld*)auswAf->dublizieren() );
+    if( mausRahmen )
+        obj->setMausRahmenZ( (LRahmen*)mausRahmen->dublizieren() );
+    obj->setMausHintergrundFarbe( mausBgF );
+    if( mausBgB )
+        obj->setMausHintergrundBild( mausBgB->getThis() );
+    if( mausAf )
+        obj->setMausAlphaFeldZ( (AlphaFeld*)mausAf->dublizieren() );
+    obj->setMaxAuskappHöhe( ausklapMaxHöhe );
+    obj->setEintragHöhe( eintragHöhe );
+    for( int i = 0; i < anzahl; ++i )
+    {
+        if( members->z( i ) )
+        {
+            obj->addEintrag( "a" );
+            obj->setEintragZ( i, (TextFeld*)members->z( i )->dublizieren() );
+            if( msStyle && msStyle->hat( i ) )
+                obj->setMsStyle( i, msStyle->get( i ) );
+            if( msAuswRahmen && msAuswRahmen->z( i ) )
+                obj->setMsAuswRahmenZ( i, (LRahmen*)msAuswRahmen->z( i )->dublizieren() );
+            if( msAuswBgF && msAuswBgF->hat( i ) )
+                obj->setMsAuswHintergrundFarbe( i, msAuswBgF->get( i ) );
+            if( msAuswBgB && msAuswBgB->z( i ) )
+                obj->setMsAuswHintergrundBild( i, msAuswBgB->get( i ) );
+            if( msAuswAf && msAuswAf->z( i ) )
+                obj->setMsAuswAlphaFeldZ( i, (AlphaFeld*)msAuswAf->z( i )->dublizieren() );
+            if( msMausRahmen && msMausRahmen->z( i ) )
+                obj->setMsMausRahmenZ( i, (LRahmen*)msMausRahmen->z( i )->dublizieren() );
+            if( msMausBgF && msMausBgF->hat( i ) )
+                obj->setMsMausHintergrundFarbe( i, msMausBgF->get( i ) );
+            if( msMausBgB && msMausBgB->z( i ) )
+                obj->setMsMausHintergrundBild( i, msMausBgB->get( i ) );
+            if( msMausAf && msMausAf->z( i ) )
+                obj->setMsMausAlphaFeldZ( i, (AlphaFeld*)msMausAf->z( i )->dublizieren() );
+        }
+    }
+    obj->setAlphaFeldFarbe( auswahl );
+    return obj;
 }
 
 // Reference Counting
 AuswahlBox *AuswahlBox::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 AuswahlBox *AuswahlBox::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Betriebssystem.h

@@ -46,27 +46,27 @@
 class CriticalSection
 {
 public:
-	CriticalSection()
-	{
-		pthread_mutexattr_t attr;
-		pthread_mutexattr_init(&attr);
-		pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
-		pthread_mutex_init( &mutex, &attr );
-  }
-	~CriticalSection()
-	{
-		pthread_mutex_destroy( &mutex );
-	}
-	void Enter()
-	{
-		pthread_mutex_lock( &mutex );
-	}
-	void Leave()
-	{
-		pthread_mutex_unlock( &mutex );
-	}
+    CriticalSection()
+    {
+        pthread_mutexattr_t attr;
+        pthread_mutexattr_init( &attr );
+        pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
+        pthread_mutex_init( &mutex, &attr );
+    }
+    ~CriticalSection()
+    {
+        pthread_mutex_destroy( &mutex );
+    }
+    void Enter()
+    {
+        pthread_mutex_lock( &mutex );
+    }
+    void Leave()
+    {
+        pthread_mutex_unlock( &mutex );
+    }
 private:
-	pthread_mutex_t mutex;
+    pthread_mutex_t mutex;
 };
 #else
 class CriticalSection;

Bild.cpp

@@ -74,7 +74,7 @@ inline void Bild::alphaPixelP( int &fc, int colorb )
     int alpha = ( ( colorb >> 24 ) & 0xFF );
     int na = ( 0x100 - alpha );
     fc = ( ( ( ( ( na * ( fc & 0xFF00FF ) ) >> 8 ) + ( ( alpha * ( colorb & 0xFF00FF ) ) >> 8 ) ) & 0xFF00FF ) |
-           ( ( ( ( na * ( fc & 0x00FF00 ) ) >> 8 ) + ( ( alpha * ( colorb & 0x00FF00 ) ) >> 8 ) ) & 0x00FF00 ) |
+        ( ( ( ( na * ( fc & 0x00FF00 ) ) >> 8 ) + ( ( alpha * ( colorb & 0x00FF00 ) ) >> 8 ) ) & 0x00FF00 ) |
            ( ( fc & 0xFF000000 ) ) ) * ( fc != 0 || !alpha3D ) | ( fc == 0 && alpha3D ) * colorb;
     //unsigned char *fc1 = (unsigned char*)&fc[ i ];
     //unsigned char *fc2 = (unsigned char*)&colorb;
@@ -396,7 +396,7 @@ void Bild::alphaRegion( int x, int y, int b, int h, int ff )
         for( ; pixel < rowEnd; ++pixel )
         {
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( ( *pixel & 0xFF000000 ) ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * ff;
         }
     }
@@ -602,7 +602,7 @@ void Bild::drawLinieHAlpha( int x, int y, int l
     for( int i = x + y * br; end < län; ++end, i += pval )
     {
         fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                    ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+            ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                     ( ( fc[ i ] & 0xFF000000 ) ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
     }
     rend = 1;
@@ -649,7 +649,7 @@ void Bild::drawLinieVAlpha( int x, int y, int l
     for( int i = x + y * br; end < län; ++end, i += pval )
     {
         fc[ i ] = ( ( ( ( ( na * ( fc[ i ] & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                    ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+            ( ( ( ( na * ( fc[ i ] & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                     ( fc[ i ] & 0xFF000000 ) ) * ( fc[ i ] != 0 || !alpha3D ) | ( fc[ i ] == 0 && alpha3D ) * f;
     }
     rend = 1;
@@ -826,7 +826,7 @@ void Bild::drawLinieAlpha( Punkt a, Punkt b, int fc )
             ++count;
             int &pixel = this->fc[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * größe.x ];
             pixel = ( ( ( ( ( na * ( pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                      ( ( ( ( na * ( pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                       ( pixel & 0xFF000000 ) ) * ( pixel != 0 || !alpha3D ) | ( pixel == 0 && alpha3D ) * fc;
             x += xf, y += yf;
         }
@@ -911,56 +911,56 @@ void Bild::drawKreisAlpha( int xOff, int yOff, int r, int fc )
         {
             pixel = &this->fc[ xOff + a + ( yOff + b ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff - a < dgx && xOff - a > dpx && yOff + b < dgy && yOff + b > dpy )
         {
             pixel = &this->fc[ xOff - a + ( yOff + b ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff + a < dgx && xOff + a > dpx && yOff - b < dgy && yOff - b > dpy )
         {
             pixel = &this->fc[ xOff + a + ( yOff - b ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff - a < dgx && xOff - a > dpx && yOff - b < dgy && yOff - b > dpy )
         {
             pixel = &this->fc[ xOff - a + ( yOff - b ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff + b < dgx && xOff + b > dpx && yOff + a < dgy && yOff + a > dpy )
         {
             pixel = &this->fc[ xOff + b + ( yOff + a ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff - b < dgx && xOff - b > dpx && yOff + a < dgy && yOff + a > dpy )
         {
             pixel = &this->fc[ xOff - b + ( yOff + a ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff + b < dgx && xOff + b > dpx && yOff - a < dgy && yOff - a > dpy )
         {
             pixel = &this->fc[ xOff + b + ( yOff - a ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
         if( xOff - b < dgx && xOff - b > dpx && yOff - a < dgy && yOff - a > dpy )
         {
             pixel = &this->fc[ xOff - b + ( yOff - a ) * größe.x ];
             *pixel = ( ( ( ( ( na * ( *pixel & 0xFF00FF ) ) >> 8 ) + i1 ) & 0xFF00FF ) |
-                       ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
+                ( ( ( ( na * ( *pixel & 0x00FF00 ) ) >> 8 ) + i2 ) & 0x00FF00 ) |
                        ( *pixel & 0xFF000000 ) ) * ( *pixel != 0 || !alpha3D ) | ( *pixel == 0 && alpha3D ) * fc;
         }
     }

Bildschirm.cpp

@@ -465,7 +465,7 @@ void Bildschirm2D::render() // Zeichnet das Bild
         int *bgBuff = tmp->getBuffer();
         int tmpBr = sizeof( D3DCOLOR )* tmp->getBreite();
         for( int y = 0, pitch = 0, bry = 0; y < tmp->getHöhe(); ++y, pitch += backRect->Pitch, bry += tmp->getBreite() )
-            memcpy( &( (BYTE *)backRect->pBits )[ pitch ], (void*)&( bgBuff[ bry ] ), tmpBr );
+            memcpy( &( (BYTE *)backRect->pBits )[ pitch ], ( void* )&( bgBuff[ bry ] ), tmpBr );
         // Beende Bild 
         result = pBackBuffer->UnlockRect();
         tmp->release();

Cube.h

@@ -8,11 +8,11 @@ namespace Framework
 
     enum CubeSeite
     {
-        VORNE, 
-        HINTEN, 
-        RECHTS, 
-        LINKS, 
-        OBEN, 
+        VORNE,
+        HINTEN,
+        RECHTS,
+        LINKS,
+        OBEN,
         UNTEN
     };
 

DXBuffer.cpp

@@ -132,8 +132,7 @@ DXBuffer *DXBuffer::release()
 // eSize: Die Länge eines Elementes in Bytes
 DXVertexBuffer::DXVertexBuffer( int eSize )
     : DXBuffer( D3D11_BIND_VERTEX_BUFFER, eSize )
-{
-}
+{}
 
 // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
 //  return: 0.
@@ -152,8 +151,7 @@ DXBuffer *DXVertexBuffer::release()
 // eSize: Die Länge eines Elementes in Bytes
 DXIndexBuffer::DXIndexBuffer( int eSize )
     : DXBuffer( D3D11_BIND_INDEX_BUFFER, eSize )
-{
-}
+{}
 
 // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
 //  return: 0.

Datei.cpp

@@ -331,15 +331,15 @@ int Datei::getUnterdateiAnzahl() const // gibt die Anzahl der unterdateien an
 #else
     if( !pfad )
         return 0;
-    if( !DateiIstVerzeichnis( pfad->getThis( ) ) )
+    if( !DateiIstVerzeichnis( pfad->getThis() ) )
         return 0;
     int ret = 0;
-    Text stxt = pfad->getText( );
+    Text stxt = pfad->getText();
     stxt.ersetzen( '\\', '/' );
-    if( stxt.positionVon( '/' ) == stxt.getLaenge( ) - 1 )
-        stxt.loeschen( stxt.getLaenge( ) - 1 );
+    if( stxt.positionVon( '/' ) == stxt.getLaenge() - 1 )
+        stxt.loeschen( stxt.getLaenge() - 1 );
     DIR *hdir;
-    hdir = opendir( stxt.getText( ) );
+    hdir = opendir( stxt.getText() );
     for( dirent *entry = readdir( hdir ); entry; entry = readdir( hdir ) )
     {
         if( entry && entry->d_name[ 0 ] != '.' )
@@ -461,8 +461,8 @@ Zeit *Datei::getLetzte
     return ret;
 #else
     struct stat attrib;
-    stat(pfad->getText(), &attrib);
-    tm *clock = gmtime(&(attrib.st_mtime));
+    stat( pfad->getText(), &attrib );
+    tm *clock = gmtime( &( attrib.st_mtime ) );
     Zeit *ret = new Zeit();
     ret->setZeit( clock->tm_year + 1900, clock->tm_mon + 1, clock->tm_mday, clock->tm_hour, clock->tm_min, clock->tm_sec );
     return ret;
@@ -782,7 +782,7 @@ bool Framework::DateiExistiert( const char *pfad ) // Pr
         return 1;
     return 0;
 #endif
-        }
+}
 
 bool Framework::DateiIstVerzeichnis( const char *pfad ) // prüft, ob pfad ein Verzeichnis ist
 {

Datei.h

@@ -6,13 +6,13 @@
 
 namespace Framework
 {
-	class Text; // Text.h
-	class Zeit; // Zeit.h
-	class Datei; // aus dieser Datei
+    class Text; // Text.h
+    class Zeit; // Zeit.h
+    class Datei; // aus dieser Datei
 
     // Ließt und schreibt in eine Datei
-	class Datei
-	{
+    class Datei
+    {
     public:
         class Style
         {
@@ -21,141 +21,141 @@ namespace Framework
             const static int schreiben = 0x02; // datei wirt zum schreiben geöffnet
             const static int ende = 0x04; // setzt dateizeiger ans Ende der Datei
         };
-	private:
-		int ref;
-		std::fstream *stream;
-		Text *pfad;
-		__int64 gr;
-		char tmpLByte;
-		char tmpLBPos;
-		char tmpSByte;
-		char tmpSBPos;
+    private:
+        int ref;
+        std::fstream *stream;
+        Text *pfad;
+        __int64 gr;
+        char tmpLByte;
+        char tmpLBPos;
+        char tmpSByte;
+        char tmpSBPos;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Datei();
-		// Destruktor 
-		__declspec( dllexport ) ~Datei();
-		// Setzt den Pfad zur Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Datei();
+        // Destruktor 
+        __declspec( dllexport ) ~Datei();
+        // Setzt den Pfad zur Datei
         //  pfad: Der Pfad
-		__declspec( dllexport ) void setDatei( const char *pfad );
+        __declspec( dllexport ) void setDatei( const char *pfad );
         // Setzt den Pfad zur Datei
         //  pfad: Der Pfad
-		__declspec( dllexport ) void setDatei( Text *pfad );
+        __declspec( dllexport ) void setDatei( Text *pfad );
         // Benennt die Datei um oder verschiebt sie
         //  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
-		__declspec( dllexport ) bool umbenennen( const char *pfad );
+        __declspec( dllexport ) bool umbenennen( const char *pfad );
         // Benennt die Datei um oder verschiebt sie
         //  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
-		__declspec( dllexport ) bool umbenennen( Text *pfad );
+        __declspec( dllexport ) bool umbenennen( Text *pfad );
         // Löscht die Datei
         //  return: 1, wenn das löschen erfolgreich war. 0 sonst
-		__declspec( dllexport ) bool löschen();
+        __declspec( dllexport ) bool löschen();
         // 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
-		__declspec( dllexport ) bool erstellen();
+        __declspec( dllexport ) bool erstellen();
         // Öffnet die Datei
         //  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
-		__declspec( dllexport ) bool öffnen( int style );
+        __declspec( dllexport ) bool öffnen( int style );
         // Setzt die Position des Bytes, das als nächstes gelesen werden soll
         //  pos: Der Index des Bytes
         //  ende: 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
-		__declspec( dllexport ) void setLPosition( __int64 pos, bool ende );
+        __declspec( dllexport ) void setLPosition( __int64 pos, bool ende );
         // Setzt die Position des Bytes, das als nächstes überschrieben wird
         //  pos: Der Index des Bytes
         //  ende: 1, wenn der Index vom ende der Datei zählt. 0, wenn der Index vom Beginn der Datei zählt
-		__declspec( dllexport ) void setSPosition( __int64 pos, bool ende );
+        __declspec( dllexport ) void setSPosition( __int64 pos, bool ende );
         // Schreibt in die Datei
         //  bytes: Ein Array von bytes, die geschrieben werden sollen.
         //  län: Wie viele Bytes in die Datei geschrieben werden sollen
-		__declspec( dllexport ) void schreibe( char *bytes, int län );
+        __declspec( dllexport ) void schreibe( char *bytes, int län );
         // Ließt aus der Datei
         //  bytes: Ein Array, der mit Bytes aus der Datei gefüllt werden soll
         //  län: Wie viele Bytes aus der Datei gelesen werden sollen
         __declspec( dllexport ) void lese( char *bytes, int län );
         // Ließt die nächste zeile der Datei ein
         //  return: Die gelesene Zeile als Text mit zeilenumbruch
-		__declspec( dllexport ) Text *leseZeile();
+        __declspec( dllexport ) Text *leseZeile();
         // Schließt die datei
-		__declspec( dllexport ) void schließen();
+        __declspec( dllexport ) void schließen();
 #ifdef WIN32
         // Setzt den Zeitpunkt der letzten Änderung der Datei (nur für Windows)
         //  zeit: den Zeitpunkt der letzten Änderung
         //  return: 1, wenn der Zeitpunkt gesetzt wurde. 0 sonst
-		__declspec( dllexport ) bool setLetzteÄnderung( Zeit *zeit );
+        __declspec( dllexport ) bool setLetzteÄnderung( Zeit *zeit );
 #endif
         // Ließt das nächste Bit aus der Datei
         //  bit: Eine Referenz auf deinen bool, in dem das Bit gespeichert wird
         //  return 1, falls das lesen erfolgreich war. 0, sonst
-		__declspec( dllexport ) bool getNextBit( bool &bit );
+        __declspec( dllexport ) bool getNextBit( bool &bit );
         // Speichert ein einzelnes Bit in der Datei
         //  bit: Das bit, welches gespeichert werden soll
         //  return 1, falls das speichern erfolgreich war
-		__declspec( dllexport ) bool setNextBit( bool bit );
-		// Prüft, ob die Datei ein Verzeichnis ist
+        __declspec( dllexport ) bool setNextBit( bool bit );
+        // Prüft, ob die Datei ein Verzeichnis ist
         //  return 1, falls die Datei ein Verzeichnis ist. 0, sonst
-		__declspec( dllexport ) bool istOrdner() const;
+        __declspec( dllexport ) bool istOrdner() const;
         // Prüft, ob die Datei bereits geöffnet wurde
         //  return: 1, wenn die Datei geöffnet ist. 0 sonnst
-		__declspec( dllexport ) bool istOffen() const;
+        __declspec( 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
         __declspec( 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
-		__declspec( dllexport ) RCArray< Text > *getDateiListe() const;
+        __declspec( 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
-		__declspec( dllexport ) __int64 getGröße() const;
+        __declspec( dllexport ) __int64 getGröße() const;
         // Gibt den Zeitpunkt der letzten änderung zurück
         //  return: 0, falls ein Fehler aufgetreten ist. Der Zeitpunkt der letzten Änderung sonst
-		__declspec( dllexport ) Zeit *getLetzteÄnderung() const;
+        __declspec( dllexport ) Zeit *getLetzteÄnderung() const;
         // Prüft, ob die Datei existiert
         //  return: 1, falls die Datei existiert. 0 sonnst
-		__declspec( dllexport ) bool existiert() const;
+        __declspec( 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
         __declspec( dllexport ) __int64 getLPosition() const;
         // 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
-		__declspec( dllexport ) __int64 getSPosition() const;
+        __declspec( dllexport ) __int64 getSPosition() const;
         // Prüft, ob die Datei vollständig gelesen wurde
         //  return 1, wenn die Datei vollständig gelesen wurde. 0, sonst
-		__declspec( dllexport ) bool istEnde() const;
+        __declspec( dllexport ) bool istEnde() const;
         // Gibt den Pfad zur Datei zurück
-		__declspec( dllexport ) Text *getPfad() const;
+        __declspec( dllexport ) Text *getPfad() const;
         // Gibt den Pfad zur Datei ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Text *zPfad() const;
+        __declspec( dllexport ) Text *zPfad() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Datei *getThis();
+        __declspec( dllexport ) Datei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Datei *release();
-	};
+        __declspec( dllexport ) Datei *release();
+    };
 
-	// Datei Funktionen
+    // Datei Funktionen
 
     // Sucht einen unbenutzten Dateinamen
     //  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
-	__declspec( dllexport ) void GetFreePfad( Text *zPfad );
+    __declspec( dllexport ) void GetFreePfad( Text *zPfad );
     // Erstellt den vollständigen Pfad mit Datei
     //  pfad: Der Pfad zur Datei
     //  return: 1, falls das erstellen erfolgreich war.
-	__declspec( dllexport ) bool DateiPfadErstellen( Text* pfad );
+    __declspec( dllexport ) bool DateiPfadErstellen( Text* pfad );
     // Löscht die angegebene Datei
     //  pfad: Der Pfad zur Datei
     //  return: 1, falls die Datei gelöscht wurde
-	__declspec( dllexport ) bool DateiLöschen( Text *pfad );
+    __declspec( dllexport ) bool DateiLöschen( 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
-	__declspec( dllexport ) bool DateiUmbenennen( Text *pfad_alt, Text *pfad_neu );
+    __declspec( dllexport ) bool DateiUmbenennen( Text *pfad_alt, Text *pfad_neu );
     // Prüft, ob Datei existiert
     //  pfad: Der Pfad zur Datei
     //  return: 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
@@ -163,28 +163,28 @@ namespace Framework
     // prüft, ob pfad ein Verzeichnis ist
     //  pfad: Der Pfad zur Datei
     //  return: 1, wenn die Datei ein Verzeichnis ist. 0 sonst
-	__declspec( dllexport ) bool DateiIstVerzeichnis( Text *pfad );
+    __declspec( dllexport ) bool DateiIstVerzeichnis( Text *pfad );
     // Erstellt den vollständigen Pfad mit Datei
     //  pfad: Der Pfad zur Datei
     //  return: 1, falls das erstellen erfolgreich war.
-	__declspec( dllexport ) bool DateiPfadErstellen( const char *pfad );
+    __declspec( dllexport ) bool DateiPfadErstellen( const char *pfad );
     // Löscht die angegebene Datei
     //  pfad: Der Pfad zur Datei
     //  return: 1, falls die Datei gelöscht wurde
-	__declspec( dllexport ) bool DateiLöschen( const char *pfad );
+    __declspec( dllexport ) bool DateiLöschen( 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
-	__declspec( dllexport ) bool DateiUmbenennen( const char *pfad_alt, const char *pfad_neu );
+    __declspec( dllexport ) bool DateiUmbenennen( const char *pfad_alt, const char *pfad_neu );
     // Prüft, ob Datei existiert
     //  pfad: Der Pfad zur Datei
     //  return: 1, wenn die Datei existiert. 0, wenn die Datei nicht gefunden wurde
-	__declspec( dllexport ) bool DateiExistiert( const char *pfad );
+    __declspec( dllexport ) bool DateiExistiert( const char *pfad );
     // prüft, ob pfad ein Verzeichnis ist
     //  pfad: Der Pfad zur Datei
     //  return: 1, wenn die Datei ein Verzeichnis ist. 0 sonst
-	__declspec( dllexport ) bool DateiIstVerzeichnis( const char *pfad );
+    __declspec( dllexport ) bool DateiIstVerzeichnis( const char *pfad );
 }
 
 #endif

DateiSystem.cpp

@@ -16,3192 +16,3182 @@ using namespace Framework;
 // Inhalt der LTDBPixel Klasse aus Dateisystem.h
 // Konstruktor 
 LTDBPixel::LTDBPixel( LTDBPixel *davor )
-	: davor( davor ),
-	  index( 0 ),
-	  iR( 0 ),
-	  iG( 0 ),
-	  iB( 0 ),
-	  iA( 0 ),
-	  miR( 8 ),
-	  miG( 8 ),
-	  miB( 8 ),
-	  miA( 8 ),
-	  maxIndex( 1 ),
-	  änder( 0 ),
-	  änderR( 0 ),
-	  änderG( 0 ),
-	  änderB( 0 ),
-	  änderA( 0 ),
-	  komp( 0 ),
-	  R( 0 ),
-	  G( 0 ),
-	  B( 0 ),
-	  A( 0 ),
-	  ref( 1 )
-{
-}
+    : davor( davor ),
+    index( 0 ),
+    iR( 0 ),
+    iG( 0 ),
+    iB( 0 ),
+    iA( 0 ),
+    miR( 8 ),
+    miG( 8 ),
+    miB( 8 ),
+    miA( 8 ),
+    maxIndex( 1 ),
+    änder( 0 ),
+    änderR( 0 ),
+    änderG( 0 ),
+    änderB( 0 ),
+    änderA( 0 ),
+    komp( 0 ),
+    R( 0 ),
+    G( 0 ),
+    B( 0 ),
+    A( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor 
 LTDBPixel::~LTDBPixel()
 {
-	if( davor )
-		davor->release();
+    if( davor )
+        davor->release();
 }
 
 // nicht constant 
 bool LTDBPixel::addBitZuFarbe( unsigned char bit ) // Fügt den Farbwerten ein Bit hinzu
 {
-	if( änderR && iR != miR ) // Das Bit gehört zu Rot
-	{
-		R |= ( ( bit & 0x1 ) ) << ( 7 - komp - iR );
-		++iR;
-	}
-	else if( änderG && iG != miG ) // Das Bit gehört zu Grün
-	{
-		G |= ( ( bit & 0x1 ) ) << ( 7 - komp - iG );
-		++iG;
-	}
-	else if( änderB && iB != miB ) // Das Bit gehört zu Blau
-	{
-		B |= ( ( bit & 0x1 ) ) << ( 7 - komp - iB );
-		++iB;
-	}
-	else if( änderA && iA != miA ) // Das Bit gehört zu Alpha
-	{
-		A |= ( ( bit & 0x1 ) ) << ( 7 - komp - iA );
-		++iA;
-	}
-	else // Das Bit gehört zum nächsten Pixel
-		return false;
-	return true;
+    if( änderR && iR != miR ) // Das Bit gehört zu Rot
+    {
+        R |= ( ( bit & 0x1 ) ) << ( 7 - komp - iR );
+        ++iR;
+    }
+    else if( änderG && iG != miG ) // Das Bit gehört zu Grün
+    {
+        G |= ( ( bit & 0x1 ) ) << ( 7 - komp - iG );
+        ++iG;
+    }
+    else if( änderB && iB != miB ) // Das Bit gehört zu Blau
+    {
+        B |= ( ( bit & 0x1 ) ) << ( 7 - komp - iB );
+        ++iB;
+    }
+    else if( änderA && iA != miA ) // Das Bit gehört zu Alpha
+    {
+        A |= ( ( bit & 0x1 ) ) << ( 7 - komp - iA );
+        ++iA;
+    }
+    else // Das Bit gehört zum nächsten Pixel
+        return false;
+    return true;
 }
 
 char LTDBPixel::addByte( char byte, char begin ) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
 {
-	if( begin >= 8 || begin < 0 )
-		return -1;
-	for( int i = begin; i < 8; ++i )
-	{
-		switch( index )
-		{
-		case 0:
-			// Das erste Bit eines Pixels speichert, ob sich an der Komprimierung etwas änderte
-			änder = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
-			if( !änder ) // Ändert sich nichts an der Komprimierung, so werden die Werte vom vorherigen Pixel übernommen
-			{
-				if( !davor ) // Die Datei ist beschädigt ( Der erste Pixel kann nicht von dem davor Übernemen )
-				{
+    if( begin >= 8 || begin < 0 )
+        return -1;
+    for( int i = begin; i < 8; ++i )
+    {
+        switch( index )
+        {
+        case 0:
+            // Das erste Bit eines Pixels speichert, ob sich an der Komprimierung etwas änderte
+            änder = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
+            if( !änder ) // Ändert sich nichts an der Komprimierung, so werden die Werte vom vorherigen Pixel übernommen
+            {
+                if( !davor ) // Die Datei ist beschädigt ( Der erste Pixel kann nicht von dem davor Übernemen )
+                {
 #ifdef WIN32
-					MessageBox( NULL, "Fehler, die Bilddatei ist beschädigt", "Fehler", MB_ICONERROR );
+                    MessageBox( NULL, "Fehler, die Bilddatei ist beschädigt", "Fehler", MB_ICONERROR );
 #endif
-					exit( 0 );
-				}
-				änderR = davor->getÄnderR();
-				änderG = davor->getÄnderG();
-				änderB = davor->getÄnderB();
-				änderA = davor->getÄnderA();
-				komp = davor->getKomp();
-				miR -= komp, miG -= komp, miB -= komp, miA -= komp;
-				if( !änderR )
-					R = davor->getR();
-				if( !änderG )
-					G = davor->getG();
-				if( !änderB )
-					B = davor->getB();
-				if( !änderA )
-					A = davor->getA();
-				maxIndex += ( änderR + änderG + änderB + änderA ) * ( 8 - komp ); // Bestimmung der Länge
-				// des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits, durch komprimierung kanns kleiner sein
-			}
-			else
-				maxIndex += 7; // Da der Pixel nicht die Werte des vorherigen übernimmt, wird er um 7 Bits größer
-			break;
-		case 1: // Das zweite Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				änderR = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 2: // Das dritte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				änderG = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 3: // Das vierte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				änderB = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 4: // Das fünfte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				änderA = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 5: // Das sechste Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 ) << 2;
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 6: // Das siebte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 ) << 1;
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 7: // Das achte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
-			{
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 );
-				// Das war das letzte Komprimierungsbit
-				// Komprimierung auswerten 
-				miR -= komp, miG -= komp, miB -= komp, miA -= komp;
-				if( !änderR )
-					R = davor->getR();
-				if( !änderG )
-					G = davor->getG();
-				if( !änderB )
-					B = davor->getB();
-				if( !änderA )
-					A = davor->getA();
-				maxIndex += ( änderR + änderG + änderB + änderA ) * ( 8 - komp ); // Bitlänge des Pixels
-			}
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
-			if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-				return i;
-			break;
-		}
-		++index;
-		if( index >= maxIndex )
-		{
-			if( davor )
-			{
-				if( änderR )
-					R = davor->getR() + R;
-				if( änderG )
-					G = davor->getG() + G;
-				if( änderB )
-					B = davor->getB() + B;
-				if( änderA )
-					A = davor->getA() + A;
-				davor = davor->release();
-			}
-			return i + 1;
-		}
-	}
-	return -1;
+                    exit( 0 );
+                }
+                änderR = davor->getÄnderR();
+                änderG = davor->getÄnderG();
+                änderB = davor->getÄnderB();
+                änderA = davor->getÄnderA();
+                komp = davor->getKomp();
+                miR -= komp, miG -= komp, miB -= komp, miA -= komp;
+                if( !änderR )
+                    R = davor->getR();
+                if( !änderG )
+                    G = davor->getG();
+                if( !änderB )
+                    B = davor->getB();
+                if( !änderA )
+                    A = davor->getA();
+                maxIndex += ( änderR + änderG + änderB + änderA ) * ( 8 - komp ); // Bestimmung der Länge
+                // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits, durch komprimierung kanns kleiner sein
+            }
+            else
+                maxIndex += 7; // Da der Pixel nicht die Werte des vorherigen übernimmt, wird er um 7 Bits größer
+            break;
+        case 1: // Das zweite Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                änderR = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 2: // Das dritte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                änderG = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 3: // Das vierte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                änderB = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 4: // Das fünfte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                änderA = (bool)( ( byte >> ( 7 - i ) ) & 0x1 );
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 5: // Das sechste Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 ) << 2;
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 6: // Das siebte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 ) << 1;
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 7: // Das achte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 7 Komprimierungsbits
+            {
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & 0x1 );
+                // Das war das letzte Komprimierungsbit
+                // Komprimierung auswerten 
+                miR -= komp, miG -= komp, miB -= komp, miA -= komp;
+                if( !änderR )
+                    R = davor->getR();
+                if( !änderG )
+                    G = davor->getG();
+                if( !änderB )
+                    B = davor->getB();
+                if( !änderA )
+                    A = davor->getA();
+                maxIndex += ( änderR + änderG + änderB + änderA ) * ( 8 - komp ); // Bitlänge des Pixels
+            }
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
+            if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                return i;
+            break;
+        }
+        ++index;
+        if( index >= maxIndex )
+        {
+            if( davor )
+            {
+                if( änderR )
+                    R = davor->getR() + R;
+                if( änderG )
+                    G = davor->getG() + G;
+                if( änderB )
+                    B = davor->getB() + B;
+                if( änderA )
+                    A = davor->getA() + A;
+                davor = davor->release();
+            }
+            return i + 1;
+        }
+    }
+    return -1;
 }
 
 void LTDBPixel::setFarbe( int f ) // setzt die Farbe des Pixels
 {   // Da diese Funktion aufgerufen wird, möchte man die Klasse nun zum speichern verwenden
-	// Werte zurücksetzen, fals mit der Klasse schon geladen oder gespeichert wurde
-	index = 0, maxIndex = 1;
-	änder = 0, änderR = 0, änderG = 0, änderB = 0, änderA = 0, komp = 0;
-	iR = 0, iG = 0, iB = 0, iA = 0;
-	miR = 8, miG = 8, miB = 8, miA = 8;
-	// Farbwerte setzen
-	R = (unsigned char)( f >> 16 );
-	G = (unsigned char)( f >> 8 );
-	B = (unsigned char)f;
-	A = (unsigned char)( f >> 24 );
+    // Werte zurücksetzen, fals mit der Klasse schon geladen oder gespeichert wurde
+    index = 0, maxIndex = 1;
+    änder = 0, änderR = 0, änderG = 0, änderB = 0, änderA = 0, komp = 0;
+    iR = 0, iG = 0, iB = 0, iA = 0;
+    miR = 8, miG = 8, miB = 8, miA = 8;
+    // Farbwerte setzen
+    R = (unsigned char)( f >> 16 );
+    G = (unsigned char)( f >> 8 );
+    B = (unsigned char)f;
+    A = (unsigned char)( f >> 24 );
 }
 
 void LTDBPixel::komprimieren() // Komprimiert den Pixel
 {
-	maxIndex = 1;
-	if( !davor )
-	{// Das ist der erste Pixel
-		änder = 1;
-		änderR = 1;
-		änderG = 1;
-		änderB = 1;
-		änderA = 1;
-		maxIndex += 7;
-		miR = getBits( R );
-		miG = getBits( G );
-		miB = getBits( B );
-		miA = getBits( A );
-	}
-	else
-	{ // Es wird die differenz zum vorrigen Pixel gespeichert
-		miR = getBits( R - davor->getR() );
-		miG = getBits( G - davor->getG() );
-		miB = getBits( B - davor->getB() );
-		miA = getBits( A - davor->getA() );
-		änderR = R != davor->getR();
-		änderG = G != davor->getG();
-		änderB = B != davor->getB();
-		änderA = A != davor->getA();
-	}// Prüfen ob sich etwas ändert
-	if( !miR && änderR )
-		++miR;
-	if( !miG && änderG )
-		++miG;
-	if( !miB && änderB )
-		++miB;
-	if( !miA && änderA )
-		++miA;
-	int k = ( miR > miG ? miR : miG );
-	k = ( k > miB ? k : miB );
-	k = ( k > miA ? k : miA );
-	miR = k, miG = k, miB = k, miA = k;
-	komp = 8 - k;
-	maxIndex += ( änderR + änderG + änderB + änderA ) * ( k );
-	if( davor )
-	{
-		if( änderR != davor->getÄnderR() ||
-			änderG != davor->getÄnderG() ||
-			änderB != davor->getÄnderB() ||
-			änderA != davor->getÄnderA() ||
-			komp != davor->getKomp() )
-		{ // Es ändert sich etwas
-			änder = 1;
-			maxIndex += 7;
-		}
-		else
-		{ // Es ändert sich nichts
-			änder = 0;
-		}
-	}
+    maxIndex = 1;
+    if( !davor )
+    {// Das ist der erste Pixel
+        änder = 1;
+        änderR = 1;
+        änderG = 1;
+        änderB = 1;
+        änderA = 1;
+        maxIndex += 7;
+        miR = getBits( R );
+        miG = getBits( G );
+        miB = getBits( B );
+        miA = getBits( A );
+    }
+    else
+    { // Es wird die differenz zum vorrigen Pixel gespeichert
+        miR = getBits( R - davor->getR() );
+        miG = getBits( G - davor->getG() );
+        miB = getBits( B - davor->getB() );
+        miA = getBits( A - davor->getA() );
+        änderR = R != davor->getR();
+        änderG = G != davor->getG();
+        änderB = B != davor->getB();
+        änderA = A != davor->getA();
+    }// Prüfen ob sich etwas ändert
+    if( !miR && änderR )
+        ++miR;
+    if( !miG && änderG )
+        ++miG;
+    if( !miB && änderB )
+        ++miB;
+    if( !miA && änderA )
+        ++miA;
+    int k = ( miR > miG ? miR : miG );
+    k = ( k > miB ? k : miB );
+    k = ( k > miA ? k : miA );
+    miR = k, miG = k, miB = k, miA = k;
+    komp = 8 - k;
+    maxIndex += ( änderR + änderG + änderB + änderA ) * ( k );
+    if( davor )
+    {
+        if( änderR != davor->getÄnderR() ||
+            änderG != davor->getÄnderG() ||
+            änderB != davor->getÄnderB() ||
+            änderA != davor->getÄnderA() ||
+            komp != davor->getKomp() )
+        { // Es ändert sich etwas
+            änder = 1;
+            maxIndex += 7;
+        }
+        else
+        { // Es ändert sich nichts
+            änder = 0;
+        }
+    }
 }
 
 bool LTDBPixel::getNextFarbeBit( char &byte, int i ) // Speichert das nächste Farbbit in byte
 {
-	unsigned char RR = R;
-	unsigned char GG = G;
-	unsigned char BB = B;
-	unsigned char AA = A;
-	if( davor )
-	{
-		RR -= davor->getR();
-		GG -= davor->getG();
-		BB -= davor->getB();
-		AA -= davor->getA();
-	}
-	if( änderR && iR != miR ) // Das Bit gehört zu Rot
-	{
-		byte |= ( ( RR >> ( 7 - komp - iR ) ) & 0x1 ) << ( 7 - i );
-		++iR;
-	}
-	else if( änderG && iG != miG ) // Das Bit gehört zu Grün
-	{
-		byte |= ( ( GG >> ( 7 - komp - iG ) ) & 0x1 ) << ( 7 - i );
-		++iG;
-	}
-	else if( änderB && iB != miB ) // Das Bit gehört zu Blau
-	{
-		byte |= ( ( BB >> ( 7 - komp - iB ) ) & 0x1 ) << ( 7 - i );
-		++iB;
-	}
-	else if( änderA && iA != miA ) // Das Bit gehört zu Alpha
-	{
-		byte |= ( ( AA >> ( 7 - komp - iA ) ) & 0x1 ) << ( 7 - i );
-		++iA;
-	}
-	else // Der Pixel ist bereits zu ende
-		return false;
-	return true;
+    unsigned char RR = R;
+    unsigned char GG = G;
+    unsigned char BB = B;
+    unsigned char AA = A;
+    if( davor )
+    {
+        RR -= davor->getR();
+        GG -= davor->getG();
+        BB -= davor->getB();
+        AA -= davor->getA();
+    }
+    if( änderR && iR != miR ) // Das Bit gehört zu Rot
+    {
+        byte |= ( ( RR >> ( 7 - komp - iR ) ) & 0x1 ) << ( 7 - i );
+        ++iR;
+    }
+    else if( änderG && iG != miG ) // Das Bit gehört zu Grün
+    {
+        byte |= ( ( GG >> ( 7 - komp - iG ) ) & 0x1 ) << ( 7 - i );
+        ++iG;
+    }
+    else if( änderB && iB != miB ) // Das Bit gehört zu Blau
+    {
+        byte |= ( ( BB >> ( 7 - komp - iB ) ) & 0x1 ) << ( 7 - i );
+        ++iB;
+    }
+    else if( änderA && iA != miA ) // Das Bit gehört zu Alpha
+    {
+        byte |= ( ( AA >> ( 7 - komp - iA ) ) & 0x1 ) << ( 7 - i );
+        ++iA;
+    }
+    else // Der Pixel ist bereits zu ende
+        return false;
+    return true;
 }
 
 char LTDBPixel::getNextByte( char &byte, int begin ) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel nicht zu ende ist
 {
-	// bbegin gibt an wohin in die byte-variable geschrieben werden soll
-	// die Funktion gibt das ende des Pixels in der byte-variable zurück
-	// -1 heißt, dass der Pixel nicht zu ende ist
-	for( int i = begin; i < 8; ++i )
-	{
-		switch( index )
-		{
-		case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der Komprimierung ändert
-			byte |= ( (int)änder & 0x1 ) << ( 7 - i );
-			break;
-		case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( (int)änderR & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 2: // Das dritte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( (int)änderG & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 3: // Das vierte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( (int)änderB & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 4: // Das fünfte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( (int)änderA & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 5: // Das sechste Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( ( komp >> 2 ) & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 6: // Das siebte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( ( komp >> 1 ) & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 7: // Das sechste Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( komp & 0x1 ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		default: // Die restlichen Bits speichern die Farbe des Pixels
-			if( !getNextFarbeBit( byte, i ) )
-				return i;
-			break;
-		}
-		++index;
-		if( index >= maxIndex )
-		{
-			if( davor )
-				davor = davor->release();
-			return i + 1;
-		}
-	}
-	return -1;
+    // bbegin gibt an wohin in die byte-variable geschrieben werden soll
+    // die Funktion gibt das ende des Pixels in der byte-variable zurück
+    // -1 heißt, dass der Pixel nicht zu ende ist
+    for( int i = begin; i < 8; ++i )
+    {
+        switch( index )
+        {
+        case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der Komprimierung ändert
+            byte |= ( (int)änder & 0x1 ) << ( 7 - i );
+            break;
+        case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( (int)änderR & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 2: // Das dritte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( (int)änderG & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 3: // Das vierte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( (int)änderB & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 4: // Das fünfte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( (int)änderA & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 5: // Das sechste Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( ( komp >> 2 ) & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 6: // Das siebte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( ( komp >> 1 ) & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 7: // Das sechste Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( komp & 0x1 ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        default: // Die restlichen Bits speichern die Farbe des Pixels
+            if( !getNextFarbeBit( byte, i ) )
+                return i;
+            break;
+        }
+        ++index;
+        if( index >= maxIndex )
+        {
+            if( davor )
+                davor = davor->release();
+            return i + 1;
+        }
+    }
+    return -1;
 }
 
 // constant 
 int LTDBPixel::zuFarbe() const // gibt den Pixel als Farbe zurück
 {
-	return ( ( (int)R << 16 ) | ( (int)G << 8 ) | (int)B | ( (int)A << 24 ) );
+    return ( ( (int)R << 16 ) | ( (int)G << 8 ) | (int)B | ( (int)A << 24 ) );
 }
 
 bool LTDBPixel::getÄnderR() const
 {
-	return änderR;
+    return änderR;
 }
 
 bool LTDBPixel::getÄnderG() const
 {
-	return änderG;
+    return änderG;
 }
 
 bool LTDBPixel::getÄnderB() const
 {
-	return änderB;
+    return änderB;
 }
 
 bool LTDBPixel::getÄnderA() const
 {
-	return änderA;
+    return änderA;
 }
 
 unsigned char LTDBPixel::getKomp() const
 {
-	return komp;
+    return komp;
 }
 
 unsigned char LTDBPixel::getR() const // gibt Rot zurück 
 {
-	return R;
+    return R;
 }
 
 unsigned char LTDBPixel::getG() const // gibt Grün zurück
 {
-	return G;
+    return G;
 }
 
 unsigned char LTDBPixel::getB() const // gibt Blau zurück
 {
-	return B;
+    return B;
 }
 
 unsigned char LTDBPixel::getA() const // gibt Alpha zurück
 {
-	return A;
+    return A;
 }
 
 // Reference Counting 
 LTDBPixel *LTDBPixel::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDBPixel *LTDBPixel::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDBDateiKopf Klasse aus Dateisystem.h
 // konstructor
 LTDBDateiKopf::LTDBDateiKopf()
-	: bilder( new RCArray< Text >() ),
-	  pos( new Array< __int64 >() ),
-	  bAnzahl( 0 ),
-	  ref( 1 )
-{
-}
+    : bilder( new RCArray< Text >() ),
+    pos( new Array< __int64 >() ),
+    bAnzahl( 0 ),
+    ref( 1 )
+{}
 
 // destructor 
 LTDBDateiKopf::~LTDBDateiKopf()
 {
-	bilder->release();
-	pos->release();
+    bilder->release();
+    pos->release();
 }
 
 // nicht constant 
 void LTDBDateiKopf::removeBild( int i )
 {
-	if( i >= bAnzahl )
-		return;
-	bilder->lösche( i );
-	pos->lösche( i );
-	--bAnzahl;
+    if( i >= bAnzahl )
+        return;
+    bilder->lösche( i );
+    pos->lösche( i );
+    --bAnzahl;
 }
 
 void LTDBDateiKopf::removeBild( Text *txt )
 {
-	int i = -1;
-	for( int ii = 0; ii < bAnzahl; ++ii )
-	{
-		Text *b = bilder->z( ii );
-		if( b->istGleich( txt->getText() ) )
-		{
-			i = ii;
-			break;
-		}
-	}
-	txt->release();
-	if( i == -1 )
-		return;
-	bilder->lösche( i );
-	pos->lösche( i );
-	--bAnzahl;
+    int i = -1;
+    for( int ii = 0; ii < bAnzahl; ++ii )
+    {
+        Text *b = bilder->z( ii );
+        if( b->istGleich( txt->getText() ) )
+        {
+            i = ii;
+            break;
+        }
+    }
+    txt->release();
+    if( i == -1 )
+        return;
+    bilder->lösche( i );
+    pos->lösche( i );
+    --bAnzahl;
 }
 
 void LTDBDateiKopf::addBild( Text *txt )
 {
-	bilder->add( txt, bAnzahl );
-	pos->add( 0, bAnzahl );
-	++bAnzahl;
+    bilder->add( txt, bAnzahl );
+    pos->add( 0, bAnzahl );
+    ++bAnzahl;
 }
 
 void LTDBDateiKopf::setBildPos( int i, __int64 pos )
 {
-	this->pos->set( pos, i );
+    this->pos->set( pos, i );
 }
 
 void LTDBDateiKopf::setBildPos( Text *txt, __int64 pos )
 {
-	int i = -1;
-	for( int ii = 0; ii < bAnzahl; ++ii )
-	{
-		Text *b = bilder->z( ii );
-		if( b->istGleich( txt->getText() ) )
-		{
-			i = ii;
-			break;
-		}
-	}
-	txt->release();
-	if( i == -1 )
-		return;
-	this->pos->set( pos, i );
+    int i = -1;
+    for( int ii = 0; ii < bAnzahl; ++ii )
+    {
+        Text *b = bilder->z( ii );
+        if( b->istGleich( txt->getText() ) )
+        {
+            i = ii;
+            break;
+        }
+    }
+    txt->release();
+    if( i == -1 )
+        return;
+    this->pos->set( pos, i );
 }
 
 void LTDBDateiKopf::laden( FBalken *f, std::ifstream *inF )
 {
-	if( inF->is_open() && inF->good() )
-	{
-		char b = 0;
-		inF->read( &b, 1 );
-		bAnzahl = b << 8;
-		inF->read( &b, 1 );
-		bAnzahl |= b & 0xFF;
+    if( inF->is_open() && inF->good() )
+    {
+        char b = 0;
+        inF->read( &b, 1 );
+        bAnzahl = b << 8;
+        inF->read( &b, 1 );
+        bAnzahl |= b & 0xFF;
 #ifdef WIN32
-		if( f )
-		{
-			f->reset();
-			f->setAktionAnzahl( bAnzahl );
-		}
+        if( f )
+        {
+            f->reset();
+            f->setAktionAnzahl( bAnzahl );
+        }
 #endif
-		bilder->leeren();
-		pos->leeren();
-		for( int i = 0; i < bAnzahl; ++i )
-		{
-			LTDBKopf *kpf = new LTDBKopf();
-			kpf->laden( inF ); // bildname und halbe datei position
-			bilder->set( kpf->getTitel(), i ); // setzt titel
-			Punkt gr = kpf->getGröße();
-			kpf->release();
-			char p[ 5 ];
-			inF->read( (char *)p, 5 ); // andere hälfte der Dateiposition
-			unsigned __int64 position = ( ( (__int64)gr.x << 52 ) & 0xFFF0000000000000 ) |
-										( ( (__int64)gr.y << 40 ) & 0xFFF0000000000 ) |
-										( ( (__int64)p[ 0 ] << 32 ) & 0xFF00000000 ) |
-										( ( (__int64)p[ 1 ] << 24 ) & 0xFF000000 ) |
-										( ( (__int64)p[ 2 ] << 16 ) & 0xFF0000 ) |
-										( ( (__int64)p[ 3 ] << 8 ) & 0xFF00 ) |
-										( (__int64)p[ 4 ] & 0xFF );
-			pos->set( position, i ); // setzt position
+        bilder->leeren();
+        pos->leeren();
+        for( int i = 0; i < bAnzahl; ++i )
+        {
+            LTDBKopf *kpf = new LTDBKopf();
+            kpf->laden( inF ); // bildname und halbe datei position
+            bilder->set( kpf->getTitel(), i ); // setzt titel
+            Punkt gr = kpf->getGröße();
+            kpf->release();
+            char p[ 5 ];
+            inF->read( (char *)p, 5 ); // andere hälfte der Dateiposition
+            unsigned __int64 position = ( ( (__int64)gr.x << 52 ) & 0xFFF0000000000000 ) |
+                ( ( (__int64)gr.y << 40 ) & 0xFFF0000000000 ) |
+                ( ( (__int64)p[ 0 ] << 32 ) & 0xFF00000000 ) |
+                ( ( (__int64)p[ 1 ] << 24 ) & 0xFF000000 ) |
+                ( ( (__int64)p[ 2 ] << 16 ) & 0xFF0000 ) |
+                ( ( (__int64)p[ 3 ] << 8 ) & 0xFF00 ) |
+                ( (__int64)p[ 4 ] & 0xFF );
+            pos->set( position, i ); // setzt position
 #ifdef WIN32
-			if( f )
-				f->aktionPlus();
+            if( f )
+                f->aktionPlus();
 #endif
-		}
-	}
+        }
+    }
 }
 
 // constant
 void LTDBDateiKopf::speichern( std::ofstream *outF ) const
 {
-	if( outF->is_open() && outF->good() )
-	{
-		char b = bAnzahl >> 8;
-		outF->write( &b, 1 );
-		b = (char)bAnzahl;
-		outF->write( &b, 1 );
-		for( int i = 0; i < bAnzahl; ++i )
-		{
-			LTDBKopf *kpf = new LTDBKopf();
-			__int64 position = pos->get( i );
-			kpf->Init( bilder->get( i ), Punkt( position >> 52, position >> 40 ) );
-			kpf->speichern( outF );
-			kpf->release();
-			char p[] = { (char)( position >> 32 ), (char)( position >> 24 ), (char)( position >> 16 ), (char)( position >> 8 ), (char)( position ) };
-			outF->write( (char *)p, 5 );
-		}
-	}
+    if( outF->is_open() && outF->good() )
+    {
+        char b = bAnzahl >> 8;
+        outF->write( &b, 1 );
+        b = (char)bAnzahl;
+        outF->write( &b, 1 );
+        for( int i = 0; i < bAnzahl; ++i )
+        {
+            LTDBKopf *kpf = new LTDBKopf();
+            __int64 position = pos->get( i );
+            kpf->Init( bilder->get( i ), Punkt( position >> 52, position >> 40 ) );
+            kpf->speichern( outF );
+            kpf->release();
+            char p[] = { (char)( position >> 32 ), (char)( position >> 24 ), (char)( position >> 16 ), (char)( position >> 8 ), (char)( position ) };
+            outF->write( (char *)p, 5 );
+        }
+    }
 }
 
 Text *LTDBDateiKopf::getBild( int i ) const
 {
-	return bilder->get( i );
+    return bilder->get( i );
 }
 
 Text *LTDBDateiKopf::zBild( int i ) const
 {
-	return bilder->z( i );
+    return bilder->z( i );
 }
 
 __int64 LTDBDateiKopf::getBildPosition( Text *txt ) const
 {
-	int i = -1;
-	for( int ii = 0; ii < bAnzahl; ++ii )
-	{
-		Text *b = bilder->z( ii );
-		if( b->istGleich( txt->getText() ) )
-		{
-			i = ii;
-			break;
-		}
-	}
-	txt->release();
-	if( i == -1 )
-		return -1;
-	return pos->get( i );
+    int i = -1;
+    for( int ii = 0; ii < bAnzahl; ++ii )
+    {
+        Text *b = bilder->z( ii );
+        if( b->istGleich( txt->getText() ) )
+        {
+            i = ii;
+            break;
+        }
+    }
+    txt->release();
+    if( i == -1 )
+        return -1;
+    return pos->get( i );
 }
 
 __int64 LTDBDateiKopf::getBildPosition( int index ) const
 {
-	return pos->get( index );
+    return pos->get( index );
 }
 
 int LTDBDateiKopf::getBildIndex( Text *txt ) const
 {
-	int i = -1;
-	for( int ii = 0; ii < bAnzahl; ++ii )
-	{
-		Text *b = bilder->z( ii );
-		if( b->istGleich( txt->getText() ) )
-		{
-			i = ii;
-			break;
-		}
-	}
-	txt->release();
-	return i;
+    int i = -1;
+    for( int ii = 0; ii < bAnzahl; ++ii )
+    {
+        Text *b = bilder->z( ii );
+        if( b->istGleich( txt->getText() ) )
+        {
+            i = ii;
+            break;
+        }
+    }
+    txt->release();
+    return i;
 }
 
 int LTDBDateiKopf::getbAnzahl() const
 {
-	return bAnzahl;
+    return bAnzahl;
 }
 
 RCArray< Text > *LTDBDateiKopf::zBildListe() const
 {
-	return bilder;
+    return bilder;
 }
 
 // Reference Counting 
 LTDBDateiKopf *LTDBDateiKopf::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDBDateiKopf *LTDBDateiKopf::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDBKopf Klasse aus DateiSystem.h
 // Konstruktor 
 LTDBKopf::LTDBKopf()
-	: ref( 1 )
-{
-}
+    : ref( 1 )
+{}
 
 // nicht constant 
 void LTDBKopf::laden( std::ifstream *f ) // Lät die Daten aus einer Datei
 {
-	if( f->is_open() )
-	{
-		a = 0;
-		b = 0;
-		c = 0;
-		char aa = 0;
-		f->read( &aa, 1 );
-		int tl = ( aa >> 4 ) & Bits( 4 );
-		int BitAnzahl = 4 + tl * 5 + 24;
-		f->seekg( -1, std::ios::cur );
-		int Bytes = BitAnzahl / 8;
-		if( ( (float)BitAnzahl / 8.0f ) != Bytes )
-			++Bytes;
-		char byte = 0;
-		for( int i = 0; i < Bytes; ++i )
-		{
-			f->read( &byte, 1 );
-			setBits( i * 8, i * 8 + 8, byte );
-		}
-	}
+    if( f->is_open() )
+    {
+        a = 0;
+        b = 0;
+        c = 0;
+        char aa = 0;
+        f->read( &aa, 1 );
+        int tl = ( aa >> 4 ) & Bits( 4 );
+        int BitAnzahl = 4 + tl * 5 + 24;
+        f->seekg( -1, std::ios::cur );
+        int Bytes = BitAnzahl / 8;
+        if( ( (float)BitAnzahl / 8.0f ) != Bytes )
+            ++Bytes;
+        char byte = 0;
+        for( int i = 0; i < Bytes; ++i )
+        {
+            f->read( &byte, 1 );
+            setBits( i * 8, i * 8 + 8, byte );
+        }
+    }
 }
 
 int LTDBKopf::Init( Text *t, const Punkt &g ) // Befüllt die Daten
 {
-	a = 0;
-	b = 0;
-	c = 0;
-	int tl = t->getLänge();
-	if( tl > 15 )
-		tl = 15;
-	char *titel = new char[ tl ];
-	int übersp = 0;
-	for( int i = 0; i < tl; ++i )
-	{
-		titel[ i - übersp ] = t->getText()[ i ];
-		if( titel[ i - übersp ] > 96 && titel[ i - übersp ] < 123 )
-			titel[ i - übersp ] -= 96;
-		else if( titel[ i - übersp ] > 64 && titel[ i - übersp ] < 91 )
-			titel[ i - übersp ] -= 64;
-		else if( titel[ i - übersp ] == 'ü' || titel[ i - übersp ] == 'Ü' )
-			titel[ i - übersp ] = 27;
-		else if( titel[ i - übersp ] == 'ö' || titel[ i - übersp ] == 'Ö' )
-			titel[ i - übersp ] = 28;
-		else if( titel[ i - übersp ] == 'ä' || titel[ i - übersp ] == 'Ä' )
-			titel[ i - übersp ] = 29;
-		else if( titel[ i - übersp ] == 'ß' )
-			titel[ i - übersp ] = 30;
-		else if( titel[ i - übersp ] == '.' )
-			titel[ i - übersp ] = 31;
-		else
-			++übersp;
-	}
-	a = (__int64)( ( tl - übersp ) & Bits( 4 ) ) << 60;
-	int BeginBit = 4;
-	for( int i = 0; i < tl - übersp; ++i )
-	{
-		BeginBit += 5;
-		switch( i )
-		{
-		case 0:
-			a |= (__int64)( titel[ i ] & 31 ) << 55; // ersten Buchstaben speichern
-			break;
-		case 1:
-			a |= (__int64)( titel[ i ] & 31 ) << 50; // zweiten Buchstaben speichern
-			break;
-		case 2:
-			a |= (__int64)( titel[ i ] & 31 ) << 45; // dritten Buchstaben speichern
-			break;
-		case 3:
-			a |= (__int64)( titel[ i ] & 31 ) << 40; // vierten Buchstaben speichern
-			break;
-		case 4:
-			a |= (__int64)( titel[ i ] & 31 ) << 35; // fünften Buchstaben speichern
-			break;
-		case 5:
-			a |= (__int64)( titel[ i ] & 31 ) << 30; // sechsten Buchstaben speichern
-			break;
-		case 6:
-			a |= (__int64)( titel[ i ] & 31 ) << 25; // siebten Buchstaben speichern
-			break;
-		case 7:
-			a |= (__int64)( titel[ i ] & 31 ) << 20; // achten Buchstaben speichern
-			break;
-		case 8:
-			a |= (__int64)( titel[ i ] & 31 ) << 15; // neunten Buchstaben speichern
-			break;
-		case 9:
-			a |= (__int64)( titel[ i ] & 31 ) << 10; // zenten Buchstaben speichern
-			break;
-		case 10:
-			a |= (__int64)( titel[ i ] & 31 ) << 5; // elften Buchstaben speichern
-			break;
-		case 11:
-			a |= (__int64)( titel[ i ] & 31 ); // zwölften Buchstaben speichern
-			break;
-		case 12:
-			b |= (__int32)( titel[ i ] & 31 ) << 27; // dreizenten Buchstaben speichern
-			break;
-		case 13:
-			b |= (__int32)( titel[ i ] & 31 ) << 22; // vierzenten Buchstaben speichern
-			break;
-		case 14:
-			b |= (__int32)( titel[ i ] & 31 ) << 17; // fünfzenten Buchstaben speichern
-			break;
-		}
-	}
-	__int16 grx = g.x & Bits( 12 );
-	__int16 gry = g.y & Bits( 12 );
-	int EndBit = BeginBit + 24;
-	setBits( BeginBit, EndBit - 12, grx );
-	setBits( BeginBit + 12, EndBit, gry );
-	t->release();
-	delete[]titel;
-	return übersp;
+    a = 0;
+    b = 0;
+    c = 0;
+    int tl = t->getLänge();
+    if( tl > 15 )
+        tl = 15;
+    char *titel = new char[ tl ];
+    int übersp = 0;
+    for( int i = 0; i < tl; ++i )
+    {
+        titel[ i - übersp ] = t->getText()[ i ];
+        if( titel[ i - übersp ] > 96 && titel[ i - übersp ] < 123 )
+            titel[ i - übersp ] -= 96;
+        else if( titel[ i - übersp ] > 64 && titel[ i - übersp ] < 91 )
+            titel[ i - übersp ] -= 64;
+        else if( titel[ i - übersp ] == 'ü' || titel[ i - übersp ] == 'Ü' )
+            titel[ i - übersp ] = 27;
+        else if( titel[ i - übersp ] == 'ö' || titel[ i - übersp ] == 'Ö' )
+            titel[ i - übersp ] = 28;
+        else if( titel[ i - übersp ] == 'ä' || titel[ i - übersp ] == 'Ä' )
+            titel[ i - übersp ] = 29;
+        else if( titel[ i - übersp ] == 'ß' )
+            titel[ i - übersp ] = 30;
+        else if( titel[ i - übersp ] == '.' )
+            titel[ i - übersp ] = 31;
+        else
+            ++übersp;
+    }
+    a = (__int64)( ( tl - übersp ) & Bits( 4 ) ) << 60;
+    int BeginBit = 4;
+    for( int i = 0; i < tl - übersp; ++i )
+    {
+        BeginBit += 5;
+        switch( i )
+        {
+        case 0:
+            a |= (__int64)( titel[ i ] & 31 ) << 55; // ersten Buchstaben speichern
+            break;
+        case 1:
+            a |= (__int64)( titel[ i ] & 31 ) << 50; // zweiten Buchstaben speichern
+            break;
+        case 2:
+            a |= (__int64)( titel[ i ] & 31 ) << 45; // dritten Buchstaben speichern
+            break;
+        case 3:
+            a |= (__int64)( titel[ i ] & 31 ) << 40; // vierten Buchstaben speichern
+            break;
+        case 4:
+            a |= (__int64)( titel[ i ] & 31 ) << 35; // fünften Buchstaben speichern
+            break;
+        case 5:
+            a |= (__int64)( titel[ i ] & 31 ) << 30; // sechsten Buchstaben speichern
+            break;
+        case 6:
+            a |= (__int64)( titel[ i ] & 31 ) << 25; // siebten Buchstaben speichern
+            break;
+        case 7:
+            a |= (__int64)( titel[ i ] & 31 ) << 20; // achten Buchstaben speichern
+            break;
+        case 8:
+            a |= (__int64)( titel[ i ] & 31 ) << 15; // neunten Buchstaben speichern
+            break;
+        case 9:
+            a |= (__int64)( titel[ i ] & 31 ) << 10; // zenten Buchstaben speichern
+            break;
+        case 10:
+            a |= (__int64)( titel[ i ] & 31 ) << 5; // elften Buchstaben speichern
+            break;
+        case 11:
+            a |= (__int64)( titel[ i ] & 31 ); // zwölften Buchstaben speichern
+            break;
+        case 12:
+            b |= (__int32)( titel[ i ] & 31 ) << 27; // dreizenten Buchstaben speichern
+            break;
+        case 13:
+            b |= (__int32)( titel[ i ] & 31 ) << 22; // vierzenten Buchstaben speichern
+            break;
+        case 14:
+            b |= (__int32)( titel[ i ] & 31 ) << 17; // fünfzenten Buchstaben speichern
+            break;
+        }
+    }
+    __int16 grx = g.x & Bits( 12 );
+    __int16 gry = g.y & Bits( 12 );
+    int EndBit = BeginBit + 24;
+    setBits( BeginBit, EndBit - 12, grx );
+    setBits( BeginBit + 12, EndBit, gry );
+    t->release();
+    delete[]titel;
+    return übersp;
 }
 
 void LTDBKopf::setBits( int BeginBit, int EndBit, __int16 bits )
 {
-	if( EndBit - BeginBit > 16 )
-		EndBit = BeginBit + 16;
-	if( BeginBit < 64 )
-	{
-		if( EndBit < 64 )
-		{
-			a |= ( (__int64)bits & Bits( EndBit - BeginBit ) ) << ( ( 64 - BeginBit ) - ( EndBit - BeginBit ) );
-		}
-		else
-		{
-			a |= ( ( (__int64)bits >> ( EndBit - 64 ) ) & Bits( 64 - BeginBit ) );
-			b |= ( (__int32)bits & Bits( EndBit - 64 ) ) << ( 32 - ( EndBit - 64 ) );
-		}
-	}
-	else
-	{
-		if( BeginBit < 96 )
-		{
-			if( EndBit < 96 )
-			{
-				b |= ( (__int32)bits & Bits( EndBit - BeginBit ) ) << ( ( 96 - BeginBit ) - ( EndBit - BeginBit ) );
-			}
-			else
-			{
-				b |= ( ( (__int32)bits >> ( EndBit - 96 ) ) & Bits( 96 - BeginBit ) );
-				c |= ( ( (__int8)bits & Bits( EndBit - 96 ) ) << ( 8 - ( EndBit - 96 ) ) );
-			}
-		}
-		else
-		{
-			c |= ( ( (__int8)bits & Bits( EndBit - BeginBit ) ) << ( 8 - ( EndBit - BeginBit ) ) );
-		}
-	}
+    if( EndBit - BeginBit > 16 )
+        EndBit = BeginBit + 16;
+    if( BeginBit < 64 )
+    {
+        if( EndBit < 64 )
+        {
+            a |= ( (__int64)bits & Bits( EndBit - BeginBit ) ) << ( ( 64 - BeginBit ) - ( EndBit - BeginBit ) );
+        }
+        else
+        {
+            a |= ( ( (__int64)bits >> ( EndBit - 64 ) ) & Bits( 64 - BeginBit ) );
+            b |= ( (__int32)bits & Bits( EndBit - 64 ) ) << ( 32 - ( EndBit - 64 ) );
+        }
+    }
+    else
+    {
+        if( BeginBit < 96 )
+        {
+            if( EndBit < 96 )
+            {
+                b |= ( (__int32)bits & Bits( EndBit - BeginBit ) ) << ( ( 96 - BeginBit ) - ( EndBit - BeginBit ) );
+            }
+            else
+            {
+                b |= ( ( (__int32)bits >> ( EndBit - 96 ) ) & Bits( 96 - BeginBit ) );
+                c |= ( ( (__int8)bits & Bits( EndBit - 96 ) ) << ( 8 - ( EndBit - 96 ) ) );
+            }
+        }
+        else
+        {
+            c |= ( ( (__int8)bits & Bits( EndBit - BeginBit ) ) << ( 8 - ( EndBit - BeginBit ) ) );
+        }
+    }
 }
 
 // constant 
 void LTDBKopf::speichern( std::ofstream *f ) const // Speichert die Daten in eine Datei
 {
-	if( f->is_open() )
-	{
-		int bits = 4/*Titellänge*/ + getTitelLänge() * 5/*Titel*/ + 24/*Bildgröße*/;
-		int bytes = bits / 8; // Bytelänge des Dateikopfes
-		if( ( (float)bits / 8.0f ) != bytes )
-			++bytes;
-		char c = 0;
-		for( int i = 0; i < bytes; ++i )
-		{
-			c = (char)getBits( i * 8, i * 8 + 8 );
-			f->write( &c, 1 );
-		}
-	}
+    if( f->is_open() )
+    {
+        int bits = 4/*Titellänge*/ + getTitelLänge() * 5/*Titel*/ + 24/*Bildgröße*/;
+        int bytes = bits / 8; // Bytelänge des Dateikopfes
+        if( ( (float)bits / 8.0f ) != bytes )
+            ++bytes;
+        char c = 0;
+        for( int i = 0; i < bytes; ++i )
+        {
+            c = (char)getBits( i * 8, i * 8 + 8 );
+            f->write( &c, 1 );
+        }
+    }
 }
 
 int LTDBKopf::getTitelLänge() const // gibt die länge des Bildnamens zurück
 {
-	return a >> 60 & Bits( 4 ); // Die Länge des Titels wird in den ersten 4 Bits der Tatei gespeichert
+    return a >> 60 & Bits( 4 ); // Die Länge des Titels wird in den ersten 4 Bits der Tatei gespeichert
 }
 
 Text *LTDBKopf::getTitel() const // gibt den Namen des Bildes zurück
 {
-	Text *ret = new Text( "" );
-	char c[ 2 ];
-	c[ 1 ] = '\0';
-	int l = getTitelLänge();
-	for( int i = 0; i < l; ++i )
-	{
-		c[ 0 ] = 0;
-		switch( i )
-		{
-		case 0:
-			c[ 0 ] = ( a >> 55 ) & 31; // ersten Buchstaben holen
-			break;
-		case 1:
-			c[ 0 ] = ( a >> 50 ) & 31; // zweiten Buchstaben holen
-			break;
-		case 2:
-			c[ 0 ] = ( a >> 45 ) & 31; // dritten Buchstaben holen
-			break;
-		case 3:
-			c[ 0 ] = ( a >> 40 ) & 31; // vierten Buchstaben holen
-			break;
-		case 4:
-			c[ 0 ] = ( a >> 35 ) & 31; // fünften Buchstaben holen
-			break;
-		case 5:
-			c[ 0 ] = ( a >> 30 ) & 31; // sechsten Buchstaben holen
-			break;
-		case 6:
-			c[ 0 ] = ( a >> 25 ) & 31; // siebten Buchstaben holen
-			break;
-		case 7:
-			c[ 0 ] = ( a >> 20 ) & 31; // achten Buchstaben holen
-			break;
-		case 8:
-			c[ 0 ] = ( a >> 15 ) & 31; // neunten Buchstaben holen
-			break;
-		case 9:
-			c[ 0 ] = ( a >> 10 ) & 31; // zenten Buchstaben holen
-			break;
-		case 10:
-			c[ 0 ] = ( a >> 5 ) & 31; // elften Buchstaben holen
-			break;
-		case 11:
-			c[ 0 ] = a & 31; // zwölften Buchstaben holen
-			break;
-		case 12:
-			c[ 0 ] = ( b >> 27 ) & 31; // dreizenten Buchstaben holen
-			break;
-		case 13:
-			c[ 0 ] = ( b >> 22 ) & 31; // vierzenten Buchstaben holen
-			break;
-		case 14:
-			c[ 0 ] = ( b >> 17 ) & 31; // fünfzenten Buchstaben holen
-			break;
-		}
-		if( c[ 0 ] == 27 )
-			c[ 0 ] = 'ü';
-		else if( c[ 0 ] == 28 )
-			c[ 0 ] = 'ö';
-		else if( c[ 0 ] == 29 )
-			c[ 0 ] = 'ä';
-		else if( c[ 0 ] == 30 )
-			c[ 0 ] = 'ß';
-		else if( c[ 0 ] == 31 )
-			c[ 0 ] = '.';
-		else
-			c[ 0 ] += 96;
-		ret->anhängen( c );
-	}
-	return ret;
+    Text *ret = new Text( "" );
+    char c[ 2 ];
+    c[ 1 ] = '\0';
+    int l = getTitelLänge();
+    for( int i = 0; i < l; ++i )
+    {
+        c[ 0 ] = 0;
+        switch( i )
+        {
+        case 0:
+            c[ 0 ] = ( a >> 55 ) & 31; // ersten Buchstaben holen
+            break;
+        case 1:
+            c[ 0 ] = ( a >> 50 ) & 31; // zweiten Buchstaben holen
+            break;
+        case 2:
+            c[ 0 ] = ( a >> 45 ) & 31; // dritten Buchstaben holen
+            break;
+        case 3:
+            c[ 0 ] = ( a >> 40 ) & 31; // vierten Buchstaben holen
+            break;
+        case 4:
+            c[ 0 ] = ( a >> 35 ) & 31; // fünften Buchstaben holen
+            break;
+        case 5:
+            c[ 0 ] = ( a >> 30 ) & 31; // sechsten Buchstaben holen
+            break;
+        case 6:
+            c[ 0 ] = ( a >> 25 ) & 31; // siebten Buchstaben holen
+            break;
+        case 7:
+            c[ 0 ] = ( a >> 20 ) & 31; // achten Buchstaben holen
+            break;
+        case 8:
+            c[ 0 ] = ( a >> 15 ) & 31; // neunten Buchstaben holen
+            break;
+        case 9:
+            c[ 0 ] = ( a >> 10 ) & 31; // zenten Buchstaben holen
+            break;
+        case 10:
+            c[ 0 ] = ( a >> 5 ) & 31; // elften Buchstaben holen
+            break;
+        case 11:
+            c[ 0 ] = a & 31; // zwölften Buchstaben holen
+            break;
+        case 12:
+            c[ 0 ] = ( b >> 27 ) & 31; // dreizenten Buchstaben holen
+            break;
+        case 13:
+            c[ 0 ] = ( b >> 22 ) & 31; // vierzenten Buchstaben holen
+            break;
+        case 14:
+            c[ 0 ] = ( b >> 17 ) & 31; // fünfzenten Buchstaben holen
+            break;
+        }
+        if( c[ 0 ] == 27 )
+            c[ 0 ] = 'ü';
+        else if( c[ 0 ] == 28 )
+            c[ 0 ] = 'ö';
+        else if( c[ 0 ] == 29 )
+            c[ 0 ] = 'ä';
+        else if( c[ 0 ] == 30 )
+            c[ 0 ] = 'ß';
+        else if( c[ 0 ] == 31 )
+            c[ 0 ] = '.';
+        else
+            c[ 0 ] += 96;
+        ret->anhängen( c );
+    }
+    return ret;
 }
 
 Punkt LTDBKopf::getGröße() const // gibt die Größe des Bildes zurück
 {
-	int BeginBit = 4/*Titellänge*/ + getTitelLänge() * 5/*Titel*/;
-	int EndBit = BeginBit + 24;
-	__int16 grx = getBits( BeginBit, EndBit - 12 );
-	__int16 gry = getBits( BeginBit + 12, EndBit );
-	return Punkt( (int)( grx & Bits( 12 ) ), (int)( gry & Bits( 12 ) ) );
+    int BeginBit = 4/*Titellänge*/ + getTitelLänge() * 5/*Titel*/;
+    int EndBit = BeginBit + 24;
+    __int16 grx = getBits( BeginBit, EndBit - 12 );
+    __int16 gry = getBits( BeginBit + 12, EndBit );
+    return Punkt( (int)( grx & Bits( 12 ) ), (int)( gry & Bits( 12 ) ) );
 }
 
 __int16 LTDBKopf::getBits( int begin, int ende )const // gibt die Bits von begin bis ende zurück( ohne ende );
 {
-	if( ende < begin )
-		return 0;
-	if( ende - begin > 16 )
-		ende = begin + 16;
-	__int16 ret = 0;
-	if( begin < 64 )
-	{
-		if( ende < 64 )
-		{
-			ret = (__int16)( a >> ( ( 64 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
-		}
-		else
-		{
-			ret = (__int16)( ( a & Bits( 64 - begin ) ) << ( ende - 64 ) );
-			ret |= (__int16)( ( b >> ( 32 - ( ende - 64 ) ) ) & Bits( ende - 64 ) );
-		}
-	}
-	else
-	{
-		if( begin < 96 )
-		{
-			if( ende < 96 )
-			{
-				ret = (__int16)( b >> ( ( 96 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
-			}
-			else
-			{
-				ret = (__int16)( ( b & Bits( 96 - begin ) ) << ( ende - 96 ) );
-				ret |= (__int16)( ( c >> ( 8 - ( ende - 96 ) ) ) & Bits( ende - 96 ) );
-			}
-		}
-		else
-		{
-			ret = (__int16)( c >> ( ( 104 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
-		}
-	}
-	return ret;
+    if( ende < begin )
+        return 0;
+    if( ende - begin > 16 )
+        ende = begin + 16;
+    __int16 ret = 0;
+    if( begin < 64 )
+    {
+        if( ende < 64 )
+        {
+            ret = (__int16)( a >> ( ( 64 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
+        }
+        else
+        {
+            ret = (__int16)( ( a & Bits( 64 - begin ) ) << ( ende - 64 ) );
+            ret |= (__int16)( ( b >> ( 32 - ( ende - 64 ) ) ) & Bits( ende - 64 ) );
+        }
+    }
+    else
+    {
+        if( begin < 96 )
+        {
+            if( ende < 96 )
+            {
+                ret = (__int16)( b >> ( ( 96 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
+            }
+            else
+            {
+                ret = (__int16)( ( b & Bits( 96 - begin ) ) << ( ende - 96 ) );
+                ret |= (__int16)( ( c >> ( 8 - ( ende - 96 ) ) ) & Bits( ende - 96 ) );
+            }
+        }
+        else
+        {
+            ret = (__int16)( c >> ( ( 104 - begin ) - ( ende - begin ) ) & Bits( ende - begin ) );
+        }
+    }
+    return ret;
 }
 
 // Reference Counting 
 LTDBKopf *LTDBKopf::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDBKopf *LTDBKopf::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDBKörper Klasse aus Dateisystem.h
 // Konstruktor 
 LTDBKörper::LTDBKörper()
-	: gr( 0, 0 ),
-	  b( new Bild() ),
-	  ref( 1 )
-{
-}
+    : gr( 0, 0 ),
+    b( new Bild() ),
+    ref( 1 )
+{}
 
 LTDBKörper::LTDBKörper( LTDBKopf *k ) // ruft Init auf
-	: gr( 0, 0 ),
-	  b( new Bild() ),
-	  ref( 1 )
+    : gr( 0, 0 ),
+    b( new Bild() ),
+    ref( 1 )
 {
-	init( k );
+    init( k );
 }
 
 // Destruktor 
 LTDBKörper::~LTDBKörper()
 {
-	b->release();
+    b->release();
 }
 
 // nicht constant
 void LTDBKörper::init( LTDBKopf k ) // Initialisiert, wird vor dem laden benötigt 
 {
-	gr = k.getGröße();
-	int l = k.getTitelLänge();
-	l = 4 + l * 5 + 24;
-	dateiLänge = ( l / 8.0 == l ) ? ( l / 8 ) : ( l / 8 + 1 );
+    gr = k.getGröße();
+    int l = k.getTitelLänge();
+    l = 4 + l * 5 + 24;
+    dateiLänge = ( l / 8.0 == l ) ? ( l / 8 ) : ( l / 8 + 1 );
 }
 
 void LTDBKörper::init( LTDBKopf *k ) // Initialisiert, wird vor dem laden benötigt
 {
-	gr = k->getGröße();
-	int l = k->getTitelLänge();
-	l = 4 + l * 5 + 24;
-	dateiLänge = ( l / 8.0 == l ) ? ( l / 8 ) : ( l / 8 + 1 );
-	k->release();
+    gr = k->getGröße();
+    int l = k->getTitelLänge();
+    l = 4 + l * 5 + 24;
+    dateiLänge = ( l / 8.0 == l ) ? ( l / 8 ) : ( l / 8 + 1 );
+    k->release();
 }
 
 void LTDBKörper::laden( FBalken *zF, std::ifstream *inF ) // läd das Bild
 {
-	b->neuBild( gr.x, gr.y, 0xFF000000 ); // neues Bild erstellen
-	int *buff = b->getBuffer();
-	int breite = b->getBreite();
-	char byte = 0;
-	int index = 0;
-	LTDBPixel *davor = 0; // zuletzt geladener Pixel
-	LTDBPixel *dieser = new LTDBPixel( 0 ); // momentan zu ladener Pixel
-	int begin = 0; // Pixelbegin, endposition in der byte variable
+    b->neuBild( gr.x, gr.y, 0xFF000000 ); // neues Bild erstellen
+    int *buff = b->getBuffer();
+    int breite = b->getBreite();
+    char byte = 0;
+    int index = 0;
+    LTDBPixel *davor = 0; // zuletzt geladener Pixel
+    LTDBPixel *dieser = new LTDBPixel( 0 ); // momentan zu ladener Pixel
+    int begin = 0; // Pixelbegin, endposition in der byte variable
 #ifdef WIN32
-	if( zF )
-	{
-		zF->reset();
-		zF->setAktionAnzahl( gr.x * gr.y );
-	}
+    if( zF )
+    {
+        zF->reset();
+        zF->setAktionAnzahl( gr.x * gr.y );
+    }
 #endif
-	while( index < gr.x * gr.y ) // für jeden Pixel
-	{
-		if( !dieser ) // wenn es nicht der erste Pixel ist
-			dieser = new LTDBPixel( davor->getThis() );
-		int ende = -1;
-		while( ende < 0 ) // Pixel laden
-		{
-			if( begin == 0 )
-				inF->read( &byte, 1 );
-			ende = dieser->addByte( byte, begin ); // byte auswerten
-			begin = 0;
-		}
-		begin = ende;
-		if( begin == 8 )
-			begin = 0;
-		buff[ ( index % gr.x ) + ( index / gr.x ) * breite ] = dieser->zuFarbe();
-		if( davor )
-			davor = davor->release();
-		davor = dieser->getThis();
-		dieser = dieser->release();
-		++index;
+    while( index < gr.x * gr.y ) // für jeden Pixel
+    {
+        if( !dieser ) // wenn es nicht der erste Pixel ist
+            dieser = new LTDBPixel( davor->getThis() );
+        int ende = -1;
+        while( ende < 0 ) // Pixel laden
+        {
+            if( begin == 0 )
+                inF->read( &byte, 1 );
+            ende = dieser->addByte( byte, begin ); // byte auswerten
+            begin = 0;
+        }
+        begin = ende;
+        if( begin == 8 )
+            begin = 0;
+        buff[ ( index % gr.x ) + ( index / gr.x ) * breite ] = dieser->zuFarbe();
+        if( davor )
+            davor = davor->release();
+        davor = dieser->getThis();
+        dieser = dieser->release();
+        ++index;
 #ifdef WIN32
-		if( zF )
-			zF->aktionPlus();
+        if( zF )
+            zF->aktionPlus();
 #endif
-	}
-	if( davor )
-		davor = davor->release();
+    }
+    if( davor )
+        davor = davor->release();
 }
 
 void LTDBKörper::setBild( Bild *b ) // setzt das zu speichernde Bild
 {
-	this->b->release();
-	this->b = b;
+    this->b->release();
+    this->b = b;
 }
 
 // constant 
 void LTDBKörper::speichern( FBalken *zF, std::ofstream *outF ) const // speichert Bild
 {
-	if( outF->is_open() )
-	{
-		LTDBPixel *letzter = 0; // Letzter gespeicherter Pixel
-		LTDBPixel *dieser = new LTDBPixel( 0 ); // Der momentan zu speichernde Pixel
-		int begin = 0, ende = 0; // Pixelbeginn, endposition in der byte variable
-		char byte = 0; // Der nächste byte der Datei
-		bool w = 0;
+    if( outF->is_open() )
+    {
+        LTDBPixel *letzter = 0; // Letzter gespeicherter Pixel
+        LTDBPixel *dieser = new LTDBPixel( 0 ); // Der momentan zu speichernde Pixel
+        int begin = 0, ende = 0; // Pixelbeginn, endposition in der byte variable
+        char byte = 0; // Der nächste byte der Datei
+        bool w = 0;
 #ifdef WIN32
-		if( zF )
-		{
-			zF->reset();
-			zF->setAktionAnzahl( gr.x * gr.y );
-		}
+        if( zF )
+        {
+            zF->reset();
+            zF->setAktionAnzahl( gr.x * gr.y );
+        }
 #endif
-		int *pBuff = b->getBuffer();
-		for( int i = 0; i < gr.x * gr.y; ++i ) // für jeden Pixel
-		{
-			if( !dieser ) // wenn es nicht der erste Pixel ist
-				dieser = new LTDBPixel( letzter->getThis() );
-			dieser->setFarbe( pBuff[ i ] ); // Farbe des Pixels setzen
-			dieser->komprimieren(); // Pixel komprimieren
-			ende = -1;
-			while( ende < 0 ) // byte befüllen
-			{
-				ende = dieser->getNextByte( byte, begin );
-				begin = 0;
-				w = 0;
-				if( ende == -1 || ende == 8 ) // byte speichern
-				{
-					outF->write( &byte, 1 );
-					w = 1;
-					byte = 0;
-				}
-			} // Pixel fertig
-			begin = ende;
-			if( begin == 8 )
-				begin = 0;
-			if( letzter )
-				letzter->release();
-			letzter = dieser->getThis(); // dieser wird zu letzter
-			dieser = dieser->release();
+        int *pBuff = b->getBuffer();
+        for( int i = 0; i < gr.x * gr.y; ++i ) // für jeden Pixel
+        {
+            if( !dieser ) // wenn es nicht der erste Pixel ist
+                dieser = new LTDBPixel( letzter->getThis() );
+            dieser->setFarbe( pBuff[ i ] ); // Farbe des Pixels setzen
+            dieser->komprimieren(); // Pixel komprimieren
+            ende = -1;
+            while( ende < 0 ) // byte befüllen
+            {
+                ende = dieser->getNextByte( byte, begin );
+                begin = 0;
+                w = 0;
+                if( ende == -1 || ende == 8 ) // byte speichern
+                {
+                    outF->write( &byte, 1 );
+                    w = 1;
+                    byte = 0;
+                }
+            } // Pixel fertig
+            begin = ende;
+            if( begin == 8 )
+                begin = 0;
+            if( letzter )
+                letzter->release();
+            letzter = dieser->getThis(); // dieser wird zu letzter
+            dieser = dieser->release();
 #ifdef WIN32
-			if( zF )
-				zF->aktionPlus();
+            if( zF )
+                zF->aktionPlus();
 #endif
-		}
-		if( letzter )
-			letzter = letzter->release();
-		if( !w )
-		{
-			outF->write( &byte, 1 ); // Das letzte byte speichern
-		}
-		outF->flush(); // dateistream speichern
-	}
+        }
+        if( letzter )
+            letzter = letzter->release();
+        if( !w )
+        {
+            outF->write( &byte, 1 ); // Das letzte byte speichern
+        }
+        outF->flush(); // dateistream speichern
+    }
 }
 
 Bild *LTDBKörper::getBild() const // gibt das geladene Bild zurück
 {
-	return b->getThis();
+    return b->getThis();
 }
 
 const Punkt &LTDBKörper::getGröße() const // gibt die größe des Bildes zurück
 {
-	return gr;
+    return gr;
 }
 
 // Reference Counting
 LTDBKörper *LTDBKörper::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDBKörper *LTDBKörper::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 // Inhalt det LTDBDatei Klasse aus Dateisystem.h
 // Konstruktor 
 LTDBDatei::LTDBDatei()
-	: pfad( new Text() ),
-	  datKpf( 0 ),
-	  ref( 1 )
-{
-}
+    : pfad( new Text() ),
+    datKpf( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor 
 LTDBDatei::~LTDBDatei()
 {
-	if( pfad )
-		pfad->release();
-	if( datKpf )
-		datKpf->release();
+    if( pfad )
+        pfad->release();
+    if( datKpf )
+        datKpf->release();
 }
 
 // nicht constant 
 void LTDBDatei::setDatei( Text *pfad ) // Setzt den Pfad zur Datei
 { // Werte der eventuellen vorherigen Datei löschen
-	if( datKpf )
-		datKpf = datKpf->release();
-	// Pfad setzen
-	this->pfad->setText( pfad->getThis() );
-	pfad->release();
+    if( datKpf )
+        datKpf = datKpf->release();
+    // Pfad setzen
+    this->pfad->setText( pfad->getThis() );
+    pfad->release();
 }
 
 void LTDBDatei::erstellen() // Erstellt die Datei
 {
-	DateiPfadErstellen( pfad->getThis() );
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
-	int i = 0;
-	outF->write( (char *)&i, 2 );
-	delete outF;
+    DateiPfadErstellen( pfad->getThis() );
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
+    int i = 0;
+    outF->write( (char *)&i, 2 );
+    delete outF;
 }
 
 void LTDBDatei::leseDaten( FBalken *f ) // Die Klasse ließt alle Bilder kurz ein, und merkt sich, an welcher stelle in der Datei was ist
 { // Diese Funktion wird ein wenig Zeit in Anspruch nemen, dafüraber danach die anderen schneller machen
-	if( DateiExistiert( pfad->getThis() ) )
-	{
-		if( datKpf )
-			datKpf->release();
-		datKpf = new LTDBDateiKopf();
-		std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-		datKpf->laden( f, inF );
-		delete inF;
-	}
+    if( DateiExistiert( pfad->getThis() ) )
+    {
+        if( datKpf )
+            datKpf->release();
+        datKpf = new LTDBDateiKopf();
+        std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+        datKpf->laden( f, inF );
+        delete inF;
+    }
 }
 
 void LTDBDatei::löschen() // Löscht die Datei
 {
-	if( DateiExistiert( pfad->getThis() ) )
-	{
-		DateiLöschen( pfad->getThis() );
-		if( datKpf )
-			datKpf->release();
-	}
+    if( DateiExistiert( pfad->getThis() ) )
+    {
+        DateiLöschen( pfad->getThis() );
+        if( datKpf )
+            datKpf->release();
+    }
 }
 
 void LTDBDatei::löschen( FBalken *f, Text *name ) // Löscht ein Bild aus der Datei
 {
-	if( DateiExistiert( pfad->getThis() ) && name )
-	{
-		if( !datKpf )
-			leseDaten( 0 ); // Daten einlesen
-		// Prüfen, ob Datei nicht vorhanden
-		if( !datKpf )
-		{
-			name->release();
-			return;
-		}
-		int index = datKpf->getBildIndex( name->getThis() );
-		if( index == -1 ) // das bild existiert nicht
-		{
-			name->release();
-			return;
-		}
-		// Zwischenspeicherpfad ermitteln
-		Text *pf_tmp = new Text( pfad->getText() );
-		char c = '0';
-		pf_tmp->anhängen( "0" );
-		for( int i = 0; DateiExistiert( pf_tmp->getThis() ); ++i )
-		{
-			c = '0' + ( i % 10 );
-			if( ( i % 10 ) == 0 )
-				pf_tmp->anhängen( "$" );
-			pf_tmp->ersetzen( pf_tmp->anzahlVon( '0' - ( ( i - 1 ) % 10 ) ) - 1, '0' - ( ( i - 1 ) % 10 ), c );
-		}
-		std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // Alte Datei öffnen
-		inF->seekg( 0, std::ios::end );
-		__int64 Datlän = inF->tellg();
-		inF->seekg( 0, std::ios::beg );
-		std::ofstream *outF = new std::ofstream( pf_tmp->getText(), std::ios::binary ); // Neue Datei öffnen
-		if( inF->is_open() && outF->is_open() )
-		{
-			__int64 position = datKpf->getBildPosition( index );
-			datKpf->removeBild( index );
-			datKpf->speichern( outF );
-			LTDBDateiKopf *kpf_tmp = new LTDBDateiKopf();
-			kpf_tmp->laden( 0, inF );
-			kpf_tmp->release();
-			char byte = 0;
-			__int64 pos_minus = inF->tellg() - outF->tellp();
-			for( int i = 0; i < index; ++i )
-				datKpf->setBildPos( i, datKpf->getBildPosition( i ) - pos_minus );
-			// Bytes bis zur Datei kopieren
-			for( __int64 i = inF->tellg(); i < position; ++i )
-			{
-				inF->read( &byte, 1 );
-				outF->write( &byte, 1 );
-			} // zu löschendes Bild überspringen
-			LTDBKopf *delkpf = new LTDBKopf();
-			delkpf->laden( inF );
-			LTDBKörper *delkpr = new LTDBKörper( delkpf->getThis() );
-			delkpr->laden( f, inF );
-			delkpf = delkpf->release();
-			delkpr = delkpr->release(); // restliche bytes kopieren
-			pos_minus = inF->tellg() - outF->tellp();
-			for( __int64 i = (__int64)inF->tellg(); i < Datlän; ++i )
-			{
-				inF->read( &byte, 1 );
-				outF->write( &byte, 1 );
-			}
-			for( int i = index; i < datKpf->getbAnzahl(); ++i )
-				datKpf->setBildPos( i, datKpf->getBildPosition( i ) - pos_minus );
-			outF->seekp( 0, std::ios::beg );
-			datKpf->speichern( outF );
-			inF->close();
-			outF->close();
-			DateiLöschen( pfad->getThis() );
-			DateiUmbenennen( pf_tmp->getThis(), pfad->getThis() );
-		}
-		delete inF;
-		delete outF;
-		pf_tmp = pf_tmp->release();
-	}
-	if( name )
-		name = name->release();
+    if( DateiExistiert( pfad->getThis() ) && name )
+    {
+        if( !datKpf )
+            leseDaten( 0 ); // Daten einlesen
+        // Prüfen, ob Datei nicht vorhanden
+        if( !datKpf )
+        {
+            name->release();
+            return;
+        }
+        int index = datKpf->getBildIndex( name->getThis() );
+        if( index == -1 ) // das bild existiert nicht
+        {
+            name->release();
+            return;
+        }
+        // Zwischenspeicherpfad ermitteln
+        Text *pf_tmp = new Text( pfad->getText() );
+        char c = '0';
+        pf_tmp->anhängen( "0" );
+        for( int i = 0; DateiExistiert( pf_tmp->getThis() ); ++i )
+        {
+            c = '0' + ( i % 10 );
+            if( ( i % 10 ) == 0 )
+                pf_tmp->anhängen( "$" );
+            pf_tmp->ersetzen( pf_tmp->anzahlVon( '0' - ( ( i - 1 ) % 10 ) ) - 1, '0' - ( ( i - 1 ) % 10 ), c );
+        }
+        std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // Alte Datei öffnen
+        inF->seekg( 0, std::ios::end );
+        __int64 Datlän = inF->tellg();
+        inF->seekg( 0, std::ios::beg );
+        std::ofstream *outF = new std::ofstream( pf_tmp->getText(), std::ios::binary ); // Neue Datei öffnen
+        if( inF->is_open() && outF->is_open() )
+        {
+            __int64 position = datKpf->getBildPosition( index );
+            datKpf->removeBild( index );
+            datKpf->speichern( outF );
+            LTDBDateiKopf *kpf_tmp = new LTDBDateiKopf();
+            kpf_tmp->laden( 0, inF );
+            kpf_tmp->release();
+            char byte = 0;
+            __int64 pos_minus = inF->tellg() - outF->tellp();
+            for( int i = 0; i < index; ++i )
+                datKpf->setBildPos( i, datKpf->getBildPosition( i ) - pos_minus );
+            // Bytes bis zur Datei kopieren
+            for( __int64 i = inF->tellg(); i < position; ++i )
+            {
+                inF->read( &byte, 1 );
+                outF->write( &byte, 1 );
+            } // zu löschendes Bild überspringen
+            LTDBKopf *delkpf = new LTDBKopf();
+            delkpf->laden( inF );
+            LTDBKörper *delkpr = new LTDBKörper( delkpf->getThis() );
+            delkpr->laden( f, inF );
+            delkpf = delkpf->release();
+            delkpr = delkpr->release(); // restliche bytes kopieren
+            pos_minus = inF->tellg() - outF->tellp();
+            for( __int64 i = (__int64)inF->tellg(); i < Datlän; ++i )
+            {
+                inF->read( &byte, 1 );
+                outF->write( &byte, 1 );
+            }
+            for( int i = index; i < datKpf->getbAnzahl(); ++i )
+                datKpf->setBildPos( i, datKpf->getBildPosition( i ) - pos_minus );
+            outF->seekp( 0, std::ios::beg );
+            datKpf->speichern( outF );
+            inF->close();
+            outF->close();
+            DateiLöschen( pfad->getThis() );
+            DateiUmbenennen( pf_tmp->getThis(), pfad->getThis() );
+        }
+        delete inF;
+        delete outF;
+        pf_tmp = pf_tmp->release();
+    }
+    if( name )
+        name = name->release();
 }
 
 Bild *LTDBDatei::laden( FBalken *f, Text *name ) // Läd ein Bild aus der Datei
 {
-	if( name )
-	{
-		if( !DateiExistiert( pfad->getThis() ) )
-		{
-			name->release();
-			return 0;
-		}
-		if( !datKpf )
-			leseDaten( 0 );
-		LTDBKopf *k_tmp = new LTDBKopf();
-		k_tmp->Init( name->getThis(), Punkt( 0, 0 ) );
-		int index = datKpf->getBildIndex( k_tmp->getTitel() );
-		k_tmp->release();
-		if( index == -1 )
-		{ // Fehlermeldung 
-			Text *fehler = new Text( "Das Bild " );
-			fehler->anhängen( name );
-			fehler->anhängen( " wurde nicht in der Datei\n" );
-			fehler->anhängen( pfad->getThis() );
-			fehler->anhängen( " gefunden!" );
+    if( name )
+    {
+        if( !DateiExistiert( pfad->getThis() ) )
+        {
+            name->release();
+            return 0;
+        }
+        if( !datKpf )
+            leseDaten( 0 );
+        LTDBKopf *k_tmp = new LTDBKopf();
+        k_tmp->Init( name->getThis(), Punkt( 0, 0 ) );
+        int index = datKpf->getBildIndex( k_tmp->getTitel() );
+        k_tmp->release();
+        if( index == -1 )
+        { // Fehlermeldung 
+            Text *fehler = new Text( "Das Bild " );
+            fehler->anhängen( name );
+            fehler->anhängen( " wurde nicht in der Datei\n" );
+            fehler->anhängen( pfad->getThis() );
+            fehler->anhängen( " gefunden!" );
             std::cout << fehler << "\n";
-			return 0;
-		}
-		std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-		// Begin der zu ladenden Datei ermitteln
-		__int64 position = datKpf->getBildPosition( index );
-		inF->seekg( position, std::ios::beg );
-		LTDBKopf *kpf = new LTDBKopf();
-		kpf->laden( inF );
-		Text *t = kpf->getTitel();
-		if( !t->istGleich( name->getThis() ) )
-		{ // Fehlermeldung 
-			t->release();
-			kpf->release();
-			inF->close();
-			delete inF;
-			Text *fehler = new Text( "Die Datei " );
-			fehler->anhängen( pfad );
-			fehler->anhängen( " ist ist keine gültige LTDB Datei!" );
+            return 0;
+        }
+        std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+        // Begin der zu ladenden Datei ermitteln
+        __int64 position = datKpf->getBildPosition( index );
+        inF->seekg( position, std::ios::beg );
+        LTDBKopf *kpf = new LTDBKopf();
+        kpf->laden( inF );
+        Text *t = kpf->getTitel();
+        if( !t->istGleich( name->getThis() ) )
+        { // Fehlermeldung 
+            t->release();
+            kpf->release();
+            inF->close();
+            delete inF;
+            Text *fehler = new Text( "Die Datei " );
+            fehler->anhängen( pfad );
+            fehler->anhängen( " ist ist keine gültige LTDB Datei!" );
 #ifdef WIN32
-			WMessageBox( 0, new Text( "Fehler" ), fehler, MB_ICONERROR );
+            WMessageBox( 0, new Text( "Fehler" ), fehler, MB_ICONERROR );
 #endif
-			name->release();
-			return 0;
-		}
-		t->release();
-		LTDBKörper *kpr = new LTDBKörper( kpf->getThis() );
-		kpr->laden( f, inF ); // Bild laden
-		Bild *ret = kpr->getBild();
-		kpr->release();
-		kpf->release();
-		inF->close();
-		delete inF;
-		name->release();
-		return ret;
-	}
-	return 0;
+            name->release();
+            return 0;
+        }
+        t->release();
+        LTDBKörper *kpr = new LTDBKörper( kpf->getThis() );
+        kpr->laden( f, inF ); // Bild laden
+        Bild *ret = kpr->getBild();
+        kpr->release();
+        kpf->release();
+        inF->close();
+        delete inF;
+        name->release();
+        return ret;
+    }
+    return 0;
 }
 
 int LTDBDatei::speichern( FBalken *f, Bild *bild, Text *name ) // Speichert ein Bild in die Datei
 {
-	int warn = -1;
-	if( name && bild )
-	{
-		if( DateiExistiert( pfad->getThis() ) )
-		{
-			if( !datKpf )
-				leseDaten( 0 );
-			int index = datKpf->getBildIndex( name->getThis() );
-			if( index == -1 )
-			{
-				warn = 0;
-				LTDBKopf *kpf = new LTDBKopf();
-				warn = kpf->Init( name->getThis(), bild->getGröße() );
-				if( datKpf->getBildIndex( kpf->getTitel() ) != -1 )
-				{
-					std::cout << "Es existiert bereits ein Bild mit diesem Namen!\n";
-					bild->release();
-					name->release();
-					kpf->release();
-					return -1;
-				}
-				// zwischendateipfad suchen
-				Text *pf_tmp = new Text( pfad->getText() );
-				char c = '0';
-				pf_tmp->anhängen( "0" );
-				for( int i = 0; DateiExistiert( pf_tmp->getThis() ); ++i )
-				{
-					c = '0' + ( i % 10 );
-					if( ( i % 10 ) == 0 )
-						pf_tmp->anhängen( "$" );
-					pf_tmp->ersetzen( pf_tmp->anzahlVon( '0' - ( ( i - 1 ) % 10 ) ) - 1, '0' - ( ( i - 1 ) % 10 ), c );
-				}
-				std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-				inF->seekg( 0, std::ios::end );
-				__int64 datLen = inF->tellg();
-				inF->seekg( 0, std::ios::beg );
-				std::ofstream *outF = new std::ofstream( pf_tmp->getText(), std::ios::binary );
-				datKpf->addBild( kpf->getTitel() );
-				index = datKpf->getBildIndex( kpf->getTitel() );
-				datKpf->speichern( outF );
-				LTDBDateiKopf *kpf_tmp = new LTDBDateiKopf();
-				kpf_tmp->laden( 0, inF );
-				kpf_tmp->release();
-				__int64 pos_plus = outF->tellp() - inF->tellg();
-				for( int i = 0; i < index; ++i )
-					datKpf->setBildPos( i, datKpf->getBildPosition( i ) + pos_plus );
-				datKpf->setBildPos( index, datLen + pos_plus );
-				outF->seekp( 0, std::ios::beg );
-				datKpf->speichern( outF );
-				char byte = 0;
-				for( __int64 i = inF->tellg(); i < datLen; ++i )
-				{
-					inF->read( &byte, 1 );
-					outF->write( &byte, 1 );
-				}
-				kpf->speichern( outF ); // Bild Kopf speichern
-				LTDBKörper *kpr = new LTDBKörper( kpf->getThis() );
-				kpr->setBild( bild->getThis() );
-				kpr->speichern( f, outF ); // Bild speichern
-				kpf->release();
-				kpr->release();
-				inF->close();
-				outF->close();
-				delete inF;
-				delete outF;
-				DateiLöschen( pfad->getThis() );
-				DateiUmbenennen( pf_tmp, pfad->getThis() );
-			}
-		}
-	}
-	if( name )
-		name->release();
-	if( bild )
-		bild->release();
-	return warn;
+    int warn = -1;
+    if( name && bild )
+    {
+        if( DateiExistiert( pfad->getThis() ) )
+        {
+            if( !datKpf )
+                leseDaten( 0 );
+            int index = datKpf->getBildIndex( name->getThis() );
+            if( index == -1 )
+            {
+                warn = 0;
+                LTDBKopf *kpf = new LTDBKopf();
+                warn = kpf->Init( name->getThis(), bild->getGröße() );
+                if( datKpf->getBildIndex( kpf->getTitel() ) != -1 )
+                {
+                    std::cout << "Es existiert bereits ein Bild mit diesem Namen!\n";
+                    bild->release();
+                    name->release();
+                    kpf->release();
+                    return -1;
+                }
+                // zwischendateipfad suchen
+                Text *pf_tmp = new Text( pfad->getText() );
+                char c = '0';
+                pf_tmp->anhängen( "0" );
+                for( int i = 0; DateiExistiert( pf_tmp->getThis() ); ++i )
+                {
+                    c = '0' + ( i % 10 );
+                    if( ( i % 10 ) == 0 )
+                        pf_tmp->anhängen( "$" );
+                    pf_tmp->ersetzen( pf_tmp->anzahlVon( '0' - ( ( i - 1 ) % 10 ) ) - 1, '0' - ( ( i - 1 ) % 10 ), c );
+                }
+                std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+                inF->seekg( 0, std::ios::end );
+                __int64 datLen = inF->tellg();
+                inF->seekg( 0, std::ios::beg );
+                std::ofstream *outF = new std::ofstream( pf_tmp->getText(), std::ios::binary );
+                datKpf->addBild( kpf->getTitel() );
+                index = datKpf->getBildIndex( kpf->getTitel() );
+                datKpf->speichern( outF );
+                LTDBDateiKopf *kpf_tmp = new LTDBDateiKopf();
+                kpf_tmp->laden( 0, inF );
+                kpf_tmp->release();
+                __int64 pos_plus = outF->tellp() - inF->tellg();
+                for( int i = 0; i < index; ++i )
+                    datKpf->setBildPos( i, datKpf->getBildPosition( i ) + pos_plus );
+                datKpf->setBildPos( index, datLen + pos_plus );
+                outF->seekp( 0, std::ios::beg );
+                datKpf->speichern( outF );
+                char byte = 0;
+                for( __int64 i = inF->tellg(); i < datLen; ++i )
+                {
+                    inF->read( &byte, 1 );
+                    outF->write( &byte, 1 );
+                }
+                kpf->speichern( outF ); // Bild Kopf speichern
+                LTDBKörper *kpr = new LTDBKörper( kpf->getThis() );
+                kpr->setBild( bild->getThis() );
+                kpr->speichern( f, outF ); // Bild speichern
+                kpf->release();
+                kpr->release();
+                inF->close();
+                outF->close();
+                delete inF;
+                delete outF;
+                DateiLöschen( pfad->getThis() );
+                DateiUmbenennen( pf_tmp, pfad->getThis() );
+            }
+        }
+    }
+    if( name )
+        name->release();
+    if( bild )
+        bild->release();
+    return warn;
 }
 
 RCArray< Text > *LTDBDatei::zBildListe() // Listet alle Bilder in der datei auf
 {
-	if( !datKpf )
-		leseDaten( 0 );
-	if( datKpf )
-		return datKpf->zBildListe();
-	return 0;
+    if( !datKpf )
+        leseDaten( 0 );
+    if( datKpf )
+        return datKpf->zBildListe();
+    return 0;
 }
 
 // constant 
 Text *LTDBDatei::getPfad() const // Gibt den Pfad zur Datei zurück
 {
-	return pfad->getThis();
+    return pfad->getThis();
 }
 
 int LTDBDatei::getBildAnzahl() const
 {
-	if( !datKpf )
-		return 0;
-	return datKpf->getbAnzahl();
+    if( !datKpf )
+        return 0;
+    return datKpf->getbAnzahl();
 }
 
 bool LTDBDatei::istOffen() const // Prüft, ob die Datei geöffnet ist
 {
-	if( !pfad )
-		return 0;
-	return DateiExistiert( pfad->getThis() );
+    if( !pfad )
+        return 0;
+    return DateiExistiert( pfad->getThis() );
 }
 
 // Reference Counting
 LTDBDatei *LTDBDatei::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDBDatei *LTDBDatei::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 #ifdef WIN32
 // LTDS Dateivormat 
 // Inhalt der LTDSPixel Klasse aus DateiSystem.h
 // Konstruktor 
 LTDSPixel::LTDSPixel( LTDSPixel *davor )
-	: ref( 1 ),
-	  index( 0 ),
-	  iA( 0 ),
-	  miA( 8 ),
-	  maxIndex( 1 ),
-	  änder( 0 ),
-	  änderA( 0 ),
-	  komp( 0 ),
-	  alpha( 0 ),
-	  davor( davor )
-{
-}
+    : ref( 1 ),
+    index( 0 ),
+    iA( 0 ),
+    miA( 8 ),
+    maxIndex( 1 ),
+    änder( 0 ),
+    änderA( 0 ),
+    komp( 0 ),
+    alpha( 0 ),
+    davor( davor )
+{}
 
 // Destruktor 
 LTDSPixel::~LTDSPixel()
 {
-	if( davor )
-		davor->release();
+    if( davor )
+        davor->release();
 }
 
 // nicht constant 
 // zum Laden gedacht 
 bool LTDSPixel::addBitZuFarbe( unsigned char bit )
 {
-	if( änderA && iA != miA ) // Das Bit gehört zu Alpha
-	{
-		alpha |= ( ( bit & Bits( 1 ) ) ) << ( 7 - komp - iA );
-		++iA;
-	}
-	else // Das Bit gehört zum nächsten Pixel
-		return false;
-	return true;
+    if( änderA && iA != miA ) // Das Bit gehört zu Alpha
+    {
+        alpha |= ( ( bit & Bits( 1 ) ) ) << ( 7 - komp - iA );
+        ++iA;
+    }
+    else // Das Bit gehört zum nächsten Pixel
+        return false;
+    return true;
 }
 
 char LTDSPixel::addByte( char byte, char begin ) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
 {
-	if( begin >= 8 || begin < 0 )
-		return -1;
-	for( int i = begin; i < 8; ++i )
-	{
-		switch( index )
-		{
-		case 0:
-			// Das erste Bit eines Pixels speichert, ob sich an der Komprimierung etwas änderte
-			änder = ( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) == 1;
-			if( !änder ) // Ändert sich nichts an der Komprimierung, so werden die Werte vom vorherigen Pixel übernommen
-			{
-				if( !davor ) // Die Datei ist beschädigt ( Der erste Pixel kann nicht von dem davor Übernemen )
-				{
-					MessageBox( NULL, "Fehler, die Bilddatei ist beschädigt", "Fehler", MB_ICONERROR );
-					exit( 0 );
-				}
-				änderA = davor->getÄnderA();
-				komp = davor->getKomp();
-				miA -= komp;
-				if( !änderA )
-					alpha = davor->getA();
-				maxIndex += änderA * ( 8 - komp ); // Bestimmung der Länge
-				// des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits, durch komprimierung kanns kleiner sein
-			}
-			else
-				maxIndex += 4; // Da der Pixel nicht die Werte des vorherigen übernimmt, wird er um 4 Bits größer
-			break;
-		case 1: // Das zweite Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
-				änderA = ( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) == 1;
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 2: // Das sechste Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) << 2;
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 3: // Das siebte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) << 1;
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		case 4: // Das achte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
-			if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
-			{
-				komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) );
-				// Das war das letzte Komprimierungsbit
-				// Komprimierung auswerten 
-				miA -= komp;
-				if( !änderA )
-					alpha = davor->getA();
-				maxIndex += änderA * ( 8 - komp ); // Bitlänge des Pixels
-			}
-			else
-			{
-				if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-					return i;
-			}
-			break;
-		default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
-			if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
-				return i;
-			break;
-		}
-		++index;
-		if( index >= maxIndex )
-		{
-			if( davor )
-			{
-				if( änderA )
-					alpha = davor->getA() + alpha;
-				davor = davor->release();
-			}
-			return i + 1;
-		}
-	}
-	return -1;
+    if( begin >= 8 || begin < 0 )
+        return -1;
+    for( int i = begin; i < 8; ++i )
+    {
+        switch( index )
+        {
+        case 0:
+            // Das erste Bit eines Pixels speichert, ob sich an der Komprimierung etwas änderte
+            änder = ( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) == 1;
+            if( !änder ) // Ändert sich nichts an der Komprimierung, so werden die Werte vom vorherigen Pixel übernommen
+            {
+                if( !davor ) // Die Datei ist beschädigt ( Der erste Pixel kann nicht von dem davor Übernemen )
+                {
+                    MessageBox( NULL, "Fehler, die Bilddatei ist beschädigt", "Fehler", MB_ICONERROR );
+                    exit( 0 );
+                }
+                änderA = davor->getÄnderA();
+                komp = davor->getKomp();
+                miA -= komp;
+                if( !änderA )
+                    alpha = davor->getA();
+                maxIndex += änderA * ( 8 - komp ); // Bestimmung der Länge
+                // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits, durch komprimierung kanns kleiner sein
+            }
+            else
+                maxIndex += 4; // Da der Pixel nicht die Werte des vorherigen übernimmt, wird er um 4 Bits größer
+            break;
+        case 1: // Das zweite Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
+                änderA = ( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) == 1;
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 2: // Das sechste Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) << 2;
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 3: // Das siebte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) ) << 1;
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        case 4: // Das achte Bit eines Pixels speichert entweder die Komprimierungsart, oder schon die Farbe
+            if( änder ) // Das Bit gehört zu den 4 Komprimierungsbits
+            {
+                komp |= (unsigned char)( ( byte >> ( 7 - i ) ) & Bits( 1 ) );
+                // Das war das letzte Komprimierungsbit
+                // Komprimierung auswerten 
+                miA -= komp;
+                if( !änderA )
+                    alpha = davor->getA();
+                maxIndex += änderA * ( 8 - komp ); // Bitlänge des Pixels
+            }
+            else
+            {
+                if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                    return i;
+            }
+            break;
+        default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
+            if( !addBitZuFarbe( byte >> ( 7 - i ) ) ) // Das Bit gehört zur Farbe
+                return i;
+            break;
+        }
+        ++index;
+        if( index >= maxIndex )
+        {
+            if( davor )
+            {
+                if( änderA )
+                    alpha = davor->getA() + alpha;
+                davor = davor->release();
+            }
+            return i + 1;
+        }
+    }
+    return -1;
 }
 
 // zum speichern gedacht 
 void LTDSPixel::setAlpha( unsigned char alpha ) // setzt die Farbe des Pixels
 {
-	this->alpha = alpha;
+    this->alpha = alpha;
 }
 
 void LTDSPixel::Komp() // Komprimiert den Pixel
 {
-	maxIndex = 1;
-	if( !davor )
-	{// Das ist der erste Pixel
-		änder = 1;
-		änderA = 1;
-		maxIndex += 4;
-		miA = getBits( alpha );
-	}
-	else
-	{ // Es wird die differenz zum vorrigen Pixel gespeichert
-		miA = getBits( alpha - davor->getA() );
-		if( alpha != davor->getA() )
-			änderA = 1;
-		else
-			änderA = 0;
-	}// Prüfen ob sich etwas ändert
-	if( !miA && änderA )
-		++miA;
-	komp = 8 - miA;
-	maxIndex += änderA * miA;
-	if( davor )
-	{
-		if( änderA != davor->getÄnderA() ||
-			komp != davor->getKomp() )
-		{ // Es ändert sich etwas
-			änder = 1;
-			maxIndex += 4;
-		}
-		else
-		{ // Es ändert sich nichts
-			änder = 0;
-		}
-	}
+    maxIndex = 1;
+    if( !davor )
+    {// Das ist der erste Pixel
+        änder = 1;
+        änderA = 1;
+        maxIndex += 4;
+        miA = getBits( alpha );
+    }
+    else
+    { // Es wird die differenz zum vorrigen Pixel gespeichert
+        miA = getBits( alpha - davor->getA() );
+        if( alpha != davor->getA() )
+            änderA = 1;
+        else
+            änderA = 0;
+    }// Prüfen ob sich etwas ändert
+    if( !miA && änderA )
+        ++miA;
+    komp = 8 - miA;
+    maxIndex += änderA * miA;
+    if( davor )
+    {
+        if( änderA != davor->getÄnderA() ||
+            komp != davor->getKomp() )
+        { // Es ändert sich etwas
+            änder = 1;
+            maxIndex += 4;
+        }
+        else
+        { // Es ändert sich nichts
+            änder = 0;
+        }
+    }
 }
 
 bool LTDSPixel::getNextFarbeBit( char &byte, int i )
 {
-	unsigned char AA = alpha;
-	if( davor )
-	{
-		AA -= davor->getA();
-	}
-	if( änderA && iA != miA ) // Das Bit gehört zu Alpha
-	{
-		byte |= ( ( AA >> ( 7 - komp - iA ) ) & Bits( 1 ) ) << ( 7 - i );
-		++iA;
-	}
-	else // Der Pixel ist bereits zu ende
-		return false;
-	return true;
+    unsigned char AA = alpha;
+    if( davor )
+    {
+        AA -= davor->getA();
+    }
+    if( änderA && iA != miA ) // Das Bit gehört zu Alpha
+    {
+        byte |= ( ( AA >> ( 7 - komp - iA ) ) & Bits( 1 ) ) << ( 7 - i );
+        ++iA;
+    }
+    else // Der Pixel ist bereits zu ende
+        return false;
+    return true;
 }
 
 char LTDSPixel::getNextByte( char &byte, int bbegin ) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel nicht zu ende ist
 {
-	// bbegin gibt an wohin in die byte-variable geschrieben werden soll
-	// die Funktion gibt das ende des Pixels in der byte-variable zurück
-	// -1 heißt, dass der Pixel nicht zu ende ist
-	for( int i = bbegin; i < 8; ++i )
-	{
-		switch( index )
-		{
-		case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der Komprimierung ändert
-			byte |= ( (int)änder & Bits( 1 ) ) << ( 7 - i );
-			break;
-		case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( (int)änderA & Bits( 1 ) ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 2: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( ( komp >> 2 ) & Bits( 1 ) ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 3: // Das dritte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( ( komp >> 1 ) & Bits( 1 ) ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		case 4: // Das vierte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
-			if( änder ) // Komprimierung
-				byte |= ( komp & Bits( 1 ) ) << ( 7 - i );
-			else // Farbe
-			{
-				if( !getNextFarbeBit( byte, i ) )
-					return i;
-			}
-			break;
-		default: // Die restlichen Bits speichern die Farbe des Pixels
-			if( !getNextFarbeBit( byte, i ) )
-				return i;
-			break;
-		}
-		++index;
-		if( index >= maxIndex )
-		{
-			if( davor )
-				davor = davor->release();
-			return i + 1;
-		}
-	}
-	return -1;
+    // bbegin gibt an wohin in die byte-variable geschrieben werden soll
+    // die Funktion gibt das ende des Pixels in der byte-variable zurück
+    // -1 heißt, dass der Pixel nicht zu ende ist
+    for( int i = bbegin; i < 8; ++i )
+    {
+        switch( index )
+        {
+        case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der Komprimierung ändert
+            byte |= ( (int)änder & Bits( 1 ) ) << ( 7 - i );
+            break;
+        case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( (int)änderA & Bits( 1 ) ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 2: // Das zweite Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( ( komp >> 2 ) & Bits( 1 ) ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 3: // Das dritte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( ( komp >> 1 ) & Bits( 1 ) ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        case 4: // Das vierte Bit des Pixels speichert entweder schon die Farbe oder die Komprimierung
+            if( änder ) // Komprimierung
+                byte |= ( komp & Bits( 1 ) ) << ( 7 - i );
+            else // Farbe
+            {
+                if( !getNextFarbeBit( byte, i ) )
+                    return i;
+            }
+            break;
+        default: // Die restlichen Bits speichern die Farbe des Pixels
+            if( !getNextFarbeBit( byte, i ) )
+                return i;
+            break;
+        }
+        ++index;
+        if( index >= maxIndex )
+        {
+            if( davor )
+                davor = davor->release();
+            return i + 1;
+        }
+    }
+    return -1;
 }
 
 // constant 
 unsigned char LTDSPixel::getKomp() const // hat sich die Komprimierung geändert
 {
-	return komp;
+    return komp;
 }
 
 bool LTDSPixel::getÄnderA() const // gibt zurück, ob sich der alphawert ändert
 {
-	return änderA;
+    return änderA;
 }
 
 unsigned char LTDSPixel::getA() const // gibt Alpha zurück
 {
-	return alpha;
+    return alpha;
 }
 
 // Reference Counting 
 LTDSPixel *LTDSPixel::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSPixel *LTDSPixel::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDSDateiKopf Klasse aus Dateisystem.h
 // Konstruktor 
 LTDSDateiKopf::LTDSDateiKopf()
-	: ref( 1 ),
-	  sganzahl( 0 ),
-	  gr( 0 ),
-	  pos( 0 )
-{
-}
+    : ref( 1 ),
+    sganzahl( 0 ),
+    gr( 0 ),
+    pos( 0 )
+{}
 
 // Destruktor 
 LTDSDateiKopf::~LTDSDateiKopf()
 {
-	delete[]gr;
-	delete[]pos;
+    delete[]gr;
+    delete[]pos;
 }
 
 // nicht constant 
 void LTDSDateiKopf::laden( std::ifstream *inF ) // Lät aus inF
 {
-	if( inF->good() && inF->is_open() )
-	{
-		inF->read( (char *)&sganzahl, 1 );
-		delete[]gr;
-		delete[]pos;
-		gr = new unsigned char[ sganzahl + 1 ];
-		pos = new int[ sganzahl + 1 ];
-		gr[ sganzahl ] = 0;
-		pos[ sganzahl ] = 0;
-		for( int i = 0; i < sganzahl; ++i )
-		{
-			inF->read( (char*)&gr[ i ], 1 );
-			inF->read( (char*)&pos[ i ], 4 );
-		}
-	}
+    if( inF->good() && inF->is_open() )
+    {
+        inF->read( (char *)&sganzahl, 1 );
+        delete[]gr;
+        delete[]pos;
+        gr = new unsigned char[ sganzahl + 1 ];
+        pos = new int[ sganzahl + 1 ];
+        gr[ sganzahl ] = 0;
+        pos[ sganzahl ] = 0;
+        for( int i = 0; i < sganzahl; ++i )
+        {
+            inF->read( (char*)&gr[ i ], 1 );
+            inF->read( (char*)&pos[ i ], 4 );
+        }
+    }
 }
 
 void LTDSDateiKopf::addSG( char sg ) // Schriftgröße hinzufügen
 {
-	++sganzahl;
-	unsigned char *gr_tmp = gr;
-	int *pos_tmp = pos;
-	gr = new unsigned char[ sganzahl + 1 ];
-	pos = new int[ sganzahl + 1 ];
-	gr[ sganzahl ] = 0;
-	pos[ sganzahl ] = 0;
-	if( sganzahl - 1 > 0 )
-	{
-		memcpy( gr, gr_tmp, 1 * ( sganzahl - 1 ) );
-		memcpy( pos, pos_tmp, 4 * ( sganzahl - 1 ) );
-	}
-	delete[]gr_tmp;
-	delete[]pos_tmp;
-	pos[ sganzahl - 1 ] = 0;
-	gr[ sganzahl - 1 ] = sg;
+    ++sganzahl;
+    unsigned char *gr_tmp = gr;
+    int *pos_tmp = pos;
+    gr = new unsigned char[ sganzahl + 1 ];
+    pos = new int[ sganzahl + 1 ];
+    gr[ sganzahl ] = 0;
+    pos[ sganzahl ] = 0;
+    if( sganzahl - 1 > 0 )
+    {
+        memcpy( gr, gr_tmp, 1 * ( sganzahl - 1 ) );
+        memcpy( pos, pos_tmp, 4 * ( sganzahl - 1 ) );
+    }
+    delete[]gr_tmp;
+    delete[]pos_tmp;
+    pos[ sganzahl - 1 ] = 0;
+    gr[ sganzahl - 1 ] = sg;
 }
 
 void LTDSDateiKopf::removeSG( char sg ) // Schriftgröße entfernen
 {
-	bool hatsg = 0;
-	int sgpos = 0;
-	for( int i = 0; i < sganzahl; ++i )
-	{
-		hatsg = gr[ i ] == sg;
-		sgpos = i;
-		if( hatsg )
-			break;
-	}
-	if( hatsg )
-	{
-		--sganzahl;
-		unsigned char *gr_tmp = gr;
-		int *pos_tmp = pos;
-		gr = new unsigned char[ sganzahl + 1 ];
-		pos = new int[ sganzahl + 1 ];
-		gr[ sganzahl ] = 0;
-		pos[ sganzahl ] = 0;
-		for( int i = 0; i < sgpos; ++i )
-		{
-			gr[ i ] = gr_tmp[ i ];
-			pos[ i ] = pos_tmp[ i ];
-		}
-		for( int i = sgpos + 1; i < sganzahl; ++i )
-		{
-			gr[ i - 1 ] = gr_tmp[ i ];
-			pos[ i - 1 ] = pos_tmp[ i ];
-		}
-		delete[]gr_tmp;
-		delete[]pos_tmp;
-	}
+    bool hatsg = 0;
+    int sgpos = 0;
+    for( int i = 0; i < sganzahl; ++i )
+    {
+        hatsg = gr[ i ] == sg;
+        sgpos = i;
+        if( hatsg )
+            break;
+    }
+    if( hatsg )
+    {
+        --sganzahl;
+        unsigned char *gr_tmp = gr;
+        int *pos_tmp = pos;
+        gr = new unsigned char[ sganzahl + 1 ];
+        pos = new int[ sganzahl + 1 ];
+        gr[ sganzahl ] = 0;
+        pos[ sganzahl ] = 0;
+        for( int i = 0; i < sgpos; ++i )
+        {
+            gr[ i ] = gr_tmp[ i ];
+            pos[ i ] = pos_tmp[ i ];
+        }
+        for( int i = sgpos + 1; i < sganzahl; ++i )
+        {
+            gr[ i - 1 ] = gr_tmp[ i ];
+            pos[ i - 1 ] = pos_tmp[ i ];
+        }
+        delete[]gr_tmp;
+        delete[]pos_tmp;
+    }
 }
 
 // constant 
 void LTDSDateiKopf::speichern( std::ofstream *outF ) const // Speichert nach outF
 {
-	if( outF->is_open() && outF->good() )
-	{
-		outF->write( (char*)&sganzahl, 1 );
-		for( int i = 0; i < sganzahl; ++i )
-		{
-			outF->write( (char*)&gr[ i ], 1 );
-			outF->write( (char*)&pos[ i ], 4 );
-		}
-	}
+    if( outF->is_open() && outF->good() )
+    {
+        outF->write( (char*)&sganzahl, 1 );
+        for( int i = 0; i < sganzahl; ++i )
+        {
+            outF->write( (char*)&gr[ i ], 1 );
+            outF->write( (char*)&pos[ i ], 4 );
+        }
+    }
 }
 
 unsigned char *LTDSDateiKopf::getSchriftGrößeList() const // gibt eine Liste mit gespeicherten Schriftgrößen zurück
 {
-	return gr;
+    return gr;
 }
 
 int *LTDSDateiKopf::getPositionList() const // gibt eine Positionsliste der gespeicherten Schriftgrößen zurück
 {
-	return pos;
+    return pos;
 }
 
 int LTDSDateiKopf::getSchriftGrößeAnzahl() const // gibt die Anzahl der gespeicherten Schriftgrößen zurück
 {
-	return sganzahl;
+    return sganzahl;
 }
 
 // Reference Counting 
 LTDSDateiKopf *LTDSDateiKopf::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSDateiKopf *LTDSDateiKopf::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDSSchriftKopf Klasse aus Dateisystem.h
 // Konstruktor 
 LTDSSchriftKopf::LTDSSchriftKopf()
-	: ref( 1 ),
-	  schriftGröße( 0 ),
-	  zeichen( 0 ),
-	  pos( 0 ),
-	  zeichenAnzahl( 0 )
-{
-}
+    : ref( 1 ),
+    schriftGröße( 0 ),
+    zeichen( 0 ),
+    pos( 0 ),
+    zeichenAnzahl( 0 )
+{}
 
 // Destruktor 
 LTDSSchriftKopf::~LTDSSchriftKopf()
 {
-	delete[]pos;
-	delete[]zeichen;
+    delete[]pos;
+    delete[]zeichen;
 }
 
 // nicht constant 
 void LTDSSchriftKopf::laden( std::ifstream *inF ) // läht von inF
 {
-	if( inF->good() && inF->is_open() )
-	{
-		inF->read( (char*)&schriftGröße, 1 );
-		inF->read( (char*)&zeichenAnzahl, 1 );
-		delete[]pos;
-		delete[]zeichen;
-		zeichen = new unsigned char[ zeichenAnzahl ];
-		pos = new int[ zeichenAnzahl + 1 ];
-		for( int i = 0; i < zeichenAnzahl; ++i )
-		{
-			inF->read( (char*)&zeichen[ i ], 1 );
-			inF->read( (char*)&pos[ i ], 4 );
-		}
-		pos[ zeichenAnzahl ] = 0;
-	}
+    if( inF->good() && inF->is_open() )
+    {
+        inF->read( (char*)&schriftGröße, 1 );
+        inF->read( (char*)&zeichenAnzahl, 1 );
+        delete[]pos;
+        delete[]zeichen;
+        zeichen = new unsigned char[ zeichenAnzahl ];
+        pos = new int[ zeichenAnzahl + 1 ];
+        for( int i = 0; i < zeichenAnzahl; ++i )
+        {
+            inF->read( (char*)&zeichen[ i ], 1 );
+            inF->read( (char*)&pos[ i ], 4 );
+        }
+        pos[ zeichenAnzahl ] = 0;
+    }
 }
 
 void LTDSSchriftKopf::setSchriftgröße( unsigned char gr ) // setze schriftgröße
 {
-	schriftGröße = gr;
+    schriftGröße = gr;
 }
 
 void LTDSSchriftKopf::setZeichenAlphabet( Alphabet *alphabet ) // setzt die Zeichen von alphabet
 {
-	int count = 0;
-	for( int i = 0; i < 256; ++i )
-	{
-		Buchstabe *zeich = alphabet->zBuchstabe( i );
-		if( zeich )
-			++count;
-	}
-	delete[]zeichen;
-	delete[]pos;
-	zeichen = new unsigned char[ count ];
-	pos = new int[ count + 1 ];
-	pos[ count ] = 0;
-	zeichenAnzahl = count;
-	count = 0;
-	for( int i = 0; i < 256; ++i )
-	{
-		Buchstabe *zeich = alphabet->getBuchstabe( i );
-		if( zeich )
-		{
-			zeichen[ count ] = i;
-			pos[ count ] = 0;
-			++count;
-			zeich->release();
-		}
-	}
-	schriftGröße = alphabet->getSchriftgröße();
-	alphabet->release();
+    int count = 0;
+    for( int i = 0; i < 256; ++i )
+    {
+        Buchstabe *zeich = alphabet->zBuchstabe( i );
+        if( zeich )
+            ++count;
+    }
+    delete[]zeichen;
+    delete[]pos;
+    zeichen = new unsigned char[ count ];
+    pos = new int[ count + 1 ];
+    pos[ count ] = 0;
+    zeichenAnzahl = count;
+    count = 0;
+    for( int i = 0; i < 256; ++i )
+    {
+        Buchstabe *zeich = alphabet->getBuchstabe( i );
+        if( zeich )
+        {
+            zeichen[ count ] = i;
+            pos[ count ] = 0;
+            ++count;
+            zeich->release();
+        }
+    }
+    schriftGröße = alphabet->getSchriftgröße();
+    alphabet->release();
 }
 
 void LTDSSchriftKopf::addZeichen( unsigned char zeichen ) // Zeichen hinzufügen
 {
-	++zeichenAnzahl;
-	unsigned char *zeichen_tmp = this->zeichen;
-	int *pos_tmp = pos;
-	this->zeichen = new unsigned char[ zeichenAnzahl ];
-	pos = new int[ zeichenAnzahl + 1 ];
-	if( zeichenAnzahl - 1 > 0 )
-	{
-		memcpy( this->zeichen, zeichen_tmp, 1 * ( zeichenAnzahl - 1 ) );
-		memcpy( pos, pos_tmp, 4 * ( zeichenAnzahl - 1 ) );
-	}
-	delete[]zeichen_tmp;
-	delete[]pos_tmp;
-	this->zeichen[ zeichenAnzahl - 1 ] = zeichen;
-	pos[ zeichenAnzahl - 1 ] = 0;
-	pos[ zeichenAnzahl ] = 0;
+    ++zeichenAnzahl;
+    unsigned char *zeichen_tmp = this->zeichen;
+    int *pos_tmp = pos;
+    this->zeichen = new unsigned char[ zeichenAnzahl ];
+    pos = new int[ zeichenAnzahl + 1 ];
+    if( zeichenAnzahl - 1 > 0 )
+    {
+        memcpy( this->zeichen, zeichen_tmp, 1 * ( zeichenAnzahl - 1 ) );
+        memcpy( pos, pos_tmp, 4 * ( zeichenAnzahl - 1 ) );
+    }
+    delete[]zeichen_tmp;
+    delete[]pos_tmp;
+    this->zeichen[ zeichenAnzahl - 1 ] = zeichen;
+    pos[ zeichenAnzahl - 1 ] = 0;
+    pos[ zeichenAnzahl ] = 0;
 }
 
 void LTDSSchriftKopf::removeZeichen( unsigned char zeich ) // Zeichen entfernen
 {
-	bool hatZ = 0;
-	int zPos = 0;
-	for( int i = 0; i < zeichenAnzahl; ++i )
-	{
-		hatZ = zeichen[ i ] == zeich;
-		zPos = i;
-		if( hatZ )
-			break;
-	}
-	if( hatZ )
-	{
-		--zeichenAnzahl;
-		unsigned char *zeichen_tmp = zeichen;
-		int *pos_tmp = pos;
-		zeichen = new unsigned char[ zeichenAnzahl ];
-		pos = new int[ zeichenAnzahl + 1 ];
-		for( int i = 0; i < zPos; ++i )
-		{
-			zeichen[ i ] = zeichen_tmp[ i ];
-			pos[ i ] = pos_tmp[ i ];
-		}
-		for( int i = zPos + 1; i <= zeichenAnzahl; ++i )
-		{
-			zeichen[ i - 1 ] = zeichen_tmp[ i ];
-			pos[ i - 1 ] = pos_tmp[ i ];
-		}
-		pos[ zeichenAnzahl ] = 0;
-		delete[]zeichen_tmp;
-		delete[]pos_tmp;
-	}
+    bool hatZ = 0;
+    int zPos = 0;
+    for( int i = 0; i < zeichenAnzahl; ++i )
+    {
+        hatZ = zeichen[ i ] == zeich;
+        zPos = i;
+        if( hatZ )
+            break;
+    }
+    if( hatZ )
+    {
+        --zeichenAnzahl;
+        unsigned char *zeichen_tmp = zeichen;
+        int *pos_tmp = pos;
+        zeichen = new unsigned char[ zeichenAnzahl ];
+        pos = new int[ zeichenAnzahl + 1 ];
+        for( int i = 0; i < zPos; ++i )
+        {
+            zeichen[ i ] = zeichen_tmp[ i ];
+            pos[ i ] = pos_tmp[ i ];
+        }
+        for( int i = zPos + 1; i <= zeichenAnzahl; ++i )
+        {
+            zeichen[ i - 1 ] = zeichen_tmp[ i ];
+            pos[ i - 1 ] = pos_tmp[ i ];
+        }
+        pos[ zeichenAnzahl ] = 0;
+        delete[]zeichen_tmp;
+        delete[]pos_tmp;
+    }
 }
 
 // constant 
 void LTDSSchriftKopf::speichern( std::ofstream *outF ) const // speichert nach outF
 {
-	if( outF->good() && outF->is_open() )
-	{
-		outF->write( (char*)&schriftGröße, 1 );
-		outF->write( (char*)&zeichenAnzahl, 1 );
-		for( int i = 0; i < zeichenAnzahl; ++i )
-		{
-			outF->write( (char*)&zeichen[ i ], 1 );
-			outF->write( (char*)&pos[ i ], 4 );
-		}
-	}
+    if( outF->good() && outF->is_open() )
+    {
+        outF->write( (char*)&schriftGröße, 1 );
+        outF->write( (char*)&zeichenAnzahl, 1 );
+        for( int i = 0; i < zeichenAnzahl; ++i )
+        {
+            outF->write( (char*)&zeichen[ i ], 1 );
+            outF->write( (char*)&pos[ i ], 4 );
+        }
+    }
 }
 
 unsigned char LTDSSchriftKopf::getSchriftGröße() const // gibt die Schriftgröße zurück
 {
-	return schriftGröße;
+    return schriftGröße;
 }
 
 unsigned char LTDSSchriftKopf::getZeichenAnzahl() const // gibt die Zeichenanzahl zurück
 {
-	return zeichenAnzahl;
+    return zeichenAnzahl;
 }
 
 int *LTDSSchriftKopf::getPositionen() const // gibt die Zeichenpositionen zurück
 {
-	return pos;
+    return pos;
 }
 
 unsigned char *LTDSSchriftKopf::getZeichen() const // gibt die zeichen zurück
 {
-	return zeichen;
+    return zeichen;
 }
 
 // Reference Counting 
 LTDSSchriftKopf *LTDSSchriftKopf::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSSchriftKopf *LTDSSchriftKopf::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDSBuchstabenKopf Klasse aus Dateisystem.h
 // Konstruktor 
 LTDSBuchstabenKopf::LTDSBuchstabenKopf()
-	: ref( 1 ),
-	  zeichen( 0 ),
-	  größe( 0, 0 )
-{
-}
+    : ref( 1 ),
+    zeichen( 0 ),
+    größe( 0, 0 )
+{}
 
 // nicht constant 
 void LTDSBuchstabenKopf::laden( std::ifstream *inF ) // lät aus inF
 {
-	if( inF->good() && inF->is_open() )
-	{
-		inF->read( (char*)&zeichen, 1 );
-		inF->read( (char*)&größe.x, 1 );
-		inF->read( (char*)&größe.y, 1 );
-	}
+    if( inF->good() && inF->is_open() )
+    {
+        inF->read( (char*)&zeichen, 1 );
+        inF->read( (char*)&größe.x, 1 );
+        inF->read( (char*)&größe.y, 1 );
+    }
 }
 
 void LTDSBuchstabenKopf::init( unsigned char zeichen, const Punkt &größe ) // initialisierung( für speichern )
 {
-	this->zeichen = zeichen;
-	this->größe = größe;
+    this->zeichen = zeichen;
+    this->größe = größe;
 }
 
 void LTDSBuchstabenKopf::init( unsigned char zeichen, int br, int hö )
 {
-	this->zeichen = zeichen;
-	größe.x = br, größe.y = hö;
+    this->zeichen = zeichen;
+    größe.x = br, größe.y = hö;
 }
 
 // constant 
 void LTDSBuchstabenKopf::speichern( std::ofstream *outF ) const // speichertn nach outF
 {
-	if( outF->good() && outF->is_open() )
-	{
-		outF->write( (char*)&zeichen, 1 );
-		outF->write( (char*)&größe.x, 1 );
-		outF->write( (char*)&größe.y, 1 );
-	}
+    if( outF->good() && outF->is_open() )
+    {
+        outF->write( (char*)&zeichen, 1 );
+        outF->write( (char*)&größe.x, 1 );
+        outF->write( (char*)&größe.y, 1 );
+    }
 }
 
 unsigned char LTDSBuchstabenKopf::getZeichen() const // gibt das Zeichen zurück
 {
-	return zeichen;
+    return zeichen;
 }
 
 int LTDSBuchstabenKopf::getBreite() const // gibt die Breite zurück
 {
-	return größe.x;
+    return größe.x;
 }
 
 int LTDSBuchstabenKopf::getHöhe() const // gibt die höhe zurück
 {
-	return größe.y;
+    return größe.y;
 }
 
 const Punkt &LTDSBuchstabenKopf::getGröße() const // gibt die Größe zurück
 {
-	return größe;
+    return größe;
 }
 
 // Reference Counting 
 LTDSBuchstabenKopf *LTDSBuchstabenKopf::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSBuchstabenKopf *LTDSBuchstabenKopf::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDSBuchstabenKörper Klasse aus Dateisystem.h
 // Konstruktor 
 LTDSBuchstabenKörper::LTDSBuchstabenKörper( LTDSBuchstabenKopf *kopf )
-	: ref( 1 ),
-	größe( kopf->getGröße() ),
-	zeichen( kopf->getZeichen() ),
-	buchstabe( new Buchstabe() )
+    : ref( 1 ),
+    größe( kopf->getGröße() ),
+    zeichen( kopf->getZeichen() ),
+    buchstabe( new Buchstabe() )
 {
-	buchstabe->NeuBuchstabe( größe );
-	kopf->release();
+    buchstabe->NeuBuchstabe( größe );
+    kopf->release();
 }
 
 // Destruktor 
 LTDSBuchstabenKörper::~LTDSBuchstabenKörper()
 {
-	if( buchstabe )
-		buchstabe->release();
+    if( buchstabe )
+        buchstabe->release();
 }
 
 // nicht constant 
 void LTDSBuchstabenKörper::setBuchstabe( Buchstabe *zeichen ) // setzt den Buchstaben
 {
-	if( buchstabe )
-		buchstabe->release();
-	buchstabe = zeichen;
+    if( buchstabe )
+        buchstabe->release();
+    buchstabe = zeichen;
 }
 
 void LTDSBuchstabenKörper::laden( std::ifstream *inF ) // Läht aus inF
 {
-	if( inF->good() && inF->is_open() )
-	{
-		LTDSPixel *vorher = 0;
-		LTDSPixel *jetzt = new LTDSPixel( vorher );
-		char byte = 0;
-		int beg = 0;
-		int ende = -1;
-		for( int i = 0; i < größe.x * größe.y; ++i )
-		{
-			if( !jetzt ) // wenn es nicht der erste Pixel ist
-				jetzt = new LTDSPixel( vorher->getThis() );
-			int ende = -1;
-			while( ende < 0 ) // Pixel laden
-			{
-				if( beg == 0 )
-					inF->read( &byte, 1 );
-				ende = jetzt->addByte( byte, beg ); // byte auswerten
-				beg = 0;
-			}
-			beg = ende;
-			if( beg == 8 )
-				beg = 0;
-			if( buchstabe )
-				buchstabe->setPixel( i, jetzt->getA() );
-			if( vorher )
-				vorher = vorher->release();
-			vorher = jetzt->getThis();
-			jetzt = jetzt->release();
-		}
-		if( vorher )
-			vorher->release();
-		if( jetzt )
-			jetzt->release();
-	}
+    if( inF->good() && inF->is_open() )
+    {
+        LTDSPixel *vorher = 0;
+        LTDSPixel *jetzt = new LTDSPixel( vorher );
+        char byte = 0;
+        int beg = 0;
+        int ende = -1;
+        for( int i = 0; i < größe.x * größe.y; ++i )
+        {
+            if( !jetzt ) // wenn es nicht der erste Pixel ist
+                jetzt = new LTDSPixel( vorher->getThis() );
+            int ende = -1;
+            while( ende < 0 ) // Pixel laden
+            {
+                if( beg == 0 )
+                    inF->read( &byte, 1 );
+                ende = jetzt->addByte( byte, beg ); // byte auswerten
+                beg = 0;
+            }
+            beg = ende;
+            if( beg == 8 )
+                beg = 0;
+            if( buchstabe )
+                buchstabe->setPixel( i, jetzt->getA() );
+            if( vorher )
+                vorher = vorher->release();
+            vorher = jetzt->getThis();
+            jetzt = jetzt->release();
+        }
+        if( vorher )
+            vorher->release();
+        if( jetzt )
+            jetzt->release();
+    }
 }
 
 // constant 
 void LTDSBuchstabenKörper::speichern( std::ofstream *outF ) const // speichert nach outF
 {
-	if( outF->good() && outF->is_open() )
-	{
-		LTDSPixel *vorher = 0; // Letzter gespeicherter Pixel
-		LTDSPixel *jetzt = new LTDSPixel( 0 ); // Der momentan zu speichernde Pixel
-		int begin = 0, ende = 0; // Pixelbeginn, endposition in der byte variable
-		char byte = 0; // Der nächste byte der Datei
-		bool w = 0;
-		unsigned char *alphaBuff = buchstabe->getBuff();
-		for( int i = 0; i < größe.x * größe.y; ++i ) // für jeden Pixel
-		{
-			if( !jetzt ) // wenn es nicht der erste Pixel ist
-				jetzt = new LTDSPixel( vorher->getThis() );
-			jetzt->setAlpha( alphaBuff[ i ] ); // Farbe des Pixels setzen
-			jetzt->Komp(); // Pixel komprimieren
-			ende = -1;
-			while( ende < 0 ) // byte befüllen
-			{
-				ende = jetzt->getNextByte( byte, begin );
-				begin = 0;
-				w = 0;
-				if( ende == -1 || ende == 8 ) // byte speichern
-				{
-					outF->write( &byte, 1 );
-					w = 1;
-					byte = 0;
-				}
-			} // Pixel fertig
-			begin = ende;
-			if( begin == 8 )
-				begin = 0;
-			if( vorher )
-				vorher->release();
-			vorher = jetzt->getThis(); // dieser wird zu letzter
-			jetzt = jetzt->release();
-		}
-		if( vorher )
-			vorher = vorher->release();
-		if( !w )
-		{
-			outF->write( &byte, 1 ); // Das letzte byte speichern
-		}
-		outF->flush(); // dateistream speichern
-	}
+    if( outF->good() && outF->is_open() )
+    {
+        LTDSPixel *vorher = 0; // Letzter gespeicherter Pixel
+        LTDSPixel *jetzt = new LTDSPixel( 0 ); // Der momentan zu speichernde Pixel
+        int begin = 0, ende = 0; // Pixelbeginn, endposition in der byte variable
+        char byte = 0; // Der nächste byte der Datei
+        bool w = 0;
+        unsigned char *alphaBuff = buchstabe->getBuff();
+        for( int i = 0; i < größe.x * größe.y; ++i ) // für jeden Pixel
+        {
+            if( !jetzt ) // wenn es nicht der erste Pixel ist
+                jetzt = new LTDSPixel( vorher->getThis() );
+            jetzt->setAlpha( alphaBuff[ i ] ); // Farbe des Pixels setzen
+            jetzt->Komp(); // Pixel komprimieren
+            ende = -1;
+            while( ende < 0 ) // byte befüllen
+            {
+                ende = jetzt->getNextByte( byte, begin );
+                begin = 0;
+                w = 0;
+                if( ende == -1 || ende == 8 ) // byte speichern
+                {
+                    outF->write( &byte, 1 );
+                    w = 1;
+                    byte = 0;
+                }
+            } // Pixel fertig
+            begin = ende;
+            if( begin == 8 )
+                begin = 0;
+            if( vorher )
+                vorher->release();
+            vorher = jetzt->getThis(); // dieser wird zu letzter
+            jetzt = jetzt->release();
+        }
+        if( vorher )
+            vorher = vorher->release();
+        if( !w )
+        {
+            outF->write( &byte, 1 ); // Das letzte byte speichern
+        }
+        outF->flush(); // dateistream speichern
+    }
 }
 
 Buchstabe *LTDSBuchstabenKörper::getBuchstabe() const // gibt den Buchstaben zurück
 {
-	return buchstabe->getThis();
+    return buchstabe->getThis();
 }
 
 unsigned char LTDSBuchstabenKörper::getZeichen() const // gibt das Zeichen zurück
 {
-	return zeichen;
+    return zeichen;
 }
 
 // Reference Counting 
 LTDSBuchstabenKörper *LTDSBuchstabenKörper::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSBuchstabenKörper *LTDSBuchstabenKörper::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der LTDSDatei Klasse aus DAteisystem.h
 // Konstruktor 
 LTDSDatei::LTDSDatei()
-	: ref( 1 ),
-	  pfad( new Text() ),
-	  dateiKopf( 0 )
-{
-}
+    : ref( 1 ),
+    pfad( new Text() ),
+    dateiKopf( 0 )
+{}
 
 // Destruktor 
 LTDSDatei::~LTDSDatei()
 {
-	if( dateiKopf )
-		dateiKopf->release();
-	pfad->release();
+    if( dateiKopf )
+        dateiKopf->release();
+    pfad->release();
 }
 
 // nicht constant 
 void LTDSDatei::setPfad( Text *txt ) // setzt den Pfad zur Datei
 {
-	if( dateiKopf )
-		dateiKopf = dateiKopf->release();
-	pfad->setText( txt->getText() );
-	txt->release();
+    if( dateiKopf )
+        dateiKopf = dateiKopf->release();
+    pfad->setText( txt->getText() );
+    txt->release();
 }
 
 void LTDSDatei::leseDaten() // ließt den Dateikopf
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return;
-	if( dateiKopf )
-		dateiKopf->release();
-	dateiKopf = new LTDSDateiKopf();
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-	dateiKopf->laden( inF );
-	inF->close();
-	delete inF;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return;
+    if( dateiKopf )
+        dateiKopf->release();
+    dateiKopf = new LTDSDateiKopf();
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+    dateiKopf->laden( inF );
+    inF->close();
+    delete inF;
 }
 
 void LTDSDatei::addSchriftgröße( Alphabet *alphabet ) // fügt eine Schriftgröße hinzu
 {
-	if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob die Datei existiert
-		return;
-	if( !dateiKopf ) // prüfen, ob der Dateikopf schon gelesen wurde
-		leseDaten();
-	int sgröße = alphabet->getSchriftgröße(); // Schriftgröße die hinzugefügt werden soll
-	unsigned char *sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen Schriftgrößen
-	unsigned char sganzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der bereits vorhandenen Schriftgrößen
-	for( int i = 0; i < sganzahl; ++i ) // prüfen, ob die Schriftgröße bereits existiert
-	{
-		if( sglist[ i ] == sgröße )
-		{
-			alphabet->release();
-			return;
-		}
-	}
-	dateiKopf->addSG( sgröße ); // Schriftgröße dem Dateikopf hinzufügen
-	int *sgPosList = dateiKopf->getPositionList(); // Liste mit positionen der Schriftgrößen
-	sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen Schriftgrößen
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
-	pfad->anhängen( "0" );
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
-	dateiKopf->speichern( outF ); // Dateikopf in neue datei speichern
-	inF->seekg( 1 + 5 * sganzahl, std::ios::beg ); // Position der ersten Schriftgröße in der alten Datei
-	for( int i = 0; i < sganzahl; ++i ) // Buchstabenpositionen aller Schriftgrößen aktualisieren
-	{
-		LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
-		sgKpf_tmp->laden( inF ); // aus alter Datei laden
-		int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
-		unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
-		for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
-			zeichP_tmp[ i1 ] += 5; // Buchstabenpositionen aktualisieren
-		sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
-		int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
-		int endByte = sgPosList[ i + 1 ];
-		if( !endByte )
-		{
-			inF->seekg( 0, std::ios::end );
-			endByte = (int)inF->tellg();
-			inF->seekg( beginByte, std::ios::beg );
-		}
-		char byte;
-		for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
-		{
-			inF->read( &byte, 1 );
-			outF->write( &byte, 1 );
-		}
-		sgKpf_tmp->release();
-	}
-	inF->close(); // Alte datei schließen
-	sgPosList[ sganzahl ] = (int)outF->tellp();
-	outF->seekp( 0, std::ios::beg );
-	for( int i = 0; i < sganzahl; ++i ) // Positionen im Dateikopf aktualisieren
-		sgPosList[ i ] += 5;
-	dateiKopf->speichern( outF ); // aktualisierter Dateikopf speichern
-	outF->seekp( sgPosList[ sganzahl ], std::ios::beg );
-	LTDSSchriftKopf *sgkopf = new LTDSSchriftKopf(); // Kopf der neuen Schriftgröße
-	sgkopf->setZeichenAlphabet( alphabet->getThis() ); // Kopf der Schriftgröße initialisieren
-	sgkopf->speichern( outF ); // Kopf der Schriftgröße speichern
-	int *BuchstabenPosList = sgkopf->getPositionen(); // positionen der verschiedenen Zeichen in der Datei( nuch 0 )
-	int count = 0;
-	for( int i = 0; i < 256; ++i )
-	{
-		Buchstabe *zeich = alphabet->getBuchstabe( i );
-		if( zeich )
-		{
-			BuchstabenPosList[ count ] = (int)outF->tellp(); // position des Zeichens setzen
-			LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
-			zeichKpf->init( i, zeich->getBreite(), zeich->getHöhe() );
-			zeichKpf->speichern( outF ); // Zeichenkopf speichern
-			LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Zeichenkörper
-			zeichKpf->release();
-			zeichKörp->setBuchstabe( zeich->getThis() );
-			zeichKörp->speichern( outF ); // Zeichenkörper speichern
-			zeich->release();
-			++count;
-		}
-	}
-	outF->seekp( sgPosList[ sganzahl ], std::ios::beg );
-	sgkopf->speichern( outF ); // aktualisierter Schriftgrößen Kopf speichern
-	outF->close();
-	Text *pfad2 = new Text();
-	pfad2->setText( pfad->getText() );
-	pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
-	DateiLöschen( pfad->getThis() ); // Alte datei Löschen
-	DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei nach alte umbenennen
-	pfad2->release(); // Speicher freigeben
-	sgkopf->release();
-	delete inF;
-	delete outF;
-	alphabet->release();
+    if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob die Datei existiert
+        return;
+    if( !dateiKopf ) // prüfen, ob der Dateikopf schon gelesen wurde
+        leseDaten();
+    int sgröße = alphabet->getSchriftgröße(); // Schriftgröße die hinzugefügt werden soll
+    unsigned char *sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen Schriftgrößen
+    unsigned char sganzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der bereits vorhandenen Schriftgrößen
+    for( int i = 0; i < sganzahl; ++i ) // prüfen, ob die Schriftgröße bereits existiert
+    {
+        if( sglist[ i ] == sgröße )
+        {
+            alphabet->release();
+            return;
+        }
+    }
+    dateiKopf->addSG( sgröße ); // Schriftgröße dem Dateikopf hinzufügen
+    int *sgPosList = dateiKopf->getPositionList(); // Liste mit positionen der Schriftgrößen
+    sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen Schriftgrößen
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
+    pfad->anhängen( "0" );
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
+    dateiKopf->speichern( outF ); // Dateikopf in neue datei speichern
+    inF->seekg( 1 + 5 * sganzahl, std::ios::beg ); // Position der ersten Schriftgröße in der alten Datei
+    for( int i = 0; i < sganzahl; ++i ) // Buchstabenpositionen aller Schriftgrößen aktualisieren
+    {
+        LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
+        sgKpf_tmp->laden( inF ); // aus alter Datei laden
+        int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
+        unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
+        for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
+            zeichP_tmp[ i1 ] += 5; // Buchstabenpositionen aktualisieren
+        sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
+        int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
+        int endByte = sgPosList[ i + 1 ];
+        if( !endByte )
+        {
+            inF->seekg( 0, std::ios::end );
+            endByte = (int)inF->tellg();
+            inF->seekg( beginByte, std::ios::beg );
+        }
+        char byte;
+        for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
+        {
+            inF->read( &byte, 1 );
+            outF->write( &byte, 1 );
+        }
+        sgKpf_tmp->release();
+    }
+    inF->close(); // Alte datei schließen
+    sgPosList[ sganzahl ] = (int)outF->tellp();
+    outF->seekp( 0, std::ios::beg );
+    for( int i = 0; i < sganzahl; ++i ) // Positionen im Dateikopf aktualisieren
+        sgPosList[ i ] += 5;
+    dateiKopf->speichern( outF ); // aktualisierter Dateikopf speichern
+    outF->seekp( sgPosList[ sganzahl ], std::ios::beg );
+    LTDSSchriftKopf *sgkopf = new LTDSSchriftKopf(); // Kopf der neuen Schriftgröße
+    sgkopf->setZeichenAlphabet( alphabet->getThis() ); // Kopf der Schriftgröße initialisieren
+    sgkopf->speichern( outF ); // Kopf der Schriftgröße speichern
+    int *BuchstabenPosList = sgkopf->getPositionen(); // positionen der verschiedenen Zeichen in der Datei( nuch 0 )
+    int count = 0;
+    for( int i = 0; i < 256; ++i )
+    {
+        Buchstabe *zeich = alphabet->getBuchstabe( i );
+        if( zeich )
+        {
+            BuchstabenPosList[ count ] = (int)outF->tellp(); // position des Zeichens setzen
+            LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
+            zeichKpf->init( i, zeich->getBreite(), zeich->getHöhe() );
+            zeichKpf->speichern( outF ); // Zeichenkopf speichern
+            LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Zeichenkörper
+            zeichKpf->release();
+            zeichKörp->setBuchstabe( zeich->getThis() );
+            zeichKörp->speichern( outF ); // Zeichenkörper speichern
+            zeich->release();
+            ++count;
+        }
+    }
+    outF->seekp( sgPosList[ sganzahl ], std::ios::beg );
+    sgkopf->speichern( outF ); // aktualisierter Schriftgrößen Kopf speichern
+    outF->close();
+    Text *pfad2 = new Text();
+    pfad2->setText( pfad->getText() );
+    pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
+    DateiLöschen( pfad->getThis() ); // Alte datei Löschen
+    DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei nach alte umbenennen
+    pfad2->release(); // Speicher freigeben
+    sgkopf->release();
+    delete inF;
+    delete outF;
+    alphabet->release();
 }
 
 void LTDSDatei::addBuchstabe( int gr, Buchstabe *zeich, unsigned char zeichen ) // Fügt einer Schriftgröße einen Buchstaben hinzu
 {
-	if( !DateiExistiert( pfad->getThis() ) ) // prüfen ob Datei existiert
-	{
-		zeich->release();
-		return;
-	}
-	if( !dateiKopf ) // prüfen, ob der DAteikopf geladen wurde
-		leseDaten();
-	unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen aus der Datei
-	int *sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgrößen positionen aus Datei
-	unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl von Schriftgrößen aus der Datei
-	int sgNum = -1;
-	for( int i = 0; i < sgAnzahl; ++i ) // Position der richtigen Schriftgröße ermitteln
-	{
-		if( sgList[ i ] == gr )
-		{
-			sgNum = i;
-			break;
-		}
-	}
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // Alte Datei
-	pfad->anhängen( "0" );
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // Neue Datei
-	inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
-	if( sgNum == -1 ) // Die Schriftgröße existiert noch nicht und wird erstellt
-	{
-		dateiKopf->addSG( gr ); // Schriftgröße dem Dateikopf hinzufügen
-		sgPosList = dateiKopf->getPositionList();
-		sgList = dateiKopf->getSchriftGrößeList();
-		dateiKopf->speichern( outF ); // Dateikopf speichern
-		inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg ); // Position der ersten Schriftgröße in der alten Datei
-		for( int i = 0; i < sgAnzahl; ++i ) // Buchstabenpositionen aller Schriftgrößen aktualisieren
-		{
-			LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
-			sgKpf_tmp->laden( inF ); // aus alter Datei laden
-			int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
-			unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
-			for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
-				zeichP_tmp[ i1 ] += 5; // Buchstabenpositionen aktualisieren
-			sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
-			int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
-			int endByte = sgPosList[ i + 1 ];
-			if( i + 1 >= sgAnzahl )
-			{
-				inF->seekg( 0, std::ios::end );
-				endByte = (int)inF->tellg();
-				inF->seekg( beginByte, std::ios::beg );
-			}
-			char byte;
-			for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
-			{
-				inF->read( &byte, 1 );
-				outF->write( &byte, 1 );
-			}
-			sgKpf_tmp->release();
-		}
-		sgPosList[ sgAnzahl ] = (int)outF->tellp();
-		outF->seekp( 0, std::ios::beg );
-		for( int i = 0; i < sgAnzahl; ++i ) // Positionen im Dateikopf aktualisieren
-			sgPosList[ i ] += 5;
-		dateiKopf->speichern( outF ); // aktualisierter Dateikopf speichern
-		outF->seekp( sgPosList[ sgAnzahl ], std::ios::beg );
-		LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf initialisiern
-		sgKpf->setSchriftgröße( gr );
-		sgKpf->addZeichen( zeichen );
-		sgKpf->getPositionen()[ 0 ] = (int)outF->tellp() + 7;
-		sgKpf->speichern( outF ); // Schriftgröße Kopf speichern
-		sgKpf->release();
-		LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Buchstabenkopf
-		zeichKpf->init( zeichen, zeich->getGröße() );
-		zeichKpf->speichern( outF ); // Buchstabenkopf speichern
-		LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Buchstabenkörper
-		zeichKpf->release();
-		zeichKörp->setBuchstabe( zeich->getThis() );
-		zeichKörp->speichern( outF ); // Buchstabenkörper speichern
-		zeichKörp->release();
-	}
-	else
-	{
-		dateiKopf->speichern( outF ); // Dateikopf speichern
-		int beginByte = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
-		int endByte = sgPosList[ sgNum ];
-		char byte;
-		for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang bis zur angegebenen größe
-		{
-			inF->read( &byte, 1 );
-			outF->write( &byte, 1 );
-		}
-		LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf
-		sgKpf->laden( inF );
-		for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
-			sgKpf->getPositionen()[ i ] += 5;
-		sgKpf->addZeichen( zeichen );
-		int indexPlus = 5;
-		int zeichenPos = sgPosList[ sgNum + 1 ]; // position des neuen Zeichens
-		if( sgNum + 1 >= sgAnzahl )
-		{
-			int tmp = (int)inF->tellg();
-			inF->seekg( 0, std::ios::end );
-			zeichenPos = (int)inF->tellg();
-			inF->seekg( tmp, std::ios::beg );
-		}
-		zeichenPos += indexPlus;
-		sgKpf->getPositionen()[ sgKpf->getZeichenAnzahl() - 1 ] = zeichenPos;
-		sgKpf->speichern( outF ); // Schriftgröße Kopf speichern
-		sgKpf->release();
-		for( int i = (int)inF->tellg() + indexPlus; i < zeichenPos; ++i ) // Kopiervorgang bis zum Zeichenbeginn
-		{
-			inF->read( &byte, 1 );
-			outF->write( &byte, 1 );
-		}
-		LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
-		zeichKpf->init( zeichen, zeich->getGröße() );
-		zeichKpf->speichern( outF ); // Zeichenkopf speichern
-		LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Zeichenkörper
-		zeichKpf->release();
-		zeichKörp->setBuchstabe( zeich->getThis() );
-		zeichKörp->speichern( outF ); // Zeichenkörper speichern
-		zeichKörp->release();
-		int nowPos = (int)outF->tellp();
-		indexPlus += nowPos - zeichenPos;
-		for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Dateikopf aktualisieren
-			sgPosList[ i ] += indexPlus;
-		outF->seekp( 0, std::ios::beg );
-		dateiKopf->speichern( outF ); // Dateikopf speichern
-		outF->seekp( nowPos, std::ios::beg );
-		for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Restliche Schriftgrößen aktualisieren
-		{
-			LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
-			sgKpf_tmp->laden( inF ); // aus alter Datei laden
-			int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
-			unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
-			for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
-				zeichP_tmp[ i1 ] += indexPlus; // Buchstabenpositionen aktualisieren
-			sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
-			int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
-			int endByte = sgPosList[ i + 1 ];
-			if( i + 1 >= sgAnzahl )
-			{
-				inF->seekg( 0, std::ios::end );
-				endByte = (int)inF->tellg();
-				inF->seekg( beginByte, std::ios::beg );
-			}
-			char byte;
-			for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
-			{
-				inF->read( &byte, 1 );
-				outF->write( &byte, 1 );
-			}
-			sgKpf_tmp->release();
-		}
-	}
-	inF->close();
-	outF->close();
-	Text *pfad2 = new Text( pfad->getText() );
-	pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
-	DateiLöschen( pfad->getThis() ); // Alte Datei löschen
-	DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // Neue Datei in alte umbenennen
-	pfad2->release();// Speicher freigeben
-	delete inF;
-	delete outF;
-	zeich->release();
+    if( !DateiExistiert( pfad->getThis() ) ) // prüfen ob Datei existiert
+    {
+        zeich->release();
+        return;
+    }
+    if( !dateiKopf ) // prüfen, ob der DAteikopf geladen wurde
+        leseDaten();
+    unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen aus der Datei
+    int *sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgrößen positionen aus Datei
+    unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl von Schriftgrößen aus der Datei
+    int sgNum = -1;
+    for( int i = 0; i < sgAnzahl; ++i ) // Position der richtigen Schriftgröße ermitteln
+    {
+        if( sgList[ i ] == gr )
+        {
+            sgNum = i;
+            break;
+        }
+    }
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // Alte Datei
+    pfad->anhängen( "0" );
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // Neue Datei
+    inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
+    if( sgNum == -1 ) // Die Schriftgröße existiert noch nicht und wird erstellt
+    {
+        dateiKopf->addSG( gr ); // Schriftgröße dem Dateikopf hinzufügen
+        sgPosList = dateiKopf->getPositionList();
+        sgList = dateiKopf->getSchriftGrößeList();
+        dateiKopf->speichern( outF ); // Dateikopf speichern
+        inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg ); // Position der ersten Schriftgröße in der alten Datei
+        for( int i = 0; i < sgAnzahl; ++i ) // Buchstabenpositionen aller Schriftgrößen aktualisieren
+        {
+            LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
+            sgKpf_tmp->laden( inF ); // aus alter Datei laden
+            int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
+            unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
+            for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
+                zeichP_tmp[ i1 ] += 5; // Buchstabenpositionen aktualisieren
+            sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
+            int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
+            int endByte = sgPosList[ i + 1 ];
+            if( i + 1 >= sgAnzahl )
+            {
+                inF->seekg( 0, std::ios::end );
+                endByte = (int)inF->tellg();
+                inF->seekg( beginByte, std::ios::beg );
+            }
+            char byte;
+            for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
+            {
+                inF->read( &byte, 1 );
+                outF->write( &byte, 1 );
+            }
+            sgKpf_tmp->release();
+        }
+        sgPosList[ sgAnzahl ] = (int)outF->tellp();
+        outF->seekp( 0, std::ios::beg );
+        for( int i = 0; i < sgAnzahl; ++i ) // Positionen im Dateikopf aktualisieren
+            sgPosList[ i ] += 5;
+        dateiKopf->speichern( outF ); // aktualisierter Dateikopf speichern
+        outF->seekp( sgPosList[ sgAnzahl ], std::ios::beg );
+        LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf initialisiern
+        sgKpf->setSchriftgröße( gr );
+        sgKpf->addZeichen( zeichen );
+        sgKpf->getPositionen()[ 0 ] = (int)outF->tellp() + 7;
+        sgKpf->speichern( outF ); // Schriftgröße Kopf speichern
+        sgKpf->release();
+        LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Buchstabenkopf
+        zeichKpf->init( zeichen, zeich->getGröße() );
+        zeichKpf->speichern( outF ); // Buchstabenkopf speichern
+        LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Buchstabenkörper
+        zeichKpf->release();
+        zeichKörp->setBuchstabe( zeich->getThis() );
+        zeichKörp->speichern( outF ); // Buchstabenkörper speichern
+        zeichKörp->release();
+    }
+    else
+    {
+        dateiKopf->speichern( outF ); // Dateikopf speichern
+        int beginByte = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
+        int endByte = sgPosList[ sgNum ];
+        char byte;
+        for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang bis zur angegebenen größe
+        {
+            inF->read( &byte, 1 );
+            outF->write( &byte, 1 );
+        }
+        LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf
+        sgKpf->laden( inF );
+        for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
+            sgKpf->getPositionen()[ i ] += 5;
+        sgKpf->addZeichen( zeichen );
+        int indexPlus = 5;
+        int zeichenPos = sgPosList[ sgNum + 1 ]; // position des neuen Zeichens
+        if( sgNum + 1 >= sgAnzahl )
+        {
+            int tmp = (int)inF->tellg();
+            inF->seekg( 0, std::ios::end );
+            zeichenPos = (int)inF->tellg();
+            inF->seekg( tmp, std::ios::beg );
+        }
+        zeichenPos += indexPlus;
+        sgKpf->getPositionen()[ sgKpf->getZeichenAnzahl() - 1 ] = zeichenPos;
+        sgKpf->speichern( outF ); // Schriftgröße Kopf speichern
+        sgKpf->release();
+        for( int i = (int)inF->tellg() + indexPlus; i < zeichenPos; ++i ) // Kopiervorgang bis zum Zeichenbeginn
+        {
+            inF->read( &byte, 1 );
+            outF->write( &byte, 1 );
+        }
+        LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
+        zeichKpf->init( zeichen, zeich->getGröße() );
+        zeichKpf->speichern( outF ); // Zeichenkopf speichern
+        LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() ); // Zeichenkörper
+        zeichKpf->release();
+        zeichKörp->setBuchstabe( zeich->getThis() );
+        zeichKörp->speichern( outF ); // Zeichenkörper speichern
+        zeichKörp->release();
+        int nowPos = (int)outF->tellp();
+        indexPlus += nowPos - zeichenPos;
+        for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Dateikopf aktualisieren
+            sgPosList[ i ] += indexPlus;
+        outF->seekp( 0, std::ios::beg );
+        dateiKopf->speichern( outF ); // Dateikopf speichern
+        outF->seekp( nowPos, std::ios::beg );
+        for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Restliche Schriftgrößen aktualisieren
+        {
+            LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
+            sgKpf_tmp->laden( inF ); // aus alter Datei laden
+            int *zeichP_tmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
+            unsigned char zeichA_tmp = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
+            for( int i1 = 0; i1 < zeichA_tmp; ++i1 )
+                zeichP_tmp[ i1 ] += indexPlus; // Buchstabenpositionen aktualisieren
+            sgKpf_tmp->speichern( outF ); // Schriftgröße Kopf in neue Datei speichern
+            int beginByte = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten Schriftgröße in neue Datei kopieren
+            int endByte = sgPosList[ i + 1 ];
+            if( i + 1 >= sgAnzahl )
+            {
+                inF->seekg( 0, std::ios::end );
+                endByte = (int)inF->tellg();
+                inF->seekg( beginByte, std::ios::beg );
+            }
+            char byte;
+            for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopiervorgang
+            {
+                inF->read( &byte, 1 );
+                outF->write( &byte, 1 );
+            }
+            sgKpf_tmp->release();
+        }
+    }
+    inF->close();
+    outF->close();
+    Text *pfad2 = new Text( pfad->getText() );
+    pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
+    DateiLöschen( pfad->getThis() ); // Alte Datei löschen
+    DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // Neue Datei in alte umbenennen
+    pfad2->release();// Speicher freigeben
+    delete inF;
+    delete outF;
+    zeich->release();
 }
 
 void LTDSDatei::löscheSchrifrGröße( int gr ) // Löscht eine Schriftgröße aus der Datei
 {
-	if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob Datei existiert
-		return;
-	if( !dateiKopf ) // prüfen, ob der Dateikopf geladen wurde
-		leseDaten();
-	unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
-	unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
-	int sgNum = -1;
-	for( int i = 0; i < sgAnzahl; ++i ) // zu löschende Schriftgröße suchen
-	{
-		if( sgList[ i ] == gr )
-		{
-			sgNum = i;
-			break;
-		}
-	}
-	if( sgNum == -1 ) // Die Schriftgröße ist nicht vorhanden
-		return;
-	int *sgPosList = dateiKopf->getPositionList();  // Liste von Positionen der Schriftgrößen
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
-	pfad->anhängen( "0" );
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
-	outF->seekp( 1 + 5 * ( sgAnzahl - 1 ), std::ios::beg );
-	inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
-	for( int i = 0; i < sgNum; ++i ) // Schriftgrößen vor der zu löschenden Schriftgröße aktualisieren
-	{
-		LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
-		sgKpf_tmp->laden( inF ); // Schriftgrößen Kopf laden
-		int *zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
-		unsigned char zeichATmp = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
-		for( int i1 = 0; i1 < zeichATmp; ++i1 ) // Position der Zeichen um 5 bytes zurücksetzen
-			zeichPosLTmp[ i1 ] -= 5;
-		sgKpf_tmp->speichern( outF ); // speichern in Neue Datei
-		char byte = 0;
-		for( int i1 = (int)inF->tellg(); i1 < sgPosList[ i + 1 ]; ++i1 ) // Den Körper des Zeichens Kopieren
-		{
-			inF->read( &byte, 1 );
-			outF->write( &byte, 1 );
-		}
-		sgKpf_tmp->release();
-	}
-	int indexMinus = 5 + sgPosList[ sgNum + 1 ] - (int)inF->tellg();
-	inF->seekg( sgPosList[ sgNum + 1 ], std::ios::beg );
-	for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Die Schriftgröße nach der zu löschenden Schriftgröße
-	{
-		LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
-		sgKpf_tmp->laden( inF ); // Schriftgrößen Kopf laden
-		int *zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
-		unsigned char zeichATmp = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
-		for( int i1 = 0; i1 < zeichATmp; ++i1 ) // Position der Zeichen aktualisieren
-			zeichPosLTmp[ i1 ] -= indexMinus;
-		sgKpf_tmp->speichern( outF ); // speichern in Neue Datei
-		char byte = 0;
-		int BeginByte = (int)inF->tellg();
-		int EndByte = sgPosList[ i + 1 ];
-		if( !EndByte )
-		{
-			inF->seekg( 0, std::ios::end );
-			EndByte = (int)inF->tellg();
-			inF->seekg( BeginByte, std::ios::beg );
-		}
-		for( int i1 = BeginByte; i1 < EndByte; ++i1 ) // Den Körper des Zeichens Kopieren
-		{
-			inF->read( &byte, 1 );
-			outF->write( &byte, 1 );
-		}
-	}
-	for( int i = 0; i < sgNum; ++i ) // Dateikopf aktualisieren
-		sgPosList[ i ] -= 5;
-	for( int i = sgNum + 1; i < sgAnzahl; ++i )
-		sgPosList[ i ] -= indexMinus;
-	dateiKopf->removeSG( gr );
-	outF->seekp( 0, std::ios::beg );
-	dateiKopf->speichern( outF ); // Dateikopf speichern
-	inF->close();
-	outF->close();
-	Text *pfad2 = new Text( pfad->getText() );
-	pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
-	DateiLöschen( pfad->getThis() ); // alte Datei löschen
-	DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei zu alter umbenennen
-	pfad2->release();
-	delete inF;
-	delete outF;
+    if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob Datei existiert
+        return;
+    if( !dateiKopf ) // prüfen, ob der Dateikopf geladen wurde
+        leseDaten();
+    unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
+    unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
+    int sgNum = -1;
+    for( int i = 0; i < sgAnzahl; ++i ) // zu löschende Schriftgröße suchen
+    {
+        if( sgList[ i ] == gr )
+        {
+            sgNum = i;
+            break;
+        }
+    }
+    if( sgNum == -1 ) // Die Schriftgröße ist nicht vorhanden
+        return;
+    int *sgPosList = dateiKopf->getPositionList();  // Liste von Positionen der Schriftgrößen
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
+    pfad->anhängen( "0" );
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
+    outF->seekp( 1 + 5 * ( sgAnzahl - 1 ), std::ios::beg );
+    inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
+    for( int i = 0; i < sgNum; ++i ) // Schriftgrößen vor der zu löschenden Schriftgröße aktualisieren
+    {
+        LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
+        sgKpf_tmp->laden( inF ); // Schriftgrößen Kopf laden
+        int *zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
+        unsigned char zeichATmp = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
+        for( int i1 = 0; i1 < zeichATmp; ++i1 ) // Position der Zeichen um 5 bytes zurücksetzen
+            zeichPosLTmp[ i1 ] -= 5;
+        sgKpf_tmp->speichern( outF ); // speichern in Neue Datei
+        char byte = 0;
+        for( int i1 = (int)inF->tellg(); i1 < sgPosList[ i + 1 ]; ++i1 ) // Den Körper des Zeichens Kopieren
+        {
+            inF->read( &byte, 1 );
+            outF->write( &byte, 1 );
+        }
+        sgKpf_tmp->release();
+    }
+    int indexMinus = 5 + sgPosList[ sgNum + 1 ] - (int)inF->tellg();
+    inF->seekg( sgPosList[ sgNum + 1 ], std::ios::beg );
+    for( int i = sgNum + 1; i < sgAnzahl; ++i ) // Die Schriftgröße nach der zu löschenden Schriftgröße
+    {
+        LTDSSchriftKopf *sgKpf_tmp = new LTDSSchriftKopf(); // Schriftgrößen Kopf
+        sgKpf_tmp->laden( inF ); // Schriftgrößen Kopf laden
+        int *zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
+        unsigned char zeichATmp = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
+        for( int i1 = 0; i1 < zeichATmp; ++i1 ) // Position der Zeichen aktualisieren
+            zeichPosLTmp[ i1 ] -= indexMinus;
+        sgKpf_tmp->speichern( outF ); // speichern in Neue Datei
+        char byte = 0;
+        int BeginByte = (int)inF->tellg();
+        int EndByte = sgPosList[ i + 1 ];
+        if( !EndByte )
+        {
+            inF->seekg( 0, std::ios::end );
+            EndByte = (int)inF->tellg();
+            inF->seekg( BeginByte, std::ios::beg );
+        }
+        for( int i1 = BeginByte; i1 < EndByte; ++i1 ) // Den Körper des Zeichens Kopieren
+        {
+            inF->read( &byte, 1 );
+            outF->write( &byte, 1 );
+        }
+    }
+    for( int i = 0; i < sgNum; ++i ) // Dateikopf aktualisieren
+        sgPosList[ i ] -= 5;
+    for( int i = sgNum + 1; i < sgAnzahl; ++i )
+        sgPosList[ i ] -= indexMinus;
+    dateiKopf->removeSG( gr );
+    outF->seekp( 0, std::ios::beg );
+    dateiKopf->speichern( outF ); // Dateikopf speichern
+    inF->close();
+    outF->close();
+    Text *pfad2 = new Text( pfad->getText() );
+    pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
+    DateiLöschen( pfad->getThis() ); // alte Datei löschen
+    DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei zu alter umbenennen
+    pfad2->release();
+    delete inF;
+    delete outF;
 }
 
 void LTDSDatei::löscheBuchstabe( int gr, unsigned char zeichen ) // Löscht einen Buchstaben aus der Datei
 {
-	if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob die Datei existiert
-		return;
-	if( !dateiKopf ) // prüfen, ob der Dateikopf gelesen wurde
-		leseDaten();
-	unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
-	unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
-	int *sgPosList = dateiKopf->getPositionList(); // Liste mit Positionen der Schriftgrößen
-	int sgNum = -1;
-	for( int i = 0; i < sgAnzahl; ++i ) // Schriftgröße suchen
-	{
-		if( sgList[ i ] == gr )
-		{
-			sgNum = i;
-			break;
-		}
-	}
-	if( sgNum == -1 ) // Schriftgröße nicht gefunden
-		return;
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
-	pfad->anhängen( "0" );
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
-	int indexMinus = 0;
-	inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
-	dateiKopf->speichern( outF ); // DateiKopf peichern
-	for( int i = 0; i < sgAnzahl; ++i )
-	{
-		LTDSSchriftKopf *sgKopf = new LTDSSchriftKopf(); // Schriftkopf
-		sgKopf->laden( inF ); // Schriftkopf laden
-		unsigned char sgZeichAnzahl = sgKopf->getZeichenAnzahl(); // Zeichenanzahl
-		unsigned char *sgZeichenList = sgKopf->getZeichen(); // Zeichen Liste
-		int *sgZPosList = sgKopf->getPositionen(); // Positions Liste
-		if( i == sgNum ) // Zeichen befindet sich in dieser Schriftgröße
-		{
-			int sgZNum = -1;
-			for( int i1 = 0; i1 < sgZeichAnzahl; ++i1 ) // Zeichen suchen
-			{
-				if( sgZeichenList[ i1 ] == zeichen )
-				{
-					sgZNum = i1;
-					break;
-				}
-			}
-			if( sgZNum == -1 ) // Zeichen nicht gefunden
-			{
-				sgKopf->release();
-				inF->close();
-				outF->close();
-				delete inF;
-				delete outF;
-				DateiLöschen( pfad->getThis() );
-				pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
-				return; // abbruch
-			}
-			outF->seekp( 2 + 5 * ( sgZeichAnzahl - 1 ), std::ios::cur );
-			indexMinus += 5;
-			for( int i1 = 0; i1 < sgZNum; ++i1 ) // Zeichen vor dem zu löschenden Zeichen
-			{
-				char byte = 0;
-				for( int i2 = sgZPosList[ i1 ]; i2 < sgZPosList[ i1 + 1 ]; ++i2 ) // Kopieren
-				{
-					inF->read( &byte, 1 );
-					outF->write( &byte, 1 );
-				}
-				sgZPosList[ i1 ] -= indexMinus; // Schriftgröße Kopf aktualisieren
-			}
-			if( !sgZPosList[ sgZNum + 1 ] )
-			{
-				int endByte = sgPosList[ i + 1 ];
-				if( !endByte )
-				{
-					int beginByte = (int)inF->tellg();
-					inF->seekg( 0, std::ios::end );
-					endByte = (int)inF->tellg();
-					inF->seekg( beginByte, std::ios::beg );
-				}
-				indexMinus += endByte - sgZPosList[ sgZNum ];
-			}
-			else
-			    indexMinus += sgZPosList[ sgZNum + 1 ] - sgZPosList[ sgZNum ];
-			if( sgZNum + 1 < sgZeichAnzahl )
-				inF->seekg( sgZPosList[ sgZNum + 1 ], std::ios::beg );
-			for( int i1 = sgZNum + 1; i1 < sgZeichAnzahl; ++i1 ) // Zeichen nach dem gelöschten Zeichen
-			{
-				int beginByte = (int)inF->tellg();
-				int endByte = sgZPosList[ i1 + 1 ];
-				if( !endByte )
-				{
-					inF->seekg( 0, std::ios::end );
-					endByte = (int)inF->tellg();
-					inF->seekg( beginByte, std::ios::beg );
-				}
-				char byte = 0;
-				for( int i2 = beginByte; i2 < endByte; ++i2 ) // Kopieren
-				{
-					inF->read( &byte, 1 );
-					outF->write( &byte, 1 );
-				}
-				sgZPosList[ i1 ] -= indexMinus; // Schriftgröße Kopf aktualisieren
-			}
-			sgKopf->removeZeichen( zeichen );
-		}
-		else
-		{
-			for( int i1 = 0; i1 < sgZeichAnzahl; ++i1 ) // Schriftgröße Kopf aktualisieren
-				sgZPosList[ i ] -= indexMinus;
-			sgKopf->speichern( outF ); // Schriftgröße Kopf speichern
-			int beginByte = (int)inF->tellg();
-			int endByte = sgPosList[ i + 1 ];
-			if( !endByte )
-			{
-				inF->seekg( 0, std::ios::end );
-				endByte = (int)inF->tellg();
-				inF->seekg( beginByte, std::ios::beg );
-			}
-			char byte;
-			for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopieren
-			{
-				inF->read( &byte, 1 );
-				outF->write( &byte, 1 );
-			}
-			sgPosList[ i ] -= indexMinus;
-		}
-		outF->seekp( sgPosList[ i ], std::ios::beg );
-		sgKopf->speichern( outF ); // Schriftgröße Kopf speichern
-		outF->seekp( sgPosList[ i + 1 ], std::ios::beg );
-		sgKopf->release();
-	}
-	inF->close();
-	outF->close();
-	Text *pfad2 = new Text( pfad->getText() );
-	pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
-	DateiLöschen( pfad->getThis() ); // alte Datei löschen
-	DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei nach alte umbenennen
-	pfad2->release(); // Speicher freigeben
-	delete inF;
-	delete outF;
+    if( !DateiExistiert( pfad->getThis() ) ) // prüfen, ob die Datei existiert
+        return;
+    if( !dateiKopf ) // prüfen, ob der Dateikopf gelesen wurde
+        leseDaten();
+    unsigned char *sgList = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
+    unsigned char sgAnzahl = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
+    int *sgPosList = dateiKopf->getPositionList(); // Liste mit Positionen der Schriftgrößen
+    int sgNum = -1;
+    for( int i = 0; i < sgAnzahl; ++i ) // Schriftgröße suchen
+    {
+        if( sgList[ i ] == gr )
+        {
+            sgNum = i;
+            break;
+        }
+    }
+    if( sgNum == -1 ) // Schriftgröße nicht gefunden
+        return;
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary ); // alte Datei
+    pfad->anhängen( "0" );
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary ); // neue Datei
+    int indexMinus = 0;
+    inF->seekg( 1 + 5 * sgAnzahl, std::ios::beg );
+    dateiKopf->speichern( outF ); // DateiKopf peichern
+    for( int i = 0; i < sgAnzahl; ++i )
+    {
+        LTDSSchriftKopf *sgKopf = new LTDSSchriftKopf(); // Schriftkopf
+        sgKopf->laden( inF ); // Schriftkopf laden
+        unsigned char sgZeichAnzahl = sgKopf->getZeichenAnzahl(); // Zeichenanzahl
+        unsigned char *sgZeichenList = sgKopf->getZeichen(); // Zeichen Liste
+        int *sgZPosList = sgKopf->getPositionen(); // Positions Liste
+        if( i == sgNum ) // Zeichen befindet sich in dieser Schriftgröße
+        {
+            int sgZNum = -1;
+            for( int i1 = 0; i1 < sgZeichAnzahl; ++i1 ) // Zeichen suchen
+            {
+                if( sgZeichenList[ i1 ] == zeichen )
+                {
+                    sgZNum = i1;
+                    break;
+                }
+            }
+            if( sgZNum == -1 ) // Zeichen nicht gefunden
+            {
+                sgKopf->release();
+                inF->close();
+                outF->close();
+                delete inF;
+                delete outF;
+                DateiLöschen( pfad->getThis() );
+                pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
+                return; // abbruch
+            }
+            outF->seekp( 2 + 5 * ( sgZeichAnzahl - 1 ), std::ios::cur );
+            indexMinus += 5;
+            for( int i1 = 0; i1 < sgZNum; ++i1 ) // Zeichen vor dem zu löschenden Zeichen
+            {
+                char byte = 0;
+                for( int i2 = sgZPosList[ i1 ]; i2 < sgZPosList[ i1 + 1 ]; ++i2 ) // Kopieren
+                {
+                    inF->read( &byte, 1 );
+                    outF->write( &byte, 1 );
+                }
+                sgZPosList[ i1 ] -= indexMinus; // Schriftgröße Kopf aktualisieren
+            }
+            if( !sgZPosList[ sgZNum + 1 ] )
+            {
+                int endByte = sgPosList[ i + 1 ];
+                if( !endByte )
+                {
+                    int beginByte = (int)inF->tellg();
+                    inF->seekg( 0, std::ios::end );
+                    endByte = (int)inF->tellg();
+                    inF->seekg( beginByte, std::ios::beg );
+                }
+                indexMinus += endByte - sgZPosList[ sgZNum ];
+            }
+            else
+                indexMinus += sgZPosList[ sgZNum + 1 ] - sgZPosList[ sgZNum ];
+            if( sgZNum + 1 < sgZeichAnzahl )
+                inF->seekg( sgZPosList[ sgZNum + 1 ], std::ios::beg );
+            for( int i1 = sgZNum + 1; i1 < sgZeichAnzahl; ++i1 ) // Zeichen nach dem gelöschten Zeichen
+            {
+                int beginByte = (int)inF->tellg();
+                int endByte = sgZPosList[ i1 + 1 ];
+                if( !endByte )
+                {
+                    inF->seekg( 0, std::ios::end );
+                    endByte = (int)inF->tellg();
+                    inF->seekg( beginByte, std::ios::beg );
+                }
+                char byte = 0;
+                for( int i2 = beginByte; i2 < endByte; ++i2 ) // Kopieren
+                {
+                    inF->read( &byte, 1 );
+                    outF->write( &byte, 1 );
+                }
+                sgZPosList[ i1 ] -= indexMinus; // Schriftgröße Kopf aktualisieren
+            }
+            sgKopf->removeZeichen( zeichen );
+        }
+        else
+        {
+            for( int i1 = 0; i1 < sgZeichAnzahl; ++i1 ) // Schriftgröße Kopf aktualisieren
+                sgZPosList[ i ] -= indexMinus;
+            sgKopf->speichern( outF ); // Schriftgröße Kopf speichern
+            int beginByte = (int)inF->tellg();
+            int endByte = sgPosList[ i + 1 ];
+            if( !endByte )
+            {
+                inF->seekg( 0, std::ios::end );
+                endByte = (int)inF->tellg();
+                inF->seekg( beginByte, std::ios::beg );
+            }
+            char byte;
+            for( int i1 = beginByte; i1 < endByte; ++i1 ) // Kopieren
+            {
+                inF->read( &byte, 1 );
+                outF->write( &byte, 1 );
+            }
+            sgPosList[ i ] -= indexMinus;
+        }
+        outF->seekp( sgPosList[ i ], std::ios::beg );
+        sgKopf->speichern( outF ); // Schriftgröße Kopf speichern
+        outF->seekp( sgPosList[ i + 1 ], std::ios::beg );
+        sgKopf->release();
+    }
+    inF->close();
+    outF->close();
+    Text *pfad2 = new Text( pfad->getText() );
+    pfad->löschen( pfad->getLänge() - 1, pfad->getLänge() );
+    DateiLöschen( pfad->getThis() ); // alte Datei löschen
+    DateiUmbenennen( pfad2->getThis(), pfad->getThis() ); // neue Datei nach alte umbenennen
+    pfad2->release(); // Speicher freigeben
+    delete inF;
+    delete outF;
 }
 
 void LTDSDatei::löscheDatei() // Löscht die gesamte Datei
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return;
-	if( !dateiKopf )
-		leseDaten();
-	DateiLöschen( pfad->getThis() );
+    if( !DateiExistiert( pfad->getThis() ) )
+        return;
+    if( !dateiKopf )
+        leseDaten();
+    DateiLöschen( pfad->getThis() );
 }
 
 void LTDSDatei::erstelleDatei() // erstellt die Datei
 {
-	DateiPfadErstellen( pfad->getThis() );
-	if( dateiKopf )
-		dateiKopf->release();
-	dateiKopf = new LTDSDateiKopf();
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
-	dateiKopf->speichern( outF );
-	outF->close();
-	delete outF;
+    DateiPfadErstellen( pfad->getThis() );
+    if( dateiKopf )
+        dateiKopf->release();
+    dateiKopf = new LTDSDateiKopf();
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
+    dateiKopf->speichern( outF );
+    outF->close();
+    delete outF;
 }
 
 void LTDSDatei::speicherSchrift( Schrift *schrift ) // Speichert die übergebene Schrift
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-	{
-		schrift->release();
-		return;
-	}
-	löscheDatei();
-	if( dateiKopf )
-		dateiKopf->release();
-	dateiKopf = new LTDSDateiKopf();
-	for( int i = 0; i < schrift->getAlphabetAnzahl(); ++i )
-	{
-		Alphabet *alp = schrift->getAlphabetI( i );
-		if( alp )
-		{
-			dateiKopf->addSG( alp->getSchriftgröße() );
-			alp->release();
-		}
-	}
-	std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
-	dateiKopf->speichern( outF );
-	for( int i = 0; i < schrift->getAlphabetAnzahl(); ++i )
-	{
-		dateiKopf->getPositionList()[ i ] = (int)outF->tellp();
-		LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
-		sgKpf->setZeichenAlphabet( schrift->getAlphabetI( i ) );
-		sgKpf->speichern( outF );
-		Alphabet *alp = schrift->getAlphabetI( i );
-		for( int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1 )
-		{
-			sgKpf->getPositionen()[ i1 ] = (int)outF->tellp();
-			LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf();
-			Buchstabe *zeichen = alp->getBuchstabe( sgKpf->getZeichen()[ i1 ] );
-			zeichKpf->init( sgKpf->getZeichen()[ i1 ], zeichen->getBreite(), zeichen->getHöhe() );
-			zeichKpf->speichern( outF );
-			LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() );
-			zeichKörp->setBuchstabe( zeichen->getThis() );
-			zeichKörp->speichern( outF );
-			zeichKörp->release();
-			zeichen->release();
-			zeichKpf->release();
-		}
-		alp->release();
-		int p = (int)outF->tellp();
-		outF->seekp( dateiKopf->getPositionList()[ i ], std::ios::beg );
-		sgKpf->speichern( outF );
-		outF->seekp( p, std::ios::beg );
-		sgKpf->release();
-	}
-	outF->seekp( 0, std::ios::beg );
-	dateiKopf->speichern( outF );
-	outF->close();
-	delete outF;
-	schrift->release();
+    if( !DateiExistiert( pfad->getThis() ) )
+    {
+        schrift->release();
+        return;
+    }
+    löscheDatei();
+    if( dateiKopf )
+        dateiKopf->release();
+    dateiKopf = new LTDSDateiKopf();
+    for( int i = 0; i < schrift->getAlphabetAnzahl(); ++i )
+    {
+        Alphabet *alp = schrift->getAlphabetI( i );
+        if( alp )
+        {
+            dateiKopf->addSG( alp->getSchriftgröße() );
+            alp->release();
+        }
+    }
+    std::ofstream *outF = new std::ofstream( pfad->getText(), std::ios::binary );
+    dateiKopf->speichern( outF );
+    for( int i = 0; i < schrift->getAlphabetAnzahl(); ++i )
+    {
+        dateiKopf->getPositionList()[ i ] = (int)outF->tellp();
+        LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
+        sgKpf->setZeichenAlphabet( schrift->getAlphabetI( i ) );
+        sgKpf->speichern( outF );
+        Alphabet *alp = schrift->getAlphabetI( i );
+        for( int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1 )
+        {
+            sgKpf->getPositionen()[ i1 ] = (int)outF->tellp();
+            LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf();
+            Buchstabe *zeichen = alp->getBuchstabe( sgKpf->getZeichen()[ i1 ] );
+            zeichKpf->init( sgKpf->getZeichen()[ i1 ], zeichen->getBreite(), zeichen->getHöhe() );
+            zeichKpf->speichern( outF );
+            LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() );
+            zeichKörp->setBuchstabe( zeichen->getThis() );
+            zeichKörp->speichern( outF );
+            zeichKörp->release();
+            zeichen->release();
+            zeichKpf->release();
+        }
+        alp->release();
+        int p = (int)outF->tellp();
+        outF->seekp( dateiKopf->getPositionList()[ i ], std::ios::beg );
+        sgKpf->speichern( outF );
+        outF->seekp( p, std::ios::beg );
+        sgKpf->release();
+    }
+    outF->seekp( 0, std::ios::beg );
+    dateiKopf->speichern( outF );
+    outF->close();
+    delete outF;
+    schrift->release();
 }
 
 // constant 
 Schrift *LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	Schrift *ret = new Schrift();
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-	inF->seekg( dateiKopf->getPositionList()[ 0 ], std::ios::beg );
-	for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
-	{
-		LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
-		sgKpf->laden( inF );
-		Alphabet *alphabet = new Alphabet();
-		alphabet->setSchriftgröße( sgKpf->getSchriftGröße() );
-		alphabet->setDrawSchriftgröße( sgKpf->getSchriftGröße() );
-		for( int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1 )
-		{
-			LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf();
-			zeichKpf->laden( inF );
-			LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() );
-			zeichKörp->laden( inF );
-			alphabet->setBuchstabe( zeichKpf->getZeichen(), zeichKörp->getBuchstabe() );
-			zeichKörp->release();
-			zeichKpf->release();
-		}
-		ret->addAlphabet( alphabet->getThis() );
-		alphabet->release();
-		sgKpf->release();
-	}
-	inF->close();
-	delete inF;
-	return ret;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    Schrift *ret = new Schrift();
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+    inF->seekg( dateiKopf->getPositionList()[ 0 ], std::ios::beg );
+    for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
+    {
+        LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
+        sgKpf->laden( inF );
+        Alphabet *alphabet = new Alphabet();
+        alphabet->setSchriftgröße( sgKpf->getSchriftGröße() );
+        alphabet->setDrawSchriftgröße( sgKpf->getSchriftGröße() );
+        for( int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1 )
+        {
+            LTDSBuchstabenKopf *zeichKpf = new LTDSBuchstabenKopf();
+            zeichKpf->laden( inF );
+            LTDSBuchstabenKörper *zeichKörp = new LTDSBuchstabenKörper( zeichKpf->getThis() );
+            zeichKörp->laden( inF );
+            alphabet->setBuchstabe( zeichKpf->getZeichen(), zeichKörp->getBuchstabe() );
+            zeichKörp->release();
+            zeichKpf->release();
+        }
+        ret->addAlphabet( alphabet->getThis() );
+        alphabet->release();
+        sgKpf->release();
+    }
+    inF->close();
+    delete inF;
+    return ret;
 }
 
 Alphabet *LTDSDatei::ladeAlphabet( int schriftgröße ) // gibt eine geladene Schrift nur mit der angegebenen Schriftgröße zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	Alphabet *ret = 0;
-	int sgNum = -1;
-	for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
-	{
-		if( dateiKopf->getSchriftGrößeList()[ i ] == schriftgröße )
-		{
-			sgNum = i;
-			break;
-		}
-	}
-	if( sgNum == -1 )
-		return 0;
-	ret = new Alphabet();
-	ret->NeuAlphabet();
-	ret->setSchriftgröße( schriftgröße );
-	ret->setDrawSchriftgröße( schriftgröße );
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-	inF->seekg( dateiKopf->getPositionList()[ sgNum ], std::ios::beg );
-	LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
-	sgKpf->laden( inF );
-	for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
-	{
-		LTDSBuchstabenKopf *sgZKpf = new LTDSBuchstabenKopf();
-		sgZKpf->laden( inF );
-		LTDSBuchstabenKörper *sgZKörp = new LTDSBuchstabenKörper( sgZKpf->getThis() );
-		sgZKörp->laden( inF );
-		ret->setBuchstabe( sgZKpf->getZeichen(), sgZKörp->getBuchstabe() );
-		sgZKörp->release();
-		sgZKpf->release();
-	}
-	sgKpf->release();
-	inF->close();
-	delete inF;
-	return ret;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    Alphabet *ret = 0;
+    int sgNum = -1;
+    for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
+    {
+        if( dateiKopf->getSchriftGrößeList()[ i ] == schriftgröße )
+        {
+            sgNum = i;
+            break;
+        }
+    }
+    if( sgNum == -1 )
+        return 0;
+    ret = new Alphabet();
+    ret->NeuAlphabet();
+    ret->setSchriftgröße( schriftgröße );
+    ret->setDrawSchriftgröße( schriftgröße );
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+    inF->seekg( dateiKopf->getPositionList()[ sgNum ], std::ios::beg );
+    LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
+    sgKpf->laden( inF );
+    for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
+    {
+        LTDSBuchstabenKopf *sgZKpf = new LTDSBuchstabenKopf();
+        sgZKpf->laden( inF );
+        LTDSBuchstabenKörper *sgZKörp = new LTDSBuchstabenKörper( sgZKpf->getThis() );
+        sgZKörp->laden( inF );
+        ret->setBuchstabe( sgZKpf->getZeichen(), sgZKörp->getBuchstabe() );
+        sgZKörp->release();
+        sgZKpf->release();
+    }
+    sgKpf->release();
+    inF->close();
+    delete inF;
+    return ret;
 }
 
 Buchstabe *LTDSDatei::ladeBuchstabe( int schriftgröße, unsigned char zeichen )// Läd einen bestimmten Buchstaben
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	Buchstabe *ret = 0;
-	int sgNum = -1;
-	for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
-	{
-		if( dateiKopf->getSchriftGrößeList()[ i ] == schriftgröße )
-		{
-			sgNum = i;
-			break;
-		}
-	}
-	if( sgNum == -1 )
-		return 0;
-	std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-	inF->seekg( dateiKopf->getPositionList()[ sgNum ], std::ios::beg );
-	LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
-	sgKpf->laden( inF );
-	int sgZNum = -1;
-	for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
-	{
-		if( sgKpf->getZeichen()[ i ] == zeichen )
-		{
-			sgZNum = i;
-			break;
-		}
-	}
-	if( sgZNum != -1 )
-	{
-		inF->seekg( sgKpf->getPositionen()[ sgZNum ], std::ios::beg );
-		LTDSBuchstabenKopf *sgZKpf = new LTDSBuchstabenKopf();
-		sgZKpf->laden( inF );
-		LTDSBuchstabenKörper *sgZKörp = new LTDSBuchstabenKörper( sgZKpf->getThis() );
-		sgZKörp->laden( inF );
-		ret = sgZKörp->getBuchstabe();
-		sgZKörp->release();
-		sgZKpf->release();
-	}
-	sgKpf->release();
-	inF->close();
-	delete inF;
-	if( ret )
-	{
-		ret->setSchriftGröße( schriftgröße );
-		ret->setDrawSchriftGröße( schriftgröße );
-	}
-	return ret;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    Buchstabe *ret = 0;
+    int sgNum = -1;
+    for( int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i )
+    {
+        if( dateiKopf->getSchriftGrößeList()[ i ] == schriftgröße )
+        {
+            sgNum = i;
+            break;
+        }
+    }
+    if( sgNum == -1 )
+        return 0;
+    std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+    inF->seekg( dateiKopf->getPositionList()[ sgNum ], std::ios::beg );
+    LTDSSchriftKopf *sgKpf = new LTDSSchriftKopf();
+    sgKpf->laden( inF );
+    int sgZNum = -1;
+    for( int i = 0; i < sgKpf->getZeichenAnzahl(); ++i )
+    {
+        if( sgKpf->getZeichen()[ i ] == zeichen )
+        {
+            sgZNum = i;
+            break;
+        }
+    }
+    if( sgZNum != -1 )
+    {
+        inF->seekg( sgKpf->getPositionen()[ sgZNum ], std::ios::beg );
+        LTDSBuchstabenKopf *sgZKpf = new LTDSBuchstabenKopf();
+        sgZKpf->laden( inF );
+        LTDSBuchstabenKörper *sgZKörp = new LTDSBuchstabenKörper( sgZKpf->getThis() );
+        sgZKörp->laden( inF );
+        ret = sgZKörp->getBuchstabe();
+        sgZKörp->release();
+        sgZKpf->release();
+    }
+    sgKpf->release();
+    inF->close();
+    delete inF;
+    if( ret )
+    {
+        ret->setSchriftGröße( schriftgröße );
+        ret->setDrawSchriftGröße( schriftgröße );
+    }
+    return ret;
 }
 
 Text *LTDSDatei::getPfad() const // gibt den Dateipfad zurück
 {
-	return pfad->getThis();
+    return pfad->getThis();
 }
 
 int LTDSDatei::getAnzahlSchriftgrößen() const // gibt die Anzahl der Schriftgrößen aus der Datei zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	return dateiKopf->getSchriftGrößeAnzahl();
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    return dateiKopf->getSchriftGrößeAnzahl();
 }
 
 unsigned char *LTDSDatei::getSchriftGrößen() const // gibt einen Array von Schriftgrößen zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	return dateiKopf->getSchriftGrößeList();
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    return dateiKopf->getSchriftGrößeList();
 }
 
 unsigned char LTDSDatei::getAnzahlBuchstaben( int sg ) // gibt die anzahl gespeicherter Buchstaben einer Schriftgröße zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	int ret = 0;
-	unsigned char *größen = dateiKopf->getSchriftGrößeList();
-	unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
-	int grpos = -1;
-	for( int i = 0; i < granzahl; ++i )
-	{
-		if( größen[ i ] == sg )
-		{
-			grpos = i;
-			break;
-		}
-	}
-	if( grpos != -1 )
-	{
-		int *grposlist = dateiKopf->getPositionList();
-		LTDSSchriftKopf *sgkpf = new LTDSSchriftKopf();
-		std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-		inF->seekg( grposlist[ grpos ], std::ios::beg );
-		sgkpf->laden( inF );
-		ret = sgkpf->getZeichenAnzahl();
-		sgkpf->release();
-		inF->close();
-		delete inF;
-	}
-	return ret;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    int ret = 0;
+    unsigned char *größen = dateiKopf->getSchriftGrößeList();
+    unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
+    int grpos = -1;
+    for( int i = 0; i < granzahl; ++i )
+    {
+        if( größen[ i ] == sg )
+        {
+            grpos = i;
+            break;
+        }
+    }
+    if( grpos != -1 )
+    {
+        int *grposlist = dateiKopf->getPositionList();
+        LTDSSchriftKopf *sgkpf = new LTDSSchriftKopf();
+        std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+        inF->seekg( grposlist[ grpos ], std::ios::beg );
+        sgkpf->laden( inF );
+        ret = sgkpf->getZeichenAnzahl();
+        sgkpf->release();
+        inF->close();
+        delete inF;
+    }
+    return ret;
 }
 
 unsigned char *LTDSDatei::getBuchstaben( int sg ) // gibt einen Array von Buchstaben einer Schriftgröße zurück
 {
-	if( !DateiExistiert( pfad->getThis() ) )
-		return 0;
-	if( !dateiKopf )
-		return 0;
-	unsigned char *ret = 0;
-	unsigned char *größen = dateiKopf->getSchriftGrößeList();
-	unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
-	int grpos = -1;
-	for( int i = 0; i < granzahl; ++i )
-	{
-		if( größen[ i ] == sg )
-		{
-			grpos = i;
-			break;
-		}
-	}
-	if( grpos != -1 )
-	{
-		int *grposlist = dateiKopf->getPositionList();
-		LTDSSchriftKopf *sgkpf = new LTDSSchriftKopf();
-		std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
-		inF->seekg( grposlist[ grpos ], std::ios::beg );
-		sgkpf->laden( inF );
-		int anz = sgkpf->getZeichenAnzahl();
-		ret = new unsigned char[ anz ];
-		for( int i = 0; i < anz; ++i )
-			ret[ i ] = sgkpf->getZeichen()[ i ];
-		sgkpf->release();
-		inF->close();
-		delete inF;
-	}
-	return ret;
+    if( !DateiExistiert( pfad->getThis() ) )
+        return 0;
+    if( !dateiKopf )
+        return 0;
+    unsigned char *ret = 0;
+    unsigned char *größen = dateiKopf->getSchriftGrößeList();
+    unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
+    int grpos = -1;
+    for( int i = 0; i < granzahl; ++i )
+    {
+        if( größen[ i ] == sg )
+        {
+            grpos = i;
+            break;
+        }
+    }
+    if( grpos != -1 )
+    {
+        int *grposlist = dateiKopf->getPositionList();
+        LTDSSchriftKopf *sgkpf = new LTDSSchriftKopf();
+        std::ifstream *inF = new std::ifstream( pfad->getText(), std::ios::binary );
+        inF->seekg( grposlist[ grpos ], std::ios::beg );
+        sgkpf->laden( inF );
+        int anz = sgkpf->getZeichenAnzahl();
+        ret = new unsigned char[ anz ];
+        for( int i = 0; i < anz; ++i )
+            ret[ i ] = sgkpf->getZeichen()[ i ];
+        sgkpf->release();
+        inF->close();
+        delete inF;
+    }
+    return ret;
 }
 
 // Reference Counting 
 LTDSDatei *LTDSDatei::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LTDSDatei *LTDSDatei::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 #endif
 // Bit Funktionen
 int Framework::Bits( int a ) // gibt 1-bits in gewinschter anzahl zurück
 {
-	int ret = 0;
-	for( int i = 0; i < a; ++i )
-	{
-		ret <<= 1;
-		++ret;
-	}
-	return ret;
+    int ret = 0;
+    for( int i = 0; i < a; ++i )
+    {
+        ret <<= 1;
+        ++ret;
+    }
+    return ret;
 }
 
 int Framework::getBits( char c ) // gibt zurück, wie viele Bits c benötigt
 {
-	int ret = 0;
-	for( int i = 0; ( c & (char)Bits( i ) ) != c; ++i )
-		++ret;
-	return ret;
+    int ret = 0;
+    for( int i = 0; ( c & (char)Bits( i ) ) != c; ++i )
+        ++ret;
+    return ret;
 }

DateiSystem.h

@@ -7,633 +7,633 @@
 
 namespace Framework
 {
-	class Bild; // Bild.h
-	class Text; // Text.h
+    class Bild; // Bild.h
+    class Text; // Text.h
 #ifdef WIN32
-	class Buchstabe; // Schrift.h
-	class Alphabet; // Schrift.h
-	class Schrift; // Schrift.h
-	class FBalken; // Fortschritt.h
+    class Buchstabe; // Schrift.h
+    class Alphabet; // Schrift.h
+    class Schrift; // Schrift.h
+    class FBalken; // Fortschritt.h
 #else
 #define FBalken int
 #endif
-	class LTDBPixel; // aus dieser Datei
-	class LTDBKopf; // aus dieser Datei
-	class LTDBKörper; // aus dieser Datei
-	class LTDBDatei; // aus dieser Datei
-	class LTDSPixel; // aus dieser Datei
+    class LTDBPixel; // aus dieser Datei
+    class LTDBKopf; // aus dieser Datei
+    class LTDBKörper; // aus dieser Datei
+    class LTDBDatei; // aus dieser Datei
+    class LTDSPixel; // aus dieser Datei
 #ifdef WIN32
-	class LTDSDateiKopf; // aus dieser Datei
-	class LTDSSchriftKopf; // aus dieser Datei
-	class LTDSBuchstabenKopf; // aus dieser Datei
-	class LTDSBuchstabenKörper; // aus dieser Datei
-	class LTDSDatei; // aus dieser Datei
+    class LTDSDateiKopf; // aus dieser Datei
+    class LTDSSchriftKopf; // aus dieser Datei
+    class LTDSBuchstabenKopf; // aus dieser Datei
+    class LTDSBuchstabenKörper; // aus dieser Datei
+    class LTDSDatei; // aus dieser Datei
 #endif
 
-	// LTDB Dateivormat --- Dient zum speichern von mehreren Bildern in einer Datei.
+    // LTDB Dateivormat --- Dient zum speichern von mehreren Bildern in einer Datei.
 
     // Dient zum Speichern und Laden eines einzelnen Pixels aus einem Bild im LTDB Dateiformat
-	class LTDBPixel // Pixel einer LTDB Datei
-	{
-	private:
-		LTDBPixel *davor; // Letzter Pixel
-		char index; // Bitlänge des Pixels
-		char iR, iG, iB, iA;
-		char miR, miG, miB, miA;
-		char maxIndex; // Länge des Pixels
-		bool änder : 1; // Verändert sich etwas an den volgenden 5 Variablen
-		bool änderR : 1; // Ändert sich Rot
-		bool änderG : 1; // Ändert sich Grün
-		bool änderB : 1; // Ändert sich Blau
-		bool änderA : 1; // Ändert sich Alpha
-		unsigned char komp : 3; // Komprimierung der Farbwerte
-		unsigned char R; // Rot
-		unsigned char G; // Grün
-		unsigned char B; // Blau
-		unsigned char A; // Alpha
-		bool addBitZuFarbe( unsigned char bit ); // Fügt den Farbwerten ein Bit hinzu
-		bool getNextFarbeBit( char &byte, int i ); // Speichert das nächste Farbbit in byte
-		int ref;
+    class LTDBPixel // Pixel einer LTDB Datei
+    {
+    private:
+        LTDBPixel *davor; // Letzter Pixel
+        char index; // Bitlänge des Pixels
+        char iR, iG, iB, iA;
+        char miR, miG, miB, miA;
+        char maxIndex; // Länge des Pixels
+        bool änder : 1; // Verändert sich etwas an den volgenden 5 Variablen
+        bool änderR : 1; // Ändert sich Rot
+        bool änderG : 1; // Ändert sich Grün
+        bool änderB : 1; // Ändert sich Blau
+        bool änderA : 1; // Ändert sich Alpha
+        unsigned char komp : 3; // Komprimierung der Farbwerte
+        unsigned char R; // Rot
+        unsigned char G; // Grün
+        unsigned char B; // Blau
+        unsigned char A; // Alpha
+        bool addBitZuFarbe( unsigned char bit ); // Fügt den Farbwerten ein Bit hinzu
+        bool getNextFarbeBit( char &byte, int i ); // Speichert das nächste Farbbit in byte
+        int ref;
 
-	public:
-		// Konstruktor
+    public:
+        // Konstruktor
         //  davor: Der Pixel, der Vorher geladen wurde. 0, falls dieß der Erste Pixel ist
-		__declspec( dllexport ) LTDBPixel( LTDBPixel *davor );
-		// Destruktor 
-		__declspec( dllexport ) ~LTDBPixel();
-		// zum Laden gedacht. Fügt dem Pixel einiege bits hinzu
+        __declspec( dllexport ) LTDBPixel( LTDBPixel *davor );
+        // Destruktor 
+        __declspec( dllexport ) ~LTDBPixel();
+        // zum Laden gedacht. Fügt dem Pixel einiege bits hinzu
         //  byte: Das zuletzt aus der Datei gelesene Byte
         //  begin: Der Index des ersten Bits im byte, wo der Pixel beginnt
         //  return: Der Index des Bits im Byte, wo der Pixel aufgehöhrt hat. -1, falls der Pixel am ende Des Bytes noch nicht zuende ist
-		__declspec( dllexport ) char addByte( char byte, char begin );
-		// zum speichern gedacht. Setzt die Farbe, die im Pixel gespeichert werden soll
+        __declspec( dllexport ) char addByte( char byte, char begin );
+        // zum speichern gedacht. Setzt die Farbe, die im Pixel gespeichert werden soll
         //  f: Die zu speichernde Farbe
-		__declspec( dllexport ) void setFarbe( int f );
+        __declspec( dllexport ) void setFarbe( int f );
         // Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
-		__declspec( dllexport ) void komprimieren();
+        __declspec( dllexport ) void komprimieren();
         // Gibt ein Teil der Bits zurück, die den Pixel representieren
         //  byte: Eine Referens auf das Byte, dass als nächstes gespeichert werden soll
         //  begin: Der Index des ersten Bits im zu speichernden Byte, wo der Pixel gespeichert werden soll
         //  return: Der Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte fortgesetzt werden muss
-		__declspec( dllexport ) char getNextByte( char &byte, int begin );
+        __declspec( dllexport ) char getNextByte( char &byte, int begin );
         // Gibt den Farbwert des Pixels zurück
-		__declspec( dllexport ) int zuFarbe() const;
+        __declspec( dllexport ) int zuFarbe() const;
         // Gibt zurück, ob sich der Anteil an Rot in der Farbe im Vergleich zum Pixel davor geändert hat
-		__declspec( dllexport ) bool getÄnderR() const;
+        __declspec( dllexport ) bool getÄnderR() const;
         // Gibt zurück, ob sich der Anteil an Grün in der Farbe im Vergleich zum Pixel davor geändert hat
-		__declspec( dllexport ) bool getÄnderG() const;
+        __declspec( dllexport ) bool getÄnderG() const;
         // Gibt zurück, ob sich der Anteil an Blau in der Farbe im Vergleich zum Pixel davor geändert hat
-		__declspec( dllexport ) bool getÄnderB() const;
+        __declspec( dllexport ) bool getÄnderB() const;
         // Gibt zurück, ob sich der Anteil an Alpha in der Farbe im Vergleich zum Pixel davor geändert hat
-		__declspec( dllexport ) bool getÄnderA() const;
+        __declspec( dllexport ) bool getÄnderA() const;
         // Gibt die Komprimierung des Pixels zurück
-		__declspec( dllexport ) unsigned char getKomp() const;
+        __declspec( dllexport ) unsigned char getKomp() const;
         // Gibt den Anteil an Rot in der Farbe des Pixels zurück
-		__declspec( dllexport ) unsigned char getR() const;
+        __declspec( dllexport ) unsigned char getR() const;
         // Gibt den Anteil an Grün in der Farbe des Pixels zurück
-		__declspec( dllexport ) unsigned char getG() const;
+        __declspec( dllexport ) unsigned char getG() const;
         // Gibt den Anteil an Blau in der Farbe des Pixels zurück
-		__declspec( dllexport ) unsigned char getB() const;
+        __declspec( dllexport ) unsigned char getB() const;
         // Gibt den Anteil an Alpha in der Farbe des Pixels zurück
-		__declspec( dllexport ) unsigned char getA() const;
+        __declspec( dllexport ) unsigned char getA() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDBPixel *getThis();
+        __declspec( dllexport ) LTDBPixel *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDBPixel *release();
-	};
+        __declspec( dllexport ) LTDBPixel *release();
+    };
 
     // Der Kopf des LTDB Dateiformates. Hier werden informationen über alle Abgespeicherten Bilder verwaltet
-	class LTDBDateiKopf
-	{
-	private:
-		RCArray< Text > *bilder;
-		Array< __int64 > *pos;
-		int bAnzahl;
-		int ref;
+    class LTDBDateiKopf
+    {
+    private:
+        RCArray< Text > *bilder;
+        Array< __int64 > *pos;
+        int bAnzahl;
+        int ref;
 
-	public:
-		// konstructor
-		__declspec( dllexport ) LTDBDateiKopf();
-		// destructor 
-		__declspec( dllexport ) ~LTDBDateiKopf();
-		// Entfernt ein Bild aus dem Dateikopf
+    public:
+        // konstructor
+        __declspec( dllexport ) LTDBDateiKopf();
+        // destructor 
+        __declspec( dllexport ) ~LTDBDateiKopf();
+        // Entfernt ein Bild aus dem Dateikopf
         //  i: Der Index des Bildes, welches entfernt werden soll
-		__declspec( dllexport ) void removeBild( int i );
+        __declspec( dllexport ) void removeBild( int i );
         // Entfernt ein Bild aus dem Dateikopf
         //  txt: Der Name des Bildes, welches entfernt werden soll
-		__declspec( dllexport ) void removeBild( Text *txt );
+        __declspec( dllexport ) void removeBild( Text *txt );
         // Fügt dem Dateikopf ein Bild hinzu
         //  txt: Der Name des Bildes.
-		__declspec( dllexport ) void addBild( Text *txt );
+        __declspec( dllexport ) void addBild( Text *txt );
         // Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
         //  i: Der index Des Bildes
         //  pos: Die Position des Bildes in der Datei
-		__declspec( dllexport ) void setBildPos( int i, __int64 pos );
+        __declspec( dllexport ) void setBildPos( int i, __int64 pos );
         // Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
         //  txt: Der Name Des Bildes
         //  pos: Die Position des Bildes in der Datei
-		__declspec( dllexport ) void setBildPos( Text *txt, __int64 pos );
+        __declspec( dllexport ) void setBildPos( Text *txt, __int64 pos );
         // Lädt den Dateikopf einer LTDB Datei
         //  f: Ein Zeiger auf einen Fortschrittsbalken, der zum Laden verwendet werden soll. Kann 0 sein.
         //  inF: Der geöffnete ifstream der LTDB Datei, bei dem die Leseposition bereits auf das erste Byte des Dateiopfes zeigt.
-		__declspec( dllexport ) void laden( FBalken *f, std::ifstream *inF );
-		// Speichert den Dateikopf in einer LTDB Datei
+        __declspec( dllexport ) void laden( FBalken *f, std::ifstream *inF );
+        // Speichert den Dateikopf in einer LTDB Datei
         //  outF: Der geöffnete ofstream der LTDB Datei, bei dem die Schreibposition bereits auf das erste Byte des Dateikopfes zeigt.
-		__declspec( dllexport ) void speichern( std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *outF ) const;
         // Gibt den Namen eines bestimmten Bildes zurück
         //  i: Der Index des Bildes, dessen Namen zurückgegeben werden soll
         //  return: Der Name des bildes
-		__declspec( dllexport ) Text *getBild( int i ) const;
+        __declspec( dllexport ) Text *getBild( int i ) const;
         // Gibt den Namen eines bestimmten Bildes zurück
         //  i: Der Index des Bildes, dessen Namen zurückgegeben werden soll
         //  return: Der Name des bildes ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zBild( int i ) const;
+        __declspec( dllexport ) Text *zBild( int i ) const;
         // Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
         //  txt: Der Name des Bildes, dessen Beginn gefunden werden soll
         //  return: -1, falls das Bild nicht gefunden wurde.
-		__declspec( dllexport ) __int64 getBildPosition( Text *txt ) const;
+        __declspec( dllexport ) __int64 getBildPosition( Text *txt ) const;
         // Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
         // Fals der Index nicht existiert wird die Exception std::out_of_range geworfen.
         //  indes: Der Indes des Bildes, dessen Beginn gefunden werden soll
-		__declspec( dllexport ) __int64 getBildPosition( int index ) const;
+        __declspec( dllexport ) __int64 getBildPosition( int index ) const;
         // Gibt den Index eines Bestimmten Bildes zurück
         //  txt: Der Name des Bildes
         //  return: -1, falls das Bild nicht gefunden wurde
-		__declspec( dllexport ) int getBildIndex( Text *txt ) const;
+        __declspec( dllexport ) int getBildIndex( Text *txt ) const;
         // Gibt die Anzahl der Bilder in der Datei zurück
-		__declspec( dllexport ) int getbAnzahl() const;
+        __declspec( dllexport ) int getbAnzahl() const;
         // Gibt eine Liste mit Bildern in der Datei ohne erhöhten Reference Counter zurück.
         // Die Liste sollte nicht verändert werden
-		__declspec( dllexport ) RCArray< Text > *zBildListe() const;
+        __declspec( dllexport ) RCArray< Text > *zBildListe() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDBDateiKopf *getThis();
+        __declspec( dllexport ) LTDBDateiKopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDBDateiKopf *release();
-	};
+        __declspec( dllexport ) LTDBDateiKopf *release();
+    };
 
     // Die im LTDB Dateikopf gespeicherten Informationen für ein einzelnes Bild
-	class LTDBKopf
-	{
-	private:
-		__int64 a; // Det LTDB Dateikopf ist maximal 104 Bits lang
-		__int32 b; // - bis zu 75 Bits für den Titel
-		__int8 c;  // - 12 Bits für breite
-		int ref;   // - 12 Bits för höhe
+    class LTDBKopf
+    {
+    private:
+        __int64 a; // Det LTDB Dateikopf ist maximal 104 Bits lang
+        __int32 b; // - bis zu 75 Bits für den Titel
+        __int8 c;  // - 12 Bits für breite
+        int ref;   // - 12 Bits för höhe
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDBKopf();
-		// Lähdt die Informationen über ein Bild
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDBKopf();
+        // Lähdt die Informationen über ein Bild
         //  f: Der geöffnette und an die richtiege Stelle zeigende ifstream der LTDB Datei
-		__declspec( dllexport ) void laden( std::ifstream *f );
+        __declspec( dllexport ) void laden( std::ifstream *f );
         // Setzt die Informationen die gespeichert werden sollen
         //  titel: Der Titel des Bildes
         //  größe: Die Größe des Bildes
         //  return: Die Anzahl der Buchstaben aus dem Titel, die im LTDB Dateiformat nicht gespeichert werden können. Erlaubt ist nur a-z und A-Z und ä ü ö ß und Ä Ü Ö und .
         // Alle großbuchstaben im Titel werden in Kleinbuchstaben umgewandelt
-		__declspec( dllexport ) int Init( Text *titel, const Punkt &größe );
+        __declspec( dllexport ) int Init( Text *titel, const Punkt &größe );
         // Lähd informationen aus geladenen Bits. Wird von der laden( std::ifstream ) Funktion verwendet.
         //  BeginBit: Der Index des ersten Bits, welches ausgewertet werden soll
         //  EndBit: Der Index des letzten Bits, welches nichtmehr ausgewertet werden soll
         //  bits: Die Bits, von denen alle von BeginBit bis EndBit ausgewertet werden sollen
         // Insgesamt müssen 104 Bits gesetzt werden. Hierauf bezihen sich BeginBit und EndBit
-		__declspec( dllexport ) void setBits( int BeginBit, int EndBit, __int16 bits );
-		// Speichert die Informationen in eine Datei
+        __declspec( dllexport ) void setBits( int BeginBit, int EndBit, __int16 bits );
+        // Speichert die Informationen in eine Datei
         //  f: Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDB Datei
-		__declspec( dllexport ) void speichern( std::ofstream *f ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *f ) const;
         // Gibt die Länge des Titels zurück
-		__declspec( dllexport ) int getTitelLänge() const;
+        __declspec( dllexport ) int getTitelLänge() const;
         // Gibt den Titel des Bildes zurück
-		__declspec( dllexport ) Text *getTitel() const;
+        __declspec( dllexport ) Text *getTitel() const;
         // Gibt die Größe des Bildes zurück
-		__declspec( dllexport ) Punkt getGröße() const;
+        __declspec( dllexport ) Punkt getGröße() const;
         // Gibt die nächsten zu speichernden Bits zurück
         //  begin: Der Index des ersten Bits, in das gespeichert werden soll
         //  end: Der Index des letzten Bits, in das gespeichert werden soll
         //  return: 16 Bits, in denen die Informationen zwischen begin und end stehen
         // Insgesamt müssen 104 Bits gelesen werden. Hierauf bezihen sich BeginBit und EndBit
-		__declspec( dllexport ) __int16 getBits( int begin, int end )const;
+        __declspec( dllexport ) __int16 getBits( int begin, int end )const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDBKopf *getThis();
+        __declspec( dllexport ) LTDBKopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDBKopf *release();
-	};
+        __declspec( dllexport ) LTDBKopf *release();
+    };
 
     // Verwaltet die Pixeldaten eines einzelnen Bildes einer LTDB Datei
-	class LTDBKörper
-	{
-	private:
-		Punkt gr;
-		Bild *b;
-		int dateiLänge;
-		int ref;
+    class LTDBKörper
+    {
+    private:
+        Punkt gr;
+        Bild *b;
+        int dateiLänge;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDBKörper();
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDBKörper();
         // Konstruktor
         //  k: Der LTDB Kopf des Bildes, der Informationen über die Größe des Bildes enthält
-		__declspec( dllexport ) LTDBKörper( LTDBKopf *k );
-		// Destruktor 
-		__declspec( dllexport ) ~LTDBKörper();
-		// Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
+        __declspec( dllexport ) LTDBKörper( LTDBKopf *k );
+        // Destruktor 
+        __declspec( dllexport ) ~LTDBKörper();
+        // Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
         //  k: Der LTDB Kopf des Bildes
-		__declspec( dllexport ) void init( LTDBKopf k );
-		// Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
+        __declspec( dllexport ) void init( LTDBKopf k );
+        // Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
         //  k: Der LTDB Kopf des Bildes
-		__declspec( dllexport ) void init( LTDBKopf *k );
+        __declspec( dllexport ) void init( LTDBKopf *k );
         // Lädt die Pixeldaten aus der Datei
         //  zF: Ein Fortschrittsbalken, der 0 sein kann
         //  inF: Der geöffnete und an die richtiege Stelle zeigende ifstream der LTDB Datei
-		__declspec( dllexport ) void laden( FBalken *zF, std::ifstream *inF );
+        __declspec( dllexport ) void laden( FBalken *zF, std::ifstream *inF );
         // Setzt das Bild, welches gespeichert werden soll
         //  b: Das zu speichernde Bild
-		__declspec( dllexport ) void setBild( Bild *b );
-		// Speichert die Pixeldaten des Bildes in einer LTDB Datei
+        __declspec( dllexport ) void setBild( Bild *b );
+        // Speichert die Pixeldaten des Bildes in einer LTDB Datei
         //  zF: Ein Fortschrittsbalken, der 0 sein kann
         //  outF: Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDB Datei
-		__declspec( dllexport ) void speichern( FBalken *zF, std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( FBalken *zF, std::ofstream *outF ) const;
         // Gibt das geladene Bild zurück
-		__declspec( dllexport ) Bild *getBild() const;
+        __declspec( dllexport ) Bild *getBild() const;
         // Gibt die Größe des Bildes zurück
         __declspec( dllexport ) const Punkt &getGröße() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDBKörper *getThis();
+        __declspec( dllexport ) LTDBKörper *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDBKörper *release();
-	};
+        __declspec( dllexport ) LTDBKörper *release();
+    };
 
     // Verwaltet eine LTDB Datei
-	class LTDBDatei
-	{
-	private:
-		Text *pfad;
-		LTDBDateiKopf *datKpf;
-		int ref;
+    class LTDBDatei
+    {
+    private:
+        Text *pfad;
+        LTDBDateiKopf *datKpf;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDBDatei();
-		// Destruktor 
-		__declspec( dllexport ) ~LTDBDatei();
-		// Setzt den Pfad zu Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDBDatei();
+        // Destruktor 
+        __declspec( dllexport ) ~LTDBDatei();
+        // Setzt den Pfad zu Datei
         //  pfad: Der Pfad
-		__declspec( dllexport ) void setDatei( Text *pfad );
+        __declspec( dllexport ) void setDatei( Text *pfad );
         // Erstellt eine neue LTDB Datei
-		__declspec( dllexport ) void erstellen();
+        __declspec( dllexport ) void erstellen();
         // Ließt grundlegende Informationen aus der Datei.
         // Wird benötigt, bevor mit der Datei gearbeitet wird
         //  zF: Ein Fortschrittsbalken, der 0 sein kann
-		__declspec( dllexport ) void leseDaten( FBalken *zF );
+        __declspec( dllexport ) void leseDaten( FBalken *zF );
         // Löscht die LTDB Datei
-		__declspec( dllexport ) void löschen();
+        __declspec( dllexport ) void löschen();
         // Löscht ein Bild aus der LTDB Datei
         //  zF: Ein Fortschrittsbalken der 0 sein kann
         //  name: Der Name des zu löschenden Bildes
-		__declspec( dllexport ) void löschen( FBalken *zF, Text *name );
+        __declspec( dllexport ) void löschen( FBalken *zF, Text *name );
         // Lädt ein Bild aus der LTDB Datei
         //  zF: Ein Fortschrittsbalken, der 0 sein kann
         //  name: Der Name des Bildes, welches geladen werden soll
         //  return: Das geladene Bild. 0, falls das Bild nicht gefunden wurde
-		__declspec( dllexport ) Bild *laden( FBalken *zF, Text *name );
+        __declspec( dllexport ) Bild *laden( FBalken *zF, Text *name );
         // Speichert ein neues Bild in der LTDB Datei
         //  zF: Ein Fortscrittsbalken, der 0 sein kann
         //  bild: Das Bild, welches gelöscht werden soll
         //  name: Der Name, unter dem das Bild gespeichert werden soll
         //  return: Anzahl der Warnungen, die beim Konvertieren des Namens in einen gültigen Namen aufgetreten sind. -1, falls bereis ein Bild mit dem selben Namen existiert
-		__declspec( dllexport ) int speichern( FBalken *zF, Bild *bild, Text *name );
+        __declspec( dllexport ) int speichern( FBalken *zF, Bild *bild, Text *name );
         // Gibt eine Liste mit gespeicherten Bildern zurück
         // Die Liste sollte nicht verändert werden
-		__declspec( dllexport ) RCArray< Text > *zBildListe();
-		// Gibt den Pfad zur LTDB Datei zurück
-		__declspec( dllexport ) Text *getPfad() const;
+        __declspec( dllexport ) RCArray< Text > *zBildListe();
+        // Gibt den Pfad zur LTDB Datei zurück
+        __declspec( dllexport ) Text *getPfad() const;
         // Gibt die Anzahl der Bilder in der LTDB Datei zurück
-		__declspec( dllexport ) int getBildAnzahl() const;
+        __declspec( dllexport ) int getBildAnzahl() const;
         // Prüft, ob die LTDB Datei existiert
-		__declspec( dllexport ) bool istOffen() const;
+        __declspec( dllexport ) bool istOffen() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDBDatei *getThis();
+        __declspec( dllexport ) LTDBDatei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDBDatei *release();
-	};
+        __declspec( dllexport ) LTDBDatei *release();
+    };
 
 #ifdef WIN32
-	// LTDS Dateivormat --- Dient zum speichern von Schriftarten
+    // LTDS Dateivormat --- Dient zum speichern von Schriftarten
 
     // Verwaltet einen einzelnen Pixel von einem Buchstaben
-	class LTDSPixel
-	{
-	private:
-		int ref;
-		char index;
-		char iA;
-		char miA;
-		char maxIndex; // Länge des Pixels
-		bool änder;
-		bool änderA;
-		unsigned char komp : 3; // Komprimierung der Farbwerte
-		unsigned char alpha;
-		LTDSPixel *davor;
-		bool addBitZuFarbe( unsigned char bit ); // Fügt den Farbwerten ein Bit hinzu
-		bool getNextFarbeBit( char &byte, int i ); // Speichert das nächste Farbbit in byte
+    class LTDSPixel
+    {
+    private:
+        int ref;
+        char index;
+        char iA;
+        char miA;
+        char maxIndex; // Länge des Pixels
+        bool änder;
+        bool änderA;
+        unsigned char komp : 3; // Komprimierung der Farbwerte
+        unsigned char alpha;
+        LTDSPixel *davor;
+        bool addBitZuFarbe( unsigned char bit ); // Fügt den Farbwerten ein Bit hinzu
+        bool getNextFarbeBit( char &byte, int i ); // Speichert das nächste Farbbit in byte
 
-	public:
-		// Konstruktor
+    public:
+        // Konstruktor
         //  davor: Der Pixel, der vor diesem geladen wurde. 0, fals dieß der erste Pixel ist
-		__declspec( dllexport ) LTDSPixel( LTDSPixel *davor );
-		// Destruktor 
-		__declspec( dllexport ) ~LTDSPixel();
-		// Fügt dem Pixel einiege geladene Bits hinzu. Zum Laden gedacht.
+        __declspec( dllexport ) LTDSPixel( LTDSPixel *davor );
+        // Destruktor 
+        __declspec( dllexport ) ~LTDSPixel();
+        // Fügt dem Pixel einiege geladene Bits hinzu. Zum Laden gedacht.
         //  byte: Das letzte aus der Datei geladene Byte.
         //  begin: Der Index des ersten Bits im Byte, wo der Pixel beginnt
         //  return: Der Index des Letzten Bits in Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte weitergeht
-		__declspec( dllexport ) char addByte( char byte, char begin );
-		// Setzt den Alpha Wert des Pixels. Zum speichern gedacht.
+        __declspec( dllexport ) char addByte( char byte, char begin );
+        // Setzt den Alpha Wert des Pixels. Zum speichern gedacht.
         //  alpha: Der Alpha Wert des Pixels.
-		__declspec( dllexport ) void setAlpha( unsigned char alpha );
+        __declspec( dllexport ) void setAlpha( unsigned char alpha );
         // Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
-		__declspec( dllexport ) void Komp();
+        __declspec( dllexport ) void Komp();
         // Gibt ein Teil der Bits zurück, die den Pixel representieren
         //  byte: Eine Referens auf das Byte, dass als nächstes gespeichert werden soll
         //  begin: Der Index des ersten Bits im zu speichernden Byte, wo der Pixel gespeichert werden soll
         //  return: Der Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte fortgesetzt werden muss
-		__declspec( dllexport ) char getNextByte( char &byte, int bbegin );
+        __declspec( dllexport ) char getNextByte( char &byte, int bbegin );
         // Gibt die Komprimierung des Pixels zurück
-		__declspec( dllexport ) unsigned char getKomp() const;
+        __declspec( dllexport ) unsigned char getKomp() const;
         // Gibt zurück, ob sich der Alpha Wert im Vergleich zu dem Pixel davor geändert hat
-		__declspec( dllexport ) bool getÄnderA() const;
+        __declspec( dllexport ) bool getÄnderA() const;
         // Gibt den Alpha Wert des Pixels zurück
-		__declspec( dllexport ) unsigned char getA() const;
+        __declspec( dllexport ) unsigned char getA() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSPixel *getThis();
+        __declspec( dllexport ) LTDSPixel *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSPixel *release();
-	};
+        __declspec( dllexport ) LTDSPixel *release();
+    };
 
     // Verwaltet den Kopf einer LTDS Datei. Er enthält Informationen über die in der Datei gespeicherten Schriftgrößen
-	class LTDSDateiKopf
-	{
-	private:
-		int ref;
-		unsigned char sganzahl;
-		unsigned char *gr;
-		int *pos;
+    class LTDSDateiKopf
+    {
+    private:
+        int ref;
+        unsigned char sganzahl;
+        unsigned char *gr;
+        int *pos;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDSDateiKopf();
-		// Destruktor 
-		__declspec( dllexport ) ~LTDSDateiKopf();
-		// Lädt den Kopf aus der LTDS Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDSDateiKopf();
+        // Destruktor 
+        __declspec( dllexport ) ~LTDSDateiKopf();
+        // Lädt den Kopf aus der LTDS Datei
         //  inF: Der geöffnete und an die richtige Stelle zeigende ifstream der LTDS Datei
-		__declspec( dllexport ) void laden( std::ifstream *inF );
+        __declspec( dllexport ) void laden( std::ifstream *inF );
         // Fügt eine Schriftgröße hinzu
         //  sg: Die Schriftgröße, die hinzugefügt werden soll
-		__declspec( dllexport ) void addSG( char sg );
+        __declspec( dllexport ) void addSG( char sg );
         // Löscht eine Schriftgröße
         //  sg: Die Schriftgröße, die gelöscht werden soll
-		__declspec( dllexport ) void removeSG( char sg );
+        __declspec( dllexport ) void removeSG( char sg );
         // Speichert den LTDS Kopf in der Datei
         //  outF: Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
-		__declspec( dllexport ) void speichern( std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *outF ) const;
         // Gibt einen Array von gespeicherten Schriftgrößen zurück
         // Der Array sollte nicht verädert werden
-		__declspec( dllexport ) unsigned char *getSchriftGrößeList() const;
+        __declspec( dllexport ) unsigned char *getSchriftGrößeList() const;
         // Gibt einen Array mit positionen der ersten Bytes für jede Schriftgröße aus der Datei zurück
         __declspec( dllexport ) int *getPositionList() const;
         // Gibt die Anzahl der gespeicherten Schriftgrößen zurück
-		__declspec( dllexport ) int getSchriftGrößeAnzahl() const;
+        __declspec( dllexport ) int getSchriftGrößeAnzahl() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSDateiKopf *getThis();
+        __declspec( dllexport ) LTDSDateiKopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSDateiKopf *release();
-	};
+        __declspec( dllexport ) LTDSDateiKopf *release();
+    };
 
     // Der Kopf einer Schriftgröße. Enthält Informationen über die gespeicherten Zeichen
-	class LTDSSchriftKopf
-	{
-	private:
-		int ref;
-		unsigned char schriftGröße;
-		unsigned char *zeichen;
-		int *pos;
-		unsigned char zeichenAnzahl;
+    class LTDSSchriftKopf
+    {
+    private:
+        int ref;
+        unsigned char schriftGröße;
+        unsigned char *zeichen;
+        int *pos;
+        unsigned char zeichenAnzahl;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDSSchriftKopf();
-		// Destruktor 
-		__declspec( dllexport ) ~LTDSSchriftKopf();
-		// Lädt den Kopf einer Schriftgröße aus der Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDSSchriftKopf();
+        // Destruktor 
+        __declspec( dllexport ) ~LTDSSchriftKopf();
+        // Lädt den Kopf einer Schriftgröße aus der Datei
         //  inF: Der geöffnete und an de richtiege Stelle zeigende ifstream der LTDS Datei
-		__declspec( dllexport ) void laden( std::ifstream *inF );
+        __declspec( dllexport ) void laden( std::ifstream *inF );
         // Setzt die Schriftgröße. Zum speichern gedacht
         //  gr: Die Schriftgröße
-		__declspec( dllexport ) void setSchriftgröße( unsigned char gr );
+        __declspec( dllexport ) void setSchriftgröße( unsigned char gr );
         // Setzt das Alphabet, welches in der Schriftgröße gespeichert werden soll
         //  alphabet: Das Alphabet, welches alle zu speichernden Zeichen in der Schriftgröße enthält
-		__declspec( dllexport ) void setZeichenAlphabet( Alphabet *alphabet );
+        __declspec( dllexport ) void setZeichenAlphabet( Alphabet *alphabet );
         // Fügt der Schriftgröße ein Zeichen hinzu, welches gespeichert werden soll
         //  zeichen: Der ASCII code des Zeichens, welches hinzugefügt werden soll
-		__declspec( dllexport ) void addZeichen( unsigned char zeichen );
+        __declspec( dllexport ) void addZeichen( unsigned char zeichen );
         // Löscht ein Zeichen aus der Schriftgröße
         //  zeich: Der ASCII code des Zeichens, welches gelöscht werden soll
         __declspec( dllexport ) void removeZeichen( unsigned char zeich );
-		// Speichert den Kopf der Schriftgröße in der LTDS Datei
+        // Speichert den Kopf der Schriftgröße in der LTDS Datei
         //  outF: Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
-		__declspec( dllexport ) void speichern( std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *outF ) const;
         // Gibt die Schriftgröße zurück, zu der dieser Kopf gehöhrt
-		__declspec( dllexport ) unsigned char getSchriftGröße() const;
+        __declspec( dllexport ) unsigned char getSchriftGröße() const;
         // Gibt die Anzahl der in der Schriftgröße gespeicherten Zeichen zurück
-		__declspec( dllexport ) unsigned char getZeichenAnzahl() const;
+        __declspec( dllexport ) unsigned char getZeichenAnzahl() const;
         // Gibt einen Array mit den Positionen der ersten Bytes von den gespeicherten Zeichen aus der LTDS Datei zurück 
-		__declspec( dllexport ) int *getPositionen() const;
+        __declspec( dllexport ) int *getPositionen() const;
         // Gibt einen Array mit den ASCII codes der Gespeicherten Zeichen zurück
-		__declspec( dllexport ) unsigned char *getZeichen() const;
+        __declspec( dllexport ) unsigned char *getZeichen() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSSchriftKopf *getThis();
+        __declspec( dllexport ) LTDSSchriftKopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSSchriftKopf *release();
-	};
+        __declspec( dllexport ) LTDSSchriftKopf *release();
+    };
 
     // Der Kopf eines einzelnen Zeichens aus der LTDS Datei. Enthält informationen über die Pixelgröße des Zeichens
-	class LTDSBuchstabenKopf
-	{
-	private:
-		int ref;
-		unsigned char zeichen;
-		Punkt größe;
+    class LTDSBuchstabenKopf
+    {
+    private:
+        int ref;
+        unsigned char zeichen;
+        Punkt größe;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDSBuchstabenKopf();
-		// Lädt die Daten aus der LTDS Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDSBuchstabenKopf();
+        // Lädt die Daten aus der LTDS Datei
         //  inF: Der geöffnete und an die richtiege Stelle zeigende ifstream der LTDS Datei
-		__declspec( dllexport ) void laden( std::ifstream *inF );
+        __declspec( dllexport ) void laden( std::ifstream *inF );
         // Setzt die Daten, die gespeichert werden sollen.
         //  zeichen: Der ASCII code des Zeichens
         //  größe: Die Größe des Zeichens in Pixeln
-		__declspec( dllexport ) void init( unsigned char zeichen, const Punkt &größe );
+        __declspec( dllexport ) void init( unsigned char zeichen, const Punkt &größe );
         // Setzt die Daten, die gespeichert werden sollen.
         //  zeichen: Der ASCII code des Zeichens
         //  br: Die Breite des Zeichens in Pixeln
         //  hö: Die Höhe des Zeichens in Pixeln
-		__declspec( dllexport ) void init( unsigned char zeichen, int br, int hö );
-		// Speichert die Daten in der LTDS Datei
+        __declspec( dllexport ) void init( unsigned char zeichen, int br, int hö );
+        // Speichert die Daten in der LTDS Datei
         //  outF: Der geöffnete und auf die richtiege Stelle zeigende ofstream der LTDS Datei
-		__declspec( dllexport ) void speichern( std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *outF ) const;
         // Gibt den ASCII code des Zeichens zurück
-		__declspec( dllexport ) unsigned char getZeichen() const;
+        __declspec( dllexport ) unsigned char getZeichen() const;
         // Gibt die Breite des Zeichens in Pixeln zurück
-		__declspec( dllexport ) int getBreite() const;
+        __declspec( dllexport ) int getBreite() const;
         // Gibt die Höhe des Zeichens in Pixeln zurück
         __declspec( dllexport ) int getHöhe() const;
         // Gib t die Größe des Zeichens in Pixeln zurück
         __declspec( dllexport ) const Punkt &getGröße() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSBuchstabenKopf *getThis();
+        __declspec( dllexport ) LTDSBuchstabenKopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSBuchstabenKopf *release();
-	};
+        __declspec( dllexport ) LTDSBuchstabenKopf *release();
+    };
 
     // Verwaltet die Pixeldaten eines Zeichens
-	class LTDSBuchstabenKörper
-	{
-	private:
-		int ref;
-		Punkt größe;
-		unsigned char zeichen;
-		Buchstabe *buchstabe;
+    class LTDSBuchstabenKörper
+    {
+    private:
+        int ref;
+        Punkt größe;
+        unsigned char zeichen;
+        Buchstabe *buchstabe;
 
-	public:
-		// Konstruktor
+    public:
+        // Konstruktor
         //  kopf: Der Kopf des Zeichens
-		__declspec( dllexport ) LTDSBuchstabenKörper( LTDSBuchstabenKopf *kopf );
-		// Destruktor 
-		__declspec( dllexport ) ~LTDSBuchstabenKörper();
-		// Setzt den Buchstaben, der gespeichert werden soll
+        __declspec( dllexport ) LTDSBuchstabenKörper( LTDSBuchstabenKopf *kopf );
+        // Destruktor 
+        __declspec( dllexport ) ~LTDSBuchstabenKörper();
+        // Setzt den Buchstaben, der gespeichert werden soll
         //  zeichen: Der zu speichernde Buchstabe
-		__declspec( dllexport ) void setBuchstabe( Buchstabe *zeichen );
+        __declspec( dllexport ) void setBuchstabe( Buchstabe *zeichen );
         // Lädt die Pixel aus der LTDS Datei
         //  inF: Der geöffnete und auf die richtiege Stelle zeigende ifstream der LTDS Datei
-		__declspec( dllexport ) void laden( std::ifstream *inF );
-		// Speichert die Pixel in die LTDS Datei
+        __declspec( dllexport ) void laden( std::ifstream *inF );
+        // Speichert die Pixel in die LTDS Datei
         //  outF: der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
-		__declspec( dllexport ) void speichern( std::ofstream *outF ) const;
+        __declspec( dllexport ) void speichern( std::ofstream *outF ) const;
         // Gibt den geladenen Buchstaben zurück
-		__declspec( dllexport ) Buchstabe *getBuchstabe() const;
+        __declspec( dllexport ) Buchstabe *getBuchstabe() const;
         // Gibt den ASCII code des Buchstabens zurück
-		__declspec( dllexport ) unsigned char getZeichen() const;
+        __declspec( dllexport ) unsigned char getZeichen() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSBuchstabenKörper *getThis();
+        __declspec( dllexport ) LTDSBuchstabenKörper *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSBuchstabenKörper *release();
-	};
+        __declspec( dllexport ) LTDSBuchstabenKörper *release();
+    };
 
     // Verwaltet eine LTDS Datei
-	class LTDSDatei
-	{
-	private:
-		int ref;
-		Text *pfad;
-		LTDSDateiKopf *dateiKopf;
+    class LTDSDatei
+    {
+    private:
+        int ref;
+        Text *pfad;
+        LTDSDateiKopf *dateiKopf;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LTDSDatei();
-		// Destruktor 
-		__declspec( dllexport ) ~LTDSDatei();
-		// Setzt den Pfad zur Datei
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LTDSDatei();
+        // Destruktor 
+        __declspec( dllexport ) ~LTDSDatei();
+        // Setzt den Pfad zur Datei
         //  txt: Der Pfad
-		__declspec( dllexport ) void setPfad( Text *txt );
+        __declspec( dllexport ) void setPfad( Text *txt );
         // Lädt wichtiege Informationen aus der Datei. Muss vor dem Verwenden der Datei aufgerufen werden
-		__declspec( dllexport ) void leseDaten();
+        __declspec( dllexport ) void leseDaten();
         // Fügt der Datei eine Schriftgröße hinzu, fals diese noch nicht existiert
         //  alphabet: Das Alphabet, welches die Zeichen in der gewünschten Schriftgrö0e enthält
-		__declspec( dllexport ) void addSchriftgröße( Alphabet *alphabet );
+        __declspec( dllexport ) void addSchriftgröße( Alphabet *alphabet );
         // Fügt einer Schriftgröße einen Buchstaben hinzu
         //  gr: Die Schriftgröße des Buchstabens
         //  zeich: Der Buchstabe, der gespeichert werden soll
         //  zeichen: Der ASCII code des Buchstabens
-		__declspec( dllexport ) void addBuchstabe( int gr, Buchstabe *zeich, unsigned char zeichen );
+        __declspec( dllexport ) void addBuchstabe( int gr, Buchstabe *zeich, unsigned char zeichen );
         // Löscht eine bestimmte Schriftgröße aus der Datei
         //  gr: Die Schriftgröße, die entfernt werden soll
-		__declspec( dllexport ) void löscheSchrifrGröße( int gr );
+        __declspec( dllexport ) void löscheSchrifrGröße( int gr );
         // Löscht einen Buchstaben aus einer Schriftgröße
         //  gr: Die Schriftgröße, aus der der Buchstabe entfernt werden soll
         //  zeichen: Der ASCII code des Zeichens, welches gelöscht werden soll
-		__declspec( dllexport ) void löscheBuchstabe( int gr, unsigned char zeichen );
+        __declspec( dllexport ) void löscheBuchstabe( int gr, unsigned char zeichen );
         // Löscht die LTDS Datei
-		__declspec( dllexport ) void löscheDatei();
+        __declspec( dllexport ) void löscheDatei();
         // Erstellt die LTDS Datei
         __declspec( dllexport ) void erstelleDatei();
         // Speichert eine gesammte Schrift in der Datei
         //  schrift: Die schrift, die gespeichert werden soll
-		__declspec( dllexport ) void speicherSchrift( Schrift *schrift );
-		// Lädt die gesammte Schrift aus der Datei
+        __declspec( dllexport ) void speicherSchrift( Schrift *schrift );
+        // Lädt die gesammte Schrift aus der Datei
         //  return: Die geladene Schrift. 0, falls ein Fehler beim Laden aufgetreten ist
-		__declspec( dllexport ) Schrift *ladeSchrift();
+        __declspec( dllexport ) Schrift *ladeSchrift();
         // Lädt eine einzelne Schriftgröße aus der Datei
         //  schriftgröße: Die zu ladende Schriftgröße
         //  return: Ein Alphabet mit den Zeichen in der Schriftgröße. 0, falls die Schriftgröße nicht gefunden wurde
-		__declspec( dllexport ) Alphabet *ladeAlphabet( int schriftgröße ); 
+        __declspec( dllexport ) Alphabet *ladeAlphabet( int schriftgröße );
         // Lädt ein bestimmtes Zeichen einer bestimmten Schriftgröße
         //  schriftgröße: Die Schriftgröße, zu dem das Zeichen gehört
         //  zeichen: Der ASCII code des zu ladenden Zeichens
         //  return: Der geladene Buchstabe. 0, falls das Zeichen nicht gefunden wurde.
-		__declspec( dllexport ) Buchstabe *ladeBuchstabe( int schriftgröße, unsigned char zeichen );
+        __declspec( dllexport ) Buchstabe *ladeBuchstabe( int schriftgröße, unsigned char zeichen );
         // Gibt den Pfad zur LTDS Datei zurück
-		__declspec( dllexport ) Text *getPfad() const;
+        __declspec( dllexport ) Text *getPfad() const;
         // Gibt die Anzahl der gespeicherten Schriftgrößen zurück
-		__declspec( dllexport ) int getAnzahlSchriftgrößen() const;
+        __declspec( dllexport ) int getAnzahlSchriftgrößen() const;
         // Gibt einen Array mit den gespeicherten Schriftgrößen zurück
         // Der Array sollte nicht verändert werden
-		__declspec( dllexport ) unsigned char *getSchriftGrößen() const;
+        __declspec( dllexport ) unsigned char *getSchriftGrößen() const;
         // Gibt die Anzahl an gespeicherten Zeichen in einer Schriftgröße zurück
         //  sg: Die Schriftgröße, von der die Anzahl der ZEichen ermittelt werden soll
         //  return: Die Anzahl der Zeichen.
-		__declspec( dllexport ) unsigned char getAnzahlBuchstaben( int sg );
+        __declspec( dllexport ) unsigned char getAnzahlBuchstaben( int sg );
         // Gibt einen Array mit Buchstaben einer bestimmten Schriftgröße zurück
         //  sg: Die Schriftgröße
         //  return: Der Array mit den ASCII codes der Zeichen. 0, falls die Schriftgröße nicht gefunden wurde.
-		__declspec( dllexport ) unsigned char *getBuchstaben( int sg );
+        __declspec( dllexport ) unsigned char *getBuchstaben( int sg );
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LTDSDatei *getThis();
+        __declspec( dllexport ) LTDSDatei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LTDSDatei *release();
-	};
+        __declspec( dllexport ) LTDSDatei *release();
+    };
 #endif
-	// Bit Funktionen 
+    // Bit Funktionen 
 
     // gibt 1-bits in gewinschter anzahl zurück.
     //  a: Die Anzahl der Bits, die 1 sein sollen
     //  return: 32 Bits, wobei die einser Bits von rechts beginnen
-	__declspec( dllexport ) int Bits( int a );
+    __declspec( dllexport ) int Bits( int a );
     // Gibt zurück, wie viele Bits benötigt werden um eine Zahl darzustellen
     //  c: Die Zahl, die dargestellt werden soll
     //  return: Die Anzahl der benötigten Bits
-	__declspec( dllexport ) int getBits( char c );
+    __declspec( dllexport ) int getBits( char c );
 }
 #endif

DreieckListe.h

@@ -6,12 +6,12 @@
 
 namespace Framework
 {
-	template< typename T >
+    template< typename T >
     // Eine Ecke eines Dreiecks
-	struct DreieckPunkt
-	{
-		T *punkt;
-		Punkt *textur;
+    struct DreieckPunkt
+    {
+        T *punkt;
+        Punkt *textur;
         // Konstruktor
         //  punkt: Die Koordinate der Ecke
         //  textur: Die Koordinate in der Textur
@@ -20,109 +20,109 @@ namespace Framework
             this->punkt = punkt;
             this->textur = textur;
         }
-		// Destruktor
-		~DreieckPunkt()
-		{
-			delete punkt;
-			delete textur;
-		}
-	};
+        // Destruktor
+        ~DreieckPunkt()
+        {
+            delete punkt;
+            delete textur;
+        }
+    };
 
-	template< typename T >
+    template< typename T >
     // Eine Liste von Dreiecken, wobei immer die Beiden letzten Punkte des vorheriegen Dreiecks mit dem nächsten Punkt ein neues Dreieck bilden
-	class DreieckListe
-	{
-	private:
-		Array< DreieckPunkt< T >* > *punkte;
-		int ref;
+    class DreieckListe
+    {
+    private:
+        Array< DreieckPunkt< T >* > *punkte;
+        int ref;
 
-	public:
-		// Konstruktor
-		DreieckListe()
-		{
-			ref = 1;
-			punkte = new Array< DreieckPunkt< T >* >();
-		}
+    public:
+        // Konstruktor
+        DreieckListe()
+        {
+            ref = 1;
+            punkte = new Array< DreieckPunkt< T >* >();
+        }
 
-		// Destruktor
-		~DreieckListe()
-		{
-			int anz = punkte->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-				delete punkte->get( i );
-			punkte->release();
-		}
+        // Destruktor
+        ~DreieckListe()
+        {
+            int anz = punkte->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                delete punkte->get( i );
+            punkte->release();
+        }
 
-		// Fügt der Liste einen Punkt hinzu
+        // Fügt der Liste einen Punkt hinzu
         //  p: Die Koordinaten des Punktes
         //  textur: Die Koordinaten in der Textur
-		void addPunkt( T *p, Punkt *textur )
-		{
-			punkte->add( new DreieckPunkt< T >( p, textur ) );
-		}
+        void addPunkt( T *p, Punkt *textur )
+        {
+            punkte->add( new DreieckPunkt< T >( p, textur ) );
+        }
 
         // Löscht den letzten Punkt
-		void löscheLetztenPunkt()
-		{
-			int i = punkte->getEintragAnzahl() - 1;
-			if( !punkte->hat( i ) )
-				return;
-			delete punkte->get( i );
-			punkte->lösche( i );
-		}
+        void löscheLetztenPunkt()
+        {
+            int i = punkte->getEintragAnzahl() - 1;
+            if( !punkte->hat( i ) )
+                return;
+            delete punkte->get( i );
+            punkte->lösche( i );
+        }
 
         // Löscht alle Ecken
-		void lehren()
-		{
-			int anz = punkte->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-				delete punkte->get( i );
-			punkte->leeren();
-		}
+        void lehren()
+        {
+            int anz = punkte->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+                delete punkte->get( i );
+            punkte->leeren();
+        }
 
-		// gibt die Anzahl der Dreiecke zurück
-		int getDreieckAnzahl() const
-		{
-			return punkte->getEintragAnzahl() - 2;
-		}
+        // gibt die Anzahl der Dreiecke zurück
+        int getDreieckAnzahl() const
+        {
+            return punkte->getEintragAnzahl() - 2;
+        }
 
         // Gibt zurück, ob eine Textur verwendet wird
-		bool hatTextur() const
-		{
-			int anz = punkte->getEintragAnzahl();
-			bool ret = 1;
-			for( int i = 0; i < anz; i++ )
-			{
-				if( punkte->hat( i ) )
-				    ret &= punkte->get( i )->textur;
-			}
-			return ret;
-		}
+        bool hatTextur() const
+        {
+            int anz = punkte->getEintragAnzahl();
+            bool ret = 1;
+            for( int i = 0; i < anz; i++ )
+            {
+                if( punkte->hat( i ) )
+                    ret &= punkte->get( i )->textur;
+            }
+            return ret;
+        }
 
         // Gibt die Liste mit Punkten zurück
-		Array< DreieckPunkt< T >* > *zListe() const
-		{
-			return punkte;
-		}
+        Array< DreieckPunkt< T >* > *zListe() const
+        {
+            return punkte;
+        }
 
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		DreieckListe *getThis()
-		{
-			ref++;
-			return this;
-		}
+        DreieckListe *getThis()
+        {
+            ref++;
+            return this;
+        }
 
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		DreieckListe *release()
-		{
-			ref--;
-			if( !ref )
-				delete this;
-			return 0;
-		}
-	};
+        DreieckListe *release()
+        {
+            ref--;
+            if( !ref )
+                delete this;
+            return 0;
+        }
+    };
 }
 
 #endif

Fenster.cpp

@@ -17,1902 +17,1901 @@ using namespace Framework;
 // Fensterklasse erzeugen
 WNDCLASS Framework::F_Normal( HINSTANCE hInst )// Erzeugen einer normalen Fensterklasse
 {
-	WNDCLASS ret;
-	ret.cbClsExtra = 0;
-	ret.cbWndExtra = 0;
-	ret.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
-	ret.hCursor = LoadCursor( NULL, IDC_ARROW );
-	ret.hIcon = LoadIcon( NULL, IDI_APPLICATION );
-	ret.hInstance = hInst;
-	ret.lpszMenuName = "";
-	ret.lpfnWndProc = WindowProc;
-	ret.style = CS_HREDRAW | CS_VREDRAW;
-	return ret;
+    WNDCLASS ret;
+    ret.cbClsExtra = 0;
+    ret.cbWndExtra = 0;
+    ret.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
+    ret.hCursor = LoadCursor( NULL, IDC_ARROW );
+    ret.hIcon = LoadIcon( NULL, IDI_APPLICATION );
+    ret.hInstance = hInst;
+    ret.lpszMenuName = "";
+    ret.lpfnWndProc = WindowProc;
+    ret.style = CS_HREDRAW | CS_VREDRAW;
+    return ret;
 }
 
 WNDCLASSEX Framework::F_NormalEx( HINSTANCE hInst )
 {
-	WNDCLASSEX ret;
-	ret.cbSize = sizeof( WNDCLASSEX );
-	ret.cbClsExtra = 0;
-	ret.cbWndExtra = 0;
-	ret.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
-	ret.hCursor = LoadCursor( NULL, IDC_ARROW );
-	ret.hIcon = LoadIcon( NULL, IDI_APPLICATION );
-	ret.hInstance = hInst;
-	ret.lpszMenuName = "";
-	ret.lpfnWndProc = WindowProc;
-	ret.style = CS_HREDRAW | CS_VREDRAW;
-	ret.hIconSm = 0;
-	return ret;
+    WNDCLASSEX ret;
+    ret.cbSize = sizeof( WNDCLASSEX );
+    ret.cbClsExtra = 0;
+    ret.cbWndExtra = 0;
+    ret.hbrBackground = (HBRUSH)GetStockObject( WHITE_BRUSH );
+    ret.hCursor = LoadCursor( NULL, IDC_ARROW );
+    ret.hIcon = LoadIcon( NULL, IDI_APPLICATION );
+    ret.hInstance = hInst;
+    ret.lpszMenuName = "";
+    ret.lpfnWndProc = WindowProc;
+    ret.style = CS_HREDRAW | CS_VREDRAW;
+    ret.hIconSm = 0;
+    return ret;
 }
 
 // WinAPI
 LRESULT CALLBACK Framework::WindowProc( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam )
 {
-	if( msgExit )
-		return ( DefWindowProc( hwnd, message, wparam, lparam ) );
-	switch( message )
-	{
-		// Maus Zeiger 
-	case WM_SETCURSOR:
-		MausZeiger.update();
-		return 0;
-		// Fenster 
-	case WM_SIZE:
-		if( wparam == SIZE_RESTORED )
-			WFensterA.sendRestoreMessage( hwnd );
-		break;
-		// Schließen 
-	case WM_CLOSE:
-		if( WFensterA.sendVSchließMessage( hwnd ) )
-			return 0;
-		else
-			break;
-	case WM_DESTROY:
-		if( WFensterA.sendNSchließMessage( hwnd ) )
-			return 0;
-		else
-			break;
-		// Maus 
-	case WM_LBUTTONDOWN: // Linksklick
-		if( 1 )
-		{
-			MausStand[ M_Links ] = 1;
-			MausEreignis me = { ME_PLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_RBUTTONDOWN: // Rechtsklick
-		if( 1 )
-		{
-			MausStand[ M_Rechts ] = 1;
-			MausEreignis me = { ME_PRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MBUTTONDOWN: // Mittelklick
-		if( 1 )
-		{
-			MausStand[ M_Mitte ] = 1;
-			MausEreignis me = { ME_PMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_LBUTTONUP: // Linksrelease
-		if( 1 )
-		{
-			MausStand[ M_Links ] = 0;
-			MausEreignis me = { ME_RLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_RBUTTONUP: // Rechtsrelease
-		if( 1 )
-		{
-			MausStand[ M_Rechts ] = 0;
-			MausEreignis me = { ME_RRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MBUTTONUP: // Mittelrelease
-		if( 1 )
-		{
-			MausStand[ M_Mitte ] = 0;
-			MausEreignis me = { ME_RMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_LBUTTONDBLCLK: // Linksdoppelklick
-		if( 1 )
-		{
-			MausEreignis me = { ME_DKLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_RBUTTONDBLCLK: // Rechtsdoppelklick
-		if( 1 )
-		{
-			MausEreignis me = { ME_DKRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MBUTTONDBLCLK: // Mitteldoppelklick
-		if( 1 )
-		{
-			MausEreignis me = { ME_DKMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MOUSEHOVER: // Maus betritt Fenster
-		if( 1 )
-		{
-			MausTrack = 1;
-			MausEreignis me = { ME_Betritt, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MOUSELEAVE: // Maus verlässt Fenster
-		if( 1 )
-		{
-			MausTrack = 1;
-			MausEreignis me = { ME_Verlässt, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MOUSEMOVE: // Maus wird bewegt
-		if( 1 )
-		{
-			if( mausPos.x == (int)LOWORD( lparam ) && mausPos.y == (int)HIWORD( lparam ) )
-				break;
-			mausPos.x = (int)LOWORD( lparam );
-			mausPos.y = (int)HIWORD( lparam );
-			if( MausTrack )
-			{
-				TRACKMOUSEEVENT lptme;
-				lptme.cbSize = sizeof( TRACKMOUSEEVENT );
-				lptme.dwFlags = TME_HOVER | TME_LEAVE;
-				lptme.dwHoverTime = 0;
-				lptme.hwndTrack = hwnd;
-				TrackMouseEvent( &lptme );
-				MausTrack = 0;
-			}
-			MausEreignis me = { ME_Bewegung, mausPos.x, mausPos.y, 0, 0, 0 };
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-	case WM_MOUSEWHEEL: // Maus scroll
-		if( 1 )
-		{
-			MausEreignis me = { 0, mausPos.x, mausPos.y, 0, 0, 0 };
-			if( (int)(short)HIWORD( wparam ) < 0 )
-				me.id = !getTastenStand( T_Shift ) ? ME_DScroll : ME_RScroll;
-			else
-				me.id = !getTastenStand( T_Shift ) ? ME_UScroll : ME_LScroll;
-			me.rmx = me.mx;
-			me.rmy = me.my;
-			WFensterA.sendMausMessage( hwnd, me );
-			break;
-		}
-		// Tastatur 
-	case WM_KEYDOWN:
-		if( 1 )
-		{
-			TastaturEreignis te = { TE_Press, VirtualZuChar( (int)wparam ), 0 };
-			if( te.taste == T_Alt_Gr )
-				TastenStand[ T_Strg ] = 0;
-			TastenStand[ te.taste ] = 1;
-			WFensterA.sendTastaturMessage( hwnd, te );
-			break;
-		} // Taste wird gedrückt
-	case WM_KEYUP:
-		if( 1 )
-		{
-			TastaturEreignis te = { TE_Release, VirtualZuChar( (int)wparam ), 0 };
-			TastenStand[ te.taste ] = 0;
-			WFensterA.sendTastaturMessage( hwnd, te );
-			break;
-		} // Taste wird losgelassen
-	}
-	return ( DefWindowProc( hwnd, message, wparam, lparam ) );
+    if( msgExit )
+        return ( DefWindowProc( hwnd, message, wparam, lparam ) );
+    switch( message )
+    {
+        // Maus Zeiger 
+    case WM_SETCURSOR:
+        MausZeiger.update();
+        return 0;
+        // Fenster 
+    case WM_SIZE:
+        if( wparam == SIZE_RESTORED )
+            WFensterA.sendRestoreMessage( hwnd );
+        break;
+        // Schließen 
+    case WM_CLOSE:
+        if( WFensterA.sendVSchließMessage( hwnd ) )
+            return 0;
+        else
+            break;
+    case WM_DESTROY:
+        if( WFensterA.sendNSchließMessage( hwnd ) )
+            return 0;
+        else
+            break;
+        // Maus 
+    case WM_LBUTTONDOWN: // Linksklick
+        if( 1 )
+        {
+            MausStand[ M_Links ] = 1;
+            MausEreignis me = { ME_PLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_RBUTTONDOWN: // Rechtsklick
+        if( 1 )
+        {
+            MausStand[ M_Rechts ] = 1;
+            MausEreignis me = { ME_PRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MBUTTONDOWN: // Mittelklick
+        if( 1 )
+        {
+            MausStand[ M_Mitte ] = 1;
+            MausEreignis me = { ME_PMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_LBUTTONUP: // Linksrelease
+        if( 1 )
+        {
+            MausStand[ M_Links ] = 0;
+            MausEreignis me = { ME_RLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_RBUTTONUP: // Rechtsrelease
+        if( 1 )
+        {
+            MausStand[ M_Rechts ] = 0;
+            MausEreignis me = { ME_RRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MBUTTONUP: // Mittelrelease
+        if( 1 )
+        {
+            MausStand[ M_Mitte ] = 0;
+            MausEreignis me = { ME_RMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_LBUTTONDBLCLK: // Linksdoppelklick
+        if( 1 )
+        {
+            MausEreignis me = { ME_DKLinks, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_RBUTTONDBLCLK: // Rechtsdoppelklick
+        if( 1 )
+        {
+            MausEreignis me = { ME_DKRechts, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MBUTTONDBLCLK: // Mitteldoppelklick
+        if( 1 )
+        {
+            MausEreignis me = { ME_DKMitte, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MOUSEHOVER: // Maus betritt Fenster
+        if( 1 )
+        {
+            MausTrack = 1;
+            MausEreignis me = { ME_Betritt, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MOUSELEAVE: // Maus verlässt Fenster
+        if( 1 )
+        {
+            MausTrack = 1;
+            MausEreignis me = { ME_Verlässt, (int)LOWORD( lparam ), (int)HIWORD( lparam ), 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MOUSEMOVE: // Maus wird bewegt
+        if( 1 )
+        {
+            if( mausPos.x == (int)LOWORD( lparam ) && mausPos.y == (int)HIWORD( lparam ) )
+                break;
+            mausPos.x = (int)LOWORD( lparam );
+            mausPos.y = (int)HIWORD( lparam );
+            if( MausTrack )
+            {
+                TRACKMOUSEEVENT lptme;
+                lptme.cbSize = sizeof( TRACKMOUSEEVENT );
+                lptme.dwFlags = TME_HOVER | TME_LEAVE;
+                lptme.dwHoverTime = 0;
+                lptme.hwndTrack = hwnd;
+                TrackMouseEvent( &lptme );
+                MausTrack = 0;
+            }
+            MausEreignis me = { ME_Bewegung, mausPos.x, mausPos.y, 0, 0, 0 };
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+    case WM_MOUSEWHEEL: // Maus scroll
+        if( 1 )
+        {
+            MausEreignis me = { 0, mausPos.x, mausPos.y, 0, 0, 0 };
+            if( (int)(short)HIWORD( wparam ) < 0 )
+                me.id = !getTastenStand( T_Shift ) ? ME_DScroll : ME_RScroll;
+            else
+                me.id = !getTastenStand( T_Shift ) ? ME_UScroll : ME_LScroll;
+            me.rmx = me.mx;
+            me.rmy = me.my;
+            WFensterA.sendMausMessage( hwnd, me );
+            break;
+        }
+        // Tastatur 
+    case WM_KEYDOWN:
+        if( 1 )
+        {
+            TastaturEreignis te = { TE_Press, VirtualZuChar( (int)wparam ), 0 };
+            if( te.taste == T_Alt_Gr )
+                TastenStand[ T_Strg ] = 0;
+            TastenStand[ te.taste ] = 1;
+            WFensterA.sendTastaturMessage( hwnd, te );
+            break;
+        } // Taste wird gedrückt
+    case WM_KEYUP:
+        if( 1 )
+        {
+            TastaturEreignis te = { TE_Release, VirtualZuChar( (int)wparam ), 0 };
+            TastenStand[ te.taste ] = 0;
+            WFensterA.sendTastaturMessage( hwnd, te );
+            break;
+        } // Taste wird losgelassen
+    }
+    return ( DefWindowProc( hwnd, message, wparam, lparam ) );
 }
 
 void Framework::StartNachrichtenSchleife()
 {
-	MSG msg;
-	while( GetMessage( &msg, NULL, 0, 0 ) > 0 && !msgExit )
-	{
-		if( !msgExit )
-		{
-			TranslateMessage( &msg );
-			DispatchMessage( &msg );
-		}
-	}
-	msgExit = 0;
+    MSG msg;
+    while( GetMessage( &msg, NULL, 0, 0 ) > 0 && !msgExit )
+    {
+        if( !msgExit )
+        {
+            TranslateMessage( &msg );
+            DispatchMessage( &msg );
+        }
+    }
+    msgExit = 0;
 }
 
 void Framework::StopNachrichtenSchleife( HWND hwnd )
 {
-	msgExit = 1;
-	PostMessage( hwnd, WM_MOUSELEAVE, 0, 0 );
+    msgExit = 1;
+    PostMessage( hwnd, WM_MOUSELEAVE, 0, 0 );
 }
 
 unsigned char Framework::VirtualZuChar( int Virtual )
 {
-	UINT vk = MapVirtualKey( Virtual, 2 );
-	if( !vk )
-	{
-		switch( Virtual )
-		{
-		case VK_CAPITAL:
-			return T_Caps_Lock;
-		case VK_SHIFT:
-			return T_Shift;
-		case VK_CONTROL:
-			return T_Strg;
-		case VK_F1:
-			return T_F1;
-		case VK_F2:
-			return T_F2;
-		case VK_F3:
-			return T_F3;
-		case VK_F4:
-			return T_F4;
-		case VK_F5:
-			return T_F5;
-		case VK_F6:
-			return T_F6;
-		case VK_F7:
-			return T_F7;
-		case VK_F8:
-			return T_F8;
-		case VK_F9:
-			return T_F9;
-		case VK_F10:
-			return T_F10;
-		case VK_F11:
-			return T_F11;
-		case VK_F12:
-			return T_F12;
-		case VK_PAUSE:
-			return T_Pause;
-		case VK_SNAPSHOT:
-			return T_Druck;
-		case VK_INSERT:
-			return T_Einfg;
-		case VK_DELETE:
-			return T_Entf;
-		case VK_LEFT:
-			return T_Links;
-		case VK_UP:
-			return T_Oben;
-		case VK_RIGHT:
-			return T_Rechts;
-		case VK_DOWN:
-			return T_Unten;
-		case VK_MENU:
-			return T_Alt_Gr;
-		case VK_NUMLOCK:
-			return T_Num;
-		case VK_HOME:
-			return T_Pos1;
-		case VK_PRIOR:
-			return T_BildO;
-		case VK_NEXT:
-			return T_BildU;
-		case VK_END:
-			return T_Ende;
-		case VK_TAB:
-			return T_Tab;
-		}
-	}
-	if( vk == VK_TAB )
-		return T_Tab;
-	char ret = (char)(short)LOWORD( vk );
-	short SHIFT = GetKeyState( VK_SHIFT );
-	short CAPSLOCK = GetKeyState( VK_CAPITAL );
-	short ALTGR = TastenStand[ T_Alt_Gr ];
-	if( ALTGR )
-	{
-		switch( ret )
-		{
-		case 'q':
-			return '@';
-		case 'Q':
-			return '@';
-		case '<':
-			return '|';
-		case '>':
-			return '|';
-		case '7':
-			return '{';
-		case '/':
-			return '{';
-		case '8':
-			return '[';
-		case '(':
-			return '[';
-		case '9':
-			return ']';
-		case ')':
-			return ']';
-		case '0':
-			return '}';
-		case '=':
-			return '}';
-		case 'ß':
-			return '\\';
-		case '?':
-			return '\\';
-		case '+':
-			return '~';
-		case '*':
-			return '~';
-		case 'e':
-			return '€';
-		case 'E':
-			return '€';
-		case 'm':
-			return 'µ';
-		case 'M':
-			return 'µ';
-		case '2':
-			return '²';
-		case '"':
-			return '²';
-		case '3':
-			return '³';
-		case '§':
-			return '³';
-		}
-	}
-	SHIFT = HIWORD( SHIFT );
-	CAPSLOCK = LOWORD( CAPSLOCK );
-	bool up = 0;
-	if( SHIFT && !CAPSLOCK )
-		up = 1;
-	if( CAPSLOCK && !SHIFT )
-		up = 1;
-	ret = KleinOrGroß( ret, up );
-	return ret;
+    UINT vk = MapVirtualKey( Virtual, 2 );
+    if( !vk )
+    {
+        switch( Virtual )
+        {
+        case VK_CAPITAL:
+            return T_Caps_Lock;
+        case VK_SHIFT:
+            return T_Shift;
+        case VK_CONTROL:
+            return T_Strg;
+        case VK_F1:
+            return T_F1;
+        case VK_F2:
+            return T_F2;
+        case VK_F3:
+            return T_F3;
+        case VK_F4:
+            return T_F4;
+        case VK_F5:
+            return T_F5;
+        case VK_F6:
+            return T_F6;
+        case VK_F7:
+            return T_F7;
+        case VK_F8:
+            return T_F8;
+        case VK_F9:
+            return T_F9;
+        case VK_F10:
+            return T_F10;
+        case VK_F11:
+            return T_F11;
+        case VK_F12:
+            return T_F12;
+        case VK_PAUSE:
+            return T_Pause;
+        case VK_SNAPSHOT:
+            return T_Druck;
+        case VK_INSERT:
+            return T_Einfg;
+        case VK_DELETE:
+            return T_Entf;
+        case VK_LEFT:
+            return T_Links;
+        case VK_UP:
+            return T_Oben;
+        case VK_RIGHT:
+            return T_Rechts;
+        case VK_DOWN:
+            return T_Unten;
+        case VK_MENU:
+            return T_Alt_Gr;
+        case VK_NUMLOCK:
+            return T_Num;
+        case VK_HOME:
+            return T_Pos1;
+        case VK_PRIOR:
+            return T_BildO;
+        case VK_NEXT:
+            return T_BildU;
+        case VK_END:
+            return T_Ende;
+        case VK_TAB:
+            return T_Tab;
+        }
+    }
+    if( vk == VK_TAB )
+        return T_Tab;
+    char ret = (char)(short)LOWORD( vk );
+    short SHIFT = GetKeyState( VK_SHIFT );
+    short CAPSLOCK = GetKeyState( VK_CAPITAL );
+    short ALTGR = TastenStand[ T_Alt_Gr ];
+    if( ALTGR )
+    {
+        switch( ret )
+        {
+        case 'q':
+            return '@';
+        case 'Q':
+            return '@';
+        case '<':
+            return '|';
+        case '>':
+            return '|';
+        case '7':
+            return '{';
+        case '/':
+            return '{';
+        case '8':
+            return '[';
+        case '(':
+            return '[';
+        case '9':
+            return ']';
+        case ')':
+            return ']';
+        case '0':
+            return '}';
+        case '=':
+            return '}';
+        case 'ß':
+            return '\\';
+        case '?':
+            return '\\';
+        case '+':
+            return '~';
+        case '*':
+            return '~';
+        case 'e':
+            return '€';
+        case 'E':
+            return '€';
+        case 'm':
+            return 'µ';
+        case 'M':
+            return 'µ';
+        case '2':
+            return '²';
+        case '"':
+            return '²';
+        case '3':
+            return '³';
+        case '§':
+            return '³';
+        }
+    }
+    SHIFT = HIWORD( SHIFT );
+    CAPSLOCK = LOWORD( CAPSLOCK );
+    bool up = 0;
+    if( SHIFT && !CAPSLOCK )
+        up = 1;
+    if( CAPSLOCK && !SHIFT )
+        up = 1;
+    ret = KleinOrGroß( ret, up );
+    return ret;
 }
 
 // Inhalt der WFenster Klasse aus Fenster.h
 // Konstruktor 
 WFenster::WFenster()
-	: hWnd( 0 ),
-	  style( 0 ),
-	  makParam( 0 ),
-	  sakParam( 0 ),
-	  takParam( 0 ),
-	  MausAktion( 0 ),
-	  VSchließAktion( 0 ),
-	  NSchließAktion( 0 ),
-	  TastaturAktion( 0 ),
-	  screen( 0 ),
-	  mx( -1 ),
-	  my( -1 ),
-	  verschiebbar( 0 ),
-	  ref( 1 ),
-	  rahmen( 0 ),
-	  bitmap( 0 ),
-	  hdc( 0 )
-{
-	WFensterA.addFenster( this );
+    : hWnd( 0 ),
+    style( 0 ),
+    makParam( 0 ),
+    sakParam( 0 ),
+    takParam( 0 ),
+    MausAktion( 0 ),
+    VSchließAktion( 0 ),
+    NSchließAktion( 0 ),
+    TastaturAktion( 0 ),
+    screen( 0 ),
+    mx( -1 ),
+    my( -1 ),
+    verschiebbar( 0 ),
+    ref( 1 ),
+    rahmen( 0 ),
+    bitmap( 0 ),
+    hdc( 0 )
+{
+    WFensterA.addFenster( this );
 }
 
 WFenster::WFenster( HWND hwnd )
-	: WFenster()
+    : WFenster()
 {
-	hWnd = hwnd;
+    hWnd = hwnd;
 }
 
 // Destruktor 
 WFenster::~WFenster()
 {
-	if( WFensterA.removeFenster( this ) )
-	{
-		WFensterA.del();
-	}
+    if( WFensterA.removeFenster( this ) )
+    {
+        WFensterA.del();
+    }
     if( hWnd )
         zerstören();
-	if( screen )
-		screen->release();
+    if( screen )
+        screen->release();
 }
 
 // nicht constant 
 void WFenster::erstellen( int style, WNDCLASS wc ) // Erstellt ein Fenster in Windows
 {
-	if( !GetClassInfo( wc.hInstance, wc.lpszClassName, &wc ) )
-	{
+    if( !GetClassInfo( wc.hInstance, wc.lpszClassName, &wc ) )
+    {
 #pragma warning(suppress: 6102)
-		if( !RegisterClass( &wc ) ) // Register Fensterklasse
-		{
-			MessageBox( hWnd, "Fehler beim Registrieren der Fensterklasse!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
-			return;
-		}
-	}
+        if( !RegisterClass( &wc ) ) // Register Fensterklasse
+        {
+            MessageBox( hWnd, "Fehler beim Registrieren der Fensterklasse!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
+            return;
+        }
+    }
 
-	hWnd = CreateWindow( wc.lpszClassName, wc.lpszClassName, style, 0, 0, 0, 0, 0, 0, wc.hInstance, 0 ); // Fenster Erstellen
+    hWnd = CreateWindow( wc.lpszClassName, wc.lpszClassName, style, 0, 0, 0, 0, 0, 0, wc.hInstance, 0 ); // Fenster Erstellen
 
-	if( hWnd == 0 )
-	{
-		MessageBox( hWnd, "Fehler beim erstellen des Fensters!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
-		return;
-	}
-	this->style = style;
+    if( hWnd == 0 )
+    {
+        MessageBox( hWnd, "Fehler beim erstellen des Fensters!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
+        return;
+    }
+    this->style = style;
 }
 
 void WFenster::erstellenEx( int exStyle, int style, WNDCLASSEX wc ) // Das Fenster Erstellen
 {
-	if( !GetClassInfoEx( wc.hInstance, wc.lpszClassName, &wc ) )
-	{
+    if( !GetClassInfoEx( wc.hInstance, wc.lpszClassName, &wc ) )
+    {
 #pragma warning(suppress: 6102)
-		if( !RegisterClassEx( &wc ) ) // Register Fensterklasse
-		{
-			MessageBox( hWnd, "Fehler beim Registrieren der Fensterklasse!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
-			return;
-		}
-	}
+        if( !RegisterClassEx( &wc ) ) // Register Fensterklasse
+        {
+            MessageBox( hWnd, "Fehler beim Registrieren der Fensterklasse!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
+            return;
+        }
+    }
 
-	hWnd = CreateWindowEx( exStyle, wc.lpszClassName, wc.lpszClassName, style, 0, 0, 0, 0, 0, 0, wc.hInstance, 0 ); // Fenster Erstellen
+    hWnd = CreateWindowEx( exStyle, wc.lpszClassName, wc.lpszClassName, style, 0, 0, 0, 0, 0, 0, wc.hInstance, 0 ); // Fenster Erstellen
 
-	if( hWnd == 0 )
-	{
-		MessageBox( hWnd, "Fehler beim erstellen des Fensters!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
-		return;
-	}
-	this->style = style;
+    if( hWnd == 0 )
+    {
+        MessageBox( hWnd, "Fehler beim erstellen des Fensters!", "Error", MB_ICONERROR ); // Fehlermeldung bei Fehler
+        return;
+    }
+    this->style = style;
 }
 
 void WFenster::setAnzeigeModus( int mod )// Fenster Anzeigen
 {
-	if( rahmen )
-	{
-		if( mod == 2 )
-			ShowWindow( rahmen, 0 );
-		else
-			ShowWindow( rahmen, mod );
-	}
-	ShowWindow( hWnd, mod );
+    if( rahmen )
+    {
+        if( mod == 2 )
+            ShowWindow( rahmen, 0 );
+        else
+            ShowWindow( rahmen, mod );
+    }
+    ShowWindow( hWnd, mod );
 }
 
 bool WFenster::setFokus() // Setzt den Fokus auf das Fenster
 {
-	DWORD dwCurrentThread = GetCurrentThreadId();
-	DWORD dwFGThread = GetWindowThreadProcessId( GetForegroundWindow(), NULL );
-	AttachThreadInput( dwCurrentThread, dwFGThread, TRUE );
-	SetFocus( hWnd );
-	AttachThreadInput( dwCurrentThread, dwFGThread, FALSE );
-	SetWindowPos( hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
-	SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
-	return GetFocus() == hWnd;
+    DWORD dwCurrentThread = GetCurrentThreadId();
+    DWORD dwFGThread = GetWindowThreadProcessId( GetForegroundWindow(), NULL );
+    AttachThreadInput( dwCurrentThread, dwFGThread, TRUE );
+    SetFocus( hWnd );
+    AttachThreadInput( dwCurrentThread, dwFGThread, FALSE );
+    SetWindowPos( hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
+    SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW );
+    return GetFocus() == hWnd;
 }
 
 void WFenster::setPosition( Punkt &p )// Fenster Position
 {
-	RECT r;
-	GetWindowRect( hWnd, &r ); // Vorherige Position herausfinden
-	RECT res;
-	res.left = p.x, res.top = p.y, res.right = r.right - r.left, res.bottom = r.bottom - r.top;
-	AdjustWindowRect( &res, style, 0 );
-	if( res.top < 0 )
-	{
-		res.bottom -= res.top;
-		res.top = 0;
-	}
-	if( res.left < 0 )
-	{
-		res.right -= res.left;
-		res.left = 0;
-	}
-	SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Position ändern
+    RECT r;
+    GetWindowRect( hWnd, &r ); // Vorherige Position herausfinden
+    RECT res;
+    res.left = p.x, res.top = p.y, res.right = r.right - r.left, res.bottom = r.bottom - r.top;
+    AdjustWindowRect( &res, style, 0 );
+    if( res.top < 0 )
+    {
+        res.bottom -= res.top;
+        res.top = 0;
+    }
+    if( res.left < 0 )
+    {
+        res.right -= res.left;
+        res.left = 0;
+    }
+    SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Position ändern
 }
 
 void WFenster::setGröße( Punkt &g )// Fenster Größe
 {
-	RECT r;
-	GetWindowRect( hWnd, &r ); // vorherige Größe herausfinden
-	RECT res;
-	res.left = r.left, res.top = r.top, res.right = g.x, res.bottom = g.y;
-	AdjustWindowRect( &res, style, 0 );
-	if( res.top < 0 )
-	{
-		res.bottom -= res.top;
-		res.top = 0;
-	}
-	if( res.left < 0 )
-	{
-		res.right -= res.left;
-		res.left = 0;
-	}
-	SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Größe ändern
+    RECT r;
+    GetWindowRect( hWnd, &r ); // vorherige Größe herausfinden
+    RECT res;
+    res.left = r.left, res.top = r.top, res.right = g.x, res.bottom = g.y;
+    AdjustWindowRect( &res, style, 0 );
+    if( res.top < 0 )
+    {
+        res.bottom -= res.top;
+        res.top = 0;
+    }
+    if( res.left < 0 )
+    {
+        res.right -= res.left;
+        res.left = 0;
+    }
+    SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Größe ändern
 }
 
 void WFenster::setGröße( int breite, int höhe )
 {
-	RECT r;
-	GetWindowRect( hWnd, &r ); // vorherige Größe herausfinden
-	RECT res;
-	res.left = r.left, res.top = r.top, res.right = breite, res.bottom = höhe;
-	AdjustWindowRect( &res, style, 0 );
-	if( res.top < 0 )
-	{
-		res.bottom -= res.top;
-		res.top = 0;
-	}
-	if( res.left < 0 )
-	{
-		res.right -= res.left;
-		res.left = 0;
-	}
-	SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Größe ändern
+    RECT r;
+    GetWindowRect( hWnd, &r ); // vorherige Größe herausfinden
+    RECT res;
+    res.left = r.left, res.top = r.top, res.right = breite, res.bottom = höhe;
+    AdjustWindowRect( &res, style, 0 );
+    if( res.top < 0 )
+    {
+        res.bottom -= res.top;
+        res.top = 0;
+    }
+    if( res.left < 0 )
+    {
+        res.right -= res.left;
+        res.left = 0;
+    }
+    SetWindowPos( hWnd, 0, res.left, res.top, res.right, res.bottom, 0 ); // Größe ändern
 }
 
 void WFenster::setBounds( Punkt &p, Punkt &g ) // setzt größe und Position
 {
-	SetWindowPos( hWnd, 0, p.x, p.y, g.x, g.y, 0 ); // Größe und Position ändern
+    SetWindowPos( hWnd, 0, p.x, p.y, g.x, g.y, 0 ); // Größe und Position ändern
 }
 
 void WFenster::setBildschirm( Bildschirm *screen )
 {
-	if( this->screen )
-		this->screen->release();
-	this->screen = screen;
+    if( this->screen )
+        this->screen->release();
+    this->screen = screen;
 }
 
 void WFenster::zerstören()
 {
-	DestroyWindow( hWnd );
+    DestroyWindow( hWnd );
     hWnd = 0;
-	if( rahmen )
-		DestroyWindow( rahmen );
+    if( rahmen )
+        DestroyWindow( rahmen );
     rahmen = 0;
-	if( bitmap )
-		DeleteObject( bitmap );
+    if( bitmap )
+        DeleteObject( bitmap );
     bitmap = 0;
-	if( hdc )
-		DeleteDC( hdc );
+    if( hdc )
+        DeleteDC( hdc );
     hdc = 0;
 }
 
 void WFenster::doMausAktion( MausEreignis &me )
 {
-	if( !MausAktion || !MausAktion( makParam, this, me ) )
-		return;
-	if( screen && me.id != ME_Betritt && me.id != ME_Verlässt )
-	{
-		screen->doMausEreignis( me );
-		if( !me.verarbeitet && verschiebbar )
-		{
-			if( mx != -1 && my != -1 ) // verschieben
-			{
-				RECT r;
-				if( rahmen )
-				{
-					GetWindowRect( rahmen, &r );
-					r.right -= r.left, r.bottom -= r.top;
-					r.left += me.mx - mx;
-					r.top += me.my - my;
-					SetWindowPos( rahmen, 0, r.left, r.top, r.right, r.bottom, 0 ); // Position setzen
-				}
-				GetWindowRect( hWnd, &r ); // Vorherige Position herausfinden
-				r.right -= r.left, r.bottom -= r.top; // Position updaten
-				r.left += me.mx - mx;
-				r.top += me.my - my;
-				SetWindowPos( hWnd, 0, r.left, r.top, r.right, r.bottom, 0 ); // Position setzen
-
-			}
-			else if( me.id == ME_PLinks ) // verschieben starten
-				mx = me.mx, my = me.my;
-			if( me.id == ME_RLinks ) // verschieben beenden
-				mx = -1, my = -1;
-			me.verarbeitet = 1;
-		}
-	}
+    if( !MausAktion || !MausAktion( makParam, this, me ) )
+        return;
+    if( screen && me.id != ME_Betritt && me.id != ME_Verlässt )
+    {
+        screen->doMausEreignis( me );
+        if( !me.verarbeitet && verschiebbar )
+        {
+            if( mx != -1 && my != -1 ) // verschieben
+            {
+                RECT r;
+                if( rahmen )
+                {
+                    GetWindowRect( rahmen, &r );
+                    r.right -= r.left, r.bottom -= r.top;
+                    r.left += me.mx - mx;
+                    r.top += me.my - my;
+                    SetWindowPos( rahmen, 0, r.left, r.top, r.right, r.bottom, 0 ); // Position setzen
+                }
+                GetWindowRect( hWnd, &r ); // Vorherige Position herausfinden
+                r.right -= r.left, r.bottom -= r.top; // Position updaten
+                r.left += me.mx - mx;
+                r.top += me.my - my;
+                SetWindowPos( hWnd, 0, r.left, r.top, r.right, r.bottom, 0 ); // Position setzen
+
+            }
+            else if( me.id == ME_PLinks ) // verschieben starten
+                mx = me.mx, my = me.my;
+            if( me.id == ME_RLinks ) // verschieben beenden
+                mx = -1, my = -1;
+            me.verarbeitet = 1;
+        }
+    }
 }
 
 void WFenster::doVSchließAktion()
 {
-	if( !VSchließAktion )
-		return;
-	VSchließAktion( sakParam, this );
+    if( !VSchließAktion )
+        return;
+    VSchließAktion( sakParam, this );
 }
 
 void WFenster::doNSchließAktion()
 {
-	if( !NSchließAktion )
-		return;
-	NSchließAktion( sakParam, this );
+    if( !NSchließAktion )
+        return;
+    NSchließAktion( sakParam, this );
 }
 
 void WFenster::doTastaturAktion( TastaturEreignis &te )
 {
-	if( !TastaturAktion || !TastaturAktion( takParam, this, te ) )
-		return;
-	if( screen )
-		screen->doTastaturEreignis( te );
+    if( !TastaturAktion || !TastaturAktion( takParam, this, te ) )
+        return;
+    if( screen )
+        screen->doTastaturEreignis( te );
 }
 
 void WFenster::doRestoreMessage() // macht den Rahmen sichtbar
 {
-	if( rahmen )
-		ShowWindow( rahmen, 1 );
-	ShowWindow( hWnd, 1 );
+    if( rahmen )
+        ShowWindow( rahmen, 1 );
+    ShowWindow( hWnd, 1 );
 }
 
 void WFenster::setMausEreignisParameter( void *p ) // setzt den Parameter vom Maus Ereignis
 {
-	makParam = p;
+    makParam = p;
 }
 
 void WFenster::setSchließEreignisParameter( void *p ) // setzt den Parameter vom Schließ Ereignis
 {
-	sakParam = p;
+    sakParam = p;
 }
 
 void WFenster::setTastaturEreignisParameter( void *p ) // setzt den Parameter vom Tastatur Ereignis
 {
-	takParam = p;
+    takParam = p;
 }
 
 void WFenster::setMausAktion( bool( *MausAk )( void *, void *, MausEreignis ) )
 {
-	MausAktion = MausAk;
+    MausAktion = MausAk;
 }
 
 void WFenster::setVSchließAktion( void( *vSchließAk )( void *, void * ) )
 {
-	VSchließAktion = vSchließAk;
+    VSchließAktion = vSchließAk;
 }
 
 void WFenster::setNSchließAktion( void( *nSchließAk )( void *, void * ) )
 {
-	NSchließAktion = nSchließAk;
+    NSchließAktion = nSchließAk;
 }
 
 void WFenster::setTastaturAktion( bool( *TastaturAk )( void *, void *, TastaturEreignis ) )
 {
-	TastaturAktion = TastaturAk;
+    TastaturAktion = TastaturAk;
 }
 
 void WFenster::setFensterHandle( HWND hWnd ) // setzt das operationsfenster
 {
-	this->hWnd = hWnd;
+    this->hWnd = hWnd;
 }
 
 void WFenster::setVerschiebbar( bool verschiebbar ) // legt fest, ob das Fenster durch ziehen mit Maus verschoben werden kann
 {
-	this->verschiebbar = verschiebbar;
+    this->verschiebbar = verschiebbar;
 }
 
 void WFenster::ladeRahmenFenster( Bild *zBild, HINSTANCE hinst ) // setzt einen Transpatenten Rahmen um das Fenster
 {
-	if( !zBild )
-		return;
-	// Fenster erstellen
-	WNDCLASSEX wcl = { 0 };
-	wcl.cbSize = sizeof( wcl );
-	wcl.style = CS_HREDRAW | CS_VREDRAW;
-	wcl.lpfnWndProc = WindowProc;
-	wcl.cbClsExtra = 0;
-	wcl.cbWndExtra = 0;
-	wcl.hInstance = hinst;
-	wcl.hIcon = LoadIcon( NULL, IDI_APPLICATION );
-	wcl.hCursor = LoadCursor( NULL, IDC_ARROW );
-	wcl.hbrBackground = NULL;
-	wcl.lpszMenuName = NULL;
-	wcl.lpszClassName = TEXT( "LayeredWindowClass" );
-	wcl.hIconSm = NULL;
-
-	// Bitmap erstellen
-	hdc = CreateCompatibleDC( NULL );
-	if( !hdc )
-		return;
-	BITMAPINFO info;
-	info.bmiHeader.biSize = sizeof( info.bmiHeader );
-	info.bmiHeader.biBitCount = 32;
-	info.bmiHeader.biWidth = zBild->getBreite();
-	info.bmiHeader.biHeight = -zBild->getHöhe();
-	info.bmiHeader.biCompression = BI_RGB;
-	info.bmiHeader.biPlanes = 1;
-	unsigned char *pPixels = 0;
-	bitmap = CreateDIBSection( hdc, &info, DIB_RGB_COLORS, (void**)&pPixels, 0, 0 );
-	if( !bitmap )
-		DeleteDC( hdc );
-	GdiFlush();
-	// bitmap füllen
-	int pitch = ( ( zBild->getBreite() * 32 + 31 ) & ~31 ) >> 3;
-	unsigned char *pRow = 0;
-	int *buffer = zBild->getBuffer();
-	for( int i = 0; i < zBild->getHöhe(); ++i )
-	{
-		pRow = &pPixels[ i * pitch ];
-		for( int i2 = 0; i2 < zBild->getBreite(); ++i2 )
-		{
-			pRow[ i2 * 4 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 16 ) & 0xFF );
-			pRow[ i2 * 4 + 1 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 8 ) & 0xFF );
-			pRow[ i2 * 4 + 2 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] ) & 0xFF );
-			pRow[ i2 * 4 + 3 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 24 ) & 0xFF );
-		}
-	}
-	// alpha berechnen
-	unsigned char *pPixel = 0;
-	if( zBild->getBreite() * 4 == pitch )
-	{
-		int i = 0;
-		int totalBytes = zBild->getBreite() * zBild->getHöhe() * 4;
-
-		for( i = 0; i < totalBytes; i += 4 )
-		{
-			pPixel = &pPixels[ i ];
-			pPixel[ 0 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-			pPixel[ 1 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-			pPixel[ 2 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-		}
-	}
-	else
-	{
-		int x = 0;
-		int y = 0;
-
-		for( y = 0; y < zBild->getHöhe(); ++y )
-		{
-			for( x = 0; x < zBild->getBreite(); ++x )
-			{
-				pPixel = &pPixels[ ( y * pitch ) + ( x * 4 ) ];
-				pPixel[ 0 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-				pPixel[ 1 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-				pPixel[ 2 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
-			}
-		}
-	}
-	// Fenster erstellen fortsetzen
-	if( RegisterClassEx( &wcl ) )
-	{
-		rahmen = CreateWindowEx( WS_EX_TOOLWINDOW | WS_EX_LAYERED,
-								 wcl.lpszClassName,
-								 TEXT( "Transparentes Fenster" ),
-								 WS_POPUP,
-								 0,
-								 0,
-								 zBild->getBreite(),
-								 zBild->getHöhe(),
-								 0,
-								 0,
-								 wcl.hInstance,
-								 0
-								 );
-		if( rahmen )
-		{
-			// zeichnen
-			HDC h = 0;
-			if( ( h = GetDC( rahmen ) ) && bitmap )
-			{
-				HGDIOBJ hPrevObj = NULL;
-				POINT ptDest = { 0, 0 };
-				POINT ptSrc = { 0, 0 };
-				SIZE client = { zBild->getBreite(), zBild->getHöhe() };
-				BLENDFUNCTION blendFunc = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
-
-				hPrevObj = SelectObject( hdc, bitmap );
-				ClientToScreen( rahmen, &ptDest );
-
-				UpdateLayeredWindow( rahmen, h, &ptDest, &client, hdc, &ptSrc, 0, &blendFunc, ULW_ALPHA );
-
-				SelectObject( hdc, hPrevObj );
-				ReleaseDC( rahmen, h );
-			}
-			UpdateWindow( rahmen );
-			Punkt pos = getPosition() + ( getGröße() - zBild->getGröße() ) / 2;
-			SetWindowPos( rahmen, 0, pos.x, pos.y, zBild->getBreite(), zBild->getHöhe(), 0 );
-		}
-	}
+    if( !zBild )
+        return;
+    // Fenster erstellen
+    WNDCLASSEX wcl = { 0 };
+    wcl.cbSize = sizeof( wcl );
+    wcl.style = CS_HREDRAW | CS_VREDRAW;
+    wcl.lpfnWndProc = WindowProc;
+    wcl.cbClsExtra = 0;
+    wcl.cbWndExtra = 0;
+    wcl.hInstance = hinst;
+    wcl.hIcon = LoadIcon( NULL, IDI_APPLICATION );
+    wcl.hCursor = LoadCursor( NULL, IDC_ARROW );
+    wcl.hbrBackground = NULL;
+    wcl.lpszMenuName = NULL;
+    wcl.lpszClassName = TEXT( "LayeredWindowClass" );
+    wcl.hIconSm = NULL;
+
+    // Bitmap erstellen
+    hdc = CreateCompatibleDC( NULL );
+    if( !hdc )
+        return;
+    BITMAPINFO info;
+    info.bmiHeader.biSize = sizeof( info.bmiHeader );
+    info.bmiHeader.biBitCount = 32;
+    info.bmiHeader.biWidth = zBild->getBreite();
+    info.bmiHeader.biHeight = -zBild->getHöhe();
+    info.bmiHeader.biCompression = BI_RGB;
+    info.bmiHeader.biPlanes = 1;
+    unsigned char *pPixels = 0;
+    bitmap = CreateDIBSection( hdc, &info, DIB_RGB_COLORS, (void**)&pPixels, 0, 0 );
+    if( !bitmap )
+        DeleteDC( hdc );
+    GdiFlush();
+    // bitmap füllen
+    int pitch = ( ( zBild->getBreite() * 32 + 31 ) & ~31 ) >> 3;
+    unsigned char *pRow = 0;
+    int *buffer = zBild->getBuffer();
+    for( int i = 0; i < zBild->getHöhe(); ++i )
+    {
+        pRow = &pPixels[ i * pitch ];
+        for( int i2 = 0; i2 < zBild->getBreite(); ++i2 )
+        {
+            pRow[ i2 * 4 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 16 ) & 0xFF );
+            pRow[ i2 * 4 + 1 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 8 ) & 0xFF );
+            pRow[ i2 * 4 + 2 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] ) & 0xFF );
+            pRow[ i2 * 4 + 3 ] = (unsigned char)( ( buffer[ i2 + i * zBild->getBreite() ] >> 24 ) & 0xFF );
+        }
+    }
+    // alpha berechnen
+    unsigned char *pPixel = 0;
+    if( zBild->getBreite() * 4 == pitch )
+    {
+        int i = 0;
+        int totalBytes = zBild->getBreite() * zBild->getHöhe() * 4;
+
+        for( i = 0; i < totalBytes; i += 4 )
+        {
+            pPixel = &pPixels[ i ];
+            pPixel[ 0 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+            pPixel[ 1 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+            pPixel[ 2 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+        }
+    }
+    else
+    {
+        int x = 0;
+        int y = 0;
+
+        for( y = 0; y < zBild->getHöhe(); ++y )
+        {
+            for( x = 0; x < zBild->getBreite(); ++x )
+            {
+                pPixel = &pPixels[ ( y * pitch ) + ( x * 4 ) ];
+                pPixel[ 0 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+                pPixel[ 1 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+                pPixel[ 2 ] *= (unsigned char)( (float)pPixel[ 3 ] / 255.0f );
+            }
+        }
+    }
+    // Fenster erstellen fortsetzen
+    if( RegisterClassEx( &wcl ) )
+    {
+        rahmen = CreateWindowEx( WS_EX_TOOLWINDOW | WS_EX_LAYERED,
+                                 wcl.lpszClassName,
+                                 TEXT( "Transparentes Fenster" ),
+                                 WS_POPUP,
+                                 0,
+                                 0,
+                                 zBild->getBreite(),
+                                 zBild->getHöhe(),
+                                 0,
+                                 0,
+                                 wcl.hInstance,
+                                 0
+        );
+        if( rahmen )
+        {
+            // zeichnen
+            HDC h = 0;
+            if( ( h = GetDC( rahmen ) ) && bitmap )
+            {
+                HGDIOBJ hPrevObj = NULL;
+                POINT ptDest = { 0, 0 };
+                POINT ptSrc = { 0, 0 };
+                SIZE client = { zBild->getBreite(), zBild->getHöhe() };
+                BLENDFUNCTION blendFunc = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+
+                hPrevObj = SelectObject( hdc, bitmap );
+                ClientToScreen( rahmen, &ptDest );
+
+                UpdateLayeredWindow( rahmen, h, &ptDest, &client, hdc, &ptSrc, 0, &blendFunc, ULW_ALPHA );
+
+                SelectObject( hdc, hPrevObj );
+                ReleaseDC( rahmen, h );
+            }
+            UpdateWindow( rahmen );
+            Punkt pos = getPosition() + ( getGröße() - zBild->getGröße() ) / 2;
+            SetWindowPos( rahmen, 0, pos.x, pos.y, zBild->getBreite(), zBild->getHöhe(), 0 );
+        }
+    }
 }
 
 // constant 
 Punkt WFenster::getPosition() const // gibt die Position zurück
 {
-	RECT r;
-	GetWindowRect( hWnd, &r ); // Position herausfinden
-	return{ r.left, r.top };
+    RECT r;
+    GetWindowRect( hWnd, &r ); // Position herausfinden
+    return{ r.left, r.top };
 }
 
 Punkt WFenster::getGröße() const // gibt die Größe zurück
 {
-	RECT r;
-	GetWindowRect( hWnd, &r ); // Größe herausfinden
-	return{ r.right - r.left, r.bottom - r.top };
+    RECT r;
+    GetWindowRect( hWnd, &r ); // Größe herausfinden
+    return{ r.right - r.left, r.bottom - r.top };
 }
 
 Punkt WFenster::getKörperGröße() const // gibt die Fenster Körpergröße zurück
 {
-	RECT r;
-	GetClientRect( hWnd, &r ); // Größe herausfinden
-	return{ r.right - r.left, r.bottom - r.top };
+    RECT r;
+    GetClientRect( hWnd, &r ); // Größe herausfinden
+    return{ r.right - r.left, r.bottom - r.top };
 }
 
 int WFenster::getKörperBreite() const // gibt die Fenster Körperbreite zurück
 {
-	RECT r;
-	GetClientRect( hWnd, &r ); // Größe herausfinden
-	return r.right;
+    RECT r;
+    GetClientRect( hWnd, &r ); // Größe herausfinden
+    return r.right;
 }
 
 int WFenster::getKörperHöhe() const // gibt die Fenster Körperhöhe zurück
 {
-	RECT r;
-	GetClientRect( hWnd, &r ); // Größe herausfinden
-	return r.bottom;
+    RECT r;
+    GetClientRect( hWnd, &r ); // Größe herausfinden
+    return r.bottom;
 }
 
 HWND WFenster::getFensterHandle() const // gibt ein Handle zum Fenster zurück
 {
-	return hWnd;
+    return hWnd;
 }
 
 bool WFenster::hatMausAktion() const
 {
-	return MausAktion != 0;
+    return MausAktion != 0;
 }
 
 bool WFenster::hatVSchließAktion() const
 {
-	return VSchließAktion != 0;
+    return VSchließAktion != 0;
 }
 
 bool WFenster::hatNSchließAktion() const
 {
-	return NSchließAktion != 0;
+    return NSchließAktion != 0;
 }
 
 bool WFenster::hatTastaturAktion() const
 {
-	return TastaturAktion != 0;
+    return TastaturAktion != 0;
 }
 
 Bildschirm *WFenster::getBildschirm() const
 {
-	if( !screen )
-		return 0;
-	return screen->getThis();
+    if( !screen )
+        return 0;
+    return screen->getThis();
 }
 
 Bildschirm *WFenster::zBildschirm() const
 {
-	return screen;
+    return screen;
 }
 
 bool WFenster::istVerschiebbar() const // prüft, ob das Fenster durch ziehen mit Maus verschoben werden kann
 {
-	return verschiebbar;
+    return verschiebbar;
 }
 
 // Reference Counting
 WFenster *WFenster::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 WFenster *WFenster::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der WFensterArray Klasse aus Fenster.h
 // Konstruktor 
 WFensterArray::WFensterArray()
-	: next( 0 ),
-	  This( 0 )
-{
-}
+    : next( 0 ),
+    This( 0 )
+{}
 
 // Destruktor 
 WFensterArray::~WFensterArray()
 {
-	if( next )
-		delete next;
+    if( next )
+        delete next;
 }
 
 // add und remove 
 bool WFensterArray::addFenster( WFenster *fenster )
 {
-	if( fenster == This )
-		return 0;
-	if( !This )
-	{
-		This = fenster;
-		return 1;
-	}
-	if( !next )
-		next = new WFensterArray();
-	return next->addFenster( fenster );
+    if( fenster == This )
+        return 0;
+    if( !This )
+    {
+        This = fenster;
+        return 1;
+    }
+    if( !next )
+        next = new WFensterArray();
+    return next->addFenster( fenster );
 }
 
 bool WFensterArray::removeFenster( WFenster *fenster )
 {
-	if( fenster == This )
-		return 1;
-	if( !next )
-		return 0;
-	if( next->removeFenster( fenster ) )
-	{
-		WFensterArray *tmp = next->getNext();
-		next->setNext0();
-		delete next;
-		next = tmp;
-	}
-	return 0;
+    if( fenster == This )
+        return 1;
+    if( !next )
+        return 0;
+    if( next->removeFenster( fenster ) )
+    {
+        WFensterArray *tmp = next->getNext();
+        next->setNext0();
+        delete next;
+        next = tmp;
+    }
+    return 0;
 }
 
 WFensterArray *WFensterArray::getNext()
 {
-	return next;
+    return next;
 }
 
 void WFensterArray::setNext0()
 {
-	next = 0;
+    next = 0;
 }
 
 void WFensterArray::del()
 {
-	if( next )
-	{
-		This = next->getThis();
-		WFensterArray *tmp = next->getNext();
-		next->setNext0();
-		delete next;
-		next = tmp;
-	}
-	else
-		This = 0;
+    if( next )
+    {
+        This = next->getThis();
+        WFensterArray *tmp = next->getNext();
+        next->setNext0();
+        delete next;
+        next = tmp;
+    }
+    else
+        This = 0;
 }
 
 // Messages 
 bool WFensterArray::sendVSchließMessage( HWND hwnd )
 {
-	if( !This )
-		return 0;
-	bool ret = 0;
-	if( This->getFensterHandle() == hwnd && This->hatVSchließAktion() )
-	{
-		This->doVSchließAktion();
-		ret = 1;
-	}
-	if( !next )
-		return ret;
-	return ret | next->sendVSchließMessage( hwnd );
+    if( !This )
+        return 0;
+    bool ret = 0;
+    if( This->getFensterHandle() == hwnd && This->hatVSchließAktion() )
+    {
+        This->doVSchließAktion();
+        ret = 1;
+    }
+    if( !next )
+        return ret;
+    return ret | next->sendVSchließMessage( hwnd );
 }
 
 bool WFensterArray::sendNSchließMessage( HWND hwnd )
 {
-	if( !This )
-		return 0;
-	bool ret = 0;
-	if( This->getFensterHandle() == hwnd && This->hatNSchließAktion() )
-	{
-		This->doNSchließAktion();
-		ret = 1;
-	}
-	if( !next )
-		return ret;
-	return ret | next->sendNSchließMessage( hwnd );
+    if( !This )
+        return 0;
+    bool ret = 0;
+    if( This->getFensterHandle() == hwnd && This->hatNSchließAktion() )
+    {
+        This->doNSchließAktion();
+        ret = 1;
+    }
+    if( !next )
+        return ret;
+    return ret | next->sendNSchließMessage( hwnd );
 }
 
 bool WFensterArray::sendMausMessage( HWND hwnd, MausEreignis &me )
 {
-	if( !This )
-		return 0;
-	bool ret = 0;
-	if( This->getFensterHandle() == hwnd && This->hatMausAktion() )
-	{
-		This->doMausAktion( me );
-		ret = 1;
-	}
-	if( !next )
-		return ret;
-	return ret | next->sendMausMessage( hwnd, me );
+    if( !This )
+        return 0;
+    bool ret = 0;
+    if( This->getFensterHandle() == hwnd && This->hatMausAktion() )
+    {
+        This->doMausAktion( me );
+        ret = 1;
+    }
+    if( !next )
+        return ret;
+    return ret | next->sendMausMessage( hwnd, me );
 }
 
 bool WFensterArray::sendTastaturMessage( HWND hwnd, TastaturEreignis &te )
 {
-	if( !This )
-		return 0;
-	bool ret = 0;
-	if( This->getFensterHandle() == hwnd && This->hatTastaturAktion() )
-	{
-		This->doTastaturAktion( te );
-		ret = 1;
-	}
-	if( !next )
-		return ret;
-	return ret | next->sendTastaturMessage( hwnd, te );
+    if( !This )
+        return 0;
+    bool ret = 0;
+    if( This->getFensterHandle() == hwnd && This->hatTastaturAktion() )
+    {
+        This->doTastaturAktion( te );
+        ret = 1;
+    }
+    if( !next )
+        return ret;
+    return ret | next->sendTastaturMessage( hwnd, te );
 }
 
 bool WFensterArray::sendRestoreMessage( HWND hwnd )
 {
-	if( !This )
-		return 0;
-	bool ret = 0;
-	if( This->getFensterHandle() == hwnd && This->hatMausAktion() )
-	{
-		This->doRestoreMessage();
-		ret = 1;
-	}
-	if( !next )
-		return ret;
-	return ret | next->sendRestoreMessage( hwnd );
+    if( !This )
+        return 0;
+    bool ret = 0;
+    if( This->getFensterHandle() == hwnd && This->hatMausAktion() )
+    {
+        This->doRestoreMessage();
+        ret = 1;
+    }
+    if( !next )
+        return ret;
+    return ret | next->sendRestoreMessage( hwnd );
 }
 
 WFenster *WFensterArray::getThis()
 {
-	return This;
+    return This;
 }
 
 // WMessageBox
 void Framework::WMessageBox( HWND hWnd, Text *titel, Text *meldung, UINT style )
 {
-	MessageBox( hWnd, meldung->getText(), titel->getText(), style ); // Message Box
-	titel->release();
-	meldung->release();
+    MessageBox( hWnd, meldung->getText(), titel->getText(), style ); // Message Box
+    titel->release();
+    meldung->release();
 }
 
 // Inhalt der Fenster Klasse aus Fenster.h
 // Konstruktor 
 Fenster::Fenster()
-	: Zeichnung(),
-	schließenMe( 0 ),
-	schließenMeParam( 0 ),
-	rahmen( 0 ),
-	titel( 0 ),
-	members( 0 ),
-	bgKörperFarbe( 0xFF000000 ),
-	bgKörperBild( 0 ),
-	körperBuffer( 0 ),
-	bgSchließFarbe( 0xFF000000 ),
-	bgSchließBild( 0 ),
-	schließBuffer( 0 ),
-	schließKlickBuffer( 0 ),
-	vScroll( 0 ),
-	hScroll( 0 ),
-	kMin( 0, 0 ),
-	kMax( 0, 0 ),
-	schließKlick( 0 ),
-	klick( 0 ),
-	mx( 0 ),
-	my( 0 ),
-	ref( 1 )
+    : Zeichnung(),
+    schließenMe( 0 ),
+    schließenMeParam( 0 ),
+    rahmen( 0 ),
+    titel( 0 ),
+    members( 0 ),
+    bgKörperFarbe( 0xFF000000 ),
+    bgKörperBild( 0 ),
+    körperBuffer( 0 ),
+    bgSchließFarbe( 0xFF000000 ),
+    bgSchließBild( 0 ),
+    schließBuffer( 0 ),
+    schließKlickBuffer( 0 ),
+    vScroll( 0 ),
+    hScroll( 0 ),
+    kMin( 0, 0 ),
+    kMax( 0, 0 ),
+    schließKlick( 0 ),
+    klick( 0 ),
+    mx( 0 ),
+    my( 0 ),
+    ref( 1 )
 {
     style = 0;
-	this->setMausEreignis( _ret1ME );
-	this->setTastaturEreignis( _ret1TE );
-	min = Punkt( 0, 0 ), max = Punkt( 0, 0 );
+    this->setMausEreignis( _ret1ME );
+    this->setTastaturEreignis( _ret1TE );
+    min = Punkt( 0, 0 ), max = Punkt( 0, 0 );
 }
 
 // Destruktor 
 Fenster::~Fenster()
 {
-	if( rahmen )
-		rahmen->release();
-	if( titel )
-		titel->release();
-	if( members )
-		delete members;
-	if( körperBuffer )
-		körperBuffer->release();
-	if( bgKörperBild )
-		bgKörperBild->release();
-	if( bgSchließBild )
-		bgSchließBild->release();
-	if( schließBuffer )
-		schließBuffer->release();
-	if( schließKlickBuffer )
-		schließKlickBuffer->release();
-	if( vScroll )
-		vScroll->release();
-	if( hScroll )
-		hScroll->release();
+    if( rahmen )
+        rahmen->release();
+    if( titel )
+        titel->release();
+    if( members )
+        delete members;
+    if( körperBuffer )
+        körperBuffer->release();
+    if( bgKörperBild )
+        bgKörperBild->release();
+    if( bgSchließBild )
+        bgSchließBild->release();
+    if( schließBuffer )
+        schließBuffer->release();
+    if( schließKlickBuffer )
+        schließKlickBuffer->release();
+    if( vScroll )
+        vScroll->release();
+    if( hScroll )
+        hScroll->release();
 }
 
 // nicht const 
 // -- Rahmen -- 
 void Fenster::setRahmenZ( LRahmen *ram ) // setzt den rahmen
 {
-	if( rahmen )
-		rahmen->release();
-	rahmen = ram;
-	rend = 1;
+    if( rahmen )
+        rahmen->release();
+    rahmen = ram;
+    rend = 1;
 }
 
 void Fenster::setRFarbe( int f ) // setzt die Rahmen Farbe
 {
-	if( !rahmen )
-		rahmen = new LRahmen();
-	rahmen->setFarbe( f );
-	rend = 1;
+    if( !rahmen )
+        rahmen = new LRahmen();
+    rahmen->setFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setRBreite( int br ) // setzt die Breite des Rahmens
 {
-	if( !rahmen )
-		rahmen = new LRahmen();
-	rahmen->setRamenBreite( br );
-	rend = 1;
+    if( !rahmen )
+        rahmen = new LRahmen();
+    rahmen->setRamenBreite( br );
+    rend = 1;
 }
 
 // -- Titel -- 
 void Fenster::setTitel( Text *txt ) // setzt den Titel
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setText( txt );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setText( txt );
+    rend = 1;
 }
 
 void Fenster::setTitelZ( Text *txt )
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setTextZ( txt );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setTextZ( txt );
+    rend = 1;
 }
 
 void Fenster::setTitel( const char *txt )
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setText( txt );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setText( txt );
+    rend = 1;
 }
 
 void Fenster::setTTextFeldZ( TextFeld *tf ) // setzt das Titel TextFeld
 {
-	if( titel )
-		titel->release();
-	titel = tf;
-	rend = 1;
+    if( titel )
+        titel->release();
+    titel = tf;
+    rend = 1;
 }
 
 // -- Schrift -- 
 void Fenster::setTSchriftZ( Schrift *schrift ) // setzt die Titel Schrift
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setSchriftZ( schrift );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setSchriftZ( schrift );
+    rend = 1;
 }
 
 void Fenster::setTSFarbe( int f ) // setzt die Titel Schrift Farbe
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setSchriftFarbe( f );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setSchriftFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setTSGröße( int gr ) // setzt die Titel Schrift Größe
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setSchriftGröße( gr );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setSchriftGröße( gr );
+    rend = 1;
 }
 
 // -- Titel Hintergrund -- 
 void Fenster::setTBgFarbe( int f ) // setzt Titel Hintergrund farbe
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setHintergrundFarbe( f );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setHintergrundFarbe( f );
+    rend = 1;
 }
 
 // -- Titel AlphaFeld -- 
 void Fenster::setTAlphaFeldZ( AlphaFeld *af ) // setzt das Titel AlphaFeld
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setAlphaFeldZ( af );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setAlphaFeldZ( af );
+    rend = 1;
 }
 
 void Fenster::setTAfFarbe( int f ) // setzt die Titel AlphFeld Farbe
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setAlphaFeldFarbe( f );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setAlphaFeldFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setTAfStärke( int st ) // setzt die Stärke des Titel AlphaFeldes
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setAlphaFeldStärke( st );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setAlphaFeldStärke( st );
+    rend = 1;
 }
 
 // -- Titel Hintergrund Bild -- 
 void Fenster::setTBgBild( Bild *b ) // setzt das Titel Hintergrund Bild
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setHintergrundBild( b );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setHintergrundBild( b );
+    rend = 1;
 }
 
 void Fenster::setTBgBildZ( Bild *b )
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setHintergrundBildZ( b );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setHintergrundBildZ( b );
+    rend = 1;
 }
 
 // -- Titel Rahmen -- 
 void Fenster::setTRahmenZ( LRahmen *ram ) // set Titel Rahmen
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setLinienRahmenZ( ram );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setLinienRahmenZ( ram );
+    rend = 1;
 }
 
 void Fenster::setTRFarbe( int f ) // setzt die Titel Rahmen Farbe
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setLinienRahmenFarbe( f );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setLinienRahmenFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setTRBreite( int br ) // setzt die Titel Rahmen Breite
 {
-	if( !titel )
-		titel = new TextFeld();
-	titel->setLinienRahmenBreite( br );
-	rend = 1;
+    if( !titel )
+        titel = new TextFeld();
+    titel->setLinienRahmenBreite( br );
+    rend = 1;
 }
 
 // -- Körper Hintergrund -- 
 void Fenster::setKBgFarbe( int f ) // setzt die Körper Hintergrund Farbe
 {
-	bgKörperFarbe = f;
-	rend = 1;
+    bgKörperFarbe = f;
+    rend = 1;
 }
 
 // -- Körper Hintergrund Bild -- 
 void Fenster::setKBgBild( Bild *b ) // setzt das Körper Hintergrund Bild
 {
-	if( !bgKörperBild )
-		bgKörperBild = new Bild();
-	bgKörperBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
-	int *buff1 = bgKörperBild->getBuffer();
-	int *buff2 = b->getBuffer();
-	int gr = bgKörperBild->getBreite() * bgKörperBild->getHöhe();
-	for( int i = 0; i < gr; ++i )
-		buff1[ i ] = buff2[ i ];
-	b->release();
-	rend = 1;
+    if( !bgKörperBild )
+        bgKörperBild = new Bild();
+    bgKörperBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
+    int *buff1 = bgKörperBild->getBuffer();
+    int *buff2 = b->getBuffer();
+    int gr = bgKörperBild->getBreite() * bgKörperBild->getHöhe();
+    for( int i = 0; i < gr; ++i )
+        buff1[ i ] = buff2[ i ];
+    b->release();
+    rend = 1;
 }
 
 void Fenster::setKBgBildZ( Bild *b )
 {
-	if( bgKörperBild )
-		bgKörperBild->release();
-	bgKörperBild = b;
-	rend = 1;
+    if( bgKörperBild )
+        bgKörperBild->release();
+    bgKörperBild = b;
+    rend = 1;
 }
 
 // -- Körper AlphaFeld -- 
 void Fenster::setKAlphaFeldZ( AlphaFeld *af ) // setzt das Körper AlphaFeld
 {
-	if( körperBuffer )
-		körperBuffer->release();
-	körperBuffer = af;
-	rend = 1;
+    if( körperBuffer )
+        körperBuffer->release();
+    körperBuffer = af;
+    rend = 1;
 }
 
 void Fenster::setKAfFarbe( int f ) // setzt Körper AlphaFeld Farbe
 {
-	if( !körperBuffer )
-		körperBuffer = new AlphaFeld();
-	körperBuffer->setFarbe( f );
-	rend = 1;
+    if( !körperBuffer )
+        körperBuffer = new AlphaFeld();
+    körperBuffer->setFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setKAfStärke( int st ) // setzt die Stärke des Körper AlphaFeldes
 {
-	if( !körperBuffer )
-		körperBuffer = new AlphaFeld();
-	körperBuffer->setStärke( st );
-	rend = 1;
+    if( !körperBuffer )
+        körperBuffer = new AlphaFeld();
+    körperBuffer->setStärke( st );
+    rend = 1;
 }
 
 // -- Schließen --
 void Fenster::setSchließenMeParam( void *param )
 {
-	schließenMeParam = param;
+    schließenMeParam = param;
 }
 
 void Fenster::setSchließenMe( bool( *schließenMe )( void *, void *, MausEreignis ) ) // setzt das Schließen Mausereignis
 {
-	this->schließenMe = schließenMe;
+    this->schließenMe = schließenMe;
 }
 
 // -- Schließen Hintergrund -- 
 void Fenster::setSBgFarbe( int f ) // setzt die Schließ Hintergrund Farbe
 {
-	bgSchließFarbe = f;
-	rend = 1;
+    bgSchließFarbe = f;
+    rend = 1;
 }
 
 // -- Schließen Hintergrund Bild -- 
 void Fenster::setSBgBild( Bild *b ) // setzt das Schließ Hintergrund Bild
 {
-	if( !bgSchließBild )
-		bgSchließBild = new Bild();
-	bgSchließBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
-	int *buff1 = bgSchließBild->getBuffer();
-	int *buff2 = b->getBuffer();
-	int gr = bgSchließBild->getBreite() * bgSchließBild->getHöhe();
-	for( int i = 0; i < gr; ++i )
-		buff1[ i ] = buff2[ i ];
-	b->release();
-	rend = 1;
+    if( !bgSchließBild )
+        bgSchließBild = new Bild();
+    bgSchließBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
+    int *buff1 = bgSchließBild->getBuffer();
+    int *buff2 = b->getBuffer();
+    int gr = bgSchließBild->getBreite() * bgSchließBild->getHöhe();
+    for( int i = 0; i < gr; ++i )
+        buff1[ i ] = buff2[ i ];
+    b->release();
+    rend = 1;
 }
 
 void Fenster::setSBgBildZ( Bild *b )
 {
-	if( bgSchließBild )
-		bgSchließBild->release();
-	bgSchließBild = b;
-	rend = 1;
+    if( bgSchließBild )
+        bgSchließBild->release();
+    bgSchließBild = b;
+    rend = 1;
 }
 
 // -- Schließen AlphaFeld -- 
 void Fenster::setSAlphaFeldZ( AlphaFeld *af ) // setzt das Schließ AlphaFeld
 {
-	if( schließBuffer )
-		schließBuffer->release();
-	schließBuffer = af;
-	rend = 1;
+    if( schließBuffer )
+        schließBuffer->release();
+    schließBuffer = af;
+    rend = 1;
 }
 
 void Fenster::setSAfFarbe( int f ) // setzt die Farbe des Schließ AlphaFeldes
 {
-	if( !schließBuffer )
-		schließBuffer = new AlphaFeld();
-	schließBuffer->setFarbe( f );
-	rend = 1;
+    if( !schließBuffer )
+        schließBuffer = new AlphaFeld();
+    schließBuffer->setFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setSAfStärke( int st ) // setzt die Stärke des Schließ AlphaFeldes
 {
-	if( !schließBuffer )
-		schließBuffer = new AlphaFeld();
-	schließBuffer->setStärke( st );
-	rend = 1;
+    if( !schließBuffer )
+        schließBuffer = new AlphaFeld();
+    schließBuffer->setStärke( st );
+    rend = 1;
 }
 
 // -- Schließen Klick AlphaFeld -- 
 void Fenster::setSKAlphaFeldZ( AlphaFeld *af ) // setzt das Schließ klick AlphaFeld
 {
-	if( schließKlickBuffer )
-		schließKlickBuffer->release();
-	schließKlickBuffer = af;
-	rend = 1;
+    if( schließKlickBuffer )
+        schließKlickBuffer->release();
+    schließKlickBuffer = af;
+    rend = 1;
 }
 
 void Fenster::setSKAfFarbe( int f ) // setzt die Farbe des Schließ klick AlphaFeldes
 {
-	if( !schließKlickBuffer )
-		schließKlickBuffer = new AlphaFeld();
-	schließKlickBuffer->setFarbe( f );
-	rend = 1;
+    if( !schließKlickBuffer )
+        schließKlickBuffer = new AlphaFeld();
+    schließKlickBuffer->setFarbe( f );
+    rend = 1;
 }
 
 void Fenster::setSKAfStärke( int st ) // setzt die Stärke des Schließ klick AlphaFeldes
 {
-	if( !schließKlickBuffer )
-		schließKlickBuffer = new AlphaFeld();
-	schließKlickBuffer->setStärke( st );
-	rend = 1;
+    if( !schließKlickBuffer )
+        schließKlickBuffer = new AlphaFeld();
+    schließKlickBuffer->setStärke( st );
+    rend = 1;
 }
 
 // -- min max -- 
 void Fenster::setMin( int mx, int my ) // setzt die Mindest Fenster Größe
 {
-	min.x = mx;
-	min.y = my;
+    min.x = mx;
+    min.y = my;
 }
 
 void Fenster::setMin( const Punkt &min )
 {
-	this->min = min;
+    this->min = min;
 }
 
 void Fenster::setMax( int mx, int my ) // setzt die Maximale Fenster Größe
 {
-	max.x = mx;
-	max.y = my;
+    max.x = mx;
+    max.y = my;
 }
 
 void Fenster::setMax( const Punkt &max )
 {
-	this->max = max;
+    this->max = max;
 }
 
 void Fenster::setKMin( int mx, int my ) // setzt die Mindest Körper Größe
 {
-	kMin.x = mx;
-	kMin.y = my;
+    kMin.x = mx;
+    kMin.y = my;
 }
 
 void Fenster::setKMin( const Punkt &min )
 {
-	kMin = min;
+    kMin = min;
 }
 
 void Fenster::setKMax( int mx, int my ) // setzt die Maximale Körper Größe
 {
-	kMax.x = mx;
-	kMax.y = my;
+    kMax.x = mx;
+    kMax.y = my;
 }
 
 void Fenster::setKMax( const Punkt &max )
 {
-	kMax = max;
+    kMax = max;
 }
 
 // -- scroll -- 
 void Fenster::setHScrollBarZ( HScrollBar *hScroll ) // setzt die Horizontale Scroll Bar
 {
-	if( this->hScroll )
-		this->hScroll->release();
-	this->hScroll = hScroll;
-	rend = 1;
+    if( this->hScroll )
+        this->hScroll->release();
+    this->hScroll = hScroll;
+    rend = 1;
 }
 
 void Fenster::setVScrollBarZ( VScrollBar *vScroll ) // setzt die Vertikale Scroll BAr
 {
-	if( this->vScroll )
-		this->vScroll->release();
-	this->vScroll = vScroll;
-	rend = 1;
+    if( this->vScroll )
+        this->vScroll->release();
+    this->vScroll = vScroll;
+    rend = 1;
 }
 
 void Fenster::setHSBMax( int max ) // setzt das Scroll Maximum
 {
-	if( !hScroll )
-		hScroll = new HScrollBar();
-	int rbr = 0;
-	if( hatStyle( Style::Rahmen ) && rahmen )
-		rbr = rahmen->getRBreite();
-	int vsh = 0;
-	if( hatStyle( Style::VScroll ) && vScroll )
-		vsh = 15;
-	hScroll->update( max, gr.x - rbr * 2 - vsh );
-	rend = 1;
+    if( !hScroll )
+        hScroll = new HScrollBar();
+    int rbr = 0;
+    if( hatStyle( Style::Rahmen ) && rahmen )
+        rbr = rahmen->getRBreite();
+    int vsh = 0;
+    if( hatStyle( Style::VScroll ) && vScroll )
+        vsh = 15;
+    hScroll->update( max, gr.x - rbr * 2 - vsh );
+    rend = 1;
 }
 
 void Fenster::setVSBMax( int max )
 {
-	if( !vScroll )
-		vScroll = new VScrollBar();
-	int rbr = 0;
-	int th = 0;
-	if( hatStyle( Style::Rahmen ) && rahmen )
-		rbr = rahmen->getRBreite();
-	if( hatStyle( Style::Titel ) && titel )
-		th = titel->getHöhe();
-	int hsh = 0;
-	if( hatStyle( Style::HScroll ) && hScroll )
-		hsh = 15;
-	vScroll->update( max, gr.y - rbr * 2 - th - hsh );
-	rend = 1;
+    if( !vScroll )
+        vScroll = new VScrollBar();
+    int rbr = 0;
+    int th = 0;
+    if( hatStyle( Style::Rahmen ) && rahmen )
+        rbr = rahmen->getRBreite();
+    if( hatStyle( Style::Titel ) && titel )
+        th = titel->getHöhe();
+    int hsh = 0;
+    if( hatStyle( Style::HScroll ) && hScroll )
+        hsh = 15;
+    vScroll->update( max, gr.y - rbr * 2 - th - hsh );
+    rend = 1;
 }
 
 void Fenster::setHSBScroll( int scroll ) // setzt die momentane Scroll Position
 {
-	if( !hScroll )
-		hScroll = new HScrollBar();
-	hScroll->scroll( scroll );
-	rend = 1;
+    if( !hScroll )
+        hScroll = new HScrollBar();
+    hScroll->scroll( scroll );
+    rend = 1;
 }
 
 void Fenster::setVSBScroll( int scroll )
 {
-	if( !vScroll )
-		vScroll = new VScrollBar();
-	vScroll->scroll( scroll );
-	rend = 1;
+    if( !vScroll )
+        vScroll = new VScrollBar();
+    vScroll->scroll( scroll );
+    rend = 1;
 }
 
 // -- Members -- 
 void Fenster::addMember( Zeichnung *obj ) // fügt einen Member hinzu
 {
-	if( !members )
-		members = new ZeichnungArray();
-	members->addZeichnung( obj );
-	members->updateIndex( 0 );
-	rend = 1;
+    if( !members )
+        members = new ZeichnungArray();
+    members->addZeichnung( obj );
+    members->updateIndex( 0 );
+    rend = 1;
 }
 
 void Fenster::removeMember( Zeichnung *obj ) // entfernt einen Member
 {
-	if( !members )
-		return;
-	members->removeZeichnung( obj );
-	members->updateIndex( 0 );
-	rend = 1;
+    if( !members )
+        return;
+    members->removeZeichnung( obj );
+    members->updateIndex( 0 );
+    rend = 1;
 }
 
 // -- Messages -- 
 bool Fenster::tick( double tickval ) // tick
 {
-	if( members && hatStyle( Style::Sichtbar ) )
-		rend |= members->tick( tickval );
-	else if( members )
-		members->tick( tickval );
-	if( vScroll && hatStyle( Style::VScroll ) )
-		rend |= vScroll->getRend();
-	if( hScroll && hatStyle( Style::HScroll ) )
-		rend |= hScroll->getRend();
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( members && hatStyle( Style::Sichtbar ) )
+        rend |= members->tick( tickval );
+    else if( members )
+        members->tick( tickval );
+    if( vScroll && hatStyle( Style::VScroll ) )
+        rend |= vScroll->getRend();
+    if( hScroll && hatStyle( Style::HScroll ) )
+        rend |= hScroll->getRend();
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void Fenster::doMausEreignis( MausEreignis &me )
 {
     bool nmakc = !me.verarbeitet;
-	if( me.verarbeitet || ( me.mx < pos.x || me.mx > pos.x + gr.x || me.my < pos.y || me.my > pos.y + gr.y ) )
-	{
-		if( mausIn )
-		{
-			mausIn = 0;
-			MausEreignis me2;
-			me2.id = ME_Verlässt;
-			me2.mx = me.mx;
-			me2.my = me.my;
-			me2.verarbeitet = 0;
-			doMausEreignis( me2 );
-			return;
-		}
-	}
-	else if( !mausIn && me.id != ME_Verlässt )
-	{
-		mausIn = 1;
-		MausEreignis me2;
-		me2.id = ME_Betritt;
-		me2.mx = me.mx;
-		me2.my = me.my;
-		me2.verarbeitet = 0;
-		doMausEreignis( me2 );
-	}
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		bool mvtmp = me.verarbeitet;
-		if( !Mak )
-			return;
-		if( hatStyleNicht( Style::Erlaubt ) )
-			me.verarbeitet = 1;
-		bool mpr = 0;
-		me.mx -= pos.x;
-		me.my -= pos.y;
-		int rbr = 0;
-		if( hatStyle( Style::Rahmen ) && rahmen )
-			rbr = rahmen->getRBreite();
-		int th = 0;
-		if( hatStyle( Style::Titel ) && titel )
-			th = titel->getHöhe();
-		bool hSc = hatStyle( Style::HScroll ) && hScroll;
-		bool vSc = hatStyle( Style::VScroll ) && vScroll;
-		if( !me.verarbeitet && me.id == ME_Bewegung && klick )
-		{
-			if( hatStyle( Style::Beweglich ) || hatStyle( Style::HöheÄnderbar ) || hatStyle( Style::BreiteÄnderbar ) || hatStyle( Style::TitelHöheÄnderbar ) )
-			{
-				if( Mak( makParam, this, me ) )
-				{
-					mpr = 1;
-					bool ret1 = 0;
-					bool mset = 0;
-					int schö = 0;
-					int scbr = 0;
-					if( hSc )
-					{
-						schö = 15;
-						scbr = 40;
-					}
-					if( vSc )
-					{
-						scbr += 15;
-						schö = 40;
-					}
-					bool minXb, maxXb, minYb, maxYb;
-					bool kMinXb, kMaxXb, kMinYb, kMaxYb;
-					minXb = hatStyle( Style::MinBr );
-					maxXb = hatStyle( Style::MaxBr );
-					minYb = hatStyle( Style::MinHö );
-					maxYb = hatStyle( Style::MaxHö );
-					kMinXb = hatStyle( Style::Körper_minBr );
-					kMaxXb = hatStyle( Style::Körper_maxBr );
-					kMinYb = hatStyle( Style::Körper_minHö );
-					kMaxYb = hatStyle( Style::Körper_maxHö );
-					int fMinBr = rbr * 2 + scbr;
-					if( minXb )
-						fMinBr = fMinBr < min.x ? min.x : fMinBr;
-					if( kMinXb )
-						fMinBr = fMinBr < ( rbr * 2 + kMin.x + scbr ) ? ( rbr * 2 + kMin.x + scbr ) : fMinBr;
-					int fMinHö = rbr * 2 + th + schö;
-					if( minYb )
-						fMinHö = fMinHö < min.y ? min.y : fMinHö;
-					if( kMinYb )
-						fMinHö = fMinHö < ( rbr * 2 + kMin.y + th + schö ) ? ( rbr * 2 + kMin.y + th + schö ) : fMinHö;
-					int fMaxBr = 0;
-					if( maxXb )
-						fMaxBr = max.x;
-					if( kMaxXb )
-						fMaxBr = fMaxBr < ( rbr * 2 + kMax.x + scbr ) ? ( rbr * 2 + kMax.x + scbr ) : fMaxBr;
-					int fMaxHö = 0;
-					if( maxYb )
-						fMaxHö = max.y;
-					if( kMaxYb )
-						fMaxHö = fMaxHö < ( rbr * 2 + kMax.y + th + schö ) ? ( rbr * 2 + kMax.y + th + schö ) : fMaxHö;
-					minXb |= kMinXb, maxXb |= kMaxXb, minYb |= kMinYb, maxYb |= kMaxYb;
-					if( hatStyle( Style::HöheÄnderbar ) )
-					{
-						if( mx > -5 && mx < gr.x + 5 && my > -5 && my < rbr )
-						{
-							pos.y -= my - me.my;
-							gr.y += my - me.my;
-							if( gr.y < fMinHö )
-							{
-								pos.y += fMinHö - gr.y;
-								gr.y = fMinHö;
-							}
-							else if( maxYb && gr.y > fMaxHö )
-							{
-								pos.y += gr.y - fMaxHö;
-								gr.y = fMaxHö;
-							}
-							else if( vSc )
-								vScroll->getScrollData()->anzeige = gr.y;
-							rend = 1;
-							ret1 = 1;
-						}
-						else if( mx > -5 && mx < gr.x + 5 && my > gr.y - rbr && my < gr.y + 5 )
-						{
-							gr.y += me.my - my;
-							if( gr.y < fMinHö )
-								gr.y = fMinHö;
-							else if( maxYb && gr.y > fMaxHö )
-								gr.y = fMaxHö;
-							else
-							{
-								mset = 1;
-								if( vSc )
-									vScroll->getScrollData()->anzeige = gr.y;
-							}
-							rend = 1;
-							ret1 = 1;
-						}
-					}
-					if( hatStyle( Style::BreiteÄnderbar ) )
-					{
-						if( mx > -5 && mx < rbr && my > -5 && my < gr.y + 5 )
-						{
-							pos.x -= mx - me.mx;
-							gr.x += mx - me.mx;
-							if( gr.x < fMinBr )
-							{
-								pos.x += fMinBr - gr.x;
-								gr.x = fMinBr;
-							}
-							else if( maxXb && gr.x > fMaxBr )
-							{
-								pos.x += gr.x - fMaxBr;
-								gr.x = fMaxBr;
-							}
-							else if( hSc )
-								hScroll->getScrollData()->anzeige = gr.x;
-							rend = 1;
-							ret1 = 1;
-						}
-						else if( mx > gr.x - rbr && mx < gr.x + 5 && my > -5 && my < gr.y + 5 )
-						{
-							gr.x += me.mx - mx;
-							if( gr.x < rbr * 2 + fMinBr )
-								gr.x = rbr * 2 + fMinBr;
-							else if( maxXb && gr.x > fMaxBr )
-								gr.x = fMaxBr;
-							else
-							{
-								mset = 1;
-								if( hSc )
-									hScroll->getScrollData()->anzeige = gr.x;
-							}
-							rend = 1;
-							ret1 = 1;
-						}
-					}
-					if( hatStyle( Style::TitelHöheÄnderbar ) && titel && mx > -5 && mx < gr.x + 5 && my < rbr + th + 5 && my > rbr + th )
-					{
-						int maxTh = gr.y - rbr * 2 - schö;
-						if( kMaxYb )
-							maxTh = maxTh < ( gr.x - rbr * 2 - kMin.y ) ? maxTh : ( gr.x - rbr * 2 - kMin.y );
-						if( hatStyle( Style::Schließbar ) )
-							maxTh = ( gr.x - th - 5 - rbr * 2 - me.my + my ) < 0 ? th : maxTh;
-						titel->setGröße( titel->getBreite(), titel->getHöhe() + me.my - my );
-						if( titel->getHöhe() > maxTh )
-							titel->setGröße( titel->getBreite(), maxTh );
-						else if( titel->getHöhe() < 5 )
-							titel->setGröße( titel->getBreite(), 5 );
-						else
-							mset = 1;
-						rend = 1;
-						ret1 = 1;
-					}
-					if( ret1 )
-					{
-						if( mset )
-							mx = me.mx, my = me.my;
-						me.verarbeitet = 1;
-					}
-					if( hatStyle( Style::Beweglich ) && mx > rbr && mx < gr.x - th - rbr && my > rbr && my < rbr + th )
-					{
-						pos.x += me.mx - mx;
-						pos.y += me.my - my;
-						rend = 1;
-						ret1 = 1;
-					}
-					if( ret1 )
-						me.verarbeitet = 1;
-				}
-			}
-		}
-		bool inside = me.mx >= 0 && me.mx <= gr.x && me.my >= 0 && me.my <= gr.y;
-		if( mpr || me.verarbeitet || ( !inside || Mak( makParam, this, me ) ) )
-		{
-			if( me.id == ME_RLinks )
-			{
-				if( schließKlick )
-					rend = 1;
-				schließKlick = 0, klick = 0;
-				mx = -1, my = -1;
-			}
-			if( me.id == ME_Verlässt )
-			{
-				if( schließKlick != 0 )
-					rend = 1;
-				schließKlick = 0, klick = 0;
-				mx = -1, my = -1;
-			}
-			if( !me.verarbeitet )
-			{
-				if( me.id == ME_PLinks )
-				{
-					klick = 1;
-					mx = me.mx, my = me.my;
-				}
-				if( hatStyle( Style::Schließbar ) && me.my <= th + rbr && me.mx >= gr.x + rbr - th && me.my >= rbr && me.mx <= gr.x - rbr )
-				{
-					if( !schließenMe || schließenMe( schließenMeParam, this, me ) )
-					{
-						if( me.id == ME_PLinks )
-						{
-							schließKlick = 1;
-							rend = 1;
-						}
-						if( !schließKlick && MausStand[ M_Links ] )
-						{
-							schließKlick = 1;
-							rend = 1;
-						}
-						me.verarbeitet = 1;
-					}
-				}
-				else if( schließKlick )
-				{
-					schließKlick = 0;
-					rend = 1;
-				}
-			}
-			if( members && me.id != ME_Betritt && me.id != ME_Verlässt )
-			{
-				if( vSc )
-				{
-					vScroll->doMausMessage( gr.x - rbr - 16, rbr + th, 15, gr.y - rbr * 2 - th - 1, me );
-					if( hSc )
-						hScroll->doMausMessage( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 16, 15, me );
-				}
-				else
-				if( hSc )
-					hScroll->doMausMessage( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 1, 15, me );
-				me.mx -= rbr;
-				me.my -= rbr + th;
-				if( hatStyle( Style::VScroll ) && vScroll )
-					me.my += vScroll->getScroll();
-				if( hatStyle( Style::HScroll ) && hScroll )
-					me.mx += hScroll->getScroll();
-				members->sendMausAll( me );
-				me.mx += rbr;
-				me.my += rbr + th;
+    if( me.verarbeitet || ( me.mx < pos.x || me.mx > pos.x + gr.x || me.my < pos.y || me.my > pos.y + gr.y ) )
+    {
+        if( mausIn )
+        {
+            mausIn = 0;
+            MausEreignis me2;
+            me2.id = ME_Verlässt;
+            me2.mx = me.mx;
+            me2.my = me.my;
+            me2.verarbeitet = 0;
+            doMausEreignis( me2 );
+            return;
+        }
+    }
+    else if( !mausIn && me.id != ME_Verlässt )
+    {
+        mausIn = 1;
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx;
+        me2.my = me.my;
+        me2.verarbeitet = 0;
+        doMausEreignis( me2 );
+    }
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        bool mvtmp = me.verarbeitet;
+        if( !Mak )
+            return;
+        if( hatStyleNicht( Style::Erlaubt ) )
+            me.verarbeitet = 1;
+        bool mpr = 0;
+        me.mx -= pos.x;
+        me.my -= pos.y;
+        int rbr = 0;
+        if( hatStyle( Style::Rahmen ) && rahmen )
+            rbr = rahmen->getRBreite();
+        int th = 0;
+        if( hatStyle( Style::Titel ) && titel )
+            th = titel->getHöhe();
+        bool hSc = hatStyle( Style::HScroll ) && hScroll;
+        bool vSc = hatStyle( Style::VScroll ) && vScroll;
+        if( !me.verarbeitet && me.id == ME_Bewegung && klick )
+        {
+            if( hatStyle( Style::Beweglich ) || hatStyle( Style::HöheÄnderbar ) || hatStyle( Style::BreiteÄnderbar ) || hatStyle( Style::TitelHöheÄnderbar ) )
+            {
+                if( Mak( makParam, this, me ) )
+                {
+                    mpr = 1;
+                    bool ret1 = 0;
+                    bool mset = 0;
+                    int schö = 0;
+                    int scbr = 0;
+                    if( hSc )
+                    {
+                        schö = 15;
+                        scbr = 40;
+                    }
+                    if( vSc )
+                    {
+                        scbr += 15;
+                        schö = 40;
+                    }
+                    bool minXb, maxXb, minYb, maxYb;
+                    bool kMinXb, kMaxXb, kMinYb, kMaxYb;
+                    minXb = hatStyle( Style::MinBr );
+                    maxXb = hatStyle( Style::MaxBr );
+                    minYb = hatStyle( Style::MinHö );
+                    maxYb = hatStyle( Style::MaxHö );
+                    kMinXb = hatStyle( Style::Körper_minBr );
+                    kMaxXb = hatStyle( Style::Körper_maxBr );
+                    kMinYb = hatStyle( Style::Körper_minHö );
+                    kMaxYb = hatStyle( Style::Körper_maxHö );
+                    int fMinBr = rbr * 2 + scbr;
+                    if( minXb )
+                        fMinBr = fMinBr < min.x ? min.x : fMinBr;
+                    if( kMinXb )
+                        fMinBr = fMinBr < ( rbr * 2 + kMin.x + scbr ) ? ( rbr * 2 + kMin.x + scbr ) : fMinBr;
+                    int fMinHö = rbr * 2 + th + schö;
+                    if( minYb )
+                        fMinHö = fMinHö < min.y ? min.y : fMinHö;
+                    if( kMinYb )
+                        fMinHö = fMinHö < ( rbr * 2 + kMin.y + th + schö ) ? ( rbr * 2 + kMin.y + th + schö ) : fMinHö;
+                    int fMaxBr = 0;
+                    if( maxXb )
+                        fMaxBr = max.x;
+                    if( kMaxXb )
+                        fMaxBr = fMaxBr < ( rbr * 2 + kMax.x + scbr ) ? ( rbr * 2 + kMax.x + scbr ) : fMaxBr;
+                    int fMaxHö = 0;
+                    if( maxYb )
+                        fMaxHö = max.y;
+                    if( kMaxYb )
+                        fMaxHö = fMaxHö < ( rbr * 2 + kMax.y + th + schö ) ? ( rbr * 2 + kMax.y + th + schö ) : fMaxHö;
+                    minXb |= kMinXb, maxXb |= kMaxXb, minYb |= kMinYb, maxYb |= kMaxYb;
+                    if( hatStyle( Style::HöheÄnderbar ) )
+                    {
+                        if( mx > -5 && mx < gr.x + 5 && my > -5 && my < rbr )
+                        {
+                            pos.y -= my - me.my;
+                            gr.y += my - me.my;
+                            if( gr.y < fMinHö )
+                            {
+                                pos.y += fMinHö - gr.y;
+                                gr.y = fMinHö;
+                            }
+                            else if( maxYb && gr.y > fMaxHö )
+                            {
+                                pos.y += gr.y - fMaxHö;
+                                gr.y = fMaxHö;
+                            }
+                            else if( vSc )
+                                vScroll->getScrollData()->anzeige = gr.y;
+                            rend = 1;
+                            ret1 = 1;
+                        }
+                        else if( mx > -5 && mx < gr.x + 5 && my > gr.y - rbr && my < gr.y + 5 )
+                        {
+                            gr.y += me.my - my;
+                            if( gr.y < fMinHö )
+                                gr.y = fMinHö;
+                            else if( maxYb && gr.y > fMaxHö )
+                                gr.y = fMaxHö;
+                            else
+                            {
+                                mset = 1;
+                                if( vSc )
+                                    vScroll->getScrollData()->anzeige = gr.y;
+                            }
+                            rend = 1;
+                            ret1 = 1;
+                        }
+                    }
+                    if( hatStyle( Style::BreiteÄnderbar ) )
+                    {
+                        if( mx > -5 && mx < rbr && my > -5 && my < gr.y + 5 )
+                        {
+                            pos.x -= mx - me.mx;
+                            gr.x += mx - me.mx;
+                            if( gr.x < fMinBr )
+                            {
+                                pos.x += fMinBr - gr.x;
+                                gr.x = fMinBr;
+                            }
+                            else if( maxXb && gr.x > fMaxBr )
+                            {
+                                pos.x += gr.x - fMaxBr;
+                                gr.x = fMaxBr;
+                            }
+                            else if( hSc )
+                                hScroll->getScrollData()->anzeige = gr.x;
+                            rend = 1;
+                            ret1 = 1;
+                        }
+                        else if( mx > gr.x - rbr && mx < gr.x + 5 && my > -5 && my < gr.y + 5 )
+                        {
+                            gr.x += me.mx - mx;
+                            if( gr.x < rbr * 2 + fMinBr )
+                                gr.x = rbr * 2 + fMinBr;
+                            else if( maxXb && gr.x > fMaxBr )
+                                gr.x = fMaxBr;
+                            else
+                            {
+                                mset = 1;
+                                if( hSc )
+                                    hScroll->getScrollData()->anzeige = gr.x;
+                            }
+                            rend = 1;
+                            ret1 = 1;
+                        }
+                    }
+                    if( hatStyle( Style::TitelHöheÄnderbar ) && titel && mx > -5 && mx < gr.x + 5 && my < rbr + th + 5 && my > rbr + th )
+                    {
+                        int maxTh = gr.y - rbr * 2 - schö;
+                        if( kMaxYb )
+                            maxTh = maxTh < ( gr.x - rbr * 2 - kMin.y ) ? maxTh : ( gr.x - rbr * 2 - kMin.y );
+                        if( hatStyle( Style::Schließbar ) )
+                            maxTh = ( gr.x - th - 5 - rbr * 2 - me.my + my ) < 0 ? th : maxTh;
+                        titel->setGröße( titel->getBreite(), titel->getHöhe() + me.my - my );
+                        if( titel->getHöhe() > maxTh )
+                            titel->setGröße( titel->getBreite(), maxTh );
+                        else if( titel->getHöhe() < 5 )
+                            titel->setGröße( titel->getBreite(), 5 );
+                        else
+                            mset = 1;
+                        rend = 1;
+                        ret1 = 1;
+                    }
+                    if( ret1 )
+                    {
+                        if( mset )
+                            mx = me.mx, my = me.my;
+                        me.verarbeitet = 1;
+                    }
+                    if( hatStyle( Style::Beweglich ) && mx > rbr && mx < gr.x - th - rbr && my > rbr && my < rbr + th )
+                    {
+                        pos.x += me.mx - mx;
+                        pos.y += me.my - my;
+                        rend = 1;
+                        ret1 = 1;
+                    }
+                    if( ret1 )
+                        me.verarbeitet = 1;
+                }
+            }
+        }
+        bool inside = me.mx >= 0 && me.mx <= gr.x && me.my >= 0 && me.my <= gr.y;
+        if( mpr || me.verarbeitet || ( !inside || Mak( makParam, this, me ) ) )
+        {
+            if( me.id == ME_RLinks )
+            {
+                if( schließKlick )
+                    rend = 1;
+                schließKlick = 0, klick = 0;
+                mx = -1, my = -1;
+            }
+            if( me.id == ME_Verlässt )
+            {
+                if( schließKlick != 0 )
+                    rend = 1;
+                schließKlick = 0, klick = 0;
+                mx = -1, my = -1;
+            }
+            if( !me.verarbeitet )
+            {
+                if( me.id == ME_PLinks )
+                {
+                    klick = 1;
+                    mx = me.mx, my = me.my;
+                }
+                if( hatStyle( Style::Schließbar ) && me.my <= th + rbr && me.mx >= gr.x + rbr - th && me.my >= rbr && me.mx <= gr.x - rbr )
+                {
+                    if( !schließenMe || schließenMe( schließenMeParam, this, me ) )
+                    {
+                        if( me.id == ME_PLinks )
+                        {
+                            schließKlick = 1;
+                            rend = 1;
+                        }
+                        if( !schließKlick && MausStand[ M_Links ] )
+                        {
+                            schließKlick = 1;
+                            rend = 1;
+                        }
+                        me.verarbeitet = 1;
+                    }
+                }
+                else if( schließKlick )
+                {
+                    schließKlick = 0;
+                    rend = 1;
+                }
+            }
+            if( members && me.id != ME_Betritt && me.id != ME_Verlässt )
+            {
+                if( vSc )
+                {
+                    vScroll->doMausMessage( gr.x - rbr - 16, rbr + th, 15, gr.y - rbr * 2 - th - 1, me );
+                    if( hSc )
+                        hScroll->doMausMessage( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 16, 15, me );
+                }
+                else
+                    if( hSc )
+                        hScroll->doMausMessage( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 1, 15, me );
+                me.mx -= rbr;
+                me.my -= rbr + th;
+                if( hatStyle( Style::VScroll ) && vScroll )
+                    me.my += vScroll->getScroll();
+                if( hatStyle( Style::HScroll ) && hScroll )
+                    me.mx += hScroll->getScroll();
+                members->sendMausAll( me );
+                me.mx += rbr;
+                me.my += rbr + th;
                 if( hatStyle( Style::VScroll ) && vScroll )
                     me.my -= vScroll->getScroll();
-				if( hatStyle( Style::HScroll ) && hScroll )
-					me.mx -= hScroll->getScroll();
-			}
-			if( inside && hatStyleNicht( Style::METransparenz ) )
-				me.verarbeitet = 1;
-		}
+                if( hatStyle( Style::HScroll ) && hScroll )
+                    me.mx -= hScroll->getScroll();
+            }
+            if( inside && hatStyleNicht( Style::METransparenz ) )
+                me.verarbeitet = 1;
+        }
         if( nmakc && me.verarbeitet && nMak )
             me.verarbeitet = nMak( nmakParam, this, me );
-		me.mx += pos.x;
-		me.my += pos.y;
-		if( hatStyleNicht( Style::Erlaubt ) )
-			me.verarbeitet = mvtmp;
-	}
-	else if( members )
-	{
-		MausEreignis me;
-		me.verarbeitet = 1;
-		me.id = 0;
-		me.mx = -1000000;
-		me.my = -1000000;
-		members->sendMausAll( me );
-	}
+        me.mx += pos.x;
+        me.my += pos.y;
+        if( hatStyleNicht( Style::Erlaubt ) )
+            me.verarbeitet = mvtmp;
+    }
+    else if( members )
+    {
+        MausEreignis me;
+        me.verarbeitet = 1;
+        me.id = 0;
+        me.mx = -1000000;
+        me.my = -1000000;
+        members->sendMausAll( me );
+    }
 }
 
 void Fenster::doTastaturEreignis( TastaturEreignis &te )
 {
     bool ntakc = !te.verarbeitet;
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		if( te.verarbeitet )
-		{
-			if( members )
-				members->sendTastaturAll( te );
-		}
-		else
-		{
-			if( Tak && Tak( takParam, this, te ) )
-			{
-				if( members )
-					members->sendTastaturAll( te );
-			}
-		}
-	}
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        if( te.verarbeitet )
+        {
+            if( members )
+                members->sendTastaturAll( te );
+        }
+        else
+        {
+            if( Tak && Tak( takParam, this, te ) )
+            {
+                if( members )
+                    members->sendTastaturAll( te );
+            }
+        }
+    }
     if( ntakc && te.verarbeitet && nTak )
         te.verarbeitet = nTak( ntakParam, this, te );
 }
@@ -1920,545 +1919,545 @@ void Fenster::doTastaturEreignis( TastaturEreignis &te )
 // -- Render -- 
 void Fenster::render( Bild &zRObj ) // zeichent nach zRObj
 {
-	if( hatStyle( Style::Sichtbar ) )
-	{
-		lockZeichnung();
-		if( !zRObj.setDrawOptions( pos, gr ) )
-		{
-			unlockZeichnung();
-			return;
-		}
+    if( hatStyle( Style::Sichtbar ) )
+    {
+        lockZeichnung();
+        if( !zRObj.setDrawOptions( pos, gr ) )
+        {
+            unlockZeichnung();
+            return;
+        }
         __super::render( zRObj );
-		int rbr = 0;
-		if( hatStyle( Style::Rahmen ) && rahmen )
-		{
-			rahmen->setGröße( gr );
-			rahmen->render( zRObj );
-			rbr = rahmen->getRBreite();
-		}
-		int th = 0;
-		if( hatStyle( Style::Titel ) && titel )
-		{
-			titel->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::TitelHintergrund ) );
-			titel->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::TitelHAlpha ) );
-			titel->setStyle( TextFeld::Style::HBild, hatStyle( Style::TitelHBild ) );
-			titel->setStyle( TextFeld::Style::Buffered, hatStyle( Style::TitelBuffered ) );
-			th = titel->getHöhe();
-			if( !zRObj.setDrawOptions( rbr, rbr, gr.x - rbr * 2, th ) )
-			{
-				zRObj.releaseDrawOptions();
-				unlockZeichnung();
-				return;
-			}
-			int sbr = 0;
-			if( hatStyle( Style::Schließbar ) )
-			{
-				sbr = th;
-				if( hatStyle( Style::SchließHintergrund ) )
-				{
-					if( hatStyle( Style::SchließHAlpha ) )
-						zRObj.alphaRegion( gr.x - th - rbr * 2, 0, th, th, bgSchließFarbe );
-					else
-						zRObj.füllRegion( gr.x - th - rbr * 2, 0, th, th, bgSchließFarbe );
-					if( hatStyle( Style::SchließHBild ) && bgSchließBild )
-					{
-						if( hatStyle( Style::SchließHAlpha ) )
-							zRObj.alphaBild( gr.x - th - rbr * 2, 0, th, th, *bgSchließBild );
-						else
-							zRObj.drawBild( gr.x - th - rbr * 2, 0, th, th, *bgSchließBild );
-					}
-				}
-				if( !hatStyle( Style::SchließHBild ) || !bgSchließBild )
-				{
-					zRObj.drawLinie( Punkt( gr.x - th - rbr * 2, 0 ), Punkt( gr.x - rbr * 2, th ), 0xFFFFFFFF );
-					zRObj.drawLinie( Punkt( gr.x - rbr * 2, 0 ), Punkt( gr.x - th - rbr * 2, th ), 0xFFFFFFFF );
-				}
-				if( hatStyle( Style::SchließBuffer ) && schließBuffer )
-				{
-					schließBuffer->setPosition( gr.x - th - rbr * 2, 0 );
-					schließBuffer->setGröße( th, th );
-					schließBuffer->render( zRObj );
-				}
-				if( hatStyle( Style::SchließKlickBuffer ) && schließKlickBuffer && schließKlick )
-				{
-					schließKlickBuffer->setPosition( gr.x - th - rbr * 2, 0 );
-					schließKlickBuffer->setGröße( th, th );
-					schließKlickBuffer->render( zRObj );
-				}
-			}
-			titel->setGröße( gr.x - rbr * 2 - sbr, th );
-			titel->render( zRObj );
-			zRObj.releaseDrawOptions();
-		}
-		bool vSc = hatStyle( Style::VScroll ) && vScroll;
-		bool hSc = hatStyle( Style::HScroll ) && hScroll;
-		if( vSc )
-		{
-			vScroll->render( gr.x - rbr - 16, rbr + th, 15, gr.y - rbr * 2 - th - 1, zRObj );
-			if( hSc )
-				hScroll->render( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 16, 15, zRObj );
-		}
-		else
-		if( hSc )
-			hScroll->render( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 1, 15, zRObj );
-		int x = rbr;
-		int y = rbr + th;
-		int br = gr.x - rbr * 2;
-		int hö = gr.y - rbr * 2 - th;
-		if( vSc )
-			br -= 16;
-		if( hSc )
-			hö -= 16;
-		if( !zRObj.setDrawOptions( x, y, br, hö ) )
-		{
-			zRObj.releaseDrawOptions();
-			unlockZeichnung();
-			return;
-		}
-		if( hatStyle( Style::KörperHintergrund ) )
-		{
-			if( hatStyle( Style::KörperHAlpha ) )
-				zRObj.alphaRegion( 0, 0, br, hö, bgKörperFarbe );
-			else
-				zRObj.füllRegion( 0, 0, br, hö, bgKörperFarbe );
-			if( hatStyle( Style::KörperHBild ) && bgKörperBild )
-			{
-				int *bgBuff = bgKörperBild->getBuffer();
-				int bgBr = bgKörperBild->getBreite();
-				if( hatStyle( Style::KörperHAlpha ) )
-					zRObj.alphaBild( 0, 0, br, hö, *bgKörperBild );
-				else
-					zRObj.drawBild( 0, 0, br, hö, *bgKörperBild );
-			}
-		}
-		if( hatStyle( Style::KörperBuffered ) && körperBuffer )
-		{
-			körperBuffer->setGröße( br, hö );
-			körperBuffer->render( zRObj );
-		}
-		if( members )
-		{
-			if( !vSc && !hSc )
-				members->render( zRObj );
-			else
-			{
-				zRObj.addScrollOffset( hSc ? hScroll->getScroll() : 0, vSc ? vScroll->getScroll() : 0 );
-				members->render( zRObj );
-			}
-		}
-		zRObj.releaseDrawOptions();
-		zRObj.releaseDrawOptions();
-		unlockZeichnung();
-	}
+        int rbr = 0;
+        if( hatStyle( Style::Rahmen ) && rahmen )
+        {
+            rahmen->setGröße( gr );
+            rahmen->render( zRObj );
+            rbr = rahmen->getRBreite();
+        }
+        int th = 0;
+        if( hatStyle( Style::Titel ) && titel )
+        {
+            titel->setStyle( TextFeld::Style::Hintergrund, hatStyle( Style::TitelHintergrund ) );
+            titel->setStyle( TextFeld::Style::HAlpha, hatStyle( Style::TitelHAlpha ) );
+            titel->setStyle( TextFeld::Style::HBild, hatStyle( Style::TitelHBild ) );
+            titel->setStyle( TextFeld::Style::Buffered, hatStyle( Style::TitelBuffered ) );
+            th = titel->getHöhe();
+            if( !zRObj.setDrawOptions( rbr, rbr, gr.x - rbr * 2, th ) )
+            {
+                zRObj.releaseDrawOptions();
+                unlockZeichnung();
+                return;
+            }
+            int sbr = 0;
+            if( hatStyle( Style::Schließbar ) )
+            {
+                sbr = th;
+                if( hatStyle( Style::SchließHintergrund ) )
+                {
+                    if( hatStyle( Style::SchließHAlpha ) )
+                        zRObj.alphaRegion( gr.x - th - rbr * 2, 0, th, th, bgSchließFarbe );
+                    else
+                        zRObj.füllRegion( gr.x - th - rbr * 2, 0, th, th, bgSchließFarbe );
+                    if( hatStyle( Style::SchließHBild ) && bgSchließBild )
+                    {
+                        if( hatStyle( Style::SchließHAlpha ) )
+                            zRObj.alphaBild( gr.x - th - rbr * 2, 0, th, th, *bgSchließBild );
+                        else
+                            zRObj.drawBild( gr.x - th - rbr * 2, 0, th, th, *bgSchließBild );
+                    }
+                }
+                if( !hatStyle( Style::SchließHBild ) || !bgSchließBild )
+                {
+                    zRObj.drawLinie( Punkt( gr.x - th - rbr * 2, 0 ), Punkt( gr.x - rbr * 2, th ), 0xFFFFFFFF );
+                    zRObj.drawLinie( Punkt( gr.x - rbr * 2, 0 ), Punkt( gr.x - th - rbr * 2, th ), 0xFFFFFFFF );
+                }
+                if( hatStyle( Style::SchließBuffer ) && schließBuffer )
+                {
+                    schließBuffer->setPosition( gr.x - th - rbr * 2, 0 );
+                    schließBuffer->setGröße( th, th );
+                    schließBuffer->render( zRObj );
+                }
+                if( hatStyle( Style::SchließKlickBuffer ) && schließKlickBuffer && schließKlick )
+                {
+                    schließKlickBuffer->setPosition( gr.x - th - rbr * 2, 0 );
+                    schließKlickBuffer->setGröße( th, th );
+                    schließKlickBuffer->render( zRObj );
+                }
+            }
+            titel->setGröße( gr.x - rbr * 2 - sbr, th );
+            titel->render( zRObj );
+            zRObj.releaseDrawOptions();
+        }
+        bool vSc = hatStyle( Style::VScroll ) && vScroll;
+        bool hSc = hatStyle( Style::HScroll ) && hScroll;
+        if( vSc )
+        {
+            vScroll->render( gr.x - rbr - 16, rbr + th, 15, gr.y - rbr * 2 - th - 1, zRObj );
+            if( hSc )
+                hScroll->render( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 16, 15, zRObj );
+        }
+        else
+            if( hSc )
+                hScroll->render( rbr, gr.y - rbr - 16, gr.x - rbr * 2 - 1, 15, zRObj );
+        int x = rbr;
+        int y = rbr + th;
+        int br = gr.x - rbr * 2;
+        int hö = gr.y - rbr * 2 - th;
+        if( vSc )
+            br -= 16;
+        if( hSc )
+            hö -= 16;
+        if( !zRObj.setDrawOptions( x, y, br, hö ) )
+        {
+            zRObj.releaseDrawOptions();
+            unlockZeichnung();
+            return;
+        }
+        if( hatStyle( Style::KörperHintergrund ) )
+        {
+            if( hatStyle( Style::KörperHAlpha ) )
+                zRObj.alphaRegion( 0, 0, br, hö, bgKörperFarbe );
+            else
+                zRObj.füllRegion( 0, 0, br, hö, bgKörperFarbe );
+            if( hatStyle( Style::KörperHBild ) && bgKörperBild )
+            {
+                int *bgBuff = bgKörperBild->getBuffer();
+                int bgBr = bgKörperBild->getBreite();
+                if( hatStyle( Style::KörperHAlpha ) )
+                    zRObj.alphaBild( 0, 0, br, hö, *bgKörperBild );
+                else
+                    zRObj.drawBild( 0, 0, br, hö, *bgKörperBild );
+            }
+        }
+        if( hatStyle( Style::KörperBuffered ) && körperBuffer )
+        {
+            körperBuffer->setGröße( br, hö );
+            körperBuffer->render( zRObj );
+        }
+        if( members )
+        {
+            if( !vSc && !hSc )
+                members->render( zRObj );
+            else
+            {
+                zRObj.addScrollOffset( hSc ? hScroll->getScroll() : 0, vSc ? vScroll->getScroll() : 0 );
+                members->render( zRObj );
+            }
+        }
+        zRObj.releaseDrawOptions();
+        zRObj.releaseDrawOptions();
+        unlockZeichnung();
+    }
 }
 
 // constant 
 // -- Rahmen -- 
 LRahmen *Fenster::getRahmen() const // gibt den Rahmen zurück
 {
-	if( !rahmen )
-		return 0;
-	return rahmen->getThis();
+    if( !rahmen )
+        return 0;
+    return rahmen->getThis();
 }
 
 LRahmen *Fenster::zRahmen() const
 {
-	return rahmen;
+    return rahmen;
 }
 
 int Fenster::getRFarbe() const // gibt die Farbe des Rahmens zurück
 {
-	if( !rahmen )
-		return 0;
-	return rahmen->getFarbe();
+    if( !rahmen )
+        return 0;
+    return rahmen->getFarbe();
 }
 
 int Fenster::getRBreite() const // gibt die breite des Rahmens zurück
 {
-	if( !rahmen )
-		return 0;
-	return rahmen->getRBreite();
+    if( !rahmen )
+        return 0;
+    return rahmen->getRBreite();
 }
 
 // -- Titel  -- 
 Text *Fenster::getTitel() const // gibt den Titel zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getText();
+    if( !titel )
+        return 0;
+    return titel->getText();
 }
 
 Text *Fenster::zTitel() const
 {
-	if( !titel )
-		return 0;
-	return titel->zText();
+    if( !titel )
+        return 0;
+    return titel->zText();
 }
 
 TextFeld *Fenster::getTTextFeld() const // gibt das Titel TextFeld zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getThis();
+    if( !titel )
+        return 0;
+    return titel->getThis();
 }
 
 TextFeld *Fenster::zTTextFeld() const
 {
-	return titel;
+    return titel;
 }
 
 // -- Titel Schrift -- 
 Schrift *Fenster::getTSchrift() const // gibt die Titel Schrift zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getSchrift();
+    if( !titel )
+        return 0;
+    return titel->getSchrift();
 }
 
 Schrift *Fenster::zTSchrift() const
 {
-	if( !titel )
-		return 0;
-	return titel->zSchrift();
+    if( !titel )
+        return 0;
+    return titel->zSchrift();
 }
 
 int Fenster::getTSFarbe() const // gibt die Titel Schrift Farbe zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getSchriftFarbe();
+    if( !titel )
+        return 0;
+    return titel->getSchriftFarbe();
 }
 
 int Fenster::getTSGröße() const // gibt die Titel Schrift Größe zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getSchriftGröße();
+    if( !titel )
+        return 0;
+    return titel->getSchriftGröße();
 }
 
 // -- Titel Hintergrund -- 
 int Fenster::getTBgFarbe() const // gibt die Titel Hintergrund Farbe zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getHintergrundFarbe();
+    if( !titel )
+        return 0;
+    return titel->getHintergrundFarbe();
 }
 
 // -- Titel AlphaFeld -- 
 AlphaFeld *Fenster::getTAlphaFeld() const // gibt das Titel AlphaFeld zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getAlphaFeld();
+    if( !titel )
+        return 0;
+    return titel->getAlphaFeld();
 }
 
 AlphaFeld *Fenster::zTAlphaFeld() const
 {
-	if( !titel )
-		return 0;
-	return titel->zAlphaFeld();
+    if( !titel )
+        return 0;
+    return titel->zAlphaFeld();
 }
 
 int Fenster::getTAfFarbe() const // gibt die Farbe des Titel AlphaFeldes zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getAlphaFeldFarbe();
+    if( !titel )
+        return 0;
+    return titel->getAlphaFeldFarbe();
 }
 
 int Fenster::getTAfStärke() const // gibt die Stärke des TitelAlphaFeldes zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getAlphaFeldStärke();
+    if( !titel )
+        return 0;
+    return titel->getAlphaFeldStärke();
 }
 
 // -- Titel Hintergrund Bild -- 
 Bild *Fenster::getTBgBild() const // gibt das Titel Hintergrund Bild zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getHintergrundBild();
+    if( !titel )
+        return 0;
+    return titel->getHintergrundBild();
 }
 
 Bild *Fenster::zTBgBild() const
 {
-	if( !titel )
-		return 0;
-	return titel->zHintergrundBild();
+    if( !titel )
+        return 0;
+    return titel->zHintergrundBild();
 }
 
 // -- Titel Rahmen -- 
 LRahmen *Fenster::getTRahmen() const // gibt den Titel Rahmen zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getLinienRahmen();
+    if( !titel )
+        return 0;
+    return titel->getLinienRahmen();
 }
 
 LRahmen *Fenster::zTRahmen() const
 {
-	if( !titel )
-		return 0;
-	return titel->zLinienRahmen();
+    if( !titel )
+        return 0;
+    return titel->zLinienRahmen();
 }
 
 int Fenster::getTRFarbe() const // gibt die Farbe des Titel Rahmens zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getLinienRahmenFarbe();
+    if( !titel )
+        return 0;
+    return titel->getLinienRahmenFarbe();
 }
 
 int Fenster::getTRBreite() const // gibt die Breite des Titel Rahmens zurück
 {
-	if( !titel )
-		return 0;
-	return titel->getLinienRahmenBreite();
+    if( !titel )
+        return 0;
+    return titel->getLinienRahmenBreite();
 }
 
 // -- Körper Hintergrund -- 
 int Fenster::getKBgFarbe() const // gibt die Körper Hintergrund Farbe zurück
 {
-	return bgKörperFarbe;
+    return bgKörperFarbe;
 }
 
 // -- Körper Hintergrund Bild -- 
 Bild *Fenster::getKBgBild() const // gibt das Körper Hintergrund Bild zurück
 {
-	if( !bgKörperBild )
-		return 0;
-	return bgKörperBild->getThis();
+    if( !bgKörperBild )
+        return 0;
+    return bgKörperBild->getThis();
 }
 
 Bild *Fenster::zKBgBild() const
 {
-	return bgKörperBild;
+    return bgKörperBild;
 }
 
 // -- Körper AlphaFeld -- 
 AlphaFeld *Fenster::getKAlphaFeld() const // gibt das Körper AlphaFeld zurück
 {
-	if( !körperBuffer )
-		return 0;
-	return körperBuffer->getThis();
+    if( !körperBuffer )
+        return 0;
+    return körperBuffer->getThis();
 }
 
 AlphaFeld *Fenster::zKAlphaFeld() const
 {
-	return körperBuffer;
+    return körperBuffer;
 }
 
 int Fenster::getKAfFarbe() const // gibt die Farbe des Körper AlphaFeldes zurück
 {
-	if( !körperBuffer )
-		return 0;
-	return körperBuffer->getFarbe();
+    if( !körperBuffer )
+        return 0;
+    return körperBuffer->getFarbe();
 }
 
 int Fenster::getKAfStärke() const // gibt die Stärke des Körper AlphaFeldes zurück
 {
-	if( !körperBuffer )
-		return 0;
-	return körperBuffer->getStärke();
+    if( !körperBuffer )
+        return 0;
+    return körperBuffer->getStärke();
 }
 
 // -- Schließen Hintergrund -- 
 int Fenster::getSBgFarbe() const // gibt die Schließ Hintergrund Farbe zurück
 {
-	return bgSchließFarbe;
+    return bgSchließFarbe;
 }
 
 // -- Schließen Hintergrund Bild -- 
 Bild *Fenster::getSBgBild() const // gibt das Schließ Hintergrund Bild zurück
 {
-	if( !bgSchließBild )
-		return 0;
-	return bgSchließBild->getThis();
+    if( !bgSchließBild )
+        return 0;
+    return bgSchließBild->getThis();
 }
 
 Bild *Fenster::zSBgBild() const
 {
-	return bgSchließBild;
+    return bgSchließBild;
 }
 
 // -- Schließen AlphaFeld -- 
 AlphaFeld *Fenster::getSAlphaFeld() const // gibt das Schließ AlphaFeld zurück
 {
-	if( !schließBuffer )
-		return 0;
-	return schließBuffer->getThis();
+    if( !schließBuffer )
+        return 0;
+    return schließBuffer->getThis();
 }
 
 AlphaFeld *Fenster::zSAlphaFeld() const
 {
-	return schließBuffer;
+    return schließBuffer;
 }
 
 int Fenster::getSAfFarbe() const // gibt die Farbe des Schließ AlphaFeldes zurück
 {
-	if( !schließBuffer )
-		return 0;
-	return schließBuffer->getFarbe();
+    if( !schließBuffer )
+        return 0;
+    return schließBuffer->getFarbe();
 }
 
 int Fenster::getSAfStärke() const // gibt die Stärke des Schließ AlphaFeldes zurück
 {
-	if( !schließBuffer )
-		return 0;
-	return schließBuffer->getStärke();
+    if( !schließBuffer )
+        return 0;
+    return schließBuffer->getStärke();
 }
 
 // -- Schließen Klick AlphaFeld -- 
 AlphaFeld *Fenster::getSKAlphaFeld() const // gibt das Schließ Klick AlphaFeld zurück
 {
-	if( !schließKlickBuffer )
-		return 0;
-	return schließKlickBuffer->getThis();
+    if( !schließKlickBuffer )
+        return 0;
+    return schließKlickBuffer->getThis();
 }
 
 AlphaFeld *Fenster::zSKAlphaFeld() const
 {
-	return schließKlickBuffer;
+    return schließKlickBuffer;
 }
 
 int Fenster::getSKAfFarbe() const // gibt die Farbe des Schließ Klick AlphaFeldes zurück
 {
-	if( !schließKlickBuffer )
-		return 0;
-	return schließKlickBuffer->getFarbe();
+    if( !schließKlickBuffer )
+        return 0;
+    return schließKlickBuffer->getFarbe();
 }
 
 int Fenster::getSKAfStärke() const // gibt die Stärke des Schließ Klick AlphaFeldes zurück
 {
-	if( !schließKlickBuffer )
-		return 0;
-	return schließKlickBuffer->getStärke();
+    if( !schließKlickBuffer )
+        return 0;
+    return schließKlickBuffer->getStärke();
 }
 
 // -- min max -- 
 const Punkt &Fenster::getMin() const // gibt die minimale Fenstergröße zurück
 {
-	return min;
+    return min;
 }
 
 const Punkt &Fenster::getMax() const // gibt die maximale Fenstergröße zurück
 {
-	return max;
+    return max;
 }
 
 const Punkt &Fenster::getKMin() const // gibt die minimale Fenstergröße zurück
 {
-	return kMin;
+    return kMin;
 }
 
 const Punkt &Fenster::getKMax() const // gibt die maximale Fenstergröße zurück
 {
-	return kMax;
+    return kMax;
 }
 
 // -- scroll -- 
 VScrollBar *Fenster::getVScrollBar() const // gibt die Vertikale Scroll Bar zurück
 {
-	if( !vScroll )
-		return 0;
-	return (VScrollBar*)vScroll->getThis();
+    if( !vScroll )
+        return 0;
+    return (VScrollBar*)vScroll->getThis();
 }
 
 VScrollBar *Fenster::zVScrollBar() const
 {
-	return vScroll;
+    return vScroll;
 }
 
 HScrollBar *Fenster::getHScrollBar() const // gibt die Horizontale Scroll Bar zurück
 {
-	if( !hScroll )
-		return 0;
-	return (HScrollBar*)hScroll->getThis();
+    if( !hScroll )
+        return 0;
+    return (HScrollBar*)hScroll->getThis();
 }
 
 HScrollBar *Fenster::zHScrollBar() const
 {
-	return hScroll;
+    return hScroll;
 }
 
 // -- Members -- 
 ZeichnungArray *Fenster::getMembers() const // gibt die Members zurück
 {
-	return members;
+    return members;
 }
 
 // -- Kopie --
 Zeichnung *Fenster::dublizieren() const // Erzeugt eine Kopie des Fensters
 {
-	Fenster *ret = new Fenster();
-	ret->setPosition( pos );
-	ret->setGröße( gr );
-	ret->setMausEreignisParameter( makParam );
-	ret->setTastaturEreignisParameter( takParam );
-	ret->setMausEreignis( Mak );
-	ret->setTastaturEreignis( Tak );
-	if( toolTip )
-		ret->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	ret->setStyle( style );
-	ret->setSchließenMeParam( schließenMeParam );
-	ret->setSchließenMe( schließenMe );
-	if( rahmen )
-	{
-		ret->setRBreite( rahmen->getRBreite() );
-		ret->setRFarbe( rahmen->getFarbe() );
-	}
-	if( titel )
-		ret->setTTextFeldZ( (TextFeld*)titel->dublizieren() );
-	ret->setKBgFarbe( bgKörperFarbe );
-	if( bgKörperBild )
-		ret->setKBgBild( bgKörperBild->getThis() );
-	if( körperBuffer )
-	{
-		ret->setKAfFarbe( körperBuffer->getFarbe() );
-		ret->setKAfStärke( körperBuffer->getStärke() );
-	}
-	ret->setSBgFarbe( bgSchließFarbe );
-	if( bgSchließBild )
-		ret->setSBgBild( bgSchließBild->getThis() );
-	if( schließBuffer )
-	{
-		ret->setSAfFarbe( schließBuffer->getFarbe() );
-		ret->setSAfStärke( schließBuffer->getStärke() );
-	}
-	if( schließKlickBuffer )
-	{
-		ret->setSKAfFarbe( schließKlickBuffer->getFarbe() );
-		ret->setSKAfStärke( schließKlickBuffer->getStärke() );
-	}
-	if( vScroll )
-	{
-		ret->setVSBMax( vScroll->getScrollData()->max );
-		ret->setVSBScroll( vScroll->getScroll() );
-	}
-	if( hScroll )
-	{
-		ret->setHSBMax( hScroll->getScrollData()->max );
-		ret->setHSBScroll( hScroll->getScroll() );
-	}
-	ret->setMin( min );
-	ret->setMax( max );
-	ret->setKMin( kMin );
-	ret->setKMax( kMax );
-	return ret;
+    Fenster *ret = new Fenster();
+    ret->setPosition( pos );
+    ret->setGröße( gr );
+    ret->setMausEreignisParameter( makParam );
+    ret->setTastaturEreignisParameter( takParam );
+    ret->setMausEreignis( Mak );
+    ret->setTastaturEreignis( Tak );
+    if( toolTip )
+        ret->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    ret->setStyle( style );
+    ret->setSchließenMeParam( schließenMeParam );
+    ret->setSchließenMe( schließenMe );
+    if( rahmen )
+    {
+        ret->setRBreite( rahmen->getRBreite() );
+        ret->setRFarbe( rahmen->getFarbe() );
+    }
+    if( titel )
+        ret->setTTextFeldZ( (TextFeld*)titel->dublizieren() );
+    ret->setKBgFarbe( bgKörperFarbe );
+    if( bgKörperBild )
+        ret->setKBgBild( bgKörperBild->getThis() );
+    if( körperBuffer )
+    {
+        ret->setKAfFarbe( körperBuffer->getFarbe() );
+        ret->setKAfStärke( körperBuffer->getStärke() );
+    }
+    ret->setSBgFarbe( bgSchließFarbe );
+    if( bgSchließBild )
+        ret->setSBgBild( bgSchließBild->getThis() );
+    if( schließBuffer )
+    {
+        ret->setSAfFarbe( schließBuffer->getFarbe() );
+        ret->setSAfStärke( schließBuffer->getStärke() );
+    }
+    if( schließKlickBuffer )
+    {
+        ret->setSKAfFarbe( schließKlickBuffer->getFarbe() );
+        ret->setSKAfStärke( schließKlickBuffer->getStärke() );
+    }
+    if( vScroll )
+    {
+        ret->setVSBMax( vScroll->getScrollData()->max );
+        ret->setVSBScroll( vScroll->getScroll() );
+    }
+    if( hScroll )
+    {
+        ret->setHSBMax( hScroll->getScrollData()->max );
+        ret->setHSBScroll( hScroll->getScroll() );
+    }
+    ret->setMin( min );
+    ret->setMax( max );
+    ret->setKMin( kMin );
+    ret->setKMax( kMax );
+    return ret;
 }
 
 // Reference Counting 
 Fenster *Fenster::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Fenster *Fenster::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }

Fortschritt.cpp

@@ -12,17 +12,17 @@ using namespace Framework;
 // Inhalt der FBalken Klasse aus Fortschritt.h 
 // Konstruktor 
 FBalken::FBalken()
-	: ZeichnungHintergrund(),
-	  maxAk( 0 ),
-	  ak( 0 ),
-	  fRahmen( 0 ),
-	  fBuffer( 0 ),
-	  fBgF( 0xFF000000 ),
-	  fBgBild( 0 ),
-	  schrift( 0 ),
-	  schriftFarbe( 0 ),
-	  schriftGröße( 0 ),
-	  ref( 1 )
+    : ZeichnungHintergrund(),
+    maxAk( 0 ),
+    ak( 0 ),
+    fRahmen( 0 ),
+    fBuffer( 0 ),
+    fBgF( 0xFF000000 ),
+    fBgBild( 0 ),
+    schrift( 0 ),
+    schriftFarbe( 0 ),
+    schriftGröße( 0 ),
+    ref( 1 )
 {
     style = 0;
 }
@@ -30,296 +30,296 @@ FBalken::FBalken()
 // Destructor 
 FBalken::~FBalken()
 {
-	if( rahmen )
-		rahmen->release();
-	if( fRahmen )
-		fRahmen->release();
-	if( fBuffer )
-		fBuffer->release();
-	if( fBgBild )
-		fBgBild->release();
-	if( schrift )
-		schrift->release();
+    if( rahmen )
+        rahmen->release();
+    if( fRahmen )
+        fRahmen->release();
+    if( fBuffer )
+        fBuffer->release();
+    if( fBgBild )
+        fBgBild->release();
+    if( schrift )
+        schrift->release();
 }
 
 // nicht constant 
 void FBalken::setAktionAnzahl( __int64 ak ) // setzt die anzahl der Aktionen
 {
-	maxAk = ak;
-	rend = 1;
+    maxAk = ak;
+    rend = 1;
 }
 
 void FBalken::aktionPlus( __int64 aktionen ) // mehrere Aktionen sind fertig
 {
-	ak += aktionen;
-	if( ak > maxAk )
-		ak = maxAk;
-	rend = 1;
+    ak += aktionen;
+    if( ak > maxAk )
+        ak = maxAk;
+    rend = 1;
 }
 
 void FBalken::reset() // setzt die fertigen Aktionen zurück
 {
-	ak = 0;
-	rend = 1;
+    ak = 0;
+    rend = 1;
 }
 
 void FBalken::setFRahmenZ( LRahmen *ram ) // setzt einen Zeiger zum Fertig Rahmen
 {
-	if( fRahmen )
-		fRahmen->release();
-	fRahmen = ram;
-	rend = 1;
+    if( fRahmen )
+        fRahmen->release();
+    fRahmen = ram;
+    rend = 1;
 }
 
 void FBalken::setFRFarbe( int f ) // setzt die Fertig Rahmen Farbe
 {
-	if( !fRahmen )
-		fRahmen = new LRahmen();
-	fRahmen->setFarbe( f );
-	rend = 1;
+    if( !fRahmen )
+        fRahmen = new LRahmen();
+    fRahmen->setFarbe( f );
+    rend = 1;
 }
 
 void FBalken::setFRBreite( int br ) // setzt die Fertig Rahmen Breite
 {
-	if( !fRahmen )
-		fRahmen = new LRahmen();
-	fRahmen->setRamenBreite( br );
-	rend = 1;
+    if( !fRahmen )
+        fRahmen = new LRahmen();
+    fRahmen->setRamenBreite( br );
+    rend = 1;
 }
 
 void FBalken::setFAlphaFeldZ( AlphaFeld *af ) // setzt einen Zeiger zum Fertig Alpha Feld
 {
-	if( fBuffer )
-		fBuffer->release();
-	fBuffer = af;
-	rend = 1;
+    if( fBuffer )
+        fBuffer->release();
+    fBuffer = af;
+    rend = 1;
 }
 
 void FBalken::setFAFFarbe( int f ) // setzt die Fertig Alpha Feld Farbe
 {
-	if( !fBuffer )
-		fBuffer = new AlphaFeld();
-	fBuffer->setFarbe( f );
-	rend = 1;
+    if( !fBuffer )
+        fBuffer = new AlphaFeld();
+    fBuffer->setFarbe( f );
+    rend = 1;
 }
 
 void FBalken::setFAFStärke( int st ) // setzt die Stärke des Fertig Alpha Feldes
 {
-	if( !fBuffer )
-		fBuffer = new AlphaFeld();
-	fBuffer->setStärke( st );
-	rend = 1;
+    if( !fBuffer )
+        fBuffer = new AlphaFeld();
+    fBuffer->setStärke( st );
+    rend = 1;
 }
 
 void FBalken::setFBgFarbe( int f ) // setzt einen Zeiger zur Fertig Hintergrund Farbe
 {
-	fBgF = f;
-	rend = 1;
+    fBgF = f;
+    rend = 1;
 }
 
 void FBalken::setFBgBildZ( Bild *b ) // setzt das Fertig Hintergrund Bild
 {
-	if( fBgBild )
-		fBgBild->release();
-	fBgBild = b;
-	rend = 1;
+    if( fBgBild )
+        fBgBild->release();
+    fBgBild = b;
+    rend = 1;
 }
 
 void FBalken::setFBgBild( Bild *b ) // kopiert in das Fertig Hintergrund Bild
 {
-	if( !fBgBild )
-		fBgBild = new Bild();
-	fBgBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
-	fBgBild->drawBild( 0, 0, b->getBreite(), b->getHöhe(), *b );
-	b->release();
-	rend = 1;
+    if( !fBgBild )
+        fBgBild = new Bild();
+    fBgBild->neuBild( b->getBreite(), b->getHöhe(), 0 );
+    fBgBild->drawBild( 0, 0, b->getBreite(), b->getHöhe(), *b );
+    b->release();
+    rend = 1;
 }
 
 void FBalken::setSchriftZ( Schrift *s ) // setzt die Schrift
 {
-	if( schrift )
-		schrift->release();
-	schrift = s;
-	rend = 1;
+    if( schrift )
+        schrift->release();
+    schrift = s;
+    rend = 1;
 }
 
 void FBalken::setSFarbe( int f ) // setzt die Schrift Farbe
 {
-	schriftFarbe = f;
-	rend = 1;
+    schriftFarbe = f;
+    rend = 1;
 }
 
 void FBalken::setSGröße( unsigned char gr ) // setzt die Schrift größe
 {
-	schriftGröße = gr;
-	rend = 1;
+    schriftGröße = gr;
+    rend = 1;
 }
 
 void FBalken::render( Bild &zRObj ) // zeichnet nach zRObj
 {
-	if( !hatStyle( Style::Sichtbar ) )
-		return;
-	lockZeichnung();
+    if( !hatStyle( Style::Sichtbar ) )
+        return;
+    lockZeichnung();
     löscheStyle( Style::VScroll | Style::HScroll );
     __super::render( zRObj );
-	if( !zRObj.setDrawOptions( pos, gr ) )
-	{
-		unlockZeichnung();
-		return;
-	}
-	int xx = 0;
-	int yy = 0;
-	int b = gr.x;
-	int h = gr.y;
-	if( hatStyle( Style::L_R ) )
-		b = (int)( ( gr.x / 100.0 ) * getProzent() );
-	else if( hatStyle( Style::R_L ) )
-	{
-		b = (int)( ( gr.x / 100.0 ) * getProzent() );
-		xx -= b;
-	}
-	else if( hatStyle( Style::O_U ) )
-		h = (int)( ( gr.y / 100.0 ) * getProzent() );
-	else if( hatStyle( Style::U_O ) )
-	{
-		h = (int)( ( gr.y / 100.0 ) * getProzent() );
-		yy -= h;
-	}
-	if( maxAk == 0 )
-		b = 0, h = 0;
-	if( !zRObj.setDrawOptions( xx, yy, b, h ) )
-	{
-		zRObj.releaseDrawOptions();
-		unlockZeichnung();
-		return;
-	}
+    if( !zRObj.setDrawOptions( pos, gr ) )
+    {
+        unlockZeichnung();
+        return;
+    }
+    int xx = 0;
+    int yy = 0;
+    int b = gr.x;
+    int h = gr.y;
+    if( hatStyle( Style::L_R ) )
+        b = (int)( ( gr.x / 100.0 ) * getProzent() );
+    else if( hatStyle( Style::R_L ) )
+    {
+        b = (int)( ( gr.x / 100.0 ) * getProzent() );
+        xx -= b;
+    }
+    else if( hatStyle( Style::O_U ) )
+        h = (int)( ( gr.y / 100.0 ) * getProzent() );
+    else if( hatStyle( Style::U_O ) )
+    {
+        h = (int)( ( gr.y / 100.0 ) * getProzent() );
+        yy -= h;
+    }
+    if( maxAk == 0 )
+        b = 0, h = 0;
+    if( !zRObj.setDrawOptions( xx, yy, b, h ) )
+    {
+        zRObj.releaseDrawOptions();
+        unlockZeichnung();
+        return;
+    }
     int rbr = 0;
-	if( hatStyle( Style::FRahmen ) && fRahmen )
-	{
-		fRahmen->setGröße( b, h );
-		fRahmen->render( zRObj );
-		rbr = fRahmen->getRBreite();
-	}
-	if( hatStyle( Style::FFarbe ) )
-	{
-		if( hatStyle( Style::FAlpha ) )
-			zRObj.alphaRegion( rbr, rbr, b - rbr * 2, h - rbr * 2, fBgF );
-		else
-			zRObj.füllRegion( rbr, rbr, b - rbr * 2, h - rbr * 2, fBgF );
-	}
-	if( hatStyle( Style::FBild ) && fBgBild )
-	{
-		if( hatStyle( Style::FAlpha ) )
-			zRObj.alphaBildSkall( rbr, rbr, b - rbr * 2, h - rbr * 2, *fBgBild );
-		else
-			zRObj.drawBildSkall( rbr, rbr, b - rbr * 2, h - rbr * 2, *fBgBild );
-	}
-	if( hatStyle( Style::FBuffered ) && fBuffer )
-	{
-		fBuffer->setGröße( b - rbr * 2, h - rbr * 2 );
-		fBuffer->render( zRObj );
-	}
-	zRObj.releaseDrawOptions();
-	if( hatStyle( Style::Prozent ) && schrift )
-	{
-		schrift->setSchriftGröße( schriftGröße );
-		Text txt;
-		txt.anhängen( (int)getProzent() );
-		txt.anhängen( "%" );
-		schrift->setDrawPosition( rbr + ( gr.x - rbr * 2 ) / 2 - schrift->getTextBreite( &txt ) / 2, rbr + ( gr.y - rbr * 2 ) / 2 - schrift->getTextHöhe( &txt ) / 2 );
-		schrift->renderText( &txt, zRObj, schriftFarbe );
-	}
-	zRObj.releaseDrawOptions();
-	unlockZeichnung();
+    if( hatStyle( Style::FRahmen ) && fRahmen )
+    {
+        fRahmen->setGröße( b, h );
+        fRahmen->render( zRObj );
+        rbr = fRahmen->getRBreite();
+    }
+    if( hatStyle( Style::FFarbe ) )
+    {
+        if( hatStyle( Style::FAlpha ) )
+            zRObj.alphaRegion( rbr, rbr, b - rbr * 2, h - rbr * 2, fBgF );
+        else
+            zRObj.füllRegion( rbr, rbr, b - rbr * 2, h - rbr * 2, fBgF );
+    }
+    if( hatStyle( Style::FBild ) && fBgBild )
+    {
+        if( hatStyle( Style::FAlpha ) )
+            zRObj.alphaBildSkall( rbr, rbr, b - rbr * 2, h - rbr * 2, *fBgBild );
+        else
+            zRObj.drawBildSkall( rbr, rbr, b - rbr * 2, h - rbr * 2, *fBgBild );
+    }
+    if( hatStyle( Style::FBuffered ) && fBuffer )
+    {
+        fBuffer->setGröße( b - rbr * 2, h - rbr * 2 );
+        fBuffer->render( zRObj );
+    }
+    zRObj.releaseDrawOptions();
+    if( hatStyle( Style::Prozent ) && schrift )
+    {
+        schrift->setSchriftGröße( schriftGröße );
+        Text txt;
+        txt.anhängen( (int)getProzent() );
+        txt.anhängen( "%" );
+        schrift->setDrawPosition( rbr + ( gr.x - rbr * 2 ) / 2 - schrift->getTextBreite( &txt ) / 2, rbr + ( gr.y - rbr * 2 ) / 2 - schrift->getTextHöhe( &txt ) / 2 );
+        schrift->renderText( &txt, zRObj, schriftFarbe );
+    }
+    zRObj.releaseDrawOptions();
+    unlockZeichnung();
 }
 
 // constant 
 __int64 FBalken::getAktionAnzahl() const // gibt die Anzahl der Aktionen zurück
 {
-	return maxAk;
+    return maxAk;
 }
 
 double FBalken::getProzent() const // gibt die momentane Prozentzahl zurück
 {
-	if( !maxAk )
-		return 0;
-	return ak / ( maxAk / 100.0 );
+    if( !maxAk )
+        return 0;
+    return ak / ( maxAk / 100.0 );
 }
 
 __int64 FBalken::getAktion() const // gibt die fertigen Aktionen zurück
 {
-	return ak;
+    return ak;
 }
 
 LRahmen *FBalken::getFRahmen() const // gibt den Fertig Rahmen zurück
 {
-	if( fRahmen )
-		return fRahmen->getThis();
-	return 0;
+    if( fRahmen )
+        return fRahmen->getThis();
+    return 0;
 }
 
 LRahmen *FBalken::zFRahmen() const
 {
-	return fRahmen;
+    return fRahmen;
 }
 
 AlphaFeld *FBalken::getFAlphaFeld() const // gibt das Fertig Alpha Feld zurück
 {
-	if( fBuffer )
-		return fBuffer->getThis();
-	return 0;
+    if( fBuffer )
+        return fBuffer->getThis();
+    return 0;
 }
 
 AlphaFeld *FBalken::zFAlphaFeld() const
 {
-	return fBuffer;
+    return fBuffer;
 }
 
 int FBalken::getFBgFarbe() const // gibt die Fertig Hintergrund Farbe zurück
 {
-	return fBgF;
+    return fBgF;
 }
 
 Bild *FBalken::getFBgBild() const // gibt das Fertig Hintergrund Bild zurück
 {
-	if( fBgBild )
-		return fBgBild->getThis();
-	return 0;
+    if( fBgBild )
+        return fBgBild->getThis();
+    return 0;
 }
 
 Bild *FBalken::zFBgBild() const
 {
-	return fBgBild;
+    return fBgBild;
 }
 
 Schrift *FBalken::getSchrift() const // gibt die Schrift zurück
 {
-	if( schrift )
-		return schrift->getThis();
-	return 0;
+    if( schrift )
+        return schrift->getThis();
+    return 0;
 }
 
 Schrift *FBalken::zSchrift() const
 {
-	return schrift;
+    return schrift;
 }
 
 int FBalken::getSFarbe() const // gibt die Schrift Farbe zurück
 {
-	return schriftFarbe;
+    return schriftFarbe;
 }
 
 // Reference Counting 
 FBalken *FBalken::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 FBalken *FBalken::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }

Fortschritt.h

@@ -5,15 +5,15 @@
 
 namespace Framework
 {
-	class LRahmen; // Rahmen.h
-	class AlphaFeld; // AlphaFeld.h
-	class Bild; // Bild.h
-	class Schrift; // Schrift.h
-	class FBalken; // aus dieser Datei
+    class LRahmen; // Rahmen.h
+    class AlphaFeld; // AlphaFeld.h
+    class Bild; // Bild.h
+    class Schrift; // Schrift.h
+    class FBalken; // aus dieser Datei
 
     // Eine Zeichnung des 2D GuI Frameworks, die einen Fortschrittsbalken zeichnet
-	class FBalken : public ZeichnungHintergrund
-	{
+    class FBalken : public ZeichnungHintergrund
+    {
     public:
         class Style : public ZeichnungHintergrund::Style
         {
@@ -33,102 +33,102 @@ namespace Framework
 
             const static __int64 normal = Sichtbar | Rahmen | Hintergrund | HBild | FRahmen | FBild | L_R | Prozent; // Vereint die Flags Sichtbar, Rahmen, Hintergrund, HBild, FRahmen, FBild, L_R, Prozent
         };
-	private:
-		__int64 maxAk;
-		__int64 ak;
-		LRahmen *fRahmen;
-		AlphaFeld *fBuffer;
-		int fBgF;
-		Bild *fBgBild;
-		Schrift *schrift;
-		int schriftFarbe;
-		unsigned char schriftGröße;
-		int ref;
+    private:
+        __int64 maxAk;
+        __int64 ak;
+        LRahmen *fRahmen;
+        AlphaFeld *fBuffer;
+        int fBgF;
+        Bild *fBgBild;
+        Schrift *schrift;
+        int schriftFarbe;
+        unsigned char schriftGröße;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) FBalken();
-		// Destructor 
-		__declspec( dllexport ) ~FBalken();
-		// Setzt die Anzahl an benötigten Operationen um 100% Fortschritt zu erreichen
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) FBalken();
+        // Destructor 
+        __declspec( dllexport ) ~FBalken();
+        // Setzt die Anzahl an benötigten Operationen um 100% Fortschritt zu erreichen
         //  ak: Die Anzahl an Operationen
-		__declspec( dllexport ) void setAktionAnzahl( __int64 ak );
+        __declspec( dllexport ) void setAktionAnzahl( __int64 ak );
         // Legt fest, dass eine bestimmte Anzahl an Operationen seit dem letzten Aufruf der Funktion durchgeführt wurden
         //  aktionen: Die durchgeführten Operationen. Standartmäßig auf 1
         __declspec( dllexport ) void aktionPlus( __int64 aktionen = 1 );
         // Setzt alle fertigen Operationen zurück, so dass der Fortschritt wieder von 0% beginnt
-		__declspec( dllexport ) void reset();
+        __declspec( dllexport ) void reset();
         // Setzt einen Zeiger auf den Rahmen, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setFRahmenZ( LRahmen *ram );
+        __declspec( dllexport ) void setFRahmenZ( LRahmen *ram );
         // Setzt die Farbe des Rahmens, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFRFarbe( int f );
+        __declspec( dllexport ) void setFRFarbe( int f );
         // Setzt die Breite des Rahmens, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setFRBreite( int br );
+        __declspec( dllexport ) void setFRBreite( int br );
         // Setzt einen Zeiger auf den Farbverlauf, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  af: Der Farbverlauf
-		__declspec( dllexport ) void setFAlphaFeldZ( AlphaFeld *af );
+        __declspec( dllexport ) void setFAlphaFeldZ( AlphaFeld *af );
         // Setzt die Farbe des Farbverlaufs, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFAFFarbe( int f );
+        __declspec( dllexport ) void setFAFFarbe( int f );
         // Setzt die Stärke des Farbverlaufs, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  st: Die Stärke
-		__declspec( dllexport ) void setFAFStärke( int st );
+        __declspec( dllexport ) void setFAFStärke( int st );
         // Setzt die Hintergrund Farbe, die in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFBgFarbe( int f );
+        __declspec( dllexport ) void setFBgFarbe( int f );
         // Setzt einen Zeiger auf das Hintergrund Bild, das in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  b: Das Bild
-		__declspec( dllexport ) void setFBgBildZ( Bild *b );
+        __declspec( dllexport ) void setFBgBildZ( Bild *b );
         // Setzt das Hintergrund Bild durch kopieren, das in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
         //  b: Das Bild, das kopiert werden soll
-		__declspec( dllexport ) void setFBgBild( Bild *b );
+        __declspec( dllexport ) void setFBgBild( Bild *b );
         // Setzt die Schrift, die verwendet wird, um die Prozentanzeige zu zeichnen
-		__declspec( dllexport ) void setSchriftZ( Schrift *b );
+        __declspec( dllexport ) void setSchriftZ( Schrift *b );
         // Setzt die Farbe der Prozentanzeige
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setSFarbe( int f );
+        __declspec( dllexport ) void setSFarbe( int f );
         // Setzt die Schriftgröße der Prozentanzeige
         //  gr: Die Größe einer Zeile in Pixeln
-		__declspec( dllexport ) void setSGröße( unsigned char gr );
+        __declspec( dllexport ) void setSGröße( unsigned char gr );
         // Zeichnet das Objekt nach zRObj, falls es sichtbar ist
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Anzahl an benötigten Operationen zurück, die für 100% benötigt werden
-		__declspec( dllexport ) __int64 getAktionAnzahl() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Anzahl an benötigten Operationen zurück, die für 100% benötigt werden
+        __declspec( dllexport ) __int64 getAktionAnzahl() const;
         // Gibt die momentan erreichte Prozentzahl des Fortschritts zurück
-		__declspec( dllexport ) double getProzent() const;
+        __declspec( dllexport ) double getProzent() const;
         // Gibt die Anzahl an fertigen Operationen zurück
-		__declspec( dllexport ) __int64 getAktion() const;
+        __declspec( dllexport ) __int64 getAktion() const;
         // Gibt den Rahmen zurück, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) LRahmen *getFRahmen() const;
+        __declspec( dllexport ) LRahmen *getFRahmen() const;
         // Gibt den Rahmen ohne erhöhten Reference Counter zurück, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) LRahmen *zFRahmen() const;
+        __declspec( dllexport ) LRahmen *zFRahmen() const;
         // Gibt den Farbübergang zurück, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) AlphaFeld *getFAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *getFAlphaFeld() const;
         // Gibt den Farbübergang ohne erhöhten Reference Counter zurück, der in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) AlphaFeld *zFAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *zFAlphaFeld() const;
         // Gibt die Hintergrund Farbe im A8R8G8B8 Format zurück, die in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) int getFBgFarbe() const;
+        __declspec( dllexport ) int getFBgFarbe() const;
         // Gibt das Hintergrund Bild zurück, das in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) Bild *getFBgBild() const;
+        __declspec( dllexport ) Bild *getFBgBild() const;
         // Gibt das Hintergrund Bild ohne erhöhten Reference COunter zurück, das in dem Teil des Balkens gezeichnet wird, der vom Fortschritt erfasst wurde
-		__declspec( dllexport ) Bild *zFBgBild() const;
+        __declspec( dllexport ) Bild *zFBgBild() const;
         // Gibt die Schrift zurück, die für die Prozentanzeige verwendet wird
-		__declspec( dllexport ) Schrift *getSchrift() const;
+        __declspec( dllexport ) Schrift *getSchrift() const;
         // Gibt die Schrift ohne erhöhten Reference Counter zurück, die für die Prozentanzeige verwendet wird
-		__declspec( dllexport ) Schrift *zSchrift() const;
+        __declspec( dllexport ) Schrift *zSchrift() const;
         // Gibt die Farbe der Prozentanzeige im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getSFarbe() const;
+        __declspec( dllexport ) int getSFarbe() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) FBalken *getThis();
+        __declspec( dllexport ) FBalken *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) FBalken *release();
-	};
+        __declspec( dllexport ) FBalken *release();
+    };
 }
 
 #endif

FrameworkMath.h

@@ -12,7 +12,7 @@
 //  b: Eine der beiden Zahlen
 inline int maxInt( int a, int b )
 {
-	return ( ( ( a - b ) >> 16 ) & b ) | ( ~( ( a - b ) >> 16 ) & a );
+    return ( ( ( a - b ) >> 16 ) & b ) | ( ~( ( a - b ) >> 16 ) & a );
 }
 
 // Gibt die kleinere Zahl zurück ohne if zu verwenden
@@ -21,7 +21,7 @@ inline int maxInt( int a, int b )
 //  b: Eine der beiden Zahlen
 inline int minInt( int a, int b )
 {
-	return ( ( ( a - b ) >> 16 ) & a ) | ( ~( ( a - b ) >> 16 ) & b );
+    return ( ( ( a - b ) >> 16 ) & a ) | ( ~( ( a - b ) >> 16 ) & b );
 }
 
 // Gibt den positiven Wert eines Zeichnunges zurück.

Global.cpp

@@ -20,50 +20,50 @@ void Framework::initFramework()
     Gdiplus::GdiplusStartupInput gdiplusStartupInput;
     ULONG_PTR gdiplusToken;
     Gdiplus::GdiplusStartup( &gdiplusToken, &gdiplusStartupInput, 0 );
-	msgExit = 0;
-	MausTrack = 1;
-	for( int i = 0; i < 255; ++i )
-		TastenStand[ i ] = 0;
-	for( int i = 0; i < 3; ++i )
-		MausStand[ i ] = 0;
+    msgExit = 0;
+    MausTrack = 1;
+    for( int i = 0; i < 255; ++i )
+        TastenStand[ i ] = 0;
+    for( int i = 0; i < 3; ++i )
+        MausStand[ i ] = 0;
     thRegister = new ThreadRegister();
     Model3DList::init();
     m3dRegister = new Model3DList();
     TexturList::init();
     texturRegister = new TexturList();
-	istInitialisiert = 1;
+    istInitialisiert = 1;
 }
 
 void Framework::releaseFramework()
 {
-	if( !istInitialisiert )
-		return;
+    if( !istInitialisiert )
+        return;
     delete thRegister;
     m3dRegister->release();
     Model3DList::destroy();
     texturRegister->release();
     TexturList::destroy();
-	istInitialisiert = 0;
+    istInitialisiert = 0;
 }
 
 const Framework::Punkt &Framework::getMausPos()
 {
-	return mausPos;
+    return mausPos;
 }
 
 bool Framework::getMausStand( int taste )
 {
-	return MausStand[ taste ];
+    return MausStand[ taste ];
 }
 
 void Framework::setTastenStand( unsigned char taste, bool st )
 {
-	TastenStand[ taste ] = st;
+    TastenStand[ taste ] = st;
 }
 
 bool Framework::getTastenStand( unsigned char taste )
 {
-	return TastenStand[ taste ];
+    return TastenStand[ taste ];
 }
 
 bool Framework::istThreadOk( Thread *t )

Globals.h

@@ -9,46 +9,46 @@
 
 namespace Framework
 {
-	class Maus; // Maus.h
-	class WFensterArray; // Fenster.h
+    class Maus; // Maus.h
+    class WFensterArray; // Fenster.h
     class Thread; // Thread.h
     class ThreadRegister; // Thread.h
     class Model3DList; // Model3DList.h
     class TexturList; // TexturList.h
 
-	Global WFensterArray WFensterA;
-	Global bool MausTrack;
-	Global bool MausStand[ 3 ];
-	Global bool TastenStand[ 255 ];
-	Global Maus MausZeiger;
-	Global bool istInitialisiert;
-	Global bool msgExit;
-	Global Punkt mausPos;
+    Global WFensterArray WFensterA;
+    Global bool MausTrack;
+    Global bool MausStand[ 3 ];
+    Global bool TastenStand[ 255 ];
+    Global Maus MausZeiger;
+    Global bool istInitialisiert;
+    Global bool msgExit;
+    Global Punkt mausPos;
     Global ThreadRegister *thRegister;
     Global Model3DList *m3dRegister;
     Global TexturList *texturRegister;
 
     // Gibt die Koordinaten der Maus auf dem Bildschirm zurück
-	__declspec( dllexport ) const Punkt &getMausPos();
+    __declspec( dllexport ) const Punkt &getMausPos();
     // Gibt zurück, ob eine Taste der Maus momentan gedrückt wird
     //  taste: Die Taste, die geprüft werden soll
     // Beispiel: getMausStand( M_Links ); (Benötigt include <MausEreignis.h>
-	__declspec( dllexport ) bool getMausStand( int taste );
+    __declspec( dllexport ) bool getMausStand( int taste );
     // Gibt zurück, ob eine Taste auf der tastatur momentan gedrückt wird
     //  taste: Die Taste, die überprüft werden soll
     // Beispiel: getTastenStand( T_Enter ); (Benötogt include <TastaturEreignis.h>
-	__declspec( dllexport ) bool getTastenStand( unsigned char taste );
+    __declspec( dllexport ) bool getTastenStand( unsigned char taste );
     // Legt fest, ob eine Taste auf der tastatur momentan gedrückt wird
     // Der Tastenstand wird vom Framework selbst verwaltet und muss nicht mit dieser Funktion gesetzt werden
     //  taste: Die Taste, deren Status gesetzt werden soll
     //  st: Ob die Taste momentan gedrückt wird. (true), wenn ja. (false) sonnst.
-	__declspec( dllexport ) void setTastenStand( unsigned char taste, bool st );
+    __declspec( dllexport ) void setTastenStand( unsigned char taste, bool st );
     // Initialisiert das Framework
     // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-	__declspec( dllexport ) void initFramework();
+    __declspec( dllexport ) void initFramework();
     // Gibt den duch (initFramework) benutzten Arbeitsspeicher wieder frei
     // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-	__declspec( dllexport ) void releaseFramework();
+    __declspec( dllexport ) void releaseFramework();
     // Überprüft, ob ein bestimmter Zeiger auf ein Gültiges Thread Objekt zeigt
     //  t: Der zeiger, der überprüft werden soll
     //  return: 1, falls der Zeiger in Ordnung ist. 0, falls der Zeiger auf kein existentes Thread Objekt zeigt

InitDatei.cpp

@@ -7,402 +7,401 @@ using namespace Framework;
 // Inhalt der InitDatei Klasse aus InitDatei.h
 // Konstruktor
 InitDatei::InitDatei()
-	: pfad( new Text() ),
-	  feldAnzahl( 0 ),
-	  name( new RCArray< Text >() ),
-	  wert( new RCArray< Text >() ),
-	  ref( 1 )
-{
-}
+    : pfad( new Text() ),
+    feldAnzahl( 0 ),
+    name( new RCArray< Text >() ),
+    wert( new RCArray< Text >() ),
+    ref( 1 )
+{}
 
 InitDatei::InitDatei( Text *pfad )
-	: pfad( new Text() ),
-	feldAnzahl( 0 ),
-	name( new RCArray< Text >() ),
-	wert( new RCArray< Text >() ),
-	ref( 1 )
+    : pfad( new Text() ),
+    feldAnzahl( 0 ),
+    name( new RCArray< Text >() ),
+    wert( new RCArray< Text >() ),
+    ref( 1 )
 {
-	setPfad( pfad );
+    setPfad( pfad );
 }
 
 InitDatei::InitDatei( const char *pfad )
-	: pfad( new Text() ),
-	feldAnzahl( 0 ),
-	name( new RCArray< Text >() ),
-	wert( new RCArray< Text >() ),
-	ref( 1 )
+    : pfad( new Text() ),
+    feldAnzahl( 0 ),
+    name( new RCArray< Text >() ),
+    wert( new RCArray< Text >() ),
+    ref( 1 )
 {
-	setPfad( pfad );
+    setPfad( pfad );
 }
 
 // Destruktor
 InitDatei::~InitDatei()
 {
-	pfad->release();
-	name->release();
-	wert->release();
+    pfad->release();
+    name->release();
+    wert->release();
 }
 
 // nicht constant
 void InitDatei::setPfad( Text *pfad )
 {
-	this->pfad->setText( pfad );
+    this->pfad->setText( pfad );
 }
 
 void InitDatei::setPfad( const char *pfad )
 {
-	this->pfad->setText( pfad );
+    this->pfad->setText( pfad );
 }
 
 bool InitDatei::laden()
 {
-	Datei *dat = new Datei();
-	dat->setDatei( pfad->getText() );
-	if( !dat->öffnen( Datei::Style::lesen ) )
-	{
-		dat->release();
-		return 0;
-	}
-	löscheAlle();
-	Text *zeile = dat->leseZeile();
-	for( int i = 0; zeile; ++i )
-	{
-		zeile->löschen( "\r\n" );
-		zeile->löschen( "\n" );
-		Text *n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
-		Text *w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
-		name->set( n, i );
-		wert->set( w, i );
-		zeile->release();
-		zeile = dat->leseZeile();
-		feldAnzahl = i + 1;
-	}
-	dat->schließen();
-	dat->release();
-	return 1;
+    Datei *dat = new Datei();
+    dat->setDatei( pfad->getText() );
+    if( !dat->öffnen( Datei::Style::lesen ) )
+    {
+        dat->release();
+        return 0;
+    }
+    löscheAlle();
+    Text *zeile = dat->leseZeile();
+    for( int i = 0; zeile; ++i )
+    {
+        zeile->löschen( "\r\n" );
+        zeile->löschen( "\n" );
+        Text *n = zeile->getTeilText( 0, zeile->positionVon( '=' ) );
+        Text *w = zeile->getTeilText( zeile->positionVon( '=' ) + 1 );
+        name->set( n, i );
+        wert->set( w, i );
+        zeile->release();
+        zeile = dat->leseZeile();
+        feldAnzahl = i + 1;
+    }
+    dat->schließen();
+    dat->release();
+    return 1;
 }
 
 bool InitDatei::addWert( Text *name, Text *wert )
 {
-	if( !wertExistiert( name->getText() ) )
-	{
-		this->name->set( new Text( name->getText() ), feldAnzahl );
-		this->wert->set( new Text( wert->getText() ), feldAnzahl );
-		++feldAnzahl;
-		name->release();
-		wert->release();
-		return 1;
-	}
-	name->release();
-	wert->release();
-	return 0;
+    if( !wertExistiert( name->getText() ) )
+    {
+        this->name->set( new Text( name->getText() ), feldAnzahl );
+        this->wert->set( new Text( wert->getText() ), feldAnzahl );
+        ++feldAnzahl;
+        name->release();
+        wert->release();
+        return 1;
+    }
+    name->release();
+    wert->release();
+    return 0;
 }
 
 bool InitDatei::addWert( const char *name, const char *wert )
 {
-	if( !wertExistiert( name ) )
-	{
-		this->name->set( new Text( name ), feldAnzahl );
-		this->wert->set( new Text( wert ), feldAnzahl );
-		++feldAnzahl;
-		return 1;
-	}
-	return 0;
+    if( !wertExistiert( name ) )
+    {
+        this->name->set( new Text( name ), feldAnzahl );
+        this->wert->set( new Text( wert ), feldAnzahl );
+        ++feldAnzahl;
+        return 1;
+    }
+    return 0;
 }
 
 bool InitDatei::setWert( Text *name, Text *wert )
 {
-	if( !wertExistiert( name->getText() ) )
-	{
-		name->release();
-		wert->release();
-		return 0;
-	}
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			this->wert->z( i )->setText( wert->getText() );
-			name->release();
-			wert->release();
-			return 1;
-		}
-	}
-	name->release();
-	wert->release();
-	return 0;
+    if( !wertExistiert( name->getText() ) )
+    {
+        name->release();
+        wert->release();
+        return 0;
+    }
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            this->wert->z( i )->setText( wert->getText() );
+            name->release();
+            wert->release();
+            return 1;
+        }
+    }
+    name->release();
+    wert->release();
+    return 0;
 }
 
 bool InitDatei::setWert( const char *name, const char *wert )
 {
-	if( !wertExistiert( name ) )
-		return 0;
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-		{
-			this->wert->z( i )->setText( wert );
-			return 1;
-		}
-	}
-	return 0;
+    if( !wertExistiert( name ) )
+        return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+        {
+            this->wert->z( i )->setText( wert );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 bool InitDatei::setWert( int num, Text *wert )
 {
-	if( num >= feldAnzahl )
-	{
-		wert->release();
-		return 0;
-	}
-	this->wert->z( num )->setText( wert->getText() );
-	wert->release();
-	return 1;
+    if( num >= feldAnzahl )
+    {
+        wert->release();
+        return 0;
+    }
+    this->wert->z( num )->setText( wert->getText() );
+    wert->release();
+    return 1;
 }
 
 bool InitDatei::setWert( int num, const char *wert )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	this->wert->z( num )->setText( wert );
-	return 1;
+    if( num >= feldAnzahl )
+        return 0;
+    this->wert->z( num )->setText( wert );
+    return 1;
 }
 
 bool InitDatei::löscheWert( Text *name )
 {
-	if( !wertExistiert( name->getText() ) )
-	{
-		name->release();
-		return 0;
-	}
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			this->name->lösche( i );
-			this->wert->lösche( i );
-			--feldAnzahl;
-			name->release();
-			return 1;
-		}
-	}
-	name->release();
-	return 0;
+    if( !wertExistiert( name->getText() ) )
+    {
+        name->release();
+        return 0;
+    }
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            this->name->lösche( i );
+            this->wert->lösche( i );
+            --feldAnzahl;
+            name->release();
+            return 1;
+        }
+    }
+    name->release();
+    return 0;
 }
 
 bool InitDatei::löscheWert( const char *name )
 {
-	if( !wertExistiert( name ) )
-		return 0;
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-		{
-			this->name->lösche( i );
-			this->wert->lösche( i );
-			--feldAnzahl;
-			return 1;
-		}
-	}
-	return 0;
+    if( !wertExistiert( name ) )
+        return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+        {
+            this->name->lösche( i );
+            this->wert->lösche( i );
+            --feldAnzahl;
+            return 1;
+        }
+    }
+    return 0;
 }
 
 bool InitDatei::löscheWert( int num )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	this->name->lösche( num );
-	this->wert->lösche( num );
-	--feldAnzahl;
-	return 1;
+    if( num >= feldAnzahl )
+        return 0;
+    this->name->lösche( num );
+    this->wert->lösche( num );
+    --feldAnzahl;
+    return 1;
 }
 
 void InitDatei::löscheAlle()
 {
-	for( ; feldAnzahl > 0; --feldAnzahl )
-	{
-		this->name->lösche( 0 );
-		this->wert->lösche( 0 );
-	}
+    for( ; feldAnzahl > 0; --feldAnzahl )
+    {
+        this->name->lösche( 0 );
+        this->wert->lösche( 0 );
+    }
 }
 
 bool InitDatei::speichern()
 {
-	Datei *dat = new Datei();
-	dat->setDatei( pfad->getText() );
-	if( !dat->existiert() )
-		dat->erstellen();
-	if( !dat->öffnen( Datei::Style::schreiben ) )
-	{
-		dat->release();
-		return 0;
-	}
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		Text *zeile = new Text( "" );
-		zeile->anhängen( name->z( i )->getText() );
-		zeile->anhängen( "=" );
-		zeile->anhängen( wert->z( i )->getText() );
-		zeile->anhängen( "\n" );
-		dat->schreibe( zeile->getText(), zeile->getLänge() );
-		zeile->release();
-	}
-	dat->schließen();
-	dat->release();
-	return 1;
+    Datei *dat = new Datei();
+    dat->setDatei( pfad->getText() );
+    if( !dat->existiert() )
+        dat->erstellen();
+    if( !dat->öffnen( Datei::Style::schreiben ) )
+    {
+        dat->release();
+        return 0;
+    }
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        Text *zeile = new Text( "" );
+        zeile->anhängen( name->z( i )->getText() );
+        zeile->anhängen( "=" );
+        zeile->anhängen( wert->z( i )->getText() );
+        zeile->anhängen( "\n" );
+        dat->schreibe( zeile->getText(), zeile->getLänge() );
+        zeile->release();
+    }
+    dat->schließen();
+    dat->release();
+    return 1;
 }
 
 // constant
 int InitDatei::getWertAnzahl() const
 {
-	return feldAnzahl;
+    return feldAnzahl;
 }
 
 bool InitDatei::wertExistiert( Text *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			name->release();
-			return 1;
-		}
-	}
-	name->release();
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            name->release();
+            return 1;
+        }
+    }
+    name->release();
+    return 0;
 }
 
 bool InitDatei::wertExistiert( const char *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-			return 1;
-	}
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+            return 1;
+    }
+    return 0;
 }
 
 int InitDatei::getWertNummer( Text *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			name->release();
-			return i;
-		}
-	}
-	name->release();
-	return -1;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            name->release();
+            return i;
+        }
+    }
+    name->release();
+    return -1;
 }
 
 int InitDatei::getWertNummer( const char *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-			return i;
-	}
-	return -1;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+            return i;
+    }
+    return -1;
 }
 
 Text *InitDatei::getWert( Text *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			name->release();
-			return wert->get( i );
-		}
-	}
-	name->release();
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            name->release();
+            return wert->get( i );
+        }
+    }
+    name->release();
+    return 0;
 }
 
 Text *InitDatei::getWert( const char *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-			return wert->get( i );
-	}
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+            return wert->get( i );
+    }
+    return 0;
 }
 
 Text *InitDatei::getWert( int num )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	return wert->get( num );
+    if( num >= feldAnzahl )
+        return 0;
+    return wert->get( num );
 }
 
 Text *InitDatei::zWert( Text *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name->getText() ) )
-		{
-			name->release();
-			return wert->z( i );
-		}
-	}
-	name->release();
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name->getText() ) )
+        {
+            name->release();
+            return wert->z( i );
+        }
+    }
+    name->release();
+    return 0;
 }
 
 Text *InitDatei::zWert( const char *name )
 {
-	for( int i = 0; i < feldAnzahl; ++i )
-	{
-		if( this->name->z( i )->istGleich( name ) )
-			return wert->z( i );
-	}
-	return 0;
+    for( int i = 0; i < feldAnzahl; ++i )
+    {
+        if( this->name->z( i )->istGleich( name ) )
+            return wert->z( i );
+    }
+    return 0;
 }
 
 Text *InitDatei::zWert( int num )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	return wert->z( num );
+    if( num >= feldAnzahl )
+        return 0;
+    return wert->z( num );
 }
 
 Text *InitDatei::getName( int num )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	return name->get( num );
+    if( num >= feldAnzahl )
+        return 0;
+    return name->get( num );
 }
 
 Text *InitDatei::zName( int num )
 {
-	if( num >= feldAnzahl )
-		return 0;
-	return name->z( num );
+    if( num >= feldAnzahl )
+        return 0;
+    return name->z( num );
 }
 
 Text *InitDatei::getPfad() const
 {
-	return pfad->getThis();
+    return pfad->getThis();
 }
 
 Text *InitDatei::zPfad() const
 {
-	return pfad;
+    return pfad;
 }
 
 // reference Counting
 InitDatei *InitDatei::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 InitDatei *InitDatei::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

InitDatei.h

@@ -5,146 +5,146 @@
 
 namespace Framework
 {
-	class Text; // Text.h
+    class Text; // Text.h
 
     // Verwaltet Initialisierungsdateien in denen Bestimmte Variablen im Format name=Wert gespeichert sind
-	class InitDatei
-	{
-	private:
-		Text *pfad;
-		int feldAnzahl;
-		RCArray< Text > *name;
-		RCArray< Text > *wert;
-		int ref;
+    class InitDatei
+    {
+    private:
+        Text *pfad;
+        int feldAnzahl;
+        RCArray< Text > *name;
+        RCArray< Text > *wert;
+        int ref;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) InitDatei();
+    public:
+        // Konstruktor
+        __declspec( dllexport ) InitDatei();
         // Konstruktor
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) InitDatei( Text *pfad );
+        __declspec( dllexport ) InitDatei( Text *pfad );
         // Konstruktor
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) InitDatei( const char *pfad );
-		// Destruktor
-		__declspec( dllexport ) ~InitDatei();
-		// Setzt den Pfad zur Datei
+        __declspec( dllexport ) InitDatei( const char *pfad );
+        // Destruktor
+        __declspec( dllexport ) ~InitDatei();
+        // Setzt den Pfad zur Datei
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) void setPfad( Text *pfad );
+        __declspec( dllexport ) void setPfad( Text *pfad );
         // Setzt den Pfad zur Datei
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) void setPfad( const char *pfad );
+        __declspec( dllexport ) void setPfad( const char *pfad );
         // Lähdt die Werte aus der Datei
         //  return: 1, falls das Laden erfolgreich war. 0, wenn ein fehler aufgetreten ist.
-		__declspec( dllexport ) bool laden();
+        __declspec( dllexport ) bool laden();
         // Fügt der Datei einen Wert hinzu
         //  name: Der Name des Wertes
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert erfolgreich hinzugefügt wurde
-		__declspec( dllexport ) bool addWert( Text *name, Text *wert );
+        __declspec( dllexport ) bool addWert( Text *name, Text *wert );
         // Fügt der Datei einen Wert hinzu
         //  name: Der Name des Wertes
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert erfolgreich hinzugefügt wurde
-		__declspec( dllexport ) bool addWert( const char *name, const char *wert );
+        __declspec( dllexport ) bool addWert( const char *name, const char *wert );
         // Ändert einen bestimmten Wert
         //  name: Der Name des Wertes
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich geändert werden konnte
-		__declspec( dllexport ) bool setWert( Text *name, Text *wert );
+        __declspec( dllexport ) bool setWert( Text *name, Text *wert );
         // Ändert einen bestimmten Wert
         //  name: Der Name des Wertes
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich geändert werden konnte
-		__declspec( dllexport ) bool setWert( const char *name, const char *wert );
+        __declspec( dllexport ) bool setWert( const char *name, const char *wert );
         // Ändert einen bestimmten Wert
         //  num: Der Index des Wertes der geändert werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich geändert werden konnte
-		__declspec( dllexport ) bool setWert( int num, Text *wert );
+        __declspec( dllexport ) bool setWert( int num, Text *wert );
         // Ändert einen bestimmten Wert
         //  num: Der Index des Wertes der geändert werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich geändert werden konnte
-		__declspec( dllexport ) bool setWert( int num, const char *wert );
+        __declspec( dllexport ) bool setWert( int num, const char *wert );
         // Löscht einen bestimmten Wert
         //  name: Der Name des Wertes, der gelöscht werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich gelöscht werden konnte
-		__declspec( dllexport ) bool löscheWert( Text *name );
+        __declspec( dllexport ) bool löscheWert( Text *name );
         // Löscht einen bestimmten Wert
         //  name: Der Name des Wertes, der gelöscht werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich gelöscht werden konnte
-		__declspec( dllexport ) bool löscheWert( const char *name );
+        __declspec( dllexport ) bool löscheWert( const char *name );
         // Löscht einen bestimmten Wert
         //  num: Der Index des Wertes der gelöscht werden soll
         //  return: 1, falls der Wert vorhanden war und erfolgreich gelöscht werden konnte
-		__declspec( dllexport ) bool löscheWert( int num );
+        __declspec( dllexport ) bool löscheWert( int num );
         // Löscht alle Werte aus der Datei
-		__declspec( dllexport ) void löscheAlle();
+        __declspec( dllexport ) void löscheAlle();
         // Speichert alle Werte in der Datei
         //  return: 1, falls das Speichern erfolgreich war
-		__declspec( dllexport ) bool speichern();
-		// Gibt die Anzahl der gespeicherten Werte zurück
-		__declspec( dllexport ) int getWertAnzahl() const;
+        __declspec( dllexport ) bool speichern();
+        // Gibt die Anzahl der gespeicherten Werte zurück
+        __declspec( dllexport ) int getWertAnzahl() const;
         // Überprüft, ob ein bestimmter Wert existiert
         //  name: Der Name, nach dem gesucht werden soll
         //  return: 1, falls der Wert gefunden wurde
-		__declspec( dllexport ) bool wertExistiert( Text *name );
+        __declspec( dllexport ) bool wertExistiert( Text *name );
         // Überprüft, ob ein bestimmter Wert existiert
         //  name: Der Name, nach dem gesucht werden soll
         //  return: 1, falls der Wert gefunden wurde
-		__declspec( dllexport ) bool wertExistiert( const char *name );
+        __declspec( dllexport ) bool wertExistiert( const char *name );
         // Gibt den Index eines Bestimmten Wertes zurück
         //  name: Der Name des Wertes, nach dem gesucht werden soll
         //  return: -1, falls der Wert nicht gefunden wurde. Der Index des Wertes.
-		__declspec( dllexport ) int getWertNummer( Text *name );
+        __declspec( dllexport ) int getWertNummer( Text *name );
         // Gibt den Index eines Bestimmten Wertes zurück
         //  name: Der Name des Wertes, nach dem gesucht werden soll
         //  return: -1, falls der Wert nicht gefunden wurde. Der Index des Wertes.
-		__declspec( dllexport ) int getWertNummer( const char *name );
+        __declspec( dllexport ) int getWertNummer( const char *name );
         // Gibt einen bestimmten Wert zurück
         //  name: Der Name des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde.
-		__declspec( dllexport ) Text *getWert( Text *name );
+        __declspec( dllexport ) Text *getWert( Text *name );
         // Gibt einen bestimmten Wert zurück
         //  name: Der Name des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde.
-		__declspec( dllexport ) Text *getWert( const char *name );
+        __declspec( dllexport ) Text *getWert( const char *name );
         // Gibt einen bestimmten Wert zurück
         //  num: Der Index des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde.
-		__declspec( dllexport ) Text *getWert( int num );
+        __declspec( dllexport ) Text *getWert( int num );
         // Gibt einen bestimmten Wert zurück
         //  name: Der Name des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde. Der Wert ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zWert( Text *name );
+        __declspec( dllexport ) Text *zWert( Text *name );
         // Gibt einen bestimmten Wert zurück
         //  name: Der Name des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde. Der Wert ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zWert( const char *name );
+        __declspec( dllexport ) Text *zWert( const char *name );
         // Gibt einen bestimmten Wert zurück
         //  num: Der Index des Wertes, der zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde. Der Wert ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zWert( int num );
+        __declspec( dllexport ) Text *zWert( int num );
         // Gibt den Namen eines bestimmten Wertes zurück
         //  num: Der Index des Wertes, dessen Namen zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde.
-		__declspec( dllexport ) Text *getName( int num );
+        __declspec( dllexport ) Text *getName( int num );
         // Gibt den Namen eines bestimmten Wertes zurück
         //  num: Der Index des Wertes, dessen Namen zurückgegeben werden soll
         //  return: 0, falls der Wert nicht gefunden wurde. Der Name ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zName( int num );
+        __declspec( dllexport ) Text *zName( int num );
         // Gibt den Pfad zur Datei zurück
-		__declspec( dllexport ) Text *getPfad() const;
+        __declspec( dllexport ) Text *getPfad() const;
         // Gibt den Pfad zur Datei ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Text *zPfad() const;
+        __declspec( dllexport ) Text *zPfad() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) InitDatei *getThis();
+        __declspec( dllexport ) InitDatei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) InitDatei *release();
-	};
+        __declspec( dllexport ) InitDatei *release();
+    };
 }
 
 #endif

KSGTDatei.cpp

@@ -7,304 +7,302 @@ using namespace Framework;
 // Inhalt der KSGTDatei Klasse aus KSGTDatei.h
 // Konstruktor
 KSGTDatei::KSGTDatei()
-	: pfad( new Text() ),
-	  data( new RCArray< RCArray< Text > >() ),
-	  ref( 1 )
-{
-}
+    : pfad( new Text() ),
+    data( new RCArray< RCArray< Text > >() ),
+    ref( 1 )
+{}
 
 KSGTDatei::KSGTDatei( const char *pfad )
-	: pfad( new Text() ),
-	  data( new RCArray< RCArray< Text > >() ),
-	  ref( 1 )
+    : pfad( new Text() ),
+    data( new RCArray< RCArray< Text > >() ),
+    ref( 1 )
 {
-	setPfad( pfad );
+    setPfad( pfad );
 }
 
 KSGTDatei::KSGTDatei( Text *pfad )
-	: pfad( new Text() ),
-	  data( new RCArray< RCArray< Text > >() ),
-	  ref( 1 )
+    : pfad( new Text() ),
+    data( new RCArray< RCArray< Text > >() ),
+    ref( 1 )
 {
-	setPfad( pfad );
+    setPfad( pfad );
 }
 
 // Destruktor
 KSGTDatei::~KSGTDatei()
 {
-	pfad->release();
-	data->release();
+    pfad->release();
+    data->release();
 }
 
 // nicht constant
 void KSGTDatei::setPfad( const char *pfad )
 {
-	this->pfad->setText( pfad );
+    this->pfad->setText( pfad );
 }
 
 void KSGTDatei::setPfad( Text *pfad )
 {
-	this->pfad->setText( pfad );
+    this->pfad->setText( pfad );
 }
 
 bool KSGTDatei::laden()
 {
-	std::ifstream inf;
-	inf.open( pfad->getText(), std::ios::binary );
-	if( !inf.good() || !inf.is_open() )
-		return 0;
-	data->leeren();
-	inf.seekg( 0, std::ios::end );
-	__int64 gr = inf.tellg();
-	__int64 pos = 0;
-	int zeilenPos = 0;
-	int feldPos = 0;
-	while( pos < gr )
-	{
-		inf.seekg( pos, std::ios::beg );
-		char c = 1;
-		int län = 0;
-		do
-		{
-			inf.read( &c, 1 );
-			++län;
-		}
-		while( c != 0 && c != '\n' && pos + län < gr );
-		if( pos + län == gr )
-			++län;
-		inf.seekg( pos, std::ios::beg );
-		char *v = new char[ län ];
-		v[ län - 1 ] = 0;
-		if( län > 1 )
-			inf.read( v, län - 1 );
-		pos += län;
-		if( län > 1 && !data->z( zeilenPos ) )
-			data->set( new RCArray< Text >, zeilenPos );
-		if( !data->z( zeilenPos )->z( feldPos ) )
-			data->z( zeilenPos )->set( new Text(), feldPos );
-		data->z( zeilenPos )->z( feldPos )->setText( v );
-		delete[] v;
-		if( c == 0 )
-			++feldPos;
-		else if( c == '\n' )
-		{
-			++zeilenPos;
-			feldPos = 0;
-		}
-		else
-			break;
-	}
-	inf.close();
-	return 1;
+    std::ifstream inf;
+    inf.open( pfad->getText(), std::ios::binary );
+    if( !inf.good() || !inf.is_open() )
+        return 0;
+    data->leeren();
+    inf.seekg( 0, std::ios::end );
+    __int64 gr = inf.tellg();
+    __int64 pos = 0;
+    int zeilenPos = 0;
+    int feldPos = 0;
+    while( pos < gr )
+    {
+        inf.seekg( pos, std::ios::beg );
+        char c = 1;
+        int län = 0;
+        do
+        {
+            inf.read( &c, 1 );
+            ++län;
+        } while( c != 0 && c != '\n' && pos + län < gr );
+        if( pos + län == gr )
+            ++län;
+        inf.seekg( pos, std::ios::beg );
+        char *v = new char[ län ];
+        v[ län - 1 ] = 0;
+        if( län > 1 )
+            inf.read( v, län - 1 );
+        pos += län;
+        if( län > 1 && !data->z( zeilenPos ) )
+            data->set( new RCArray< Text >, zeilenPos );
+        if( !data->z( zeilenPos )->z( feldPos ) )
+            data->z( zeilenPos )->set( new Text(), feldPos );
+        data->z( zeilenPos )->z( feldPos )->setText( v );
+        delete[] v;
+        if( c == 0 )
+            ++feldPos;
+        else if( c == '\n' )
+        {
+            ++zeilenPos;
+            feldPos = 0;
+        }
+        else
+            break;
+    }
+    inf.close();
+    return 1;
 }
 
 bool KSGTDatei::addZeile( int feldAnzahl, RCArray< Text > *zWert )
 {
-	int pos = getZeilenAnzahl();
-	data->set( new RCArray< Text >(), pos );
-	for( int i = 0; i < feldAnzahl; ++i )
-		data->z( pos )->set( new Text( zWert->z( i )->getText() ), i );
-	return 1;
+    int pos = getZeilenAnzahl();
+    data->set( new RCArray< Text >(), pos );
+    for( int i = 0; i < feldAnzahl; ++i )
+        data->z( pos )->set( new Text( zWert->z( i )->getText() ), i );
+    return 1;
 }
 
 bool KSGTDatei::setZeile( int zeile, int feldAnzahl, RCArray< Text > *zWert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	data->set( new RCArray< Text >(), zeile );
-	for( int i = 0; i < feldAnzahl; ++i )
-		data->z( zeile )->set( new Text( zWert->z( i )->getText() ), i );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    data->set( new RCArray< Text >(), zeile );
+    for( int i = 0; i < feldAnzahl; ++i )
+        data->z( zeile )->set( new Text( zWert->z( i )->getText() ), i );
+    return 1;
 }
 
 bool KSGTDatei::löscheZeile( int zeile )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	data->lösche( zeile );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    data->lösche( zeile );
+    return 1;
 }
 
 bool KSGTDatei::addFeld( int zeile, int pos, Text *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-	{
-		wert->release();
-		return 0;
-	}
-	int fA = getFeldAnzahl( zeile );
-	if( pos > fA )
-	{
-		wert->release();
-		return 0;
-	}
-	data->z( zeile )->add( new Text( wert->getText() ), pos );
-	wert->release();
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+    {
+        wert->release();
+        return 0;
+    }
+    int fA = getFeldAnzahl( zeile );
+    if( pos > fA )
+    {
+        wert->release();
+        return 0;
+    }
+    data->z( zeile )->add( new Text( wert->getText() ), pos );
+    wert->release();
+    return 1;
 }
 
 bool KSGTDatei::addFeld( int zeile, int pos, const char *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	if( pos > fA )
-		return 0;
-	data->z( zeile )->add( new Text( wert ), pos );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    if( pos > fA )
+        return 0;
+    data->z( zeile )->add( new Text( wert ), pos );
+    return 1;
 }
 
 bool KSGTDatei::addFeld( int zeile, Text *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-	{
-		wert->release();
-		return 0;
-	}
-	int fA = getFeldAnzahl( zeile );
-	data->z( zeile )->set( new Text( wert->getText() ), fA );
-	wert->release();
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+    {
+        wert->release();
+        return 0;
+    }
+    int fA = getFeldAnzahl( zeile );
+    data->z( zeile )->set( new Text( wert->getText() ), fA );
+    wert->release();
+    return 1;
 }
 
 bool KSGTDatei::addFeld( int zeile, const char *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	data->z( zeile )->set( new Text( wert ), fA );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    data->z( zeile )->set( new Text( wert ), fA );
+    return 1;
 }
 
 bool KSGTDatei::setFeld( int zeile, int feld, Text *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-	{
-		wert->release();
-		return 0;
-	}
-	int fA = getFeldAnzahl( zeile );
-	if( feld >= fA )
-	{
-		wert->release();
-		return 0;
-	}
-	data->z( zeile )->set( new Text( wert->getText() ), feld );
-	wert->release();
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+    {
+        wert->release();
+        return 0;
+    }
+    int fA = getFeldAnzahl( zeile );
+    if( feld >= fA )
+    {
+        wert->release();
+        return 0;
+    }
+    data->z( zeile )->set( new Text( wert->getText() ), feld );
+    wert->release();
+    return 1;
 }
 
 bool KSGTDatei::setFeld( int zeile, int feld, const char *wert )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	if( feld >= fA )
-		return 0;
-	data->z( zeile )->set( new Text( wert ), feld );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    if( feld >= fA )
+        return 0;
+    data->z( zeile )->set( new Text( wert ), feld );
+    return 1;
 }
 
 bool KSGTDatei::löscheFeld( int zeile, int feld )
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	if( feld >= fA )
-		return 0;
-	data->z( zeile )->lösche( feld );
-	return 1;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    if( feld >= fA )
+        return 0;
+    data->z( zeile )->lösche( feld );
+    return 1;
 }
 
 bool KSGTDatei::speichern()
 {
-	if( !pfad->getLänge() )
-		return 0;
-	if( !DateiExistiert( pfad->getText() ) )
-		DateiPfadErstellen( pfad->getText() );
-	std::ofstream of( pfad->getText(), std::ios::binary );
-	if( !of.good() || !of.is_open() )
-		return 0;
-	int zA = getZeilenAnzahl();
-	for( int z = 0; z < zA; ++z )
-	{
-		if( z )
-			of.write( "\n", 1 );
-		int fA = getFeldAnzahl( z );
-		for( int f = 0; f < fA; ++f )
-		{
-			if( f )
-				of.write( "\0", 1 );
-			if( data->z( z ) && data->z( z )->z( f ) )
-				of.write( data->z( z )->z( f )->getText(), data->z( z )->z( f )->getLänge() );
-		}
-	}
-	of.close();
-	return 1;
+    if( !pfad->getLänge() )
+        return 0;
+    if( !DateiExistiert( pfad->getText() ) )
+        DateiPfadErstellen( pfad->getText() );
+    std::ofstream of( pfad->getText(), std::ios::binary );
+    if( !of.good() || !of.is_open() )
+        return 0;
+    int zA = getZeilenAnzahl();
+    for( int z = 0; z < zA; ++z )
+    {
+        if( z )
+            of.write( "\n", 1 );
+        int fA = getFeldAnzahl( z );
+        for( int f = 0; f < fA; ++f )
+        {
+            if( f )
+                of.write( "\0", 1 );
+            if( data->z( z ) && data->z( z )->z( f ) )
+                of.write( data->z( z )->z( f )->getText(), data->z( z )->z( f )->getLänge() );
+        }
+    }
+    of.close();
+    return 1;
 }
 
 // constant
 int KSGTDatei::getZeilenAnzahl() const
 {
-	int ret = 0;
-	while( data->z( ret ) )
-		++ret;
-	return ret;
+    int ret = 0;
+    while( data->z( ret ) )
+        ++ret;
+    return ret;
 }
 
 int KSGTDatei::getFeldAnzahl( int zeile ) const
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int ret = 0;
-	while( data->z( zeile )->z( ret ) )
-		++ret;
-	return ret;
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int ret = 0;
+    while( data->z( zeile )->z( ret ) )
+        ++ret;
+    return ret;
 }
 
 Text *KSGTDatei::getFeld( int zeile, int feld ) const
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	if( feld >= fA )
-		return 0;
-	return data->z( zeile )->get( feld );
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    if( feld >= fA )
+        return 0;
+    return data->z( zeile )->get( feld );
 }
 
 Text *KSGTDatei::zFeld( int zeile, int feld ) const
 {
-	int zA = getZeilenAnzahl();
-	if( zeile >= zA )
-		return 0;
-	int fA = getFeldAnzahl( zeile );
-	if( feld >= fA )
-		return 0;
-	return data->z( zeile )->z( feld );
+    int zA = getZeilenAnzahl();
+    if( zeile >= zA )
+        return 0;
+    int fA = getFeldAnzahl( zeile );
+    if( feld >= fA )
+        return 0;
+    return data->z( zeile )->z( feld );
 }
 
 // Reference Counting
 KSGTDatei *KSGTDatei::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 KSGTDatei *KSGTDatei::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

KSGTDatei.h

@@ -5,115 +5,115 @@
 
 namespace Framework
 {
-	class Text;
+    class Text;
 
     // Verwaltet eine Datei in der Daten tabellarisch abgespeichert werden
-	class KSGTDatei
-	{
-	private:
-		Text *pfad;
-		RCArray< RCArray< Text > > *data;
-		int ref;
+    class KSGTDatei
+    {
+    private:
+        Text *pfad;
+        RCArray< RCArray< Text > > *data;
+        int ref;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) KSGTDatei();
+    public:
+        // Konstruktor
+        __declspec( dllexport ) KSGTDatei();
         // Konstruktor
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) KSGTDatei( const char *pfad );
+        __declspec( dllexport ) KSGTDatei( const char *pfad );
         // Konstruktor
         //  pfad: Der Pfad zur Datei
         __declspec( dllexport ) KSGTDatei( Text *pfad );
-		// Destruktor
-		__declspec( dllexport ) ~KSGTDatei();
-		// Setzt den Pfad zur Datei
+        // Destruktor
+        __declspec( dllexport ) ~KSGTDatei();
+        // Setzt den Pfad zur Datei
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) void setPfad( const char *pfad );
+        __declspec( dllexport ) void setPfad( const char *pfad );
         // Setzt den Pfad zur Datei
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) void setPfad( Text *pfad );
+        __declspec( dllexport ) void setPfad( Text *pfad );
         // lähdt alle Daten aus der angegebenen Datei
         //  return: 1, falls das laden erfolgreich war. 0, wenn ein Fehler beim laden aufgetreten ist
-		__declspec( dllexport ) bool laden();
+        __declspec( dllexport ) bool laden();
         // Fügt eine Zeile zur Tabelle hinzu
         //  feldAnzahl: Die Anzahl der Felder in der Zeile
         //  zWert: Einen Zeiger auf die Werte in der Zeile ohne erhöhten Reference Counter
         //  return: 1, wenn kein Fehler aufgetreten ist
-		__declspec( dllexport ) bool addZeile( int feldAnzahl, RCArray< Text > *zWert );
+        __declspec( dllexport ) bool addZeile( int feldAnzahl, RCArray< Text > *zWert );
         // Ersetzt eine existierende Zeile
         //  zeile: Der Index der Zeile, die ersetzt werden soll
         //  feldAnzahl: Die Anzahl der Felder in der Zeile
         //  zWert: Einen Zeiger auf die Werte in der Zeile ohne erhöhten Reference Counter
         //  return: 1, wenn die Zeile existierte und ersetzt wurde. 0, wenn die angegebene Zeile nicht existierte
-		__declspec( dllexport ) bool setZeile( int zeile, int feldAnzahl, RCArray< Text > *zWert );
+        __declspec( dllexport ) bool setZeile( int zeile, int feldAnzahl, RCArray< Text > *zWert );
         // Löscht eine Zeile
         //  zeile: Der Index der Zeile, die gelöscht werden soll
         //  return: 1, wenn die Zeile gelöscht wurde. 0, wenn die Zeile nicht gefunden wurde
-		__declspec( dllexport ) bool löscheZeile( int zeile );
+        __declspec( dllexport ) bool löscheZeile( int zeile );
         // Fügt einer Bestimmten Zeile einen Wert hinzu
         //  zeile: Der Index der Zeile, der ein Wert hinzugefügt werden soll
         //  pos: Die Position in der Zeile, an der der Wert hinzugefügt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich hinzugefügt wurde. 0, falls die Zeile nicht existiert, oder pos zu groß ist
-		__declspec( dllexport ) bool addFeld( int zeile, int pos, Text *wert );
+        __declspec( dllexport ) bool addFeld( int zeile, int pos, Text *wert );
         // Fügt einer Bestimmten Zeile einen Wert hinzu
         //  zeile: Der Index der Zeile, der ein Wert hinzugefügt werden soll
         //  pos: Die Position in der Zeile, an der der Wert hinzugefügt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich hinzugefügt wurde. 0, falls die Zeile nicht existiert, oder pos zu groß ist
-		__declspec( dllexport ) bool addFeld( int zeile, int pos, const char *wert );
+        __declspec( dllexport ) bool addFeld( int zeile, int pos, const char *wert );
         // Fügt einer Bestimmten Zeile am Ende einen Wert hinzu
         //  zeile: Der Index der Zeile, der ein Wert hinzugefügt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich hinzugefügt wurde. 0, falls die Zeile nicht existiert
-		__declspec( dllexport ) bool addFeld( int zeile, Text *wert );
+        __declspec( dllexport ) bool addFeld( int zeile, Text *wert );
         // Fügt einer Bestimmten Zeile am Ende einen Wert hinzu
         //  zeile: Der Index der Zeile, der ein Wert hinzugefügt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich hinzugefügt wurde. 0, falls die Zeile nicht existiert
-		__declspec( dllexport ) bool addFeld( int zeile, const char *wert );
+        __declspec( dllexport ) bool addFeld( int zeile, const char *wert );
         // Setzt einen Bestimmten Wert in einer Zeile
         //  zeile: Der Index der Zeile, in der ein Wert verändert werden soll
         //  feld: Die Position in der Zeile, an der der Wert gesetzt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich ersetzt wurde. 0, falls die Zeile oder der Wert nicht existiert
-		__declspec( dllexport ) bool setFeld( int zeile, int feld, Text *wert );
+        __declspec( dllexport ) bool setFeld( int zeile, int feld, Text *wert );
         // Setzt einen Bestimmten Wert in einer Zeile
         //  zeile: Der Index der Zeile, in der ein Wert verändert werden soll
         //  feld: Die Position in der Zeile, an der der Wert gesetzt werden soll
         //  wert: Der Wert, der gespeichert werden soll
         //  return: 1, falls Der Wert erfolgreich ersetzt wurde. 0, falls die Zeile oder der Wert nicht existiert
-		__declspec( dllexport ) bool setFeld( int zeile, int feld, const char *wert );
+        __declspec( dllexport ) bool setFeld( int zeile, int feld, const char *wert );
         // Entfernt einen bestimmten Wert
         //  zeile: Der Index der Zeile, aus der ein Wert gelöscht werden soll
         //  feld: Die Position in der Zeile, an der der Wert gelöscht werden soll
         //  return: 1, falls Der Wert erfolgreich gelöscht wurde. 0, falls die Zeile oder der Wert nicht existiert
-		__declspec( dllexport ) bool löscheFeld( int zeile, int feld );
+        __declspec( dllexport ) bool löscheFeld( int zeile, int feld );
         // Speichert die Tabelle in der Datei
         //  return: 1, falls die Tabbelle erfolgreich gespeichert wurde
-		__declspec( dllexport ) bool speichern();
-		// Gibt die Anzahl der Zeilen zurück
-		__declspec( dllexport ) int getZeilenAnzahl() const;
+        __declspec( dllexport ) bool speichern();
+        // Gibt die Anzahl der Zeilen zurück
+        __declspec( dllexport ) int getZeilenAnzahl() const;
         // Gibt die Anzahl der Werte (Spalten) in einer Zeile zurück
         //  zeile: Der Index der Zeile, von der die Anzahl Werte ermittelt werden soll
-		__declspec( dllexport ) int getFeldAnzahl( int zeile ) const;
+        __declspec( dllexport ) int getFeldAnzahl( int zeile ) const;
         // Gibt einen bestimmten gespeicherten Wert zurück
         //  zeile: Der Index der Zeile, in der der Wert gespeichert wird
         //  feld: Der Index des Wertes in der Zeile
         //  return: Den gespeicherten Wert mit erhöhtem Reference Counter
-		__declspec( dllexport ) Text *getFeld( int zeile, int feld ) const;
+        __declspec( dllexport ) Text *getFeld( int zeile, int feld ) const;
         // Gibt einen bestimmten gespeicherten Wert zurück
         //  zeile: Der Index der Zeile, in der der Wert gespeichert wird
         //  feld: Der Index des Wertes in der Zeile
         //  return: Den gespeicherten Wert ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zFeld( int zeile, int feld ) const;
+        __declspec( dllexport ) Text *zFeld( int zeile, int feld ) const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) KSGTDatei *getThis();
+        __declspec( dllexport ) KSGTDatei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) KSGTDatei *release();
-	};
+        __declspec( dllexport ) KSGTDatei *release();
+    };
 }
 
 #endif

Knopf.h

@@ -5,18 +5,18 @@
 
 namespace Framework
 {
-	class TextFeld; // TextFeld.h
-	class AlphaFeld; // AlphaFeld.h
-	class Text; // Text.h
-	class Schrift; // Schrift.h
-	class LRahmen; // Rahmen.h
-	class LTDBDatei; // Dateisystem.h
-	class Knopf; // aus dieser Datei
-	class KontrollKnopf; // aus dieser Datei
+    class TextFeld; // TextFeld.h
+    class AlphaFeld; // AlphaFeld.h
+    class Text; // Text.h
+    class Schrift; // Schrift.h
+    class LRahmen; // Rahmen.h
+    class LTDBDatei; // Dateisystem.h
+    class Knopf; // aus dieser Datei
+    class KontrollKnopf; // aus dieser Datei
 
     // Eine Zeichnung des 2D GUI Frameworks, die einen Knopf zeichnet, den der Benutzer drücken kann
-	class Knopf : public TextFeld
-	{
+    class Knopf : public TextFeld
+    {
     public:
         class Style : public ZeichnungHintergrund::Style
         {
@@ -30,69 +30,69 @@ namespace Framework
             const static __int64 Normal = Sichtbar | Erlaubt | Rahmen | Buffered | MehrfarbigText | KlickBuffer; // Vereint di Flags Sichtbar, Erlaubt, Rahmen, Buffered, MehrfarbigText, KlickBuffer
         };
 
-	private:
-		int klickFarbe;
-		Bild *klickBild;
-		AlphaFeld *klickBuffer;
-		int klickIndex;
-		int ref;
+    private:
+        int klickFarbe;
+        Bild *klickBild;
+        AlphaFeld *klickBuffer;
+        int klickIndex;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Knopf();
-		// Destruktor 
-		__declspec( dllexport ) ~Knopf();
-		// Setzt die Farbe, die als Hintergrund verwendet wird, wenn der Knopf gedrückt wird
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Knopf();
+        // Destruktor 
+        __declspec( dllexport ) ~Knopf();
+        // Setzt die Farbe, die als Hintergrund verwendet wird, wenn der Knopf gedrückt wird
         //  fc: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setKlickFarbe( int fc );
+        __declspec( dllexport ) void setKlickFarbe( int fc );
         // Setzt das Hintergrund Bild durch kopieren, das verwendet wird, wenn der Knopf gedrückt wird
         //  bild: Das Bild, das kopiert werden soll
-		__declspec( dllexport ) void setKlickBild( Bild *bild );
+        __declspec( dllexport ) void setKlickBild( Bild *bild );
         // Setzt einen Zeiger auf das Hintergrund Bild, das verwendet wird, wenn der Knopf gedrückt wird
         //  bild: Das neue Bild
-		__declspec( dllexport ) void setKlickBildZ( Bild *bild );
+        __declspec( dllexport ) void setKlickBildZ( Bild *bild );
         // Setzt einen Zeiger auf den Farbübergang, der verwendet wird, wenn der Knopf gedrückt wird
         //  af: Der neue Farbübergang
-		__declspec( dllexport ) void setKBZ( AlphaFeld *af );
+        __declspec( dllexport ) void setKBZ( AlphaFeld *af );
         // Setzt die Stärke des Farbübergangs, der verwendet wird, wenn der Knopf gedrückt wird
         //  st: Die Stärke
-		__declspec( dllexport ) void setKBStärke( int st );
+        __declspec( dllexport ) void setKBStärke( int st );
         // Setzt die Farbe des Farbübergangs, der verwendet wird, wenn der Knopf gedrückt wird
         //  fc: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setKBFarbe( int fc );
+        __declspec( dllexport ) void setKBFarbe( int fc );
         // Verarbeitet Maus Nachrichten
         //  me: Das Ereignis, was durch die Mauseingabe ausgelößt wurde
-		__declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
         // Zeichnet das Objekt nach zRObj, falls es sichtbar ist
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Hintergrund Farbe im A8R8G8B8 Format zurück, die verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) int getKlickFarbe() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Hintergrund Farbe im A8R8G8B8 Format zurück, die verwendet wird, wenn der Knopf gedrückt wird
+        __declspec( dllexport ) int getKlickFarbe() const;
         // Gibt das Hintergrund Bild zurück, das verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) Bild *getKlickBild() const;
+        __declspec( dllexport ) Bild *getKlickBild() const;
         // Gibt das Hintergrund Bild ohne erhöhten Reference Counter zurück, das verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) Bild *zKlickBild() const;
+        __declspec( dllexport ) Bild *zKlickBild() const;
         // Gibt den Farbübergang zurück, der verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) AlphaFeld *getKB() const;
+        __declspec( dllexport ) AlphaFeld *getKB() const;
         // Gibt den Farbübergang ohne erhöhten Reference Counter zurück, der verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) AlphaFeld *zKB() const;
+        __declspec( dllexport ) AlphaFeld *zKB() const;
         // Gibt die Farbe des Farbübergangs im A8R8G8B8 Format zurück, der verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) int getKBFarbe() const;
+        __declspec( dllexport ) int getKBFarbe() const;
         // Gibt die Stärke des Farbübergangs zurück, der verwendet wird, wenn der Knopf gedrückt wird
-		__declspec( dllexport ) int getKBStärke() const;
+        __declspec( dllexport ) int getKBStärke() const;
         // Kopiert den Knopf, so das er ohne auswirkungen auf das Original verändert werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Knopf *getThis();
+        __declspec( dllexport ) Knopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Knopf *release();
-	};
+        __declspec( dllexport ) Knopf *release();
+    };
 
     // Eine Zeichnung des 2D GUI Frameworks, die einen Auswählbares Kästchen mit beschriftung zeichnet
-	class KontrollKnopf : public ZeichnungHintergrund
-	{
+    class KontrollKnopf : public ZeichnungHintergrund
+    {
     public:
         class Style : public ZeichnungHintergrund::Style
         {
@@ -116,147 +116,147 @@ namespace Framework
             const static __int64 Normal = Sichtbar | Erlaubt | Rahmen | KlickBuffer; // Vereint die Flags Sichtbar, Erlaubt, Rahmen, KlickBuffer
         };
 
-	private:
-		Text *txt;
-		Text *sTxt;
-		int sBgF;
-		int kBgF;
-		Bild *sBgB;
-		Bild *kBgB;
-		AlphaFeld *sAf;
-		AlphaFeld *kAf;
-		Bild *kasten;
-		Bild *sKasten;
-		Schrift *schrift;
-		int sF;
-		int sGr;
-		int ref;
+    private:
+        Text *txt;
+        Text *sTxt;
+        int sBgF;
+        int kBgF;
+        Bild *sBgB;
+        Bild *kBgB;
+        AlphaFeld *sAf;
+        AlphaFeld *kAf;
+        Bild *kasten;
+        Bild *sKasten;
+        Schrift *schrift;
+        int sF;
+        int sGr;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) KontrollKnopf();
-		// Destruktor 
-		__declspec( dllexport ) ~KontrollKnopf();
-		// Setzt den Zeiger auf den Beschriftungs Text
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) KontrollKnopf();
+        // Destruktor 
+        __declspec( dllexport ) ~KontrollKnopf();
+        // Setzt den Zeiger auf den Beschriftungs Text
         //  txt: Der Text
-		__declspec( dllexport ) void setTextZ( Text *txt );
+        __declspec( dllexport ) void setTextZ( Text *txt );
         // Setzt den Beschriftungs Text
         //  txt: Der Text
-		__declspec( dllexport ) void setText( Text *txt );
+        __declspec( dllexport ) void setText( Text *txt );
         // Setzt den Beschriftungs Text
         //  txt: Der Text
-		__declspec( dllexport ) void setText( const char *txt );
+        __declspec( dllexport ) void setText( const char *txt );
         // Setzt den Zeiger auf den Beschriftungs Text, der angezeigt wird, während das Kästchen ausgewählt ist
         //  txt: Der Text
-		__declspec( dllexport ) void setSTextZ( Text *txt );
+        __declspec( dllexport ) void setSTextZ( Text *txt );
         // Setzt den Beschriftungs Text, der angezeigt wird, während das Kästchen ausgewählt ist
         //  txt: Der Text
-		__declspec( dllexport ) void setSText( Text *txt );
+        __declspec( dllexport ) void setSText( Text *txt );
         // Setzt den Beschriftungs Text, der angezeigt wird, während das Kästchen ausgewählt ist
         //  txt: Der Text
-		__declspec( dllexport ) void setSText( const char *txt );
+        __declspec( dllexport ) void setSText( const char *txt );
         // Setzt die Schrift, die für die Beschriftung verwendet werden soll
         //  schrift: Die Schrift
-		__declspec( dllexport ) void setSchriftZ( Schrift *schrift );
+        __declspec( dllexport ) void setSchriftZ( Schrift *schrift );
         // Setzt die Farbe der Schrift, die für die Beschriftung verwendet werden soll
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setSFarbe( int f );
+        __declspec( dllexport ) void setSFarbe( int f );
         // Setzt die Größe der Schrift, die für die Beschriftung verwendet werden soll
         //  f: Die Höhe einer Zeile in Pixeln
-		__declspec( dllexport ) void setSGröße( int gr );
+        __declspec( dllexport ) void setSGröße( int gr );
         // Setzt die Hintergrund Farbe, die verwendet wird, während das Kästchen ausgewählt ist
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setSBgFarbe( int f );
+        __declspec( dllexport ) void setSBgFarbe( int f );
         // Setzt die Hintergrund Farbe, die verwendet wird, während auf das Kästchen geklickt wird
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setKBgFarbe( int f );
+        __declspec( dllexport ) void setKBgFarbe( int f );
         // Setzt einen Zeiger auf das Hintergrund Bild, das verwendet wird, während das Kästchen ausgewählt ist
         //  b: Das Bild
-		__declspec( dllexport ) void setSBgBildZ( Bild *b );
+        __declspec( dllexport ) void setSBgBildZ( Bild *b );
         // Setzt das Hintergrund Bild durch kopieren, das verwendet wird, während das Kästchen ausgewählt ist
         //  b: Das Bild, das kopiert werden soll
-		__declspec( dllexport ) void setSBgBild( Bild *b );
+        __declspec( dllexport ) void setSBgBild( Bild *b );
         // Setzt einen Zeiger auf das Hintergrund Bild, das verwendet wird, während auf das Kästchen geklickt wird
         //  b: Das Bild
-		__declspec( dllexport ) void setKBgBildZ( Bild *b );
+        __declspec( dllexport ) void setKBgBildZ( Bild *b );
         // Setzt das Hintergrund Bild durch kopieren, das verwendet wird, während auf das Kästchen geklickt wird
         //  b: Das Bild, das kopiert werden soll
-		__declspec( dllexport ) void setKBgBild( Bild *b );
+        __declspec( dllexport ) void setKBgBild( Bild *b );
         // Setzt einen Zeiger auf den Farbübergang, der verwendet wird, während das Kästchen ausgewählt ist
         //  af: Der Farbübergang
-		__declspec( dllexport ) void setSAlphaFeldZ( AlphaFeld *af );
+        __declspec( dllexport ) void setSAlphaFeldZ( AlphaFeld *af );
         // Setzt die Farbe des Farbübergangs, der verwendet wird, während das Kästchen ausgewählt ist
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setSAFFarbe( int f );
+        __declspec( dllexport ) void setSAFFarbe( int f );
         // Setzt die Stärke des Farbübergangs, der verwendet wird, während das Kästchen ausgewählt ist
         //  st: Die Stärke
-		__declspec( dllexport ) void setSAFStärke( int st );
+        __declspec( dllexport ) void setSAFStärke( int st );
         // Setzt einen Zeiger auf den Farbübergang, der verwendet wird, während auf das Kästchen geklickt wird
         //  af: Der Farbübergang
-		__declspec( dllexport ) void setKAlphaFeldZ( AlphaFeld *af );
+        __declspec( dllexport ) void setKAlphaFeldZ( AlphaFeld *af );
         // Setzt die Farbe des Farbübergangs, der verwendet wird, während auf das Kästchen geklickt wird
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setKAFFarbe( int f );
+        __declspec( dllexport ) void setKAFFarbe( int f );
         // Setzt die Stärke des Farbübergangs, der verwendet wird, während auf das Kästchen geklickt wird
         //  st: Die Stärke
-		__declspec( dllexport ) void setKAFStärke( int st );
+        __declspec( dllexport ) void setKAFStärke( int st );
         // Lädt die Bilder "kasten.gif" und "skasten.gif" aus einer LTDB Datei
         // Das Bild kasten.gif wird gezeichnet, wenn das Kästchen nicht ausgewählt ist. Das Bild skasten.gif wird gezeichnet, wenn das Kästchen ausgewählt wird
         //  zDat: Die LTDB Datei
-		__declspec( dllexport ) void loadData( LTDBDatei *zDat );
+        __declspec( dllexport ) void loadData( LTDBDatei *zDat );
         // Lädt die Bilder "kasten.gif" und "skasten.gif" aus einer LTDB Datei
         // Das Bild kasten.gif wird gezeichnet, wenn das Kästchen nicht ausgewählt ist. Das Bild skasten.gif wird gezeichnet, wenn das Kästchen ausgewählt wird
         //  ltdb: Der Pfad zur LTDB Datei
-		__declspec( dllexport ) void loadData( const char *ltdb );
+        __declspec( dllexport ) void loadData( const char *ltdb );
         // Verarbeitet Maus Nachrichten
         //  me: Das Ereignis, was durch die Mauseingabe ausgelößt wurde
-		__declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
         // Zeichnet das Objekt nach zRObj, falls es sichtbar ist
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die beschriftung zurück
-		__declspec( dllexport ) Text *getText() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die beschriftung zurück
+        __declspec( dllexport ) Text *getText() const;
         // Gibt die beschriftung ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Text *zText() const;
+        __declspec( dllexport ) Text *zText() const;
         // Gibt die beschriftung zurück, die verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) Text *getSText() const;
+        __declspec( dllexport ) Text *getSText() const;
         // Gibt die beschriftung ohne erhöhten Reference Counter zurück, die verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) Text *zSText() const;
+        __declspec( dllexport ) Text *zSText() const;
         // Gibt die verwendete Schrift zurück
-		__declspec( dllexport ) Schrift *getSchrift() const;
+        __declspec( dllexport ) Schrift *getSchrift() const;
         // Gibt die verwendete Schrift ohne Reference Counter zurück
-		__declspec( dllexport ) Schrift *zSchrift() const;
+        __declspec( dllexport ) Schrift *zSchrift() const;
         // Gibt die Schrift Farbe im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getSFarbe() const;
+        __declspec( dllexport ) int getSFarbe() const;
         // Gibt die Schrift Größe zurück
-		__declspec( dllexport ) int getSGröße() const;
+        __declspec( dllexport ) int getSGröße() const;
         // Gibt die Hintergrund Farbe im A8R8G8B8 Format zurück, die verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) int getSBgFarbe() const;
+        __declspec( dllexport ) int getSBgFarbe() const;
         // Gibt die Hintergrund Farbe im A8R8G8B8 Format zurück, die verwendet wird, während auf das Kästchen geklickt wird
-		__declspec( dllexport ) int getKBgFarbe() const;
+        __declspec( dllexport ) int getKBgFarbe() const;
         // Gibt das Hintergrund Bild zurück, das verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) Bild *getSBgBild() const;
+        __declspec( dllexport ) Bild *getSBgBild() const;
         // Gibt das Hintergrund Bild ohne erhöhten Reference Counter zurück, das verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) Bild *zSBgBild() const;
+        __declspec( dllexport ) Bild *zSBgBild() const;
         // Gibt das Hintergrund Bild zurück, das verwendet wird, während auf das Kästchen geklickt wird
-		__declspec( dllexport ) Bild *getKBgBild() const;
+        __declspec( dllexport ) Bild *getKBgBild() const;
         // Gibt das Hintergrund Bild ohne erhöhten Reference Counter zurück, das verwendet wird, während auf das Kästchen geklickt wird
-		__declspec( dllexport ) Bild *zKBgBild() const;
+        __declspec( dllexport ) Bild *zKBgBild() const;
         // Gibt den Farbübergang zurück, der verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) AlphaFeld *getSAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *getSAlphaFeld() const;
         // Gibt den Farbübergang ohne erhöhten Reference COunter zurück, der verwendet wird, während das Kästchen ausgewählt ist
-		__declspec( dllexport ) AlphaFeld *zSAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *zSAlphaFeld() const;
         // Gibt den Farbübergang zurück, der verwendet wird, während auf das Kästchen geklickt wird
-		__declspec( dllexport ) AlphaFeld *getKAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *getKAlphaFeld() const;
         // Gibt den Farbübergang ohne erhöhten Reference COunter zurück, der verwendet wird, während auf das Kästchen geklickt wird
-		__declspec( dllexport ) AlphaFeld *zKAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *zKAlphaFeld() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) KontrollKnopf *getThis();
+        __declspec( dllexport ) KontrollKnopf *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) KontrollKnopf *release();
-	};
+        __declspec( dllexport ) KontrollKnopf *release();
+    };
 }
 
 #endif

Liste.cpp

@@ -663,7 +663,7 @@ void AuswahlListe::render( Bild &zRObj ) // zeichnet nach zRObj
         for( int i = 0; i < einträge; ++i )
         {
             TextFeld *tf = tfListe->z( i );
-            if( dy + tf->getHöhe() > mdy && !(vertikalScrollBar && hatStyle( Style::VScroll ) ) )
+            if( dy + tf->getHöhe() > mdy && !( vertikalScrollBar && hatStyle( Style::VScroll ) ) )
                 break;
             tf->setPosition( dx, dy );
             tf->setGröße( innenGröße.x, tf->getHöhe() );

M2Datei.cpp

@@ -9,373 +9,373 @@ using namespace Framework;
 // Konstruktor
 M2Datei::M2Datei()
 {
-	pfad = new Text();
-	modelName = new RCArray< Text >();
-	modelPos = new Array< __int64 >();
-	ref = 1;
+    pfad = new Text();
+    modelName = new RCArray< Text >();
+    modelPos = new Array< __int64 >();
+    ref = 1;
 }
 
 M2Datei::M2Datei( const char *pfad )
 {
-	this->pfad = new Text( pfad );
-	modelName = new RCArray< Text >();
-	modelPos = new Array< __int64 >();
-	ref = 1;
+    this->pfad = new Text( pfad );
+    modelName = new RCArray< Text >();
+    modelPos = new Array< __int64 >();
+    ref = 1;
 }
 
 M2Datei::M2Datei( Text *pfad )
 {
-	this->pfad = pfad;
-	modelName = new RCArray< Text >();
-	modelPos = new Array< __int64 >();
-	ref = 1;
+    this->pfad = pfad;
+    modelName = new RCArray< Text >();
+    modelPos = new Array< __int64 >();
+    ref = 1;
 }
 
 // Destruktor
 M2Datei::~M2Datei()
 {
-	pfad->release();
-	modelName->release();
-	modelPos->release();
+    pfad->release();
+    modelName->release();
+    modelPos->release();
 }
 
 // nicht constant
 void M2Datei::setPfad( const char *pfad )
 {
-	this->pfad->setText( pfad );
+    this->pfad->setText( pfad );
 }
 
 void M2Datei::setPfadZ( Text *pfad )
 {
-	if( this->pfad )
-		this->pfad->release();
-	this->pfad = pfad;
+    if( this->pfad )
+        this->pfad->release();
+    this->pfad = pfad;
 }
 
 void M2Datei::leseDaten()
 {
-	Datei d;
-	d.setDatei( pfad->getText() );
-	d.öffnen( Datei::Style::lesen );
-	char anz = 0;
-	d.lese( &anz, 1 );
-	modelName->leeren();
-	modelPos->leeren();
-	for( int i = 0; i < anz; i++ )
-	{
-		char län = 0;
-		d.lese( &län, 1 );
-		char *txt = new char[ län + 1 ];
-		d.lese( txt, län );
-		txt[ (int)län ] = 0;
-		modelName->set( new Text( txt ), i );
-		delete[] txt;
-		__int64 pos = 0;
-		d.lese( (char*)&pos, 8 );
-		modelPos->set( pos, i );
-	}
-	d.schließen();
+    Datei d;
+    d.setDatei( pfad->getText() );
+    d.öffnen( Datei::Style::lesen );
+    char anz = 0;
+    d.lese( &anz, 1 );
+    modelName->leeren();
+    modelPos->leeren();
+    for( int i = 0; i < anz; i++ )
+    {
+        char län = 0;
+        d.lese( &län, 1 );
+        char *txt = new char[ län + 1 ];
+        d.lese( txt, län );
+        txt[ (int)län ] = 0;
+        modelName->set( new Text( txt ), i );
+        delete[] txt;
+        __int64 pos = 0;
+        d.lese( (char*)&pos, 8 );
+        modelPos->set( pos, i );
+    }
+    d.schließen();
 }
 
 bool M2Datei::saveModel( Model2DData *zMdr, Text *name )
 {
-	bool ret = saveModel( zMdr, name->getText() );
-	name->release();
-	return ret;
+    bool ret = saveModel( zMdr, name->getText() );
+    name->release();
+    return ret;
 }
 
 bool M2Datei::saveModel( Model2DData *zMdr, const char *name )
 {
-	int anz = modelName->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( modelName->z( i )->istGleich( name ) )
-		{
-			if( !löscheModel( name ) )
-				return 0;
-			break;
-		}
-	}
-	anz = modelName->getEintragAnzahl();
-	Datei d;
-	d.setDatei( pfad->getText() );
-	d.öffnen( Datei::Style::lesen );
-	Datei neu;
-	neu.setDatei( pfad->getText() );
-	neu.zPfad()->anhängen( "0" );
-	while( neu.existiert() )
-		neu.zPfad()->anhängen( "0" );
-	if( !neu.öffnen( Datei::Style::schreiben ) )
-	{
-		if( d.istOffen() )
-			d.schließen();
-		return 0;
-	}
-	modelName->add( new Text( name ) );
-	int offs = textLänge( name ) + 9;
-	for( int i = 0; i < anz; i++ )
-		modelPos->set( modelPos->get( i ) + offs, i );
-	if( d.getGröße() < 0 )
-		modelPos->add( offs + 1 );
-	else
-		modelPos->add( d.getGröße() + offs );
-	anz++;
-	char tmp = (char)anz;
-	neu.schreibe( &tmp, 1 );
-	for( int i = 0; i < anz; i++ )
-	{
-		char län = (char)modelName->z( i )->getLänge();
-		neu.schreibe( &län, 1 );
-		neu.schreibe( modelName->z( i )->getText(), län );
-		__int64 pos = modelPos->get( i );
-		neu.schreibe( (char*)&pos, 8 );
-	}
-	if( d.existiert() )
-	{
-		d.setLPosition( modelPos->get( 0 ) - offs, 0 );
-		__int64 dl = d.getGröße() - d.getLPosition();
-		char bytes[ 2048 ];
-		while( dl )
-		{
-			int l = dl > 2048 ? 2048 : (int)dl;
-			d.lese( bytes, l );
-			neu.schreibe( bytes, l );
-			dl -= l;
-		}
-	}
-	d.schließen();
-	char pAnz = zMdr->polygons->getEintragAnzahl();
-	neu.schreibe( &pAnz, 1 );
-	for( int p = 0; p < pAnz; p++ )
-	{
-		int vAnz = zMdr->polygons->get( p ).vertex->getEintragAnzahl();
-		char textur = 1;
-		for( int i = 0; i < vAnz; i++ )
-			textur &= (char)zMdr->polygons->get( p ).tKordinaten->hat( i );
-		neu.schreibe( &textur, 1 );
-		neu.schreibe( (char*)&vAnz, 4 );
-		for( int i = 0; i < vAnz; i++ )
-		{
-			float v = zMdr->polygons->get( p ).vertex->get( i ).x;
-			neu.schreibe( (char*)&v, 4 );
-			v = zMdr->polygons->get( p ).vertex->get( i ).y;
-			neu.schreibe( (char*)&v, 4 );
-			if( textur )
-			{
-				int t = zMdr->polygons->get( p ).tKordinaten->get( i ).x;
-				neu.schreibe( (char*)&t, 4 );
-				t = zMdr->polygons->get( p ).tKordinaten->get( i ).y;
-				neu.schreibe( (char*)&t, 4 );
-			}
-		}
-	}
-	d.löschen();
-	neu.schließen();
-	neu.umbenennen( pfad->getText() );
-	leseDaten();
-	return 1;
+    int anz = modelName->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( modelName->z( i )->istGleich( name ) )
+        {
+            if( !löscheModel( name ) )
+                return 0;
+            break;
+        }
+    }
+    anz = modelName->getEintragAnzahl();
+    Datei d;
+    d.setDatei( pfad->getText() );
+    d.öffnen( Datei::Style::lesen );
+    Datei neu;
+    neu.setDatei( pfad->getText() );
+    neu.zPfad()->anhängen( "0" );
+    while( neu.existiert() )
+        neu.zPfad()->anhängen( "0" );
+    if( !neu.öffnen( Datei::Style::schreiben ) )
+    {
+        if( d.istOffen() )
+            d.schließen();
+        return 0;
+    }
+    modelName->add( new Text( name ) );
+    int offs = textLänge( name ) + 9;
+    for( int i = 0; i < anz; i++ )
+        modelPos->set( modelPos->get( i ) + offs, i );
+    if( d.getGröße() < 0 )
+        modelPos->add( offs + 1 );
+    else
+        modelPos->add( d.getGröße() + offs );
+    anz++;
+    char tmp = (char)anz;
+    neu.schreibe( &tmp, 1 );
+    for( int i = 0; i < anz; i++ )
+    {
+        char län = (char)modelName->z( i )->getLänge();
+        neu.schreibe( &län, 1 );
+        neu.schreibe( modelName->z( i )->getText(), län );
+        __int64 pos = modelPos->get( i );
+        neu.schreibe( (char*)&pos, 8 );
+    }
+    if( d.existiert() )
+    {
+        d.setLPosition( modelPos->get( 0 ) - offs, 0 );
+        __int64 dl = d.getGröße() - d.getLPosition();
+        char bytes[ 2048 ];
+        while( dl )
+        {
+            int l = dl > 2048 ? 2048 : (int)dl;
+            d.lese( bytes, l );
+            neu.schreibe( bytes, l );
+            dl -= l;
+        }
+    }
+    d.schließen();
+    char pAnz = zMdr->polygons->getEintragAnzahl();
+    neu.schreibe( &pAnz, 1 );
+    for( int p = 0; p < pAnz; p++ )
+    {
+        int vAnz = zMdr->polygons->get( p ).vertex->getEintragAnzahl();
+        char textur = 1;
+        for( int i = 0; i < vAnz; i++ )
+            textur &= (char)zMdr->polygons->get( p ).tKordinaten->hat( i );
+        neu.schreibe( &textur, 1 );
+        neu.schreibe( (char*)&vAnz, 4 );
+        for( int i = 0; i < vAnz; i++ )
+        {
+            float v = zMdr->polygons->get( p ).vertex->get( i ).x;
+            neu.schreibe( (char*)&v, 4 );
+            v = zMdr->polygons->get( p ).vertex->get( i ).y;
+            neu.schreibe( (char*)&v, 4 );
+            if( textur )
+            {
+                int t = zMdr->polygons->get( p ).tKordinaten->get( i ).x;
+                neu.schreibe( (char*)&t, 4 );
+                t = zMdr->polygons->get( p ).tKordinaten->get( i ).y;
+                neu.schreibe( (char*)&t, 4 );
+            }
+        }
+    }
+    d.löschen();
+    neu.schließen();
+    neu.umbenennen( pfad->getText() );
+    leseDaten();
+    return 1;
 }
 
 bool M2Datei::löscheModel( Text *name )
 {
-	bool ret = löscheModel( name->getText() );
-	name->release();
-	return ret;
+    bool ret = löscheModel( name->getText() );
+    name->release();
+    return ret;
 }
 
 bool M2Datei::löscheModel( const char *name )
 {
-	int anz = modelName->getEintragAnzahl();
-	int p = -1;
-	for( int i = 0; i < anz; i++ )
-	{
-		if( modelName->z( i )->istGleich( name ) )
-		{
-			p = i;
-			break;
-		}
-	}
-	if( p < 0 )
-		return 0;
-	Datei d;
-	d.setDatei( pfad->getText() );
-	if( !d.öffnen( Datei::Style::lesen ) )
-		return 0;
-	Datei neu;
-	neu.setDatei( pfad->getText() );
-	neu.zPfad()->anhängen( "0" );
-	while( neu.existiert() )
-		neu.zPfad()->anhängen( "0" );
-	if( !neu.öffnen( Datei::Style::schreiben ) )
-	{
-		if( d.istOffen() )
-			d.schließen();
-		return 0;
-	}
-	char nAnz = (char)anz - 1;
-	neu.schreibe( &nAnz, 1 );
-	int offs = modelName->z( p )->getLänge() + 9;
-	__int64 startP = 0, endP = 0, start2P = 0;
-	for( int i = 0; i < anz; i++ )
-	{
-		char nLän = (char)modelName->z( i )->getLänge();
-		char *n = modelName->z( i )->getText();
-		__int64 pos = modelPos->get( i );
-		if( !startP )
-			startP = pos;
-		if( i == p + 1 )
-			start2P = pos;
-		if( i == p )
-		{
-			if( !endP )
-				endP = pos;
-			if( i < anz - 1 )
-				offs += (int)( modelPos->get( i + 1 ) - pos );
-		}
-		if( i != p )
-		{
-			pos -= offs;
-			neu.schreibe( &nLän, 1 );
-			neu.schreibe( n, nLän );
-			neu.schreibe( (char*)&pos, 8 );
-		}
-	}
-	if( d.istOffen() )
-	{
-		d.setLPosition( startP, 0 );
-		__int64 bLän = endP - startP;
-		char bytes[ 2048 ];
-		while( bLän > 0 )
-		{
-			int l = 2048 > bLän ? (int)bLän : 2048;
-			d.lese( bytes, l );
-			neu.schreibe( bytes, l );
-			bLän -= l;
-		}
-		if( start2P )
-		{
-			d.setLPosition( start2P, 0 );
-			bLän = d.getGröße() - start2P;
-			while( bLän > 0 )
-			{
-				int l = 2048 > bLän ? (int)bLän : 2048;
-				d.lese( bytes, l );
-				neu.schreibe( bytes, l );
-				bLän -= l;
-			}
-		}
-		d.schließen();
-	}
-	d.löschen();
-	neu.schließen();
-	neu.umbenennen( pfad->getText() );
-	leseDaten();
-	return 1;
+    int anz = modelName->getEintragAnzahl();
+    int p = -1;
+    for( int i = 0; i < anz; i++ )
+    {
+        if( modelName->z( i )->istGleich( name ) )
+        {
+            p = i;
+            break;
+        }
+    }
+    if( p < 0 )
+        return 0;
+    Datei d;
+    d.setDatei( pfad->getText() );
+    if( !d.öffnen( Datei::Style::lesen ) )
+        return 0;
+    Datei neu;
+    neu.setDatei( pfad->getText() );
+    neu.zPfad()->anhängen( "0" );
+    while( neu.existiert() )
+        neu.zPfad()->anhängen( "0" );
+    if( !neu.öffnen( Datei::Style::schreiben ) )
+    {
+        if( d.istOffen() )
+            d.schließen();
+        return 0;
+    }
+    char nAnz = (char)anz - 1;
+    neu.schreibe( &nAnz, 1 );
+    int offs = modelName->z( p )->getLänge() + 9;
+    __int64 startP = 0, endP = 0, start2P = 0;
+    for( int i = 0; i < anz; i++ )
+    {
+        char nLän = (char)modelName->z( i )->getLänge();
+        char *n = modelName->z( i )->getText();
+        __int64 pos = modelPos->get( i );
+        if( !startP )
+            startP = pos;
+        if( i == p + 1 )
+            start2P = pos;
+        if( i == p )
+        {
+            if( !endP )
+                endP = pos;
+            if( i < anz - 1 )
+                offs += (int)( modelPos->get( i + 1 ) - pos );
+        }
+        if( i != p )
+        {
+            pos -= offs;
+            neu.schreibe( &nLän, 1 );
+            neu.schreibe( n, nLän );
+            neu.schreibe( (char*)&pos, 8 );
+        }
+    }
+    if( d.istOffen() )
+    {
+        d.setLPosition( startP, 0 );
+        __int64 bLän = endP - startP;
+        char bytes[ 2048 ];
+        while( bLän > 0 )
+        {
+            int l = 2048 > bLän ? (int)bLän : 2048;
+            d.lese( bytes, l );
+            neu.schreibe( bytes, l );
+            bLän -= l;
+        }
+        if( start2P )
+        {
+            d.setLPosition( start2P, 0 );
+            bLän = d.getGröße() - start2P;
+            while( bLän > 0 )
+            {
+                int l = 2048 > bLän ? (int)bLän : 2048;
+                d.lese( bytes, l );
+                neu.schreibe( bytes, l );
+                bLän -= l;
+            }
+        }
+        d.schließen();
+    }
+    d.löschen();
+    neu.schließen();
+    neu.umbenennen( pfad->getText() );
+    leseDaten();
+    return 1;
 }
 
 // constant
 Model2DData *M2Datei::ladeModel( Text *name ) const
 {
-	Model2DData *ret = ladeModel( name->getText() );
-	name->release();
-	return ret;
+    Model2DData *ret = ladeModel( name->getText() );
+    name->release();
+    return ret;
 }
 
 Model2DData *M2Datei::ladeModel( const char *name ) const
 {
-	Datei d;
-	d.setDatei( pfad->getText() );
-	if( !d.öffnen( Datei::Style::lesen ) )
-		return 0;
-	int anz = modelName->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( modelName->z( i )->istGleich( name ) )
-		{
-			d.setLPosition( modelPos->get( i ), 0 );
-			break;
-		}
-	}
-	if( !d.getLPosition() )
-	{
-		d.schließen();
-		return 0;
-	}
-	char pAnz = 0;
-	d.lese( &pAnz, 1 );
-	Array< Polygon2D > *polygons = new Array< Polygon2D >();
-	for( int p = 0; p < pAnz; p++ )
-	{
-		char textur = 0;
-		d.lese( &textur, 1 );
-		int vAnz = 0;
-		d.lese( (char*)&vAnz, 4 );
-		if( polygons->hat( p ) )
-		{
-			if( polygons->get( p ).vertex )
-				polygons->get( p ).vertex->release();
-			if( polygons->get( p ).tKordinaten )
-				polygons->get( p ).tKordinaten->release();
-		}
-		Polygon2D polygon;
-		polygon.vertex = new Array< Vertex >();
-		if( textur )
-			polygon.tKordinaten = new Array< Punkt >();
-		else
-			polygon.tKordinaten = 0;
-		for( int v = 0; v < vAnz; v++ )
-		{
-			Vertex p;
-			d.lese( (char*)&p.x, 4 );
-			d.lese( (char*)&p.y, 4 );
-			polygon.vertex->add( p );
-			if( textur )
-			{
-				Punkt tp;
-				d.lese( (char*)&tp.x, 4 );
-				d.lese( (char*)&tp.y, 4 );
-				polygon.tKordinaten->add( tp );
-			}
-		}
-		polygons->add( polygon );
-	}
-	d.schließen();
-	Model2DData *ret = new Model2DData();
-	ret->erstelleModell( polygons );
-	return ret;
+    Datei d;
+    d.setDatei( pfad->getText() );
+    if( !d.öffnen( Datei::Style::lesen ) )
+        return 0;
+    int anz = modelName->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( modelName->z( i )->istGleich( name ) )
+        {
+            d.setLPosition( modelPos->get( i ), 0 );
+            break;
+        }
+    }
+    if( !d.getLPosition() )
+    {
+        d.schließen();
+        return 0;
+    }
+    char pAnz = 0;
+    d.lese( &pAnz, 1 );
+    Array< Polygon2D > *polygons = new Array< Polygon2D >();
+    for( int p = 0; p < pAnz; p++ )
+    {
+        char textur = 0;
+        d.lese( &textur, 1 );
+        int vAnz = 0;
+        d.lese( (char*)&vAnz, 4 );
+        if( polygons->hat( p ) )
+        {
+            if( polygons->get( p ).vertex )
+                polygons->get( p ).vertex->release();
+            if( polygons->get( p ).tKordinaten )
+                polygons->get( p ).tKordinaten->release();
+        }
+        Polygon2D polygon;
+        polygon.vertex = new Array< Vertex >();
+        if( textur )
+            polygon.tKordinaten = new Array< Punkt >();
+        else
+            polygon.tKordinaten = 0;
+        for( int v = 0; v < vAnz; v++ )
+        {
+            Vertex p;
+            d.lese( (char*)&p.x, 4 );
+            d.lese( (char*)&p.y, 4 );
+            polygon.vertex->add( p );
+            if( textur )
+            {
+                Punkt tp;
+                d.lese( (char*)&tp.x, 4 );
+                d.lese( (char*)&tp.y, 4 );
+                polygon.tKordinaten->add( tp );
+            }
+        }
+        polygons->add( polygon );
+    }
+    d.schließen();
+    Model2DData *ret = new Model2DData();
+    ret->erstelleModell( polygons );
+    return ret;
 }
 
 bool M2Datei::hatModel( const char *name ) const
 {
-	int anz = modelName->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( modelName->z( i )->istGleich( name ) )
-			return 1;
-	}
-	return 0;
+    int anz = modelName->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( modelName->z( i )->istGleich( name ) )
+            return 1;
+    }
+    return 0;
 }
 
 int M2Datei::getModelAnzahl() const
 {
-	return modelName->getEintragAnzahl();
+    return modelName->getEintragAnzahl();
 }
 
 Text *M2Datei::zModelName( int i ) const
 {
-	return modelName->z( i );
+    return modelName->z( i );
 }
 
 // Reference Counting
 M2Datei *M2Datei::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 M2Datei *M2Datei::release()
 {
-	if( !--ref )
-		delete this;
-	return 0;
+    if( !--ref )
+        delete this;
+    return 0;
 }

M2Datei.h

@@ -5,81 +5,81 @@
 
 namespace Framework
 {
-	class Model2DData; // Model2D.h
-	class Text; // Text.h
+    class Model2DData; // Model2D.h
+    class Text; // Text.h
 
     // Diese Klasse verwaltet das Framework eigenen Dateivormat für 2D Modell Daten
     // Es können mehrere 2D Modell Daten in einer Datei gespeichert werden
-	class M2Datei
-	{
-	private:
-		Text *pfad;
-		RCArray< Text > *modelName;
-		Array< __int64 > *modelPos;
-		int ref;
+    class M2Datei
+    {
+    private:
+        Text *pfad;
+        RCArray< Text > *modelName;
+        Array< __int64 > *modelPos;
+        int ref;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) M2Datei();
+    public:
+        // Konstruktor
+        __declspec( dllexport ) M2Datei();
         // Konstruktor
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) M2Datei( const char *pfad );
+        __declspec( dllexport ) M2Datei( const char *pfad );
         // Konstruktor
         //  pfad: Der Pfad zur Datei
-		__declspec( dllexport ) M2Datei( Text *pfad );
-		// Destruktor
-		__declspec( dllexport ) ~M2Datei();
-		// Setzt den Pfad zur Datei
+        __declspec( dllexport ) M2Datei( Text *pfad );
+        // Destruktor
+        __declspec( dllexport ) ~M2Datei();
+        // Setzt den Pfad zur Datei
         //  pfad: Pfad zur Datei
-		__declspec( dllexport ) void setPfad( const char *pfad );
+        __declspec( dllexport ) void setPfad( const char *pfad );
         // Setzt einen Zeiger auf den Pfad zur Datei
         //  pfad: Zeiger auf den Pfad zur Datei
-		__declspec( dllexport ) void setPfadZ( Text *pfad );
+        __declspec( dllexport ) void setPfadZ( Text *pfad );
         // Ließt grundlegende Informationen aus der Datei, die für ihre Verwendung benötigt werden
-		__declspec( dllexport ) void leseDaten();
+        __declspec( dllexport ) void leseDaten();
         // Speichert 2D Modell Daten in der Datei
         //  zMdr: Ein Zeiger auf die zu speichernden Daten ohne erhöhtem Reference Counter
         //  name: Der Name, unter dem die Daten in der Datei gespeichert werden sollen
         //  return: 1, falls das Modell gespeichert wurde. 0, falls ein fehler beim speichern auftrat
-		__declspec( dllexport ) bool saveModel( Model2DData *zMdr, Text *name );
+        __declspec( dllexport ) bool saveModel( Model2DData *zMdr, Text *name );
         // Speichert 2D Modell Daten in der Datei
         //  zMdr: Ein Zeiger auf die zu speichernden Daten ohne erhöhtem Reference Counter
         //  name: Der Name, unter dem die Daten in der Datei gespeichert werden sollen
         //  return: 1, falls das Modell gespeichert wurde. 0, falls ein fehler beim speichern auftrat
-		__declspec( dllexport ) bool saveModel( Model2DData *zMdr, const char *name );
+        __declspec( dllexport ) bool saveModel( Model2DData *zMdr, const char *name );
         // Löscht ein 2D Modell aus der Datei
         //  name: Der Name des Modells
         //  return: 1, wenn das Modell gelöscht wurde. 0, wenn das Modell nicht gefunden wurde, oder ein fehler beim speichern auftrat
-		__declspec( dllexport ) bool löscheModel( Text *name );
+        __declspec( dllexport ) bool löscheModel( Text *name );
         // Löscht ein 2D Modell aus der Datei
         //  name: Der Name des Modells
         //  return: 1, wenn das Modell gelöscht wurde. 0, wenn das Modell nicht gefunden wurde, oder ein fehler beim speichern auftrat
-		__declspec( dllexport ) bool löscheModel( const char *name );
-		// Lähd ein 2D Modell aus der Datei
+        __declspec( dllexport ) bool löscheModel( const char *name );
+        // Lähd ein 2D Modell aus der Datei
         //  name: Der name des zu ladenden Modells
         //  return: Die geladenen Daten
-		__declspec( dllexport ) Model2DData *ladeModel( Text *name ) const;
+        __declspec( dllexport ) Model2DData *ladeModel( Text *name ) const;
         // Lähd ein 2D Modell aus der Datei
         //  name: Der name des zu ladenden Modells
         //  return: Die geladenen Daten
-		__declspec( dllexport ) Model2DData *ladeModel( const char *name ) const;
+        __declspec( dllexport ) Model2DData *ladeModel( const char *name ) const;
         // überprft, ob ein bestimmtes 2D Modell in der Datei existiert
         //  name: Der Name des zu suchenden 2D Modells
         //  return: 1, wenn das Modell gefunden wurde. 0 sonst
-		__declspec( dllexport ) bool hatModel( const char *name ) const;
+        __declspec( dllexport ) bool hatModel( const char *name ) const;
         // ügibt die Anzahl der gespeicherten Modelle zurück
-		__declspec( dllexport ) int getModelAnzahl() const;
+        __declspec( dllexport ) int getModelAnzahl() const;
         // Gibt den Namen eines Bestimmten Modells zurück
         //  i: Der Index des Modells
         //  return: Ein Zeiger aud den Namen des Modells ohne erhöhten Reference Counter
-		__declspec( dllexport ) Text *zModelName( int i ) const;
+        __declspec( dllexport ) Text *zModelName( int i ) const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) M2Datei *getThis();
+        __declspec( dllexport ) M2Datei *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) M2Datei *release();
-	};
+        __declspec( dllexport ) M2Datei *release();
+    };
 }
 
 #endif

Mat3.h

@@ -5,96 +5,96 @@
 
 namespace Framework
 {
-	template< typename T >
+    template< typename T >
     // Eine 3x3 Matrix
-	class Mat3
-	{
-	public:
-		T elements[ 3 ][ 3 ]; // Die Elemente der Matrix
-		// Kopiert die Elemente einer anderen Matrix in diese
+    class Mat3
+    {
+    public:
+        T elements[ 3 ][ 3 ]; // Die Elemente der Matrix
+        // Kopiert die Elemente einer anderen Matrix in diese
         //  r: Die andere Matrix
-		Mat3 &operator=( const Mat3 &r )
-		{
-			memcpy( elements, r.elements, sizeof( elements ) );
-			return *this;
-		}
+        Mat3 &operator=( const Mat3 &r )
+        {
+            memcpy( elements, r.elements, sizeof( elements ) );
+            return *this;
+        }
         // Multipliziert alle Werte mit einem Skalar und speichert das Ergebnis in dieser
         //  r: Der Skalar
-		Mat3 &operator*=( const T r )
-		{
-			for( T &e : elements )
-				e *= r;
-			return *this;
-		}
+        Mat3 &operator*=( const T r )
+        {
+            for( T &e : elements )
+                e *= r;
+            return *this;
+        }
         // Multipliziert die Matrix mit einer anderen und speichert das Ergebnis in dieser
         //  r: Die andere Matrix
-		Mat3 &operator*=( const Mat3 &r )
-		{
-			return *this = *this * r;
-		}
+        Mat3 &operator*=( const Mat3 &r )
+        {
+            return *this = *this * r;
+        }
         // Multipliziert alle Werte mit einem Skalar ohne diese zu verändern
         //  r: Der Skalar
-		Mat3 operator*( const T r ) const
-		{
-			Mat3 result = *this;
-			return result *= r;
-		}
+        Mat3 operator*( const T r ) const
+        {
+            Mat3 result = *this;
+            return result *= r;
+        }
         // Multipliziert die Matrix mit einer anderen ohne diese zu verändern
         //  r: Die andere Matrix
-		Mat3 operator*( const Mat3 &r ) const
-		{
-			Mat3 result;
-			for( int j = 0; j < 3; j++ )
-			{
-				for( int k = 0; k < 3; k++ )
-				{
-					T sum = 0;
-					for( int i = 0; i < 3; i++ )
-						sum += elements[ j ][ i ] * r.elements[ i ][ k ];
-					result.elements[ j ][ k ] = sum;
-				}
-			}
-			return result;
-		}
+        Mat3 operator*( const Mat3 &r ) const
+        {
+            Mat3 result;
+            for( int j = 0; j < 3; j++ )
+            {
+                for( int k = 0; k < 3; k++ )
+                {
+                    T sum = 0;
+                    for( int i = 0; i < 3; i++ )
+                        sum += elements[ j ][ i ] * r.elements[ i ][ k ];
+                    result.elements[ j ][ k ] = sum;
+                }
+            }
+            return result;
+        }
         // Multipliziert die Matrix mit einem Vektor ohne diese zu verändern
         //  r: Der Vektor
-		Vec2< T > operator*( const Vec2< T > r ) const
-		{
-			Vec2< T > result;
-			result.x = elements[ 0 ][ 0 ] * r.x + elements[ 0 ][ 1 ] * r.y + elements[ 0 ][ 2 ];
-			result.y = elements[ 1 ][ 0 ] * r.x + elements[ 1 ][ 1 ] * r.y + elements[ 1 ][ 2 ];
-			return  result;
-		}
+        Vec2< T > operator*( const Vec2< T > r ) const
+        {
+            Vec2< T > result;
+            result.x = elements[ 0 ][ 0 ] * r.x + elements[ 0 ][ 1 ] * r.y + elements[ 0 ][ 2 ];
+            result.y = elements[ 1 ][ 0 ] * r.x + elements[ 1 ][ 1 ] * r.y + elements[ 1 ][ 2 ];
+            return  result;
+        }
         // Erzeugt eine Matrix, die verwendet wird, um einen Vektor zu drehen, wenn sie mit ihm multipliziert wird
         //  radian: Der Winkel im Bogenmas, um dem der Vektor gedreht werden soll
-		static Mat3 rotation( T radian )
-		{
-			const T cosTheta = (T)cos( radian );
-			const T sinTheta = (T)sin( radian );
-			Mat3 r = { cosTheta, -sinTheta, 0, sinTheta, cosTheta, 0, 0, 0, 1 };
-			return r;
-		}
+        static Mat3 rotation( T radian )
+        {
+            const T cosTheta = (T)cos( radian );
+            const T sinTheta = (T)sin( radian );
+            Mat3 r = { cosTheta, -sinTheta, 0, sinTheta, cosTheta, 0, 0, 0, 1 };
+            return r;
+        }
         // Erzeugt eine Matrix, die einen Vektor skalliert. wenn sie mit ihm multipliziert wird
         //  faktor: Der Faktor, um den Skalliert werden soll
-		static Mat3 scaling( T faktor )
-		{
-			Mat3 s = { faktor, 0, 0, 0, faktor, 0, 0, 0, 1 };
-			return s;
-		}
+        static Mat3 scaling( T faktor )
+        {
+            Mat3 s = { faktor, 0, 0, 0, faktor, 0, 0, 0, 1 };
+            return s;
+        }
         // Erzeugt eine Matrix, die einen Vektor verschiebt, wenn sie mit ihm multipliziert wird
         //  offset: Die x und y Werte, die zu dem Vektor dazu addiert werden sollen
-		static Mat3 translation( const Vec2< T > offset )
-		{
-			Mat3 t = { 1, 0, offset.x, 0, 1, offset.y, 0, 0, 1 };
-			return t;
-		}
+        static Mat3 translation( const Vec2< T > offset )
+        {
+            Mat3 t = { 1, 0, offset.x, 0, 1, offset.y, 0, 0, 1 };
+            return t;
+        }
         // Erzeugt eine MAtrix, die mit allem multiplizert werden kann, ohne es zu verändern
-		static Mat3 identity()
-		{
-			Mat3 i = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
-			return i;
-		}
-	};
+        static Mat3 identity()
+        {
+            Mat3 i = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
+            return i;
+        }
+    };
 }
 
 #endif

Mat4.h

@@ -123,7 +123,7 @@ namespace Framework
         static Mat4 projektion( float öffnungswinkel, float bildschirmXY, float minZ, float maxZ )
         {
             Mat4 p = { (float)( 1 / tan( öffnungswinkel / 2 ) ) / bildschirmXY, 0, 0, 0,
-                0, (float)( 1 / tan( öffnungswinkel / 2 ) ), 0, 0, 
+                0, (float)( 1 / tan( öffnungswinkel / 2 ) ), 0, 0,
                 0, 0, maxZ / ( maxZ - minZ ), -( minZ * maxZ ) / ( maxZ - minZ ),
                 0, 0, 1, 0 };
             return p;

Maus.cpp

@@ -7,113 +7,112 @@ using namespace Framework;
 // Inhalt der Maus Klasse aus Maus.h
 // Konstruktor 
 Maus::Maus()
-	: hMaus( LoadCursor( 0, IDC_ARROW ) ),
-	  ref( 1 )
-{
-}
+    : hMaus( LoadCursor( 0, IDC_ARROW ) ),
+    ref( 1 )
+{}
 
 // nicht constant
 void Maus::ladeMaus( int mausId )
 {
-	if( mausId == MausId::nichts )
-		hMaus = 0;
-	if( mausId == MausId::normal )
-		hMaus = LoadCursor( 0, IDC_ARROW );
-	if( mausId == MausId::hand )
-		hMaus = LoadCursor( 0, IDC_HAND );
-	if( mausId == MausId::warten )
-		hMaus = LoadCursor( 0, IDC_APPSTARTING );
-	if( mausId == MausId::verschieben )
-		hMaus = LoadCursor( 0, IDC_SIZEALL );
-	if( mausId == MausId::text )
-		hMaus = LoadCursor( 0, IDC_IBEAM );
-	if( mausId == MausId::wahgerecht )
-		hMaus = LoadCursor( 0, IDC_SIZEWE );
-	if( mausId == MausId::senkrecht )
-		hMaus = LoadCursor( 0, IDC_SIZENS );
-	if( mausId == MausId::diagonal1 )
-		hMaus = LoadCursor( 0, IDC_SIZENWSE );
-	if( mausId == MausId::diagonal2 )
-		hMaus = LoadCursor( 0, IDC_SIZENESW );
-	if( mausId == MausId::verboten )
-		hMaus = LoadCursor( 0, IDC_NO );
-	SetCursor( hMaus );
+    if( mausId == MausId::nichts )
+        hMaus = 0;
+    if( mausId == MausId::normal )
+        hMaus = LoadCursor( 0, IDC_ARROW );
+    if( mausId == MausId::hand )
+        hMaus = LoadCursor( 0, IDC_HAND );
+    if( mausId == MausId::warten )
+        hMaus = LoadCursor( 0, IDC_APPSTARTING );
+    if( mausId == MausId::verschieben )
+        hMaus = LoadCursor( 0, IDC_SIZEALL );
+    if( mausId == MausId::text )
+        hMaus = LoadCursor( 0, IDC_IBEAM );
+    if( mausId == MausId::wahgerecht )
+        hMaus = LoadCursor( 0, IDC_SIZEWE );
+    if( mausId == MausId::senkrecht )
+        hMaus = LoadCursor( 0, IDC_SIZENS );
+    if( mausId == MausId::diagonal1 )
+        hMaus = LoadCursor( 0, IDC_SIZENWSE );
+    if( mausId == MausId::diagonal2 )
+        hMaus = LoadCursor( 0, IDC_SIZENESW );
+    if( mausId == MausId::verboten )
+        hMaus = LoadCursor( 0, IDC_NO );
+    SetCursor( hMaus );
 }
 
 void Maus::ladeMaus( Bild *maus )
 {
-	HBITMAP hAndMaskBitmap;
-	HBITMAP hXorMaskBitmap;
-	HDC hDC = GetDC( 0 );
-	HDC hAndMaskDC = CreateCompatibleDC( hDC );
-	HDC hXorMaskDC = CreateCompatibleDC( hDC );
+    HBITMAP hAndMaskBitmap;
+    HBITMAP hXorMaskBitmap;
+    HDC hDC = GetDC( 0 );
+    HDC hAndMaskDC = CreateCompatibleDC( hDC );
+    HDC hXorMaskDC = CreateCompatibleDC( hDC );
 
-	hAndMaskBitmap = CreateCompatibleBitmap( hDC, maus->getBreite(), maus->getHöhe() );
-	hXorMaskBitmap = CreateCompatibleBitmap( hDC, maus->getBreite(), maus->getHöhe() );
+    hAndMaskBitmap = CreateCompatibleBitmap( hDC, maus->getBreite(), maus->getHöhe() );
+    hXorMaskBitmap = CreateCompatibleBitmap( hDC, maus->getBreite(), maus->getHöhe() );
 
-	//Select the bitmaps to DC
-	HBITMAP hOldAndMaskBitmap = (HBITMAP)SelectObject( hAndMaskDC, hAndMaskBitmap );
-	HBITMAP hOldXorMaskBitmap = (HBITMAP)SelectObject( hXorMaskDC, hXorMaskBitmap );
+    //Select the bitmaps to DC
+    HBITMAP hOldAndMaskBitmap = (HBITMAP)SelectObject( hAndMaskDC, hAndMaskBitmap );
+    HBITMAP hOldXorMaskBitmap = (HBITMAP)SelectObject( hXorMaskDC, hXorMaskBitmap );
 
-	//Scan each pixel of the souce bitmap and create the masks
-	int y;
-	for( int x = 0; x < maus->getBreite(); ++x )
-	{
-		for( y = 0; y < maus->getHöhe(); ++y )
-		{
-			int pixel = maus->getPixel( x, y );
-			if( ( ( pixel >> 24 ) & 0xFF ) == 0 )
-			{
-				SetPixel( hAndMaskDC, x, y, RGB( 255, 255, 255 ) );
-				SetPixel( hXorMaskDC, x, y, RGB( 0, 0, 0 ) );
-			}
-			else
-			{
-				SetPixel( hAndMaskDC, x, y, RGB( 0, 0, 0 ) );
-				SetPixel( hXorMaskDC, x, y, RGB( ( pixel >> 16 ) & 0xFF, ( pixel >> 8 ) & 0xFF, pixel & 0xFF ) );
-			}
-		}
-	}
-	SelectObject( hAndMaskDC, hOldAndMaskBitmap );
-	SelectObject( hXorMaskDC, hOldXorMaskBitmap );
+    //Scan each pixel of the souce bitmap and create the masks
+    int y;
+    for( int x = 0; x < maus->getBreite(); ++x )
+    {
+        for( y = 0; y < maus->getHöhe(); ++y )
+        {
+            int pixel = maus->getPixel( x, y );
+            if( ( ( pixel >> 24 ) & 0xFF ) == 0 )
+            {
+                SetPixel( hAndMaskDC, x, y, RGB( 255, 255, 255 ) );
+                SetPixel( hXorMaskDC, x, y, RGB( 0, 0, 0 ) );
+            }
+            else
+            {
+                SetPixel( hAndMaskDC, x, y, RGB( 0, 0, 0 ) );
+                SetPixel( hXorMaskDC, x, y, RGB( ( pixel >> 16 ) & 0xFF, ( pixel >> 8 ) & 0xFF, pixel & 0xFF ) );
+            }
+        }
+    }
+    SelectObject( hAndMaskDC, hOldAndMaskBitmap );
+    SelectObject( hXorMaskDC, hOldXorMaskBitmap );
 
-	DeleteDC( hXorMaskDC );
-	DeleteDC( hAndMaskDC );
-	ReleaseDC( 0, hDC );
+    DeleteDC( hXorMaskDC );
+    DeleteDC( hAndMaskDC );
+    ReleaseDC( 0, hDC );
 
-	ICONINFO iconinfo = { 0 };
-	iconinfo.fIcon = 0;
-	iconinfo.xHotspot = 0;
-	iconinfo.yHotspot = 0;
-	iconinfo.hbmMask = hAndMaskBitmap;
-	iconinfo.hbmColor = hXorMaskBitmap;
-	hMaus = CreateIconIndirect( &iconinfo );
+    ICONINFO iconinfo = { 0 };
+    iconinfo.fIcon = 0;
+    iconinfo.xHotspot = 0;
+    iconinfo.yHotspot = 0;
+    iconinfo.hbmMask = hAndMaskBitmap;
+    iconinfo.hbmColor = hXorMaskBitmap;
+    hMaus = CreateIconIndirect( &iconinfo );
 
-	SetCursor( hMaus );
+    SetCursor( hMaus );
 }
 
 void Maus::update()
 {
-	SetCursor( hMaus );
+    SetCursor( hMaus );
 }
 
 // constant
 HCURSOR Maus::getMausHandle()
 {
-	return hMaus;
+    return hMaus;
 }
 
 // Reference Counting
 Maus *Maus::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Maus *Maus::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Maus.h

@@ -5,54 +5,54 @@
 
 namespace Framework
 {
-	class Bild; // aus Bild.h
-	class Maus; // aus dieser Datei
+    class Bild; // aus Bild.h
+    class Maus; // aus dieser Datei
 
-	namespace MausId
-	{
-		const int nichts = 0;
-		const int normal = 1;
-		const int hand = 2;
-		const int warten = 3;
-		const int verschieben = 4;
-		const int text = 5;
-		const int wahgerecht = 6;
-		const int senkrecht = 7;
-		const int diagonal1 = 8;
-		const int diagonal2 = 9;
-		const int verboten = 10;
-	}
+    namespace MausId
+    {
+        const int nichts = 0;
+        const int normal = 1;
+        const int hand = 2;
+        const int warten = 3;
+        const int verschieben = 4;
+        const int text = 5;
+        const int wahgerecht = 6;
+        const int senkrecht = 7;
+        const int diagonal1 = 8;
+        const int diagonal2 = 9;
+        const int verboten = 10;
+    }
 
     // Diese Klasse verwaltet das Bild des Mauszeigers
     // Sie wird vom Framework intern verwendet
     // Siehe Globals.h MausZeiger
-	class Maus
-	{
-	private:
-		HCURSOR hMaus;
-		int ref;
+    class Maus
+    {
+    private:
+        HCURSOR hMaus;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Maus();
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Maus();
         // läd eine maus von Windows
         //  mausId: Werte aus dem Namespace MausId
         // beispiel: ladeMaus( MausId::hand );
-		__declspec( dllexport ) void ladeMaus( int mausId );
+        __declspec( dllexport ) void ladeMaus( int mausId );
         // Kopiert ein Bild und verwendet es als Mauszeiger.
         //  maus: Das Bild, was als Mauszeiger verwendet werden soll
-		__declspec( dllexport ) void ladeMaus( Bild *maus );
+        __declspec( dllexport ) void ladeMaus( Bild *maus );
         // Akzualisiert die Maus. Wird vom Framework selbst aufgerufen
-		__declspec( dllexport ) void update();
+        __declspec( dllexport ) void update();
         // gibt ein Händle zur maus zurück
-		__declspec( dllexport ) HCURSOR getMausHandle();
+        __declspec( dllexport ) HCURSOR getMausHandle();
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Maus *getThis();
+        __declspec( dllexport ) Maus *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Maus *release();
-	};
+        __declspec( dllexport ) Maus *release();
+    };
 }
 
 #endif

MausEreignis.cpp

@@ -4,5 +4,5 @@ using namespace Framework;
 
 bool Framework::_ret1ME( void *param, void *obj, MausEreignis me )
 {
-	return 1;
+    return 1;
 }

MausEreignis.h

@@ -5,42 +5,42 @@
 
 namespace Framework
 {
-	const int M_Links = 0;
-	const int M_Mitte = 1;
-	const int M_Rechts = 2;
-	const int ME_PLinks = 0;
-	const int ME_PRechts = 1;
-	const int ME_PMitte = 2;
-	const int ME_RLinks = 3;
-	const int ME_RRechts = 4;
-	const int ME_RMitte = 5;
-	const int ME_DKLinks = 6;
-	const int ME_DKRechts = 7;
-	const int ME_DKMitte = 8;
-	const int ME_Betritt = 9;
-	const int ME_Verlässt = 10;
-	const int ME_Bewegung = 11;
-	const int ME_UScroll = 12;
-	const int ME_DScroll = 13;
-	const int ME_RScroll = 14;
-	const int ME_LScroll = 15;
+    const int M_Links = 0;
+    const int M_Mitte = 1;
+    const int M_Rechts = 2;
+    const int ME_PLinks = 0;
+    const int ME_PRechts = 1;
+    const int ME_PMitte = 2;
+    const int ME_RLinks = 3;
+    const int ME_RRechts = 4;
+    const int ME_RMitte = 5;
+    const int ME_DKLinks = 6;
+    const int ME_DKRechts = 7;
+    const int ME_DKMitte = 8;
+    const int ME_Betritt = 9;
+    const int ME_Verlässt = 10;
+    const int ME_Bewegung = 11;
+    const int ME_UScroll = 12;
+    const int ME_DScroll = 13;
+    const int ME_RScroll = 14;
+    const int ME_LScroll = 15;
 
     // Speichert eine bestimmte Mauseingabe des Nutzers
-	struct MausEreignis
-	{
+    struct MausEreignis
+    {
         // Art der Eingabe
-		int id;
+        int id;
         // X koordinate auf dem Bildschirm relativ zur Zeichnungposition
-		int mx;
+        int mx;
         // Y Koordinate auf dem Bildschirm relativ zur Zeichnungposition
-		int my;
+        int my;
         // X Koordinate auf dem Bildschirm zur linken oberen Ecke
-		int rmx;
+        int rmx;
         // Y Koordinate auf dem Bildschirm zur linken oberen Ecke
-		int rmy;
+        int rmy;
         // Speichert, ob die Eingabe bereits verarbeitet wurde
-		bool verarbeitet;
-	};
+        bool verarbeitet;
+    };
 
     // Standart Maus Ereinis Rückruffunktion
     //  param: Ein beliebiger Parameter
@@ -48,7 +48,7 @@ namespace Framework
     //  te: Das Mausereignis, welches verarbeitet werden soll
     //  return: (true), wenn aufrufende Zeichnung das Ereignis weiterverarbeiten soll. (false) sonnst.
     // Gibt immer (true) zurück
-	__declspec( dllexport ) bool _ret1ME( void *param, void *obj, MausEreignis me );
+    __declspec( dllexport ) bool _ret1ME( void *param, void *obj, MausEreignis me );
 }
 
 #endif

Model2D.cpp

@@ -11,396 +11,396 @@ using namespace Framework;
 // Inhalt der Model2DData Klasse aus Model2D.h
 // Konstruktor
 Model2DData::Model2DData()
-	: polygons( 0 ),
-	  vListen( 0 ),
-	  minP( 0, 0 ),
-	  maxP( 0, 0 )
+    : polygons( 0 ),
+    vListen( 0 ),
+    minP( 0, 0 ),
+    maxP( 0, 0 )
 {
-	ref = 1;
+    ref = 1;
 }
 
 // Destruktor
 Model2DData::~Model2DData()
 {
-	if( polygons )
-	{
-		int anz = polygons->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
+    if( polygons )
+    {
+        int anz = polygons->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
 #ifdef WIN32
-			if( polygons->get( i ).tKordinaten )
-				polygons->get( i ).tKordinaten->release();
+            if( polygons->get( i ).tKordinaten )
+                polygons->get( i ).tKordinaten->release();
 #endif
-			if( polygons->get( i ).vertex )
-				polygons->get( i ).vertex->release();
-		}
-		polygons = polygons->release();
-	}
-	if( vListen )
-		vListen->release();
+            if( polygons->get( i ).vertex )
+                polygons->get( i ).vertex->release();
+        }
+        polygons = polygons->release();
+    }
+    if( vListen )
+        vListen->release();
 }
 
 // privat
 bool Model2DData::istPunktInnen( Vertex p, int polygonId ) const
 {
-	if( p < minP || p > maxP || !polygons )
-		return 0;
-	int num = 0;
-	for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
-	{
-		if( polygonId >= 0 && num != polygonId )
-			continue;
-		int anz = polygon->var.vertex->getEintragAnzahl();
-		int ola = outList.z( num )->getEintragAnzahl();
-		bool c = 0;
-		int j = anz - 1;
-		for( int k = 0; k < ola; k++ )
-		{
-			Punkt out = outList.z( num )->get( k );
-			if( out.x < out.y && j > out.x && j < out.y )
-				j = out.x;
-			if( out.x > out.y && ( j > out.x || j < out.y ) )
-				j = out.x;
-		}
-		for( int i = 0; i < anz; i++ )
-		{
-			bool cont = 0;
-			for( int k = 0; k < ola; k++ )
-			{
-				Punkt out = outList.z( num )->get( k );
-				if( out.x < out.y && i > out.x && i < out.y )
-					cont = 1;
-				if( out.x > out.y && ( i > out.x || i < out.y ) )
-					cont = 1;
-			}
-			if( cont )
-				continue;
-			Vertex a = polygon->var.vertex->get( i );
-			Vertex b = polygon->var.vertex->get( j );
-			if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
-				c = !c;
-			j = i;
-		}
-		if( c )
-			return 1;
-	}
-	return 0;
+    if( p < minP || p > maxP || !polygons )
+        return 0;
+    int num = 0;
+    for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    {
+        if( polygonId >= 0 && num != polygonId )
+            continue;
+        int anz = polygon->var.vertex->getEintragAnzahl();
+        int ola = outList.z( num )->getEintragAnzahl();
+        bool c = 0;
+        int j = anz - 1;
+        for( int k = 0; k < ola; k++ )
+        {
+            Punkt out = outList.z( num )->get( k );
+            if( out.x < out.y && j > out.x && j < out.y )
+                j = out.x;
+            if( out.x > out.y && ( j > out.x || j < out.y ) )
+                j = out.x;
+        }
+        for( int i = 0; i < anz; i++ )
+        {
+            bool cont = 0;
+            for( int k = 0; k < ola; k++ )
+            {
+                Punkt out = outList.z( num )->get( k );
+                if( out.x < out.y && i > out.x && i < out.y )
+                    cont = 1;
+                if( out.x > out.y && ( i > out.x || i < out.y ) )
+                    cont = 1;
+            }
+            if( cont )
+                continue;
+            Vertex a = polygon->var.vertex->get( i );
+            Vertex b = polygon->var.vertex->get( j );
+            if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
+                c = !c;
+            j = i;
+        }
+        if( c )
+            return 1;
+    }
+    return 0;
 }
 
 bool Model2DData::istLinieInnen( Vertex a, Vertex b, int polygonId ) const
 {
-	if( !polygons )
-		return 0;
-	int pAnz = polygons->getEintragAnzahl();
-	for( int p = 0; p < pAnz; p++ )
-	{
-		if( polygonId >= 0 && p != polygonId )
-			continue;
-		int ola = outList.z( p )->getEintragAnzahl();
-		int anz = polygons->get( p ).vertex->getEintragAnzahl();
-		int j = anz - 1;
-		for( int k = 0; k < ola; k++ )
-		{
-			Punkt out = outList.z( p )->get( k );
-			if( out.x < out.y && j > out.x && j < out.y )
-				j = out.x;
-			if( out.x > out.y && ( j > out.x || j < out.y ) )
-				j = out.x;
-		}
-		for( int i = 0; i < anz; i++ )
-		{
-			bool cont = 0;
-			for( int k = 0; k < ola; k++ )
-			{
-				Punkt out = outList.z( p )->get( k );
-				if( out.x < out.y && i > out.x && i < out.y )
-					cont = 1;
-				if( out.x > out.y && ( i > out.x || i < out.y ) )
-					cont = 1;
-			}
-			if( cont )
-				continue;
-			Punkt va = polygons->get( p ).vertex->get( i );
-			Punkt vb = polygons->get( p ).vertex->get( j );
-			if( (Punkt)a == va && (Punkt)b == vb )
-				return 1;
-			if( (Punkt)a == vb && (Punkt)b == va )
-				return 1;
-			j = i;
-		}
-		Vertex län = b - a;
-		Vertex speed( län.x > 0 ? 1 : -1.f, län.y > 0 ? 1 : -1.f );
-		int mLän = 0;
-		if( fabs( län.x ) > fabs( län.y ) )
-		{
-			mLän = (int)fabs( län.x );
-			speed.y = län.y / (float)fabs( län.x );
-		}
-		else
-		{
-			mLän = (int)fabs( län.y );
-			speed.x = län.x / (float)fabs( län.y );
-		}
-		int i = 1;
-		bool inside = 1;
-		for( Vertex vp = speed + a; (Punkt)vp != (Punkt)( b - speed ) && inside && i < mLän - 1; vp += speed, i++ )
-			inside &= istPunktInnen( vp, p );
-		if( inside )
-			return 1;
-	}
-	return 0;
+    if( !polygons )
+        return 0;
+    int pAnz = polygons->getEintragAnzahl();
+    for( int p = 0; p < pAnz; p++ )
+    {
+        if( polygonId >= 0 && p != polygonId )
+            continue;
+        int ola = outList.z( p )->getEintragAnzahl();
+        int anz = polygons->get( p ).vertex->getEintragAnzahl();
+        int j = anz - 1;
+        for( int k = 0; k < ola; k++ )
+        {
+            Punkt out = outList.z( p )->get( k );
+            if( out.x < out.y && j > out.x && j < out.y )
+                j = out.x;
+            if( out.x > out.y && ( j > out.x || j < out.y ) )
+                j = out.x;
+        }
+        for( int i = 0; i < anz; i++ )
+        {
+            bool cont = 0;
+            for( int k = 0; k < ola; k++ )
+            {
+                Punkt out = outList.z( p )->get( k );
+                if( out.x < out.y && i > out.x && i < out.y )
+                    cont = 1;
+                if( out.x > out.y && ( i > out.x || i < out.y ) )
+                    cont = 1;
+            }
+            if( cont )
+                continue;
+            Punkt va = polygons->get( p ).vertex->get( i );
+            Punkt vb = polygons->get( p ).vertex->get( j );
+            if( (Punkt)a == va && (Punkt)b == vb )
+                return 1;
+            if( (Punkt)a == vb && (Punkt)b == va )
+                return 1;
+            j = i;
+        }
+        Vertex län = b - a;
+        Vertex speed( län.x > 0 ? 1 : -1.f, län.y > 0 ? 1 : -1.f );
+        int mLän = 0;
+        if( fabs( län.x ) > fabs( län.y ) )
+        {
+            mLän = (int)fabs( län.x );
+            speed.y = län.y / (float)fabs( län.x );
+        }
+        else
+        {
+            mLän = (int)fabs( län.y );
+            speed.x = län.x / (float)fabs( län.y );
+        }
+        int i = 1;
+        bool inside = 1;
+        for( Vertex vp = speed + a; (Punkt)vp != (Punkt)( b - speed ) && inside && i < mLän - 1; vp += speed, i++ )
+            inside &= istPunktInnen( vp, p );
+        if( inside )
+            return 1;
+    }
+    return 0;
 }
 
 // nicht constant
 bool Model2DData::erstelleModell( Array< Polygon2D > *polygons )
 {
-	löscheModell();
+    löscheModell();
     if( !polygons || !polygons->getEintragAnzahl() )
     {
         this->polygons = polygons;
         vListen = new RCArray< RCArray< DreieckListe< Vertex > > >();
         return 1;
     }
-	this->polygons = polygons;
-	int pAnz = polygons->getEintragAnzahl();
-	vListen = new RCArray< RCArray< DreieckListe< Vertex > > >();
-	for( int p = 0; p < pAnz; p++ )
-	{
-		Polygon2D pg = polygons->get( p );
-		if( !pg.vertex || pg.vertex->getEintragAnzahl() < 3 )
-			continue;
-		vListen->add( new RCArray< DreieckListe< Vertex > >() );
-		outList.set( new Array< Punkt >, p );
-		int vAnz = pg.vertex->getEintragAnzahl();
-		bool textur = pg.tKordinaten != 0;
-		for( int i = 0; i < vAnz && textur; i++ )
-			textur &= pg.tKordinaten->hat( i );
-		for( int i = 0; i < vAnz; i++ )
-		{
-			if( maxP.x < fabs( pg.vertex->get( i ).x ) )
-				maxP.x = abs( (int)pg.vertex->get( i ).x ) + 1;
-			if( maxP.y < fabs( pg.vertex->get( i ).y ) )
-				maxP.y = abs( (int)pg.vertex->get( i ).y ) + 1;
-		}
-		minP = -maxP;
-		if( !textur )
-		{
-			if( pg.tKordinaten )
-				pg.tKordinaten->leeren();
-		}
-		RCArray< RCArray< DreieckListe< Vertex > > > lists;
-		int lauf = 0;
-		while( 1 )
-		{
-			lists.set( new RCArray< DreieckListe< Vertex > >(), lauf );
-			outList.z( p )->set( Punkt( 0, 0 ), lauf );
-			bool fertig = 0;
-			Vertex a;
-			Vertex b;
-			Array< Punkt > tmpOutList;
-			for( int i = 0; i < vAnz; i++ )
-			{
-				bool cont = 0;
-				int vorher = i - 1;
-				int nachher = i + 1;
-				if( nachher >= vAnz )
-					nachher = 0;
-				if( vorher < 0 )
-					vorher = vAnz - 1;
-				int ola = outList.z( p )->getEintragAnzahl();
-				for( int j = 0; j < ola; j++ )
-				{
-					Punkt out = outList.z( p )->get( j );
-					if( out.x < out.y )
-					{
-						if( nachher > out.x && nachher < out.y )
-							nachher = out.y;
-						if( vorher > out.x && vorher < out.y )
-							vorher = out.x;
-					}
-					if( out.x > out.y )
-					{
-						if( nachher > out.x || nachher < out.y )
-							nachher = out.y;
-						if( vorher > out.x || vorher < out.y )
-							vorher = out.x;
-					}
-					if( out.x < out.y && i > out.x && i < out.y )
-						cont = 1;
-					if( out.x > out.y && ( i > out.x || i < out.y ) )
-						cont = 1;
-				}
-				if( cont )
-					continue;
-				if( vorher < 0 )
-					a = pg.vertex->get( vAnz + vorher );
-				else
-					a = pg.vertex->get( vorher );
-				if( nachher > vAnz - 1 )
-					b = pg.vertex->get( nachher - vAnz + 1 );
-				else
-					b = pg.vertex->get( nachher );
-				if( istLinieInnen( a, b, p ) )
-				{
-					DreieckListe< Vertex > *lowL = new DreieckListe< Vertex >();
-					DreieckListe< Vertex > *hightL = new DreieckListe< Vertex >();
-					lowL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
-					hightL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
-					int hight = i + 1;
-					int low = i - 1;
-					Punkt outL( 0, 0 );
-					Punkt outH( 0, 0 );
-					for( int k = 0; k < 2; k++ )
-					{
-						bool lowp = !k;
-						while( 1 )
-						{
-							if( hight >= vAnz )
-								hight = 0;
-							if( low < 0 )
-								low = vAnz - 1;
-							for( int j = 0; j <= lauf; j++ )
-							{
-								Punkt out = outList.z( p )->get( j );
-								if( out.x < out.y )
-								{
-									if( hight > out.x && hight < out.y )
-										hight = out.y;
-									if( low > out.x && low < out.y )
-										low = out.x;
-								}
-								if( out.x > out.y )
-								{
-									if( hight > out.x || hight < out.y )
-										hight = out.y;
-									if( low > out.x || low < out.y )
-										low = out.x;
-								}
-							}
-							Vertex a = pg.vertex->get( hight );
-							Vertex b = pg.vertex->get( low );
-							if( low == hight )
-							{
-								fertig = 1;
-								outList.z( p )->set( Punkt( 0, 0 ), lauf );
-								if( !k )
-									lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
-								else
-									hightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
-								break;
-							}
-							bool inside = istLinieInnen( a, b, p );
-							if( inside )
-							{
-								if( !k )
-									outL = Punkt( low, hight );
-								else
-									outH = Punkt( low, hight );
-								outList.z( p )->set( Punkt( low, hight ), lauf );
-							}
-							if( lowp )
-							{
-								if( !k )
-									lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
-								else
-									hightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
-								low--;
-							}
-							else
-							{
-								if( !k )
-									lowL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( hight ) ) : 0 );
-								else
-									hightL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( hight ) ) : 0 );
-								hight++;
-							}
-							lowp = !lowp;
-							if( !inside )
-							{
-								hight = i + 1;
-								low = i - 1;
-								outList.z( p )->set( Punkt( 0, 0 ), lauf );
-								break;
-							}
-						}
-						if( fertig )
-							break;
-					}
-					if( lowL->getDreieckAnzahl() > hightL->getDreieckAnzahl() )
-					{
-						lists.z( lauf )->set( lowL, i );
-						tmpOutList.set( outL, i );
-						hightL->release();
-					}
-					else
-					{
-						lists.z( lauf )->set( hightL, i );
-						tmpOutList.set( outH, i );
-						lowL->release();
-					}
-				}
-				else
-					lists.z( lauf )->set( new DreieckListe< Vertex >(), i );
-				if( fertig )
-					break;
-			}
-			int maxP = -1;
-			int max = 0;
-			for( int i = 0; i < vAnz; i++ )
-			{
-				if( lists.z( lauf )->z( i ) && lists.z( lauf )->z( i )->getDreieckAnzahl() > max )
-				{
-					max = lists.z( lauf )->z( i )->getDreieckAnzahl();
-					maxP = i;
-				}
-			}
-			if( !max || maxP < 0 )
-				break;
-			vListen->z( p )->add( lists.z( lauf )->get( maxP ) );
-			outList.z( p )->set( tmpOutList.get( maxP ), lauf );
-			if( fertig )
-				break;
-			lauf++;
-		}
-		outList.z( p )->leeren();
-	}
-	return 1;
+    this->polygons = polygons;
+    int pAnz = polygons->getEintragAnzahl();
+    vListen = new RCArray< RCArray< DreieckListe< Vertex > > >();
+    for( int p = 0; p < pAnz; p++ )
+    {
+        Polygon2D pg = polygons->get( p );
+        if( !pg.vertex || pg.vertex->getEintragAnzahl() < 3 )
+            continue;
+        vListen->add( new RCArray< DreieckListe< Vertex > >() );
+        outList.set( new Array< Punkt >, p );
+        int vAnz = pg.vertex->getEintragAnzahl();
+        bool textur = pg.tKordinaten != 0;
+        for( int i = 0; i < vAnz && textur; i++ )
+            textur &= pg.tKordinaten->hat( i );
+        for( int i = 0; i < vAnz; i++ )
+        {
+            if( maxP.x < fabs( pg.vertex->get( i ).x ) )
+                maxP.x = abs( (int)pg.vertex->get( i ).x ) + 1;
+            if( maxP.y < fabs( pg.vertex->get( i ).y ) )
+                maxP.y = abs( (int)pg.vertex->get( i ).y ) + 1;
+        }
+        minP = -maxP;
+        if( !textur )
+        {
+            if( pg.tKordinaten )
+                pg.tKordinaten->leeren();
+        }
+        RCArray< RCArray< DreieckListe< Vertex > > > lists;
+        int lauf = 0;
+        while( 1 )
+        {
+            lists.set( new RCArray< DreieckListe< Vertex > >(), lauf );
+            outList.z( p )->set( Punkt( 0, 0 ), lauf );
+            bool fertig = 0;
+            Vertex a;
+            Vertex b;
+            Array< Punkt > tmpOutList;
+            for( int i = 0; i < vAnz; i++ )
+            {
+                bool cont = 0;
+                int vorher = i - 1;
+                int nachher = i + 1;
+                if( nachher >= vAnz )
+                    nachher = 0;
+                if( vorher < 0 )
+                    vorher = vAnz - 1;
+                int ola = outList.z( p )->getEintragAnzahl();
+                for( int j = 0; j < ola; j++ )
+                {
+                    Punkt out = outList.z( p )->get( j );
+                    if( out.x < out.y )
+                    {
+                        if( nachher > out.x && nachher < out.y )
+                            nachher = out.y;
+                        if( vorher > out.x && vorher < out.y )
+                            vorher = out.x;
+                    }
+                    if( out.x > out.y )
+                    {
+                        if( nachher > out.x || nachher < out.y )
+                            nachher = out.y;
+                        if( vorher > out.x || vorher < out.y )
+                            vorher = out.x;
+                    }
+                    if( out.x < out.y && i > out.x && i < out.y )
+                        cont = 1;
+                    if( out.x > out.y && ( i > out.x || i < out.y ) )
+                        cont = 1;
+                }
+                if( cont )
+                    continue;
+                if( vorher < 0 )
+                    a = pg.vertex->get( vAnz + vorher );
+                else
+                    a = pg.vertex->get( vorher );
+                if( nachher > vAnz - 1 )
+                    b = pg.vertex->get( nachher - vAnz + 1 );
+                else
+                    b = pg.vertex->get( nachher );
+                if( istLinieInnen( a, b, p ) )
+                {
+                    DreieckListe< Vertex > *lowL = new DreieckListe< Vertex >();
+                    DreieckListe< Vertex > *hightL = new DreieckListe< Vertex >();
+                    lowL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
+                    hightL->addPunkt( new Vertex( pg.vertex->get( i ) ), textur ? new Punkt( pg.tKordinaten->get( i ) ) : 0 );
+                    int hight = i + 1;
+                    int low = i - 1;
+                    Punkt outL( 0, 0 );
+                    Punkt outH( 0, 0 );
+                    for( int k = 0; k < 2; k++ )
+                    {
+                        bool lowp = !k;
+                        while( 1 )
+                        {
+                            if( hight >= vAnz )
+                                hight = 0;
+                            if( low < 0 )
+                                low = vAnz - 1;
+                            for( int j = 0; j <= lauf; j++ )
+                            {
+                                Punkt out = outList.z( p )->get( j );
+                                if( out.x < out.y )
+                                {
+                                    if( hight > out.x && hight < out.y )
+                                        hight = out.y;
+                                    if( low > out.x && low < out.y )
+                                        low = out.x;
+                                }
+                                if( out.x > out.y )
+                                {
+                                    if( hight > out.x || hight < out.y )
+                                        hight = out.y;
+                                    if( low > out.x || low < out.y )
+                                        low = out.x;
+                                }
+                            }
+                            Vertex a = pg.vertex->get( hight );
+                            Vertex b = pg.vertex->get( low );
+                            if( low == hight )
+                            {
+                                fertig = 1;
+                                outList.z( p )->set( Punkt( 0, 0 ), lauf );
+                                if( !k )
+                                    lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                else
+                                    hightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                break;
+                            }
+                            bool inside = istLinieInnen( a, b, p );
+                            if( inside )
+                            {
+                                if( !k )
+                                    outL = Punkt( low, hight );
+                                else
+                                    outH = Punkt( low, hight );
+                                outList.z( p )->set( Punkt( low, hight ), lauf );
+                            }
+                            if( lowp )
+                            {
+                                if( !k )
+                                    lowL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                else
+                                    hightL->addPunkt( new Vertex( b ), textur ? new Punkt( pg.tKordinaten->get( low ) ) : 0 );
+                                low--;
+                            }
+                            else
+                            {
+                                if( !k )
+                                    lowL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( hight ) ) : 0 );
+                                else
+                                    hightL->addPunkt( new Vertex( a ), textur ? new Punkt( pg.tKordinaten->get( hight ) ) : 0 );
+                                hight++;
+                            }
+                            lowp = !lowp;
+                            if( !inside )
+                            {
+                                hight = i + 1;
+                                low = i - 1;
+                                outList.z( p )->set( Punkt( 0, 0 ), lauf );
+                                break;
+                            }
+                        }
+                        if( fertig )
+                            break;
+                    }
+                    if( lowL->getDreieckAnzahl() > hightL->getDreieckAnzahl() )
+                    {
+                        lists.z( lauf )->set( lowL, i );
+                        tmpOutList.set( outL, i );
+                        hightL->release();
+                    }
+                    else
+                    {
+                        lists.z( lauf )->set( hightL, i );
+                        tmpOutList.set( outH, i );
+                        lowL->release();
+                    }
+                }
+                else
+                    lists.z( lauf )->set( new DreieckListe< Vertex >(), i );
+                if( fertig )
+                    break;
+            }
+            int maxP = -1;
+            int max = 0;
+            for( int i = 0; i < vAnz; i++ )
+            {
+                if( lists.z( lauf )->z( i ) && lists.z( lauf )->z( i )->getDreieckAnzahl() > max )
+                {
+                    max = lists.z( lauf )->z( i )->getDreieckAnzahl();
+                    maxP = i;
+                }
+            }
+            if( !max || maxP < 0 )
+                break;
+            vListen->z( p )->add( lists.z( lauf )->get( maxP ) );
+            outList.z( p )->set( tmpOutList.get( maxP ), lauf );
+            if( fertig )
+                break;
+            lauf++;
+        }
+        outList.z( p )->leeren();
+    }
+    return 1;
 }
 
 void Model2DData::löscheModell() // setzt die Vertex daten zurück
 {
-	if( polygons )
-	{
-		int anz = polygons->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( polygons->get( i ).tKordinaten )
-				polygons->get( i ).tKordinaten->release();
-			if( polygons->get( i ).vertex )
-				polygons->get( i ).vertex->release();
-		}
-		polygons = polygons->release();
-	}
-	if( vListen )
-		vListen = vListen->release();
-	outList.leeren();
-	minP = Punkt( 0, 0 );
-	maxP = Punkt( 0, 0 );
+    if( polygons )
+    {
+        int anz = polygons->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( polygons->get( i ).tKordinaten )
+                polygons->get( i ).tKordinaten->release();
+            if( polygons->get( i ).vertex )
+                polygons->get( i ).vertex->release();
+        }
+        polygons = polygons->release();
+    }
+    if( vListen )
+        vListen = vListen->release();
+    outList.leeren();
+    minP = Punkt( 0, 0 );
+    maxP = Punkt( 0, 0 );
 }
 
 // Reference Counting
 Model2DData *Model2DData::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Model2DData *Model2DData::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
@@ -408,347 +408,347 @@ Model2DData *Model2DData::release()
 // Konstruktor
 Model2D::Model2D()
 #ifdef WIN32
-	: Zeichnung(),
-	  textur( 0 )
+    : Zeichnung(),
+    textur( 0 )
 #endif
 {
 #ifdef WIN32
-	farbe = 0;
-	style = 0;
+    farbe = 0;
+    style = 0;
 #else
-	pos = Punkt( 0, 0 );
+    pos = Punkt( 0, 0 );
 #endif
-	rData = 0;
-	drehung = 0;
-	größe = 1;
-	ref = 1;
+    rData = 0;
+    drehung = 0;
+    größe = 1;
+    ref = 1;
 }
 
 // Destruktor
 Model2D::~Model2D()
 {
-	if( rData )
-		rData->release();
+    if( rData )
+        rData->release();
 #ifdef WIN32
-	if( textur )
-		textur->release();
+    if( textur )
+        textur->release();
 #endif
 }
 
 // nicht constant
 void Model2D::setModel( Model2DData *mdl )
 {
-	if( rData )
-		rData->release();
-	rData = mdl;
+    if( rData )
+        rData->release();
+    rData = mdl;
 }
 
 void Model2D::setDrehung( float drehung )
 {
-	this->drehung = drehung;
-	while( this->drehung > PI * 2 )
-		this->drehung -= (float)PI * 2;
-	while( this->drehung < 0 )
-		this->drehung += (float)PI * 2;
+    this->drehung = drehung;
+    while( this->drehung > PI * 2 )
+        this->drehung -= (float)PI * 2;
+    while( this->drehung < 0 )
+        this->drehung += (float)PI * 2;
 #ifdef WIN32
-	rend = 1;
+    rend = 1;
 #endif
 }
 
 void Model2D::addDrehung( float drehung )
 {
-	this->drehung += drehung;
-	while( this->drehung > PI * 2 )
-		this->drehung -= (float)PI * 2;
-	while( this->drehung < 0 )
-		this->drehung += (float)PI * 2;
+    this->drehung += drehung;
+    while( this->drehung > PI * 2 )
+        this->drehung -= (float)PI * 2;
+    while( this->drehung < 0 )
+        this->drehung += (float)PI * 2;
 #ifdef WIN32
-	rend = 1;
+    rend = 1;
 #endif
 }
 
 void Model2D::setGröße( float größe )
 {
-	this->größe = größe;
+    this->größe = größe;
 #ifdef WIN32
-	rend = 1;
+    rend = 1;
 #endif
 }
 
 void Model2D::addGröße( float größe )
 {
-	this->größe += größe;
+    this->größe += größe;
 #ifdef WIN32
-	rend = 1;
+    rend = 1;
 #endif
 }
 #ifdef WIN32
 void Model2D::setTextur( Bild *t )
 {
-	if( textur )
-		textur->release();
-	textur = t;
+    if( textur )
+        textur->release();
+    textur = t;
 }
 
 void Model2D::setFarbe( int f )
 {
-	farbe = f;
-	rend = 1;
+    farbe = f;
+    rend = 1;
 }
 
 void Model2D::doMausEreignis( MausEreignis &me )
 {
-	if( !Mak || me.verarbeitet || !istPunktInnen( Punkt( me.mx, me.my ) )  )
-		return;
-	me.mx -= pos.x;
-	me.my -= pos.y;
-	Mak( makParam, this, me );
-	me.mx += pos.x;
-	me.my += pos.y;
+    if( !Mak || me.verarbeitet || !istPunktInnen( Punkt( me.mx, me.my ) ) )
+        return;
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    Mak( makParam, this, me );
+    me.mx += pos.x;
+    me.my += pos.y;
     me.verarbeitet = 1;
 }
 
 bool Model2D::tick( double tickVal )
 {
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void Model2D::render( Bild &zRObj )
 {
-	if( !rData || hatStyleNicht( Model2D::Style::Sichtbar ) || !rData->polygons )
-		return;
+    if( !rData || hatStyleNicht( Model2D::Style::Sichtbar ) || !rData->polygons )
+        return;
     __super::render( zRObj );
-	int num = 0;
-	for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
-	{
-		Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
-		if( hatStyle( Model2D::Style::Textur ) )
-		{
-			if( !textur || !rData->polygons->get( num ).tKordinaten )
-			{
-				for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
-				{
-					for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
-					{
-						Vertex a = mat * *j->var->punkt;
-						Vertex b = mat * *j->next->var->punkt;
-						Vertex c = mat * *j->next->next->var->punkt;
-						if( hatStyle( Model2D::Style::Alpha ) )
-							zRObj.drawDreieckAlpha( a, b, c, farbe );
-						else
-							zRObj.drawDreieck( a, b, c, farbe );
-					}
-				}
-			}
-			else
-			{
-				for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
-				{
-					for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
-					{
-						Vertex a = mat * *j->var->punkt;
-						Vertex b = mat * *j->next->var->punkt;
-						Vertex c = mat * *j->next->next->var->punkt;
-						if( hatStyle( Model2D::Style::Alpha ) )
-							zRObj.drawDreieckTexturAlpha( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
-						else
-							zRObj.drawDreieckTextur( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
-					}
-				}
-			}
-		}
-		if( hatStyle( Model2D::Style::Mesh ) )
-		{
-			for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
-			{
-				for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
-				{
-					Vertex a = mat * *j->var->punkt;
-					Vertex b = mat * *j->next->var->punkt;
-					Vertex c = mat * *j->next->next->var->punkt;
-					if( hatStyle( Model2D::Style::Alpha ) )
-					{
-						zRObj.drawLinieAlpha( a, b, farbe );
-						zRObj.drawLinieAlpha( b, c, farbe );
-						zRObj.drawLinieAlpha( c, a, farbe );
-					}
-					else
-					{
-						zRObj.drawLinie( a, b, farbe );
-						zRObj.drawLinie( b, c, farbe );
-						zRObj.drawLinie( c, a, farbe );
-					}
-				}
-			}
-		}
-		if( hatStyle( Model2D::Style::Rahmen ) )
-		{
-			ArrayEintrag< Vertex > &beg = rData->polygons->get( num ).vertex->getArray();
-			if( beg.set )
-			{
-				ArrayEintrag< Vertex > *letzter = 0;
-				for( ArrayEintrag< Vertex > *e = &beg; e && e->next && e->set && e->next->set; e = e->next )
-				{
-					if( hatStyle( Model2D::Style::Alpha ) )
-						zRObj.drawLinieAlpha( mat * e->var, mat * e->next->var, farbe );
-					else
-						zRObj.drawLinie( mat * e->var, mat * e->next->var, farbe );
-					letzter = e->next;
-				}
-				if( letzter && letzter->set )
-				{
-					if( hatStyle( Model2D::Style::Alpha ) )
-						zRObj.drawLinieAlpha( mat * letzter->var, mat * beg.var, farbe );
-					else
-						zRObj.drawLinie( mat * letzter->var, mat * beg.var, farbe );
-				}
-			}
-		}
-	}
+    int num = 0;
+    for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
+    {
+        Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
+        if( hatStyle( Model2D::Style::Textur ) )
+        {
+            if( !textur || !rData->polygons->get( num ).tKordinaten )
+            {
+                for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+                {
+                    for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                    {
+                        Vertex a = mat * *j->var->punkt;
+                        Vertex b = mat * *j->next->var->punkt;
+                        Vertex c = mat * *j->next->next->var->punkt;
+                        if( hatStyle( Model2D::Style::Alpha ) )
+                            zRObj.drawDreieckAlpha( a, b, c, farbe );
+                        else
+                            zRObj.drawDreieck( a, b, c, farbe );
+                    }
+                }
+            }
+            else
+            {
+                for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+                {
+                    for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                    {
+                        Vertex a = mat * *j->var->punkt;
+                        Vertex b = mat * *j->next->var->punkt;
+                        Vertex c = mat * *j->next->next->var->punkt;
+                        if( hatStyle( Model2D::Style::Alpha ) )
+                            zRObj.drawDreieckTexturAlpha( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
+                        else
+                            zRObj.drawDreieckTextur( a, b, c, *j->var->textur, *j->next->var->textur, *j->next->next->var->textur, *textur );
+                    }
+                }
+            }
+        }
+        if( hatStyle( Model2D::Style::Mesh ) )
+        {
+            for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+            {
+                for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                {
+                    Vertex a = mat * *j->var->punkt;
+                    Vertex b = mat * *j->next->var->punkt;
+                    Vertex c = mat * *j->next->next->var->punkt;
+                    if( hatStyle( Model2D::Style::Alpha ) )
+                    {
+                        zRObj.drawLinieAlpha( a, b, farbe );
+                        zRObj.drawLinieAlpha( b, c, farbe );
+                        zRObj.drawLinieAlpha( c, a, farbe );
+                    }
+                    else
+                    {
+                        zRObj.drawLinie( a, b, farbe );
+                        zRObj.drawLinie( b, c, farbe );
+                        zRObj.drawLinie( c, a, farbe );
+                    }
+                }
+            }
+        }
+        if( hatStyle( Model2D::Style::Rahmen ) )
+        {
+            ArrayEintrag< Vertex > &beg = rData->polygons->get( num ).vertex->getArray();
+            if( beg.set )
+            {
+                ArrayEintrag< Vertex > *letzter = 0;
+                for( ArrayEintrag< Vertex > *e = &beg; e && e->next && e->set && e->next->set; e = e->next )
+                {
+                    if( hatStyle( Model2D::Style::Alpha ) )
+                        zRObj.drawLinieAlpha( mat * e->var, mat * e->next->var, farbe );
+                    else
+                        zRObj.drawLinie( mat * e->var, mat * e->next->var, farbe );
+                    letzter = e->next;
+                }
+                if( letzter && letzter->set )
+                {
+                    if( hatStyle( Model2D::Style::Alpha ) )
+                        zRObj.drawLinieAlpha( mat * letzter->var, mat * beg.var, farbe );
+                    else
+                        zRObj.drawLinie( mat * letzter->var, mat * beg.var, farbe );
+                }
+            }
+        }
+    }
 }
 #else
 void Model2D::setPosition( Punkt p )
 {
-	pos = p;
+    pos = p;
 }
 #endif
 // constant
 float Model2D::getDrehung() const
 {
-	return drehung;
+    return drehung;
 }
 
 float Model2D::getGröße() const
 {
-	return größe;
+    return größe;
 }
 
 bool Model2D::istPunktInnen( Vertex p ) const
 {
-	if( !rData )
-		return 0;
-	p -= pos;
-	if( p < Mat3< float >::scaling( größe ) * rData->minP || p > Mat3< float >::scaling( größe ) * rData->maxP || !rData->polygons )
-		return 0;
-	int num = 0;
-	for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
-	{
-		Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
-		int anz = polygon->var.vertex->getEintragAnzahl();
-		bool c = 0;
-		int j = anz - 1;
-		for( int i = 0; i < anz; i++ )
-		{
-			Vertex a = mat * polygon->var.vertex->get( i );
-			Vertex b = mat * polygon->var.vertex->get( j );
-			if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
-				c = !c;
-			j = i;
-		}
-		if( c )
-			return 1;
-	}
-	return 0;
+    if( !rData )
+        return 0;
+    p -= pos;
+    if( p < Mat3< float >::scaling( größe ) * rData->minP || p > Mat3< float >::scaling( größe ) * rData->maxP || !rData->polygons )
+        return 0;
+    int num = 0;
+    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    {
+        Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
+        int anz = polygon->var.vertex->getEintragAnzahl();
+        bool c = 0;
+        int j = anz - 1;
+        for( int i = 0; i < anz; i++ )
+        {
+            Vertex a = mat * polygon->var.vertex->get( i );
+            Vertex b = mat * polygon->var.vertex->get( j );
+            if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
+                c = !c;
+            j = i;
+        }
+        if( c )
+            return 1;
+    }
+    return 0;
 }
 
 bool Model2D::istLinieInnen( Vertex a, Vertex b ) const
 {
-	if( !rData || !rData->polygons )
-		return 0;
-	int pAnz = rData->polygons->getEintragAnzahl();
-	for( int p = 0; p < pAnz; p++ )
-	{
-		Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
-		int anz = rData->polygons->get( p ).vertex->getEintragAnzahl();
-		int j = anz - 1;
-		for( int i = 0; i < anz; i++ )
-		{
-			Punkt va = mat * rData->polygons->get( p ).vertex->get( i );
-			Punkt vb = mat * rData->polygons->get( p ).vertex->get( j );
-			if( (Punkt)a == pos + va && (Punkt)b == pos + vb )
-				return 1;
-			if( (Punkt)a == pos + vb && (Punkt)b == pos + va )
-				return 1;
-			j = i;
-		}
-		Vertex län = b - a;
-		Vertex speed( län.x > 0 ? 1 : -1.f, län.y > 0 ? 1 : -1.f );
-		int mLän = 0;
-		if( fabs( län.x ) > fabs( län.y ) )
-		{
-			mLän = (int)fabs( län.x );
-			speed.y = län.y / (float)fabs( län.x );
-		}
-		else
-		{
-			mLän = (int)fabs( län.y );
-			speed.x = län.x / (float)fabs( län.y );
-		}
-		int i = 1;
-		bool inside = 1;
-		for( Vertex vp = speed + a; (Punkt)vp != (Punkt)( b - speed ) && inside && i < mLän - 1; vp += speed, i++ )
-			inside &= istPunktInnen( vp );
-		if( inside )
-			return 1;
-	}
-	return 0;
+    if( !rData || !rData->polygons )
+        return 0;
+    int pAnz = rData->polygons->getEintragAnzahl();
+    for( int p = 0; p < pAnz; p++ )
+    {
+        Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
+        int anz = rData->polygons->get( p ).vertex->getEintragAnzahl();
+        int j = anz - 1;
+        for( int i = 0; i < anz; i++ )
+        {
+            Punkt va = mat * rData->polygons->get( p ).vertex->get( i );
+            Punkt vb = mat * rData->polygons->get( p ).vertex->get( j );
+            if( (Punkt)a == pos + va && (Punkt)b == pos + vb )
+                return 1;
+            if( (Punkt)a == pos + vb && (Punkt)b == pos + va )
+                return 1;
+            j = i;
+        }
+        Vertex län = b - a;
+        Vertex speed( län.x > 0 ? 1 : -1.f, län.y > 0 ? 1 : -1.f );
+        int mLän = 0;
+        if( fabs( län.x ) > fabs( län.y ) )
+        {
+            mLän = (int)fabs( län.x );
+            speed.y = län.y / (float)fabs( län.x );
+        }
+        else
+        {
+            mLän = (int)fabs( län.y );
+            speed.x = län.x / (float)fabs( län.y );
+        }
+        int i = 1;
+        bool inside = 1;
+        for( Vertex vp = speed + a; (Punkt)vp != (Punkt)( b - speed ) && inside && i < mLän - 1; vp += speed, i++ )
+            inside &= istPunktInnen( vp );
+        if( inside )
+            return 1;
+    }
+    return 0;
 }
 
 bool Model2D::istModelInnen( const Model2D *zMdl, bool end ) const
 {
-	if( !end )
-	{
-		Vertex min = (Vertex)rData->minP * größe + pos;
-		Vertex max = (Vertex)rData->maxP * größe + pos;
-		Vertex min2 = (Vertex)zMdl->zModel()->minP * zMdl->getGröße() + zMdl->getPosition();
-		Vertex max2 = (Vertex)zMdl->zModel()->maxP * zMdl->getGröße() + zMdl->getPosition();
-		if( max.x < min2.x || min.x > max2.x || max.y < min2.y || min.y > max2.y )
-			return 0;
-	}
-	Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
-	for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
-	{
-		int anz = polygon->var.vertex->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( zMdl->istPunktInnen( mat * polygon->var.vertex->get( i ) ) )
-				return 1;
-		}
-	}
-	if( end )
-		return 0;
-	return zMdl->istModelInnen( this, 1 );
+    if( !end )
+    {
+        Vertex min = (Vertex)rData->minP * größe + pos;
+        Vertex max = (Vertex)rData->maxP * größe + pos;
+        Vertex min2 = (Vertex)zMdl->zModel()->minP * zMdl->getGröße() + zMdl->getPosition();
+        Vertex max2 = (Vertex)zMdl->zModel()->maxP * zMdl->getGröße() + zMdl->getPosition();
+        if( max.x < min2.x || min.x > max2.x || max.y < min2.y || min.y > max2.y )
+            return 0;
+    }
+    Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( größe );
+    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
+    {
+        int anz = polygon->var.vertex->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( zMdl->istPunktInnen( mat * polygon->var.vertex->get( i ) ) )
+                return 1;
+        }
+    }
+    if( end )
+        return 0;
+    return zMdl->istModelInnen( this, 1 );
 }
 
 Model2DData *Model2D::getModel() const
 {
-	return rData ? rData->getThis() : 0;
+    return rData ? rData->getThis() : 0;
 }
 
 Model2DData *Model2D::zModel() const
 {
-	return rData;
+    return rData;
 }
 #ifndef WIN32
 Punkt Model2D::getPosition() const
 {
-	return pos;
+    return pos;
 }
 #endif
 
 // Reference Counting
 Model2D *Model2D::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Model2D *Model2D::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Model2D.h

@@ -11,63 +11,63 @@
 
 namespace Framework
 {
-	typedef Vec2< float > Vertex;
-	class Bild;
+    typedef Vec2< float > Vertex;
+    class Bild;
 
     // Eine Polygon Struktur, die von Model2D verwendet wird
-	// Model2D Klasse löscht die Zeiger
-	struct Polygon2D
-	{
-		Array< Vertex > *vertex;
-		Array< Punkt > *tKordinaten;
-	};
+    // Model2D Klasse löscht die Zeiger
+    struct Polygon2D
+    {
+        Array< Vertex > *vertex;
+        Array< Punkt > *tKordinaten;
+    };
 
     // Die Daten für ein 2D Model
-	class Model2DData
-	{
-	private:
-		RCArray< Array< Punkt > > outList;
-		int ref;
+    class Model2DData
+    {
+    private:
+        RCArray< Array< Punkt > > outList;
+        int ref;
 
-		// Überprüft, ob ein Punkt im Model ist
+        // Überprüft, ob ein Punkt im Model ist
         //  p: Der Punkt
         //  polygonId: Die Id des Polygons, das geprüft werden soll
-		bool istPunktInnen( Vertex p, int polygonId = -1 ) const;
+        bool istPunktInnen( Vertex p, int polygonId = -1 ) const;
         // Überprüft, ob eine Linie innerhalb des Models ist
         //  a: Der Startpunkt der Linie
         //  b: Der Endpunkt der Linie
-		bool istLinieInnen( Vertex a, Vertex b, int polygonId = -1 ) const;
+        bool istLinieInnen( Vertex a, Vertex b, int polygonId = -1 ) const;
 
-	public:
-		Array< Polygon2D > *polygons;
-		RCArray< RCArray< DreieckListe< Vertex > > > *vListen;
-		Punkt minP, maxP;
+    public:
+        Array< Polygon2D > *polygons;
+        RCArray< RCArray< DreieckListe< Vertex > > > *vListen;
+        Punkt minP, maxP;
 
-		// Konstruktor
-		__declspec( dllexport ) Model2DData();
-		// Destruktor
-		__declspec( dllexport ) ~Model2DData();
-		// Erstellt die Dreieck Listen anhand aller gegebenen Eckpunkte der Polygons
+        // Konstruktor
+        __declspec( dllexport ) Model2DData();
+        // Destruktor
+        __declspec( dllexport ) ~Model2DData();
+        // Erstellt die Dreieck Listen anhand aller gegebenen Eckpunkte der Polygons
         //  polygons: Ein Array von Polygons
         //  return: gibt immer 1 zurück
-		__declspec( dllexport ) bool erstelleModell( Array< Polygon2D > *polygons );
+        __declspec( dllexport ) bool erstelleModell( Array< Polygon2D > *polygons );
         // Löscht die erstellten Dreiecklisten und die Eckpunkte
-		__declspec( dllexport ) void löscheModell();
+        __declspec( dllexport ) void löscheModell();
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Model2DData *getThis();
+        __declspec( dllexport ) Model2DData *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Model2DData *release();
-	};
+        __declspec( dllexport ) Model2DData *release();
+    };
 
 #ifdef WIN32
     // Eine Zeichnung von einem Model
-	class Model2D : public Zeichnung
+    class Model2D : public Zeichnung
 #else
-	class Model2D
+    class Model2D
 #endif
-	{
+    {
     public:
 #ifdef WIN32
         class Style : public Zeichnung::Style
@@ -79,89 +79,89 @@ namespace Framework
             const static __int64 Mesh = 0x20; // Wenn dieser Flag gesetzt ist, werden die Render der Dreiecke gezeichnet
         };
 #endif
-	private:
-		Model2DData *rData;
-		float drehung;
-		float größe;
-		int ref;
+    private:
+        Model2DData *rData;
+        float drehung;
+        float größe;
+        int ref;
 #ifdef WIN32
-		int farbe;
-		Bild *textur;
+        int farbe;
+        Bild *textur;
 #else
-		Punkt pos;
+        Punkt pos;
 #endif
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) Model2D();
-		// Destruktor
-		__declspec( dllexport ) ~Model2D();
-		// Setzt die Daten des Models
+    public:
+        // Konstruktor
+        __declspec( dllexport ) Model2D();
+        // Destruktor
+        __declspec( dllexport ) ~Model2D();
+        // Setzt die Daten des Models
         //  mdl: Die Model Daten
-		__declspec( dllexport ) void setModel( Model2DData *mdl );
+        __declspec( dllexport ) void setModel( Model2DData *mdl );
         // Setzt die Drehung des Models gegen den Uhrzeigersinn
         //  drehung: Der winkel in Bogenmas
-		__declspec( dllexport ) void setDrehung( float drehung );
+        __declspec( dllexport ) void setDrehung( float drehung );
         // Fügt zum aktuellen Drehungswinkel etwas hinzu
         //  drehung: Der Winkel in Bogenmas, der hinzugefügt werden soll
-		__declspec( dllexport ) void addDrehung( float drehung );
+        __declspec( dllexport ) void addDrehung( float drehung );
         // Setzt die Skallierung des Modells
         //  größe: Der Faktor, mit dem Skalliert wird
-		__declspec( dllexport ) void setGröße( float größe );
+        __declspec( dllexport ) void setGröße( float größe );
         // Addiert zur Skallierung einen bestimmten Wert hinzu
         //  größe: Der Wert, der zur skallierung hinzugefügt werden soll
-		__declspec( dllexport ) void addGröße( float größe );
+        __declspec( dllexport ) void addGröße( float größe );
 #ifdef WIN32
         // Setzt die Textur
         //  t: Das Bild, das als Textur verwendet werden soll
-		__declspec( dllexport ) void setTextur( Bild *t );
+        __declspec( dllexport ) void setTextur( Bild *t );
         // Setzt die Farbe
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFarbe( int f );
+        __declspec( dllexport ) void setFarbe( int f );
         // Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
         //  me: Das Ereignis
-		__declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
         // Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion vergangen ist
         //  tickVal: Die vergangene Zeit in Sekunden
-		__declspec( dllexport ) bool tick( double tickVal ) override;
+        __declspec( dllexport ) bool tick( double tickVal ) override;
         // Zeichnet die Zeihnung in ein bestimmtes Bild
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
 #else
         // Setzt die Position
         //  p: Die neue Position
-		__declspec( dllexport ) void setPosition( Punkt p );
+        __declspec( dllexport ) void setPosition( Punkt p );
 #endif
-		// gibt die Drehung des Models zurück
-		__declspec( dllexport ) float getDrehung() const;
+        // gibt die Drehung des Models zurück
+        __declspec( dllexport ) float getDrehung() const;
         // gibt den Skallierungs Faktor zurück
-		__declspec( dllexport ) float getGröße() const;
+        __declspec( dllexport ) float getGröße() const;
         // Gibt zurück, ob ein Punkt in dem Model enthalten ist
-		//  p: Der Punkt
+        //  p: Der Punkt
         __declspec( dllexport ) bool istPunktInnen( Vertex p ) const;
         // Überprüft, ob eine Linie im Model enthalten ist
         //  a: Der startpunkt der Linie
         //  b: Der endpunkt der Linie
-		__declspec( dllexport ) bool istLinieInnen( Vertex a, Vertex b ) const;
+        __declspec( dllexport ) bool istLinieInnen( Vertex a, Vertex b ) const;
         // Überprüft, ob sich das Model mit einem anderen Überschneidet
         //  zMdl: Ein Zeiger auf das andere Model ohne erhöhten Reference Counter
         //  end: 0, falls alle Ecken beider Modele überprüft werdden sollen. 1, falls nur die Punkte dieses Models im anderen gesucht werden sollen
-		__declspec( dllexport ) bool istModelInnen( const Model2D *zMdl, bool end = 0 ) const;
+        __declspec( dllexport ) bool istModelInnen( const Model2D *zMdl, bool end = 0 ) const;
         // Gibt die Model Daten zurück
-		__declspec( dllexport ) Model2DData *getModel() const;
+        __declspec( dllexport ) Model2DData *getModel() const;
         // Gibt die Model Daten ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Model2DData *zModel() const;
+        __declspec( dllexport ) Model2DData *zModel() const;
 #ifndef WIN32
         // Gibt die Position des Models zurück
-		Punkt getPosition() const;
+        Punkt getPosition() const;
 #endif
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Model2D *getThis();
+        __declspec( dllexport ) Model2D *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Model2D *release();
-	};
+        __declspec( dllexport ) Model2D *release();
+    };
 }
 
 #endif

ObjectRegister.h

@@ -10,6 +10,6 @@ namespace Framework
 
     class ObjectRegister
     {
-        
+
     };
 }

Prozess.cpp

@@ -15,170 +15,169 @@ using namespace Framework;
 Prozess::Prozess()
 {
 #ifdef WIN32
-	pHandle = GetCurrentProcess();
-	SYSTEM_INFO sysInfo;
-	FILETIME ftime, fsys, fuser;
+    pHandle = GetCurrentProcess();
+    SYSTEM_INFO sysInfo;
+    FILETIME ftime, fsys, fuser;
 
-	GetSystemInfo( &sysInfo );
-	numProcessors = sysInfo.dwNumberOfProcessors;
+    GetSystemInfo( &sysInfo );
+    numProcessors = sysInfo.dwNumberOfProcessors;
 
-	GetSystemTimeAsFileTime( &ftime );
-	memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );
+    GetSystemTimeAsFileTime( &ftime );
+    memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );
 
-	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
-	memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
-	memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
+    GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
+    memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
+    memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
 #endif
-	ref = 1;
+    ref = 1;
 }
 
 // nicht constant 
 #ifdef WIN32
 void Prozess::setProcess( void *pHandle )
 {
-	this->pHandle = pHandle;
-	SYSTEM_INFO sysInfo;
-	FILETIME ftime, fsys, fuser;
+    this->pHandle = pHandle;
+    SYSTEM_INFO sysInfo;
+    FILETIME ftime, fsys, fuser;
 
-	GetSystemInfo( &sysInfo );
-	numProcessors = sysInfo.dwNumberOfProcessors;
+    GetSystemInfo( &sysInfo );
+    numProcessors = sysInfo.dwNumberOfProcessors;
 
-	GetSystemTimeAsFileTime( &ftime );
-	memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );
+    GetSystemTimeAsFileTime( &ftime );
+    memcpy( &lastCPU, &ftime, sizeof( FILETIME ) );
 
-	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
-	memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
-	memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
+    GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
+    memcpy( &lastSysCPU, &fsys, sizeof( FILETIME ) );
+    memcpy( &lastUserCPU, &fuser, sizeof( FILETIME ) );
 }
 #endif
 // constant
 double Prozess::getCPU() const
 {
 #ifdef WIN32
-	FILETIME ftime, fsys, fuser;
-	ULARGE_INTEGER now, sys, user;
-	double percent;
-
-	GetSystemTimeAsFileTime( &ftime );
-	memcpy( &now, &ftime, sizeof( FILETIME ) );
-
-	GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
-	memcpy( &sys, &fsys, sizeof( FILETIME ) );
-	memcpy( &user, &fuser, sizeof( FILETIME ) );
-	percent = (double)( ( sys.QuadPart - lastSysCPU.QuadPart ) +
-						( user.QuadPart - lastUserCPU.QuadPart ) );
-	percent /= ( now.QuadPart - lastCPU.QuadPart );
-	percent /= numProcessors;
-	memcpy( (void*)&lastCPU, (void*)&now, sizeof( now ) );
-	memcpy( (void*)&lastUserCPU, (void*)&user, sizeof( now ) );
-	memcpy( (void*)&lastSysCPU, (void*)&sys, sizeof( now ) );
-
-	return percent * 100;
+    FILETIME ftime, fsys, fuser;
+    ULARGE_INTEGER now, sys, user;
+    double percent;
+
+    GetSystemTimeAsFileTime( &ftime );
+    memcpy( &now, &ftime, sizeof( FILETIME ) );
+
+    GetProcessTimes( pHandle, &ftime, &ftime, &fsys, &fuser );
+    memcpy( &sys, &fsys, sizeof( FILETIME ) );
+    memcpy( &user, &fuser, sizeof( FILETIME ) );
+    percent = (double)( ( sys.QuadPart - lastSysCPU.QuadPart ) +
+        ( user.QuadPart - lastUserCPU.QuadPart ) );
+    percent /= ( now.QuadPart - lastCPU.QuadPart );
+    percent /= numProcessors;
+    memcpy( (void*)&lastCPU, (void*)&now, sizeof( now ) );
+    memcpy( (void*)&lastUserCPU, (void*)&user, sizeof( now ) );
+    memcpy( (void*)&lastSysCPU, (void*)&sys, sizeof( now ) );
+
+    return percent * 100;
 #else
-	return 0; //usage.ru_stime usage.ru_utime;
+    return 0; //usage.ru_stime usage.ru_utime;
 #endif
 }
 
 __int64 Prozess::getMem() const
 {
 #ifdef WIN32
-	PROCESS_MEMORY_COUNTERS pMemCountr;
-	pMemCountr = PROCESS_MEMORY_COUNTERS();
-	if( GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) ) )
-		return pMemCountr.WorkingSetSize;
-	return 0;
+    PROCESS_MEMORY_COUNTERS pMemCountr;
+    pMemCountr = PROCESS_MEMORY_COUNTERS();
+    if( GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) ) )
+        return pMemCountr.WorkingSetSize;
+    return 0;
 #else
-   using std::ios_base;
-   using std::ifstream;
-   using std::string;
-
-   // 'file' stat seems to give the most reliable results
-   //
-   ifstream stat_stream("/proc/self/stat",ios_base::in);
-
-   // dummy vars for leading entries in stat that we don't care about
-   //
-   string pid, comm, state, ppid, pgrp, session, tty_nr;
-   string tpgid, flags, minflt, cminflt, majflt, cmajflt;
-   string utime, stime, cutime, cstime, priority, nice;
-   string O, itrealvalue, starttime;
-
-   // the two fields we want
-   //
-   unsigned long vsize;
-   long rss;
-
-   stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
-               >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
-               >> utime >> stime >> cutime >> cstime >> priority >> nice
-               >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
-
-   stat_stream.close();
-
-   long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
-   return rss * page_size_kb;
+    using std::ios_base;
+    using std::ifstream;
+    using std::string;
+
+    // 'file' stat seems to give the most reliable results
+    //
+    ifstream stat_stream( "/proc/self/stat", ios_base::in );
+
+    // dummy vars for leading entries in stat that we don't care about
+    //
+    string pid, comm, state, ppid, pgrp, session, tty_nr;
+    string tpgid, flags, minflt, cminflt, majflt, cmajflt;
+    string utime, stime, cutime, cstime, priority, nice;
+    string O, itrealvalue, starttime;
+
+    // the two fields we want
+    //
+    unsigned long vsize;
+    long rss;
+
+    stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
+        >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
+        >> utime >> stime >> cutime >> cstime >> priority >> nice
+        >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
+
+    stat_stream.close();
+
+    long page_size_kb = sysconf( _SC_PAGE_SIZE ) / 1024; // in case x86-64 is configured to use 2MB pages
+    return rss * page_size_kb;
 #endif
 }
 #ifdef WIN32
 MemoryInfo Prozess::getMemInfo() const
 {
-	PROCESS_MEMORY_COUNTERS pMemCountr;
-	pMemCountr = PROCESS_MEMORY_COUNTERS();
-	int result = GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) );
-	MemoryInfo ret;
-	ZeroMemory( &ret, sizeof( ret ) );
-	if( result )
-	{
-		ret.ausgelagerteFehler = pMemCountr.PageFaultCount;
-		ret.ausgelagerterPool = pMemCountr.QuotaPagedPoolUsage;
-		ret.ausgelagerterSpeicher = pMemCountr.WorkingSetSize;
-		ret.höchsteAusgelagerterSpeicher = pMemCountr.PeakWorkingSetSize;
-		ret.höchsterAusgelagerterPool = pMemCountr.QuotaPeakPagedPoolUsage;
-		ret.höchsterNichtAusgelagerterPool = pMemCountr.QuotaPeakNonPagedPoolUsage;
-		ret.höchsterVorreservierterSpeicher = pMemCountr.PeakPagefileUsage;
-		ret.nichtAusgelagerterPool = pMemCountr.QuotaNonPagedPoolUsage;
-		ret.vorreservierterSpeicher = pMemCountr.PagefileUsage;
-		return ret;
-	}
-	return ret;
+    PROCESS_MEMORY_COUNTERS pMemCountr;
+    pMemCountr = PROCESS_MEMORY_COUNTERS();
+    int result = GetProcessMemoryInfo( pHandle, &pMemCountr, sizeof( pMemCountr ) );
+    MemoryInfo ret;
+    ZeroMemory( &ret, sizeof( ret ) );
+    if( result )
+    {
+        ret.ausgelagerteFehler = pMemCountr.PageFaultCount;
+        ret.ausgelagerterPool = pMemCountr.QuotaPagedPoolUsage;
+        ret.ausgelagerterSpeicher = pMemCountr.WorkingSetSize;
+        ret.höchsteAusgelagerterSpeicher = pMemCountr.PeakWorkingSetSize;
+        ret.höchsterAusgelagerterPool = pMemCountr.QuotaPeakPagedPoolUsage;
+        ret.höchsterNichtAusgelagerterPool = pMemCountr.QuotaPeakNonPagedPoolUsage;
+        ret.höchsterVorreservierterSpeicher = pMemCountr.PeakPagefileUsage;
+        ret.nichtAusgelagerterPool = pMemCountr.QuotaNonPagedPoolUsage;
+        ret.vorreservierterSpeicher = pMemCountr.PagefileUsage;
+        return ret;
+    }
+    return ret;
 }
 
 int Prozess::getThreadAnzahl() const
 {
-	int ret = 0;
-	DWORD processID = GetCurrentProcessId();
-	HANDLE snap = CreateToolhelp32Snapshot( TH32CS_SNAPALL, processID );
-	if( snap != INVALID_HANDLE_VALUE )
-	{
-		PROCESSENTRY32 entry = { 0 };
-		entry.dwSize = sizeof( PROCESSENTRY32 );
-		if( Process32First( snap, &entry ) )
-		{
-			do
-			{
-				if( entry.th32ProcessID == processID )
-				{
-					ret = entry.cntThreads;
-					break;
-				}
-			}
-			while( Process32Next( snap, &entry ) );
-		}
-		CloseHandle( snap );
-	}
-	return ret;
+    int ret = 0;
+    DWORD processID = GetCurrentProcessId();
+    HANDLE snap = CreateToolhelp32Snapshot( TH32CS_SNAPALL, processID );
+    if( snap != INVALID_HANDLE_VALUE )
+    {
+        PROCESSENTRY32 entry = { 0 };
+        entry.dwSize = sizeof( PROCESSENTRY32 );
+        if( Process32First( snap, &entry ) )
+        {
+            do
+            {
+                if( entry.th32ProcessID == processID )
+                {
+                    ret = entry.cntThreads;
+                    break;
+                }
+            } while( Process32Next( snap, &entry ) );
+        }
+        CloseHandle( snap );
+    }
+    return ret;
 }
 #endif
 Prozess *Prozess::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
-Prozess *Prozess::release( )
+Prozess *Prozess::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Prozess.h

@@ -10,61 +10,61 @@
 namespace Framework
 {
 #ifdef WIN32
-	struct MemoryInfo; // aus dieser Datei
+    struct MemoryInfo; // aus dieser Datei
 #endif
-	class Prozess; // aus dieser Datei
+    class Prozess; // aus dieser Datei
 
 #ifdef WIN32
-	struct MemoryInfo
-	{
-		unsigned long ausgelagerteFehler;
-		__int64 höchsteAusgelagerterSpeicher;
-		__int64 ausgelagerterSpeicher;
-		__int64 höchsterAusgelagerterPool;
-		__int64 ausgelagerterPool;
-		__int64 höchsterNichtAusgelagerterPool;
-		__int64 nichtAusgelagerterPool;
-		__int64 vorreservierterSpeicher;
-		__int64 höchsterVorreservierterSpeicher;
-	};
+    struct MemoryInfo
+    {
+        unsigned long ausgelagerteFehler;
+        __int64 höchsteAusgelagerterSpeicher;
+        __int64 ausgelagerterSpeicher;
+        __int64 höchsterAusgelagerterPool;
+        __int64 ausgelagerterPool;
+        __int64 höchsterNichtAusgelagerterPool;
+        __int64 nichtAusgelagerterPool;
+        __int64 vorreservierterSpeicher;
+        __int64 höchsterVorreservierterSpeicher;
+    };
 #endif
     // Diese Klasse findet informationen über einen laufenden Prozess heraus (CPU, MEM)
     // Bei Ubuntu immer der eigene Prozess
-	class Prozess
-	{
-	private:
+    class Prozess
+    {
+    private:
 #ifdef WIN32
-		int numProcessors;
-		ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
-		void *pHandle;
+        int numProcessors;
+        ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
+        void *pHandle;
 #endif
-		int ref;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Prozess();
-		// nicht constant 
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Prozess();
+        // nicht constant 
 #ifdef WIN32
         // Setzt den Prozess, der überwacht werden soll (Nur für Windows)
-		__declspec( dllexport ) void setProcess( void *pHandle );
+        __declspec( dllexport ) void setProcess( void *pHandle );
 #endif
-		// Gibt den CPU verbrauch des Prozesses zurück
-		__declspec( dllexport ) double getCPU() const;
+        // Gibt den CPU verbrauch des Prozesses zurück
+        __declspec( dllexport ) double getCPU() const;
         // Gibt den Speicherverbrauch des Prozesses zurück
-		__declspec( dllexport ) __int64 getMem() const;
+        __declspec( dllexport ) __int64 getMem() const;
 #ifdef WIN32
         // Gibt detailierte Informationen über den Speicherverbrauch des Prozesses zurück (Nur für Windows)
-		__declspec( dllexport ) MemoryInfo getMemInfo() const;
+        __declspec( dllexport ) MemoryInfo getMemInfo() const;
         // Gibt die Anzahl der Threads zurück (Nur für Windows)
-		__declspec( dllexport ) int getThreadAnzahl() const;
+        __declspec( dllexport ) int getThreadAnzahl() const;
 #endif
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) Prozess *getThis();
+        __declspec( dllexport ) Prozess *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) Prozess *release();
-	};
+        __declspec( dllexport ) Prozess *release();
+    };
 }
 
 #endif

Punkt.cpp

@@ -9,42 +9,42 @@ using namespace Framework;
 #ifdef WIN32
 inline Punkt Framework::BildschirmGröße() // Gibt die Größe des Bildschirms zurück
 {
-	RECT r;
-	GetWindowRect( GetDesktopWindow(), &r );
-	return Punkt( r.right, r.bottom );
+    RECT r;
+    GetWindowRect( GetDesktopWindow(), &r );
+    return Punkt( r.right, r.bottom );
 }
 
 inline Punkt Framework::Bildschirmmitte() // Giebt die Mitte des Bildschirms zurück
 {
-	RECT r;
-	GetWindowRect( GetDesktopWindow(), &r ); // Bildschirmgröße herausfinden
-	return Punkt( r.right / 2, r.bottom / 2 );
+    RECT r;
+    GetWindowRect( GetDesktopWindow(), &r ); // Bildschirmgröße herausfinden
+    return Punkt( r.right / 2, r.bottom / 2 );
 }
 
 inline Punkt Framework::Bildschirmmitte( WFenster *f ) // Giebt die Mitte des Bildschirms zurück
 {
-	Punkt p = Bildschirmmitte();
-	Punkt p2 = f->getGröße();
-	f->release();
-	return { p.x - p2.x / 2, p.y - p2.y / 2 };
+    Punkt p = Bildschirmmitte();
+    Punkt p2 = f->getGröße();
+    f->release();
+    return{ p.x - p2.x / 2, p.y - p2.y / 2 };
 }
 #endif
 bool Framework::operator >( const Punkt &a, const Punkt &b ) // Gibt an, ob a > als b ist
 {
-	return a.x > b.x && a.y > b.y;
+    return a.x > b.x && a.y > b.y;
 }
 
 bool Framework::operator <( const Punkt &a, const Punkt &b ) // Gibt an, ob a < als b ist
 {
-	return a.x < b.x && a.y < b.y;
+    return a.x < b.x && a.y < b.y;
 }
 
 bool Framework::operator <=( const Punkt &a, const Punkt &b ) // Gibt an, ob a <= als b ist
 {
-	return a.x <= b.x && a.y <= b.y;
+    return a.x <= b.x && a.y <= b.y;
 }
 
 bool Framework::operator >=( const Punkt &a, const Punkt &b ) // Gibt an, ob a >= als b ist
 {
-	return a.x >= b.x && a.y >= b.y;
+    return a.x >= b.x && a.y >= b.y;
 }

Punkt.h

@@ -6,32 +6,32 @@
 
 namespace Framework
 {
-	// benötigte includes
-	class WFenster; // aus Fenster.h
-	
-	typedef Vec2< int > Punkt; // Speichert die ganzzahligen Koordinaten eines Punktes
+    // benötigte includes
+    class WFenster; // aus Fenster.h
+
+    typedef Vec2< int > Punkt; // Speichert die ganzzahligen Koordinaten eines Punktes
+
 
-	
 #ifdef WIN32
     // Gibt die Größe des Bildschirms zurück
-	__declspec( dllexport ) Punkt BildschirmGröße();
+    __declspec( dllexport ) Punkt BildschirmGröße();
     // Giebt die Mitte des Bildschirms zurück
-	__declspec( dllexport ) Punkt Bildschirmmitte();
+    __declspec( dllexport ) Punkt Bildschirmmitte();
     // Giebt einen Punkt zurück, der als Fensterposition verwendet werden kann um das Fenster zu zentrieren
     //  f: Das Fenster, welches Zentriert werden soll
-	__declspec( dllexport ) Punkt Bildschirmmitte( WFenster *f );
+    __declspec( dllexport ) Punkt Bildschirmmitte( WFenster *f );
 #endif
     // Prüft, ob ein Punkt weiter rechts unten ist als ein anderer
     //  return: (true), wenn der linke Punkt weiter rechts und weiter unten ist. (false) sonnst
-	__declspec( dllexport ) bool operator >( const Punkt &a, const Punkt &b );
+    __declspec( dllexport ) bool operator >( const Punkt &a, const Punkt &b );
     // Prüft, ob ein Punkt weiter links obem ist als ein anderer
     //  return: (true), wenn der linke Punkt weiter links und weiter oben ist. (false) sonnst
-	__declspec( dllexport ) bool operator <( const Punkt &a, const Punkt &b );
+    __declspec( dllexport ) bool operator <( const Punkt &a, const Punkt &b );
     // Prüft, ob ein Punkt weiter links obem ist als ein anderer
     //  return: (true), wenn der linke Punkt weiter links und weiter oben oder gleich ist. (false) sonnst
-	__declspec( dllexport ) inline bool operator <=( const Punkt &a, const Punkt &b );
+    __declspec( dllexport ) inline bool operator <=( const Punkt &a, const Punkt &b );
     // Prüft, ob ein Punkt weiter rechts unten ist als ein anderer
     //  return: (true), wenn der linke Punkt weiter rechts und weiter unten oder gleich ist. (false) sonnst
-	__declspec( dllexport ) inline bool operator >=( const Punkt &a, const Punkt &b );
+    __declspec( dllexport ) inline bool operator >=( const Punkt &a, const Punkt &b );
 }
 #endif

Rahmen.cpp

@@ -10,106 +10,105 @@ using namespace Framework;
 // Inhalt der LRahmen Klasse aus Rahmen.h
 // Konstruktor 
 LRahmen::LRahmen()
-	: Zeichnung(),
-	  br( 1 ),
-	  farbe( 0xFF000000 ),
-	  alpha( 0 ),
-	  ref( 1 )
-{
-}
+    : Zeichnung(),
+    br( 1 ),
+    farbe( 0xFF000000 ),
+    alpha( 0 ),
+    ref( 1 )
+{}
 
 // nicht constant 
 void LRahmen::setRamenBreite( int br ) // setzt die Breite des Rahmens
 {
-	this->br = br;
-	rend = 1;
+    this->br = br;
+    rend = 1;
 }
 
 void LRahmen::setAlpha( bool a ) // Legt fest, ob der Alphawert der Farbe berücksichtigt werden soll
 {
-	alpha = a;
-	rend = 1;
+    alpha = a;
+    rend = 1;
 }
 
 void LRahmen::setFarbe( int f ) // Legt die Farbe des Rahmens fest
 {
-	farbe = f;
-	rend = 1;
+    farbe = f;
+    rend = 1;
 }
 
 void LRahmen::render( Bild &Obj ) // Zeichnet den Rahmen in das RenderZeichnung
 {
     __super::render( Obj );
-	int x = pos.x;
-	int y = pos.y;
-	int b = x + gr.x - 1;
-	int h = y + gr.y - 1;
-	if( alpha )
-	{
-		for( int i = 0; i < br; ++i )
-		{
-			Obj.drawLinieHAlpha( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
-			Obj.drawLinieVAlpha( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
-			Obj.drawLinieHAlpha( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
-			Obj.drawLinieVAlpha( x + i, y + i, gr.y - i * 2, farbe );
-		}
-	}
-	else
-	{
-		for( int i = 0; i < br; ++i )
-		{
-			Obj.drawLinieH( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
-			Obj.drawLinieV( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
-			Obj.drawLinieH( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
-			Obj.drawLinieV( x + i, y + i, gr.y - i * 2, farbe );
-		}
-	}
+    int x = pos.x;
+    int y = pos.y;
+    int b = x + gr.x - 1;
+    int h = y + gr.y - 1;
+    if( alpha )
+    {
+        for( int i = 0; i < br; ++i )
+        {
+            Obj.drawLinieHAlpha( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
+            Obj.drawLinieVAlpha( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
+            Obj.drawLinieHAlpha( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
+            Obj.drawLinieVAlpha( x + i, y + i, gr.y - i * 2, farbe );
+        }
+    }
+    else
+    {
+        for( int i = 0; i < br; ++i )
+        {
+            Obj.drawLinieH( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
+            Obj.drawLinieV( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
+            Obj.drawLinieH( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
+            Obj.drawLinieV( x + i, y + i, gr.y - i * 2, farbe );
+        }
+    }
 }
 
 // constant 
 int LRahmen::getRBreite() const // Gibt die Breite des Rahmens zurück
 {
-	return br;
+    return br;
 }
 
 int LRahmen::getFarbe() const // Gibt die Farbe des Ramens zurück
 {
-	return farbe;
+    return farbe;
 }
 
 bool LRahmen::hatAlpha() const // Gibt zurück, ob der Alphawert der Farbe beachtet wird
 {
-	return alpha;
+    return alpha;
 }
 
 Zeichnung *LRahmen::dublizieren() const // Kopiert das Zeichnung
 {
-	LRahmen *obj = new LRahmen();
-	obj->setPosition( pos );
-	obj->setGröße( gr );
-	obj->setMausEreignisParameter( makParam );
-	obj->setTastaturEreignisParameter( takParam );
-	obj->setMausEreignis( Mak );
-	obj->setTastaturEreignis( Tak );
-	if( toolTip )
-		obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	obj->setAlpha( alpha );
-	obj->setFarbe( farbe );
-	obj->setRamenBreite( br );
-	return obj;
+    LRahmen *obj = new LRahmen();
+    obj->setPosition( pos );
+    obj->setGröße( gr );
+    obj->setMausEreignisParameter( makParam );
+    obj->setTastaturEreignisParameter( takParam );
+    obj->setMausEreignis( Mak );
+    obj->setTastaturEreignis( Tak );
+    if( toolTip )
+        obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    obj->setAlpha( alpha );
+    obj->setFarbe( farbe );
+    obj->setRamenBreite( br );
+    return obj;
 }
 
 // Reference Counting 
 LRahmen *LRahmen::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 LRahmen *LRahmen::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }

Rahmen.h

@@ -5,50 +5,50 @@
 
 namespace Framework
 {
-	class Bild; // aus Bild.h
-	struct VScrollData; // Scroll.h
-	struct HScrollData; // Scroll.h
-	class LRahmen; // aus dieser Datei
+    class Bild; // aus Bild.h
+    struct VScrollData; // Scroll.h
+    struct HScrollData; // Scroll.h
+    class LRahmen; // aus dieser Datei
 
     // Eine Zeichnung des 2D GUI Frameworks, die einen Linienrahmen um ein Rechteck zeichnet
-	class LRahmen : public Zeichnung
-	{
-	private:
-		int br;
-		int farbe;
-		bool alpha;
-		int ref;
+    class LRahmen : public Zeichnung
+    {
+    private:
+        int br;
+        int farbe;
+        bool alpha;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) LRahmen();
-		// Setzt die Breite des Rahmens
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) LRahmen();
+        // Setzt die Breite des Rahmens
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setRamenBreite( int br );
+        __declspec( dllexport ) void setRamenBreite( int br );
         // Legt fest, ob beim zeichnen alpha blending verwendet werden soll
         //  a: 1, falls alpha blending verwendet werden soll
         __declspec( dllexport ) void setAlpha( bool a );
         // Setzt die Fare des Rahmens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setFarbe( int f );
+        __declspec( dllexport ) void setFarbe( int f );
         // Zeichnet den Rahmen
         //  zRObj: Das Bild, in den der Rahmen gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Breite des Rahmens in Pixeln zurück
-		__declspec( dllexport ) int getRBreite() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Breite des Rahmens in Pixeln zurück
+        __declspec( dllexport ) int getRBreite() const;
         // Gibt die Farbe des Rahmens im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getFarbe() const;
+        __declspec( dllexport ) int getFarbe() const;
         // Gibt zurück, ob der Rahmen mit Alpha Blending gezeichnet wird
-		__declspec( dllexport ) bool hatAlpha() const;
+        __declspec( dllexport ) bool hatAlpha() const;
         // Kopiert den Rahmen, so dass er ohne auswirkungen auf das Original verändert werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) LRahmen *getThis();
+        __declspec( dllexport ) LRahmen *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) LRahmen *release();
-	};
+        __declspec( dllexport ) LRahmen *release();
+    };
 }
 
 #endif

RenderThread.cpp

@@ -7,155 +7,155 @@ using namespace Framework;
 // Inhalt der RenderTh Klasse aus RenderThread.h
 // Konstruktor 
 RenderTh::RenderTh()
-	: stoppen( 0 ),
-	  bildschirm( 0 ),
-	  zeit( new ZeitMesser() ),
-	  renderTickZeit( 1 / 60 ),
-	  renderParameter( 0 ),
-	  tickParameter( 0 ),
-	  renderFunktion( 0 ),
-	  tickFunktion( 0 ),
-	  pause( 0 ),
-	  maxFps( 30 ),
-	  ref( 1 )
+    : stoppen( 0 ),
+    bildschirm( 0 ),
+    zeit( new ZeitMesser() ),
+    renderTickZeit( 1 / 60 ),
+    renderParameter( 0 ),
+    tickParameter( 0 ),
+    renderFunktion( 0 ),
+    tickFunktion( 0 ),
+    pause( 0 ),
+    maxFps( 30 ),
+    ref( 1 )
 {
-	InitializeCriticalSection( &cs );
+    InitializeCriticalSection( &cs );
 }
 
 // Destruktor 
 RenderTh::~RenderTh()
 {
-	if( run )
-		beenden();
-	if( bildschirm )
-		bildschirm->release();
-	zeit->release();
-	DeleteCriticalSection( &cs );
+    if( run )
+        beenden();
+    if( bildschirm )
+        bildschirm->release();
+    zeit->release();
+    DeleteCriticalSection( &cs );
 }
 
 // nicht constant 
 void RenderTh::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void RenderTh::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void RenderTh::setBildschirm( Bildschirm *bildschirm ) // setzt den Bildschirm
 {
-	lock();
-	if( this->bildschirm )
-		this->bildschirm->release();
-	this->bildschirm = bildschirm;
-	unlock();
+    lock();
+    if( this->bildschirm )
+        this->bildschirm->release();
+    this->bildschirm = bildschirm;
+    unlock();
 }
 
 void RenderTh::thread() // Render Schleife
 {
-	zeit->messungStart();
-	double ausgleich = 0;
-	while( !stoppen )
-	{
-		lock();
-		if( bildschirm && !pause )
-		{
-			if( renderFunktion )
-				renderFunktion( renderParameter, this, bildschirm->zRenderBild() );
-			bildschirm->render();
-			if( tickFunktion )
-				tickFunktion( tickParameter, this, renderTickZeit );
-			bildschirm->tick( renderTickZeit );
-			unlock();
-		}
-		else
-		{
-			unlock();
-			Sleep( 100 );
-		}
-		ausgleich += 1.0 / maxFps - renderTickZeit;
-		if( ausgleich > 0 )
-			Sleep( (int)( ausgleich * 1000 ) );
-		zeit->messungEnde();
-		zeit->messungStart();
-		renderTickZeit = zeit->getSekunden();
-	}
-	zeit->messungEnde();
+    zeit->messungStart();
+    double ausgleich = 0;
+    while( !stoppen )
+    {
+        lock();
+        if( bildschirm && !pause )
+        {
+            if( renderFunktion )
+                renderFunktion( renderParameter, this, bildschirm->zRenderBild() );
+            bildschirm->render();
+            if( tickFunktion )
+                tickFunktion( tickParameter, this, renderTickZeit );
+            bildschirm->tick( renderTickZeit );
+            unlock();
+        }
+        else
+        {
+            unlock();
+            Sleep( 100 );
+        }
+        ausgleich += 1.0 / maxFps - renderTickZeit;
+        if( ausgleich > 0 )
+            Sleep( (int)( ausgleich * 1000 ) );
+        zeit->messungEnde();
+        zeit->messungStart();
+        renderTickZeit = zeit->getSekunden();
+    }
+    zeit->messungEnde();
 }
 
 void RenderTh::beginn() // beginnt rendering
 {
-	stoppen = 0;
-	start();
+    stoppen = 0;
+    start();
 }
 
 void RenderTh::beenden() // beendet den Thread
 {
-	stoppen = 1;
-	warteAufThread( 2000 );
-	if( run )
-		ende();
+    stoppen = 1;
+    warteAufThread( 2000 );
+    if( run )
+        ende();
 }
 
 void RenderTh::setMaxFps( int fps ) // setzt die Anzahl der Bilder pro Sekunde
 {
-	maxFps = fps;
+    maxFps = fps;
 }
 
 void RenderTh::setPause( bool p ) // Renderpause
 {
-	pause = p;
+    pause = p;
 }
 
 void RenderTh::setRenderFunktion( void( *rF )( void *, void *, Bild * ) ) // setzt die Rückruf Funktion beim Rendern
 {
-	renderFunktion = rF;
+    renderFunktion = rF;
 }
 
 void RenderTh::setTickFunktion( void( *tF )( void *, void *, double ) ) // setzt die Rückruf Funktion beim Tick
 {
-	tickFunktion = tF;
+    tickFunktion = tF;
 }
 
 void RenderTh::setRenderFunktionParameter( void *p ) // setzt den Parameter der Rückruf Funktion beim Rendern
 {
-	renderParameter = p;
+    renderParameter = p;
 }
 
 void RenderTh::setTickFunktionParameter( void *p ) // setzt den Parameter der Rückruf Funktion beim Tick
 {
-	tickParameter = p;
+    tickParameter = p;
 }
 
 // constant
 Bildschirm *RenderTh::getBildschirm() const // gibt den Bildschirm zurück
 {
-	return bildschirm ? bildschirm->getThis() : 0;
+    return bildschirm ? bildschirm->getThis() : 0;
 }
 
 Bildschirm *RenderTh::zBildschirm() const
 {
-	return bildschirm;
+    return bildschirm;
 }
 
 double RenderTh::getRenderTickZeit() const // gibt die Zeit zurück, die zum Rendern und zum Tick benötigt wird
 {
-	return renderTickZeit;
+    return renderTickZeit;
 }
 
 // Reference Counting
 RenderTh *RenderTh::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 RenderTh *RenderTh::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

RenderThread.h

@@ -5,77 +5,77 @@
 
 namespace Framework
 {
-	class Bildschirm; // Bildschirm.h
-	class ZeitMesser; // ZeitMesser.h
-	class Bild; // Bild.h
+    class Bildschirm; // Bildschirm.h
+    class ZeitMesser; // ZeitMesser.h
+    class Bild; // Bild.h
 
     // Ein Thread, der ein Bildschirm verwaltet. Er ruft die render() und tick() funktionen automatisch auf
-	class RenderTh : private Thread
-	{
-	private:
-		bool stoppen;
-		Bildschirm *bildschirm;
-		ZeitMesser *zeit;
-		double renderTickZeit;
-		void *renderParameter;
-		void *tickParameter;
-		void ( *renderFunktion )( void *, void *, Bild * );
-		void ( *tickFunktion )( void *, void *, double );
-		bool pause;
-		CRITICAL_SECTION cs;
-		int maxFps;
-		int ref;
+    class RenderTh : private Thread
+    {
+    private:
+        bool stoppen;
+        Bildschirm *bildschirm;
+        ZeitMesser *zeit;
+        double renderTickZeit;
+        void *renderParameter;
+        void *tickParameter;
+        void( *renderFunktion )( void *, void *, Bild * );
+        void( *tickFunktion )( void *, void *, double );
+        bool pause;
+        CRITICAL_SECTION cs;
+        int maxFps;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) RenderTh();
-		// Destruktor 
-		__declspec( dllexport ) ~RenderTh();
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) RenderTh();
+        // Destruktor 
+        __declspec( dllexport ) ~RenderTh();
         // Dies ist notwendig, falls mehrere Threads gleichzeitig das Objekt benutzen.
         // Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
-		__declspec( dllexport ) void lock();
+        __declspec( dllexport ) void lock();
         // Dies ist notwendig, falls mehrere Threads gleichzeitig das Objekt benutzen.
         // Wenn lock() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlock() aufgerufen hat.
-		__declspec( dllexport ) void unlock();
+        __declspec( dllexport ) void unlock();
         // Setzt das Bildschirm Objekt, das verwaltet werden soll
         //  bildschirm: Der Bildschirm
-		__declspec( dllexport ) void setBildschirm( Bildschirm *bildschirm );
+        __declspec( dllexport ) void setBildschirm( Bildschirm *bildschirm );
         // Die Funktion, die automatisch in einem neuen Thread ausgeführt wird
-		__declspec( dllexport ) void thread() override;
+        __declspec( dllexport ) void thread() override;
         // Beginnt den Render Thread
-		__declspec( dllexport ) void beginn();
+        __declspec( dllexport ) void beginn();
         // Beendet den Render Thread
-		__declspec( dllexport ) void beenden();
+        __declspec( dllexport ) void beenden();
         // Setzt die maximalen Bilder pro Sekunde
         //  fps: maximale Bilder pro Sekunde
-		__declspec( dllexport ) void setMaxFps( int fps );
+        __declspec( dllexport ) void setMaxFps( int fps );
         // Pausiert den Render Thread
         //  p: 1, wenn der Thread pausiert werden soll
-		__declspec( dllexport ) void setPause( bool p );
+        __declspec( dllexport ) void setPause( bool p );
         // Setzt die Rückruffunktion, die immer vor dem Zeichnen aufgerufen wird
         //  rF: Die Rückruffunktion
-		__declspec( dllexport ) void setRenderFunktion( void ( *rF )( void *, void *, Bild * ) );
+        __declspec( dllexport ) void setRenderFunktion( void( *rF )( void *, void *, Bild * ) );
         // Setzt die Rückruffunktion, die immer vor dem Aktualisieren aller Objekte aufgerufen wird
         //  rF: Die Rückruffunktion
-		__declspec( dllexport ) void setTickFunktion( void ( *tF )( void *, void *, double ) );
+        __declspec( dllexport ) void setTickFunktion( void( *tF )( void *, void *, double ) );
         // Setzt den Parameter der Rückruffunktion, die immer vor dem Zeichnen aufgerufen wird
         //  p: Der Parameter
-		__declspec( dllexport ) void setRenderFunktionParameter( void *p );
+        __declspec( dllexport ) void setRenderFunktionParameter( void *p );
         // Setzt den Parameter der Rückruffunktion, die immer vor dem Aktualisieren aller Objekte aufgerufen wird
-		__declspec( dllexport ) void setTickFunktionParameter( void *p );
-		// Gibt den Bildschirm zurück, der von dem Thread verwaltet wird
-		__declspec( dllexport ) Bildschirm *getBildschirm() const;
+        __declspec( dllexport ) void setTickFunktionParameter( void *p );
+        // Gibt den Bildschirm zurück, der von dem Thread verwaltet wird
+        __declspec( dllexport ) Bildschirm *getBildschirm() const;
         // Gibt den Bildschirm ohne erhöhten Reference Counter zurück, der von dem Thread verwaltet wird
-		__declspec( dllexport ) Bildschirm *zBildschirm() const;
+        __declspec( dllexport ) Bildschirm *zBildschirm() const;
         // Gibt die Zeit zurück, mit der die tick() Funktion des Bildschirms als letztes aufgerufen wurde
-		__declspec( dllexport ) double getRenderTickZeit() const;
+        __declspec( dllexport ) double getRenderTickZeit() const;
         // Erhöht den Reference Counter um 1
         //  Return: Ein zeiger auf diesen Shader
-		__declspec( dllexport ) RenderTh *getThis();
+        __declspec( dllexport ) RenderTh *getThis();
         // Verringert den Reference Counter und löscht den Shader, falls der Refeence Counter auf 0 ist
         //  Return: 0
-		__declspec( dllexport ) RenderTh *release();
-	};
+        __declspec( dllexport ) RenderTh *release();
+    };
 }
 
 #endif

Schluessel.cpp

@@ -5,239 +5,236 @@ using namespace Framework::Verschl
 // Inhalt der Bytes Klasse aus Schlüssel.h
 // Konstruktor
 Bytes::Bytes()
-	: bytes( 0 ),
-	  del( 1 ),
-	  län( 0 ),
-	  ref( 1 )
-{
-}
+    : bytes( 0 ),
+    del( 1 ),
+    län( 0 ),
+    ref( 1 )
+{}
 
 Bytes::Bytes( int län )
-	: bytes( new char[ län ] ),
-	  del( 1 ),
-	  län( län ),
-	  ref( 1 )
-{
-}
+    : bytes( new char[ län ] ),
+    del( 1 ),
+    län( län ),
+    ref( 1 )
+{}
 
 Bytes::Bytes( const char *daten, int län )
-	: bytes( new char[ län ] ),
-	  del( 1 ),
-	  län( län ),
-	  ref( 1 )
+    : bytes( new char[ län ] ),
+    del( 1 ),
+    län( län ),
+    ref( 1 )
 {
-	setBytes( daten );
+    setBytes( daten );
 }
 
 // Destruktor
 Bytes::~Bytes()
 {
-	if( del )
-	    delete[] bytes;
+    if( del )
+        delete[] bytes;
 }
 
 // nicht constant
 void Bytes::setBytes( const char *daten )
 {
-	if( !bytes || !daten )
-		return;
-	char *end = bytes + län;
-	for( char *c = bytes; c < end; c++, ++daten )
-		*c = *daten;
+    if( !bytes || !daten )
+        return;
+    char *end = bytes + län;
+    for( char *c = bytes; c < end; c++, ++daten )
+        *c = *daten;
 }
 
 void Bytes::setBytes( const char *daten, int län )
 {
-	if( !daten || !län )
-		return;
-	if( del )
-	    delete[] bytes;
-	del = 1;
-	bytes = new char[ län ];
-	this->län = län;
-	setBytes( daten );
+    if( !daten || !län )
+        return;
+    if( del )
+        delete[] bytes;
+    del = 1;
+    bytes = new char[ län ];
+    this->län = län;
+    setBytes( daten );
 }
 
 void Bytes::setBytesZ( char *daten, int län )
 {
-	if( del )
-	    delete[] bytes;
-	del = 0;
-	bytes = daten;
-	this->län = län;
+    if( del )
+        delete[] bytes;
+    del = 0;
+    bytes = daten;
+    this->län = län;
 }
 
 void Bytes::füll( const char c )
 {
-	if( !bytes )
-		return;
-	char *end = bytes + län;
-	for( char *b = bytes; b < end; ++b )
-		*b = c;
+    if( !bytes )
+        return;
+    char *end = bytes + län;
+    for( char *b = bytes; b < end; ++b )
+        *b = c;
 }
 
 void Bytes::füll( const char c, int län )
 {
-	if( !bytes )
-		bytes = new char[ län ];
-	län = län > this->län ? this->län : län;
-	char *end = bytes + län;
-	for( char *b = bytes; b < end; ++b )
-		*b = c;
+    if( !bytes )
+        bytes = new char[ län ];
+    län = län > this->län ? this->län : län;
+    char *end = bytes + län;
+    for( char *b = bytes; b < end; ++b )
+        *b = c;
 }
 
 void Bytes::füll( const char c, int beg, int end )
 {
-	if( beg >= län )
-		return;
-	if( !bytes )
-		bytes = new char[ end - beg ];
-	end = end > this->län ? this->län : end;
-	char *endB = bytes + end;
-	for( char *b = bytes + beg; b < endB; ++b )
-		*b = c;
+    if( beg >= län )
+        return;
+    if( !bytes )
+        bytes = new char[ end - beg ];
+    end = end > this->län ? this->län : end;
+    char *endB = bytes + end;
+    for( char *b = bytes + beg; b < endB; ++b )
+        *b = c;
 }
 
 void Bytes::füll( const char *c, int cLän )
 {
-	if( !c || !cLän || !bytes )
-		return;
-	char *endB = bytes + län;
-	const char *endC = c + cLän;
-	const char *d = c;
-	for( char *b = bytes; b < endB; b++, d = d < endC - 1 ? d + 1 : c )
-		*b = *d;
+    if( !c || !cLän || !bytes )
+        return;
+    char *endB = bytes + län;
+    const char *endC = c + cLän;
+    const char *d = c;
+    for( char *b = bytes; b < endB; b++, d = d < endC - 1 ? d + 1 : c )
+        *b = *d;
 }
 
 void Bytes::set( const char c, int pos )
 {
-	if( !bytes || pos >= län )
-		return;
-	bytes[ pos ] = c;
+    if( !bytes || pos >= län )
+        return;
+    bytes[ pos ] = c;
 }
 
 // constant
 int Bytes::getLänge() const
 {
-	return län;
+    return län;
 }
 
 char *Bytes::getBytes() const
 {
-	return bytes;
+    return bytes;
 }
 
 // Reference Counting
 Bytes *Bytes::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Bytes *Bytes::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 // Inhalt der Schlüssel Klasse aus Schlüssel.h
 // Konstruktor
 Schlüssel::Schlüssel()
-	: schlüssel( 0 ),
-	  län( 0 ),
-	  pos( 0 ),
-	  ref( 1 )
-{
-}
+    : schlüssel( 0 ),
+    län( 0 ),
+    pos( 0 ),
+    ref( 1 )
+{}
 
 Schlüssel::Schlüssel( const char *s, int län )
-	: schlüssel( new unsigned char[ län ] ),
-	  län( län ),
-	  pos( 0 ),
-	  ref( 1 )
+    : schlüssel( new unsigned char[ län ] ),
+    län( län ),
+    pos( 0 ),
+    ref( 1 )
 {
-	for( int i = 0; i < län; ++i )
-		schlüssel[ i ] = s[ i ];
+    for( int i = 0; i < län; ++i )
+        schlüssel[ i ] = s[ i ];
 }
 
 // Destruktor
 Schlüssel::~Schlüssel()
 {
-	delete[] schlüssel;
+    delete[] schlüssel;
 }
 
 // nicht constant
 void Schlüssel::setPos( int p )
 {
-	if( p < 0 )
-		p = 0;
-	pos = p > län ? 0 : p;
+    if( p < 0 )
+        p = 0;
+    pos = p > län ? 0 : p;
 }
 
 void Schlüssel::setSchlüssel( const char *s, int län )
 {
-	delete[] schlüssel;
-	schlüssel = new unsigned char[ län ];
-	for( int i = 0; i < län; ++i )
-		schlüssel[ i ] = s[ i ];
-	pos = 0;
-	this->län = län;
+    delete[] schlüssel;
+    schlüssel = new unsigned char[ län ];
+    for( int i = 0; i < län; ++i )
+        schlüssel[ i ] = s[ i ];
+    pos = 0;
+    this->län = län;
 }
 
 void Schlüssel::codieren( Bytes *daten )
 {
-	if( !schlüssel || !län )
-	{
-		daten->release();
-		return;
-	}
-	int dLän = daten->getLänge();
-	char *bytes = daten->getBytes();
-	char *bEnd = bytes + dLän;
-	for( char *c = bytes; c < bEnd; ++c )
-	{
-		*c = *c + schlüssel[ pos ];
-		++pos;
-		if( pos >= län )
-			pos = 0;
-	}
-	daten->release();
+    if( !schlüssel || !län )
+    {
+        daten->release();
+        return;
+    }
+    int dLän = daten->getLänge();
+    char *bytes = daten->getBytes();
+    char *bEnd = bytes + dLän;
+    for( char *c = bytes; c < bEnd; ++c )
+    {
+        *c = *c + schlüssel[ pos ];
+        ++pos;
+        if( pos >= län )
+            pos = 0;
+    }
+    daten->release();
 }
 
 void Schlüssel::decodieren( Bytes *daten )
 {
-	if( !schlüssel || !län )
-	{
-		daten->release();
-		return;
-	}
-	int dLän = daten->getLänge();
-	char *bytes = daten->getBytes();
-	char *bEnd = bytes + dLän;
-	for( char *c = bytes; c < bEnd; ++c )
-	{
-		*c = *c - schlüssel[ pos ];
-		++pos;
-		if( pos >= län )
-			pos = 0;
-	}
-	daten->release();
+    if( !schlüssel || !län )
+    {
+        daten->release();
+        return;
+    }
+    int dLän = daten->getLänge();
+    char *bytes = daten->getBytes();
+    char *bEnd = bytes + dLän;
+    for( char *c = bytes; c < bEnd; ++c )
+    {
+        *c = *c - schlüssel[ pos ];
+        ++pos;
+        if( pos >= län )
+            pos = 0;
+    }
+    daten->release();
 }
 
 // Reference Counting
 Schlüssel *Schlüssel::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Schlüssel *Schlüssel::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Schluessel.h

@@ -5,116 +5,111 @@
 
 namespace Framework
 {
-	namespace Verschlüsselung
-	{
+    namespace Verschlüsselung
+    {
         // Speichert einen Array von bytes
-		class Bytes
-		{
-		private:
-			char *bytes;
-			bool del;
-			int län;
-			int ref;
+        class Bytes
+        {
+        private:
+            char *bytes;
+            bool del;
+            int län;
+            int ref;
 
-		public:
-			// Erzeugt einen lehren Byte Array
-			__declspec( dllexport ) Bytes();
+        public:
+            // Erzeugt einen lehren Byte Array
+            __declspec( dllexport ) Bytes();
             // Erzeugt einen neuen Byte Array mit bestimmter Länge
             //  län: Die Länge des Arrays
-			__declspec( dllexport ) Bytes( int län );
+            __declspec( dllexport ) Bytes( int län );
             // Erzeugt ein neuen Byte Array durch kopieren der bytes
             //  daten: Die Bytes, die kopiert werden sollen
             //  län: Die Anzahl der Bytes die kopiert werden sollen
-			__declspec( dllexport ) Bytes( const char *daten, int län );
-			// Löscht den Array
-			__declspec( dllexport ) ~Bytes();
-			
+            __declspec( dllexport ) Bytes( const char *daten, int län );
+            // Löscht den Array
+            __declspec( dllexport ) ~Bytes();
             // Befüllt den Bytearray durch kopieren der Bytes
             //  daten: Die Bytes, die kopiert werden sollen
-			__declspec( dllexport ) void setBytes( const char *daten );
+            __declspec( dllexport ) void setBytes( const char *daten );
             // Löscht den Array und erzeugt einen neuen
             //  daten: Die Bytes, die kopiert werden sollen
             //  län: Die nänge des Arrays
-			__declspec( dllexport ) void setBytes( const char *daten, int län );
+            __declspec( dllexport ) void setBytes( const char *daten, int län );
             // Löscht den Array und übernimmt den übergebenen ohne zu kopieren
             //  daten: Der neue Byte Array
             //  län: Die nänge des Arrays
-			__declspec( dllexport ) void setBytesZ( char *daten, int län );
+            __declspec( dllexport ) void setBytesZ( char *daten, int län );
             // Setzt alle Bytes des Arrays auf einen bestimmten Wert
             //  c: Der Wert, auf den die Bytes gesetzt werden sollen
-			__declspec( dllexport ) void füll( const char c );
+            __declspec( dllexport ) void füll( const char c );
             // Setzt eine bestimmte Anzahl von Bytes des Arrays auf einen bestimmten Wert
             //  c: Der Wert, auf den die Bytes gesetzt werden sollen
             //  län: Die Anzahl der Bytes die gesetzt werden sollen
-			__declspec( dllexport ) void füll( const char c, int län );
+            __declspec( dllexport ) void füll( const char c, int län );
             // Setzt einen bestimmte Abschnitt von Bytes des Arrays auf einen bestimmten Wert
             //  c: Der Wert, auf den die Bytes gesetzt werden sollen
             //  beg: Die Startposition des zu setzenden Abschnittes
             //  end: Die Endposition des zu setzenden Abschnittes (nicht enthalten)
-			__declspec( dllexport ) void füll( const char c, int beg, int end );
+            __declspec( dllexport ) void füll( const char c, int beg, int end );
             // Kopiert bestimmte bytes in den Array
             //  c: Die Bytes, die kopiert werden sollen
             //  cLän: Die Anzahl an Bytes, die gesetzt werden sollen
-			__declspec( dllexport ) void füll( const char *c, int cLän );
+            __declspec( dllexport ) void füll( const char *c, int cLän );
             // Setzt ein bestimmtes Byte auf einen Wert
             //  c: Der Wert, auf den das Byte gesetzt werden soll
             //  pos: Die Position des Bytes im Array
-			__declspec( dllexport ) void set( const char c, int pos );
-			
+            __declspec( dllexport ) void set( const char c, int pos );
             // Gibt die Länge des Arrays zurück
-			__declspec( dllexport ) int getLänge() const;
+            __declspec( dllexport ) int getLänge() const;
             // Gibt den Array von Bytes zurück
-			__declspec( dllexport ) char *getBytes() const;
-
+            __declspec( dllexport ) char *getBytes() const;
             // Erhöht den Reference Counting Zähler.
             //  return: this.
-			__declspec( dllexport ) Bytes *getThis();
+            __declspec( dllexport ) Bytes *getThis();
             // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
             //  return: 0.
-			__declspec( dllexport ) Bytes *release();
-		};
+            __declspec( dllexport ) Bytes *release();
+        };
 
         // Kann Bytesequenzen mit bestimmten Schlüsseln verschlüsseln und entschlüsseln
-		class Schlüssel
-		{
-		private:
-			unsigned char *schlüssel;
-			int län;
-			int pos;
-			int ref;
+        class Schlüssel
+        {
+        private:
+            unsigned char *schlüssel;
+            int län;
+            int pos;
+            int ref;
 
-		public:
-			// Erzeugt ein leeres Zeichnung
-			__declspec( dllexport ) Schlüssel();
+        public:
+            // Erzeugt ein leeres Zeichnung
+            __declspec( dllexport ) Schlüssel();
             // Erzeugt ein neues Zeichnung mi einem Schlüssel
             //  s: Der Schlüssel, der zum verschlüsseln und entchlüsseln verwendet werden soll
             //  län: Die Länge des Schlüssels
-			__declspec( dllexport ) Schlüssel( const char *s, int län );
-			// Löscht das Zeichnung
-			__declspec( dllexport ) ~Schlüssel();
-			
+            __declspec( dllexport ) Schlüssel( const char *s, int län );
+            // Löscht das Zeichnung
+            __declspec( dllexport ) ~Schlüssel();
             // Setzt die Position im Schlüssel, wo mit dem verschlüsseln und entschlüsseln begonnen werden soll
-			//  p: Die Position im Schlüssel
+            //  p: Die Position im Schlüssel
             __declspec( dllexport ) void setPos( int p );
             // Setzt den Schlüssel, der zum ver- und entschlüsseln verwendet werden soll
             //  s: Der Schlüssel
             //  län: Die Länge des Schlüssels
-			__declspec( dllexport ) void setSchlüssel( const char *s, int län );
+            __declspec( dllexport ) void setSchlüssel( const char *s, int län );
             // Verschlüsselt einen Byte Array mit dem gesetzten Schlüssel
             //  daten: Der Byte Array, der verschlüsselt werden soll. Wird von der Funktion verändert
-			__declspec( dllexport ) void codieren( Bytes *daten );
+            __declspec( dllexport ) void codieren( Bytes *daten );
             // Entschlüsselt einen Byte Array mit dem gesetzten Schlüssel
             //  daten: Der Byte Array, der entschlüsselt werden soll. Wird von der Funktion verändert
-			__declspec( dllexport ) void decodieren( Bytes *daten );
-			
+            __declspec( dllexport ) void decodieren( Bytes *daten );
             // Erhöht den Reference Counting Zähler.
             //  return: this.
-			__declspec( dllexport ) Schlüssel *getThis();
+            __declspec( dllexport ) Schlüssel *getThis();
             // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
             //  return: 0.
-			__declspec( dllexport ) Schlüssel *release();
-		};
-	}
+            __declspec( dllexport ) Schlüssel *release();
+        };
+    }
 }
 
 #endif

Schrift.cpp

@@ -11,546 +11,545 @@ using namespace Framework;
 // Inhalt der Buchstabe Klasse aus Schrift.h
 // Konstruktor 
 Buchstabe::Buchstabe()
-	: größe( 0, 0 ),
-	  pos( 0, 0 ),
-	  alpha( 0 ),
-	  schriftGröße( 0 ),
-	  drawSg( 0 ),
-	  ref( 1 )
-{
-}
+    : größe( 0, 0 ),
+    pos( 0, 0 ),
+    alpha( 0 ),
+    schriftGröße( 0 ),
+    drawSg( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor 
 Buchstabe::~Buchstabe()
 {
-	if( alpha )
-		delete[]alpha;
+    if( alpha )
+        delete[]alpha;
 }
 
 // nicht constant 
 void Buchstabe::NeuBuchstabe( Punkt &größe ) // Initialisierung
 {
-	this->größe = größe;
-	if( alpha )
-		delete[]alpha;
-	alpha = new unsigned char[ größe.x * größe.y ];
-	ZeroMemory( alpha, größe.x * größe.y );
+    this->größe = größe;
+    if( alpha )
+        delete[]alpha;
+    alpha = new unsigned char[ größe.x * größe.y ];
+    ZeroMemory( alpha, größe.x * größe.y );
 }
 
 void Buchstabe::setPixel( Punkt &pos, unsigned char alpha ) // setzt den alphawert des Pixels
 {
-	this->alpha[ pos.x + pos.y * größe.x ] = alpha;
+    this->alpha[ pos.x + pos.y * größe.x ] = alpha;
 }
 
 void Buchstabe::setPixel( int x, int y, unsigned char alpha )
 {
-	this->alpha[ x + y * größe.x ] = alpha;
+    this->alpha[ x + y * größe.x ] = alpha;
 }
 
 void Buchstabe::setPixel( int i, unsigned char alpha )
 {
-	this->alpha[ i ] = alpha;
+    this->alpha[ i ] = alpha;
 }
 
 void Buchstabe::setPosition( Punkt &pos ) // setzt die Buchstabenposition
 {
-	this->pos = pos;
+    this->pos = pos;
 }
 
 void Buchstabe::setPosition( int x, int y )
 {
-	pos.x = x;
-	pos.y = y;
+    pos.x = x;
+    pos.y = y;
 }
 
 void Buchstabe::setSchriftGröße( int sg ) // setzt die Schriftgröße des Buchstaben
 {
-	schriftGröße = sg;
+    schriftGröße = sg;
 }
 
 void Buchstabe::setDrawSchriftGröße( int dsg ) // setzt die Zeichengröße des Buchstaben
 {
-	drawSg = dsg;
+    drawSg = dsg;
 }
 
 // constant
 const Punkt &Buchstabe::getGröße() const // gibt die Buchstabenbildgröße zurück
 {
-	return größe;
+    return größe;
 }
 
 int Buchstabe::getBreite() const // Buchstabenbreite
 {
-	return (int)( ( (double)größe.x / (double)schriftGröße ) * (double)drawSg + 0.5 );
+    return (int)( ( (double)größe.x / (double)schriftGröße ) * (double)drawSg + 0.5 );
 }
 
 int Buchstabe::getHöhe() const // Buchstabenhöhe
 {
-	return (int)( ( (double)größe.y / (double)schriftGröße ) *(double)drawSg + 0.5 );
+    return (int)( ( (double)größe.y / (double)schriftGröße ) *(double)drawSg + 0.5 );
 }
 
 int Buchstabe::getNormHöhe() const // Buchstabenhöhe
 {
-	return größe.y;
+    return größe.y;
 }
 
 unsigned char *Buchstabe::getBuff() const // gibt den Alphabuffer zurück
 {
-	return alpha;
+    return alpha;
 }
 
 void Buchstabe::render( Bild &zRObj, int f ) const // Zeichnet nach zRObj
 {
-	if( alpha )
-	{
-		const Punkt &zRObjGr = zRObj.getDrawGr();
-		const Punkt &zRObjPos = zRObj.getDrawPos();
-		const Punkt &zRObjOff = zRObj.getDrawOff();
-		int xp = pos.x + zRObjOff.x, yp = pos.y + zRObjOff.y;
-		int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
-		int b = größe.x, h = größe.y;
-		unsigned char a2 = ( 255 - ( f >> 24 ) );
-		f &= 0x00FFFFFF;
-		if( schriftGröße == drawSg )
-		{
-			if( xp >= zRObjGr.x || yp >= zRObjGr.y || xp + b < zRObjPos.x || yp + h < zRObjPos.y )
-				return;
-			b = ( xp + b ) > zRObjGr.x ? ( zRObjGr.x - xp ) : b;
-			h = ( yp + h ) > zRObjGr.y ? ( zRObjGr.y - yp ) : h;
-			if( !a2 )
-			{
-				int xx, ygr = ( ys - 1 ) * größe.x, ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
-				for( int yy = ys; yy < h; ++yy )
-				{
-					ygr += größe.x;
-					ygr2 += zRObj.getBreite();
-					for( xx = xs; xx < b; ++xx )
-						zRObj.alphaPixel( xp + xx + ygr2, f | ( alpha[ xx + ygr ] << 24 ) );
-				}
-			}
-			else
-			{
-				int a;
-				int xx, ygr = ( ys - 1 ) * größe.x, ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
-				for( int yy = ys; yy < h; ++yy )
-				{
-					ygr += größe.x;
-					ygr2 += zRObj.getBreite();
-					for( xx = xs; xx < b; ++xx )
-					{
-						a = alpha[ xx + ygr ] - a2;
-						if( a > 0 )
-							zRObj.alphaPixel( xp + xx + ygr2, f | ( a << 24 ) );
-					}
-				}
-			}
-		}
-		else
-		{
-			double xoff = (double)schriftGröße / (double)drawSg,
-				yoff = (double)schriftGröße / (double)drawSg;
-			double x = xs * xoff, y = ys * yoff;
-			int maxX = getBreite(), maxY = getHöhe();
-			maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
-			maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
-			if( !a2 )
-			{
-				int dx, ygr, ygr2;
-				for( int dy = ys; dy < maxY; ++dy )
-				{
-					ygr2 = ( yp + dy ) * zRObj.getBreite();
-					ygr = (int)y * b;
-					for( dx = xs; dx < maxX; ++dx )
-					{
-						zRObj.alphaPixel( xp + dx + ygr2, f | ( alpha[ (int)x + ygr ] << 24 ) );
-						x += xoff;
-					}
-					x = xs;
-					y += yoff;
-				}
-			}
-			else
-			{
-				int a, dx, ygr, ygr2;
-				for( int dy = ys; dy < maxY; ++dy )
-				{
-					ygr2 = ( yp + dy ) * zRObj.getBreite();
-					ygr = (int)y * b;
-					for( dx = xs; dx < maxX; ++dx )
-					{
-						a = alpha[ (int)x + ygr ] - a2;
-						zRObj.alphaPixel( xp + dx + ygr2, f | ( a << 24 ) );
-						x += xoff;
-					}
-					x = xs;
-					y += yoff;
-				}
-			}
-		}
-	}
+    if( alpha )
+    {
+        const Punkt &zRObjGr = zRObj.getDrawGr();
+        const Punkt &zRObjPos = zRObj.getDrawPos();
+        const Punkt &zRObjOff = zRObj.getDrawOff();
+        int xp = pos.x + zRObjOff.x, yp = pos.y + zRObjOff.y;
+        int xs = xp < zRObjPos.x ? ( zRObjPos.x - xp ) : 0, ys = yp < zRObjPos.y ? ( zRObjPos.y - yp ) : 0;
+        int b = größe.x, h = größe.y;
+        unsigned char a2 = ( 255 - ( f >> 24 ) );
+        f &= 0x00FFFFFF;
+        if( schriftGröße == drawSg )
+        {
+            if( xp >= zRObjGr.x || yp >= zRObjGr.y || xp + b < zRObjPos.x || yp + h < zRObjPos.y )
+                return;
+            b = ( xp + b ) > zRObjGr.x ? ( zRObjGr.x - xp ) : b;
+            h = ( yp + h ) > zRObjGr.y ? ( zRObjGr.y - yp ) : h;
+            if( !a2 )
+            {
+                int xx, ygr = ( ys - 1 ) * größe.x, ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
+                for( int yy = ys; yy < h; ++yy )
+                {
+                    ygr += größe.x;
+                    ygr2 += zRObj.getBreite();
+                    for( xx = xs; xx < b; ++xx )
+                        zRObj.alphaPixel( xp + xx + ygr2, f | ( alpha[ xx + ygr ] << 24 ) );
+                }
+            }
+            else
+            {
+                int a;
+                int xx, ygr = ( ys - 1 ) * größe.x, ygr2 = ( yp + ys - 1 ) * zRObj.getBreite();
+                for( int yy = ys; yy < h; ++yy )
+                {
+                    ygr += größe.x;
+                    ygr2 += zRObj.getBreite();
+                    for( xx = xs; xx < b; ++xx )
+                    {
+                        a = alpha[ xx + ygr ] - a2;
+                        if( a > 0 )
+                            zRObj.alphaPixel( xp + xx + ygr2, f | ( a << 24 ) );
+                    }
+                }
+            }
+        }
+        else
+        {
+            double xoff = (double)schriftGröße / (double)drawSg,
+                yoff = (double)schriftGröße / (double)drawSg;
+            double x = xs * xoff, y = ys * yoff;
+            int maxX = getBreite(), maxY = getHöhe();
+            maxX = ( xp + maxX ) >= zRObjGr.x ? ( zRObjGr.x - xp ) : maxX;
+            maxY = ( yp + maxY ) >= zRObjGr.y ? ( zRObjGr.y - yp ) : maxY;
+            if( !a2 )
+            {
+                int dx, ygr, ygr2;
+                for( int dy = ys; dy < maxY; ++dy )
+                {
+                    ygr2 = ( yp + dy ) * zRObj.getBreite();
+                    ygr = (int)y * b;
+                    for( dx = xs; dx < maxX; ++dx )
+                    {
+                        zRObj.alphaPixel( xp + dx + ygr2, f | ( alpha[ (int)x + ygr ] << 24 ) );
+                        x += xoff;
+                    }
+                    x = xs;
+                    y += yoff;
+                }
+            }
+            else
+            {
+                int a, dx, ygr, ygr2;
+                for( int dy = ys; dy < maxY; ++dy )
+                {
+                    ygr2 = ( yp + dy ) * zRObj.getBreite();
+                    ygr = (int)y * b;
+                    for( dx = xs; dx < maxX; ++dx )
+                    {
+                        a = alpha[ (int)x + ygr ] - a2;
+                        zRObj.alphaPixel( xp + dx + ygr2, f | ( a << 24 ) );
+                        x += xoff;
+                    }
+                    x = xs;
+                    y += yoff;
+                }
+            }
+        }
+    }
 }
 
 // Reference Counting 
 Buchstabe *Buchstabe::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Buchstabe *Buchstabe::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der Alphabet Klasse aus Schrift.h
 // Konstruktor 
 Alphabet::Alphabet()
-	: zeichen( new Buchstabe*[ 256 ] ),
-	  schriftGröße( 12 ),
-	  drawSchriftGröße( 12 ),
-	  pos( 0, 0 ),
-	  zeilenHöhe( 0 ),
-	  zeilenAbstand( 5 ),
-	  ref( 1 )
+    : zeichen( new Buchstabe*[ 256 ] ),
+    schriftGröße( 12 ),
+    drawSchriftGröße( 12 ),
+    pos( 0, 0 ),
+    zeilenHöhe( 0 ),
+    zeilenAbstand( 5 ),
+    ref( 1 )
 {
-	for( int i = 0; i < 256; ++i )
-		zeichen[ i ] = 0;
+    for( int i = 0; i < 256; ++i )
+        zeichen[ i ] = 0;
 }
 
 // Destruktor 
 Alphabet::~Alphabet()
 {
-	for( int i = 0; i < 256; ++i )
-	{
-		if( zeichen[ i ] )
-			zeichen[ i ]->release();
-	}
-	delete[]zeichen;
+    for( int i = 0; i < 256; ++i )
+    {
+        if( zeichen[ i ] )
+            zeichen[ i ]->release();
+    }
+    delete[]zeichen;
 }
 
 // nicht constant 
 void Alphabet::NeuAlphabet() // Initialisierung 
 {
-	for( int i = 0; i < 256; ++i )
-	{
-		if( zeichen[ i ] )
-			zeichen[ i ]->release();
-	}
-	for( int i = 0; i < 256; ++i )
-		zeichen[ i ] = 0;
-	zeilenHöhe = 0;
+    for( int i = 0; i < 256; ++i )
+    {
+        if( zeichen[ i ] )
+            zeichen[ i ]->release();
+    }
+    for( int i = 0; i < 256; ++i )
+        zeichen[ i ] = 0;
+    zeilenHöhe = 0;
 }
 
 void Alphabet::setBuchstabe( unsigned char i, Buchstabe *buchstabe ) // setzt einen Buchstaben
 {
-	if( zeichen[ i ] )
-		zeichen[ i ]->release();
-	zeichen[ i ] = buchstabe;
-	if( zeichen[ i ] )
-	{
-		zeichen[ i ]->setSchriftGröße( schriftGröße );
-		zeichen[ i ]->setDrawSchriftGröße( drawSchriftGröße );
-	}
-	zeilenHöhe = 0;
-	for( int i = 0; i < 256; ++i )
-	{
-		if( zeichen[ i ] != 0 )
-			zeilenHöhe = maxInt( zeichen[ i ]->getHöhe(), zeilenHöhe );
-	}
+    if( zeichen[ i ] )
+        zeichen[ i ]->release();
+    zeichen[ i ] = buchstabe;
+    if( zeichen[ i ] )
+    {
+        zeichen[ i ]->setSchriftGröße( schriftGröße );
+        zeichen[ i ]->setDrawSchriftGröße( drawSchriftGröße );
+    }
+    zeilenHöhe = 0;
+    for( int i = 0; i < 256; ++i )
+    {
+        if( zeichen[ i ] != 0 )
+            zeilenHöhe = maxInt( zeichen[ i ]->getHöhe(), zeilenHöhe );
+    }
 }
 
 void Alphabet::setSchriftgröße( int gr ) // setzt die Schriftgröße
 {
-	schriftGröße = gr;
-	for( int i = 0; i < 256; ++i )
-	{
-		if( zeichen[ i ] )
-			zeichen[ i ]->setSchriftGröße( gr );
-	}
+    schriftGröße = gr;
+    for( int i = 0; i < 256; ++i )
+    {
+        if( zeichen[ i ] )
+            zeichen[ i ]->setSchriftGröße( gr );
+    }
 }
 
 void Alphabet::setDrawSchriftgröße( int gr ) // setzt die Zeichengröße
 {
-	drawSchriftGröße = gr;
-	for( int i = 0; i < 256; ++i )
-	{
-		if( zeichen[ i ] )
-			zeichen[ i ]->setDrawSchriftGröße( gr );
-	}
+    drawSchriftGröße = gr;
+    for( int i = 0; i < 256; ++i )
+    {
+        if( zeichen[ i ] )
+            zeichen[ i ]->setDrawSchriftGröße( gr );
+    }
 }
 
 void Alphabet::setZeilenAbstand( int za ) // setzt die Zeilenhöhe( Zeilenabstand )
 {
-	zeilenAbstand = za;
+    zeilenAbstand = za;
 }
 
 void Alphabet::setDrawPosition( Punkt &pos ) // setzt die Draw Position
 {
-	this->pos = pos;
+    this->pos = pos;
 }
 
 void Alphabet::setDrawPosition( int x, int y )
 {
-	pos.x = x;
-	pos.y = y;
+    pos.x = x;
+    pos.y = y;
 }
 
 // constant 
 Buchstabe *Alphabet::getBuchstabe( unsigned char i ) const // gibt einen Buchstaben zurück
 {
-	if( zeichen[ i ] )
-		return zeichen[ i ]->getThis();
-	return 0;
+    if( zeichen[ i ] )
+        return zeichen[ i ]->getThis();
+    return 0;
 }
 
 Buchstabe *Alphabet::zBuchstabe( unsigned char i ) const
 {
-	return zeichen[ i ];
+    return zeichen[ i ];
 }
 
 bool Alphabet::hatBuchstabe( unsigned char b ) const
 {
-	return zeichen[ b ] != 0;
+    return zeichen[ b ] != 0;
 }
 
 int Alphabet::getSchriftgröße() const // gibt die Schriftgröße zurück
 {
-	return schriftGröße;
+    return schriftGröße;
 }
 
 int Alphabet::getDrawSchriftGröße() const // gibt die Zeichengröße zurück
 {
-	return drawSchriftGröße;
+    return drawSchriftGröße;
 }
 
 int Alphabet::getZeilenAbstand() const // gibt den Zeilenabstand zurück
 {
-	return zeilenAbstand;
+    return zeilenAbstand;
 }
 
 int Alphabet::getZeilenHöhe() const // gibt die Höhe des höchsten Zeichens zurück
 {
-	return (int)( (double)zeilenHöhe / schriftGröße * drawSchriftGröße + 0.5 );
+    return (int)( (double)zeilenHöhe / schriftGröße * drawSchriftGröße + 0.5 );
 }
 
 const Punkt &Alphabet::getPosition() const // gibt die DrawPosition zurück
 {
-	return pos;
+    return pos;
 }
 
 int Alphabet::getTextBreite( Text *zTxt ) const // gibt die Breite des Textes zurück
 {
-	int ret = 0;
-	int län = zTxt->getLänge();
-	char *buff = zTxt->getText();
-	unsigned char c = 0;
-	int tmp = 0;
-	for( int i = 0; i < län; ++i )
-	{
-		c = (unsigned char)buff[ i ];
-		if( buff[ i ] == '\n' )
-		{
-			if( tmp > ret )
-				ret = tmp;
-			tmp = 0;
-		}
-		else if( buff[ i ] == '\r' )
-		{
-			i += 10;
-			continue;
-		}
+    int ret = 0;
+    int län = zTxt->getLänge();
+    char *buff = zTxt->getText();
+    unsigned char c = 0;
+    int tmp = 0;
+    for( int i = 0; i < län; ++i )
+    {
+        c = (unsigned char)buff[ i ];
+        if( buff[ i ] == '\n' )
+        {
+            if( tmp > ret )
+                ret = tmp;
+            tmp = 0;
+        }
+        else if( buff[ i ] == '\r' )
+        {
+            i += 10;
+            continue;
+        }
         else if( buff[ i ] == '\t' )
             tmp += drawSchriftGröße;
-		else if( buff[ i ] == ' ' )
-			tmp += drawSchriftGröße / 2;
-		else if( zeichen[ c ] )
-			tmp += zeichen[ c ]->getBreite();
-	}
-	if( tmp > ret )
-		ret = tmp;
-	return ret;
+        else if( buff[ i ] == ' ' )
+            tmp += drawSchriftGröße / 2;
+        else if( zeichen[ c ] )
+            tmp += zeichen[ c ]->getBreite();
+    }
+    if( tmp > ret )
+        ret = tmp;
+    return ret;
 }
 
 int Alphabet::getTextHöhe( Text *zTxt ) const // gibt die Höhe des Textes zurück
 {
-	int hö = getZeilenHöhe();
-	return hö + ( ( hö + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) );
+    int hö = getZeilenHöhe();
+    return hö + ( ( hö + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) );
 }
 
 int Alphabet::textPos( Text *zText, int mausX, int mausY ) const // gibt den Buchstaben zurück, auf den die Maus zeigt
 {
-	char *buffer = zText->getText();
-	int län = zText->getLänge();
-	int tx = 0;
-	int ty = 0;
-	int sh = getZeilenHöhe();
-	if( mausX < 0 || mausY < 0 )
-		return -1;
-	for( int i = 0; i < län; ++i )
-	{
-		if( buffer[ i ] == '\n' )
-		{
-			ty += sh + zeilenAbstand;
-			tx = 0;
-			if( mausY < ty )
-				return i;
-		}
+    char *buffer = zText->getText();
+    int län = zText->getLänge();
+    int tx = 0;
+    int ty = 0;
+    int sh = getZeilenHöhe();
+    if( mausX < 0 || mausY < 0 )
+        return -1;
+    for( int i = 0; i < län; ++i )
+    {
+        if( buffer[ i ] == '\n' )
+        {
+            ty += sh + zeilenAbstand;
+            tx = 0;
+            if( mausY < ty )
+                return i;
+        }
         if( buffer[ i ] == '\t' )
             tx += drawSchriftGröße;
-		if( buffer[ i ] == ' ' )
-			tx += drawSchriftGröße / 2;
-		if( zeichen[ (unsigned char)buffer[ i ] ] )
-			tx += zeichen[ (unsigned char)buffer[ i ] ]->getBreite();
-		int txpl = 0;
-		if( zeichen[ (unsigned char)buffer[ i + 1 ] ] )
-			txpl = zeichen[ (unsigned char)buffer[ i + 1 ] ]->getBreite() / 2;
-		if( mausX < tx - txpl && mausY < ty + sh + zeilenAbstand )
-			return i;
-	}
-	if( mausY < ty + sh + zeilenAbstand )
-		return län;
-	return -1;
+        if( buffer[ i ] == ' ' )
+            tx += drawSchriftGröße / 2;
+        if( zeichen[ (unsigned char)buffer[ i ] ] )
+            tx += zeichen[ (unsigned char)buffer[ i ] ]->getBreite();
+        int txpl = 0;
+        if( zeichen[ (unsigned char)buffer[ i + 1 ] ] )
+            txpl = zeichen[ (unsigned char)buffer[ i + 1 ] ]->getBreite() / 2;
+        if( mausX < tx - txpl && mausY < ty + sh + zeilenAbstand )
+            return i;
+    }
+    if( mausY < ty + sh + zeilenAbstand )
+        return län;
+    return -1;
 }
 
 void Alphabet::textFormatieren( Text *zText, int maxBreite, int schriftGröße ) // fügt zeilenumbrüche ein 
 {
-	int sg = drawSchriftGröße;
-	setDrawSchriftgröße( schriftGröße );
-	int zeilenHöhe = getZeilenHöhe() + getZeilenAbstand();
-	int lastPos = -1;
-	int län = zText->getLänge();
-	char *txt = zText->getText();
-	int x = 0;
-	Text result = zText->getText();
-	for( int i = 0; i < län; ++i )
-	{
-		char c = txt[ i ];
-		if( c == ' ' )
-		{
-			lastPos = i;
-			x += schriftGröße / 2;
-			continue;
-		}
+    int sg = drawSchriftGröße;
+    setDrawSchriftgröße( schriftGröße );
+    int zeilenHöhe = getZeilenHöhe() + getZeilenAbstand();
+    int lastPos = -1;
+    int län = zText->getLänge();
+    char *txt = zText->getText();
+    int x = 0;
+    Text result = zText->getText();
+    for( int i = 0; i < län; ++i )
+    {
+        char c = txt[ i ];
+        if( c == ' ' )
+        {
+            lastPos = i;
+            x += schriftGröße / 2;
+            continue;
+        }
         if( c == '\t' )
         {
             lastPos = i;
             x += schriftGröße;
             continue;
         }
-		if( c == '\n' )
-		{
-			x = 0;
-			lastPos = -1;
-			continue;
-		}
-		if( c == '\r' && län - i >= 11 )
-		{
-			i += 10;
-			continue;
-		}
-		Buchstabe *b = getBuchstabe( (unsigned)c );
-		if( b )
-		{
-			x += b->getBreite();
-			if( x > maxBreite && lastPos > -1 )
-			{
-				result.ersetzen( lastPos, lastPos + 1, "\n" );
-				x = 0;
-				i = lastPos;
-				lastPos = -1;
-			}
-			b = b->release();
-		}
-	}
-	zText->setText( result );
-	setDrawSchriftgröße( sg );
+        if( c == '\n' )
+        {
+            x = 0;
+            lastPos = -1;
+            continue;
+        }
+        if( c == '\r' && län - i >= 11 )
+        {
+            i += 10;
+            continue;
+        }
+        Buchstabe *b = getBuchstabe( (unsigned)c );
+        if( b )
+        {
+            x += b->getBreite();
+            if( x > maxBreite && lastPos > -1 )
+            {
+                result.ersetzen( lastPos, lastPos + 1, "\n" );
+                x = 0;
+                i = lastPos;
+                lastPos = -1;
+            }
+            b = b->release();
+        }
+    }
+    zText->setText( result );
+    setDrawSchriftgröße( sg );
 }
 
 void Alphabet::render( Text *zTxt, Bild &rendezRObj, int f ) const // Zeichnet txt nach rendezRObj
 {
-	int zRObjBr = rendezRObj.getBreite();
-	int zRObjHö = rendezRObj.getHöhe();
-	int xp = pos.x;
-	int yp = pos.y;
-	int zh = getZeilenHöhe();
-	if( yp + ( zh + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) + zh < 0 || xp >= zRObjBr || yp >= zRObjHö )
-		return;
-	char *text = zTxt->getText();
-	int län = zTxt->getLänge();
-	for( int i = 0; i < län; ++i )
-	{
-		unsigned char c = text[ i ];
-		if( c == ' ' )
-		{
-			xp += drawSchriftGröße / 2;
-			continue;
-		}
+    int zRObjBr = rendezRObj.getBreite();
+    int zRObjHö = rendezRObj.getHöhe();
+    int xp = pos.x;
+    int yp = pos.y;
+    int zh = getZeilenHöhe();
+    if( yp + ( zh + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) + zh < 0 || xp >= zRObjBr || yp >= zRObjHö )
+        return;
+    char *text = zTxt->getText();
+    int län = zTxt->getLänge();
+    for( int i = 0; i < län; ++i )
+    {
+        unsigned char c = text[ i ];
+        if( c == ' ' )
+        {
+            xp += drawSchriftGröße / 2;
+            continue;
+        }
         if( c == '\t' )
         {
             xp += drawSchriftGröße;
             continue;
         }
-		if( c == '\n' )
-		{
-			yp += zh + zeilenAbstand;
-			xp = pos.x;
-			continue;
-		}
-		if( c == '\r' && län - i >= 11 )
-		{
-			i += 3;
-			Text *hex1 = zTxt->getTeilText( i, i + 6 );
-			Text *hex2 = zTxt->getTeilText( i + 6, i + 8 );
-			f = ( TextZuInt( hex1->getText(), 16 ) << 8 ) |
-				( TextZuInt( hex2->getText(), 16 ) );
-			hex1->release();
-			hex2->release();
-			i += 7;
-			continue;
-		}
-		if( zeichen[ c ] )
-		{
-			if( xp >= zRObjBr )
-				continue;
-			zeichen[ c ]->setPosition( xp, yp );
-			zeichen[ c ]->render( rendezRObj, f );
-			xp += zeichen[ c ]->getBreite();
-		}
-	}
+        if( c == '\n' )
+        {
+            yp += zh + zeilenAbstand;
+            xp = pos.x;
+            continue;
+        }
+        if( c == '\r' && län - i >= 11 )
+        {
+            i += 3;
+            Text *hex1 = zTxt->getTeilText( i, i + 6 );
+            Text *hex2 = zTxt->getTeilText( i + 6, i + 8 );
+            f = ( TextZuInt( hex1->getText(), 16 ) << 8 ) |
+                ( TextZuInt( hex2->getText(), 16 ) );
+            hex1->release();
+            hex2->release();
+            i += 7;
+            continue;
+        }
+        if( zeichen[ c ] )
+        {
+            if( xp >= zRObjBr )
+                continue;
+            zeichen[ c ]->setPosition( xp, yp );
+            zeichen[ c ]->render( rendezRObj, f );
+            xp += zeichen[ c ]->getBreite();
+        }
+    }
 }
 
 void Alphabet::render( Text *zTxt, Bild &rendezRObj, int cpos, int cf, int fbeg, int ff, int f ) const
 {
-	int zRObjBr = rendezRObj.getBreite();
-	int zRObjHö = rendezRObj.getHöhe();
-	int xp = pos.x;
-	int yp = pos.y;
-	int zh = getZeilenHöhe();
-	if( yp + ( zh + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) + zh < 0 || xp >= zRObjBr || yp >= zRObjHö )
-		return;
-	char *text = zTxt->getText();
-	int län = zTxt->getLänge();
-	bool färb = 0;
-	for( int i = 0; i < län; ++i )
-	{
-		unsigned char c = text[ i ];
-		if( i == fbeg )
-			färb = !färb;
-		if( i == cpos )
-		{
-			rendezRObj.drawLinieVAlpha( xp, yp, zh, cf );
-			färb = !färb;
-		}
-		if( c == ' ' )
-		{
-			if( färb )
-				rendezRObj.alphaRegion( xp, yp, drawSchriftGröße / 2, zh, ff );
-			xp += drawSchriftGröße / 2;
-			continue;
-		}
+    int zRObjBr = rendezRObj.getBreite();
+    int zRObjHö = rendezRObj.getHöhe();
+    int xp = pos.x;
+    int yp = pos.y;
+    int zh = getZeilenHöhe();
+    if( yp + ( zh + zeilenAbstand ) * zTxt->anzahlVon( '\n' ) + zh < 0 || xp >= zRObjBr || yp >= zRObjHö )
+        return;
+    char *text = zTxt->getText();
+    int län = zTxt->getLänge();
+    bool färb = 0;
+    for( int i = 0; i < län; ++i )
+    {
+        unsigned char c = text[ i ];
+        if( i == fbeg )
+            färb = !färb;
+        if( i == cpos )
+        {
+            rendezRObj.drawLinieVAlpha( xp, yp, zh, cf );
+            färb = !färb;
+        }
+        if( c == ' ' )
+        {
+            if( färb )
+                rendezRObj.alphaRegion( xp, yp, drawSchriftGröße / 2, zh, ff );
+            xp += drawSchriftGröße / 2;
+            continue;
+        }
         if( c == '\t' )
         {
             if( färb )
@@ -558,215 +557,214 @@ void Alphabet::render( Text *zTxt, Bild &rendezRObj, int cpos, int cf, int fbeg,
             xp += drawSchriftGröße;
             continue;
         }
-		if( c == '\n' )
-		{
-			yp += zh + zeilenAbstand;
-			xp = pos.x;
-			continue;
-		}
-		if( c == '\r' && län - i >= 11 )
-		{
-			i += 3;
-			Text *hex1 = zTxt->getTeilText( i, i + 6 );
-			Text *hex2 = zTxt->getTeilText( i + 6, i + 8 );
-			f = ( TextZuInt( hex1->getText(), 16 ) << 8 ) |
-				( TextZuInt( hex2->getText(), 16 ) );
-			hex1->release();
-			hex2->release();
-			i += 7;
-			continue;
-		}
-		if( zeichen[ c ] )
-		{
-			if( xp >= zRObjBr )
-				continue;
-			if( färb )
-			{
-				int br = zeichen[ c ]->getBreite();
-				rendezRObj.alphaRegion( xp, yp, br, zh, ff );
-			}
-			zeichen[ c ]->setPosition( xp, yp );
-			zeichen[ c ]->render( rendezRObj, f );
-			xp += zeichen[ c ]->getBreite();
-		}
-	}
-	if( län == cpos )
-		rendezRObj.drawLinieVAlpha( xp, yp, zh, cf );
+        if( c == '\n' )
+        {
+            yp += zh + zeilenAbstand;
+            xp = pos.x;
+            continue;
+        }
+        if( c == '\r' && län - i >= 11 )
+        {
+            i += 3;
+            Text *hex1 = zTxt->getTeilText( i, i + 6 );
+            Text *hex2 = zTxt->getTeilText( i + 6, i + 8 );
+            f = ( TextZuInt( hex1->getText(), 16 ) << 8 ) |
+                ( TextZuInt( hex2->getText(), 16 ) );
+            hex1->release();
+            hex2->release();
+            i += 7;
+            continue;
+        }
+        if( zeichen[ c ] )
+        {
+            if( xp >= zRObjBr )
+                continue;
+            if( färb )
+            {
+                int br = zeichen[ c ]->getBreite();
+                rendezRObj.alphaRegion( xp, yp, br, zh, ff );
+            }
+            zeichen[ c ]->setPosition( xp, yp );
+            zeichen[ c ]->render( rendezRObj, f );
+            xp += zeichen[ c ]->getBreite();
+        }
+    }
+    if( län == cpos )
+        rendezRObj.drawLinieVAlpha( xp, yp, zh, cf );
 }
 
 // Reference Counting 
 Alphabet *Alphabet::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Alphabet *Alphabet::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der AlphabetArray Klasse aus Schrift.h
 // Konstruktor 
 AlphabetArray::AlphabetArray()
-	: next( 0 ),
-	  This( 0 )
-{
-}
+    : next( 0 ),
+    This( 0 )
+{}
 
 // Destruktor 
 AlphabetArray::~AlphabetArray()
 {
-	if( This )
-		This->release();
-	delete next;
+    if( This )
+        This->release();
+    delete next;
 }
 
 // nicht constant 
 bool AlphabetArray::addAlphabet( Alphabet *alphabet ) // Fügt ein Alphabet hinzu
 {
-	if( This )
-	{
-		if( This->getSchriftgröße() == alphabet->getSchriftgröße() )
-		{
-			alphabet->release();
-			return false;
-		}
-	}
-	else
-	{
-		This = alphabet;
-		return true;
-	}
-	if( !next )
-		next = new AlphabetArray();
-	return next->addAlphabet( alphabet );
+    if( This )
+    {
+        if( This->getSchriftgröße() == alphabet->getSchriftgröße() )
+        {
+            alphabet->release();
+            return false;
+        }
+    }
+    else
+    {
+        This = alphabet;
+        return true;
+    }
+    if( !next )
+        next = new AlphabetArray();
+    return next->addAlphabet( alphabet );
 }
 
 bool AlphabetArray::removeAlphabet( int sg ) // entfernt ein Alphabet
 {
-	if( This )
-	{
-		if( This->getSchriftgröße() == sg )
-			This = This->release();
-		return 1;
-	}
-	if( !next )
-		return 0;
-	if( next->removeAlphabet( sg ) )
-	{
-		AlphabetArray *tmp = next->getNext();
-		next->setNext0();
-		delete next;
-		next = tmp;
-	}
-	return 0;
+    if( This )
+    {
+        if( This->getSchriftgröße() == sg )
+            This = This->release();
+        return 1;
+    }
+    if( !next )
+        return 0;
+    if( next->removeAlphabet( sg ) )
+    {
+        AlphabetArray *tmp = next->getNext();
+        next->setNext0();
+        delete next;
+        next = tmp;
+    }
+    return 0;
 }
 
 void AlphabetArray::setDrawSchriftGröße( int sg ) // Setzt die Draw Schriftgröße aller Alphabete
 {
-	if( This )
-		This->setDrawSchriftgröße( sg );
-	if( next )
-		next->setDrawSchriftGröße( sg );
+    if( This )
+        This->setDrawSchriftgröße( sg );
+    if( next )
+        next->setDrawSchriftGröße( sg );
 }
 
 void AlphabetArray::setZeilenAbstand( int za ) // setzt den Zeilenabstant aller Alphabete
 {
-	if( This )
-		This->setZeilenAbstand( za );
-	if( next )
-		next->setZeilenAbstand( za );
+    if( This )
+        This->setZeilenAbstand( za );
+    if( next )
+        next->setZeilenAbstand( za );
 }
 
 void AlphabetArray::setNext0() // setzt den next Zeiger zu 0
 {
-	next = 0;
+    next = 0;
 }
 
 // constant 
 Alphabet *AlphabetArray::getAlphabet( unsigned char sg ) const // gibt getThis von einem Alphabet zurück
 {
-	if( !This )
-		return 0;
-	if( This->getSchriftgröße() == sg )
-		return This->getThis();
-	if( next )
-		return next->getAlphabet( sg );
-	return 0;
+    if( !This )
+        return 0;
+    if( This->getSchriftgröße() == sg )
+        return This->getThis();
+    if( next )
+        return next->getAlphabet( sg );
+    return 0;
 }
 
 Alphabet *AlphabetArray::zAlphabet( unsigned char sg ) const // gibt ein Alphabet zurück
 {
-	if( !This )
-		return 0;
-	if( This->getSchriftgröße() == sg )
-		return This;
-	if( next )
-		return next->zAlphabet( sg );
-	return 0;
+    if( !This )
+        return 0;
+    if( This->getSchriftgröße() == sg )
+        return This;
+    if( next )
+        return next->zAlphabet( sg );
+    return 0;
 }
 
 Alphabet *AlphabetArray::getAlphabetI( int index, int count ) const
 {
-	if( count == index )
-		return This->getThis();
-	if( next )
-		return next->getAlphabetI( index, count + 1 );
-	return 0;
+    if( count == index )
+        return This->getThis();
+    if( next )
+        return next->getAlphabetI( index, count + 1 );
+    return 0;
 }
 
 Alphabet *AlphabetArray::zAlphabetI( int index, int count ) const
 {
-	if( count == index )
-		return This;
-	if( next )
-		return next->zAlphabetI( index, count + 1 );
-	return 0;
+    if( count == index )
+        return This;
+    if( next )
+        return next->zAlphabetI( index, count + 1 );
+    return 0;
 }
 
 AlphabetArray *AlphabetArray::getNext() const // gibt das nächste Alphabet zurück
 {
-	return next;
+    return next;
 }
 
 // Inhalt der Schrift Klasse aus Schrift.h
 // Konstruktor 
 Schrift::Schrift()
-	: alphabetAnzahl( 0 ),
-	  alphabet( new AlphabetArray() ),
-	  schriftGröße( 12 ),
-	  zeilenAbstand( 5 ),
-	  drawPos( 0, 0 ),
-	  ref( 1 )
+    : alphabetAnzahl( 0 ),
+    alphabet( new AlphabetArray() ),
+    schriftGröße( 12 ),
+    zeilenAbstand( 5 ),
+    drawPos( 0, 0 ),
+    ref( 1 )
 {
-	InitializeCriticalSection( &cs );
+    InitializeCriticalSection( &cs );
 }
 
 // Destruktor 
 Schrift::~Schrift()
 {
-	delete alphabet;
-	DeleteCriticalSection( &cs );
+    delete alphabet;
+    DeleteCriticalSection( &cs );
 }
 
 // nicht constant 
 void Schrift::lock() // lockt die Schrift
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void Schrift::unlock() // unlockt die Schrift
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 bool Schrift::addAlphabet( Alphabet *alphabet ) // Fügt der Schrift ein Alphabet hinzu
 {
-	lock();
+    lock();
     if( this->alphabet->addAlphabet( alphabet ) )
     {
         ++alphabetAnzahl;
@@ -774,240 +772,240 @@ bool Schrift::addAlphabet( Alphabet *alphabet ) // F
         unlock();
         return true;
     }
-	unlock();
+    unlock();
     return false;
 }
 
 void Schrift::removeAlphabet( int sg ) // Entfernt ein Alphabet
 {
-	lock();
+    lock();
     if( alphabet->removeAlphabet( sg ) )
         --alphabetAnzahl;
-	unlock();
+    unlock();
 }
 
 void Schrift::setDrawPosition( int x, int y ) // setzt die Zeichenposition
 {
-	lock();
-	drawPos.x = x;
-	drawPos.y = y;
-	unlock();
+    lock();
+    drawPos.x = x;
+    drawPos.y = y;
+    unlock();
 }
 
 void Schrift::setDrawPosition( Punkt &pos )
 {
-	lock();
-	drawPos = pos;
-	unlock();
+    lock();
+    drawPos = pos;
+    unlock();
 }
 
 void Schrift::setSchriftGröße( int sg ) // setzt die Schriftgröße
 {
-	lock();
-	schriftGröße = sg;
-	alphabet->setDrawSchriftGröße( sg );
-	unlock();
+    lock();
+    schriftGröße = sg;
+    alphabet->setDrawSchriftGröße( sg );
+    unlock();
 }
 
 void Schrift::setZeilenAbstand( int za ) // setzt den Zeilenabstand
 {
-	lock();
-	zeilenAbstand = za;
-	alphabet->setZeilenAbstand( za );
-	unlock();
+    lock();
+    zeilenAbstand = za;
+    alphabet->setZeilenAbstand( za );
+    unlock();
 }
 
 void Schrift::textFormatieren( Text *zText, int maxBreite, int schriftGröße ) // fügt zeilenumbrüche ein
 {
-	lock();
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( drawAlphabet )
-		drawAlphabet->textFormatieren( zText, maxBreite, schriftGröße );
-	unlock();
+    lock();
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( drawAlphabet )
+        drawAlphabet->textFormatieren( zText, maxBreite, schriftGröße );
+    unlock();
 }
 
 void Schrift::renderText( Text *zTxt, Bild &zRObj, int f ) // zeichnet txt nach zRObj
 {
-	lock();
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( drawAlphabet )
-	{
-		drawAlphabet->setDrawPosition( drawPos.x, drawPos.y );
-		drawAlphabet->render( zTxt, zRObj, f );
-	}
-	unlock();
+    lock();
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( drawAlphabet )
+    {
+        drawAlphabet->setDrawPosition( drawPos.x, drawPos.y );
+        drawAlphabet->render( zTxt, zRObj, f );
+    }
+    unlock();
 }
 
 void Schrift::renderText( Text *zTxt, Bild &zRObj, int cpos, int cf, int fbeg, int ff, int f )
 {
-	lock();
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( drawAlphabet )
-	{
-		drawAlphabet->setDrawPosition( drawPos.x, drawPos.y );
-		drawAlphabet->render( zTxt, zRObj, cpos, cf, fbeg, ff, f );
-	}
-	unlock();
+    lock();
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( drawAlphabet )
+    {
+        drawAlphabet->setDrawPosition( drawPos.x, drawPos.y );
+        drawAlphabet->render( zTxt, zRObj, cpos, cf, fbeg, ff, f );
+    }
+    unlock();
 }
 
 // constant 
 Alphabet *Schrift::getAlphabet( int sg ) const // gibt einen Alphaberarray zurück
 {
-	return alphabet->getAlphabet( sg );
+    return alphabet->getAlphabet( sg );
 }
 
 Alphabet *Schrift::zAlphabet( int sg ) const
 {
-	return alphabet->zAlphabet( sg );
+    return alphabet->zAlphabet( sg );
 }
 
 Alphabet *Schrift::getAlphabetI( int index ) const
 {
-	return alphabet->getAlphabetI( index, 0 );
+    return alphabet->getAlphabetI( index, 0 );
 }
 
 Alphabet *Schrift::zAlphabetI( int index ) const
 {
-	return alphabet->zAlphabetI( index, 0 );
+    return alphabet->zAlphabetI( index, 0 );
 }
 
 unsigned char Schrift::getAlphabetAnzahl() const // gibt die anzahl von in der Schrift enthaltenen Alphabeten zurück
 {
-	return alphabetAnzahl;
+    return alphabetAnzahl;
 }
 
 int Schrift::getSchriftGröße() const // gibt die Schriftgröße zurück
 {
-	return schriftGröße;
+    return schriftGröße;
 }
 
 int Schrift::getZeilenabstand() const // gibt den Zeilenabstand zurück
 {
-	return zeilenAbstand;
+    return zeilenAbstand;
 }
 
 int Schrift::getDrawX() const // gibt die Zeichenposition zurück
 {
-	return drawPos.x;
+    return drawPos.x;
 }
 
 int Schrift::getDrawY() const
 {
-	return drawPos.y;
+    return drawPos.y;
 }
 
 const Punkt &Schrift::getDrawPosition() const
 {
-	return drawPos;
+    return drawPos;
 }
 
 int Schrift::getTextBreite( Text *zTxt ) const // gibt die Breite des Textes zurück
 {
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( !drawAlphabet )
-		return 0;
-	return drawAlphabet->getTextBreite( zTxt );
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( !drawAlphabet )
+        return 0;
+    return drawAlphabet->getTextBreite( zTxt );
 }
 
 int Schrift::getTextHöhe( Text *zTxt ) const // gibt die Höhe des Textes zurück
 {
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( !drawAlphabet )
-		return 0;
-	return drawAlphabet->getTextHöhe( zTxt );
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( !drawAlphabet )
+        return 0;
+    return drawAlphabet->getTextHöhe( zTxt );
 }
 
 int Schrift::textPos( Text *zTxt, int mausX, int mausY ) const // gibt den Buchstaben zurück, auf den die Maus zeigt
 {
-	Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
-	if( !drawAlphabet )
-	{
-		for( int i = 0; i < 256; ++i )
-		{
-			drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
-			if( drawAlphabet )
-				break;
-			drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
-			if( drawAlphabet )
-				break;
-		}
-	}
-	if( !drawAlphabet )
-		return 0;
-	return drawAlphabet->textPos( zTxt, mausX, mausY );
+    Alphabet *drawAlphabet = alphabet->zAlphabet( schriftGröße );
+    if( !drawAlphabet )
+    {
+        for( int i = 0; i < 256; ++i )
+        {
+            drawAlphabet = alphabet->zAlphabet( schriftGröße - i );
+            if( drawAlphabet )
+                break;
+            drawAlphabet = alphabet->zAlphabet( schriftGröße + i );
+            if( drawAlphabet )
+                break;
+        }
+    }
+    if( !drawAlphabet )
+        return 0;
+    return drawAlphabet->textPos( zTxt, mausX, mausY );
 }
 
 // Reference Counting 
 Schrift *Schrift::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Schrift *Schrift::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }

Schrift.h

@@ -311,7 +311,6 @@ namespace Framework
         //  ff: Die Hintergrund Farbe des eingefärbten Textes
         //  f: Die Farbe, in der der Text gezeichnet werden soll
         __declspec( dllexport ) void renderText( Text *zTxt, Bild &zRObj, int cpos, int cf, int fbeg, int ff, int f );
-        
         // Gibt ein bestimmtes Alphabet mit erhöhtem Reference Counter zurück
         //  sg: Die Schriftgröße, dessen Alphabet gesucht werden soll
         //  return: (0), fals kein passendes Alphabet gefunden wurde

Scroll.cpp

@@ -7,123 +7,122 @@ using namespace Framework;
 // Inhalt der VScrollBar Klasse aus Scroll.h
 // Konstruktor 
 ScrollBar::ScrollBar()
-	: data(new ScrollData()),
-	  knopfdruck( 0 ),
-	  farbe( 0xFF808080),
-	  bgFarbe( 0xFF000000 ),
-	  bg( 0 ),
-	  klickScroll( 10 ),
-	  mx( -1 ),
-	  my( -1 ),
-	  mp( 0 ),
-	  rend( 0 ),
-	  ref( 1 )
-{
-}
+    : data( new ScrollData() ),
+    knopfdruck( 0 ),
+    farbe( 0xFF808080 ),
+    bgFarbe( 0xFF000000 ),
+    bg( 0 ),
+    klickScroll( 10 ),
+    mx( -1 ),
+    my( -1 ),
+    mp( 0 ),
+    rend( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor 
 ScrollBar::~ScrollBar()
 {
-	delete data;
+    delete data;
 }
 
 // nicht constant
 void ScrollBar::setFarbe( int fc )
 {
-	farbe = fc;
-	rend = 1;
+    farbe = fc;
+    rend = 1;
 }
 
 void ScrollBar::setBgFarbe( int fc, bool bgF )
 {
-	bgFarbe = fc;
-	bg = bgF;
-	rend = 1;
+    bgFarbe = fc;
+    bg = bgF;
+    rend = 1;
 }
 
 void ScrollBar::update( int maxGr, int anzeigeGr )
 {
-	if( data->max != maxGr || data->anzeige != anzeigeGr )
-	{
-		data->max = maxGr, data->anzeige = anzeigeGr;
-		rend = 1;
-	}
-	if( data->scrollPos > data->max - data->anzeige && data->max - data->anzeige >= 0 )
-	{
-		data->scrollPos = data->max - data->anzeige;
-		rend = 1;
-	}
-	if( data->scrollPos < 0 )
-	{
-		data->scrollPos = 0;
-		rend = 1;
-	}
+    if( data->max != maxGr || data->anzeige != anzeigeGr )
+    {
+        data->max = maxGr, data->anzeige = anzeigeGr;
+        rend = 1;
+    }
+    if( data->scrollPos > data->max - data->anzeige && data->max - data->anzeige >= 0 )
+    {
+        data->scrollPos = data->max - data->anzeige;
+        rend = 1;
+    }
+    if( data->scrollPos < 0 )
+    {
+        data->scrollPos = 0;
+        rend = 1;
+    }
 }
 
 void ScrollBar::setKlickScroll( int ks )
 {
-	klickScroll = ks;
-	rend = 1;
+    klickScroll = ks;
+    rend = 1;
 }
 
 void ScrollBar::scroll( int höhe )
 {
-	data->scrollPos = höhe;
-	if( data->scrollPos > data->max - data->anzeige )
-		data->scrollPos = data->max - data->anzeige;
-	if( data->scrollPos < 0 )
-		data->scrollPos = 0;
-	rend = 1;
+    data->scrollPos = höhe;
+    if( data->scrollPos > data->max - data->anzeige )
+        data->scrollPos = data->max - data->anzeige;
+    if( data->scrollPos < 0 )
+        data->scrollPos = 0;
+    rend = 1;
 }
 
 bool ScrollBar::getRend()
 {
-	if( knopfdruck == 1 )
-	{
-		int tmp = data->scrollPos;
-		data->scrollPos -= klickScroll;
-		if( data->scrollPos > data->max - data->anzeige )
-			data->scrollPos = data->max - data->anzeige;
-		if( data->scrollPos < 0 )
-			data->scrollPos = 0;
-		if( tmp != data->scrollPos )
-			rend = 1;
-	}
-	if( knopfdruck == 2 )
-	{
-		int tmp = data->scrollPos;
-		data->scrollPos += klickScroll;
-		if( data->scrollPos > data->max - data->anzeige )
-			data->scrollPos = data->max - data->anzeige;
-		if( data->scrollPos < 0 )
-			data->scrollPos = 0;
-		if( tmp != data->scrollPos )
-			rend = 1;
-	}
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( knopfdruck == 1 )
+    {
+        int tmp = data->scrollPos;
+        data->scrollPos -= klickScroll;
+        if( data->scrollPos > data->max - data->anzeige )
+            data->scrollPos = data->max - data->anzeige;
+        if( data->scrollPos < 0 )
+            data->scrollPos = 0;
+        if( tmp != data->scrollPos )
+            rend = 1;
+    }
+    if( knopfdruck == 2 )
+    {
+        int tmp = data->scrollPos;
+        data->scrollPos += klickScroll;
+        if( data->scrollPos > data->max - data->anzeige )
+            data->scrollPos = data->max - data->anzeige;
+        if( data->scrollPos < 0 )
+            data->scrollPos = 0;
+        if( tmp != data->scrollPos )
+            rend = 1;
+    }
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 // const 
 ScrollData *ScrollBar::getScrollData() const
 {
-	return data;
+    return data;
 }
 
 int ScrollBar::getKlickScroll() const
 {
-	return klickScroll;
+    return klickScroll;
 }
 
 int ScrollBar::getFarbe() const
 {
-	return farbe;
+    return farbe;
 }
 
 int ScrollBar::getBgFarbe() const
 {
-	return bg ? bgFarbe : 0;
+    return bg ? bgFarbe : 0;
 }
 
 int ScrollBar::getScroll() const
@@ -134,23 +133,22 @@ int ScrollBar::getScroll() const
 // Reference Counting
 ScrollBar *ScrollBar::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 ScrollBar *ScrollBar::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }
 
 // Inhalt der VScrollBar Klasse
 VScrollBar::VScrollBar()
     : ScrollBar()
-{
-}
+{}
 
 bool VScrollBar::doMausMessage( int x, int y, int br, int hö, MausEreignis &me )
 {
@@ -251,103 +249,102 @@ ScrollBar *VScrollBar::release()
 // Inhalt der HScrollBar Klasse aus Scroll.h
 // Konstruktor 
 HScrollBar::HScrollBar()
-	: ScrollBar()
-{
-}
+    : ScrollBar()
+{}
 
 // nicht constant
 bool HScrollBar::doMausMessage( int x, int y, int br, int hö, MausEreignis &me )
 {
     bool ret = me.mx >= x && me.mx <= x + br && me.my >= y && me.my <= y + hö;
-	knopfdruck = 0;
-	if( me.verarbeitet )
-	{
-		mx = -1, my = -1;
-		mp = 0;
-		return ret;
-	}
-	if( me.id == ME_LScroll )
-	{
-		data->scrollPos -= klickScroll;
-		if( data->scrollPos < 0 )
-			data->scrollPos = 0;
-		rend = 1;
-		return ret;
-	}
-	if( me.id == ME_RScroll )
-	{
-		data->scrollPos += klickScroll;
-		if( data->scrollPos > data->max - data->anzeige )
-			data->scrollPos = data->max - data->anzeige;
-		if( data->scrollPos < 0 )
-			data->scrollPos = 0;
-		rend = 1;
-		return ret;
-	}
-	if( ret )
-		mx = me.mx - x, my = me.my - y;
-	else
-		mx = -1, my = -1;
-	if( me.id == ME_PLinks )
-		mp = 1;
-	if( me.id == ME_RLinks )
-		mp = 0;
-	if( mp )
-	{
-		if( mx >= 0 && my >= 0 )
-		{
-			if( mx < hö )
-			{
-				knopfdruck = 1;
-				data->scrollPos -= klickScroll;
-			}
-			else if( mx > br - hö )
-			{
-				knopfdruck = 2;
-				data->scrollPos += klickScroll;
-			}
-			else
-				data->scrollPos = (int)( ( data->max / ( br - 2.0 * hö ) ) * ( mx - hö ) ) - data->anzeige / 2;
-			if( data->scrollPos > data->max - data->anzeige )
-				data->scrollPos = data->max - data->anzeige;
-			if( data->scrollPos < 0 )
-				data->scrollPos = 0;
-			rend = 1;
-		}
-	}
+    knopfdruck = 0;
+    if( me.verarbeitet )
+    {
+        mx = -1, my = -1;
+        mp = 0;
+        return ret;
+    }
+    if( me.id == ME_LScroll )
+    {
+        data->scrollPos -= klickScroll;
+        if( data->scrollPos < 0 )
+            data->scrollPos = 0;
+        rend = 1;
+        return ret;
+    }
+    if( me.id == ME_RScroll )
+    {
+        data->scrollPos += klickScroll;
+        if( data->scrollPos > data->max - data->anzeige )
+            data->scrollPos = data->max - data->anzeige;
+        if( data->scrollPos < 0 )
+            data->scrollPos = 0;
+        rend = 1;
+        return ret;
+    }
+    if( ret )
+        mx = me.mx - x, my = me.my - y;
+    else
+        mx = -1, my = -1;
+    if( me.id == ME_PLinks )
+        mp = 1;
+    if( me.id == ME_RLinks )
+        mp = 0;
+    if( mp )
+    {
+        if( mx >= 0 && my >= 0 )
+        {
+            if( mx < hö )
+            {
+                knopfdruck = 1;
+                data->scrollPos -= klickScroll;
+            }
+            else if( mx > br - hö )
+            {
+                knopfdruck = 2;
+                data->scrollPos += klickScroll;
+            }
+            else
+                data->scrollPos = (int)( ( data->max / ( br - 2.0 * hö ) ) * ( mx - hö ) ) - data->anzeige / 2;
+            if( data->scrollPos > data->max - data->anzeige )
+                data->scrollPos = data->max - data->anzeige;
+            if( data->scrollPos < 0 )
+                data->scrollPos = 0;
+            rend = 1;
+        }
+    }
     return ret;
 }
 
 void HScrollBar::render( int x, int y, int br, int hö, Bild &zRObj ) const
 {
-	if( bg )
-		zRObj.alphaRegion( x, y, br, hö, bgFarbe );
-	--br;
-	--hö;
-	zRObj.drawLinieV( x, y, hö + 1, farbe );
-	zRObj.drawLinieV( x + br, y, hö + 1, farbe );
-	zRObj.drawLinieH( x + 1, y, br - 1, farbe );
-	zRObj.drawLinieH( x + 1, y + hö, br - 1, farbe );
-	zRObj.drawLinieV( x + hö, y + 1, hö - 1, farbe );
-	zRObj.drawLinieV( x + br - hö, y + 1, hö - 1, farbe );
-	++br;
-	++hö;
-	int st = (int)( data->scrollPos / ( data->max / ( br - hö * 2.0 ) ) );
-	int end = (int)( ( br - 2.0 * hö ) / ( (double)data->max / data->anzeige ) );
-	if( data->scrollPos > data->max - data->anzeige )
-		data->scrollPos = data->max - data->anzeige;
-	if( data->scrollPos < 0 )
-	{
-		data->scrollPos = 0;
-		end = br - hö * 2;
-	}
-	zRObj.füllRegion( x + hö + st, y + 1, end, hö - 1, farbe );
+    if( bg )
+        zRObj.alphaRegion( x, y, br, hö, bgFarbe );
+    --br;
+    --hö;
+    zRObj.drawLinieV( x, y, hö + 1, farbe );
+    zRObj.drawLinieV( x + br, y, hö + 1, farbe );
+    zRObj.drawLinieH( x + 1, y, br - 1, farbe );
+    zRObj.drawLinieH( x + 1, y + hö, br - 1, farbe );
+    zRObj.drawLinieV( x + hö, y + 1, hö - 1, farbe );
+    zRObj.drawLinieV( x + br - hö, y + 1, hö - 1, farbe );
+    ++br;
+    ++hö;
+    int st = (int)( data->scrollPos / ( data->max / ( br - hö * 2.0 ) ) );
+    int end = (int)( ( br - 2.0 * hö ) / ( (double)data->max / data->anzeige ) );
+    if( data->scrollPos > data->max - data->anzeige )
+        data->scrollPos = data->max - data->anzeige;
+    if( data->scrollPos < 0 )
+    {
+        data->scrollPos = 0;
+        end = br - hö * 2;
+    }
+    zRObj.füllRegion( x + hö + st, y + 1, end, hö - 1, farbe );
 }
 
 ScrollBar *HScrollBar::release()
 {
-	--ref;
-	if( ref == 0 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref == 0 )
+        delete this;
+    return 0;
 }

Scroll.h

@@ -5,8 +5,8 @@
 
 namespace Framework
 {
-	class Bild; // Bild.h
-	struct MausEreignis; // MausEreignis.h
+    class Bild; // Bild.h
+    struct MausEreignis; // MausEreignis.h
 
     struct ScrollData
     {
@@ -87,54 +87,54 @@ namespace Framework
     };
 
     // Eine vertikale Scrollbar, wie sie in manchen 2D GUI Zeichnungen des Frameworks verwendet wird
-	class VScrollBar : public ScrollBar
-	{
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) VScrollBar();
+    class VScrollBar : public ScrollBar
+    {
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) VScrollBar();
         // Verarbeitet ein Maus Ereignis
         //  x: Die X Position der Scroll Bar im Fenster
         //  y: Die Y Position der Scroll Bar im Fenster
         //  br: Die Breite der Scroll Bar
         //  hö: Die Höhe der Scroll Bar
         //  return: 1, falls die Nachricht verarbeitet wurde. Setzt dafür nicht den verarbeitet flag des Maus Ereignisses
-		__declspec( dllexport ) bool doMausMessage( int x, int y, int br, int hö, MausEreignis &me ) override;
+        __declspec( dllexport ) bool doMausMessage( int x, int y, int br, int hö, MausEreignis &me ) override;
         // Zeichnet die Scrollbar
         //  x: Die X Position der Scroll Bar
         //  y: Die Y Position der Scroll Bar
         //  br: Die Breite der Scroll Bar
         //  hö: Die Höhe der Scroll Bar
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) void render( int x, int y, int br, int hö, Bild &zRObj ) const override;
+        __declspec( dllexport ) void render( int x, int y, int br, int hö, Bild &zRObj ) const override;
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) ScrollBar *release() override;
-	};
+        __declspec( dllexport ) ScrollBar *release() override;
+    };
 
     // Eine horizontale Scrollbar, wie sie in manchen 2D GUI Zeichnungen des Frameworks verwendet wird
-	class HScrollBar : public ScrollBar
-	{
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) HScrollBar();
+    class HScrollBar : public ScrollBar
+    {
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) HScrollBar();
         // Verarbeitet ein Maus Ereignis
         //  x: Die X Position der Scroll Bar im Fenster
         //  y: Die Y Position der Scroll Bar im Fenster
         //  br: Die Breite der Scroll Bar
         //  hö: Die Höhe der Scroll Bar
         //  return: 1, falls die Nachricht verarbeitet wurde. Setzt dafür nicht den verarbeitet flag des Maus Ereignisses
-		__declspec( dllexport ) bool doMausMessage( int x, int y, int br, int hö, MausEreignis &me ) override;
+        __declspec( dllexport ) bool doMausMessage( int x, int y, int br, int hö, MausEreignis &me ) override;
         // Zeichnet die Scrollbar
         //  x: Die X Position der Scroll Bar
         //  y: Die Y Position der Scroll Bar
         //  br: Die Breite der Scroll Bar
         //  hö: Die Höhe der Scroll Bar
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) void render( int x, int y, int br, int hö, Bild &zRObj ) const override;
+        __declspec( dllexport ) void render( int x, int y, int br, int hö, Bild &zRObj ) const override;
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) ScrollBar *release() override;
-	};
+        __declspec( dllexport ) ScrollBar *release() override;
+    };
 }
 
 #endif

Shader.cpp

@@ -89,8 +89,7 @@ bool Shader::compile( ID3D11Device *zD3d11Device, const char *einstiegsFunktion,
 // Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
 //  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
 void Shader::benutzeShader( ID3D11DeviceContext *zD3d11Context )
-{
-}
+{}
 
 // erstellt ein constanten Buffer, der constante daten an den Shader übergibt
 // es können maximal 14 Buffer erstellt werden

Tabelle.cpp

@@ -13,32 +13,32 @@ using namespace Framework;
 // Inhalt der ObjTabelle Klasse aus Tabelle.h
 // Konstruktor 
 ObjTabelle::ObjTabelle()
-	: ZeichnungHintergrund(),
-	  zZeichnungs( new RCArray< Array< Zeichnung* > >() ),
-	  spaltenNamen( new RCArray< Text >() ),
-	  zeilenNamen( new RCArray< Text >() ),
-	  spaltenBreite( new Array< int >() ),
-	  zeilenHöhe( new Array< int >() ),
-	  minSpaltenBreite( new Array< int >() ),
-	  maxSpaltenBreite( new Array< int >() ),
-	  minZeilenHöhe( new Array< int >() ),
-	  maxZeilenHöhe( new Array< int >() ),
-	  spaltenAnzahl( 0 ),
-	  zeilenAnzahl( 0 ),
-	  klickSpalte( -1 ),
-	  mSpalte( -1 ),
-	  mZeile( -1 ),
-	  mx( 0 ),
-	  my( 0 ),
-	  selected( -1, -1 ),
-	  rasterFarbe( 0xFF000000 ),
-	  rasterBreite( 1 ),
-	  aRam( 0 ),
-	  aAf( 0 ),
-	  msaRam( new RCArray< RCArray< LRahmen > >() ),
-	  msaAf( new RCArray< RCArray< AlphaFeld > >() ),
-	  styles( new RCArray< Array< __int64 > >() ),
-	  ref( 1 )
+    : ZeichnungHintergrund(),
+    zZeichnungs( new RCArray< Array< Zeichnung* > >() ),
+    spaltenNamen( new RCArray< Text >() ),
+    zeilenNamen( new RCArray< Text >() ),
+    spaltenBreite( new Array< int >() ),
+    zeilenHöhe( new Array< int >() ),
+    minSpaltenBreite( new Array< int >() ),
+    maxSpaltenBreite( new Array< int >() ),
+    minZeilenHöhe( new Array< int >() ),
+    maxZeilenHöhe( new Array< int >() ),
+    spaltenAnzahl( 0 ),
+    zeilenAnzahl( 0 ),
+    klickSpalte( -1 ),
+    mSpalte( -1 ),
+    mZeile( -1 ),
+    mx( 0 ),
+    my( 0 ),
+    selected( -1, -1 ),
+    rasterFarbe( 0xFF000000 ),
+    rasterBreite( 1 ),
+    aRam( 0 ),
+    aAf( 0 ),
+    msaRam( new RCArray< RCArray< LRahmen > >() ),
+    msaAf( new RCArray< RCArray< AlphaFeld > >() ),
+    styles( new RCArray< Array< __int64 > >() ),
+    ref( 1 )
 {
     style = 0;
 }
@@ -46,1547 +46,1547 @@ ObjTabelle::ObjTabelle()
 // Destruktor 
 ObjTabelle::~ObjTabelle()
 {
-	if( zZeichnungs )
-		zZeichnungs->release();
-	if( spaltenNamen )
-		spaltenNamen->release();
-	if( zeilenNamen )
-		zeilenNamen->release();
-	if( spaltenBreite )
-		spaltenBreite->release();
-	if( zeilenHöhe )
-		zeilenHöhe->release();
-	if( minSpaltenBreite )
-		minSpaltenBreite->release();
-	if( maxSpaltenBreite )
-		maxSpaltenBreite->release();
-	if( minZeilenHöhe )
-		minZeilenHöhe->release();
-	if( maxZeilenHöhe )
-		maxZeilenHöhe->release();
-	if( aRam )
-		aRam->release();
-	if( aAf )
-		aAf->release();
-	if( msaRam )
-		msaRam->release();
-	if( msaAf )
-		msaAf->release();
-	if( styles )
-		styles->release();
+    if( zZeichnungs )
+        zZeichnungs->release();
+    if( spaltenNamen )
+        spaltenNamen->release();
+    if( zeilenNamen )
+        zeilenNamen->release();
+    if( spaltenBreite )
+        spaltenBreite->release();
+    if( zeilenHöhe )
+        zeilenHöhe->release();
+    if( minSpaltenBreite )
+        minSpaltenBreite->release();
+    if( maxSpaltenBreite )
+        maxSpaltenBreite->release();
+    if( minZeilenHöhe )
+        minZeilenHöhe->release();
+    if( maxZeilenHöhe )
+        maxZeilenHöhe->release();
+    if( aRam )
+        aRam->release();
+    if( aAf )
+        aAf->release();
+    if( msaRam )
+        msaRam->release();
+    if( msaAf )
+        msaAf->release();
+    if( styles )
+        styles->release();
 }
 
 // nicht constant 
 void ObjTabelle::addSpalte( const char *name ) // Spalte hinzufügen
 {
-	lockZeichnung();
-	zZeichnungs->add( new Array< Zeichnung* >(), spaltenAnzahl );
-	spaltenNamen->add( new Text( name ), spaltenAnzahl );
-	spaltenBreite->add( 100 );
-	msaRam->add( new RCArray< LRahmen >(), spaltenAnzahl );
-	msaAf->add( new RCArray< AlphaFeld >(), spaltenAnzahl );
-	++spaltenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    lockZeichnung();
+    zZeichnungs->add( new Array< Zeichnung* >(), spaltenAnzahl );
+    spaltenNamen->add( new Text( name ), spaltenAnzahl );
+    spaltenBreite->add( 100 );
+    msaRam->add( new RCArray< LRahmen >(), spaltenAnzahl );
+    msaAf->add( new RCArray< AlphaFeld >(), spaltenAnzahl );
+    ++spaltenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addSpalte( Text *name )
 {
-	lockZeichnung();
-	zZeichnungs->add( new Array< Zeichnung* >(), spaltenAnzahl );
-	spaltenNamen->add( name, spaltenAnzahl );
-	spaltenBreite->add( 100 );
-	msaRam->add( new RCArray< LRahmen >(), spaltenAnzahl );
-	msaAf->add( new RCArray< AlphaFeld >(), spaltenAnzahl );
-	++spaltenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    lockZeichnung();
+    zZeichnungs->add( new Array< Zeichnung* >(), spaltenAnzahl );
+    spaltenNamen->add( name, spaltenAnzahl );
+    spaltenBreite->add( 100 );
+    msaRam->add( new RCArray< LRahmen >(), spaltenAnzahl );
+    msaAf->add( new RCArray< AlphaFeld >(), spaltenAnzahl );
+    ++spaltenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addSpalte( int sNum, const char *name ) // Spalte bei sNum einfügen
 {
-	if( sNum > spaltenAnzahl )
-		return;
-	lockZeichnung();
-	zZeichnungs->add( new Array< Zeichnung* >(), sNum );
-	spaltenNamen->add( new Text( name ), sNum );
-	spaltenBreite->add( 100, sNum );
-	minSpaltenBreite->add( 0, sNum );
-	maxSpaltenBreite->add( 300, sNum );
-	msaRam->add( new RCArray< LRahmen >(), sNum );
-	msaAf->add( new RCArray< AlphaFeld >(), sNum );
-	styles->add( new Array< __int64 >(), sNum );
-	++spaltenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( sNum > spaltenAnzahl )
+        return;
+    lockZeichnung();
+    zZeichnungs->add( new Array< Zeichnung* >(), sNum );
+    spaltenNamen->add( new Text( name ), sNum );
+    spaltenBreite->add( 100, sNum );
+    minSpaltenBreite->add( 0, sNum );
+    maxSpaltenBreite->add( 300, sNum );
+    msaRam->add( new RCArray< LRahmen >(), sNum );
+    msaAf->add( new RCArray< AlphaFeld >(), sNum );
+    styles->add( new Array< __int64 >(), sNum );
+    ++spaltenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addSpalte( int sNum, Text *name )
 {
-	if( sNum > spaltenAnzahl )
-		return;
-	lockZeichnung();
-	zZeichnungs->add( new Array< Zeichnung* >(), sNum );
-	spaltenNamen->add( name, sNum );
-	spaltenBreite->add( 100, sNum );
-	minSpaltenBreite->add( 0, sNum );
-	maxSpaltenBreite->add( 300, sNum );
-	msaRam->add( new RCArray< LRahmen >(), sNum );
-	msaAf->add( new RCArray< AlphaFeld >(), sNum );
-	styles->add( new Array< __int64 >(), sNum );
-	++spaltenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( sNum > spaltenAnzahl )
+        return;
+    lockZeichnung();
+    zZeichnungs->add( new Array< Zeichnung* >(), sNum );
+    spaltenNamen->add( name, sNum );
+    spaltenBreite->add( 100, sNum );
+    minSpaltenBreite->add( 0, sNum );
+    maxSpaltenBreite->add( 300, sNum );
+    msaRam->add( new RCArray< LRahmen >(), sNum );
+    msaAf->add( new RCArray< AlphaFeld >(), sNum );
+    styles->add( new Array< __int64 >(), sNum );
+    ++spaltenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addZeile( const char *name ) // Zeile Hinzufügen
 {
-	lockZeichnung();
-	zeilenNamen->add( new Text( name ), zeilenAnzahl );
-	zeilenHöhe->add( 20 );
-	++zeilenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    lockZeichnung();
+    zeilenNamen->add( new Text( name ), zeilenAnzahl );
+    zeilenHöhe->add( 20 );
+    ++zeilenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addZeile( Text *name )
 {
-	lockZeichnung();
-	zeilenNamen->add( name, zeilenAnzahl );
-	zeilenHöhe->add( 20 );
-	++zeilenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    lockZeichnung();
+    zeilenNamen->add( name, zeilenAnzahl );
+    zeilenHöhe->add( 20 );
+    ++zeilenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addZeile( int zNum, const char *name ) // Zeile bei zNum einfügen
 {
-	if( zNum > zeilenAnzahl )
-		return;
-	lockZeichnung();
-	zeilenNamen->add( new Text( name ), zNum );
-	zeilenHöhe->add( 20, zNum );
-	minZeilenHöhe->add( 0, zNum );
-	maxZeilenHöhe->add( 100, zNum );
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		if( zZeichnungs->z( i ) )
-			zZeichnungs->z( i )->add( 0, zNum );
-		if( msaRam->z( i ) )
-			msaRam->z( i )->add( 0, zNum );
-		if( msaAf->z( i ) )
-			msaAf->z( i )->add( 0, zNum );
-		if( styles->z( i ) )
-			styles->z( i )->add( 0, zNum );
-	}
-	++zeilenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( zNum > zeilenAnzahl )
+        return;
+    lockZeichnung();
+    zeilenNamen->add( new Text( name ), zNum );
+    zeilenHöhe->add( 20, zNum );
+    minZeilenHöhe->add( 0, zNum );
+    maxZeilenHöhe->add( 100, zNum );
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        if( zZeichnungs->z( i ) )
+            zZeichnungs->z( i )->add( 0, zNum );
+        if( msaRam->z( i ) )
+            msaRam->z( i )->add( 0, zNum );
+        if( msaAf->z( i ) )
+            msaAf->z( i )->add( 0, zNum );
+        if( styles->z( i ) )
+            styles->z( i )->add( 0, zNum );
+    }
+    ++zeilenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::addZeile( int zNum, Text *name )
 {
-	if( zNum > zeilenAnzahl )
-		return;
-	lockZeichnung();
-	zeilenNamen->add( name, zNum );
-	zeilenHöhe->add( 20, zNum );
-	minZeilenHöhe->add( 0, zNum );
-	maxZeilenHöhe->add( 100, zNum );
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		if( zZeichnungs->z( i ) )
-			zZeichnungs->z( i )->add( 0, zNum );
-		if( msaRam->z( i ) )
-			msaRam->z( i )->add( 0, zNum );
-		if( msaAf->z( i ) )
-			msaAf->z( i )->add( 0, zNum );
-		if( styles->z( i ) )
-			styles->z( i )->add( 0, zNum );
-	}
-	++zeilenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( zNum > zeilenAnzahl )
+        return;
+    lockZeichnung();
+    zeilenNamen->add( name, zNum );
+    zeilenHöhe->add( 20, zNum );
+    minZeilenHöhe->add( 0, zNum );
+    maxZeilenHöhe->add( 100, zNum );
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        if( zZeichnungs->z( i ) )
+            zZeichnungs->z( i )->add( 0, zNum );
+        if( msaRam->z( i ) )
+            msaRam->z( i )->add( 0, zNum );
+        if( msaAf->z( i ) )
+            msaAf->z( i )->add( 0, zNum );
+        if( styles->z( i ) )
+            styles->z( i )->add( 0, zNum );
+    }
+    ++zeilenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::removeSpalte( int sNum ) // Spalte löschen
 {
-	if( sNum >= spaltenAnzahl )
-		return;
-	lockZeichnung();
-	zZeichnungs->lösche( sNum );
-	spaltenNamen->lösche( sNum );
-	spaltenBreite->lösche( sNum );
-	minSpaltenBreite->lösche( sNum );
-	maxSpaltenBreite->lösche( sNum );
-	if( msaRam->z( sNum ) )
-		msaRam->z( sNum )->release();
-	msaRam->lösche( sNum );
-	if( msaAf->z( sNum ) )
-		msaAf->z( sNum )->release();
-	msaAf->lösche( sNum );
-	styles->lösche( sNum );
-	--spaltenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl )
+        return;
+    lockZeichnung();
+    zZeichnungs->lösche( sNum );
+    spaltenNamen->lösche( sNum );
+    spaltenBreite->lösche( sNum );
+    minSpaltenBreite->lösche( sNum );
+    maxSpaltenBreite->lösche( sNum );
+    if( msaRam->z( sNum ) )
+        msaRam->z( sNum )->release();
+    msaRam->lösche( sNum );
+    if( msaAf->z( sNum ) )
+        msaAf->z( sNum )->release();
+    msaAf->lösche( sNum );
+    styles->lösche( sNum );
+    --spaltenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::removeSpalte( const char *name )
 {
-	removeSpalte( getSpaltenNummer( name ) );
+    removeSpalte( getSpaltenNummer( name ) );
 }
 
 void ObjTabelle::removeSpalte( Text *name )
 {
-	removeSpalte( getSpaltenNummer( name ) );
+    removeSpalte( getSpaltenNummer( name ) );
 }
 
 void ObjTabelle::removeZeile( int zNum ) // Zeile löschen
 {
-	if( zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	zeilenNamen->lösche( zNum );
-	zeilenHöhe->lösche( zNum );
-	minZeilenHöhe->lösche( zNum );
-	maxZeilenHöhe->lösche( zNum );
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		if( zZeichnungs->z( i ) )
-			zZeichnungs->z( i )->lösche( zNum );
-		if( msaRam->z( i ) )
-			msaRam->z( i )->lösche( zNum );
-		if( msaAf->z( i ) )
-			msaAf->z( i )->lösche( zNum );
-		if( styles->z( i ) )
-			styles->z( i )->lösche( zNum );
-	}
-	--zeilenAnzahl;
-	rend = 1;
-	unlockZeichnung();
+    if( zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    zeilenNamen->lösche( zNum );
+    zeilenHöhe->lösche( zNum );
+    minZeilenHöhe->lösche( zNum );
+    maxZeilenHöhe->lösche( zNum );
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        if( zZeichnungs->z( i ) )
+            zZeichnungs->z( i )->lösche( zNum );
+        if( msaRam->z( i ) )
+            msaRam->z( i )->lösche( zNum );
+        if( msaAf->z( i ) )
+            msaAf->z( i )->lösche( zNum );
+        if( styles->z( i ) )
+            styles->z( i )->lösche( zNum );
+    }
+    --zeilenAnzahl;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::removeZeile( const char *name )
 {
-	removeZeile( getZeilenNummer( name ) );
+    removeZeile( getZeilenNummer( name ) );
 }
 
 void ObjTabelle::removeZeile( Text *name )
 {
-	removeZeile( getZeilenNummer( name ) );
+    removeZeile( getZeilenNummer( name ) );
 }
 
 void ObjTabelle::setSpaltePosition( const char *name, int pos ) // setzt die Position einer Spalte
 {
-	setSpaltePosition( getSpaltenNummer( name ), pos );
+    setSpaltePosition( getSpaltenNummer( name ), pos );
 }
 
 void ObjTabelle::setSpaltePosition( Text *name, int pos )
 {
-	setSpaltePosition( getSpaltenNummer( name ), pos );
+    setSpaltePosition( getSpaltenNummer( name ), pos );
 }
 
 void ObjTabelle::setSpaltePosition( int sNum, int pos )
 {
-	if( sNum >= spaltenAnzahl || pos >= spaltenAnzahl || sNum == pos )
-		return;
-	int löschPos = sNum;
-	int insertPos = pos;
-	if( pos < sNum )
-		++löschPos;
-	else
-		++insertPos;
-	lockZeichnung();
-	zZeichnungs->add( zZeichnungs->get( sNum ), insertPos );
-	zZeichnungs->lösche( löschPos );
-	spaltenNamen->add( spaltenNamen->get( sNum ), insertPos );
-	spaltenNamen->lösche( löschPos );
-	spaltenBreite->add( spaltenBreite->hat( sNum ) ? spaltenBreite->get( sNum ) : 0, insertPos );
-	spaltenBreite->lösche( löschPos );
-	minSpaltenBreite->add( minSpaltenBreite->hat( sNum ) ? minSpaltenBreite->get( sNum ) : 0, insertPos );
-	minSpaltenBreite->lösche( löschPos );
-	msaRam->add( msaRam->z( sNum ), insertPos );
-	msaRam->lösche( löschPos );
-	msaAf->add( msaAf->z( sNum ), insertPos );
-	msaAf->lösche( löschPos );
-	styles->add( styles->get( sNum ), insertPos );
-	styles->lösche( löschPos );
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl || pos >= spaltenAnzahl || sNum == pos )
+        return;
+    int löschPos = sNum;
+    int insertPos = pos;
+    if( pos < sNum )
+        ++löschPos;
+    else
+        ++insertPos;
+    lockZeichnung();
+    zZeichnungs->add( zZeichnungs->get( sNum ), insertPos );
+    zZeichnungs->lösche( löschPos );
+    spaltenNamen->add( spaltenNamen->get( sNum ), insertPos );
+    spaltenNamen->lösche( löschPos );
+    spaltenBreite->add( spaltenBreite->hat( sNum ) ? spaltenBreite->get( sNum ) : 0, insertPos );
+    spaltenBreite->lösche( löschPos );
+    minSpaltenBreite->add( minSpaltenBreite->hat( sNum ) ? minSpaltenBreite->get( sNum ) : 0, insertPos );
+    minSpaltenBreite->lösche( löschPos );
+    msaRam->add( msaRam->z( sNum ), insertPos );
+    msaRam->lösche( löschPos );
+    msaAf->add( msaAf->z( sNum ), insertPos );
+    msaAf->lösche( löschPos );
+    styles->add( styles->get( sNum ), insertPos );
+    styles->lösche( löschPos );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setZeilePosition( const char *name, int pos ) // setzt die Zeilen Position
 {
-	setZeilePosition( getZeilenNummer( name ), pos );
+    setZeilePosition( getZeilenNummer( name ), pos );
 }
 
 void ObjTabelle::setZeilePosition( Text *name, int pos )
 {
-	setZeilePosition( getZeilenNummer( name ), pos );
+    setZeilePosition( getZeilenNummer( name ), pos );
 }
 
 void ObjTabelle::setZeilePosition( int zNum, int pos )
 {
-	if( zNum >= zeilenAnzahl || pos >= zeilenAnzahl || pos == zNum )
-		return;
-	int löschPos = zNum;
-	int insertPos = pos;
-	if( pos < zNum )
-		++löschPos;
-	else
-		++insertPos;
-	lockZeichnung();
-	zeilenNamen->add( zeilenNamen->get( zNum ), insertPos );
-	zeilenNamen->lösche( löschPos );
-	zeilenHöhe->add( zeilenHöhe->hat( zNum ) ? zeilenHöhe->get( zNum ) : 0, insertPos );
-	zeilenHöhe->lösche( löschPos );
-	minZeilenHöhe->add( minZeilenHöhe->hat( zNum ) ? minZeilenHöhe->get( zNum ) : 0, insertPos );
-	minZeilenHöhe->lösche( löschPos );
-	maxZeilenHöhe->add( maxZeilenHöhe->hat( zNum ) ? maxZeilenHöhe->get( zNum ) : 0, insertPos );
-	maxZeilenHöhe->lösche( löschPos );
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		if( zZeichnungs->z( i ) )
-		{
-			zZeichnungs->z( i )->add( zZeichnungs->z( i )->hat( zNum ) ? zZeichnungs->z( i )->get( zNum ) : 0, insertPos );
-			zZeichnungs->z( i )->lösche( löschPos );
-		}
-		if( msaRam->z( i ) )
-		{
-			msaRam->z( i )->add( msaRam->z( i )->z( zNum ) ? msaRam->z( i )->get( zNum ) : 0, insertPos );
-			msaRam->z( i )->lösche( löschPos );
-		}
-		if( msaAf->z( i ) )
-		{
-			msaAf->z( i )->add( msaAf->z( i )->z( zNum ) ? msaAf->z( i )->get( zNum ) : 0, insertPos );
-			msaAf->z( i )->lösche( löschPos );
-		}
-		if( styles->z( i ) )
-		{
-			styles->z( i )->add( styles->z( i )->hat( zNum ) ? styles->z( i )->get( zNum ) : 0, insertPos );
-			styles->z( i )->lösche( löschPos );
-		}
-	}
-	rend = 1;
-	unlockZeichnung();
+    if( zNum >= zeilenAnzahl || pos >= zeilenAnzahl || pos == zNum )
+        return;
+    int löschPos = zNum;
+    int insertPos = pos;
+    if( pos < zNum )
+        ++löschPos;
+    else
+        ++insertPos;
+    lockZeichnung();
+    zeilenNamen->add( zeilenNamen->get( zNum ), insertPos );
+    zeilenNamen->lösche( löschPos );
+    zeilenHöhe->add( zeilenHöhe->hat( zNum ) ? zeilenHöhe->get( zNum ) : 0, insertPos );
+    zeilenHöhe->lösche( löschPos );
+    minZeilenHöhe->add( minZeilenHöhe->hat( zNum ) ? minZeilenHöhe->get( zNum ) : 0, insertPos );
+    minZeilenHöhe->lösche( löschPos );
+    maxZeilenHöhe->add( maxZeilenHöhe->hat( zNum ) ? maxZeilenHöhe->get( zNum ) : 0, insertPos );
+    maxZeilenHöhe->lösche( löschPos );
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        if( zZeichnungs->z( i ) )
+        {
+            zZeichnungs->z( i )->add( zZeichnungs->z( i )->hat( zNum ) ? zZeichnungs->z( i )->get( zNum ) : 0, insertPos );
+            zZeichnungs->z( i )->lösche( löschPos );
+        }
+        if( msaRam->z( i ) )
+        {
+            msaRam->z( i )->add( msaRam->z( i )->z( zNum ) ? msaRam->z( i )->get( zNum ) : 0, insertPos );
+            msaRam->z( i )->lösche( löschPos );
+        }
+        if( msaAf->z( i ) )
+        {
+            msaAf->z( i )->add( msaAf->z( i )->z( zNum ) ? msaAf->z( i )->get( zNum ) : 0, insertPos );
+            msaAf->z( i )->lösche( löschPos );
+        }
+        if( styles->z( i ) )
+        {
+            styles->z( i )->add( styles->z( i )->hat( zNum ) ? styles->z( i )->get( zNum ) : 0, insertPos );
+            styles->z( i )->lösche( löschPos );
+        }
+    }
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setZeichnungZ( int sNum, int zNum, Zeichnung *zObj ) // setzt ein Zeichnung
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	if( !zZeichnungs->z( sNum ) )
-		zZeichnungs->set( new Array< Zeichnung* >(), sNum );
-	zZeichnungs->z( sNum )->set( zObj, zNum );
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    if( !zZeichnungs->z( sNum ) )
+        zZeichnungs->set( new Array< Zeichnung* >(), sNum );
+    zZeichnungs->z( sNum )->set( zObj, zNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setZeichnungZ( const char *spaltenName, const char *zeilenName, Zeichnung *zZeichnung )
 {
-	setZeichnungZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), zZeichnung );
+    setZeichnungZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), zZeichnung );
 }
 
 void ObjTabelle::setZeichnungZ( Text *spaltenName, Text *zeilenName, Zeichnung *zZeichnung )
 {
-	setZeichnungZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), zZeichnung );
+    setZeichnungZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), zZeichnung );
 }
 
 void ObjTabelle::setSpaltenBreite( int sNum, int br ) // setzt die Spaltenbreite
 {
-	if( sNum >= spaltenAnzahl )
-		return;
-	lockZeichnung();
-	spaltenBreite->set( br, sNum );
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl )
+        return;
+    lockZeichnung();
+    spaltenBreite->set( br, sNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setSpaltenBreite( const char *name, int br )
 {
-	setSpaltenBreite( getSpaltenNummer( name ), br );
+    setSpaltenBreite( getSpaltenNummer( name ), br );
 }
 
 void ObjTabelle::setSpaltenBreite( Text *name, int br )
 {
-	setSpaltenBreite( getSpaltenNummer( name ), br );
+    setSpaltenBreite( getSpaltenNummer( name ), br );
 }
 
 void ObjTabelle::setZeilenHöhe( int zNum, int hö ) // setzt die Zeilenhöhe
 {
-	if( zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	zeilenHöhe->set( hö, zNum );
-	rend = 1;
-	unlockZeichnung();
+    if( zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    zeilenHöhe->set( hö, zNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setZeilenHöhe( const char *name, int hö )
 {
-	setZeilenHöhe( getZeilenNummer( name ), hö );
+    setZeilenHöhe( getZeilenNummer( name ), hö );
 }
 
 void ObjTabelle::setZeilenHöhe( Text *name, int hö )
 {
-	setZeilenHöhe( getZeilenNummer( name ), hö );
+    setZeilenHöhe( getZeilenNummer( name ), hö );
 }
 
 void ObjTabelle::setMinSpaltenBreite( int sNum, int minBr ) // setzt die mindest Spaltenbreite
 {
-	if( sNum >= spaltenAnzahl )
-		return;
-	lockZeichnung();
-	minSpaltenBreite->set( minBr, sNum );
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl )
+        return;
+    lockZeichnung();
+    minSpaltenBreite->set( minBr, sNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setMinSpaltenBreite( const char *name, int minBr )
 {
-	setMinSpaltenBreite( getSpaltenNummer( name ), minBr );
+    setMinSpaltenBreite( getSpaltenNummer( name ), minBr );
 }
 
 void ObjTabelle::setMinSpaltenBreite( Text *name, int minBr )
 {
-	setMinSpaltenBreite( getSpaltenNummer( name ), minBr );
+    setMinSpaltenBreite( getSpaltenNummer( name ), minBr );
 }
 
 void ObjTabelle::setMaxSpaltenBreite( int sNum, int maxBr ) // setzt die maximale Spaltenbreite
 {
-	if( sNum >= spaltenAnzahl )
-		return;
-	lockZeichnung();
-	maxSpaltenBreite->set( maxBr, sNum );
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl )
+        return;
+    lockZeichnung();
+    maxSpaltenBreite->set( maxBr, sNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setMaxSpaltenBreite( const char *name, int maxBr )
 {
-	setMaxSpaltenBreite( getSpaltenNummer( name ), maxBr );
+    setMaxSpaltenBreite( getSpaltenNummer( name ), maxBr );
 }
 
 void ObjTabelle::setMaxSpaltenBreite( Text *name, int maxBr )
 {
-	setMaxSpaltenBreite( getSpaltenNummer( name ), maxBr );
+    setMaxSpaltenBreite( getSpaltenNummer( name ), maxBr );
 }
 
 void ObjTabelle::setMinZeilenHöhe( int zNum, int minHö ) // setzt die mindest Zeilenhöhe
 {
-	if( zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	minZeilenHöhe->set( minHö, zNum );
-	rend = 1;
-	unlockZeichnung();
+    if( zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    minZeilenHöhe->set( minHö, zNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setMinZeilenHöhe( const char *name, int minHö )
 {
-	setMinZeilenHöhe( getZeilenNummer( name ), minHö );
+    setMinZeilenHöhe( getZeilenNummer( name ), minHö );
 }
 
 void ObjTabelle::setMinZeilenHöhe( Text *name, int minHö )
 {
-	setMinZeilenHöhe( getZeilenNummer( name ), minHö );
+    setMinZeilenHöhe( getZeilenNummer( name ), minHö );
 }
 
 void ObjTabelle::setMaxZeilenHöhe( int zNum, int maxHö ) // setzt die maximale Zeilenhöhe
 {
-	if( zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	maxZeilenHöhe->set( maxHö, zNum );
-	rend = 1;
-	unlockZeichnung();
+    if( zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    maxZeilenHöhe->set( maxHö, zNum );
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setMaxZeilenHöhe( const char *name, int maxHö )
 {
-	setMaxZeilenHöhe( getZeilenHöhe( name ), maxHö );
+    setMaxZeilenHöhe( getZeilenHöhe( name ), maxHö );
 }
 
 void ObjTabelle::setMaxZeilenHöhe( Text *name, int maxHö )
 {
-	setMaxZeilenHöhe( getZeilenHöhe( name ), maxHö );
+    setMaxZeilenHöhe( getZeilenHöhe( name ), maxHö );
 }
 
 void ObjTabelle::setAuswahl( int sNum, int zNum ) // wählt das entsprechnde Feld aus
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	lockZeichnung();
-	selected.x = sNum;
-	selected.y = zNum;
-	rend = 1;
-	unlockZeichnung();
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    lockZeichnung();
+    selected.x = sNum;
+    selected.y = zNum;
+    rend = 1;
+    unlockZeichnung();
 }
 
 void ObjTabelle::setAuswahl( const char *spaltenName, const char *zeilenName )
 {
-	setAuswahl( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    setAuswahl( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 void ObjTabelle::setAuswahl( Text *spaltenName, Text *zeilenName )
 {
-	setAuswahl( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    setAuswahl( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 void ObjTabelle::setRasterFarbe( int f ) // settzt die Farbe des Rasters
 {
-	rasterFarbe = f;
-	rend = 1;
+    rasterFarbe = f;
+    rend = 1;
 }
 
 void ObjTabelle::setRasterBreite( int br ) // setzt die Breite des Rasters
 {
-	rasterBreite = br;
-	rend = 1;
+    rasterBreite = br;
+    rend = 1;
 }
 
 void ObjTabelle::setARahmenZ( LRahmen *ram ) // setzt den auswahl Rahmen
 {
-	if( aRam )
-		aRam->release();
-	aRam = ram;
-	rend = 1;
+    if( aRam )
+        aRam->release();
+    aRam = ram;
+    rend = 1;
 }
 
 void ObjTabelle::setARFarbe( int f ) // setzt die auswahl Rahmen Farbe
 {
-	if( !aRam )
-		aRam = new LRahmen();
-	aRam->setFarbe( f );
-	rend = 1;
+    if( !aRam )
+        aRam = new LRahmen();
+    aRam->setFarbe( f );
+    rend = 1;
 }
 
 void ObjTabelle::setARBreite( int br ) // setzt die auswahl Rahmen Breite
 {
-	if( !aRam )
-		aRam = new LRahmen();
-	aRam->setRamenBreite( br );
-	rend = 1;
+    if( !aRam )
+        aRam = new LRahmen();
+    aRam->setRamenBreite( br );
+    rend = 1;
 }
 
 void ObjTabelle::setAAlphaFeldZ( AlphaFeld *af ) // setzt das auswahl AlphaFeld
 {
-	if( aAf )
-		aAf->release();
-	aAf = af;
-	rend = 1;
+    if( aAf )
+        aAf->release();
+    aAf = af;
+    rend = 1;
 }
 
 void ObjTabelle::setAAfFarbe( int f ) // setzt die Farbe des auswahl AlphaFeldes
 {
-	if( !aAf )
-		aAf = new AlphaFeld();
-	aAf->setFarbe( f );
-	rend = 1;
+    if( !aAf )
+        aAf = new AlphaFeld();
+    aAf->setFarbe( f );
+    rend = 1;
 }
 
 void ObjTabelle::setAAfStärke( int st ) // setzt die Stärke des auswahl AlphaFeldes
 {
-	if( !aAf )
-		aAf = new AlphaFeld();
-	aAf->setStärke( st );
-	rend = 1;
+    if( !aAf )
+        aAf = new AlphaFeld();
+    aAf->setStärke( st );
+    rend = 1;
 }
 
 void ObjTabelle::setARahmenZ( int sNum, int zNum, LRahmen *ram ) // setzt den auswahl Rahmen
 {
-	if( msaRam->z( sNum ) )
-		msaRam->z( sNum )->set( ram, zNum );
-	rend = 1;
+    if( msaRam->z( sNum ) )
+        msaRam->z( sNum )->set( ram, zNum );
+    rend = 1;
 }
 
 void ObjTabelle::setARahmenZ( const char *spaltenName, const char *zeilenName, LRahmen *ram )
 {
-	setARahmenZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), ram );
+    setARahmenZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), ram );
 }
 
 void ObjTabelle::setARahmenZ( Text *spaltenName, Text *zeilenName, LRahmen *ram )
 {
-	setARahmenZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), ram );
+    setARahmenZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), ram );
 }
 
 void ObjTabelle::setARFarbe( int sNum, int zNum, int f ) // setzt die auswahl Rahmen Farbe
 {
-	if( msaRam->z( sNum ) )
-	{
-		LRahmen *tmp = msaRam->z( sNum )->z( zNum );
-		if( !tmp )
-		{
-			tmp = new LRahmen();
-			msaRam->z( sNum )->set( tmp, zNum );
-		}
-		tmp->setFarbe( f );
-		rend = 1;
-	}
+    if( msaRam->z( sNum ) )
+    {
+        LRahmen *tmp = msaRam->z( sNum )->z( zNum );
+        if( !tmp )
+        {
+            tmp = new LRahmen();
+            msaRam->z( sNum )->set( tmp, zNum );
+        }
+        tmp->setFarbe( f );
+        rend = 1;
+    }
 }
 
 void ObjTabelle::setARFarbe( const char *spaltenName, const char *zeilenName, int f )
 {
-	setARFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
+    setARFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
 }
 
 void ObjTabelle::setARFarbe( Text *spaltenName, Text *zeilenName, int f )
 {
-	setARFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
+    setARFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
 }
 
 void ObjTabelle::setARBreite( int sNum, int zNum, int br ) // setzt die auswahl Rahmen Breite
 {
-	if( msaRam->z( sNum ) )
-	{
-		LRahmen *tmp = msaRam->z( sNum )->z( zNum );
-		if( !tmp )
-		{
-			tmp = new LRahmen();
-			msaRam->z( sNum )->set( tmp, zNum );
-		}
-		tmp->setRamenBreite( br );
-		rend = 1;
-	}
+    if( msaRam->z( sNum ) )
+    {
+        LRahmen *tmp = msaRam->z( sNum )->z( zNum );
+        if( !tmp )
+        {
+            tmp = new LRahmen();
+            msaRam->z( sNum )->set( tmp, zNum );
+        }
+        tmp->setRamenBreite( br );
+        rend = 1;
+    }
 }
 
 void ObjTabelle::setARBreite( const char *spaltenName, const char *zeilenName, int br )
 {
-	setARBreite( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), br );
+    setARBreite( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), br );
 }
 
 void ObjTabelle::setARBreite( Text *spaltenName, Text *zeilenName, int br )
 {
-	setARBreite( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), br );
+    setARBreite( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), br );
 }
 
 void ObjTabelle::setAAlphaFeldZ( int sNum, int zNum, AlphaFeld *af ) // setzt das auswahl AlphaFeld
 {
-	if( msaAf->z( sNum ) )
-		msaAf->z( sNum )->set( af, zNum );
-	rend = 1;
+    if( msaAf->z( sNum ) )
+        msaAf->z( sNum )->set( af, zNum );
+    rend = 1;
 }
 
 void ObjTabelle::setAAlphaFeldZ( const char *spaltenName, const char *zeilenName, AlphaFeld *af )
 {
-	setAAlphaFeldZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), af );
+    setAAlphaFeldZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), af );
 }
 
 void ObjTabelle::setAAlphaFeldZ( Text *spaltenName, Text *zeilenName, AlphaFeld *af )
 {
-	setAAlphaFeldZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), af );
+    setAAlphaFeldZ( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), af );
 }
 
 void ObjTabelle::setAAfFarbe( int sNum, int zNum, int f ) // setzt die Farbe des auswahl AlphaFeldes
 {
-	if( msaAf->z( sNum ) )
-	{
-		AlphaFeld *tmp = msaAf->z( sNum )->z( zNum );
-		if( !tmp )
-		{
-			tmp = new AlphaFeld();
-			msaAf->z( sNum )->set( tmp, zNum );
-		}
-		tmp->setFarbe( f );
-		rend = 1;
-	}
+    if( msaAf->z( sNum ) )
+    {
+        AlphaFeld *tmp = msaAf->z( sNum )->z( zNum );
+        if( !tmp )
+        {
+            tmp = new AlphaFeld();
+            msaAf->z( sNum )->set( tmp, zNum );
+        }
+        tmp->setFarbe( f );
+        rend = 1;
+    }
 }
 
 void ObjTabelle::setAAfFarbe( const char *spaltenName, const char *zeilenName, int f )
 {
-	setAAfFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
+    setAAfFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
 }
 
 void ObjTabelle::setAAfFarbe( Text *spaltenName, Text *zeilenName, int f )
 {
-	setAAfFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
+    setAAfFarbe( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), f );
 }
 
 void ObjTabelle::setAAfStärke( int sNum, int zNum, int st ) // setzt die Stärke des auswahl AlphaFeldes
 {
-	if( msaAf->z( sNum ) )
-	{
-		AlphaFeld *tmp = msaAf->z( sNum )->z( zNum );
-		if( !tmp )
-		{
-			tmp = new AlphaFeld();
-			msaAf->z( sNum )->set( tmp, zNum );
-		}
-		tmp->setStärke( st );
-		rend = 1;
-	}
+    if( msaAf->z( sNum ) )
+    {
+        AlphaFeld *tmp = msaAf->z( sNum )->z( zNum );
+        if( !tmp )
+        {
+            tmp = new AlphaFeld();
+            msaAf->z( sNum )->set( tmp, zNum );
+        }
+        tmp->setStärke( st );
+        rend = 1;
+    }
 }
 
 void ObjTabelle::setAAfStärke( const char *spaltenName, const char *zeilenName, int st )
 {
-	setAAfStärke( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), st );
+    setAAfStärke( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), st );
 }
 
 void ObjTabelle::setAAfStärke( Text *spaltenName, Text *zeilenName, int st )
 {
-	setAAfStärke( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), st );
+    setAAfStärke( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), st );
 }
 
 void ObjTabelle::addMsStyle( int sNum, int zNum, __int64 style ) // setzt den Style wenn Multistyled
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	if( styles->z( sNum ) )
-		styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) | style, zNum );
-	rend = 1;
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    if( styles->z( sNum ) )
+        styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) | style, zNum );
+    rend = 1;
 }
 
 void ObjTabelle::addMsStyle( const char *spaltenName, const char *zeilenName, __int64 style )
 {
-	addMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    addMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 void ObjTabelle::addMsStyle( Text *spaltenName, Text *zeilenName, __int64 style )
 {
-	addMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    addMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 void ObjTabelle::setMsStyle( int sNum, int zNum, __int64 style )
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	if( styles->z( sNum ) )
-		styles->z( sNum )->set( style, zNum );
-	rend = 1;
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    if( styles->z( sNum ) )
+        styles->z( sNum )->set( style, zNum );
+    rend = 1;
 }
 
 void ObjTabelle::setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style )
 {
-	setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 void ObjTabelle::setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style )
 {
-	setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 void ObjTabelle::setMsStyle( int sNum, int zNum, __int64 style, bool add_remove )
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	if( styles->z( sNum ) )
-	{
-		if( add_remove )
-			styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) | style, zNum );
-		else
-			styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) & ( ~style ), zNum );
-		rend = 1;
-	}
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    if( styles->z( sNum ) )
+    {
+        if( add_remove )
+            styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) | style, zNum );
+        else
+            styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) & ( ~style ), zNum );
+        rend = 1;
+    }
 }
 
 void ObjTabelle::setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style, bool add_remove )
 {
-	setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style, add_remove );
+    setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style, add_remove );
 }
 
 void ObjTabelle::setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style, bool add_remove )
 {
-	setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style, add_remove );
+    setMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style, add_remove );
 }
 
 void ObjTabelle::löscheMsStyle( int sNum, int zNum, __int64 style )
 {
-	if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
-		return;
-	if( styles->z( sNum ) )
-		styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) & ( ~style ), zNum );
-	rend = 1;
+    if( sNum >= spaltenAnzahl || zNum >= zeilenAnzahl )
+        return;
+    if( styles->z( sNum ) )
+        styles->z( sNum )->set( ( styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0 ) & ( ~style ), zNum );
+    rend = 1;
 }
 
 void ObjTabelle::löscheMsStyle( const char *spaltenName, const char *zeilenName, __int64 style )
 {
-	löscheMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    löscheMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 void ObjTabelle::löscheMsStyle( Text *spaltenName, Text *zeilenName, __int64 style )
 {
-	löscheMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    löscheMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 bool ObjTabelle::tick( double tickVal ) // tick Message
 {
-	lockZeichnung();
-	for( int i = 0; i < zeilenAnzahl; ++i )
-	{
-		for( int j = 0; j < spaltenAnzahl; ++j )
-		{
-			Zeichnung *obj = zZeichnung( j, i );
-			if( obj )
-				rend |= obj->tick( tickVal );
-		}
-	}
+    lockZeichnung();
+    for( int i = 0; i < zeilenAnzahl; ++i )
+    {
+        for( int j = 0; j < spaltenAnzahl; ++j )
+        {
+            Zeichnung *obj = zZeichnung( j, i );
+            if( obj )
+                rend |= obj->tick( tickVal );
+        }
+    }
     unlockZeichnung();
-	return __super::tick( tickVal );
+    return __super::tick( tickVal );
 }
 
 void ObjTabelle::doMausEreignis( MausEreignis &me ) // verarbeitet Nachrichten
 {
     bool nmakc = !me.verarbeitet;
-	if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
-		return;
-	bool removeFokus = 0;
-	if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
-	{
-		if( mausIn )
-		{
-			mausIn = 0;
-			MausEreignis me2;
-			me2.id = ME_Verlässt;
-			me2.mx = me.mx;
-			me2.my = me.my;
-			me2.verarbeitet = 0;
-			doMausEreignis( me2 );
-			return;
-		}
-		removeFokus = 1;
-	}
-	bool außerhalb = !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt;
-	bool MakB = Mak && ( me.verarbeitet || außerhalb || Mak( makParam, this, me ) );
-	if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt )
-	{
-		if( removeFokus && me.id == ME_RLinks )
-		{
-			if( MakB )
-				löscheStyle( Style::Fokus );
-		}
-	}
-	else if( !mausIn && me.id != ME_Verlässt )
-	{
-		mausIn = 1;
-		MausEreignis me2;
-		me2.id = ME_Betritt;
-		me2.mx = me.mx;
-		me2.my = me.my;
-		me2.verarbeitet = 0;
-		doMausEreignis( me2 );
-	}
-	int tmx = me.mx;
-	int tmy = me.my;
-	bool aufScroll = 0;
-	if( !außerhalb && vertikalScrollBar && hatStyle( Style::VScroll ) && me.mx > pos.x + gr.x - 15 )
-		aufScroll = 1;
-	if( !außerhalb && horizontalScrollBar && hatStyle( Style::HScroll ) && me.my > pos.y + gr.y - 15 )
-		aufScroll = 1;
-	me.mx -= pos.x + ( ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0 );
-	me.my -= pos.y + ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0 );
-	if( MakB )
-	{
-		lockZeichnung();
-		if( removeFokus && me.id == ME_RLinks )
-		{
-			löscheStyle( Style::Fokus );
-			klickSpalte = -1;
-		}
-		if( !me.verarbeitet && !außerhalb && !aufScroll )
-		{
-			double ox = getMausSpalte( me.mx + ( ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0 ) );
-			double oy = getMausZeile( me.my + ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0 ) );
-			if( me.id == ME_RLinks )
-			{
-				addStyle( Style::Fokus );
-				klickSpalte = -1;
-				mSpalte = -1, mZeile = -1;
-			}
-			if( ( hatStyle( Style::SpaltenBreiteÄnderbar ) || hatStyle( Style::ZeilenHöheÄnderbar ) ) && klickSpalte < 0 )
-			{
-				if( hatStyle( Style::SpaltenBreiteÄnderbar ) )
-				{
-					if( me.id == ME_PLinks && ox != (int)ox )
-					{
-						mSpalte = ox;
-						mx = me.mx;
-						rend = 1;
-					}
-					if( mSpalte > -1 )
-					{
-						int br = getSpaltenBreite( (int)mSpalte ) + ( me.mx - mx );
-						if( hatStyle( Style::SpaltenBreiteMax ) && br > getMaxSpaltenBreite( (int)mSpalte ) )
-							br = getMaxSpaltenBreite( (int)mSpalte );
-						if( hatStyle( Style::SpaltenBreiteMin ) && br < getMinSpaltenBreite( (int)mSpalte ) )
-							br = getMinSpaltenBreite( (int)mSpalte );
-						setSpaltenBreite( (int)mSpalte, br );
-						mx = me.mx;
-						rend = 1;
-					}
-				}
-				if( hatStyle( Style::ZeilenHöheÄnderbar ) )
-				{
-					if( me.id == ME_PLinks && oy != (int)oy )
-					{
-						mZeile = oy;
-						my = me.my;
-						rend = 1;
-					}
-					if( mZeile > -1 )
-					{
-						int hö = getZeilenHöhe( (int)mZeile ) + ( me.my - my );
-						if( hatStyle( Style::ZeilenHöheMax ) && hö > getMaxZeilenHöhe( (int)mZeile ) )
-							hö = getMaxZeilenHöhe( (int)mZeile );
-						if( hatStyle( Style::ZeilenHöheMin ) && hö < getMinZeilenHöhe( (int)mZeile ) )
-							hö = getMinZeilenHöhe( (int)mZeile );
-						setZeilenHöhe( (int)mZeile, hö );
-						my = me.my;
-						rend = 1;
-					}
-				}
-			}
-			if( hatStyle( Style::SpaltenBeweglich ) && ox == (int)ox && mSpalte == -1 && mZeile == -1 )
-			{
-				if( klickSpalte >= 0 && klickSpalte < spaltenAnzahl && klickSpalte != ox && !oy && ox >= 0 )
-				{
-					setSpaltePosition( klickSpalte, (int)ox );
-					klickSpalte = (int)ox;
-					rend = 1;
-				}
-				if( me.id == ME_PLinks )
-				{
-					if( !oy && klickSpalte < 0 )
-					{
-						klickSpalte = (int)ox;
-						rend = 1;
-					}
-				}
-			}
-		}
+    if( hatStyleNicht( Style::Sichtbar ) || hatStyleNicht( Style::Erlaubt ) )
+        return;
+    bool removeFokus = 0;
+    if( me.verarbeitet || !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) )
+    {
+        if( mausIn )
+        {
+            mausIn = 0;
+            MausEreignis me2;
+            me2.id = ME_Verlässt;
+            me2.mx = me.mx;
+            me2.my = me.my;
+            me2.verarbeitet = 0;
+            doMausEreignis( me2 );
+            return;
+        }
+        removeFokus = 1;
+    }
+    bool außerhalb = !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt;
+    bool MakB = Mak && ( me.verarbeitet || außerhalb || Mak( makParam, this, me ) );
+    if( !( me.mx >= pos.x && me.mx <= pos.x + gr.x && me.my >= pos.y && me.my <= pos.y + gr.y ) && me.id != ME_Verlässt )
+    {
+        if( removeFokus && me.id == ME_RLinks )
+        {
+            if( MakB )
+                löscheStyle( Style::Fokus );
+        }
+    }
+    else if( !mausIn && me.id != ME_Verlässt )
+    {
+        mausIn = 1;
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx;
+        me2.my = me.my;
+        me2.verarbeitet = 0;
+        doMausEreignis( me2 );
+    }
+    int tmx = me.mx;
+    int tmy = me.my;
+    bool aufScroll = 0;
+    if( !außerhalb && vertikalScrollBar && hatStyle( Style::VScroll ) && me.mx > pos.x + gr.x - 15 )
+        aufScroll = 1;
+    if( !außerhalb && horizontalScrollBar && hatStyle( Style::HScroll ) && me.my > pos.y + gr.y - 15 )
+        aufScroll = 1;
+    me.mx -= pos.x + ( ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0 );
+    me.my -= pos.y + ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0 );
+    if( MakB )
+    {
+        lockZeichnung();
+        if( removeFokus && me.id == ME_RLinks )
+        {
+            löscheStyle( Style::Fokus );
+            klickSpalte = -1;
+        }
+        if( !me.verarbeitet && !außerhalb && !aufScroll )
+        {
+            double ox = getMausSpalte( me.mx + ( ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0 ) );
+            double oy = getMausZeile( me.my + ( ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0 ) );
+            if( me.id == ME_RLinks )
+            {
+                addStyle( Style::Fokus );
+                klickSpalte = -1;
+                mSpalte = -1, mZeile = -1;
+            }
+            if( ( hatStyle( Style::SpaltenBreiteÄnderbar ) || hatStyle( Style::ZeilenHöheÄnderbar ) ) && klickSpalte < 0 )
+            {
+                if( hatStyle( Style::SpaltenBreiteÄnderbar ) )
+                {
+                    if( me.id == ME_PLinks && ox != (int)ox )
+                    {
+                        mSpalte = ox;
+                        mx = me.mx;
+                        rend = 1;
+                    }
+                    if( mSpalte > -1 )
+                    {
+                        int br = getSpaltenBreite( (int)mSpalte ) + ( me.mx - mx );
+                        if( hatStyle( Style::SpaltenBreiteMax ) && br > getMaxSpaltenBreite( (int)mSpalte ) )
+                            br = getMaxSpaltenBreite( (int)mSpalte );
+                        if( hatStyle( Style::SpaltenBreiteMin ) && br < getMinSpaltenBreite( (int)mSpalte ) )
+                            br = getMinSpaltenBreite( (int)mSpalte );
+                        setSpaltenBreite( (int)mSpalte, br );
+                        mx = me.mx;
+                        rend = 1;
+                    }
+                }
+                if( hatStyle( Style::ZeilenHöheÄnderbar ) )
+                {
+                    if( me.id == ME_PLinks && oy != (int)oy )
+                    {
+                        mZeile = oy;
+                        my = me.my;
+                        rend = 1;
+                    }
+                    if( mZeile > -1 )
+                    {
+                        int hö = getZeilenHöhe( (int)mZeile ) + ( me.my - my );
+                        if( hatStyle( Style::ZeilenHöheMax ) && hö > getMaxZeilenHöhe( (int)mZeile ) )
+                            hö = getMaxZeilenHöhe( (int)mZeile );
+                        if( hatStyle( Style::ZeilenHöheMin ) && hö < getMinZeilenHöhe( (int)mZeile ) )
+                            hö = getMinZeilenHöhe( (int)mZeile );
+                        setZeilenHöhe( (int)mZeile, hö );
+                        my = me.my;
+                        rend = 1;
+                    }
+                }
+            }
+            if( hatStyle( Style::SpaltenBeweglich ) && ox == (int)ox && mSpalte == -1 && mZeile == -1 )
+            {
+                if( klickSpalte >= 0 && klickSpalte < spaltenAnzahl && klickSpalte != ox && !oy && ox >= 0 )
+                {
+                    setSpaltePosition( klickSpalte, (int)ox );
+                    klickSpalte = (int)ox;
+                    rend = 1;
+                }
+                if( me.id == ME_PLinks )
+                {
+                    if( !oy && klickSpalte < 0 )
+                    {
+                        klickSpalte = (int)ox;
+                        rend = 1;
+                    }
+                }
+            }
+        }
         me.mx += ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
         me.my += ( vertikalScrollBar && hatStyle( Style::VScroll ) ) ? vertikalScrollBar->getScroll() : 0;
-		if( me.id != ME_Betritt && me.id != ME_Verlässt )
-		{
-			if( !außerhalb )
-			{
-				bool vs = hatStyle( Style::VScroll ) && vertikalScrollBar;
-				bool hs = hatStyle( Style::HScroll ) && horizontalScrollBar;
-				int rbr = rahmen ? rahmen->getRBreite() : 0;
-				if( vs )
-				{
-					if( hs )
-						horizontalScrollBar->doMausMessage( rbr, gr.y - 15 - rbr, gr.x - 15 - rbr * 2, 15, me );
-					vertikalScrollBar->doMausMessage( gr.x - 15 - rbr, rbr, 15, gr.y - rbr * 2, me );
-				}
-				else if( hs )
-					horizontalScrollBar->doMausMessage( rbr, gr.y - 15 - rbr, gr.x - rbr * 2, 15, me );
-			}
-			unlockZeichnung();
-			if( aufScroll )
-				me.verarbeitet = 1;
-			for( int i = 0; i < zeilenAnzahl; ++i )
-			{
-				for( int j = 0; j < spaltenAnzahl; ++j )
-				{
-					bool b = me.verarbeitet;
-					Zeichnung *obj = zZeichnung( j, i );
-					if( obj )
-						obj->doMausEreignis( me );
-					if( !b && me.verarbeitet && me.id == ME_PLinks )
-						selected = Punkt( j, i );
-				}
-			}
-		}
-		else
-			unlockZeichnung();
-		if( me.mx >= 0 && me.mx <= gr.x && me.my >= 0 && me.my <= gr.y )
-			me.verarbeitet = 1;
-	}
+        if( me.id != ME_Betritt && me.id != ME_Verlässt )
+        {
+            if( !außerhalb )
+            {
+                bool vs = hatStyle( Style::VScroll ) && vertikalScrollBar;
+                bool hs = hatStyle( Style::HScroll ) && horizontalScrollBar;
+                int rbr = rahmen ? rahmen->getRBreite() : 0;
+                if( vs )
+                {
+                    if( hs )
+                        horizontalScrollBar->doMausMessage( rbr, gr.y - 15 - rbr, gr.x - 15 - rbr * 2, 15, me );
+                    vertikalScrollBar->doMausMessage( gr.x - 15 - rbr, rbr, 15, gr.y - rbr * 2, me );
+                }
+                else if( hs )
+                    horizontalScrollBar->doMausMessage( rbr, gr.y - 15 - rbr, gr.x - rbr * 2, 15, me );
+            }
+            unlockZeichnung();
+            if( aufScroll )
+                me.verarbeitet = 1;
+            for( int i = 0; i < zeilenAnzahl; ++i )
+            {
+                for( int j = 0; j < spaltenAnzahl; ++j )
+                {
+                    bool b = me.verarbeitet;
+                    Zeichnung *obj = zZeichnung( j, i );
+                    if( obj )
+                        obj->doMausEreignis( me );
+                    if( !b && me.verarbeitet && me.id == ME_PLinks )
+                        selected = Punkt( j, i );
+                }
+            }
+        }
+        else
+            unlockZeichnung();
+        if( me.mx >= 0 && me.mx <= gr.x && me.my >= 0 && me.my <= gr.y )
+            me.verarbeitet = 1;
+    }
     if( nmakc && me.verarbeitet && nMak )
         me.verarbeitet = nMak( nmakParam, this, me );
-	me.mx = tmx;
-	me.my = tmy;
+    me.mx = tmx;
+    me.my = tmy;
 }
 
 void ObjTabelle::doTastaturEreignis( TastaturEreignis &te )
 {
     bool ntakc = !te.verarbeitet;
-	if( hatStyleNicht( Style::Fokus ) || hatStyleNicht( Style::Erlaubt ) || hatStyleNicht( Style::Sichtbar ) )
-		return;
-	if( Tak && ( te.verarbeitet || Tak( takParam, this, te ) ) )
-	{
-		lockZeichnung();
-		if( zZeichnung( selected.x, selected.y ) )
-		{
-			zZeichnung( selected.x, selected.y )->doTastaturEreignis( te );
-			if( !te.verarbeitet && te.id == TE_Press )
-			{
-				if( te.taste == T_Oben )
-				{
-					--( selected.y );
-					rend = 1;
-				}
-				if( te.taste == T_Unten )
-				{
-					++( selected.y );
-					rend = 1;
-				}
-				if( te.taste == T_Links )
-				{
-					--( selected.x );
-					rend = 1;
-				}
-				if( te.taste == T_Rechts )
-				{
-					++( selected.x );
-					rend = 1;
-				}
-			}
-		}
-		unlockZeichnung();
-	}
-	te.verarbeitet = 1;
+    if( hatStyleNicht( Style::Fokus ) || hatStyleNicht( Style::Erlaubt ) || hatStyleNicht( Style::Sichtbar ) )
+        return;
+    if( Tak && ( te.verarbeitet || Tak( takParam, this, te ) ) )
+    {
+        lockZeichnung();
+        if( zZeichnung( selected.x, selected.y ) )
+        {
+            zZeichnung( selected.x, selected.y )->doTastaturEreignis( te );
+            if( !te.verarbeitet && te.id == TE_Press )
+            {
+                if( te.taste == T_Oben )
+                {
+                    --( selected.y );
+                    rend = 1;
+                }
+                if( te.taste == T_Unten )
+                {
+                    ++( selected.y );
+                    rend = 1;
+                }
+                if( te.taste == T_Links )
+                {
+                    --( selected.x );
+                    rend = 1;
+                }
+                if( te.taste == T_Rechts )
+                {
+                    ++( selected.x );
+                    rend = 1;
+                }
+            }
+        }
+        unlockZeichnung();
+    }
+    te.verarbeitet = 1;
     if( ntakc && te.verarbeitet && nTak )
         te.verarbeitet = nTak( ntakParam, this, te );
 }
 
 void ObjTabelle::render( Bild &zRObj ) // zeichnet nach zRObj
 {
-	if( hatStyleNicht( Style::Sichtbar ) )
-		return;
+    if( hatStyleNicht( Style::Sichtbar ) )
+        return;
     __super::render( zRObj );
     lockZeichnung();
-	if( !zRObj.setDrawOptions( innenPosition, innenGröße ) )
-	{
-		unlockZeichnung();
-		return;
-	}
-	int xPos = 0;
-	if( horizontalScrollBar && hatStyle( Style::HScroll ) )
-		xPos -= horizontalScrollBar->getScroll();
-	for( int s = 0; s < spaltenAnzahl; ++s )
-	{
-		int sBr = spaltenBreite->hat( s ) ? spaltenBreite->get( s ) : 0;
-		int yPos = 0;
-		if( vertikalScrollBar && hatStyle( Style::VScroll ) )
-			yPos -= vertikalScrollBar->getScroll();
-		Array< Zeichnung* > *tmp_zZeichnungs = zZeichnungs->z( s );
-		if( !tmp_zZeichnungs )
-			continue;
-		for( int z = 0; z < zeilenAnzahl && tmp_zZeichnungs; ++z )
-		{
-			int zHö = zeilenHöhe->hat( z ) ? zeilenHöhe->get( z ) : 0;
-			Zeichnung *obj = tmp_zZeichnungs->hat( z ) ? tmp_zZeichnungs->get( z ) : 0;
-			if( obj )
-			{
-				obj->setPosition( xPos, yPos );
-				obj->setGröße( sBr, zHö );
-				obj->render( zRObj );
-				if( selected.x == s && selected.y == z )
-				{
-					LRahmen *tmp_aRam = aRam;
-					AlphaFeld *tmp_aAf = aAf;
-					bool aRamB = hatStyle( Style::AuswahlRahmen ) && tmp_aRam;
-					bool aAfB = hatStyle( Style::AuswahlBuffer ) && tmp_aAf;
-					if( hatStyle( Style::AuswahlMultistyled ) )
-					{
-						tmp_aRam = getARahmen( s, z );
-						tmp_aAf = getAAlphaFeld( s, z );
-						aRamB = hatMsStyle( s, z, Style::AuswahlRahmen ) && tmp_aRam;
-						aAfB = hatMsStyle( s, z, Style::AuswahlBuffer ) && tmp_aAf;
-					}
-					int aRbr = 0;
-					if( aRamB )
-					{
-						tmp_aRam->setPosition( xPos, yPos );
-						tmp_aRam->setGröße( sBr, zHö );
-						tmp_aRam->render( zRObj );
-						aRbr = tmp_aRam->getRBreite();
-					}
-					if( aAfB )
-					{
-						tmp_aAf->setPosition( aRbr + xPos, aRbr + yPos );
-						tmp_aAf->setGröße( sBr - aRbr * 2, zHö - aRbr * 2 );
-						tmp_aAf->render( zRObj );
-					}
-				}
-			}
-			if( hatStyle( Style::Raster ) )
-			{
-				zRObj.drawLinieH( xPos, yPos + zHö, sBr, rasterFarbe );
-				yPos += rasterBreite;
-			}
-			yPos += zHö;
-			if( z == zeilenAnzahl - 1 && vertikalScrollBar && hatStyle( Style::VScroll ) )
-				vertikalScrollBar->getScrollData()->max = yPos + vertikalScrollBar->getScroll();
-		}
-		if( hatStyle( Style::Raster ) )
-		{
-			zRObj.drawLinieV( xPos + sBr, 0, innenGröße.y, rasterFarbe );
-			xPos += rasterBreite;
-		}
-		xPos += sBr;
-	}
-	if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+    if( !zRObj.setDrawOptions( innenPosition, innenGröße ) )
+    {
+        unlockZeichnung();
+        return;
+    }
+    int xPos = 0;
+    if( horizontalScrollBar && hatStyle( Style::HScroll ) )
+        xPos -= horizontalScrollBar->getScroll();
+    for( int s = 0; s < spaltenAnzahl; ++s )
+    {
+        int sBr = spaltenBreite->hat( s ) ? spaltenBreite->get( s ) : 0;
+        int yPos = 0;
+        if( vertikalScrollBar && hatStyle( Style::VScroll ) )
+            yPos -= vertikalScrollBar->getScroll();
+        Array< Zeichnung* > *tmp_zZeichnungs = zZeichnungs->z( s );
+        if( !tmp_zZeichnungs )
+            continue;
+        for( int z = 0; z < zeilenAnzahl && tmp_zZeichnungs; ++z )
+        {
+            int zHö = zeilenHöhe->hat( z ) ? zeilenHöhe->get( z ) : 0;
+            Zeichnung *obj = tmp_zZeichnungs->hat( z ) ? tmp_zZeichnungs->get( z ) : 0;
+            if( obj )
+            {
+                obj->setPosition( xPos, yPos );
+                obj->setGröße( sBr, zHö );
+                obj->render( zRObj );
+                if( selected.x == s && selected.y == z )
+                {
+                    LRahmen *tmp_aRam = aRam;
+                    AlphaFeld *tmp_aAf = aAf;
+                    bool aRamB = hatStyle( Style::AuswahlRahmen ) && tmp_aRam;
+                    bool aAfB = hatStyle( Style::AuswahlBuffer ) && tmp_aAf;
+                    if( hatStyle( Style::AuswahlMultistyled ) )
+                    {
+                        tmp_aRam = getARahmen( s, z );
+                        tmp_aAf = getAAlphaFeld( s, z );
+                        aRamB = hatMsStyle( s, z, Style::AuswahlRahmen ) && tmp_aRam;
+                        aAfB = hatMsStyle( s, z, Style::AuswahlBuffer ) && tmp_aAf;
+                    }
+                    int aRbr = 0;
+                    if( aRamB )
+                    {
+                        tmp_aRam->setPosition( xPos, yPos );
+                        tmp_aRam->setGröße( sBr, zHö );
+                        tmp_aRam->render( zRObj );
+                        aRbr = tmp_aRam->getRBreite();
+                    }
+                    if( aAfB )
+                    {
+                        tmp_aAf->setPosition( aRbr + xPos, aRbr + yPos );
+                        tmp_aAf->setGröße( sBr - aRbr * 2, zHö - aRbr * 2 );
+                        tmp_aAf->render( zRObj );
+                    }
+                }
+            }
+            if( hatStyle( Style::Raster ) )
+            {
+                zRObj.drawLinieH( xPos, yPos + zHö, sBr, rasterFarbe );
+                yPos += rasterBreite;
+            }
+            yPos += zHö;
+            if( z == zeilenAnzahl - 1 && vertikalScrollBar && hatStyle( Style::VScroll ) )
+                vertikalScrollBar->getScrollData()->max = yPos + vertikalScrollBar->getScroll();
+        }
+        if( hatStyle( Style::Raster ) )
+        {
+            zRObj.drawLinieV( xPos + sBr, 0, innenGröße.y, rasterFarbe );
+            xPos += rasterBreite;
+        }
+        xPos += sBr;
+    }
+    if( horizontalScrollBar && hatStyle( Style::HScroll ) )
         horizontalScrollBar->getScrollData()->max = xPos + horizontalScrollBar->getScroll();
-	zRObj.releaseDrawOptions();
-	unlockZeichnung();
+    zRObj.releaseDrawOptions();
+    unlockZeichnung();
 }
 
 // constant 
 int ObjTabelle::getSpaltenAnzahl() const // gibt die Anzahl der Spalten zurück
 {
-	return spaltenAnzahl;
+    return spaltenAnzahl;
 }
 
 int ObjTabelle::getZeilenAnzahl() const // gibt die Anzahl der Zeilen zurück
 {
-	return zeilenAnzahl;
+    return zeilenAnzahl;
 }
 
 int ObjTabelle::getSpaltenNummer( const char *name ) const // gibt die Nummer der Spalte mit dem Namen name zurück
 {
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		if( spaltenNamen->z( i )->istGleich( name ) )
-			return i;
-	}
-	return -1;
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        if( spaltenNamen->z( i )->istGleich( name ) )
+            return i;
+    }
+    return -1;
 }
 
 int ObjTabelle::getSpaltenNummer( Text *name ) const
 {
-	int ret = getSpaltenNummer( name->getText() );
-	name->release();
-	return ret;
+    int ret = getSpaltenNummer( name->getText() );
+    name->release();
+    return ret;
 }
 
 Text *ObjTabelle::getSpaltenName( int num ) const // gibt den Namen der Spalte mit Nummer num zurück
 {
-	return spaltenNamen->get( num );
+    return spaltenNamen->get( num );
 }
 
 Text *ObjTabelle::zSpaltenName( int num ) const
 {
-	return spaltenNamen->z( num );
+    return spaltenNamen->z( num );
 }
 
 int ObjTabelle::getZeilenNummer( const char *name ) const // gibt die Nummer der Zeile mit dem Namen name zurück
 {
-	for( int i = 0; i < zeilenAnzahl; ++i )
-	{
-		if( zeilenNamen->z( i )->istGleich( name ) )
-			return i;
-	}
-	return -1;
+    for( int i = 0; i < zeilenAnzahl; ++i )
+    {
+        if( zeilenNamen->z( i )->istGleich( name ) )
+            return i;
+    }
+    return -1;
 }
 
 int ObjTabelle::getZeilenNummer( Text *name ) const
 {
-	int ret = getZeilenNummer( name->getText() );
-	name->release();
-	return ret;
+    int ret = getZeilenNummer( name->getText() );
+    name->release();
+    return ret;
 }
 
 Text *ObjTabelle::getZeilenName( int num ) const // gibt den Namen der Zeile mit Nummer num zurück
 {
-	return zeilenNamen->get( num );
+    return zeilenNamen->get( num );
 }
 
 Text *ObjTabelle::zZeilenName( int num ) const
 {
-	return zeilenNamen->z( num );
+    return zeilenNamen->z( num );
 }
 
 Punkt ObjTabelle::getZeichnungPosition( Zeichnung *zObj ) const // gibt die Position eines Zeichnungs zurück
 {
-	for( int x = 0; x < spaltenAnzahl; ++x )
-	{
-		for( int y = 0; y < zeilenAnzahl; ++y )
-		{
-			if( zZeichnung( x, y ) == zObj )
-				return Punkt( x, y  );
-		}
-	}
-	return Punkt( -1, -1 );
+    for( int x = 0; x < spaltenAnzahl; ++x )
+    {
+        for( int y = 0; y < zeilenAnzahl; ++y )
+        {
+            if( zZeichnung( x, y ) == zObj )
+                return Punkt( x, y );
+        }
+    }
+    return Punkt( -1, -1 );
 }
 
 Zeichnung *ObjTabelle::zZeichnung( int sNum, int zNum ) const // gibt das Zeichnung auf der Position zurück
 {
-	if( !zZeichnungs->z( sNum ) )
-		return 0;
-	Array< Zeichnung* > *tmp = zZeichnungs->z( sNum );
-	if( !tmp->hat( zNum ) )
-		return 0;
-	return tmp ? tmp->get( zNum ) : 0;
+    if( !zZeichnungs->z( sNum ) )
+        return 0;
+    Array< Zeichnung* > *tmp = zZeichnungs->z( sNum );
+    if( !tmp->hat( zNum ) )
+        return 0;
+    return tmp ? tmp->get( zNum ) : 0;
 }
 
 Zeichnung *ObjTabelle::zZeichnung( const char *spaltenName, const char *zeilenName ) const
 {
-	return zZeichnung( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zZeichnung( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 Zeichnung *ObjTabelle::zZeichnung( Text *spaltenName, Text *zeilenName ) const
 {
-	return zZeichnung( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zZeichnung( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 int ObjTabelle::getSpaltenBreite( int num ) const // gibt die Breite der Spalte zurück
 {
-	return spaltenBreite->get( num );
+    return spaltenBreite->get( num );
 }
 
 int ObjTabelle::getSpaltenBreite( const char *name ) const
 {
-	return getSpaltenBreite( getSpaltenNummer( name ) );
+    return getSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getSpaltenBreite( Text *name ) const
 {
-	return getSpaltenBreite( getSpaltenNummer( name ) );
+    return getSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getZeilenHöhe( int num ) const // gibt die Höhe der Zeile zurück
 {
-	return zeilenHöhe->get( num );
+    return zeilenHöhe->get( num );
 }
 
 int ObjTabelle::getZeilenHöhe( const char *name ) const
 {
-	return getZeilenHöhe( getZeilenNummer( name ) );
+    return getZeilenHöhe( getZeilenNummer( name ) );
 }
 
 int ObjTabelle::getZeilenHöhe( Text *name ) const
 {
-	return getZeilenHöhe( getZeilenNummer( name ) );
+    return getZeilenHöhe( getZeilenNummer( name ) );
 }
 
 int ObjTabelle::getMinSpaltenBreite( int num ) const // gibt die minimale Spaltengröße zurück
 {
-	return minSpaltenBreite->get( num );
+    return minSpaltenBreite->get( num );
 }
 
 int ObjTabelle::getMinSpaltenBreite( const char *name ) const
 {
-	return getMinSpaltenBreite( getSpaltenNummer( name ) );
+    return getMinSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getMinSpaltenBreite( Text *name ) const
 {
-	return getMinSpaltenBreite( getSpaltenNummer( name ) );
+    return getMinSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getMaxSpaltenBreite( int num ) const // gibt die maximale Spaltengröße zurück
 {
-	return maxSpaltenBreite->get( num );
+    return maxSpaltenBreite->get( num );
 }
 
 int ObjTabelle::getMaxSpaltenBreite( const char *name ) const
 {
-	return getMaxSpaltenBreite( getSpaltenNummer( name ) );
+    return getMaxSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getMaxSpaltenBreite( Text *name ) const
 {
-	return getMaxSpaltenBreite( getSpaltenNummer( name ) );
+    return getMaxSpaltenBreite( getSpaltenNummer( name ) );
 }
 
 int ObjTabelle::getMinZeilenHöhe( int num ) const // gibt die minimale Zeilenhöhe zurück
 {
-	return minZeilenHöhe->get( num );
+    return minZeilenHöhe->get( num );
 }
 
 int ObjTabelle::getMinZeilenHöhe( const char *name ) const
 {
-	return getMinZeilenHöhe( getZeilenNummer( name ) );
+    return getMinZeilenHöhe( getZeilenNummer( name ) );
 }
 
 int ObjTabelle::getMinZeilenHöhe( Text *name ) const
 {
-	return getMinZeilenHöhe( getZeilenNummer( name ) );
+    return getMinZeilenHöhe( getZeilenNummer( name ) );
 }
 
 int ObjTabelle::getMaxZeilenHöhe( int num ) const // gibt die maximale Zeilenhöhe zurück
 {
-	return maxZeilenHöhe->get( num );
+    return maxZeilenHöhe->get( num );
 }
 
 int ObjTabelle::getMaxZeilenHöhe( const char *name ) const
 {
-	return getMaxZeilenHöhe( getZeilenNummer( name ) );
+    return getMaxZeilenHöhe( getZeilenNummer( name ) );
 }
 
 int ObjTabelle::getMaxZeilenHöhe( Text *name ) const
 {
-	return getMaxZeilenHöhe( getZeilenNummer( name ) );
+    return getMaxZeilenHöhe( getZeilenNummer( name ) );
 }
 
 double ObjTabelle::getMausSpalte( int mx ) const // ermittelt die Spalte unter der Maus
 {
-	if( mx >= gr.x )
-		return -1;
-	int hsBeg = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
-	mx += hsBeg;
-	if( mx < 0 )
-		return -1;
-	int xx = rahmen ? rahmen->getRBreite() : 0;
-	for( int i = 0; i < spaltenAnzahl; ++i )
-	{
-		xx += spaltenBreite->get( i );
-		if( mx < xx - 5 )
-			return i;
-		if( mx < xx + 5 )
-			return i + 0.5;
-		xx += rasterBreite;
-	}
-	return -1;
+    if( mx >= gr.x )
+        return -1;
+    int hsBeg = ( horizontalScrollBar && hatStyle( Style::HScroll ) ) ? horizontalScrollBar->getScroll() : 0;
+    mx += hsBeg;
+    if( mx < 0 )
+        return -1;
+    int xx = rahmen ? rahmen->getRBreite() : 0;
+    for( int i = 0; i < spaltenAnzahl; ++i )
+    {
+        xx += spaltenBreite->get( i );
+        if( mx < xx - 5 )
+            return i;
+        if( mx < xx + 5 )
+            return i + 0.5;
+        xx += rasterBreite;
+    }
+    return -1;
 }
 
 Text *ObjTabelle::getMausSpaltenName( int mx ) const
 {
-	double tmp = getMausSpalte( mx );
-	if( tmp != (int)tmp )
-		return 0;
-	return getSpaltenName( (int)tmp );
+    double tmp = getMausSpalte( mx );
+    if( tmp != (int)tmp )
+        return 0;
+    return getSpaltenName( (int)tmp );
 }
 
 Text *ObjTabelle::zMausSpaltenName( int mx ) const
 {
-	double tmp = getMausSpalte( mx );
-	if( tmp != (int)tmp )
-		return 0;
-	return zSpaltenName( (int)tmp );
+    double tmp = getMausSpalte( mx );
+    if( tmp != (int)tmp )
+        return 0;
+    return zSpaltenName( (int)tmp );
 }
 
 double ObjTabelle::getMausZeile( int my ) const // ermittelt die Zeile unter der Maus
 {
-	if( my >= gr.y )
-		return -1;
-	if( my < 0 )
-		return -1;
+    if( my >= gr.y )
+        return -1;
+    if( my < 0 )
+        return -1;
     int vsBeg = vertikalScrollBar && hatStyle( Style::VScroll ) ? vertikalScrollBar->getScroll() : 0;
     my += vsBeg;
-	int yy = rahmen ? rahmen->getRBreite() : 0;
-	for( int i = 0; i < zeilenAnzahl; ++i )
-	{
-		yy += zeilenHöhe->get( i );
-		if( my < yy - 5 )
-			return i;
-		if( my < yy + 5 )
-			return i + 0.5;
-		yy += rasterBreite;
-	}
-	return -1;
+    int yy = rahmen ? rahmen->getRBreite() : 0;
+    for( int i = 0; i < zeilenAnzahl; ++i )
+    {
+        yy += zeilenHöhe->get( i );
+        if( my < yy - 5 )
+            return i;
+        if( my < yy + 5 )
+            return i + 0.5;
+        yy += rasterBreite;
+    }
+    return -1;
 }
 
 Text *ObjTabelle::getMausZeilenName( int my ) const
 {
-	double tmp = getMausZeile( my );
-	if( tmp != (int)tmp )
-		return 0;
-	return getZeilenName( (int)tmp );
+    double tmp = getMausZeile( my );
+    if( tmp != (int)tmp )
+        return 0;
+    return getZeilenName( (int)tmp );
 }
 
 Text *ObjTabelle::zMausZeilenName( int my ) const
 {
-	double tmp = getMausZeile( my );
-	if( tmp != (int)tmp )
-		return 0;
-	return zZeilenName( (int)tmp );
+    double tmp = getMausZeile( my );
+    if( tmp != (int)tmp )
+        return 0;
+    return zZeilenName( (int)tmp );
 }
 
 const Punkt &ObjTabelle::getAuswahlPosition() const // gibt die Auswahl Position zurück
 {
-	return selected;
+    return selected;
 }
 
 int ObjTabelle::getRasterFarbe() const // gibt die Farbe des Rasters zurück
 {
-	return rasterFarbe;
+    return rasterFarbe;
 }
 
 int ObjTabelle::getRasterBreite() const // gibt die Breite des Rasters zurück
 {
-	return rasterBreite;
+    return rasterBreite;
 }
 
 LRahmen *ObjTabelle::getARahmen() const // gibt den auswahl Rahmen zurück
 {
-	return aRam ? aRam->getThis() : 0;
+    return aRam ? aRam->getThis() : 0;
 }
 
 LRahmen *ObjTabelle::zARahmen() const
 {
-	return aRam;
+    return aRam;
 }
 
 AlphaFeld *ObjTabelle::getAAlphaFeld() const // gibt das auswahl AlphaFeld zurück
 {
-	return aAf ? aAf->getThis() : 0;
+    return aAf ? aAf->getThis() : 0;
 }
 
 AlphaFeld *ObjTabelle::zAAlphaFeld() const
 {
-	return aAf;
+    return aAf;
 }
 
 LRahmen *ObjTabelle::getARahmen( int sNum, int zNum ) const // gibt den auswahl Rahmen zurück
 {
-	RCArray< LRahmen > *tmp = msaRam->z( sNum );
-	return tmp ? tmp->get( zNum ) : 0;
+    RCArray< LRahmen > *tmp = msaRam->z( sNum );
+    return tmp ? tmp->get( zNum ) : 0;
 }
 
 LRahmen *ObjTabelle::zARahmen( int sNum, int zNum ) const
 {
-	RCArray< LRahmen > *tmp = msaRam->z( sNum );
-	return tmp ? tmp->z( zNum ) : 0;
+    RCArray< LRahmen > *tmp = msaRam->z( sNum );
+    return tmp ? tmp->z( zNum ) : 0;
 }
 
 AlphaFeld *ObjTabelle::getAAlphaFeld( int sNum, int zNum ) const // gibt das auswahl AlphaFeld zurück
 {
-	RCArray< AlphaFeld > *tmp = msaAf->z( sNum );
-	return tmp ? tmp->get( zNum ) : 0;
+    RCArray< AlphaFeld > *tmp = msaAf->z( sNum );
+    return tmp ? tmp->get( zNum ) : 0;
 }
 
 AlphaFeld *ObjTabelle::zAAlphaFeld( int sNum, int zNum ) const
 {
-	return msaAf->z( sNum ) ? msaAf->z( sNum )->z( zNum ) : 0;
+    return msaAf->z( sNum ) ? msaAf->z( sNum )->z( zNum ) : 0;
 }
 
 LRahmen *ObjTabelle::getARahmen( const char *spaltenName, const char *zeilenName ) const // gibt den auswahl Rahmen zurück
 {
-	return getARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return getARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 LRahmen *ObjTabelle::zARahmen( const char *spaltenName, const char *zeilenName ) const
 {
-	return zARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 AlphaFeld *ObjTabelle::getAAlphaFeld( const char *spaltenName, const char *zeilenName ) const // gibt das auswahl AlphaFeld zurück
 {
-	return getAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return getAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 AlphaFeld *ObjTabelle::zAAlphaFeld( const char *spaltenName, const char *zeilenName ) const
 {
-	return zAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 LRahmen *ObjTabelle::getARahmen( Text *spaltenName, Text *zeilenName ) const // gibt den auswahl Rahmen zurück
 {
-	return getARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return getARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 LRahmen *ObjTabelle::zARahmen( Text *spaltenName, Text *zeilenName ) const
 {
-	return zARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zARahmen( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 AlphaFeld *ObjTabelle::getAAlphaFeld( Text *spaltenName, Text *zeilenName ) const // gibt das auswahl AlphaFeld zurück
 {
-	return getAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return getAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 AlphaFeld *ObjTabelle::zAAlphaFeld( Text *spaltenName, Text *zeilenName ) const
 {
-	return zAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
+    return zAAlphaFeld( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ) );
 }
 
 bool ObjTabelle::hatMsStyle( int sNum, int zNum, __int64 style ) const // prüft, ob style vorhanden ist
 {
-	__int64 s = styles->z( sNum ) && styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0;
-	return ( s | style ) == s;
+    __int64 s = styles->z( sNum ) && styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0;
+    return ( s | style ) == s;
 }
 
 bool ObjTabelle::hatMsStyleNicht( int sNum, int zNum, __int64 style ) const // prüft, ob style nicht vorhanden ist
 {
     __int64 s = styles->z( sNum ) && styles->z( sNum )->hat( zNum ) ? styles->z( sNum )->get( zNum ) : 0;
-	return ( s | style ) != s;
+    return ( s | style ) != s;
 }
 
 bool ObjTabelle::hatMsStyle( const char *spaltenName, const char *zeilenName, __int64 style ) const // prüft, ob style vorhanden ist
 {
-	return hatMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    return hatMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 bool ObjTabelle::hatMsStyleNicht( const char *spaltenName, const char *zeilenName, __int64 style ) const // prüft, ob style nicht vorhanden ist
 {
-	return hatMsStyleNicht( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    return hatMsStyleNicht( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 bool ObjTabelle::hatMsStyle( Text *spaltenName, Text *zeilenName, __int64 style ) const // prüft, ob style vorhanden ist
 {
-	return hatMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    return hatMsStyle( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 bool ObjTabelle::hatMsStyleNicht( Text *spaltenName, Text *zeilenName, __int64 style ) const // prüft, ob style nicht vorhanden ist
 {
-	return hatMsStyleNicht( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
+    return hatMsStyleNicht( getSpaltenNummer( spaltenName ), getZeilenNummer( zeilenName ), style );
 }
 
 Zeichnung *ObjTabelle::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
 {
-	ObjTabelle *obj = new ObjTabelle();
-	obj->setPosition( pos );
-	obj->setGröße( gr );
-	obj->setMausEreignisParameter( makParam );
-	obj->setTastaturEreignisParameter( takParam );
-	obj->setMausEreignis( Mak );
-	obj->setTastaturEreignis( Tak );
-	if( toolTip )
-		obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
-	obj->setStyle( style );
-	if( rahmen )
-		obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
-	obj->setHintergrundFarbe( hintergrundFarbe );
-	if( hintergrundBild )
-		obj->setHintergrundBild( hintergrundBild->getThis() );
-	if( hintergrundFeld )
-		obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
-	obj->setRasterFarbe( rasterFarbe );
-	obj->setRasterBreite( rasterBreite );
-	if( aRam )
-		obj->setARahmenZ( (LRahmen*)aRam->dublizieren() );
-	if( aAf )
-		obj->setAAlphaFeldZ( (AlphaFeld*)aAf->dublizieren() );
-	for( int s = 0; s < spaltenAnzahl; ++s )
-	{
-		obj->addSpalte( spaltenNamen->get( s ) );
-		if( spaltenBreite->hat( s ) )
-			obj->setSpaltenBreite( s, spaltenBreite->get( s ) );
-		if( minSpaltenBreite->hat( s ) )
-			obj->setMinSpaltenBreite( s, minSpaltenBreite->get( s ) );
-		if( maxSpaltenBreite->hat( s ) )
-			obj->setMaxSpaltenBreite( s, maxSpaltenBreite->get( s ) );
-		for( int z = 0; z < zeilenAnzahl; ++z )
-		{
-			if( !s )
-			{
-				obj->addZeile( zeilenNamen->get( z ) );
-				if( zeilenHöhe->hat( z ) )
-					obj->setZeilenHöhe( z, zeilenHöhe->get( z ) );
-				if( minZeilenHöhe->hat( z ) )
-					obj->setMinZeilenHöhe( z, minZeilenHöhe->get( z ) );
-				if( maxZeilenHöhe->hat( z ) )
-					obj->setMaxZeilenHöhe( z, maxZeilenHöhe->get( z ) );
-			}
-			if( zZeichnungs->z( s ) && zZeichnungs->z( s )->hat( z ) )
-				obj->setZeichnungZ( s, z, zZeichnungs->z( s )->get( z ) );
-			if( styles->z( s ) && styles->z( s )->hat( z ) )
-				obj->setMsStyle( s, z, styles->z( s )->get( z ) );
-			if( msaRam->z( s ) && msaRam->z( s )->z( z ) )
-				obj->setARahmenZ( s, z, (LRahmen*)msaRam->z( s )->z( z )->dublizieren() );
-			if( msaAf->z( s ) && msaAf->z( s )->z( z ) )
-				obj->setAAlphaFeldZ( s, z, (AlphaFeld*)msaAf->z( s )->z( z )->dublizieren() );
-		}
-	}
-	obj->setAuswahl( selected.x, selected.y );
-	return obj;
+    ObjTabelle *obj = new ObjTabelle();
+    obj->setPosition( pos );
+    obj->setGröße( gr );
+    obj->setMausEreignisParameter( makParam );
+    obj->setTastaturEreignisParameter( takParam );
+    obj->setMausEreignis( Mak );
+    obj->setTastaturEreignis( Tak );
+    if( toolTip )
+        obj->setToolTipText( toolTip->zText()->getText(), toolTip->zBildschirm() );
+    obj->setStyle( style );
+    if( rahmen )
+        obj->setLinienRahmenZ( (LRahmen*)rahmen->dublizieren() );
+    obj->setHintergrundFarbe( hintergrundFarbe );
+    if( hintergrundBild )
+        obj->setHintergrundBild( hintergrundBild->getThis() );
+    if( hintergrundFeld )
+        obj->setAlphaFeldZ( (AlphaFeld*)hintergrundFeld->dublizieren() );
+    obj->setRasterFarbe( rasterFarbe );
+    obj->setRasterBreite( rasterBreite );
+    if( aRam )
+        obj->setARahmenZ( (LRahmen*)aRam->dublizieren() );
+    if( aAf )
+        obj->setAAlphaFeldZ( (AlphaFeld*)aAf->dublizieren() );
+    for( int s = 0; s < spaltenAnzahl; ++s )
+    {
+        obj->addSpalte( spaltenNamen->get( s ) );
+        if( spaltenBreite->hat( s ) )
+            obj->setSpaltenBreite( s, spaltenBreite->get( s ) );
+        if( minSpaltenBreite->hat( s ) )
+            obj->setMinSpaltenBreite( s, minSpaltenBreite->get( s ) );
+        if( maxSpaltenBreite->hat( s ) )
+            obj->setMaxSpaltenBreite( s, maxSpaltenBreite->get( s ) );
+        for( int z = 0; z < zeilenAnzahl; ++z )
+        {
+            if( !s )
+            {
+                obj->addZeile( zeilenNamen->get( z ) );
+                if( zeilenHöhe->hat( z ) )
+                    obj->setZeilenHöhe( z, zeilenHöhe->get( z ) );
+                if( minZeilenHöhe->hat( z ) )
+                    obj->setMinZeilenHöhe( z, minZeilenHöhe->get( z ) );
+                if( maxZeilenHöhe->hat( z ) )
+                    obj->setMaxZeilenHöhe( z, maxZeilenHöhe->get( z ) );
+            }
+            if( zZeichnungs->z( s ) && zZeichnungs->z( s )->hat( z ) )
+                obj->setZeichnungZ( s, z, zZeichnungs->z( s )->get( z ) );
+            if( styles->z( s ) && styles->z( s )->hat( z ) )
+                obj->setMsStyle( s, z, styles->z( s )->get( z ) );
+            if( msaRam->z( s ) && msaRam->z( s )->z( z ) )
+                obj->setARahmenZ( s, z, (LRahmen*)msaRam->z( s )->z( z )->dublizieren() );
+            if( msaAf->z( s ) && msaAf->z( s )->z( z ) )
+                obj->setAAlphaFeldZ( s, z, (AlphaFeld*)msaAf->z( s )->z( z )->dublizieren() );
+        }
+    }
+    obj->setAuswahl( selected.x, selected.y );
+    return obj;
 }
 
 // Reference Counting
 ObjTabelle *ObjTabelle::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 ObjTabelle *ObjTabelle::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }

Tabelle.h

@@ -6,16 +6,16 @@
 
 namespace Framework
 {
-	class LRahmen; // Rahmen.h
-	class AlphaFeld; // AlphaFeld.h
-	class VScrollBar; // Scroll.h
-	class HScrollBar; // Scroll.h
-	class Text; // Text.h
-	class ObjTabelle; // aus dieser Datei
+    class LRahmen; // Rahmen.h
+    class AlphaFeld; // AlphaFeld.h
+    class VScrollBar; // Scroll.h
+    class HScrollBar; // Scroll.h
+    class Text; // Text.h
+    class ObjTabelle; // aus dieser Datei
 
     // Verwaltet eine Tabelle aus Zeichnungen
-	class ObjTabelle : public ZeichnungHintergrund
-	{
+    class ObjTabelle : public ZeichnungHintergrund
+    {
     public:
         class Style : public ZeichnungHintergrund::Style
         {
@@ -37,123 +37,123 @@ namespace Framework
             const static __int64 scroll = VScroll | HScroll; // Vereint die Flags: VScroll, HScroll
             const static __int64 normal = Rahmen | Erlaubt | Sichtbar | AuswahlBuffer | AuswahlRahmen | Raster; // Vereint die Flags: Rahmen, Erlaubt, Sichtbar, SpaltenBeweglich, AuswahlBuffer, AuswahlRahmen, Raster
         };
-	private:
-		RCArray< Array< Zeichnung* > > *zZeichnungs;
-		RCArray< Text > *spaltenNamen;
-		RCArray< Text > *zeilenNamen;
-		Array< int > *spaltenBreite;
-		Array< int > *zeilenHöhe;
-		Array< int > *minSpaltenBreite;
-		Array< int > *maxSpaltenBreite;
-		Array< int > *minZeilenHöhe;
-		Array< int > *maxZeilenHöhe;
-		int spaltenAnzahl, zeilenAnzahl;
-		int klickSpalte;
-		double mSpalte, mZeile;
-		int mx, my;
-		Punkt selected;
-		int rasterFarbe;
-		int rasterBreite;
-		LRahmen *aRam;
-		AlphaFeld *aAf;
-		RCArray< RCArray< LRahmen > > *msaRam;
-		RCArray< RCArray< AlphaFeld > > *msaAf;
-		RCArray< Array< __int64 > > *styles;
-		int ref;
+    private:
+        RCArray< Array< Zeichnung* > > *zZeichnungs;
+        RCArray< Text > *spaltenNamen;
+        RCArray< Text > *zeilenNamen;
+        Array< int > *spaltenBreite;
+        Array< int > *zeilenHöhe;
+        Array< int > *minSpaltenBreite;
+        Array< int > *maxSpaltenBreite;
+        Array< int > *minZeilenHöhe;
+        Array< int > *maxZeilenHöhe;
+        int spaltenAnzahl, zeilenAnzahl;
+        int klickSpalte;
+        double mSpalte, mZeile;
+        int mx, my;
+        Punkt selected;
+        int rasterFarbe;
+        int rasterBreite;
+        LRahmen *aRam;
+        AlphaFeld *aAf;
+        RCArray< RCArray< LRahmen > > *msaRam;
+        RCArray< RCArray< AlphaFeld > > *msaAf;
+        RCArray< Array< __int64 > > *styles;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) ObjTabelle();
-		// Destruktor 
-		__declspec( dllexport ) ~ObjTabelle();
-		// Fügt der Tabelle eine Spalte hinzu
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) ObjTabelle();
+        // Destruktor 
+        __declspec( dllexport ) ~ObjTabelle();
+        // Fügt der Tabelle eine Spalte hinzu
         //  name: Der Name der Spalte
-		__declspec( dllexport ) void addSpalte( const char *name );
+        __declspec( dllexport ) void addSpalte( const char *name );
         // Fügt der Tabelle eine Spalte hinzu
         //  name: Der Name der Spalte
-		__declspec( dllexport ) void addSpalte( Text *name );
+        __declspec( dllexport ) void addSpalte( Text *name );
         // Fügt der Tabelle an einer bestimmten Position eine Spalte hinzu
         //  sNum: Der Index der neuen Spalte
         //  name: Der Name der neuen Spalte
-		__declspec( dllexport ) void addSpalte( int sNum, const char *name );
+        __declspec( dllexport ) void addSpalte( int sNum, const char *name );
         // Fügt der Tabelle an einer bestimmten Position eine Spalte hinzu
         //  sNum: Der Index der neuen Spalte
         //  name: Der Name der neuen Spalte
-		__declspec( dllexport ) void addSpalte( int sNum, Text *name );
+        __declspec( dllexport ) void addSpalte( int sNum, Text *name );
         // Fügt der Tabelle eine Zeile hinzu
         //  name: Der Name der Zeile
-		__declspec( dllexport ) void addZeile( const char *name );
+        __declspec( dllexport ) void addZeile( const char *name );
         // Fügt der Tabelle eine Zeile hinzu
         //  name: Der Name der Zeile
-		__declspec( dllexport ) void addZeile( Text *name );
+        __declspec( dllexport ) void addZeile( Text *name );
         // Fügt der Tabelle an einer bestimmten Position eine Zeile hinzu
         //  zNum: Der Index der neuen Zeile
         //  name: Der Name der neuen Zeile
-		__declspec( dllexport ) void addZeile( int zNum, const char *name );
+        __declspec( dllexport ) void addZeile( int zNum, const char *name );
         // Fügt der Tabelle an einer bestimmten Position eine Zeile hinzu
         //  sNum: Der Index der neuen Zeile
         //  name: Der Name der neuen Zeile
-		__declspec( dllexport ) void addZeile( int zNum, Text *name );
+        __declspec( dllexport ) void addZeile( int zNum, Text *name );
         // Entfernt eine Spalte
         //  sNum: Der Index der Spalte
-		__declspec( dllexport ) void removeSpalte( int sNum );
+        __declspec( dllexport ) void removeSpalte( int sNum );
         // Entfernt eine Spalte
         //  name: Der Name der Spalte
-		__declspec( dllexport ) void removeSpalte( const char *name );
+        __declspec( dllexport ) void removeSpalte( const char *name );
         // Entfernt eine Spalte
         //  name: Der Name der Spalte
-		__declspec( dllexport ) void removeSpalte( Text *name );
+        __declspec( dllexport ) void removeSpalte( Text *name );
         // Entfernt eine Zeile
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) void removeZeile( int zNum );
+        __declspec( dllexport ) void removeZeile( int zNum );
         // Entfernt eine Zeile
         //  name: Der Name der Zeile
-		__declspec( dllexport ) void removeZeile( const char *name );
+        __declspec( dllexport ) void removeZeile( const char *name );
         // Entfernt eine Zeile
         //  name: Der Name der Zeile
-		__declspec( dllexport ) void removeZeile( Text *name );
+        __declspec( dllexport ) void removeZeile( Text *name );
         // Setzt den Index einer Spalte
         //  name: Der Name der Spalte
         //  pos: Der neue Index der Spalte
-		__declspec( dllexport ) void setSpaltePosition( const char *name, int pos );
+        __declspec( dllexport ) void setSpaltePosition( const char *name, int pos );
         // Setzt den Index einer Spalte
         //  name: Der Name der Spalte
         //  pos: Der neue Index der Spalte
-		__declspec( dllexport ) void setSpaltePosition( Text *name, int pos );
+        __declspec( dllexport ) void setSpaltePosition( Text *name, int pos );
         // Setzt den Index einer Spalte
         //  sNum: Der alte Index der Spalte
         //  pos: Der neue Index der Spalte
-		__declspec( dllexport ) void setSpaltePosition( int sNum, int pos );
+        __declspec( dllexport ) void setSpaltePosition( int sNum, int pos );
         // Setzt den Index einer Zeile
         //  name: Der Name der Zeile
         //  pos: Der neue Index der Zeile
-		__declspec( dllexport ) void setZeilePosition( const char *name, int pos );
+        __declspec( dllexport ) void setZeilePosition( const char *name, int pos );
         // Setzt den Index einer Zeile
         //  name: Der Name der Zeile
         //  pos: Der neue Index der Zeile
-		__declspec( dllexport ) void setZeilePosition( Text *name, int pos );
+        __declspec( dllexport ) void setZeilePosition( Text *name, int pos );
         // Setzt den Index einer Zeile
         //  zNum: Der alte Index der Zeile
         //  pos: Der neue Index der Zeile
-		__declspec( dllexport ) void setZeilePosition( int zNum, int pos );
+        __declspec( dllexport ) void setZeilePosition( int zNum, int pos );
         // Setzt ein Zeichnung, welches in einem Bestimmten Feld sein soll
         // Wenn bereits ein Zeichnung in dem Feld ist, wird es überschrieben.
         //  sNum: Der Index der Spalte, in der das Zeichnung stehen soll
         //  zNum: Der Index der Zeile, in der das Zeichnung stehen soll
         //  zObj: Das Zeichnung welches in dem Feld sein soll
-		__declspec( dllexport ) void setZeichnungZ( int sNum, int zNum, Zeichnung *zObj );
+        __declspec( dllexport ) void setZeichnungZ( int sNum, int zNum, Zeichnung *zObj );
         // Setzt ein Zeichnung, welches in einem Bestimmten Feld sein soll
         // Wenn bereits ein Zeichnung in dem Feld ist, wird es überschrieben.
         //  spaltenName: Der Name der Spalte, in der das Zeichnung stehen soll
         //  zeilenName: Der Name der Zeile, in der das Zeichnung stehen soll
         //  zZeichnung: Das Zeichnung welches in dem Feld sein soll
-		__declspec( dllexport ) void setZeichnungZ( const char *spaltenName, const char *zeilenName, Zeichnung *zZeichnung );
+        __declspec( dllexport ) void setZeichnungZ( const char *spaltenName, const char *zeilenName, Zeichnung *zZeichnung );
         // Setzt ein Zeichnung, welches in einem Bestimmten Feld sein soll
         // Wenn bereits ein Zeichnung in dem Feld ist, wird es überschrieben.
         //  spaltenName: Der Name der Spalte, in der das Zeichnung stehen soll
         //  zeilenName: Der Name der Zeile, in der das Zeichnung stehen soll
         //  zZeichnung: Das Zeichnung welches in dem Feld sein soll
-		__declspec( dllexport ) void setZeichnungZ( Text *spaltenName, Text *zeilenName, Zeichnung *zZeichnung );
+        __declspec( dllexport ) void setZeichnungZ( Text *spaltenName, Text *zeilenName, Zeichnung *zZeichnung );
         // Setzt die Spalten Breite
         //  sNum: Der Index der Spalte
         //  br: Die Breite in Pixeln
@@ -161,488 +161,488 @@ namespace Framework
         // Setzt die Spalten Breite
         //  name: Der Name der Spalte
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setSpaltenBreite( const char *name, int br );
+        __declspec( dllexport ) void setSpaltenBreite( const char *name, int br );
         // Setzt die Spalten Breite
         //  name: Der Name der Spalte
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setSpaltenBreite( Text *name, int br );
+        __declspec( dllexport ) void setSpaltenBreite( Text *name, int br );
         // Setzt die Zeilen Höhe
         //  zNum: Der Index der Zeile
         //  hö: Die Höhe in Pixeln
-		__declspec( dllexport ) void setZeilenHöhe( int zNum, int hö );
+        __declspec( dllexport ) void setZeilenHöhe( int zNum, int hö );
         // Setzt die Zeilen Höhe
         //  name: Der Index der Zeile
         //  hö: Die Höhe in Pixeln
-		__declspec( dllexport ) void setZeilenHöhe( const char *name, int hö );
+        __declspec( dllexport ) void setZeilenHöhe( const char *name, int hö );
         // Setzt die Zeilen Höhe
         //  name: Der Index der Zeile
         //  hö: Die Höhe in Pixeln
-		__declspec( dllexport ) void setZeilenHöhe( Text *name, int hö );
+        __declspec( dllexport ) void setZeilenHöhe( Text *name, int hö );
         // Setzt die minimale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMin)
         //  sNum: Der Index der Spalte
         //  minBr: Die minimale Breite in Pixeln
-		__declspec( dllexport ) void setMinSpaltenBreite( int sNum, int minBr );
+        __declspec( dllexport ) void setMinSpaltenBreite( int sNum, int minBr );
         // Setzt die minimale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMin)
         //  name: Der Name der Spalte
         //  minBr: Die minimale Breite in Pixeln
-		__declspec( dllexport ) void setMinSpaltenBreite( const char *name, int minBr );
+        __declspec( dllexport ) void setMinSpaltenBreite( const char *name, int minBr );
         // Setzt die minimale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMin)
         //  name: Der Name der Spalte
         //  minBr: Die minimale Breite in Pixeln
-		__declspec( dllexport ) void setMinSpaltenBreite( Text *name, int minBr );
+        __declspec( dllexport ) void setMinSpaltenBreite( Text *name, int minBr );
         // Setzt die maximale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMax)
         //  sNum: Der Index der Spalte
         //  maxBr: Die maximale Breite in Pixeln
-		__declspec( dllexport ) void setMaxSpaltenBreite( int sNum, int maxBr );
+        __declspec( dllexport ) void setMaxSpaltenBreite( int sNum, int maxBr );
         // Setzt die maximale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMax)
         //  name: Der Name der Spalte
         //  maxBr: Die maximale Breite in Pixeln
-		__declspec( dllexport ) void setMaxSpaltenBreite( const char *name, int maxBr );
+        __declspec( dllexport ) void setMaxSpaltenBreite( const char *name, int maxBr );
         // Setzt die maximale Spalten Breite (benötigt Flag: SpaltenBreiteÄnderbar, SpaltenBreiteMax)
         //  name: Der Name der Spalte
         //  maxBr: Die maximale Breite in Pixeln
-		__declspec( dllexport ) void setMaxSpaltenBreite( Text *name, int maxBr );
+        __declspec( dllexport ) void setMaxSpaltenBreite( Text *name, int maxBr );
         // Setzt die minimale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMin)
         //  zNum: Der Index der Zeile
         //  minHö: Die minimale Höhe in Pixeln
-		__declspec( dllexport ) void setMinZeilenHöhe( int zNum, int minHö );
+        __declspec( dllexport ) void setMinZeilenHöhe( int zNum, int minHö );
         // Setzt die minimale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMin)
         //  name: Der Name der Zeile
         //  minHö: Die minimale Höhe in Pixeln
-		__declspec( dllexport ) void setMinZeilenHöhe( const char *name, int minHö );
+        __declspec( dllexport ) void setMinZeilenHöhe( const char *name, int minHö );
         // Setzt die minimale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMin)
         //  name: Der Name der Zeile
         //  minHö: Die minimale Höhe in Pixeln
-		__declspec( dllexport ) void setMinZeilenHöhe( Text *name, int minHö );
+        __declspec( dllexport ) void setMinZeilenHöhe( Text *name, int minHö );
         // Setzt die maximale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMax)
         //  zNum: Der Index der Zeile
         //  maxHö: Die maximale Höhe in Pixeln
-		__declspec( dllexport ) void setMaxZeilenHöhe( int zNum, int maxHö );
+        __declspec( dllexport ) void setMaxZeilenHöhe( int zNum, int maxHö );
         // Setzt die maximale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMax)
         //  name: Der Name der Zeile
         //  maxHö: Die maximale Höhe in Pixeln
-		__declspec( dllexport ) void setMaxZeilenHöhe( const char *name, int maxHö );
+        __declspec( dllexport ) void setMaxZeilenHöhe( const char *name, int maxHö );
         // Setzt die maximale Zeilen Höhe (benötigt Flag: ZeilenHöheÄnderbar, ZeienHöheMax)
         //  name: Der Name der Zeile
         //  maxHö: Die maximale Höhe in Pixeln
-		__declspec( dllexport ) void setMaxZeilenHöhe( Text *name, int maxHö );
+        __declspec( dllexport ) void setMaxZeilenHöhe( Text *name, int maxHö );
         // Legt fest, welches Feld ausgewählt ist (benötigt Flag: Erlaubt)
         //  sNum: Der Index der Spalte des Feldes
         //  zNum: Der Index der Zeile des Feldes
-		__declspec( dllexport ) void setAuswahl( int sNum, int zNum );
+        __declspec( dllexport ) void setAuswahl( int sNum, int zNum );
         // Legt fest, welches Feld ausgewählt ist (benötigt Flag: Erlaubt)
         //  spaltenName: Der Name der Spalte des Feldes
         //  zeilenName: Der Name der Zeile des Feldes
-		__declspec( dllexport ) void setAuswahl( const char *spaltenName, const char *zeilenName );
+        __declspec( dllexport ) void setAuswahl( const char *spaltenName, const char *zeilenName );
         // Legt fest, welches Feld ausgewählt ist (benötigt Flag: Erlaubt)
         //  spaltenName: Der Name der Spalte des Feldes
         //  zeilenName: Der Name der Zeile des Feldes
-		__declspec( dllexport ) void setAuswahl( Text *spaltenName, Text *zeilenName );
+        __declspec( dllexport ) void setAuswahl( Text *spaltenName, Text *zeilenName );
         // Setzt dei Farbe des zwischen den Kästchen angezeigten Rasters
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setRasterFarbe( int f );
+        __declspec( dllexport ) void setRasterFarbe( int f );
         // Setzt due Breite des zwischen den Kästchen angezeigten Raseter
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setRasterBreite( int br );
+        __declspec( dllexport ) void setRasterBreite( int br );
         // Setzte den Zeiger auf einen Rahmen, der um das ausgewählte Kästchen gezeichnet wird
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setARahmenZ( LRahmen *ram );
+        __declspec( dllexport ) void setARahmenZ( LRahmen *ram );
         // Setzt die farbe des Rahmens, der um das ausgewählte Kästchen gezeichnet wird
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setARFarbe( int f ); 
+        __declspec( dllexport ) void setARFarbe( int f );
         // Setzt die Breite des Rahmens, der um das ausgewählte Kästchen gezeichnet wird
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setARBreite( int br );
+        __declspec( dllexport ) void setARBreite( int br );
         // Setzt einen Zeiger auf das AlphaFeld, das für das ausgewählte Kästchen verwendet wird
         //  af: Das AlphaFeld
-		__declspec( dllexport ) void setAAlphaFeldZ( AlphaFeld *af );
+        __declspec( dllexport ) void setAAlphaFeldZ( AlphaFeld *af );
         // Setzt die Farbe des AlphaFeldes, das für das ausgewählte Kästchen verwendet wird
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setAAfFarbe( int f );
+        __declspec( dllexport ) void setAAfFarbe( int f );
         // Setzt die Stärke des AlphaFeldes, das für das ausgewählte Kästchen verwendet wird
         //  st: Die Stärke
-		__declspec( dllexport ) void setAAfStärke( int st );
+        __declspec( dllexport ) void setAAfStärke( int st );
         // Setzt einen Zeiger auf einen Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setARahmenZ( int sNum, int zNum, LRahmen *ram );
+        __declspec( dllexport ) void setARahmenZ( int sNum, int zNum, LRahmen *ram );
         // Setzt einen Zeiger auf einen Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setARahmenZ( const char *spaltenName, const char *zeilenName, LRahmen *ram );
+        __declspec( dllexport ) void setARahmenZ( const char *spaltenName, const char *zeilenName, LRahmen *ram );
         // Setzt einen Zeiger auf einen Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  ram: Der Rahmen
-		__declspec( dllexport ) void setARahmenZ( Text *spaltenName, Text *zeilenName, LRahmen *ram );
+        __declspec( dllexport ) void setARahmenZ( Text *spaltenName, Text *zeilenName, LRahmen *ram );
         // Setzt die Farbe von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setARFarbe( int sNum, int zNum, int f );
+        __declspec( dllexport ) void setARFarbe( int sNum, int zNum, int f );
         // Setzt die Farbe von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setARFarbe( const char *spaltenName, const char *zeilenName, int f );
+        __declspec( dllexport ) void setARFarbe( const char *spaltenName, const char *zeilenName, int f );
         // Setzt die Farbe von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setARFarbe( Text *spaltenName, Text *zeilenName, int f );
+        __declspec( dllexport ) void setARFarbe( Text *spaltenName, Text *zeilenName, int f );
         // Setzt die Breite von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setARBreite( int sNum, int zNum, int br );
+        __declspec( dllexport ) void setARBreite( int sNum, int zNum, int br );
         // Setzt die Breite von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setARBreite( const char *spaltenName, const char *zeilenName, int br );
+        __declspec( dllexport ) void setARBreite( const char *spaltenName, const char *zeilenName, int br );
         // Setzt die Breite von einem Rahmen, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  br: Die Breite in Pixeln
-		__declspec( dllexport ) void setARBreite( Text *spaltenName, Text *zeilenName, int br );
+        __declspec( dllexport ) void setARBreite( Text *spaltenName, Text *zeilenName, int br );
         // Setzt den Farbüergang, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  af: Der Farbübergang
-		__declspec( dllexport ) void setAAlphaFeldZ( int sNum, int zNum, AlphaFeld *af );
+        __declspec( dllexport ) void setAAlphaFeldZ( int sNum, int zNum, AlphaFeld *af );
         // Setzt den Farbüergang, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  af: Der Farbübergang
-		__declspec( dllexport ) void setAAlphaFeldZ( const char *spaltenName, const char *zeilenName, AlphaFeld *af );
+        __declspec( dllexport ) void setAAlphaFeldZ( const char *spaltenName, const char *zeilenName, AlphaFeld *af );
         // Setzt den Farbüergang, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  af: Der Farbübergang
-		__declspec( dllexport ) void setAAlphaFeldZ( Text *spaltenName, Text *zeilenName, AlphaFeld *af );
+        __declspec( dllexport ) void setAAlphaFeldZ( Text *spaltenName, Text *zeilenName, AlphaFeld *af );
         // Setzt die Farbe des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setAAfFarbe( int sNum, int zNum, int f );
+        __declspec( dllexport ) void setAAfFarbe( int sNum, int zNum, int f );
         // Setzt die Farbe des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setAAfFarbe( const char *spaltenName, const char *zeilenName, int f );
+        __declspec( dllexport ) void setAAfFarbe( const char *spaltenName, const char *zeilenName, int f );
         // Setzt die Farbe des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  f: Die Farbe im A8R8G8B8 Format
-		__declspec( dllexport ) void setAAfFarbe( Text *spaltenName, Text *zeilenName, int f );
+        __declspec( dllexport ) void setAAfFarbe( Text *spaltenName, Text *zeilenName, int f );
         // Setzt die Stärke des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  st: Die Stärke
-		__declspec( dllexport ) void setAAfStärke( int sNum, int zNum, int st );
+        __declspec( dllexport ) void setAAfStärke( int sNum, int zNum, int st );
         // Setzt die Stärke des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  st: Die Stärke
-		__declspec( dllexport ) void setAAfStärke( const char *spaltenName, const char *zeilenName, int st );
+        __declspec( dllexport ) void setAAfStärke( const char *spaltenName, const char *zeilenName, int st );
         // Setzt die Stärke des Farbüergangs, der bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte wird
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  st: Die Stärke
-		__declspec( dllexport ) void setAAfStärke( Text *spaltenName, Text *zeilenName, int st );
+        __declspec( dllexport ) void setAAfStärke( Text *spaltenName, Text *zeilenName, int st );
         // Fügt Styles hinzu, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  style: der Style, der hinzugefügt werden soll
-		__declspec( dllexport ) void addMsStyle( int sNum, int zNum, __int64 style );
+        __declspec( dllexport ) void addMsStyle( int sNum, int zNum, __int64 style );
         // Fügt Styles hinzu, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der hinzugefügt werden soll
-		__declspec( dllexport ) void addMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
+        __declspec( dllexport ) void addMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
         // Fügt Styles hinzu, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der hinzugefügt werden soll
-		__declspec( dllexport ) void addMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
+        __declspec( dllexport ) void addMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
-		__declspec( dllexport ) void setMsStyle( int sNum, int zNum, __int64 style );
+        __declspec( dllexport ) void setMsStyle( int sNum, int zNum, __int64 style );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
-		__declspec( dllexport ) void setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
+        __declspec( dllexport ) void setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
-		__declspec( dllexport ) void setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
+        __declspec( dllexport ) void setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
         //  add_remove: 1, falls die übergebenen Styles hinzugefügt werden sollen. 0, fals sie entfernt werden sollen
-		__declspec( dllexport ) void setMsStyle( int sNum, int zNum, __int64 style, bool add_remove );
+        __declspec( dllexport ) void setMsStyle( int sNum, int zNum, __int64 style, bool add_remove );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
         //  add_remove: 1, falls die übergebenen Styles hinzugefügt werden sollen. 0, fals sie entfernt werden sollen
-		__declspec( dllexport ) void setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style, bool add_remove );
+        __declspec( dllexport ) void setMsStyle( const char *spaltenName, const char *zeilenName, __int64 style, bool add_remove );
         // Setzt die Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der verwendet werden soll
         //  add_remove: 1, falls die übergebenen Styles hinzugefügt werden sollen. 0, fals sie entfernt werden sollen
-		__declspec( dllexport ) void setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style, bool add_remove );
+        __declspec( dllexport ) void setMsStyle( Text *spaltenName, Text *zeilenName, __int64 style, bool add_remove );
         // Entfernt Styles von den Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  sNum: Der Index der Spalte des Kästchens
         //  zNum: Der Index der Zeile des Kästchens
         //  style: der Style, der entfernt werden soll
-		__declspec( dllexport ) void löscheMsStyle( int sNum, int zNum, __int64 style );
+        __declspec( dllexport ) void löscheMsStyle( int sNum, int zNum, __int64 style );
         // Entfernt Styles von den Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der entfernt werden soll
-		__declspec( dllexport ) void löscheMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
+        __declspec( dllexport ) void löscheMsStyle( const char *spaltenName, const char *zeilenName, __int64 style );
         // Entfernt Styles von den Styles, die bei dem Flag AuswahlMultistyled bei der Auswahl eines bestimmten Kästchens verwendte werden
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
         //  style: der Style, der entfernt werden soll
-		__declspec( dllexport ) void löscheMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
+        __declspec( dllexport ) void löscheMsStyle( Text *spaltenName, Text *zeilenName, __int64 style );
         // Aktualisiert das Objekt. Wird vom Framework aufgerufen
         //  tickVal: Die Zeit in sekunden, die seit dem lezten Aufruf dieser Funktion vergangen ist
         //  return: 1, wenn sich etwas verändert hat und das Bild neu gezeichnet werden muss. 0 sonst
         __declspec( dllexport ) bool tick( double tickVal ) override;
         // Verarbeitet Maus Nachrichten
         //  me: Das Ereignis, was durch die Mauseingabe ausgelößt wurde
-		__declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
         // Verarbeitet Tastatur Nachrichten
         //  me: Das Ereignis, was durch die Tastatureingabe ausgelößt wurde
-		__declspec( dllexport ) void doTastaturEreignis( TastaturEreignis &te ) override;
+        __declspec( dllexport ) void doTastaturEreignis( TastaturEreignis &te ) override;
         // Zeichnet das Objekt nach zRObj, falls er sichtbar ist
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt die Anzahl der Spalten zurück
-		__declspec( dllexport ) int getSpaltenAnzahl() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt die Anzahl der Spalten zurück
+        __declspec( dllexport ) int getSpaltenAnzahl() const;
         // Gibt die Anzahl der Zeilen zurück
-		__declspec( dllexport ) int getZeilenAnzahl() const;
+        __declspec( dllexport ) int getZeilenAnzahl() const;
         // Gibt den Index einer Spalte zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getSpaltenNummer( const char *name ) const;
+        __declspec( dllexport ) int getSpaltenNummer( const char *name ) const;
         // Gibt den Index einer Spalte zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getSpaltenNummer( Text *name ) const;
+        __declspec( dllexport ) int getSpaltenNummer( Text *name ) const;
         // Gibt den Namen einer Spalte zurück
         //  num: Der Index der Splate
-		__declspec( dllexport ) Text *getSpaltenName( int num ) const;
+        __declspec( dllexport ) Text *getSpaltenName( int num ) const;
         // Gibt den Namen einer Spalte ohne erhöhten reference Counter zurück
         //  num: Der Index der Splate
-		__declspec( dllexport ) Text *zSpaltenName( int num ) const;
+        __declspec( dllexport ) Text *zSpaltenName( int num ) const;
         // Gibt den Index einer Zeile zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getZeilenNummer( const char *name ) const;
+        __declspec( dllexport ) int getZeilenNummer( const char *name ) const;
         // Gibt den Index einer Zeile zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getZeilenNummer( Text *name ) const;
+        __declspec( dllexport ) int getZeilenNummer( Text *name ) const;
         // Gibt den Namen einer Zeile zurück
         //  num: Der Index der Zeile
-		__declspec( dllexport ) Text *getZeilenName( int num ) const;
+        __declspec( dllexport ) Text *getZeilenName( int num ) const;
         // Gibt den Namen einer Zeile ohne erhöhten Reference Counter zurück
         //  num: Der Index der Zeile
-		__declspec( dllexport ) Text *zZeilenName( int num ) const;
+        __declspec( dllexport ) Text *zZeilenName( int num ) const;
         // Sucht eine Zeichnung in der Tabelle und gibt den Index der Spalte als x und den der Zeile als y zurück. (-1, -1) falls das Objekt nicht gefunden wurde
         //  zObj: Die Zeichnung
-		__declspec( dllexport ) Punkt getZeichnungPosition( Zeichnung *zObj ) const;
+        __declspec( dllexport ) Punkt getZeichnungPosition( Zeichnung *zObj ) const;
         // Gibt die Zeichnung zurück, die in einem bestimmten Kästchen der Tabelle ist
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) Zeichnung *zZeichnung( int sNum, int zNum ) const;
+        __declspec( dllexport ) Zeichnung *zZeichnung( int sNum, int zNum ) const;
         // Gibt die Zeichnung zurück, die in einem bestimmten Kästchen der Tabelle ist
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
-		__declspec( dllexport ) Zeichnung *zZeichnung( const char *spaltenName, const char *zeilenName ) const;
+        __declspec( dllexport ) Zeichnung *zZeichnung( const char *spaltenName, const char *zeilenName ) const;
         // Gibt die Zeichnung zurück, die in einem bestimmten Kästchen der Tabelle ist
         //  spaltenName: Der Name der Spalte des Kästchens
         //  zeilenName: Der Name der Zeile des Kästchens
-		__declspec( dllexport ) Zeichnung *zZeichnung( Text *spaltenName, Text *zeilenName ) const;
+        __declspec( dllexport ) Zeichnung *zZeichnung( Text *spaltenName, Text *zeilenName ) const;
         // Gibt die Breite einer Spalte in Pixeln zurück
         //  num: Der Index der Spalte
-		__declspec( dllexport ) int getSpaltenBreite( int num ) const;
+        __declspec( dllexport ) int getSpaltenBreite( int num ) const;
         // Gibt die Breite einer Spalte in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getSpaltenBreite( const char *name ) const;
+        __declspec( dllexport ) int getSpaltenBreite( const char *name ) const;
         // Gibt die Breite einer Spalte in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getSpaltenBreite( Text *name ) const;
+        __declspec( dllexport ) int getSpaltenBreite( Text *name ) const;
         // Gibt die Höhe einer Zeile in Pixeln zurück
         //  num: Der Index der Zeile
-		__declspec( dllexport ) int getZeilenHöhe( int num ) const;
+        __declspec( dllexport ) int getZeilenHöhe( int num ) const;
         // Gibt die Höhe einer Zeile in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getZeilenHöhe( const char *name ) const;
+        __declspec( dllexport ) int getZeilenHöhe( const char *name ) const;
         // Gibt die Höhe einer Zeile in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getZeilenHöhe( Text *name ) const;
+        __declspec( dllexport ) int getZeilenHöhe( Text *name ) const;
         // Gibt die minimale Spalten breite in Pixeln zurück
         //  num: Der Index der Spalte
-		__declspec( dllexport ) int getMinSpaltenBreite( int num ) const;
+        __declspec( dllexport ) int getMinSpaltenBreite( int num ) const;
         // Gibt die minimale Spalten breite in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getMinSpaltenBreite( const char *name ) const;
+        __declspec( dllexport ) int getMinSpaltenBreite( const char *name ) const;
         // Gibt die minimale Spalten breite in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getMinSpaltenBreite( Text *name ) const;
+        __declspec( dllexport ) int getMinSpaltenBreite( Text *name ) const;
         // Gibt die maximale Spalten breite in Pixeln zurück
         //  num: Der Index der Spalte
-		__declspec( dllexport ) int getMaxSpaltenBreite( int num ) const;
+        __declspec( dllexport ) int getMaxSpaltenBreite( int num ) const;
         // Gibt die maximale Spalten breite in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getMaxSpaltenBreite( const char *name ) const;
+        __declspec( dllexport ) int getMaxSpaltenBreite( const char *name ) const;
         // Gibt die maximale Spalten breite in Pixeln zurück
         //  name: Der Name der Spalte
-		__declspec( dllexport ) int getMaxSpaltenBreite( Text *name ) const;
+        __declspec( dllexport ) int getMaxSpaltenBreite( Text *name ) const;
         // Gibt die minimale Zeilen Höhe in Pixeln zurück
         //  num: Der Index der Zeile
-		__declspec( dllexport ) int getMinZeilenHöhe( int num ) const;
+        __declspec( dllexport ) int getMinZeilenHöhe( int num ) const;
         // Gibt die minimale Zeilen Höhe in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getMinZeilenHöhe( const char *name ) const;
+        __declspec( dllexport ) int getMinZeilenHöhe( const char *name ) const;
         // Gibt die minimale Zeilen Höhe in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getMinZeilenHöhe( Text *name ) const;
+        __declspec( dllexport ) int getMinZeilenHöhe( Text *name ) const;
         // Gibt die maximale Zeilen Höhe in Pixeln zurück
         //  num: Der Index der Zeile
-		__declspec( dllexport ) int getMaxZeilenHöhe( int num ) const;
+        __declspec( dllexport ) int getMaxZeilenHöhe( int num ) const;
         // Gibt die maximale Zeilen Höhe in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getMaxZeilenHöhe( const char *name ) const;
+        __declspec( dllexport ) int getMaxZeilenHöhe( const char *name ) const;
         // Gibt die maximale Zeilen Höhe in Pixeln zurück
         //  name: Der Name der Zeile
-		__declspec( dllexport ) int getMaxZeilenHöhe( Text *name ) const;
+        __declspec( dllexport ) int getMaxZeilenHöhe( Text *name ) const;
         // Gibt den index der Splate zurück, auf die die Maus zeigt
         //  mx: Die x Koordinate der Mausposition basierend zum linken Rand der Tabelle in Pixeln
-		__declspec( dllexport ) double getMausSpalte( int mx ) const;
+        __declspec( dllexport ) double getMausSpalte( int mx ) const;
         // Gibt den Namen der Splate zurück, auf die die Maus zeigt
         //  mx: Die x Koordinate der Mausposition basierend zum linken Rand der Tabelle in Pixeln
-		__declspec( dllexport ) Text *getMausSpaltenName( int mx ) const;
+        __declspec( dllexport ) Text *getMausSpaltenName( int mx ) const;
         // Gibt den Namen der Splate ohne erhöhten Reference Counter zurück, auf die die Maus zeigt
         //  mx: Die x Koordinate der Mausposition basierend zum linken Rand der Tabelle in Pixeln
-		__declspec( dllexport ) Text *zMausSpaltenName( int mx ) const;
+        __declspec( dllexport ) Text *zMausSpaltenName( int mx ) const;
         // Gibt den index der Zeile zurück, auf die die Maus zeigt
         //  my: Die Y Koordinate der Mausposition basierend zum oberen Rand der Tabelle in Pixeln
-		__declspec( dllexport ) double getMausZeile( int my ) const;
+        __declspec( dllexport ) double getMausZeile( int my ) const;
         // Gibt den Namen der Zeile zurück, auf die die Maus zeigt
         //  my: Die Y Koordinate der Mausposition basierend zum oberen Rand der Tabelle in Pixeln
-		__declspec( dllexport ) Text *getMausZeilenName( int my ) const;
+        __declspec( dllexport ) Text *getMausZeilenName( int my ) const;
         // Gibt den Namen der Zeile ohne erhöhten Reference Counter zurück, auf die die Maus zeigt
         //  my: Die Y Koordinate der Mausposition basierend zum oberen Rand der Tabelle in Pixeln
-		__declspec( dllexport ) Text *zMausZeilenName( int my ) const;
+        __declspec( dllexport ) Text *zMausZeilenName( int my ) const;
         // Gibt den Index der Spalte als x und den der Zeile als y des ausgewählten Feldes zurück
-		__declspec( dllexport ) const Punkt &getAuswahlPosition() const;
+        __declspec( dllexport ) const Punkt &getAuswahlPosition() const;
         // Gibt die Farbe des Rasters im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getRasterFarbe() const;
+        __declspec( dllexport ) int getRasterFarbe() const;
         // Gibt die Breite des Rasters in Pixeln zurück
-		__declspec( dllexport ) int getRasterBreite() const;
+        __declspec( dllexport ) int getRasterBreite() const;
         // Gibt einen Zeiger auf den Rahmen zurück, der bei dem ausgewählten Feld verwendet wird
         __declspec( dllexport ) LRahmen *getARahmen() const;
         // Gibt einen Zeiger auf den Rahmen ohne erhöhten Reference Counter zurück, der bei dem ausgewählten Feld verwendet wird
-		__declspec( dllexport ) LRahmen *zARahmen() const;
+        __declspec( dllexport ) LRahmen *zARahmen() const;
         // Gibt einen Zeiger auf den Farbübergang zurück, der bei dem ausgewählten Feld verwendet wird
-		__declspec( dllexport ) AlphaFeld *getAAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *getAAlphaFeld() const;
         // Gibt einen Zeiger auf den Farbübergang ohne erhöhten Reference Counter zurück, der bei dem ausgewählten Feld verwendet wird
-		__declspec( dllexport ) AlphaFeld *zAAlphaFeld() const;
+        __declspec( dllexport ) AlphaFeld *zAAlphaFeld() const;
         // Gibt einen Zeiger auf den Rahmen zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) LRahmen *getARahmen( int sNum, int zNum ) const;
+        __declspec( dllexport ) LRahmen *getARahmen( int sNum, int zNum ) const;
         // Gibt einen Zeiger auf den Rahmen ohne erhöhten Reference Couner zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) LRahmen *zARahmen( int sNum, int zNum ) const;
+        __declspec( dllexport ) LRahmen *zARahmen( int sNum, int zNum ) const;
         // Gibt einen Zeiger auf den Farbübergang zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) AlphaFeld *getAAlphaFeld( int sNum, int zNum ) const;
+        __declspec( dllexport ) AlphaFeld *getAAlphaFeld( int sNum, int zNum ) const;
         // Gibt einen Zeiger auf den Farbübergang ohne erhöhten Reference Couner zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
-		__declspec( dllexport ) AlphaFeld *zAAlphaFeld( int sNum, int zNum ) const;
+        __declspec( dllexport ) AlphaFeld *zAAlphaFeld( int sNum, int zNum ) const;
         // Gibt einen Zeiger auf den Rahmen zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) LRahmen *getARahmen( const char *spaltenName, const char *zeilenName ) const;
+        __declspec( dllexport ) LRahmen *getARahmen( const char *spaltenName, const char *zeilenName ) const;
         // Gibt einen Zeiger auf den Rahmen ohne erhöhten Reference Coune zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) LRahmen *zARahmen( const char *spaltenName, const char *zeilenName ) const;
+        __declspec( dllexport ) LRahmen *zARahmen( const char *spaltenName, const char *zeilenName ) const;
         // Gibt einen Zeiger auf den Farbübergang zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) AlphaFeld *getAAlphaFeld( const char *spaltenName, const char *zeilenName ) const;
+        __declspec( dllexport ) AlphaFeld *getAAlphaFeld( const char *spaltenName, const char *zeilenName ) const;
         // Gibt einen Zeiger auf den Farbübergang ohne erhöhten Reference Coune zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) AlphaFeld *zAAlphaFeld( const char *spaltenName, const char *zeilenName ) const;
+        __declspec( dllexport ) AlphaFeld *zAAlphaFeld( const char *spaltenName, const char *zeilenName ) const;
         // Gibt einen Zeiger auf den Rahmen zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) LRahmen *getARahmen( Text *spaltenName, Text *zeilenName ) const;
+        __declspec( dllexport ) LRahmen *getARahmen( Text *spaltenName, Text *zeilenName ) const;
         // Gibt einen Zeiger auf den Rahmen ohne erhöhten Reference Coune zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) LRahmen *zARahmen( Text *spaltenName, Text *zeilenName ) const;
+        __declspec( dllexport ) LRahmen *zARahmen( Text *spaltenName, Text *zeilenName ) const;
         // Gibt einen Zeiger auf den Farbübergang zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) AlphaFeld *getAAlphaFeld( Text *spaltenName, Text *zeilenName ) const;
+        __declspec( dllexport ) AlphaFeld *getAAlphaFeld( Text *spaltenName, Text *zeilenName ) const;
         // Gibt einen Zeiger auf den Farbübergang ohne erhöhten Reference Coune zurück, der bei dem Flag AuswahlMultistyled bei der auswahl eines bestimmten Kästchens verwendet wird
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
-		__declspec( dllexport ) AlphaFeld *zAAlphaFeld( Text *spaltenName, Text *zeilenName ) const;
+        __declspec( dllexport ) AlphaFeld *zAAlphaFeld( Text *spaltenName, Text *zeilenName ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style gesetzt ist
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyle( int sNum, int zNum, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyle( int sNum, int zNum, __int64 style ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style nicht gesetzt ist
         //  sNum: Der Index der Spalte
         //  zNum: Der Index der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyleNicht( int sNum, int zNum, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyleNicht( int sNum, int zNum, __int64 style ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style gesetzt ist
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyle( const char *spaltenName, const char *zeilenName, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyle( const char *spaltenName, const char *zeilenName, __int64 style ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style nicht gesetzt ist
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyleNicht( const char *spaltenName, const char *zeilenName, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyleNicht( const char *spaltenName, const char *zeilenName, __int64 style ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style gesetzt ist
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyle( Text *spaltenName, Text *zeilenName, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyle( Text *spaltenName, Text *zeilenName, __int64 style ) const;
         // Prüft ob bei dem Flag AuswahlMultistyled für ein bestimmtes Kästchen ein bestimmter Style nicht gesetzt ist
         //  spaltenName: Der Name der Spalte
         //  zeilenName: Der Name der Zeile
         //  style: Der Style, der gepfüft werden soll
-		__declspec( dllexport ) inline bool hatMsStyleNicht( Text *spaltenName, Text *zeilenName, __int64 style ) const;
+        __declspec( dllexport ) inline bool hatMsStyleNicht( Text *spaltenName, Text *zeilenName, __int64 style ) const;
         // Erzeugt eine Kopie der Tabelle, die ohne auswirkungen auf das Original verändert werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) ObjTabelle *getThis();
+        __declspec( dllexport ) ObjTabelle *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) ObjTabelle *release();
-	};
+        __declspec( dllexport ) ObjTabelle *release();
+    };
 }
 #endif

TastaturEreignis.cpp

@@ -4,31 +4,31 @@ using namespace Framework;
 
 bool Framework::_ret1TE( void *param, void *obj, TastaturEreignis te )
 {
-	return 1;
+    return 1;
 }
 
 bool Framework::_nurNummernTE( void *param, void *obj, TastaturEreignis te )
 {
-	if( te.taste >= '0' && te.taste <= '9' )
-		return 1;
-	if( te.taste == T_Entf || te.taste == T_BackSpace )
-		return 1;
-	if( te.taste == T_Links || te.taste == T_Rechts || te.taste == T_Unten || te.taste == T_Oben )
-		return 1;
-	return 0;
+    if( te.taste >= '0' && te.taste <= '9' )
+        return 1;
+    if( te.taste == T_Entf || te.taste == T_BackSpace )
+        return 1;
+    if( te.taste == T_Links || te.taste == T_Rechts || te.taste == T_Unten || te.taste == T_Oben )
+        return 1;
+    return 0;
 }
 
 bool Framework::_nurHexTE( void *param, void *obj, TastaturEreignis te )
 {
-	if( te.taste >= '0' && te.taste <= '9' )
-		return 1;
-	if( te.taste >= 'A' && te.taste <= 'F' )
-		return 1;
-	if( te.taste >= 'a' && te.taste <= 'f' )
-		return 1;
-	if( te.taste == T_Entf || te.taste == T_BackSpace )
-		return 1;
-	if( te.taste == T_Links || te.taste == T_Rechts || te.taste == T_Unten || te.taste == T_Oben )
-		return 1;
-	return 0;
+    if( te.taste >= '0' && te.taste <= '9' )
+        return 1;
+    if( te.taste >= 'A' && te.taste <= 'F' )
+        return 1;
+    if( te.taste >= 'a' && te.taste <= 'f' )
+        return 1;
+    if( te.taste == T_Entf || te.taste == T_BackSpace )
+        return 1;
+    if( te.taste == T_Links || te.taste == T_Rechts || te.taste == T_Unten || te.taste == T_Oben )
+        return 1;
+    return 0;
 }

TastaturEreignis.h

@@ -6,54 +6,54 @@
 namespace Framework
 {
     // Es wurde eine Taste runtergedrückt
-	const int TE_Press = 0;
+    const int TE_Press = 0;
     // Es wurde eine Taste losgelassen
-	const int TE_Release = 1;
-	const unsigned char T_Esc = 27;
-	const unsigned char T_Tab = 0;
-	const unsigned char T_Enter = 13;
-	const unsigned char T_BackSpace = 8;
-	const unsigned char T_Space = 32;
-	const unsigned char T_Caps_Lock = 129;
-	const unsigned char T_Shift = 130;
-	const unsigned char T_Strg = 141;
-	const unsigned char T_F1 = 143;
-	const unsigned char T_F2 = 144;
-	const unsigned char T_F3 = 157;
-	const unsigned char T_F4 = 160;
-	const unsigned char T_F5 = 130;
-	const unsigned char T_F6 = 132;
-	const unsigned char T_F7 = 133;
-	const unsigned char T_F8 = 134;
-	const unsigned char T_F9 = 135;
-	const unsigned char T_F10 = 136;
-	const unsigned char T_F11 = 137;
-	const unsigned char T_F12 = 138;
-	const unsigned char T_Pause = 139;
-	const unsigned char T_Druck = 140;
-	const unsigned char T_Einfg = 142;
-	const unsigned char T_Entf = 145;
-	const unsigned char T_Links = 146;
-	const unsigned char T_Oben = 147;
-	const unsigned char T_Rechts = 148;
-	const unsigned char T_Unten = 149;
-	const unsigned char T_Alt_Gr = 150;
-	const unsigned char T_Num = 151;
-	const unsigned char T_Pos1 = 152;
-	const unsigned char T_BildO = 153;
-	const unsigned char T_BildU = 154;
-	const unsigned char T_Ende = 155;
+    const int TE_Release = 1;
+    const unsigned char T_Esc = 27;
+    const unsigned char T_Tab = 0;
+    const unsigned char T_Enter = 13;
+    const unsigned char T_BackSpace = 8;
+    const unsigned char T_Space = 32;
+    const unsigned char T_Caps_Lock = 129;
+    const unsigned char T_Shift = 130;
+    const unsigned char T_Strg = 141;
+    const unsigned char T_F1 = 143;
+    const unsigned char T_F2 = 144;
+    const unsigned char T_F3 = 157;
+    const unsigned char T_F4 = 160;
+    const unsigned char T_F5 = 130;
+    const unsigned char T_F6 = 132;
+    const unsigned char T_F7 = 133;
+    const unsigned char T_F8 = 134;
+    const unsigned char T_F9 = 135;
+    const unsigned char T_F10 = 136;
+    const unsigned char T_F11 = 137;
+    const unsigned char T_F12 = 138;
+    const unsigned char T_Pause = 139;
+    const unsigned char T_Druck = 140;
+    const unsigned char T_Einfg = 142;
+    const unsigned char T_Entf = 145;
+    const unsigned char T_Links = 146;
+    const unsigned char T_Oben = 147;
+    const unsigned char T_Rechts = 148;
+    const unsigned char T_Unten = 149;
+    const unsigned char T_Alt_Gr = 150;
+    const unsigned char T_Num = 151;
+    const unsigned char T_Pos1 = 152;
+    const unsigned char T_BildO = 153;
+    const unsigned char T_BildU = 154;
+    const unsigned char T_Ende = 155;
 
     // Speichert den Input eines Nutzers auf der Tastatur
-	struct TastaturEreignis
-	{
+    struct TastaturEreignis
+    {
         // Art der Eingabe
-		int id;
+        int id;
         // Betroffene Taste
-		unsigned char taste;
+        unsigned char taste;
         // (true), wenn die Eingabe bereits verarbeitet wurde. (false) sonnst
-		bool verarbeitet;
-	};
+        bool verarbeitet;
+    };
 
     // Standart Tastatur Ereinis Rückruffunktion
     //  param: Ein beliebiger Parameter
@@ -61,21 +61,21 @@ namespace Framework
     //  te: Das Tastaturereignis, welches verarbeitet werden soll
     //  return: (true), wenn aufrufende Zeichnung das Ereignis weiterverarbeiten soll. (false) sonnst.
     // Gibt immer (true) zurück
-	__declspec( dllexport ) bool _ret1TE( void *param, void *obj, TastaturEreignis te );
+    __declspec( dllexport ) bool _ret1TE( void *param, void *obj, TastaturEreignis te );
     // Standart Tastatur Ereinis Rückruffunktion
     //  param: Ein beliebiger Parameter
     //  obj: Die Zeichnung, welches diese Funktion aufruft
     //  te: Das Tastaturereignis, welches verarbeitet werden soll
     //  return: (true), wenn aufrufende Zeichnung das Ereignis weiterverarbeiten soll. (false) sonnst.
     // Gibt nur (true) zurück, wenn die Taste zwischen '0' und '9' ist, oder zum Löschen oder Cursorbewegen dient
-	__declspec( dllexport ) bool _nurNummernTE( void *param, void *obj, TastaturEreignis te );
+    __declspec( dllexport ) bool _nurNummernTE( void *param, void *obj, TastaturEreignis te );
     // Standart Tastatur Ereinis Rückruffunktion
     //  param: Ein beliebiger Parameter
     //  obj: Die Zeichnung, welches diese Funktion aufruft
     //  te: Das Tastaturereignis, welches verarbeitet werden soll
     //  return: (true), wenn aufrufende Zeichnung das Ereignis weiterverarbeiten soll. (false) sonnst.
     // Gibt nur (true) zurück, wenn die Taste zwischen '0' und '9' oder 'A' und 'F' ist, oder zum Löschen oder Cursorbewegen dient
-	__declspec( dllexport ) bool _nurHexTE( void *param, void *obj, TastaturEreignis te );
+    __declspec( dllexport ) bool _nurHexTE( void *param, void *obj, TastaturEreignis te );
 }
 
 #endif

Text.cpp

@@ -14,33 +14,33 @@ using namespace Framework;
 // inhalt der Text Klasse aus Text.h
 // Konstruktor 
 Text::Text()
-	: txt( 0 ),
-	  suchGBeg( 0 ),
-	  suchGEnd( 0 ),
-	  präzision( 0 ),
-	  ref( 1 )
+    : txt( 0 ),
+    suchGBeg( 0 ),
+    suchGEnd( 0 ),
+    präzision( 0 ),
+    ref( 1 )
 {
-	setText( "" );
+    setText( "" );
 }
 
 Text::Text( const Text &txt )
-	: txt( 0 ),
-	suchGBeg( 0 ),
-	suchGEnd( 0 ),
-	präzision( 0 ),
-	ref( 1 )
+    : txt( 0 ),
+    suchGBeg( 0 ),
+    suchGEnd( 0 ),
+    präzision( 0 ),
+    ref( 1 )
 {
-	setText( txt );
+    setText( txt );
 }
 
 Text::Text( const char *t )
-	: txt( 0 ),
-	  suchGBeg( 0 ),
-	  suchGEnd( 0 ),
-	  präzision( 0 ),
-	  ref( 1 )
+    : txt( 0 ),
+    suchGBeg( 0 ),
+    suchGEnd( 0 ),
+    präzision( 0 ),
+    ref( 1 )
 {
-	setText( t ); // Text setzen
+    setText( t ); // Text setzen
 }
 
 Text::Text( int zahl )
@@ -56,59 +56,59 @@ Text::Text( int zahl )
 // Destruktor 
 Text::~Text()
 {
-	delete[]txt;
+    delete[]txt;
 }
 
 // nicht constant
 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
 {
-	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
+    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
+    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
+    setText( t->getText() ); // Text setzen
+    t = t->release(); // übergabe loslassen
 }
 
 void Text::anhängen( char c ) // hängt an den Text an
 {
-	anhängen( &c, 1 );
+    anhängen( &c, 1 );
 }
 
 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
+    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::hexAnhängen( int num ) // hängt die zahl in hex anden Text an
@@ -130,1217 +130,1217 @@ void Text::hexAnh
 void Text::farbeAnhängen( int fc ) // setzt die Farbe des folgenden Textes
 {
     int l = getLänge();
-	char *res = new char[ l + 12 ];
-	for( int i = 0; i < l; ++i )
-		res[ i ] = txt[ i ];
-	res[ l ] = '\r';
-	res[ l + 1 ] = '0';
-	res[ l + 2 ] = 'x';
-	std::stringstream stream;
-	stream << std::setfill( '0' ) << std::setw( sizeof( int ) * 2 ) << std::hex << fc;
-	std::string str = stream.str();
-	for( int i = l + 3; i < l + 11; ++i )
-		res[ i ] = str.c_str()[ i - ( l + 3 ) ];
-	res[ l + 11 ] = 0;
-	setText( res );
-	delete[] res;
+    char *res = new char[ l + 12 ];
+    for( int i = 0; i < l; ++i )
+        res[ i ] = txt[ i ];
+    res[ l ] = '\r';
+    res[ l + 1 ] = '0';
+    res[ l + 2 ] = 'x';
+    std::stringstream stream;
+    stream << std::setfill( '0' ) << std::setw( sizeof( int ) * 2 ) << std::hex << fc;
+    std::string str = stream.str();
+    for( int i = l + 3; i < l + 11; ++i )
+        res[ i ] = str.c_str()[ i - ( l + 3 ) ];
+    res[ l + 11 ] = 0;
+    setText( res );
+    delete[] res;
 }
 
 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
+    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
+    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() );
+    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() );
+    std::stringstream ss;
+    ss << num;
+    anhängen( ss.str().c_str() );
 }
 
 void Text::anhängen( double num )
 {
-	std::stringstream ss;
-	ss.precision( präzision );
-	ss << num;
-	anhängen( ss.str().c_str() );
+    std::stringstream ss;
+    ss.precision( präzision );
+    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
+    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
+    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
+    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
+    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
+    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
-	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
-	}
+    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
+    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 = 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( 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;
+    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( 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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
-		ersetzen( t1->getText(), t2 ); // ersetzen
-	t1 = t1->release(); // Übergabe loslassen
+    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
+    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();
+    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 anz = anzahlVon( c1 );
-	if( index >= anz ) // prüfen ob es ein i-tes c1 gibt
-		return;
-	txt[ positionVon( c1, index ) ] = 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 = getLänge(); // Text Länge
-	int t1l = (int)strlen( 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
+    int txl = getLänge(); // Text Länge
+    int t1l = (int)strlen( 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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
-		ersetzen( i, t1->getText(), t2 ); // ersetzen
-	t1 = t1->release(); // Übergabe loslassen
+    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
+    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();
+    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;
+    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 < 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
+    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 < 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::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
+    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
-	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
+    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
+    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::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( 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
+    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( 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::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
+    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
-	if( pos < 0 )
-		return;
-	int l = getLänge(); // 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
+    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 = getLänge(); // 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::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
-	if( pos < 0 )
-		return;
-	int l = getLänge(); // Länge des Textes
-	if( !l )
-		return;
-	char *res = new char[ 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
+    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
+    if( pos < 0 )
+        return;
+    int l = getLänge(); // Länge des Textes
+    if( !l )
+        return;
+    char *res = new char[ 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::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
+    if( t->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
+        löschen( i, t->getText() ); // löschen
+    t = t->release(); // Übergabe loslassen
 }
 
 void Text::setPräzision( int p ) // setzt die Anzahl der Nachkommastellen bei doubles
 {
-	präzision = p;
+    präzision = p;
 }
 
 // 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;
+    if( !txt )
+        return -1;
+    int ret = 0;
+    for( ; txt[ ret ] != '\0'; ++ret ); // zählen
+    return ret;
 }
 
 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;
-	}
+    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 vllän = 1;
-	while( pos - lpos - vllän - 1 >= 0 && txt[ pos - lpos - vllän - 1 ] != '\n' )
-		++vllän;
-	if( vllän > lpos )
-		return pos - vllän;
-	else
-		return pos - lpos - 1;
+    if( !hat( '\n' ) )
+        return 0;
+    int lpos = 0;
+    while( pos - lpos - 1 > 0 && txt[ pos - lpos - 1 ] != '\n' )
+        ++lpos;
+    int vllän = 1;
+    while( pos - lpos - vllän - 1 >= 0 && txt[ pos - lpos - vllän - 1 ] != '\n' )
+        ++vllän;
+    if( vllän > lpos )
+        return pos - vllän;
+    else
+        return pos - lpos - 1;
 }
 
 int Text::getRKick( int pos ) const
 {
-	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 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 ) const
 {
-	if( !hat( '\n' ) )
-		return getLänge();
-	int lpos = 0;
-	while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
-		++lpos;
-	int llän = 1;
-	while( pos + llän - 1 < getLänge() && txt[ pos + llän - 1 ] != '\n' )
-		++llän;
-	int vllän = 1;
-	while( pos + llän + vllän - 1 < getLänge() && txt[ pos + llän + vllän - 1 ] != '\n' )
-		++vllän;
-	if( vllän == 1 )
-		return pos + llän < getLänge() ? pos + llän : getLänge();
-	if( vllän < lpos )
-		return pos + llän + vllän - 1;
-	return pos + llän + lpos;
+    if( !hat( '\n' ) )
+        return getLänge();
+    int lpos = 0;
+    while( pos - lpos > 0 && txt[ pos - lpos - 1 ] != '\n' )
+        ++lpos;
+    int llän = 1;
+    while( pos + llän - 1 < getLänge() && txt[ pos + llän - 1 ] != '\n' )
+        ++llän;
+    int vllän = 1;
+    while( pos + llän + vllän - 1 < getLänge() && txt[ pos + llän + vllän - 1 ] != '\n' )
+        ++vllän;
+    if( vllän == 1 )
+        return pos + llän < getLänge() ? pos + llän : getLänge();
+    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 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;
-	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;
+    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 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;
 }
 
 bool Text::hat( char c ) const // enthält c
 {
-	int l = getLänge(); // 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;
+    int l = getLänge(); // 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 = 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
-		ret &= txt[ i ] == t[ i ];
-	return ret;
+    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
+        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;
+    bool ret = istGleich( t->getText() ); // prüfen
+    t->release(); // Übergabe loslassen
+    return ret;
 }
 
 char *Text::getText() const // gibt Text zurück
 {
-	return txt;
+    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
-	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 ret = 0;
+    int l = getLänge(); // 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)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;
-	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 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;
+    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->getLänge() > 0 )  // Auf unsinnige übergabe prüfen
-		ret = anzahlVon( t->getText() ); // zählen
-	t = t->release(); // Übergabe loslassen
-	return ret;
+    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
-	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 l = getLänge(); // 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)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;
-	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 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;
+    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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
-		ret = positionVon( t->getText() ); // position ermitteln
-	t = t->release(); // Übergabe loslassen
-	return ret;
+    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;
-	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 l = getLänge(); // 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)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;
-	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 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;
+    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->getLänge() > 0 ) // Auf unsinnige übergabe prüfen
-		ret = positionVon( t->getText(), i ); // position ermitteln
-	t = t->release(); // Übergabe loslassen
-	return ret;
+    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;
+    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
+    return getTeilText( p, getLänge() ); // Text zurückgeben
 }
 
 // Reference Counting
 Text *Text::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Text *Text::release()
 {
-	--ref;
-	if( ref < 1 )
-		delete this;
-	return 0;
+    --ref;
+    if( ref < 1 )
+        delete this;
+    return 0;
 }
 
 // Operatoren
 Text &Text::operator+=( const int num )
 {
-	anhängen( num );
-	return *this;
+    anhängen( num );
+    return *this;
 }
 
 Text &Text::operator+=( const double num )
 {
-	anhängen( num );
-	return *this;
+    anhängen( num );
+    return *this;
 }
 
 Text &Text::operator+=( const char *txt )
 {
-	anhängen( txt );
-	return *this;
+    anhängen( txt );
+    return *this;
 }
 
 Text &Text::operator+=( const Text &txt )
 {
-	anhängen( txt.getText() );
-	return *this;
+    anhängen( txt.getText() );
+    return *this;
 }
 
 Text &Text::operator=( const int num )
 {
-	setText( "" );
-	anhängen( num );
-	return *this;
+    setText( "" );
+    anhängen( num );
+    return *this;
 }
 
 Text &Text::operator=( const double num )
 {
-	setText( "" );
-	anhängen( num );
-	return *this;
+    setText( "" );
+    anhängen( num );
+    return *this;
 }
 
 Text &Text::operator=( const char *txt )
 {
-	setText( txt );
-	return *this;
+    setText( txt );
+    return *this;
 }
 
 Text &Text::operator=( const Text &txt )
 {
-	setText( txt.getText() );
-	return *this;
+    setText( txt.getText() );
+    return *this;
 }
 
 Text::operator char*( ) const
 {
-	return txt;
+    return txt;
 }
 
 Text::operator int() const
 {
-	if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
-		return TextZuInt( ( txt + 2 ), 16 );
-	return TextZuInt( txt, 10 );
+    if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
+        return TextZuInt( ( txt + 2 ), 16 );
+    return TextZuInt( txt, 10 );
 }
 
 Text::operator double() const
 {
-	if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
-		return TextZuInt( ( txt + 2 ), 16 );
-	return TextZuDouble( txt );
+    if( txt[ 0 ] == '0' && txt[ 1 ] == 'x' )
+        return TextZuInt( ( txt + 2 ), 16 );
+    return TextZuDouble( txt );
 }
 
 bool Text::operator>( Text &t ) const
 {
-	int län1 = getLänge();
-	int län2 = t.getLänge();
-	char *txt2 = t;
-	for( int i = 0; i < län1 && i < län2; ++i )
-	{
-		if( txt[ i ] > txt2[ i ] )
-			return 1;
-		if( txt[ i ] < txt2[ i ] )
-			return 0;
-	}
-	if( län1 > län2 )
-		return 1;
-	return 0;
+    int län1 = getLänge();
+    int län2 = t.getLänge();
+    char *txt2 = t;
+    for( int i = 0; i < län1 && i < län2; ++i )
+    {
+        if( txt[ i ] > txt2[ i ] )
+            return 1;
+        if( txt[ i ] < txt2[ i ] )
+            return 0;
+    }
+    if( län1 > län2 )
+        return 1;
+    return 0;
 }
 
 bool Text::operator<( Text &t ) const
 {
-	int län1 = getLänge();
-	int län2 = t.getLänge();
-	char *txt2 = t;
-	for( int i = 0; i < län1 && i < län2; ++i )
-	{
-		if( txt[ i ] < txt2[ i ] )
-			return 1;
-		if( txt[ i ] > txt2[ i ] )
-			return 0;
-	}
-	if( län1 < län2 )
-		return 1;
-	return 0;
+    int län1 = getLänge();
+    int län2 = t.getLänge();
+    char *txt2 = t;
+    for( int i = 0; i < län1 && i < län2; ++i )
+    {
+        if( txt[ i ] < txt2[ i ] )
+            return 1;
+        if( txt[ i ] > txt2[ i ] )
+            return 0;
+    }
+    if( län1 < län2 )
+        return 1;
+    return 0;
 }
 
 // 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 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 = textLänge( suche ); // Länge der Übergabe
-	int txl = textLänge( 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;
+    for( int i = 0; i < sBegPos; ++i )
+    {
+        if( !*string )
+            return -1;
+        ++string;
+    }
+    int tl = textLänge( suche ); // Länge der Übergabe
+    int txl = textLänge( 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
 {
 #ifdef WIN32
-	int län = textLänge( 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 = textLänge( 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::TextEinfügen() // 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::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;
+    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 == ' ' || zeichen == '\t' )
-		return 1;
-	return 0;
+    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 strtoul( c, 0, system );
-	return strtol( c, 0, system );
+    if( system == 16 )
+        return strtoul( c, 0, system );
+    return strtol( c, 0, system );
 }
 
 unsigned int Framework::TextZuInt( char *c, char **c_ende, int system )
 {
-	if( system == 16 )
-		return strtoul( c, c_ende, system );
-	return strtol( c, c_ende, system );
+    if( system == 16 )
+        return strtoul( c, c_ende, system );
+    return strtol( c, c_ende, system );
 }
 
 double Framework::TextZuDouble( char *c ) // Konvertiert c zu double
 {
-	return strtod( c, 0 );
+    return strtod( c, 0 );
 }
 
 double Framework::TextZuDouble( char *c, char **c_ende )
 {
-	return strtod( c, c_ende );
+    return strtod( c, c_ende );
 }
 
 int Framework::textLänge( const char *txt ) // gibt die Länge von txt zurück
 {
-	if( !txt )
-		return 0;
-	int ret = 0;
-	for( ; txt[ ret ] != 0; ++ret );
-	return ret;
+    if( !txt )
+        return 0;
+    int ret = 0;
+    for( ; txt[ ret ] != 0; ++ret );
+    return ret;
 }

Text.h

@@ -31,7 +31,6 @@ namespace Framework
         __declspec( dllexport ) Text( int zahl );
         // Löscht den Text
         __declspec( dllexport ) ~Text();
-
         // Legt die Suchgrenzen fest, die von den Suchfunktionen verwendet werden.
         //  gBeg: Das Zeichen, bei dem die Suche beginnen soll
         //  gEnd: Das Zeichen, bei dem die Suche enden soll
@@ -178,7 +177,6 @@ namespace Framework
         // Setzt die Anzahl der Nachkommastellen beim Anhängen von Kommazahlen
         //  p: Die Anzahl der Stellen nach dem Komma
         __declspec( dllexport ) void setPräzision( int p );
-
         // Gibt die Länge des Textes zurück
         __declspec( dllexport ) int getLänge() const;
         // Ermittelt die neue Curserposition nachdem Drücken der 'Links' Pfeiltaste
@@ -261,14 +259,12 @@ namespace Framework
         // 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)
         __declspec( dllexport ) Text *getTeilText( int p ) const;
-
         // Erhöht den Reference Counting Zähler.
         //  return: this.
         __declspec( dllexport ) Text *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
         __declspec( dllexport ) Text *release();
-
         // Hängt eine Zahl ans Ende des Textes an
         __declspec( dllexport ) Text &operator+=( const int num );
         // Hängt eine Kommazahl ans Ende des Textes an

TextFeld.h

@@ -5,17 +5,17 @@
 
 namespace Framework
 {
-	class Schrift; // Schrift.h
-	class Text; // Text.h
-	class AlphaFeld; // AlphaFeld.h
-	class LRahmen; // Rahmen.h
-	class TextFeld; // aus dieser Datei
-	class VScrollBar; // Scroll.h
+    class Schrift; // Schrift.h
+    class Text; // Text.h
+    class AlphaFeld; // AlphaFeld.h
+    class LRahmen; // Rahmen.h
+    class TextFeld; // aus dieser Datei
+    class VScrollBar; // Scroll.h
     class HScrollBar; // Scroll.h
 
     // Verwaltet ein Textfeld
-	class TextFeld : public ZeichnungHintergrund
-	{
+    class TextFeld : public ZeichnungHintergrund
+    {
     public:
         class Style : public ZeichnungHintergrund::Style
         {
@@ -31,26 +31,26 @@ namespace Framework
             const static __int64 TextGebiet = Sichtbar | Erlaubt | Rahmen | Hintergrund | Mehrfarbig | Mehrzeilig | VScroll; // Vereint die Flags Sichtbar, Erlaubt, Rahmen, Hintergrund, Mehrzeilig, Mehrfarbig, VScroll
             const static __int64 Scroll = VScroll | HScroll; // Vereint die Flags VScroll und HScroll
         };
-	private:
-		unsigned char schriftGröße;
-		Schrift *schrift;
-		Text *text;
-		int sF;
-		unsigned char showChar;
-		int begf, cpos;
-		double tickVal;
-		bool mausKlick;
+    private:
+        unsigned char schriftGröße;
+        Schrift *schrift;
+        Text *text;
+        int sF;
+        unsigned char showChar;
+        int begf, cpos;
+        double tickVal;
+        bool mausKlick;
     protected:
-		int ref;
+        int ref;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) TextFeld();
-		// Destruktor 
-		__declspec( dllexport ) ~TextFeld();
-		// setzt einen Zeiger auf den Text im Textfeld
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) TextFeld();
+        // Destruktor 
+        __declspec( dllexport ) ~TextFeld();
+        // setzt einen Zeiger auf den Text im Textfeld
         //  txt: Der Zeiger auf den Text
-		__declspec( dllexport ) void setTextZ( Text *txt );
+        __declspec( dllexport ) void setTextZ( Text *txt );
         // setzt den Text des Textfeldes
         //  txt: der Text
         __declspec( dllexport ) void setText( Text *txt );
@@ -59,63 +59,63 @@ namespace Framework
         __declspec( dllexport ) void setText( const char *txt );
         // Fügt eine Zeile an den Text an
         //  zeile: Die neue Zeile
-		__declspec( dllexport ) void addZeile( const char *zeile );
+        __declspec( dllexport ) void addZeile( const char *zeile );
         // Setzt den ausgewählten textabschnitt fest (benötigt Flag zum Zeichnen: Erlaubt, Fokus)
         //  pos1: Die Cursorposition im Text
         //  pos2: Die Position im Text, bis zu der der Text eingefärbt werden soll
-		__declspec( dllexport ) void setAuswahl( int pos1, int pos2 );
+        __declspec( dllexport ) void setAuswahl( int pos1, int pos2 );
         // Setzt den ausgewählten textabschnitt fest (benötigt Flag zum Zeichnen: Erlaubt, Fokus)
         //  auswahl: Ein punkt mit x als Cursorposition und y als der Position, bis zu der der Text eingefärbt werden soll
         __declspec( dllexport ) void setAuswahl( Punkt &auswahl );
         // Setzt einen Zeiger zur Schrift
         //  schrift: Die Schrift, die zum Textzeichnen verwendet werden soll.
-		__declspec( dllexport ) void setSchriftZ( Schrift *schrift );
+        __declspec( dllexport ) void setSchriftZ( Schrift *schrift );
         // Setzt die Schriftgröße (Standart: 12)
         //  gr: Die Schriftgröße, die zum Textzeichnen verwendet werden soll
-		__declspec( dllexport ) void setSchriftGröße( unsigned char gr );
+        __declspec( dllexport ) void setSchriftGröße( unsigned char gr );
         // Setzt die Schrift Farbe
         //  fc: Die Farbe, die zum Textzeichnen verwendet werden soll
-		__declspec( dllexport ) void setSchriftFarbe( int fc );
+        __declspec( dllexport ) void setSchriftFarbe( int fc );
         // Legt einen Buchstaben fest, der zum zeichnen verwendet werden soll, unabhängig vom Text des Textfeldes (benötigt Flag zum Zeichnen: Rahmen)
         //  c: Der Buchstabe, der gezeichnet werden soll
         // Beispiel: setShowChar( '*' ); Bei Passwort Textfeldern
-		__declspec( dllexport ) void setSchowChar( unsigned char c );
+        __declspec( dllexport ) void setSchowChar( unsigned char c );
         // Scrollt zu einer bestimmten Zeile (benötigt Flag zum Zeichnen: VScroll)
         //  zeile: Der Index der Zeile, die als oberste Zeile zu sehen sein soll
-		__declspec( dllexport ) void setVScrollZuZeile( int zeile );
+        __declspec( dllexport ) void setVScrollZuZeile( int zeile );
         // Scrollt zu einer bestimmten Position im Text. Ohne den Flag Erlaubt wrd immer ganz nach unten gescrollt. (benötigt Flag zum Zeichnen: VScroll)
         //  pos: Der Index des Zeichens, zu dem gescrollt werden soll. Standartmäßig wird zur Cursorposition gescrollt
-		__declspec( dllexport ) void updateVScroll( int pos = -1 );
+        __declspec( dllexport ) void updateVScroll( int pos = -1 );
         // Scrollt zu einer bestimmten Position im Text. Benötigt den Flag Erlaubt. (benötigt Flag zum Zeichnen: HScroll)
         //  pos: Der Index des Zeichens, zu dem gescrollt werden soll. Standartmäßig wird zur Cursorposition gescrollt
-		__declspec( dllexport ) void updateHScroll( int pos = -1 );
+        __declspec( dllexport ) void updateHScroll( int pos = -1 );
         // Aktualisiert das Objekt. Wird vom Framework aufgerufen
         //  tickVal: Die Zeit in sekunden, die seit dem lezten Aufruf dieser Funktion vergangen ist
         //  return: 1, wenn sich etwas verändert hat und das Bild neu gezeichnet werden muss. 0 sonst
-		__declspec( dllexport ) virtual bool tick( double tickval ) override;
+        __declspec( dllexport ) virtual bool tick( double tickval ) override;
         // Verarbeitet Maus Nachrichten
         //  me: Das Ereignis, was durch die Mauseingabe ausgelößt wurde
-		__declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me ) override;
         // Verarbeitet Tastatur Nachrichten
         //  me: Das Ereignis, was durch die Tastatureingabe ausgelößt wurde
-		__declspec( dllexport ) void doTastaturEreignis( TastaturEreignis &te ) override;
+        __declspec( dllexport ) void doTastaturEreignis( TastaturEreignis &te ) override;
         // Zeichnet das Objekt nach zRObj, falls es sichtbar ist
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) virtual void render( Bild &zRObj ) override;
-		// Gibt den Text aus dem Textfeld zurück
-		__declspec( dllexport ) Text *getText() const;
+        __declspec( dllexport ) virtual void render( Bild &zRObj ) override;
+        // Gibt den Text aus dem Textfeld zurück
+        __declspec( dllexport ) Text *getText() const;
         // Gibt den Text aus dem Textfeld ohne erhöhten Reference Counter zurück
-		__declspec( dllexport ) Text *zText() const;
+        __declspec( dllexport ) Text *zText() const;
         // Gibt die Schrift zurück.
         //  return: 0, falls die Schrift nicht gesetzt wurde
-		__declspec( dllexport ) Schrift *getSchrift() const;
+        __declspec( dllexport ) Schrift *getSchrift() const;
         // Gibt die Schrift ohne erhöhten Reference Counter zurük
         //  return: 0, falls die Schrift nicht gesetzt wurde
-		__declspec( dllexport ) Schrift *zSchrift() const;
+        __declspec( dllexport ) Schrift *zSchrift() const;
         // Gibt die Schriftgröße zurück
-		__declspec( dllexport ) unsigned char getSchriftGröße() const;
+        __declspec( dllexport ) unsigned char getSchriftGröße() const;
         // Gibt die Schriftfarbe im A8R8G8B8 Format zurück
-		__declspec( dllexport ) int getSchriftFarbe() const;
+        __declspec( dllexport ) int getSchriftFarbe() const;
         // Gibt den Anzeigebuchstabe zurück
         __declspec( dllexport ) unsigned char getShowChar() const;
         // Gibt die Cursorposition zurück
@@ -123,13 +123,13 @@ namespace Framework
         // Gibt den Index des Buchstaben zurück, con dem an der Text bis zur Cursorposition eingefärbt ist
         __declspec( dllexport ) int getFärbungPos() const;
         // Erzeugt eine Komplette Kopie des Textfeldes, welches ohne auswirkungen verändert werden kann
-		__declspec( dllexport ) Zeichnung *dublizieren() const override;
+        __declspec( dllexport ) Zeichnung *dublizieren() const override;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) virtual TextFeld *getThis();
+        __declspec( dllexport ) virtual TextFeld *getThis();
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Objekt automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) virtual TextFeld *release();
-	};
+        __declspec( dllexport ) virtual TextFeld *release();
+    };
 }
 #endif

Textur.cpp

@@ -77,7 +77,7 @@ bool Textur::updateTextur( Render3D *zRObj )
         bufferDesc.MipLevels = 1;
         bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
         HRESULT r = zRObj->zDevice()->CreateTexture2D( &bufferDesc, 0, &txt );
-        if( r != S_OK  )
+        if( r != S_OK )
             return 0;
     }
     D3D11_MAPPED_SUBRESOURCE buffer;
@@ -85,7 +85,7 @@ bool Textur::updateTextur( Render3D *zRObj )
     int *bgBuff = bild->getBuffer();
     int tmpBr = 4 * bild->getBreite();
     for( int y = 0, pitch = 0, bry = 0; y < bild->getHöhe(); ++y, pitch += buffer.RowPitch, bry += bild->getBreite() )
-        memcpy( &( (BYTE *)buffer.pData )[ pitch ], (void*)&( bgBuff[ bry ] ), tmpBr );
+        memcpy( &( (BYTE *)buffer.pData )[ pitch ], ( void* )&( bgBuff[ bry ] ), tmpBr );
     zRObj->zContext()->Unmap( txt, 0 );
     if( !view || lastGr != bild->getGröße() )
     {

Textur.h

@@ -45,7 +45,7 @@ namespace Framework
         // Gibt die Id der Textur zurück, wenn sie in einer TexturList registriert wurde. (siehe Framework::zTexturRegister())
         __declspec( dllexport ) int getId() const;
         // Gibt die verwendtete Shader Resource View zurück
-        __declspec( dllexport ) operator ID3D11ShaderResourceView*() const;
+        __declspec( dllexport ) operator ID3D11ShaderResourceView*( ) const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
         __declspec( dllexport ) Textur *getThis();

Thread.cpp

@@ -9,10 +9,10 @@ Thread::Thread()
 {
     thRegister->add( this );
 #ifdef WIN32
-	threadHandle = 0;
-	threadId = 0;
+    threadHandle = 0;
+    threadId = 0;
 #endif
-	run = 0;
+    run = 0;
 }
 
 // Destruktor 
@@ -35,48 +35,47 @@ Thread::~Thread()
 // nicht constant 
 void Thread::start() // startet den Thread
 {
-	if( !run )
-	{
+    if( !run )
+    {
 #ifdef WIN32
-		threadHandle = CreateThread( 0, 0, threadStart, this, 0, &threadId );
+        threadHandle = CreateThread( 0, 0, threadStart, this, 0, &threadId );
 #else
-		pthread_create( &threadHandle, NULL, threadStart, this );
+        pthread_create( &threadHandle, NULL, threadStart, this );
 #endif
-	}
-	run = 1;
+    }
+    run = 1;
 }
 #ifdef WIN32
 void Thread::pause() // pausiert den Thread
 {
-	if( run )
-		SuspendThread( threadHandle );
-	run = 0;
+    if( run )
+        SuspendThread( threadHandle );
+    run = 0;
 }
 
 void Thread::fortsetzen() // pausiert den Thread
 {
-	if( !run )
-		ResumeThread( threadHandle );
-	run = 1;
+    if( !run )
+        ResumeThread( threadHandle );
+    run = 1;
 }
 #endif
 void Thread::ende() // beendet den Thread
 {
-	if( run )
-	{
+    if( run )
+    {
 #ifdef WIN32
 #pragma warning(suppress: 6258)
-		TerminateThread( threadHandle, 0 );
+        TerminateThread( threadHandle, 0 );
 #else
-		pthread_cancel( threadHandle );
+        pthread_cancel( threadHandle );
 #endif
-	}
-	run = 0;
+    }
+    run = 0;
 }
 
 void Thread::thread() // Thread
-{
-}
+{}
 
 void Thread::threadEnd()
 {
@@ -86,28 +85,28 @@ void Thread::threadEnd()
 // constant 
 bool Thread::läuft() const // prüft, ob der Thrad aktiv ist
 {
-	return run;
+    return run;
 }
 
 int Thread::warteAufThread( int zeit ) const // wartet zeit lang auf den Thread
 {
 #ifdef WIN32
-	if( !run )
-		return WAIT_OBJECT_0;
-	if( GetCurrentThreadId() == GetThreadId( threadHandle ) )
-		return WAIT_OBJECT_0;
-	return WaitForSingleObject( threadHandle, zeit );
+    if( !run )
+        return WAIT_OBJECT_0;
+    if( GetCurrentThreadId() == GetThreadId( threadHandle ) )
+        return WAIT_OBJECT_0;
+    return WaitForSingleObject( threadHandle, zeit );
 #else
-	if( !run )
-		return 0;
-	return pthread_join( threadHandle, 0 );
+    if( !run )
+        return 0;
+    return pthread_join( threadHandle, 0 );
 #endif
 }
 
 #ifdef WIN32
 void *Thread::getThreadHandle() const
 {
-	return threadHandle;
+    return threadHandle;
 }
 #endif
 
@@ -117,18 +116,18 @@ unsigned long __stdcall Framework::threadStart( void *param )
 {
     if( istThreadOk( (Thread *)param ) )
         ( (Thread *)param )->thread();
-    if( istThreadOk( ( Thread *)param ) )
+    if( istThreadOk( (Thread *)param ) )
         ( (Thread *)param )->threadEnd();
-	return 0;
+    return 0;
 }
 #else
 void *Framework::threadStart( void *param )
 {
-	pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, 0 );
-	( (Thread *)param )->thread();
+    pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, 0 );
+    ( (Thread *)param )->thread();
     ( (Thread *)param )->threadEnd();
-	pthread_exit( 0 );
-	return 0;
+    pthread_exit( 0 );
+    return 0;
 }
 #endif
 

Thread.h

@@ -5,58 +5,58 @@
 
 namespace Framework
 {
-	class Thread;
+    class Thread;
 
     // Ein neuer Thread wie die Thread Klasse aus Java
-	class Thread
-	{
-	protected:
+    class Thread
+    {
+    protected:
 #ifdef WIN32
-		void *threadHandle;
-		unsigned long threadId;
+        void *threadHandle;
+        unsigned long threadId;
 #else
-		pthread_t threadHandle;
+        pthread_t threadHandle;
 #endif
-		bool run;
+        bool run;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Thread();
-		// Destruktor 
-		__declspec( dllexport ) ~Thread();
-		// Startet den neuen Thread 
-		__declspec( dllexport ) void start();
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Thread();
+        // Destruktor 
+        __declspec( dllexport ) ~Thread();
+        // Startet den neuen Thread 
+        __declspec( dllexport ) void start();
 #ifdef WIN32
         // Pausiert den Thread (Nur für Windows)
-		__declspec( dllexport ) void pause();
+        __declspec( dllexport ) void pause();
         // Setzt den Thread Fort (Nur für Windows)
-		__declspec( dllexport ) void fortsetzen();
+        __declspec( dllexport ) void fortsetzen();
 #endif
         // Beendet den Thread
-		__declspec( dllexport ) void ende();
+        __declspec( dllexport ) void ende();
         // Diese Funktion wird von dem neuen Thread ausgeführt.
-		__declspec( dllexport ) virtual void thread();
+        __declspec( dllexport ) virtual void thread();
         // Diese Funktion wird eufgerufen, nachdem die thread Funktion zuende ist
         __declspec( dllexport ) virtual void threadEnd();
         // prüft, ob der Thrad aktiv ist
         // return: true, falls der Thread läuft. 
         //         false, wenn der Thread beendet, pausiert oder noch nicht gestartet wurde.
-		__declspec( dllexport ) bool läuft() const;
+        __declspec( dllexport ) bool läuft() const;
         // wartet zeit lang auf den Thread
         // zeit: Die Zeit, die auf den Thread gewartet werden soll. 1000 = 1 Sekunde
-		__declspec( dllexport ) int warteAufThread( int zeit ) const;
+        __declspec( dllexport ) int warteAufThread( int zeit ) const;
 #ifdef WIN32
         // Gibt ein Handle auf den Thread zurück (Nur für Windows)
-		__declspec( dllexport ) void *getThreadHandle() const;
+        __declspec( dllexport ) void *getThreadHandle() const;
 #endif
-	};
+    };
 
 #ifdef WIN32
     // Diese Funktion wird fon der Thread Klasse benutzt um einen thread zu starten
-	__declspec( dllexport ) unsigned long __stdcall threadStart( void *param ); 
+    __declspec( dllexport ) unsigned long __stdcall threadStart( void *param );
 #else
     // Diese Funktion wird fon der Thread Klasse benutzt um einen thread zu starten
-	void *threadStart( void *param ); // startet thread
+    void *threadStart( void *param ); // startet thread
 #endif
 
     // Eine Klasse, die alle aktuell laufenden Thread Objekte speichert

ToolTip.h

@@ -5,77 +5,78 @@
 
 namespace Framework
 {
-	class Schrift; // Schrift.h
-	class Bild; // Bild.h
-	class AlphaFeld; // AlphaFeld.h
-	class Text; // Text.h
-	class LRahmen; // Rahmen.h
-	struct MausEreignis; // MausEreignis.h
-	class Bildschirm; // Bildschirm.h
+    class Schrift; // Schrift.h
+    class Bild; // Bild.h
+    class AlphaFeld; // AlphaFeld.h
+    class Text; // Text.h
+    class LRahmen; // Rahmen.h
+    struct MausEreignis; // MausEreignis.h
+    class Bildschirm; // Bildschirm.h
 
     // Verwaltet ein automatisch ausfahrendes Fenster an der Mausposition, wo hilfe Texte eingeblendet werden
-	class ToolTip : public TextFeld
-	{
+    class ToolTip : public TextFeld
+    {
     public:
-        class Style : public TextFeld::Style{};
-	private:
+        class Style : public TextFeld::Style
+        {};
+    private:
         Punkt größe;
-		double animationSpeed;
-		double warten;
-		double wartenCount;
+        double animationSpeed;
+        double warten;
+        double wartenCount;
         double tval;
-		bool mausIn;
-		unsigned char alpha;
-		bool sichtbar;
+        bool mausIn;
+        unsigned char alpha;
+        bool sichtbar;
         bool zeichnen;
-		Bildschirm *bildschirm;
+        Bildschirm *bildschirm;
 
-	public:
-		// Konstruktor
-		__declspec( dllexport ) ToolTip( Bildschirm *zSceen );
-		// Destruktor
-		__declspec( dllexport ) ~ToolTip();
-		// Setzt die ausgeklappte Größe.
+    public:
+        // Konstruktor
+        __declspec( dllexport ) ToolTip( Bildschirm *zSceen );
+        // Destruktor
+        __declspec( dllexport ) ~ToolTip();
+        // Setzt die ausgeklappte Größe.
         //  breite: Die Breite in Pixeln
         //  höhe: Die Höhe in Pixeln
         // Die Größe wird beim rendern überschrieben
-		__declspec( dllexport ) void setGröße( int breite, int höhe );
+        __declspec( dllexport ) void setGröße( int breite, int höhe );
         // Setzt die ausgeklappte Größe.
         //  gr: Die Größe in Pixeln
         // Die Größe wird beim rendern überschrieben
-		__declspec( dllexport ) void setGröße( Punkt &gr );
+        __declspec( dllexport ) void setGröße( Punkt &gr );
         // Setzt die anzahl an Seunden, de gewartet wird bis der Tipp erscheint
         //  warten: Die Anzahl an Sekunden
-		__declspec( dllexport ) void setWarten( double warten );
+        __declspec( dllexport ) void setWarten( double warten );
         // Legt fest, wie schnell der Tipp erscheint
         //  speed: Anzahl der Pixel, die pro Sekunde eingeblendet werden. (Standart: 250)
-		__declspec( dllexport ) void setAnimationSpeed( double speed );
+        __declspec( dllexport ) void setAnimationSpeed( double speed );
         // Legt Fest, ob die Maus in dem Zeichnung ist, zu dem der Tip gehört
         //  mausIn: 1, wenn die Maus in dem Zeichnung ist. 0 sonst
-		__declspec( dllexport ) void setMausIn( bool mausIn );
+        __declspec( dllexport ) void setMausIn( bool mausIn );
         // Setzt den Counter zurück, der zählt, wann der Tipp eingeblendet wird.
-		__declspec( dllexport ) void wartenReset();
+        __declspec( dllexport ) void wartenReset();
         // Legt fest, das das Zeichnung, zu dem der Tip gehört gezeichnet wurde, so dass der Tip auch gezeichnet werden könnte
         __declspec( dllexport ) void setZeichnen();
         // Aktualisiert den Tip. Wird vom Framework aufgerufen
         //  tickVal: Die Zeit in sekunden, die seit dem lezten Aufruf dieser Funktion vergangen ist
-		//  return: 1, wenn sich etwas verändert hat und das Bild neu gezeichnet werden muss. 0 sonst
+        //  return: 1, wenn sich etwas verändert hat und das Bild neu gezeichnet werden muss. 0 sonst
         __declspec( dllexport ) bool tick( double tickVal ) override;
         // Verarbeitet Maus Nachrichten
         //  me: Das Ereignis, was durch die Mauseingabe ausgelößt wurde
-		__declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
+        __declspec( dllexport ) void doMausEreignis( MausEreignis &me ) override;
         // Zeichnet den Tip nach zRObj, falls er sichtbar ist und das zugehörige Zeichnung ebenfalls gezeichnet wurde
         //  zRObj: Das Bild, in welches gezeichnet werden soll
-		__declspec( dllexport ) void render( Bild &zRObj ) override;
-		// Gibt einen Zeiger auf den Bildschirm ohne erhöhten Reference Counter zurück, so dem der Tooltip gehört.
-		__declspec( dllexport ) Bildschirm *zBildschirm() const;
+        __declspec( dllexport ) void render( Bild &zRObj ) override;
+        // Gibt einen Zeiger auf den Bildschirm ohne erhöhten Reference Counter zurück, so dem der Tooltip gehört.
+        __declspec( dllexport ) Bildschirm *zBildschirm() const;
         // Erhöht den Reference Counting Zähler.
         //  return: this.
-		__declspec( dllexport ) TextFeld *getThis() override;
+        __declspec( dllexport ) TextFeld *getThis() override;
         // Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
         //  return: 0.
-		__declspec( dllexport ) TextFeld *release() override;
-	};
+        __declspec( dllexport ) TextFeld *release() override;
+    };
 }
 
 #endif

Vec2.h

@@ -6,195 +6,192 @@
 namespace Framework
 {
     // Ein zweidimensionaler Vektor
-	template< typename T >
-	class Vec2
-	{
-	public:
-		T x; // x Komponente des Vektors
-		T y; // y Komponente des Vektors
-		// Konstruktor
-		inline Vec2()
-		{
-		}
+    template< typename T >
+    class Vec2
+    {
+    public:
+        T x; // x Komponente des Vektors
+        T y; // y Komponente des Vektors
+        // Konstruktor
+        inline Vec2()
+        {}
         // Konstruktor
         //  x: X Komponente des Vektors
         //  y: Y Komponente des Vektors
-		inline Vec2( T x, T y )
-			: x( x ),
-			  y( y )
-		{
-		}
+        inline Vec2( T x, T y )
+            : x( x ),
+            y( y )
+        {}
         // Konstruktor
         //  vect: Ein Vektor, dessen Komponenten übernommen werden
-		inline Vec2( const Vec2 &vect )
-			: x( (T)vect.x ),
-			  y( (T)vect.y )
-		{
-		}
-		// Skalliert den Vektor, so dass er die Länge 1 hat
-		inline Vec2 &normalize()
-		{
-			const T länge = län();
-			x /= länge;
-			y /= länge;
-			return *this;
-		}
+        inline Vec2( const Vec2 &vect )
+            : x( (T)vect.x ),
+            y( (T)vect.y )
+        {}
+        // Skalliert den Vektor, so dass er die Länge 1 hat
+        inline Vec2 &normalize()
+        {
+            const T länge = län();
+            x /= länge;
+            y /= länge;
+            return *this;
+        }
         // Dreht den Vektor um 90 Grad gegen den Uhrzeigersinn
-		inline Vec2 &CCW90()
-		{
-			T temp = y;
-			y = -x;
-			x = temp;
-			return *this;
-		}
+        inline Vec2 &CCW90()
+        {
+            T temp = y;
+            y = -x;
+            x = temp;
+            return *this;
+        }
         // Dreht den Vektor um 90 Grad im Uhrzeigersinn
-		inline Vec2 &CW90()
-		{
-			T temp = y;
-			y = x;
-			x = -temp;
-			return *this;
-		}
+        inline Vec2 &CW90()
+        {
+            T temp = y;
+            y = x;
+            x = -temp;
+            return *this;
+        }
         // Tauscht die Werte der Vektoren aus
         //  vect: Der Vektor, mit dem getauscht werden soll
-		inline Vec2 &Swap( Vec2 &vect )
-		{
-			const Vec2 tmp = vect;
-			vect = *this;
-			*this = tmp;
-			return *this;
-		}
+        inline Vec2 &Swap( Vec2 &vect )
+        {
+            const Vec2 tmp = vect;
+            vect = *this;
+            *this = tmp;
+            return *this;
+        }
         // nimmt die Werte eines anderen Vektors an
         //  r: Der andere Vektor
-		inline Vec2 operator=( const Vec2 &r )
-		{
-			x = r.x;
-			y = r.y;
-			return *this;
-		}
+        inline Vec2 operator=( const Vec2 &r )
+        {
+            x = r.x;
+            y = r.y;
+            return *this;
+        }
         // addiert einen anderen Vektor zu diesem hinzu
         //  r: Der andere Vektor
-		inline Vec2 operator+=( const Vec2 &r )
-		{
-			x += r.x;
-			y += r.y;
-			return *this;
-		}
+        inline Vec2 operator+=( const Vec2 &r )
+        {
+            x += r.x;
+            y += r.y;
+            return *this;
+        }
         // Zieht einen anderen Vektor von diesem ab
         //  r: Der andere Vektor
-		inline Vec2 operator-=( const Vec2 &r )
-		{
-			x -= r.x;
-			y -= r.y;
-			return *this;
-		}
+        inline Vec2 operator-=( const Vec2 &r )
+        {
+            x -= r.x;
+            y -= r.y;
+            return *this;
+        }
         // Skalliert diesen Vektor mit einem anderen Vektor
         //  r: Der andere Vektor
-		inline Vec2 operator*=( const T &r )
-		{
-			x *= r;
-			y *= r;
-			return *this;
-		}
+        inline Vec2 operator*=( const T &r )
+        {
+            x *= r;
+            y *= r;
+            return *this;
+        }
         // Verkürtzt diesen Vektor durch einen anderen Vektor
         //  r: Der andere Vektor
-		inline Vec2 operator/=( const T &r )
-		{
-			x /= r;
-			y /= r;
-			return *this;
-		}
-		// Bildet die Negation des Vektors
-		inline Vec2 operator-( ) const
-		{
-			return Vec2< T >( -x, -y );
-		}
+        inline Vec2 operator/=( const T &r )
+        {
+            x /= r;
+            y /= r;
+            return *this;
+        }
+        // Bildet die Negation des Vektors
+        inline Vec2 operator-() const
+        {
+            return Vec2< T >( -x, -y );
+        }
         // Konvertiert den Vektor in ein Vektor eines anderen Typs
-		template< typename T2 >
-		inline operator Vec2< T2 >() const
-		{
-			return Vec2< T2 >( (T2)x, (T2)y );
-		}
+        template< typename T2 >
+        inline operator Vec2< T2 >() const
+        {
+            return Vec2< T2 >( (T2)x, (T2)y );
+        }
         // Errechnet das Quadrat der Länge desVektors
-		inline T länSq() const
-		{
-			return *this * *this;
-		}
+        inline T länSq() const
+        {
+            return *this * *this;
+        }
         // Errechnet die Länge des Vektors
-		inline T län() const
-		{
-			return sqrt( länSq() );
-		}
+        inline T län() const
+        {
+            return sqrt( länSq() );
+        }
         // Errechnet das Skalarprodukt zwischen zwei Vektoren
         //  r: Der andere Vektor
-		inline T operator*( const Vec2 &r ) const
-		{
-			return x * r.x + y * r.y;
-		}
+        inline T operator*( const Vec2 &r ) const
+        {
+            return x * r.x + y * r.y;
+        }
         // Addiert zwei Vektoren
         //  r: Der andere Vektor
-		inline Vec2 operator+( const Vec2 &r ) const
-		{
-			return Vec2( *this ) += r;
-		}
+        inline Vec2 operator+( const Vec2 &r ) const
+        {
+            return Vec2( *this ) += r;
+        }
         // Subtrahiert zwei Vektoren
         //  r: Der andere Vektor
-		inline Vec2 operator-( const Vec2 &r ) const
-		{
-			return Vec2( *this ) -= r;
-		}
+        inline Vec2 operator-( const Vec2 &r ) const
+        {
+            return Vec2( *this ) -= r;
+        }
         // Multipliziert die Komponenten zweier Vektoren
         //  r: Der andere Vektor
-		inline Vec2 operator*( const T &r ) const
-		{
-			return Vec2( *this ) *= r;
-		}
+        inline Vec2 operator*( const T &r ) const
+        {
+            return Vec2( *this ) *= r;
+        }
         // Dividiert die Komponenten zweier Vektoren
         //  r: Der andere Vektor
-		inline Vec2 operator/( const T &r ) const
-		{
-			return Vec2( *this ) /= r;
-		}
+        inline Vec2 operator/( const T &r ) const
+        {
+            return Vec2( *this ) /= r;
+        }
         // Prüft, ob sich der Vektor in dem Rechteck zwischen zwei Vektoren befindet
         //  p1: Ein Vektor zur einen Ecke des Rechtecks
         //  p2: Ein Vektor zur gegenüberliegenden Ecke des Rechtecks
-		inline bool istInRegion( const Vec2 &p1, const Vec2 &p2 ) const
-		{
-			const T medianX = (T)( ( p1.x + p2.x ) / 2.0 );
-			const T medianY = (T)( ( p1.y + p2.y ) / 2.0 );
-			return abs< T >( medianX - x ) <= abs< T >( medianX - p1.x ) &&
-				   abs< T >( medianY - y ) <= abs< T >( medianY - p1.y );
-		}
+        inline bool istInRegion( const Vec2 &p1, const Vec2 &p2 ) const
+        {
+            const T medianX = (T)( ( p1.x + p2.x ) / 2.0 );
+            const T medianY = (T)( ( p1.y + p2.y ) / 2.0 );
+            return abs< T >( medianX - x ) <= abs< T >( medianX - p1.x ) &&
+                abs< T >( medianY - y ) <= abs< T >( medianY - p1.y );
+        }
         // Überprüft zwei Vektoren auf Gleichheit
         //  r: Der andere Vektor
-		inline bool operator==( const Vec2 &r ) const
-		{
-			return x == r.x && y == r.y;
-		}
+        inline bool operator==( const Vec2 &r ) const
+        {
+            return x == r.x && y == r.y;
+        }
         // Überprüft zwei Vektoren auf Ungleichheit
         //  r: Der andere Vektor
-		inline bool operator!=( const Vec2 &r ) const
-		{
-			return !( *this == r );
-		}
+        inline bool operator!=( const Vec2 &r ) const
+        {
+            return !( *this == r );
+        }
         // Errechnet den Mittelpunkt zwischen zwei Vektoren
         //  p2: Der andere Vektor
-		inline Vec2 mittelpunktMit( const Vec2 &p2 ) const
-		{
-			return Vec2( (T)( ( x + p2.x ) / 2.0 ), (T)( ( y + p2.y ) / 2.0 ) );
-		}
+        inline Vec2 mittelpunktMit( const Vec2 &p2 ) const
+        {
+            return Vec2( (T)( ( x + p2.x ) / 2.0 ), (T)( ( y + p2.y ) / 2.0 ) );
+        }
         // Rotiert den Vektor gegen den Uhrzeigersinn
         //  angle: Der Winkel in Bogenmas
-		inline Vec2 rotation( const float angle ) const
-		{
-			Vec2 result;
-			float cosine = cosf( angle );
-			float sine = sinf( angle );
-			result.x = (T)( x * cosine - y * sine );
-			result.y = (T)( x * sine + y * cosine );
-			return result;
-		}
-	};
+        inline Vec2 rotation( const float angle ) const
+        {
+            Vec2 result;
+            float cosine = cosf( angle );
+            float sine = sinf( angle );
+            result.x = (T)( x * cosine - y * sine );
+            result.y = (T)( x * sine + y * cosine );
+            return result;
+        }
+    };
 }
 
 #endif

Vec3.h

@@ -5,98 +5,95 @@
 
 namespace Framework
 {
-	template< typename T >
+    template< typename T >
     // Ein 3D Vektor
-	class Vec3
-	{
-	public:
-		T x; // X Komponente des Vektors
-		T y; // y Komponente des Vektors
-		T z; // z Komponente des Vektors
-		// Konstruktor
-		inline Vec3()
-		{
-		}
+    class Vec3
+    {
+    public:
+        T x; // X Komponente des Vektors
+        T y; // y Komponente des Vektors
+        T z; // z Komponente des Vektors
+        // Konstruktor
+        inline Vec3()
+        {}
         // Konstruktor
         //  x: Die X Komponente des neuen Vektors
         //  y: Die Y Komponente des neuen Vektors
         //  z: Die Z Komponente des neuen Vektors
-		inline Vec3( T x, T y, T z )
-			: x( x ),
-			  y( y ),
-			  z( z )
-		{
-		}
+        inline Vec3( T x, T y, T z )
+            : x( x ),
+            y( y ),
+            z( z )
+        {}
         // Konstruktor
         //  vect: Ein Vektor, dessen Werte kopiert werden sollen
-		inline Vec3( const Vec3 &vect )
-			: Vec3( vect.x, vect.y, vect.z )
-		{
-		}
-		// Skalliert den Vektor, so dass er die Länge 1 hat
-		inline Vec3 &normalize()
-		{
-			const T länge = län();
-			x /= länge;
-			y /= länge;
-			z /= länge;
-			return *this;
-		}
+        inline Vec3( const Vec3 &vect )
+            : Vec3( vect.x, vect.y, vect.z )
+        {}
+        // Skalliert den Vektor, so dass er die Länge 1 hat
+        inline Vec3 &normalize()
+        {
+            const T länge = län();
+            x /= länge;
+            y /= länge;
+            z /= länge;
+            return *this;
+        }
         // Vertaucht die Werte des Vektors mit denen eines anderen Vektor
         //  vect: Der andere Vektor
-		inline Vec3 &Swap( Vec3 &vect )
-		{
-			const Vec3 tmp = vect;
-			vect = *this;
-			*this = tmp;
-			return *this;
-		}
+        inline Vec3 &Swap( Vec3 &vect )
+        {
+            const Vec3 tmp = vect;
+            vect = *this;
+            *this = tmp;
+            return *this;
+        }
         // Kopiert die Werte eines anderen Vektors
         //  r: Der andere Vektor
-		inline Vec3 operator=( const Vec3 &r )
-		{
-			x = r.x;
-			y = r.y;
-			z = r.z;
-			return *this;
-		}
+        inline Vec3 operator=( const Vec3 &r )
+        {
+            x = r.x;
+            y = r.y;
+            z = r.z;
+            return *this;
+        }
         // Addiert einen anderen Vektor zu diesem Hinzu
         //  r: Der andere Vektor
-		inline Vec3 operator+=( const Vec3 &r )
-		{
-			x += r.x;
-			y += r.y;
-			z += r.z;
-			return *this;
-		}
+        inline Vec3 operator+=( const Vec3 &r )
+        {
+            x += r.x;
+            y += r.y;
+            z += r.z;
+            return *this;
+        }
         // Zieht einen anderen Vektor von diesem ab
         //  r: Der andere Vektor
-		inline Vec3 operator-=( const Vec3 &r )
-		{
-			x -= r.x;
-			y -= r.y;
-			z -= r.z;
-			return *this;
-		}
+        inline Vec3 operator-=( const Vec3 &r )
+        {
+            x -= r.x;
+            y -= r.y;
+            z -= r.z;
+            return *this;
+        }
         // Skalliert diesen Vektor
         //  r: Der Faktor
-		inline Vec3 operator*=( const T &r )
-		{
-			x *= r;
-			y *= r;
-			z *= r;
-			return *this;
-		}
+        inline Vec3 operator*=( const T &r )
+        {
+            x *= r;
+            y *= r;
+            z *= r;
+            return *this;
+        }
         // Skalliert diesen Vektor mit 1/Faktor
         //  r: Der Faktor
-		inline Vec3 operator/=( const T &r )
-		{
-			x /= r;
-			y /= r;
-			z /= r;
-			return *this;
-		}
-		// Errechnet das Quadrat des Abstands zwischen zewi Vektoren
+        inline Vec3 operator/=( const T &r )
+        {
+            x /= r;
+            y /= r;
+            z /= r;
+            return *this;
+        }
+        // Errechnet das Quadrat des Abstands zwischen zewi Vektoren
         //  p: Der andere Vektor
         inline T abstandSq( const Vec3 &p ) const
         {
@@ -109,69 +106,69 @@ namespace Framework
             return sqrt( abstandSq( p ) );
         }
         // Gibt einen neuen Vektor zurück, der die negation von diesem ist
-		inline Vec3 operator-( ) const
-		{
-			return{ -x, -y, -z };
-		}
-		template< typename T2 >
+        inline Vec3 operator-() const
+        {
+            return{ -x, -y, -z };
+        }
+        template< typename T2 >
         // Konvertiert den Typ des Vektors in einen anderen
-		inline operator Vec3< T2 >() const
-		{
-			return{ (T2)x, (T2)y, (T2)z };
-		}
+        inline operator Vec3< T2 >() const
+        {
+            return{ (T2)x, (T2)y, (T2)z };
+        }
         // Errechnet das Quadrat der Länge des Vektors
-		inline T länSq() const
-		{
-			return *this * *this;
-		}
+        inline T länSq() const
+        {
+            return *this * *this;
+        }
         // Errechnet due Länge des Vektors
-		inline T län() const
-		{
-			return sqrt( länSq() );
-		}
+        inline T län() const
+        {
+            return sqrt( länSq() );
+        }
         // Bildet das Skalarprodukt zwischen zwei Vektoren
         //  r: Der andere Vektor
-		inline T operator*( const Vec3 &r ) const
-		{
-			return x * r.x + y * r.y + z * r.z;
-		}
+        inline T operator*( const Vec3 &r ) const
+        {
+            return x * r.x + y * r.y + z * r.z;
+        }
         // Errechnet die Summe zweier Vektoren
         //  r: Der andere Vektor
-		inline Vec3 operator+( const Vec3 &r ) const
-		{
-			return Vec3( *this ) += r;
-		}
+        inline Vec3 operator+( const Vec3 &r ) const
+        {
+            return Vec3( *this ) += r;
+        }
         // Zieht zwei Vektoren von einander ab
         //  r: Der andere Vektor
-		inline Vec3 operator-( const Vec3 &r ) const
-		{
-			return Vec3( *this ) -= r;
-		}
+        inline Vec3 operator-( const Vec3 &r ) const
+        {
+            return Vec3( *this ) -= r;
+        }
         // Skalliert den Vektor ohne ihn zu verändern
         //  r: Der Faktor
-		inline Vec3 operator*( const T &r ) const
-		{
-			return Vec3( *this ) *= r;
-		}
+        inline Vec3 operator*( const T &r ) const
+        {
+            return Vec3( *this ) *= r;
+        }
         // Skalliert den Vektor mit 1/Faktor ohne ihn zu Verändern
         //  r: Der Faktor
-		inline Vec3 operator/( const T &r ) const
-		{
-			return Vec3( *this ) /= r;
-		}
+        inline Vec3 operator/( const T &r ) const
+        {
+            return Vec3( *this ) /= r;
+        }
         // Überprüft zwei Vektoren auf Gleichheit
         //  r: Der andere Vektor
-		inline bool operator==( const Vec3 &r ) const
-		{
-			return x == r.x && y == r.y && z == r.z;
-		}
+        inline bool operator==( const Vec3 &r ) const
+        {
+            return x == r.x && y == r.y && z == r.z;
+        }
         // Überprüft zwei Vektoren auf Ungleichheit
         //  r: Der andere Vektor
-		inline bool operator!=( const Vec3 &r ) const
-		{
-			return !( *this == r );
-		}
-	};
+        inline bool operator!=( const Vec3 &r ) const
+        {
+            return !( *this == r );
+        }
+    };
 }
 
 #endif

Welt3D.cpp

@@ -142,7 +142,7 @@ void Welt3D::render( Render3D *zRObj )
     int index = 0;
     for( Zeichnung3D **i = members; index < arraySize; i++, index++ )
     {
-        if( *i && zRObj->isInFrustrum( (*i)->getPos(), (*i)->getRadius() ) )
+        if( *i && zRObj->isInFrustrum( ( *i )->getPos(), ( *i )->getRadius() ) )
             ( *i )->render( zRObj );
     }
     memset( used, 0, arraySizeAlpha * sizeof( bool ) );
@@ -176,8 +176,7 @@ void Welt3D::render( Render3D *zRObj )
             alphaVS[ ind ]->render( zRObj );
             used[ ind ] = 1;
         }
-    }
-    while( ind >= 0 );
+    } while( ind >= 0 );
 }
 
 // Erhöht den Reference Counting Zähler.

Zeichnung.h

@@ -5,23 +5,23 @@
 
 namespace Framework
 {
-	struct VScrollData; // Scroll.h
-	struct HScrollData; // Scroll.h
-	struct MausEreignis; // MausEreignis.h
-	struct TastaturEreignis; // TastaturEreignis.h
-	class Bild; // Bild.h
-	class Zeichnung; // Aus dieser Datei
-	class ZeichnungArray; // Aus dieser Datei
-	class ToolTip; // ToopTip.h
-	class Bildschirm; // Bildschirm.h
+    struct VScrollData; // Scroll.h
+    struct HScrollData; // Scroll.h
+    struct MausEreignis; // MausEreignis.h
+    struct TastaturEreignis; // TastaturEreignis.h
+    class Bild; // Bild.h
+    class Zeichnung; // Aus dieser Datei
+    class ZeichnungArray; // Aus dieser Datei
+    class ToolTip; // ToopTip.h
+    class Bildschirm; // Bildschirm.h
     class LRahmen; // Rahmen.h
     class AlphaFeld; // AlphaFeld.h
     class VScrollBar; // Scroll.h
     class HScrollBar; // Scroll.h
 
     // Eine Zeichnung für das 2D GUI Framework
-	class Zeichnung
-	{
+    class Zeichnung
+    {
     public:
         class Style
         {
@@ -30,139 +30,139 @@ namespace Framework
             const static __int64 Erlaubt = 0x00002; // Wenn dieser Style gesetzt ist, kann der Benutzer mit der Zeichnung interagieren
             const static __int64 Fokus = 0x00004; // Wenn dieser Style gesetzt ist, werden die Tastatur Ereignisse von der Zeichnung verarbeitet
         };
-	protected:
-		Punkt pos;
-		Punkt gr;
-		void *makParam;
-		void *takParam;
-		bool( *Mak )( void *, void *, MausEreignis );
-		bool( *Tak )( void *, void *, TastaturEreignis );
+    protected:
+        Punkt pos;
+        Punkt gr;
+        void *makParam;
+        void *takParam;
+        bool( *Mak )( void *, void *, MausEreignis );
+        bool( *Tak )( void *, void *, TastaturEreignis );
         void *nmakParam;
         void *ntakParam;
         bool( *nMak )( void *, void *, MausEreignis );
         bool( *nTak )( void *, void *, TastaturEreignis );
-		bool mausIn;
-		CRITICAL_SECTION cs;
-		ToolTip *toolTip;
+        bool mausIn;
+        CRITICAL_SECTION cs;
+        ToolTip *toolTip;
         __int64 style;
-		bool rend;
+        bool rend;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) Zeichnung();
-		// Destruktor 
-		__declspec( dllexport ) ~Zeichnung();
-		// Legt fest, ob sich die Zeichnung seit des letzten Bildes verändert hat und neu gezeichnet werden muss
-		__declspec( dllexport ) void setRender();
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) Zeichnung();
+        // Destruktor 
+        __declspec( dllexport ) ~Zeichnung();
+        // Legt fest, ob sich die Zeichnung seit des letzten Bildes verändert hat und neu gezeichnet werden muss
+        __declspec( dllexport ) void setRender();
         // Setzt den Text, der erscheint, wenn der Benutzer für längere Zeit mit der Maus in der Zeichnung verweilt
         //  txt: Der Text, der angezeigt werden soll
         //  zScreen: Ein Zeiger auf das Verwendete Bildschirm Objekt ohne erhöhten Reference Counter
-		__declspec( dllexport ) void setToolTipText( const char *txt, Bildschirm *zScreen );
+        __declspec( dllexport ) void setToolTipText( const char *txt, Bildschirm *zScreen );
         // Dies ist notwendig, falls mehrere Threads gleichzeitig die Zeichnung benutzen.
         // Wenn lockZeichnung() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlockZeichnung() aufgerufen hat.
-		__declspec( dllexport ) void lockZeichnung();
+        __declspec( dllexport ) void lockZeichnung();
         // Dies ist notwendig, falls mehrere Threads gleichzeitig die Zeichnung benutzen.
         // Wenn lockZeichnung() von zwei threads aufgerufen wird, wartet der letzte so lange, bis der erste unlockZeichnung() aufgerufen hat.
-		__declspec( dllexport ) void unlockZeichnung();
+        __declspec( dllexport ) void unlockZeichnung();
         // setzt den Parameter, der bei einem Maus Ereignis an die Rückruffunktion übergeben wird
         //  p: Der Parameter
-		__declspec( dllexport ) void setMausEreignisParameter( void *p );
+        __declspec( dllexport ) void setMausEreignisParameter( void *p );
         // Setzt den Parameter, der bei einem Tastatur Ereignis an die Rückruffunktion übergeben wird
         //  p: Der Parameter
-		__declspec( dllexport ) void setTastaturEreignisParameter( void *p );
+        __declspec( dllexport ) void setTastaturEreignisParameter( void *p );
         // Setzt die Rückruffunktion, die bei einem Maus Ereignis aufgerufen werden soll.
         // Wenn die Rückruffunktion 0 zurückgiebt, oder nicht gesetzt wurde, wird ein Maus Ereignis von der Zeichnung nicht weiter beachtet
         // Es kann die Standartfunktion __ret1ME verwendet werden, die in MausEreignis.h definiert ist und immer 1 zurückgibt
-		//  ak: Ein Zeiger auf die Rückruffunktion
+        //  ak: Ein Zeiger auf die Rückruffunktion
         __declspec( dllexport ) void setMausEreignis( bool( *ak )( void *, void *, MausEreignis ) );
         // Setzt die Rückruffunktion, die bei einem Tastatur Ereignis aufgerufen werdne soll.
         // Wenn die Rückruffunktion 0 zurückgiebt, oder nicht gesetzt wurde, wird ein Tastatur Ereignis von der Zeichnung nicht weiter beachtet
         // Es kann die Standartfunktion __ret1TE verwendet werden, die in TastaturEreignis.h definiert ist und immer 1 zurückgibt
         // Weitere Standartfunktionen sind _nurNummernTE und _nurHexTE ebenfals aus TastaturEreignis.h
         //  ak: Ein Zeiger auf die Rückruffunktion
-		__declspec( dllexport ) void setTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) );
+        __declspec( dllexport ) void setTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) );
         // setzt den Parameter, der bei einem Maus Ereignis an die Rückruffunktion übergeben wird, die aufgerufen wird, fals das Ereignis von der Zeichnung verarbeitet wurde
         //  p: Der Parameter
-		__declspec( dllexport ) void setNMausEreignisParameter( void *p );
+        __declspec( dllexport ) void setNMausEreignisParameter( void *p );
         // Setzt den Parameter, der bei einem Tastatur Ereignis an die Rückruffunktion übergeben wird, die aufgerufen wird, fals das Ereignis von der Zeichnung verarbeitet wurde
         //  p: Der Parameter
-		__declspec( dllexport ) void setNTastaturEreignisParameter( void *p );
+        __declspec( dllexport ) void setNTastaturEreignisParameter( void *p );
         // Setzt die Rückruffunktion, die bei einem Maus Ereignis aufgerufen werden soll, nachdem das Ereignis bereits von der Zeichnung verarbeitet wurde
         // Wenn die Rückruffunktion 1 zurückgiebt, oder nicht gesetzt wurde, wird das Maus Ereignis von keiner weiteren Zeichnung verarbeitet, die zum Beispiel hinter dieser Zeichnung liegen
         // Es kann die Standartfunktion __ret1ME verwendet werden, die in MausEreignis.h definiert ist und immer 1 zurückgibt
         //  ak: Ein Zeiger auf die Rückruffunktion
-		__declspec( dllexport ) void setNMausEreignis( bool( *ak )( void *, void *, MausEreignis ) );
+        __declspec( dllexport ) void setNMausEreignis( bool( *ak )( void *, void *, MausEreignis ) );
         // Setzt die Rückruffunktion, die bei einem Tastatur Ereignis aufgerufen werdne soll, nachdem das Ereignis bereits von der Zeichnung verarbeitet wurde
         // Wenn die Rückruffunktion 1 zurückgiebt, oder nicht gesetzt wurde, wird das Tastatur Ereignis von keiner weiteren Zeichnung verarbeitet
         // Es kann die Standartfunktion __ret1TE verwendet werden, die in TastaturEreignis.h definiert ist und immer 1 zurückgibt
         // Weitere Standartfunktionen sind _nurNummernTE und _nurHexTE ebenfals aus TastaturEreignis.h
         //  ak: Ein Zeiger auf die Rückruffunktion
-		__declspec( dllexport ) void setNTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) );
+        __declspec( dllexport ) void setNTastaturEreignis( bool( *ak )( void *, void *, TastaturEreignis ) );
         // Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
         //  me: Das Ereignis
-		__declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me );
+        __declspec( dllexport ) virtual void doMausEreignis( MausEreignis &me );
         // Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
         //  te: Das Ereignis
-		__declspec( dllexport ) virtual void doTastaturEreignis( TastaturEreignis &te );
+        __declspec( dllexport ) virtual void doTastaturEreignis( TastaturEreignis &te );
         // Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion vergangen ist
         //  tickVal: Die vergangene Zeit in Sekunden
-		__declspec( dllexport ) virtual bool tick( double tickval );
+        __declspec( dllexport ) virtual bool tick( double tickval );
         // Setzt die Position der Zeichnung
         //  pos: Die Position in Pixeln
-		__declspec( dllexport ) void setPosition( const Punkt &pos );
+        __declspec( dllexport ) void setPosition( const Punkt &pos );
         // Setzt die X Position der Zeichnung
         //  xPos: Die Position in Pixeln
-		__declspec( dllexport ) void setX( int xPos );
+        __declspec( dllexport ) void setX( int xPos );
         // Setzt die Y Position der Zeichnung
         //  yPos: Die Position in Pixeln
-		__declspec( dllexport ) void setY( int yPos );
+        __declspec( dllexport ) void setY( int yPos );
         // Setzt die Größe der Zeichnung
         //  gr: Ein Punkt mit x als Breite und y als Höhe in Pixeln
         __declspec( dllexport ) void setGröße( const Punkt &gr );
         // Setzt die Position der Zeichnung
         //  x: Die X Position in Pixeln
         //  y: Die Y Position in Pixeln
-		__declspec( dllexport ) void setPosition( int x, int y );
+        __declspec( dllexport ) void setPosition( int x, int y );
         // Setzt die Größe der Zeichnung
         //  br: Die Breite in Pixeln
         //  hö: Die Höhe in Pixeln
-		__declspec( dllexport ) void setGröße( int br, int hö );
+        __declspec( dllexport ) void setGröße( int br, int hö );
         // Setzt den Style der Zeichnung
         //  style: Der neue Style bestehend aus den Flags aus der zugehörigen Style Klasse
-		__declspec( dllexport ) void setStyle( __int64 style );
+        __declspec( dllexport ) void setStyle( __int64 style );
         // Setzt den Style der Zeichnung
         //  style: Alle Style Flags, die verändert werden sollen
         //  add_löschen: 1, falls der Style hinzugefügt werden soll. 0, falls der Style entfernt weden soll
         __declspec( dllexport ) void setStyle( __int64 style, bool add_löschen );
         // Fügt Style Flags hinzu
         //  style: Der Style, der hinzugefügt werden soll
-		__declspec( dllexport ) void addStyle( __int64 style );
+        __declspec( dllexport ) void addStyle( __int64 style );
         // Entfernt Style Flags
         //  style: Der Style, der entfernt werden soll
-		__declspec( dllexport ) void löscheStyle( __int64 style );
+        __declspec( dllexport ) void löscheStyle( __int64 style );
         // Zeichnet die Zeihnung in ein bestimmtes Bild
         //  zRObj: Das Bild, in das gezeichnet werden soll
-		__declspec( dllexport ) virtual void render( Bild &zRObj );
-		// Gibt zurück, ob eine Rückruffunktion für Maus Ereignisse gesetzt wurde
-		__declspec( dllexport ) bool hatMausEreignis() const;
+        __declspec( dllexport ) virtual void render( Bild &zRObj );
+        // Gibt zurück, ob eine Rückruffunktion für Maus Ereignisse gesetzt wurde
+        __declspec( dllexport ) bool hatMausEreignis() const;
         // Gibt zurück, ob eine Rückruffunktion für Tastatur Ereignisse gesetzt wurde
-		__declspec( dllexport ) bool hatTastaturEreignis() const;
+        __declspec( dllexport ) bool hatTastaturEreignis() const;
         // Gibt die Position der Zeichnung in Pixeln zurück
-		__declspec( dllexport ) const Punkt &getPosition() const;
+        __declspec( dllexport ) const Punkt &getPosition() const;
         // Gibt die Größe der Zeichnung in Pixeln zurück. x für Breite und y für Höhe
-		__declspec( dllexport ) const Punkt &getGröße() const;
+        __declspec( dllexport ) const Punkt &getGröße() const;
         // Gibt die Breite der Zeichnung in Pixeln zurück
-		__declspec( dllexport ) int getBreite() const;
+        __declspec( dllexport ) int getBreite() const;
         // Gibt die Höhe der Zeichnung in Pixeln zurück
-		__declspec( dllexport ) int getHöhe() const;
+        __declspec( dllexport ) int getHöhe() const;
         // Gibt die X Position der Zeichnung in Pixeln zurück
-		__declspec( dllexport ) int getX() const;
+        __declspec( dllexport ) int getX() const;
         // Gibt die Y Position der Zeichnung in Pixeln zurück
-		__declspec( dllexport ) int getY() const;
+        __declspec( dllexport ) int getY() const;
         // Gibt einen Zeiger auf das Tooltip Objekt zurück, walls es verwendet wird
-		__declspec( dllexport ) ToolTip *getToolTip() const;
+        __declspec( dllexport ) ToolTip *getToolTip() const;
         // Gibt einen Zeiger auf das Tooltip Objekt ohne erhöhten Reference Counter zurück, walls es verwendet wird
-		__declspec( dllexport ) ToolTip *zToolTip() const;
+        __declspec( dllexport ) ToolTip *zToolTip() const;
         // Gibt zurück, ob bestimmte Styles gesetzt wurden
         //  style: Die Styles, die überprüft werden sollen
         //  return: 1, falls alle Styles in style gesetzt wurden
@@ -173,23 +173,23 @@ namespace Framework
         __declspec( dllexport ) inline bool hatStyleNicht( __int64 style ) const;
         // Kopiert die Komplette Zeichnung, so dass sie ohne Effekt auf das Original verändert werden kann
         __declspec( dllexport ) virtual Zeichnung *dublizieren() const;
-	};
+    };
 
     // Ein Array von Zeichnungen, der von den Bildschirm Klassen verwendet wird, um die Objekte der GUI zu speichern
-	class ZeichnungArray// Array von Zeichnungen
-	{
-	private:
+    class ZeichnungArray// Array von Zeichnungen
+    {
+    private:
         Zeichnung *This;
         ZeichnungArray *next;
-		int index;
+        int index;
 
-	public:
-		// Konstruktor 
-		__declspec( dllexport ) ZeichnungArray();
-		// Destruktor 
-		__declspec( dllexport ) ~ZeichnungArray();
-		// Fügt dem Array eine Zeichnung hinzu. Es kann jede Zeichnung nur einmal hinzugefügt werden
-		//  obj: Die neue Zeichnung
+    public:
+        // Konstruktor 
+        __declspec( dllexport ) ZeichnungArray();
+        // Destruktor 
+        __declspec( dllexport ) ~ZeichnungArray();
+        // Fügt dem Array eine Zeichnung hinzu. Es kann jede Zeichnung nur einmal hinzugefügt werden
+        //  obj: Die neue Zeichnung
         //  return: 1, falls die Zeichnung erfolgreich hinzugefügt wurde.
         __declspec( dllexport ) bool addZeichnung( Zeichnung *obj );
         // Entfernt eine Zeichnung
@@ -199,33 +199,33 @@ namespace Framework
         // Entfernt eine Zeichnung
         //  i: Der Index der Zeichnung, die entfernt werden soll
         //  return 1, falls die Zeichnung erfolgreich entfernt wurde
-		__declspec( dllexport ) bool removeZeichnung( int i );
+        __declspec( dllexport ) bool removeZeichnung( int i );
         // Setzt den Zeiger auf das Nächste Array Element auf 0
-		__declspec( dllexport ) void setNext0();
+        __declspec( dllexport ) void setNext0();
         // Aktualisiert die Array indizes.
         //  i: Der Index des ersten Elements
-		__declspec( dllexport ) void updateIndex( int i );
-		// Gibt den Zeiger auf das nchste Array Element zurück
-		__declspec( dllexport ) ZeichnungArray *getNext() const;
+        __declspec( dllexport ) void updateIndex( int i );
+        // Gibt den Zeiger auf das nchste Array Element zurück
+        __declspec( dllexport ) ZeichnungArray *getNext() const;
         // Gibt eine Zeichnung zurück
         //  i: Der Index der Zeichnung
-		__declspec( dllexport ) Zeichnung *getZeichnung( int i ) const;
+        __declspec( dllexport ) Zeichnung *getZeichnung( int i ) const;
         // Gibt die Zeichnung dieses Array Elements zurück
-		__declspec( dllexport ) Zeichnung *getZeichnung() const;
+        __declspec( dllexport ) Zeichnung *getZeichnung() const;
         // Gibt den Index dieses Array Elements zurück
-		__declspec( dllexport ) int getIndex() const;
+        __declspec( dllexport ) int getIndex() const;
         // Sendet an alle Zeichnungen ein Maus Ereignis. Die zuletzt hinzugefügte Zeichnung bekommt das Ereignis als Erste
         //  me: Das Ereignis
-		__declspec( dllexport ) void sendMausAll( MausEreignis &me ) const;
+        __declspec( dllexport ) void sendMausAll( MausEreignis &me ) const;
         // Sendet an alle Zeichnungen ein Tastatur Ereignis. Die zuletzt hinzugefügte Zeichnung bekommt das Ereignis als Erste
         //  te: Das Ereignis
-		__declspec( dllexport ) void sendTastaturAll( TastaturEreignis &te ) const;
+        __declspec( dllexport ) void sendTastaturAll( TastaturEreignis &te ) const;
         // Zeichnet alle Zeichnungen. Die zuletzt hinzugefügte Zeichnung ist oben
         //  zRObj: Das Bild, in das alle Zeichnungen gezeichnet werden sollen
-		__declspec( dllexport ) void render( Bild &zRObj );
+        __declspec( dllexport ) void render( Bild &zRObj );
         // Verarbeitet bei allen Zeichnungen die Vergangene Zeit seit dem letzten Aufruf der Funktion
         //  tickVal: Die vergangene Zeit in Sekunden
-		__declspec( dllexport ) bool tick( double tickval );
+        __declspec( dllexport ) bool tick( double tickval );
     };
 
     // Eine Zeichnung für das 2D GUI Framework mit Hintergrund, Rahmen und Scroll Balken

Zeichnung3D.h

@@ -76,7 +76,7 @@ namespace Framework
         __declspec( dllexport ) virtual bool tick( double tickval );
         // Zeichnet das Objekt
         //  zRObj: Ein Zeiger auf das Objekt, das zum Zeichnen verwendet werden soll (ohne erhöhten Reference Counter)
-		__declspec( dllexport ) virtual void render( Render3D *zRObj );
+        __declspec( dllexport ) virtual void render( Render3D *zRObj );
         // Gibt zurück, ob das Objekt teilweise oder ganz transparente stellen enthält
         __declspec( dllexport ) bool hatAlpha() const;
         // Gibt den radius einer Kugel zurück, die das gesammte Model umschließt

Zeit.cpp

@@ -19,50 +19,50 @@
 
 struct timeval
 {
-	long tv_sec;        // Sekunden seit dem 1.1.1970
-	long tv_usec;       // und Mikrosekunden
+    long tv_sec;        // Sekunden seit dem 1.1.1970
+    long tv_usec;       // und Mikrosekunden
 };
 
 struct timezone
 {
-	int tz_minuteswest; // minutes W of Greenwich
-	int tz_dsttime;     // type of dst correction
+    int tz_minuteswest; // minutes W of Greenwich
+    int tz_dsttime;     // type of dst correction
 };
 
 int gettimeofday( struct timeval *tv, struct timezone *tz )
 {
-	FILETIME ft;
-	unsigned __int64 tmpres = 0;
-	static int tzflag;
+    FILETIME ft;
+    unsigned __int64 tmpres = 0;
+    static int tzflag;
 
-	if( NULL != tv )
-	{
-		GetSystemTimeAsFileTime( &ft );
+    if( NULL != tv )
+    {
+        GetSystemTimeAsFileTime( &ft );
 
-		tmpres |= ft.dwHighDateTime;
-		tmpres <<= 32;
-		tmpres |= ft.dwLowDateTime;
+        tmpres |= ft.dwHighDateTime;
+        tmpres <<= 32;
+        tmpres |= ft.dwLowDateTime;
 
-		//converting file time to unix epoch
-		tmpres -= DELTA_EPOCH_IN_MICROSECS;
-		tmpres /= 10;  //convert into microseconds
-		tv->tv_sec = (long)( tmpres / 1000000UL );
-		tv->tv_usec = (long)( tmpres % 1000000UL );
-	}
+        //converting file time to unix epoch
+        tmpres -= DELTA_EPOCH_IN_MICROSECS;
+        tmpres /= 10;  //convert into microseconds
+        tv->tv_sec = (long)( tmpres / 1000000UL );
+        tv->tv_usec = (long)( tmpres % 1000000UL );
+    }
 
-	if( NULL != tz )
-	{
-		if( !tzflag )
-		{
-			_tzset();
-			++tzflag;
-		}
-		_get_timezone( (long*)&( tz->tz_minuteswest ) );
-		tz->tz_minuteswest /= 60;
-		_get_daylight( &( tz->tz_dsttime ) );
-	}
+    if( NULL != tz )
+    {
+        if( !tzflag )
+        {
+            _tzset();
+            ++tzflag;
+        }
+        _get_timezone( ( long* )&( tz->tz_minuteswest ) );
+        tz->tz_minuteswest /= 60;
+        _get_daylight( &( tz->tz_dsttime ) );
+    }
 
-	return 0;
+    return 0;
 }
 
 #endif
@@ -74,593 +74,592 @@ using namespace Framework;
 // Privat 
 int Uhrzeit::update() // berechnet die neue Zeit
 {
-	int ret = 0;
-	while( sekunde >= 60 )
-	{
-		sekunde -= 60;
-		++minute;
-	}
-	while( minute >= 60 )
-	{
-		minute -= 60;
-		++stunde;
-	}
-	while( stunde >= 24 )
-	{
-		stunde -= 24;
-		++ret;
-	}
-	while( sekunde < 0 )
-	{
-		sekunde += 60;
-		--minute;
-	}
-	while( minute < 0 )
-	{
-		minute += 60;
-		--stunde;
-	}
-	while( stunde < 0 )
-	{
-		stunde += 24;
-		--ret;
-	}
-	return ret;
+    int ret = 0;
+    while( sekunde >= 60 )
+    {
+        sekunde -= 60;
+        ++minute;
+    }
+    while( minute >= 60 )
+    {
+        minute -= 60;
+        ++stunde;
+    }
+    while( stunde >= 24 )
+    {
+        stunde -= 24;
+        ++ret;
+    }
+    while( sekunde < 0 )
+    {
+        sekunde += 60;
+        --minute;
+    }
+    while( minute < 0 )
+    {
+        minute += 60;
+        --stunde;
+    }
+    while( stunde < 0 )
+    {
+        stunde += 24;
+        --ret;
+    }
+    return ret;
 }
 
 Uhrzeit::Uhrzeit()
-	: stunde( 0 ),
-	  minute( 0 ),
-	  sekunde( 0 ),
-	  ref( 1 )
-{
-}
+    : stunde( 0 ),
+    minute( 0 ),
+    sekunde( 0 ),
+    ref( 1 )
+{}
 
 int Uhrzeit::setUhrzeit( Uhrzeit *zeit ) // setzt die Uhrzeit
 {
-	stunde = zeit->getStunde();
-	minute = zeit->getMinute();
-	sekunde = zeit->getSekunde();
-	zeit->release();
-	return update();
+    stunde = zeit->getStunde();
+    minute = zeit->getMinute();
+    sekunde = zeit->getSekunde();
+    zeit->release();
+    return update();
 }
 
 int Uhrzeit::setUhrzeit( int stunde, int minute, int sekunde )
 {
-	this->stunde = stunde;
-	this->minute = minute;
-	this->sekunde = sekunde;
-	return update();
+    this->stunde = stunde;
+    this->minute = minute;
+    this->sekunde = sekunde;
+    return update();
 }
 
 int Uhrzeit::setUhrzeit( const char *format, const char *zeit ) // format Beispiele: "H:i:s", "H-i-s" (H=stunde,i=minute,s=sekunde)
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			stunde = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			minute = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sekunde = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            stunde = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            minute = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sekunde = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return update();
 }
 
 int Uhrzeit::setUhrzeit( const char *format, Text *zeit )
 {
-	int ret = setUhrzeit( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    int ret = setUhrzeit( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 int Uhrzeit::setStunde( int stunde ) // setzt die Stunde
 {
-	this->stunde = stunde;
-	return update();
+    this->stunde = stunde;
+    return update();
 }
 
 int Uhrzeit::setMinute( int minute ) // setzt die Minute
 {
-	this->minute = minute;
-	return update();
+    this->minute = minute;
+    return update();
 }
 
 int Uhrzeit::setSekunde( int sekunde ) // setzt die Sekunde
 {
-	this->sekunde = sekunde;
-	return update();
+    this->sekunde = sekunde;
+    return update();
 }
 
 int Uhrzeit::plusUhrzeit( Uhrzeit *zeit ) // addiert die zeiten
 {
-	stunde += zeit->getStunde();
-	minute += zeit->getMinute();
-	sekunde += zeit->getSekunde();
-	return update();
+    stunde += zeit->getStunde();
+    minute += zeit->getMinute();
+    sekunde += zeit->getSekunde();
+    return update();
 }
 
 int Uhrzeit::plusUhrzeit( int stunde, int minute, int sekunde )
 {
-	this->stunde += stunde;
-	this->minute += minute;
-	this->sekunde += sekunde;
-	return update();
+    this->stunde += stunde;
+    this->minute += minute;
+    this->sekunde += sekunde;
+    return update();
 }
 
 int Uhrzeit::plusUhrzeit( const char *format, const char *zeit )
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			stunde += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			minute += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sekunde += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            stunde += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            minute += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sekunde += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return update();
 }
 
 int Uhrzeit::plusUhrzeit( const char *format, Text *zeit )
 {
-	int ret = plusUhrzeit( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    int ret = plusUhrzeit( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 int Uhrzeit::plusStunde( int stunde ) // addiert stunde Stunden
 {
-	this->stunde += stunde;
-	return update();
+    this->stunde += stunde;
+    return update();
 }
 
 int Uhrzeit::plusMinute( int minute ) // addiert minute Minuten
 {
-	this->minute += minute;
-	return update();
+    this->minute += minute;
+    return update();
 }
 
 int Uhrzeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
 {
-	this->sekunde += sekunde;
-	return update();
+    this->sekunde += sekunde;
+    return update();
 }
 
 int Uhrzeit::minusUhrzeit( Uhrzeit *zeit ) // subtrahiert die zeiten
 {
-	stunde -= zeit->getStunde();
-	minute -= zeit->getMinute();
-	sekunde -= zeit->getSekunde();
-	zeit->release();
-	return update();
+    stunde -= zeit->getStunde();
+    minute -= zeit->getMinute();
+    sekunde -= zeit->getSekunde();
+    zeit->release();
+    return update();
 }
 
 int Uhrzeit::minusUhrzeit( int stunde, int minute, int sekunde )
 {
-	this->stunde -= stunde;
-	this->minute -= minute;
-	this->sekunde -= sekunde;
-	return update();
+    this->stunde -= stunde;
+    this->minute -= minute;
+    this->sekunde -= sekunde;
+    return update();
 }
 
 int Uhrzeit::minusUhrzeit( const char *format, const char *zeit )
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			stunde -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			minute -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sekunde -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            stunde -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            minute -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sekunde -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return update();
 }
 
 int Uhrzeit::minusUhrzeit( const char *format, Text *zeit )
 {
-	int ret = plusUhrzeit( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    int ret = plusUhrzeit( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 int Uhrzeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
 {
-	this->stunde -= stunde;
-	return update();
+    this->stunde -= stunde;
+    return update();
 }
 
 int Uhrzeit::minusMinute( int minute ) // subtrahiert minute Minuten
 {
-	this->minute -= minute;
-	return update();
+    this->minute -= minute;
+    return update();
 }
 
 int Uhrzeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
 {
-	this->sekunde -= sekunde;
-	return update();
+    this->sekunde -= sekunde;
+    return update();
 }
 
 // constant 
 int Uhrzeit::getStunde() const // gibt die Stunde zurück
 {
-	return stunde;
+    return stunde;
 }
 
 int Uhrzeit::getMinute() const // gibt die Minute zurück
 {
-	return minute;
+    return minute;
 }
 
 int Uhrzeit::getSekunde() const // gibt die Sekunde zurück
 {
-	return sekunde;
+    return sekunde;
 }
 
 Text *Uhrzeit::getUhrzeit( const char *format ) const // gibt die Uhrzeit als Text formatiert zurück
 {
-	Text *ret = new Text( "" );
-	int flän = textLänge( format );
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			ret->anhängen( stunde );
-			break;
-		case 'i':
-			ret->anhängen( minute );
-			break;
-		case 's':
-			ret->anhängen( sekunde );
-			break;
-		default:
-			ret->anhängen( f, 1 );
-			break;
-		}
-	}
-	return ret;
+    Text *ret = new Text( "" );
+    int flän = textLänge( format );
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            ret->anhängen( stunde );
+            break;
+        case 'i':
+            ret->anhängen( minute );
+            break;
+        case 's':
+            ret->anhängen( sekunde );
+            break;
+        default:
+            ret->anhängen( f, 1 );
+            break;
+        }
+    }
+    return ret;
 }
 
 bool Uhrzeit::istGleich( Uhrzeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
 {
-	bool ret = stunde == zeit->getStunde() &&
-		minute == zeit->getMinute() &&
-		sekunde == zeit->getSekunde();
-	zeit->release();
-	return ret;
+    bool ret = stunde == zeit->getStunde() &&
+        minute == zeit->getMinute() &&
+        sekunde == zeit->getSekunde();
+    zeit->release();
+    return ret;
 }
 
 bool Uhrzeit::istGleich( const char *format, const char *zeit ) const
 {
-	int st = stunde, min = minute, sek = sekunde;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			st = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			min = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sek = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	bool ret = stunde == st &&
-		minute == min &&
-		sekunde == sek;
-	return ret;
+    int st = stunde, min = minute, sek = sekunde;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            st = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            min = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sek = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    bool ret = stunde == st &&
+        minute == min &&
+        sekunde == sek;
+    return ret;
 }
 
 bool Uhrzeit::istGleich( const char *format, Text *zeit ) const
 {
-	bool ret = istGleich( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istGleich( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 bool Uhrzeit::istGleich( int stunde, int minute, int sekunde ) const
 {
-	return this->stunde == stunde &&
-		this->minute == minute &&
-		this->sekunde == sekunde;
+    return this->stunde == stunde &&
+        this->minute == minute &&
+        this->sekunde == sekunde;
 }
 
 bool Uhrzeit::stundeGleich( int stunde ) const // prüft, ob die Stunde gleich stunde ist
 {
-	return this->stunde == stunde;
+    return this->stunde == stunde;
 }
 
 bool Uhrzeit::minuteGleich( int minute ) const // prüft, ob die Minute gleich minute ist
 {
-	return this->minute == minute;
+    return this->minute == minute;
 }
 
 bool Uhrzeit::sekundeGleich( int sekunde ) const // prüft, ob die Sekunde gleich sekunde ist
 {
-	return this->sekunde == sekunde;
+    return this->sekunde == sekunde;
 }
 
 bool Uhrzeit::istKleiner( Uhrzeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
 {
-	bool ret = istKleiner( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
-	zeit->release();
-	return ret;
+    bool ret = istKleiner( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
+    zeit->release();
+    return ret;
 }
 
 bool Uhrzeit::istKleiner( int stunde, int minute, int sekunde ) const
 {
-	if( this->stunde < stunde )
-		return 1;
-	else if( this->stunde == stunde )
-	{
-		if( this->minute < minute )
-			return 1;
-		else if( this->minute == minute )
-		{
-			if( this->sekunde < sekunde )
-				return 1;
-			else if( this->sekunde == sekunde )
-				return 0;
-			else
-				return 0;
-		}
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( this->stunde < stunde )
+        return 1;
+    else if( this->stunde == stunde )
+    {
+        if( this->minute < minute )
+            return 1;
+        else if( this->minute == minute )
+        {
+            if( this->sekunde < sekunde )
+                return 1;
+            else if( this->sekunde == sekunde )
+                return 0;
+            else
+                return 0;
+        }
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Uhrzeit::istKleiner( const char *format, const char *zeit ) const
 {
-	int st = stunde, min = minute, sek = sekunde;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			st = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			min = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sek = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return istKleiner( st, min, sek );
+    int st = stunde, min = minute, sek = sekunde;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            st = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            min = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sek = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return istKleiner( st, min, sek );
 }
 
 bool Uhrzeit::istKleiner( const char *format, Text *zeit ) const
 {
-	bool ret = istKleiner( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istKleiner( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 bool Uhrzeit::istGrößer( Uhrzeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
 {
-	bool ret = istGrößer( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
-	zeit->release();
-	return ret;
+    bool ret = istGrößer( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
+    zeit->release();
+    return ret;
 }
 
 bool Uhrzeit::istGrößer( int stunde, int minute, int sekunde ) const
 {
-	if( this->stunde > stunde )
-		return 1;
-	else if( this->stunde == stunde )
-	{
-		if( this->minute > minute )
-			return 1;
-		else if( this->minute == minute )
-		{
-			if( this->sekunde > sekunde )
-				return 1;
-			else if( this->sekunde == sekunde )
-				return 0;
-			else
-				return 0;
-		}
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( this->stunde > stunde )
+        return 1;
+    else if( this->stunde == stunde )
+    {
+        if( this->minute > minute )
+            return 1;
+        else if( this->minute == minute )
+        {
+            if( this->sekunde > sekunde )
+                return 1;
+            else if( this->sekunde == sekunde )
+                return 0;
+            else
+                return 0;
+        }
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Uhrzeit::istGrößer( const char *format, const char *zeit ) const
 {
-	int st = stunde, min = minute, sek = sekunde;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'h':
-			st = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			min = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			sek = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return istGrößer( st, min, sek );
+    int st = stunde, min = minute, sek = sekunde;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'h':
+            st = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            min = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            sek = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return istGrößer( st, min, sek );
 }
 
 bool Uhrzeit::istGrößer( const char *format, Text *zeit ) const
 {
-	bool ret = istGrößer( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istGrößer( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 // Reference Counting 
 Uhrzeit *Uhrzeit::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Uhrzeit *Uhrzeit::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der Datum Klasse aus Zeit.h
 // Privat 
 void Datum::update() // berechnet die neue Zeit
 {
-	while( monat > 12 )
-	{
-		monat -= 12;
-		++jahr;
-	}
-	while( monat <= 0 )
-	{
-		monat += 12;
-		--jahr;
-	}
-	if( istSchaltjahr( jahr ) )
-		maxTage[ 1 ] = 29;
-	else
-		maxTage[ 1 ] = 28;
-	while( tag > maxTage[ monat - 1 ] )
-	{
-		tag -= maxTage[ monat - 1 ];
-		++monat;
-		if( monat > 12 )
-		{
-			monat -= 12;
-			++jahr;
-			if( istSchaltjahr( jahr ) )
-				maxTage[ 1 ] = 29;
-			else
-				maxTage[ 1 ] = 28;
-		}
-	}
-	while( tag <= 0 )
-	{
-		tag += maxTage[ ( monat - 2 > 0 ? monat - 2 : 11 ) ];
-		--monat;
-		if( monat <= 0 )
-		{
-			monat += 12;
-			--jahr;
-			if( istSchaltjahr( jahr ) )
-				maxTage[ 1 ] = 29;
-			else
-				maxTage[ 1 ] = 28;
-		}
-	}
+    while( monat > 12 )
+    {
+        monat -= 12;
+        ++jahr;
+    }
+    while( monat <= 0 )
+    {
+        monat += 12;
+        --jahr;
+    }
+    if( istSchaltjahr( jahr ) )
+        maxTage[ 1 ] = 29;
+    else
+        maxTage[ 1 ] = 28;
+    while( tag > maxTage[ monat - 1 ] )
+    {
+        tag -= maxTage[ monat - 1 ];
+        ++monat;
+        if( monat > 12 )
+        {
+            monat -= 12;
+            ++jahr;
+            if( istSchaltjahr( jahr ) )
+                maxTage[ 1 ] = 29;
+            else
+                maxTage[ 1 ] = 28;
+        }
+    }
+    while( tag <= 0 )
+    {
+        tag += maxTage[ ( monat - 2 > 0 ? monat - 2 : 11 ) ];
+        --monat;
+        if( monat <= 0 )
+        {
+            monat += 12;
+            --jahr;
+            if( istSchaltjahr( jahr ) )
+                maxTage[ 1 ] = 29;
+            else
+                maxTage[ 1 ] = 28;
+        }
+    }
 }
 
 // Konstruktor 
 Datum::Datum()
-	: jahr( 0 ),
-	  monat( 0 ),
-	  tag( 0 ),
-	  ref( 1 )
+    : jahr( 0 ),
+    monat( 0 ),
+    tag( 0 ),
+    ref( 1 )
 {
-	int maxT[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+    int maxT[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
     maxTage = new int[ 12 ];
-	memcpy( maxTage, maxT, 12 * sizeof( int ) );
+    memcpy( maxTage, maxT, 12 * sizeof( int ) );
 }
 
 // Destruktor 
@@ -672,1189 +671,1187 @@ Datum::~Datum()
 // nicht constant 
 void Datum::setDatum( Datum *datum ) // setzt das Datum
 {
-	jahr = datum->getJahr();
-	monat = datum->getMonat();
-	tag = datum->getTag();
-	datum->release();
-	update();
+    jahr = datum->getJahr();
+    monat = datum->getMonat();
+    tag = datum->getTag();
+    datum->release();
+    update();
 }
 
 void Datum::setDatum( int jahr, int monat, int tag )
 {
-	this->jahr = jahr;
-	this->monat = monat;
-	this->tag = tag;
-	update();
+    this->jahr = jahr;
+    this->monat = monat;
+    this->tag = tag;
+    update();
 }
 
 void Datum::setDatum( const char *format, const char *datum ) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			jahr = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			monat = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			tag = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            jahr = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            monat = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            tag = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    update();
 }
 
 void Datum::setDatum( const char *format, Text *datum )
 {
-	setDatum( format, datum->getText() );
-	datum->release();
+    setDatum( format, datum->getText() );
+    datum->release();
 }
 
 void Datum::setJahr( int jahr ) // setzt das Jahr
 {
-	this->jahr = jahr;
-	update();
+    this->jahr = jahr;
+    update();
 }
 
 void Datum::setMonat( int monat ) // setzt den Monat
 {
-	this->monat = monat;
-	update();
+    this->monat = monat;
+    update();
 }
 
 void Datum::setTag( int tag ) // setzt den Tag
 {
-	this->tag = tag;
-	update();
+    this->tag = tag;
+    update();
 }
 
 void Datum::plusDatum( Datum *datum ) // addiert das datum
 {
-	this->jahr += datum->getJahr();
-	this->monat += datum->getMonat();
-	this->tag += datum->getTag();
-	datum->release();
-	update();
+    this->jahr += datum->getJahr();
+    this->monat += datum->getMonat();
+    this->tag += datum->getTag();
+    datum->release();
+    update();
 }
 
 void Datum::plusDatum( int jahr, int monat, int tag )
 {
-	this->jahr += jahr;
-	this->monat += monat;
-	this->tag += tag;
-	update();
+    this->jahr += jahr;
+    this->monat += monat;
+    this->tag += tag;
+    update();
 }
 
 void Datum::plusDatum( const char *format, const char *datum )
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			jahr += TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			monat += TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			tag += TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            jahr += TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            monat += TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            tag += TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    update();
 }
 
 void Datum::plusDatum( const char *format, Text *datum )
 {
-	plusDatum( format, datum->getText() );
-	datum->release();
+    plusDatum( format, datum->getText() );
+    datum->release();
 }
 
 void Datum::plusJahr( int jahr ) // addiert jahr Jahre
 {
-	this->jahr += jahr;
-	update();
+    this->jahr += jahr;
+    update();
 }
 
 void Datum::plusMonat( int monat ) // addiert monat Monate
 {
-	this->monat = monat;
-	update();
+    this->monat = monat;
+    update();
 }
 
 void Datum::plusTag( int tag ) // addiert tag Tage
 {
-	this->tag += tag;
-	update();
+    this->tag += tag;
+    update();
 }
 
 void Datum::minusDatum( Datum *datum ) // subtrahiert das datum
 {
-	jahr -= datum->getJahr();
-	monat -= datum->getMonat();
-	tag -= datum->getTag();
-	datum->release();
-	update();
+    jahr -= datum->getJahr();
+    monat -= datum->getMonat();
+    tag -= datum->getTag();
+    datum->release();
+    update();
 }
 
 void Datum::minusDatum( int jahr, int monat, int tag )
 {
-	this->jahr -= jahr;
-	this->monat -= monat;
-	this->tag -= tag;
-	update();
+    this->jahr -= jahr;
+    this->monat -= monat;
+    this->tag -= tag;
+    update();
 }
 
 void Datum::minusDatum( const char *format, const char *datum )
 {
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			jahr -= TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			monat -= TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			tag -= TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	update();
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            jahr -= TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            monat -= TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            tag -= TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    update();
 }
 
 void Datum::minusDatum( const char *format, Text *datum )
 {
-	minusDatum( format, datum->getText() );
-	datum->release();
+    minusDatum( format, datum->getText() );
+    datum->release();
 }
 
 void Datum::minusJahr( int jahr ) // subtrahiert jahr Jahre
 {
-	this->jahr -= jahr;
-	update();
+    this->jahr -= jahr;
+    update();
 }
 
 void Datum::minusMonat( int monat ) // subtrahiert monat Monate
 {
-	this->monat -= monat;
-	update();
+    this->monat -= monat;
+    update();
 }
 
 void Datum::minusTag( int tag ) // subtrahiert tag Tage
 {
-	this->tag -= tag;
-	update();
+    this->tag -= tag;
+    update();
 }
 
 // constant 
 int Datum::getJahr() const // gibt das Jahr zurück
 {
-	return jahr;
+    return jahr;
 }
 
 int Datum::getMonat() const // gibt der Monat zurück
 {
-	return monat;
+    return monat;
 }
 
 int Datum::getTag() const // gibt der Tag zurück
 {
-	return tag;
+    return tag;
 }
 
 Text *Datum::getDatum( const char *format ) const // gibt das Datum als Text formatiert zurück
 {
-	Text *ret = new Text( "" );
-	int flän = textLänge( format );
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			ret->anhängen( jahr );
-			break;
-		case 'm':
-			ret->anhängen( monat );
-			break;
-		case 'd':
-			ret->anhängen( tag );
-			break;
-		default:
-			ret->anhängen( f, 1 );
-			break;
-		}
-	}
-	return ret;
+    Text *ret = new Text( "" );
+    int flän = textLänge( format );
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            ret->anhängen( jahr );
+            break;
+        case 'm':
+            ret->anhängen( monat );
+            break;
+        case 'd':
+            ret->anhängen( tag );
+            break;
+        default:
+            ret->anhängen( f, 1 );
+            break;
+        }
+    }
+    return ret;
 }
 
 bool Datum::istGleich( Datum *datum ) const // prüft, ob das Datum gleich datum ist
 {
-	bool ret = jahr == datum->getJahr() &&
-		monat == datum->getMonat() &&
-		tag == datum->getTag();
-	datum->release();
-	return ret;
+    bool ret = jahr == datum->getJahr() &&
+        monat == datum->getMonat() &&
+        tag == datum->getTag();
+    datum->release();
+    return ret;
 }
 
 bool Datum::istGleich( const char *format, const char *datum ) const
 {
-	int j = jahr, m = monat, t = tag;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			j = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			t = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	bool ret = jahr == j &&
-		monat == m &&
-		tag == t;
-	return ret;
+    int j = jahr, m = monat, t = tag;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            j = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            t = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    bool ret = jahr == j &&
+        monat == m &&
+        tag == t;
+    return ret;
 }
 
 bool Datum::istGleich( const char *format, Text *datum ) const
 {
-	bool ret = istGleich( format, datum->getText() );
-	datum->release();
-	return ret;
+    bool ret = istGleich( format, datum->getText() );
+    datum->release();
+    return ret;
 }
 
 bool Datum::istGleich( int jahr, int monat, int tag ) const
 {
-	return this->jahr == jahr &&
-		this->monat == monat &&
-		this->tag == tag;
+    return this->jahr == jahr &&
+        this->monat == monat &&
+        this->tag == tag;
 }
 
 bool Datum::jahrGleich( int jahr ) const // prüft, ob das Jahr gleich jahr ist
 {
-	return this->jahr == jahr;
+    return this->jahr == jahr;
 }
 
 bool Datum::monatGleich( int monat ) const // prüft, ob der Monat gleich monat ist
 {
-	return this->monat == monat;
+    return this->monat == monat;
 }
 
 bool Datum::tagGleich( int tag ) const // prüft, ob der Tag gleich tag ist
 {
-	return this->tag == tag;
+    return this->tag == tag;
 }
 
 bool Datum::istKleiner( Datum *datum ) const // prüft, ob die Datum kleiner als datum ist
 {
-	bool ret = istKleiner( datum->getJahr(), datum->getMonat(), datum->getTag() );
-	datum->release();
-	return ret;
+    bool ret = istKleiner( datum->getJahr(), datum->getMonat(), datum->getTag() );
+    datum->release();
+    return ret;
 }
 
 bool Datum::istKleiner( int jahr, int monat, int tag ) const
 {
-	if( this->jahr < jahr )
-		return 1;
-	else if( this->jahr == jahr )
-	{
-		if( this->monat < monat )
-			return 1;
-		else if( this->monat == monat )
-		{
-			if( this->tag < tag )
-				return 1;
-			else if( this->tag == tag )
-				return 0;
-			else
-				return 0;
-		}
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( this->jahr < jahr )
+        return 1;
+    else if( this->jahr == jahr )
+    {
+        if( this->monat < monat )
+            return 1;
+        else if( this->monat == monat )
+        {
+            if( this->tag < tag )
+                return 1;
+            else if( this->tag == tag )
+                return 0;
+            else
+                return 0;
+        }
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Datum::istKleiner( const char *format, const char *datum ) const
 {
-	int j = jahr, m = monat, t = tag;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			j = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			t = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	return istKleiner( j, m, t );
+    int j = jahr, m = monat, t = tag;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            j = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            t = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    return istKleiner( j, m, t );
 }
 
 bool Datum::istKleiner( const char *format, Text *datum ) const
 {
-	bool ret = istKleiner( format, datum->getText() );
-	datum->release();
-	return ret;
+    bool ret = istKleiner( format, datum->getText() );
+    datum->release();
+    return ret;
 }
 
 bool Datum::istGrößer( Datum *datum ) const // prüft, ob die Datum größer als datum ist
 {
-	bool ret = istGrößer( datum->getJahr(), datum->getMonat(), datum->getTag() );
-	datum->release();
-	return ret;
+    bool ret = istGrößer( datum->getJahr(), datum->getMonat(), datum->getTag() );
+    datum->release();
+    return ret;
 }
 
 bool Datum::istGrößer( int jahr, int monat, int tag ) const
 {
-	if( this->jahr > jahr )
-		return 1;
-	else if( this->jahr == jahr )
-	{
-		if( this->monat > monat )
-			return 1;
-		else if( this->monat == monat )
-		{
-			if( this->tag > tag )
-				return 1;
-			else if( this->tag == tag )
-				return 0;
-			else
-				return 0;
-		}
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( this->jahr > jahr )
+        return 1;
+    else if( this->jahr == jahr )
+    {
+        if( this->monat > monat )
+            return 1;
+        else if( this->monat == monat )
+        {
+            if( this->tag > tag )
+                return 1;
+            else if( this->tag == tag )
+                return 0;
+            else
+                return 0;
+        }
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Datum::istGrößer( const char *format, const char *datum ) const
 {
-	int j = jahr, m = monat, t = tag;
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			j = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		case 'd':
-			t = TextZuInt( (char*)datum, &ende, 10 );
-			datum = ende;
-			ende = 0;
-			break;
-		default:
-			++datum;
-			break;
-		}
-	}
-	return istGrößer( j, m, t );
+    int j = jahr, m = monat, t = tag;
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            j = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        case 'd':
+            t = TextZuInt( (char*)datum, &ende, 10 );
+            datum = ende;
+            ende = 0;
+            break;
+        default:
+            ++datum;
+            break;
+        }
+    }
+    return istGrößer( j, m, t );
 }
 
 bool Datum::istGrößer( const char *format, Text *datum ) const
 {
-	bool ret = istGrößer( format, datum->getText() );
-	datum->release();
-	return ret;
+    bool ret = istGrößer( format, datum->getText() );
+    datum->release();
+    return ret;
 }
 
 // Reference Counting 
 Datum *Datum::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Datum *Datum::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der Zeit Klasse aus Zeit.h
 // Konstruktor 
 Zeit::Zeit()
-	: datum( new Datum() ),
-	  uhrzeit( new Uhrzeit() ),
-	  ref( 1 )
-{
-}
+    : datum( new Datum() ),
+    uhrzeit( new Uhrzeit() ),
+    ref( 1 )
+{}
 
 // Destruktor 
 Zeit::~Zeit()
 {
-	datum->release();
-	uhrzeit->release();
+    datum->release();
+    uhrzeit->release();
 }
 
 // nicht constant 
 void Zeit::setZeit( Zeit *zeit ) // setzt die Zeit
 {
-	datum->setDatum( zeit->getDatum() );
-	datum->plusTag( uhrzeit->setUhrzeit( zeit->getUhrzeit() ) );
-	zeit->release();
+    datum->setDatum( zeit->getDatum() );
+    datum->plusTag( uhrzeit->setUhrzeit( zeit->getUhrzeit() ) );
+    zeit->release();
 }
 
 void Zeit::setZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
 {
-	datum->setDatum( jahr, monat, tag );
-	datum->plusTag( uhrzeit->setUhrzeit( stunde, minute, sekunde ) );
+    datum->setDatum( jahr, monat, tag );
+    datum->plusTag( uhrzeit->setUhrzeit( stunde, minute, sekunde ) );
 }
 
 void Zeit::setZeit( const char *format, const char *zeit ) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s" (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	datum->setDatum( y, m, d );
-	datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    datum->setDatum( y, m, d );
+    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
 }
 
 void Zeit::setZeit( const char *format, Text *zeit )
 {
-	setZeit( format, zeit->getText() );
-	zeit->release();
+    setZeit( format, zeit->getText() );
+    zeit->release();
 }
 
 void Zeit::setJahr( int jahr ) // setzt das Jahr
 {
-	datum->setJahr( jahr );
+    datum->setJahr( jahr );
 }
 
 void Zeit::setMonat( int monat ) // setzt den Monat
 {
-	datum->setMonat( monat );
+    datum->setMonat( monat );
 }
 
 void Zeit::setTag( int tag ) // setzt den Tag
 {
-	datum->setTag( tag );
+    datum->setTag( tag );
 }
 
 void Zeit::setStunde( int stunde ) // setzt die Stunde
 {
-	datum->plusTag( uhrzeit->setStunde( stunde ) );
+    datum->plusTag( uhrzeit->setStunde( stunde ) );
 }
 
 void Zeit::setMinute( int minute ) // setzt die Minute
 {
-	datum->plusTag( uhrzeit->setMinute( minute ) );
+    datum->plusTag( uhrzeit->setMinute( minute ) );
 }
 
 void Zeit::setSekunde( int sekunde ) // setzt die Sekunde
 {
-	datum->plusTag( uhrzeit->setSekunde( sekunde ) );
+    datum->plusTag( uhrzeit->setSekunde( sekunde ) );
 }
 
 void Zeit::plusZeit( Zeit *zeit ) // addiert die zeit
 {
-	datum->plusDatum( zeit->getDatum() );
-	datum->plusTag( uhrzeit->plusUhrzeit( zeit->getUhrzeit() ) );
-	zeit->release();
+    datum->plusDatum( zeit->getDatum() );
+    datum->plusTag( uhrzeit->plusUhrzeit( zeit->getUhrzeit() ) );
+    zeit->release();
 }
 
 void Zeit::plusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
 {
-	datum->plusDatum( jahr, monat, tag );
-	datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
+    datum->plusDatum( jahr, monat, tag );
+    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
 }
 
 void Zeit::plusZeit( const char *format, const char *zeit )
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	datum->setDatum( y, m, d );
-	datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    datum->setDatum( y, m, d );
+    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
 }
 
 void Zeit::plusZeit( const char *format, Text *zeit )
 {
-	plusZeit( format, zeit->getText() );
-	zeit->release();
+    plusZeit( format, zeit->getText() );
+    zeit->release();
 }
 
 void Zeit::plusJahr( int jahr ) // addiert jahr Jahre
 {
-	datum->plusJahr( jahr );
+    datum->plusJahr( jahr );
 }
 
 void Zeit::plusMonat( int monat ) // addiert monat Monate
 {
-	datum->plusMonat( monat );
+    datum->plusMonat( monat );
 }
 
 void Zeit::plusTag( int tag ) // addiert tag Tage
 {
-	datum->plusTag( tag );
+    datum->plusTag( tag );
 }
 
 void Zeit::plusStunde( int stunde ) // addiert stunde Stunden
 {
-	datum->plusTag( uhrzeit->plusStunde( stunde ) );
+    datum->plusTag( uhrzeit->plusStunde( stunde ) );
 }
 
 void Zeit::plusMinute( int minute ) // addiert minute Minuten
 {
-	datum->plusTag( uhrzeit->plusMinute( minute ) );
+    datum->plusTag( uhrzeit->plusMinute( minute ) );
 }
 
 void Zeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
 {
-	datum->plusTag( uhrzeit->plusSekunde( sekunde ) );
+    datum->plusTag( uhrzeit->plusSekunde( sekunde ) );
 }
 
 void Zeit::minusZeit( Zeit *zeit ) // subtrahiert die zeit
 {
-	datum->minusDatum( zeit->getDatum() );
-	datum->plusTag( uhrzeit->minusUhrzeit( zeit->getUhrzeit() ) );
-	zeit->release();
+    datum->minusDatum( zeit->getDatum() );
+    datum->plusTag( uhrzeit->minusUhrzeit( zeit->getUhrzeit() ) );
+    zeit->release();
 }
 
 void Zeit::minusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
 {
-	datum->minusDatum( jahr, monat, tag );
-	datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
+    datum->minusDatum( jahr, monat, tag );
+    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
 }
 
 void Zeit::minusZeit( const char *format, const char *zeit )
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h += TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s -= TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	datum->setDatum( y, m, d );
-	datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h += TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s -= TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    datum->setDatum( y, m, d );
+    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
 }
 
 void Zeit::minusZeit( const char *format, Text *zeit )
 {
-	minusZeit( format, zeit->getText() );
-	zeit->release();
+    minusZeit( format, zeit->getText() );
+    zeit->release();
 }
 
 void Zeit::minusJahr( int jahr ) // subtrahiert jahr Jahre
 {
-	datum->minusJahr( jahr );
+    datum->minusJahr( jahr );
 }
 
 void Zeit::minusMonat( int monat ) // subtrahiert monat Monate
 {
-	datum->minusMonat( monat );
+    datum->minusMonat( monat );
 }
 
 void Zeit::minusTag( int tag ) // subtrahiert tag Tage
 {
-	datum->minusTag( tag );
+    datum->minusTag( tag );
 }
 
 void Zeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
 {
-	datum->plusTag( uhrzeit->minusStunde( stunde ) );
+    datum->plusTag( uhrzeit->minusStunde( stunde ) );
 }
 
 void Zeit::minusMinute( int minute ) // subtrahiert minute Minuten
 {
-	datum->plusTag( uhrzeit->minusMinute( minute ) );
+    datum->plusTag( uhrzeit->minusMinute( minute ) );
 }
 
 void Zeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
 {
-	datum->plusTag( uhrzeit->minusSekunde( sekunde ) );
+    datum->plusTag( uhrzeit->minusSekunde( sekunde ) );
 }
 
 // constant 
 Text *Zeit::getZeit( const char *format ) const // gibt die Zeit als Text formatiert zurück
 {
-	Text *ret = new Text( "" );
-	int flän = textLänge( format );
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			ret->anhängen( datum->getJahr() );
-			break;
-		case 'm':
-			ret->anhängen( datum->getMonat() );
-			break;
-		case 'd':
-			ret->anhängen( datum->getTag() );
-			break;
-		case 'h':
-			ret->anhängen( uhrzeit->getStunde() );
-			break;
-		case 'i':
-			ret->anhängen( uhrzeit->getMinute() );
-			break;
-		case 's':
-			ret->anhängen( uhrzeit->getSekunde() );
-			break;
-		default:
-			ret->anhängen( f, 1 );
-		}
-	}
-	return ret;
+    Text *ret = new Text( "" );
+    int flän = textLänge( format );
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            ret->anhängen( datum->getJahr() );
+            break;
+        case 'm':
+            ret->anhängen( datum->getMonat() );
+            break;
+        case 'd':
+            ret->anhängen( datum->getTag() );
+            break;
+        case 'h':
+            ret->anhängen( uhrzeit->getStunde() );
+            break;
+        case 'i':
+            ret->anhängen( uhrzeit->getMinute() );
+            break;
+        case 's':
+            ret->anhängen( uhrzeit->getSekunde() );
+            break;
+        default:
+            ret->anhängen( f, 1 );
+        }
+    }
+    return ret;
 }
 
 bool Zeit::istGleich( Zeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
 {
-	bool ret = datum->istGleich( zeit->getDatum() ) && uhrzeit->istGleich( zeit->getUhrzeit() );
-	zeit->release();
-	return ret;
+    bool ret = datum->istGleich( zeit->getDatum() ) && uhrzeit->istGleich( zeit->getUhrzeit() );
+    zeit->release();
+    return ret;
 }
 
 bool Zeit::istGleich( const char *format, const char *zeit ) const
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	return datum->istGleich( y, m, d ) && uhrzeit->istGleich( h, i, s );
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    return datum->istGleich( y, m, d ) && uhrzeit->istGleich( h, i, s );
 }
 
 bool Zeit::istGleich( const char *format, Text *zeit ) const
 {
-	bool ret = istGleich( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istGleich( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 bool Zeit::istGleich( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
 {
-	return datum->istGleich( jahr, monat, tag ) && uhrzeit->istGleich( stunde, minute, sekunde );
+    return datum->istGleich( jahr, monat, tag ) && uhrzeit->istGleich( stunde, minute, sekunde );
 }
 
 Datum *Zeit::getDatum() const // gibt das Datum zurück
 {
-	return datum->getThis();
+    return datum->getThis();
 }
 
 Datum *Zeit::zDatum() const
 {
-	return datum;
+    return datum;
 }
 
 Uhrzeit *Zeit::getUhrzeit() const // gibt die Uhrzeit zurück
 {
-	return uhrzeit->getThis();
+    return uhrzeit->getThis();
 }
 
 Uhrzeit *Zeit::zUhrzeit() const
 {
-	return uhrzeit;
+    return uhrzeit;
 }
 
 bool Zeit::istKleiner( Zeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
 {
-	if( datum->istKleiner( zeit->getDatum() ) )
-	{
-		zeit->release();
-		return 1;
-	}
-	else if( datum->istGleich( zeit->getDatum() ) )
-	{
-		if( uhrzeit->istKleiner( zeit->getUhrzeit() ) )
-		{
-			zeit->release();
-			return 1;
-		}
-		else
-		{
-			zeit->release();
-			return 0;
-		}
-	}
-	else
-	{
-		zeit->release();
-		return 0;
-	}
+    if( datum->istKleiner( zeit->getDatum() ) )
+    {
+        zeit->release();
+        return 1;
+    }
+    else if( datum->istGleich( zeit->getDatum() ) )
+    {
+        if( uhrzeit->istKleiner( zeit->getUhrzeit() ) )
+        {
+            zeit->release();
+            return 1;
+        }
+        else
+        {
+            zeit->release();
+            return 0;
+        }
+    }
+    else
+    {
+        zeit->release();
+        return 0;
+    }
 }
 
 bool Zeit::istKleiner( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
 {
-	if( datum->istKleiner( jahr, monat, tag ) )
-		return 1;
-	else if( datum->istGleich( jahr, monat, tag ) )
-	{
-		if( uhrzeit->istKleiner( stunde, minute, sekunde ) )
-			return 1;
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( datum->istKleiner( jahr, monat, tag ) )
+        return 1;
+    else if( datum->istGleich( jahr, monat, tag ) )
+    {
+        if( uhrzeit->istKleiner( stunde, minute, sekunde ) )
+            return 1;
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Zeit::istKleiner( const char *format, const char *zeit ) const
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	if( datum->istKleiner( y, m, d ) )
-		return 1;
-	else if( datum->istGleich( y, m, d ) )
-	{
-		if( uhrzeit->istKleiner( h, i, s ) )
-			return 1;
-		else
-			return 0;
-	}
-	else
-		return 0;
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    if( datum->istKleiner( y, m, d ) )
+        return 1;
+    else if( datum->istGleich( y, m, d ) )
+    {
+        if( uhrzeit->istKleiner( h, i, s ) )
+            return 1;
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Zeit::istKleiner( const char *format, Text *zeit ) const
 {
-	bool ret = istKleiner( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istKleiner( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 bool Zeit::istGrößer( Zeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
 {
-	if( datum->istGrößer( zeit->getDatum() ) )
-	{
-		zeit->release();
-		return 1;
-	}
-	else if( datum->istGleich( zeit->getDatum() ) )
-	{
-		if( uhrzeit->istGrößer( zeit->getUhrzeit() ) )
-		{
-			zeit->release();
-			return 1;
-		}
-		else
-		{
-			zeit->release();
-			return 0;
-		}
-	}
-	else
-	{
-		zeit->release();
-		return 0;
-	}
+    if( datum->istGrößer( zeit->getDatum() ) )
+    {
+        zeit->release();
+        return 1;
+    }
+    else if( datum->istGleich( zeit->getDatum() ) )
+    {
+        if( uhrzeit->istGrößer( zeit->getUhrzeit() ) )
+        {
+            zeit->release();
+            return 1;
+        }
+        else
+        {
+            zeit->release();
+            return 0;
+        }
+    }
+    else
+    {
+        zeit->release();
+        return 0;
+    }
 }
 
 bool Zeit::istGrößer( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
 {
-	if( datum->istGrößer( jahr, monat, tag ) )
-		return 1;
-	else if( datum->istGleich( jahr, monat, tag ) )
-	{
-		if( uhrzeit->istGrößer( stunde, minute, sekunde ) )
-			return 1;
-		else
-			return 0;
-	}
-	else
-		return 0;
+    if( datum->istGrößer( jahr, monat, tag ) )
+        return 1;
+    else if( datum->istGleich( jahr, monat, tag ) )
+    {
+        if( uhrzeit->istGrößer( stunde, minute, sekunde ) )
+            return 1;
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Zeit::istGrößer( const char *format, const char *zeit ) const
 {
-	int y = datum->getJahr();
-	int m = datum->getMonat();
-	int d = datum->getTag();
-	int h = uhrzeit->getStunde();
-	int i = uhrzeit->getMinute();
-	int s = uhrzeit->getSekunde();
-
-	int flän = textLänge( format );
-	char *ende = 0;
-	for( const char *f = format; f < format + flän; ++f )
-	{
-		switch( *f )
-		{
-		case 'y':
-			y = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'm':
-			m = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'd':
-			d = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'h':
-			h = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 'i':
-			i = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		case 's':
-			s = TextZuInt( (char*)zeit, &ende, 10 );
-			zeit = ende;
-			ende = 0;
-			break;
-		default:
-			++zeit;
-			break;
-		}
-	}
-	if( datum->istGrößer( y, m, d ) )
-		return 1;
-	else if( datum->istGleich( y, m, d ) )
-	{
-		if( uhrzeit->istGrößer( h, i, s ) )
-			return 1;
-		else
-			return 0;
-	}
-	else
-		return 0;
+    int y = datum->getJahr();
+    int m = datum->getMonat();
+    int d = datum->getTag();
+    int h = uhrzeit->getStunde();
+    int i = uhrzeit->getMinute();
+    int s = uhrzeit->getSekunde();
+
+    int flän = textLänge( format );
+    char *ende = 0;
+    for( const char *f = format; f < format + flän; ++f )
+    {
+        switch( *f )
+        {
+        case 'y':
+            y = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'm':
+            m = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'd':
+            d = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'h':
+            h = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 'i':
+            i = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        case 's':
+            s = TextZuInt( (char*)zeit, &ende, 10 );
+            zeit = ende;
+            ende = 0;
+            break;
+        default:
+            ++zeit;
+            break;
+        }
+    }
+    if( datum->istGrößer( y, m, d ) )
+        return 1;
+    else if( datum->istGleich( y, m, d ) )
+    {
+        if( uhrzeit->istGrößer( h, i, s ) )
+            return 1;
+        else
+            return 0;
+    }
+    else
+        return 0;
 }
 
 bool Zeit::istGrößer( const char *format, Text *zeit ) const
 {
-	bool ret = istGrößer( format, zeit->getText() );
-	zeit->release();
-	return ret;
+    bool ret = istGrößer( format, zeit->getText() );
+    zeit->release();
+    return ret;
 }
 
 // Reference Counting 
 Zeit *Zeit::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 Zeit *Zeit::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der ZeitMesser Klasse aus Zeit.h
 // Konstruktor 
 ZeitMesser::ZeitMesser()
-	: start( 0 ),
-	  ende( 0 ),
-	  messung( 0 ),
-	  ref( 1 )
-{
-}
+    : start( 0 ),
+    ende( 0 ),
+    messung( 0 ),
+    ref( 1 )
+{}
 
 // Destruktor 
 ZeitMesser::~ZeitMesser()
@@ -1865,119 +1862,119 @@ ZeitMesser::~ZeitMesser()
 // nicht constant 
 void ZeitMesser::messungStart() // legt des Startpunkt der Zeitmessung fest
 {
-	timeval tv;
-	gettimeofday( &tv, 0 );
-	start = tv.tv_sec + tv.tv_usec / 1000000.0;
+    timeval tv;
+    gettimeofday( &tv, 0 );
+    start = tv.tv_sec + tv.tv_usec / 1000000.0;
 }
 
 void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
 {
-	timeval tv;
-	gettimeofday( &tv, 0 );
-	ende = tv.tv_sec + tv.tv_usec / 1000000.0;
-	messung = ende - start;
+    timeval tv;
+    gettimeofday( &tv, 0 );
+    ende = tv.tv_sec + tv.tv_usec / 1000000.0;
+    messung = ende - start;
 }
 
 // constant 
 double ZeitMesser::getSekunden() const // gibt den sekundenabstand zwischen start und ende der Messung zurück
 {
-	return messung;
+    return messung;
 }
 
 double ZeitMesser::getMinuten() const // gibt den minutenabstand zwischen start und ende der Messung zurück
 {
-	return messung / 60;
+    return messung / 60;
 }
 
 double ZeitMesser::getStunden() const // gibt den stundenabstand zwischen start und ende der Messung zurück
 {
-	return messung / 3600;
+    return messung / 3600;
 }
 
 // Reference Counting 
 ZeitMesser *ZeitMesser::getThis()
 {
-	++ref;
-	return this;
+    ++ref;
+    return this;
 }
 
 ZeitMesser *ZeitMesser::release()
 {
-	--ref;
-	if( !ref )
-		delete this;
-	return 0;
+    --ref;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Globale Funktionen 
 Uhrzeit *Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurück
 {
 #ifdef WIN32
-	Uhrzeit *ret = new Uhrzeit();
-	time_t Zeitstempel = time( 0 );
-	tm now;
-	localtime_s( &now, &Zeitstempel );
-	ret->setUhrzeit( now.tm_hour, now.tm_min, now.tm_sec );
-	return ret;
+    Uhrzeit *ret = new Uhrzeit();
+    time_t Zeitstempel = time( 0 );
+    tm now;
+    localtime_s( &now, &Zeitstempel );
+    ret->setUhrzeit( now.tm_hour, now.tm_min, now.tm_sec );
+    return ret;
 #else
-	Uhrzeit *ret = new Uhrzeit( );
-	time_t Zeitstempel = time( 0 );
-	tm *now = localtime( &Zeitstempel );
-	ret->setUhrzeit( now->tm_hour, now->tm_min, now->tm_sec );
-	return ret;
+    Uhrzeit *ret = new Uhrzeit();
+    time_t Zeitstempel = time( 0 );
+    tm *now = localtime( &Zeitstempel );
+    ret->setUhrzeit( now->tm_hour, now->tm_min, now->tm_sec );
+    return ret;
 #endif
 }
 
 Datum *Framework::getDatum() // gibt das aktuelle Datum zurück
 {
 #ifdef WIN32
-	Datum *ret = new Datum();
-	time_t Zeitstempel = time( 0 );
-	tm now;
-	localtime_s( &now, &Zeitstempel );
-	ret->setDatum( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday );
-	return ret;
+    Datum *ret = new Datum();
+    time_t Zeitstempel = time( 0 );
+    tm now;
+    localtime_s( &now, &Zeitstempel );
+    ret->setDatum( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday );
+    return ret;
 #else
-	Datum *ret = new Datum( );
-	time_t Zeitstempel = time( 0 );
-	tm *now = localtime( &Zeitstempel );
-	ret->setDatum( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday );
-	return ret;
+    Datum *ret = new Datum();
+    time_t Zeitstempel = time( 0 );
+    tm *now = localtime( &Zeitstempel );
+    ret->setDatum( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday );
+    return ret;
 #endif
 }
 
 Zeit *Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück
 {
 #ifdef WIN32
-	Zeit *ret = new Zeit();
-	time_t Zeitstempel = time( 0 );
-	tm now;
-	localtime_s( &now, &Zeitstempel );
-	ret->setZeit( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec );
-	return ret;
+    Zeit *ret = new Zeit();
+    time_t Zeitstempel = time( 0 );
+    tm now;
+    localtime_s( &now, &Zeitstempel );
+    ret->setZeit( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec );
+    return ret;
 #else
-	Zeit *ret = new Zeit( );
-	time_t Zeitstempel = time( 0 );
-	tm *now = localtime( &Zeitstempel );
-	ret->setZeit( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec );
-	return ret;
+    Zeit *ret = new Zeit();
+    time_t Zeitstempel = time( 0 );
+    tm *now = localtime( &Zeitstempel );
+    ret->setZeit( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec );
+    return ret;
 #endif
 }
 
 bool Framework::istSchaltjahr( int jahr ) // prüft, ob jahr ein Schaltjahr ist
 {
-	if( jahr % 4 == 0 )
-	{
-		if( jahr % 100 == 0 )
-		{
-			if( jahr % 400 == 0 )
-				return true;
-			else
-				return false;
-		}
-		else
-			return true;
-	}
-	else
-		return false;
+    if( jahr % 4 == 0 )
+    {
+        if( jahr % 100 == 0 )
+        {
+            if( jahr % 400 == 0 )
+                return true;
+            else
+                return false;
+        }
+        else
+            return true;
+    }
+    else
+        return false;
 }

Zeit.h

@@ -234,7 +234,6 @@ namespace Framework
         //  return: (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
         // Beispiel: (5:30:00).istGrößer( "h:i:s", "10:40:29" ); return false
         __declspec( dllexport ) bool istGrößer( const char *format, Text *zeit ) const;
-        
         // Erhöht den Reference Counting Zähler
         //  return: this
         __declspec( dllexport ) Uhrzeit *getThis();
@@ -443,7 +442,6 @@ namespace Framework
         //  return: (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
         // Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", new Text( "2016, 1, 23" ) ) ); return true
         __declspec( dllexport ) bool istGrößer( const char *format, Text *datum ) const;
-
         // Erhöht den Reference Counting Zähler
         //  return: this
         __declspec( dllexport ) Datum *getThis();
@@ -465,7 +463,6 @@ namespace Framework
         __declspec( dllexport ) Zeit();
         // Löscht das aktuelle Zeichnung.
         __declspec( dllexport ) ~Zeit();
-        
         // Ändert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
         //  zeit: Die neue Zeit.
         __declspec( dllexport ) void setZeit( Zeit *zeit );
@@ -579,7 +576,6 @@ namespace Framework
         // Zieht die übergebene Zeit ab und speichert das Ergebnis.
         //  sekunde: Die abzuziehende Sekunde.
         __declspec( dllexport ) void minusSekunde( int sekunde );
-        
         // Gibt die gespeicherte Zeit als Text zurück.
         //  format: Eine Zeichenkette, die angibt in welcher Form die neue Zeit zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
         __declspec( dllexport ) Text *getZeit( const char *format ) const;
@@ -660,7 +656,6 @@ namespace Framework
         //  zeit: Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
         //  return: (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
         __declspec( dllexport ) bool istGrößer( const char *format, Text *zeit ) const;
-
         // Erhöht den Reference Counting Zähler
         //  return: this
         __declspec( dllexport ) Zeit *getThis();
@@ -683,19 +678,16 @@ namespace Framework
         __declspec( dllexport ) ZeitMesser();
         // Löscht das aktuelle Zeichnung
         __declspec( dllexport ) ~ZeitMesser();
-
         // legt den Startpunkt des zeitstoppens fest
         __declspec( dllexport ) void messungStart();
         // legt des Endpunkt der Zeitmessung fest
         __declspec( dllexport ) void messungEnde();
-        
         // gibt den Abstand zwischen start und ende der Messung in Sekunden zurück
         __declspec( dllexport ) double getSekunden() const;
         // gibt den Abstand zwischen start und ende der Messung in Minuten zurück
         __declspec( dllexport ) double getMinuten() const;
         // gibt den Abstand zwischen start und ende der Messung in Stunden zurück
         __declspec( dllexport ) double getStunden() const;
-        
         // Erhöht den Reference Counting Zähler.
         //  return: this.
         __declspec( dllexport ) ZeitMesser *getThis();

main.h

@@ -19,22 +19,22 @@
 namespace Framework
 {
     // Speichert die dem Programm vom Betriebssystem beim Start übergebenen Parameter
-	struct Startparam
-	{
-		HINSTANCE hinst, hpinst;
-		LPSTR cmd;
-		int show;
-	};
+    struct Startparam
+    {
+        HINSTANCE hinst, hpinst;
+        LPSTR cmd;
+        int show;
+    };
 
     // Überschreibe diese Funktion. Sie wird vom Framework automatisch beim Start des Programmes aufgerufen
     //  p: Die Parameter, die dem Programm beim Start vom Betriebssystem übergeben wurden
-	int KSGStart Start( Startparam p );
+    int KSGStart Start( Startparam p );
     // Initialisiert das Framework
     // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-	__declspec( dllexport ) void initFramework();
+    __declspec( dllexport ) void initFramework();
     // Gibt den duch (initFramework) benutzten Arbeitsspeicher wieder frei
     // Wird in der (WinMain) des Frameworks automatisch aufgerufen
-	__declspec( dllexport ) void releaseFramework();
+    __declspec( dllexport ) void releaseFramework();
 }
 
 int WINAPI WinMain( _In_ HINSTANCE hinst, _In_opt_ HINSTANCE hpinst, _In_ LPSTR cmd, int _In_ show )
@@ -42,15 +42,15 @@ int WINAPI WinMain( _In_ HINSTANCE hinst, _In_opt_ HINSTANCE hpinst, _In_ LPSTR
 #ifdef _DEBUG
     _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
 #endif
-	Framework::initFramework();
-	Framework::Startparam stp;
-	stp.hinst = hinst;
-	stp.hpinst = hpinst;
-	stp.cmd = cmd;
-	stp.show = show;
-	int ret = Framework::Start( stp );
-	Framework::releaseFramework();
-	return ret;
+    Framework::initFramework();
+    Framework::Startparam stp;
+    stp.hinst = hinst;
+    stp.hpinst = hpinst;
+    stp.cmd = cmd;
+    stp.show = show;
+    int ret = Framework::Start( stp );
+    Framework::releaseFramework();
+    return ret;
 }
 
 #endif