use framework ui initialisation and reference counting

Blöcke/Blöcke.vcxproj

@@ -22,13 +22,13 @@
     <ProjectGuid>{1CED0788-41C6-463C-8D29-C7AF41EE6357}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>Blöcke</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

Blöcke/Game.cpp

@@ -4,13 +4,11 @@
 // Inhalt der Game Klasse aus Game.h
 // Konstruktor
 Game::Game()
+    : ReferenceCounter()
 {
-	schrift = 0;
-	screen = 0;
-	alpha = 0;
-	menü = 0;
+    alpha = 0;
+    menü = 0;
     client = 0;
-	ref = 1;
 }
 
 // Destruktor
@@ -18,16 +16,14 @@ Game::~Game()
 {
     if( client )
         client->release();
-	if( schrift )
-		schrift->release();
-	if( menü )
-		menü->release();
+    if( menü )
+        menü->release();
 }
 
 // nicht constant
 bool Game::laden()
 {
-	return 1;
+    return 1;
 }
 
 void Game::setMinigameClientZ( KSGClient::MinigameServerClient *client )
@@ -44,76 +40,54 @@ void Game::setMinigameAPI( MinigameAPI *api )
 
 void Game::doPublicMausEreignis( MausEreignis &me )
 {
-	if( menü )
-		menü->doPublicMausEreignis( me );
+    if( menü )
+        menü->doPublicMausEreignis( me );
 }
 
 void Game::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( menü )
-		menü->doTastaturEreignis( te );
+    if( menü )
+        menü->doTastaturEreignis( te );
 }
 
 bool Game::tick( double zeit )
 {
-	int val = (int)( zeit * 150 );
-	if( menü && !menü->istBeendet() && alpha != 255 )
-	{
-		alpha += val;
-		if( alpha > 255 )
-			alpha = 255;
-		return 1;
-	}
-	if( menü && menü->istBeendet() && alpha )
-	{
-		alpha -= val;
-		if( alpha < 255 )
-			alpha = 0;
-	}
-	if( menü )
-		return menü->tick( zeit );
-	return 0;
+    int val = (int)( zeit * 150 );
+    if( menü && !menü->istBeendet() && alpha != 255 )
+    {
+        alpha += val;
+        if( alpha > 255 )
+            alpha = 255;
+        return 1;
+    }
+    if( menü && menü->istBeendet() && alpha )
+    {
+        alpha -= val;
+        if( alpha < 255 )
+            alpha = 0;
+    }
+    if( menü )
+        return menü->tick( zeit );
+    return 0;
 }
 
 void Game::render( Bild &zRObj )
 {
-	zRObj.setAlpha( alpha );
-	if( menü )
-		menü->render( zRObj );
-	zRObj.releaseAlpha();
+    zRObj.setAlpha( alpha );
+    if( menü )
+        menü->render( zRObj );
+    zRObj.releaseAlpha();
 }
 
-void Game::setSchriftZ( Schrift *schrift )
+void Game::setUIFactory( UIInit &uiFactory )
 {
-	this->schrift = schrift;
-	if( !menü && this->schrift && screen )
-		menü = new Menü( schrift, screen, client->getThis() );
-}
-
-void Game::setBildschirmZ( Bildschirm *zScreen )
-{
-	screen = zScreen;
-	if( !menü && schrift && screen )
-		menü = new Menü( schrift, screen, client->getThis() );
+    this->uiFactory = uiFactory;
+    if( !menü )
+        menü = new Menü( uiFactory, dynamic_cast<KSGClient::MinigameServerClient *>( client->getThis() ) );
 }
 
 // constant
 bool Game::istEnde() const
 {
-	return menü ? ( menü->istBeendet() && !alpha ) : 0;
-}
-
-// Reference Counting
-MiniGameV *Game::getThis()
-{
-	ref++;
-	return this;
-}
-
-MiniGameV *Game::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return menü ? ( menü->istBeendet() && !alpha ) : 0;
 }

Blöcke/Game.h

@@ -7,33 +7,28 @@
 class Game : public MiniGameV
 {
 private:
-	Schrift *schrift;
-	Bildschirm *screen;
-	Menü *menü;
+    UIInit uiFactory;
+    Menü *menü;
     KSGClient::MinigameServerClient *client;
-	int alpha;
-	int ref;
+    int alpha;
+    int ref;
 
 public:
-	// Konstruktor
-	Game();
-	// Destruktor
-	~Game();
-	// nicht constant
-	virtual bool laden() override;
+    // Konstruktor
+    Game();
+    // Destruktor
+    ~Game();
+    // nicht constant
+    virtual bool laden() override;
     virtual void setMinigameClientZ( KSGClient::MinigameServerClient *client ) override;
     virtual void setMinigameAPI( MinigameAPI *api ) override;
-	virtual void doPublicMausEreignis( MausEreignis &me ) override;
-	virtual void doTastaturEreignis( TastaturEreignis &te ) override;
-	virtual bool tick( double zeit ) override;
-	virtual void render( Bild &zRObj ) override;
-	virtual void setSchriftZ( Schrift *schrift ) override;
-	virtual void setBildschirmZ( Bildschirm *zScreen ) override;
-	// constant
-	virtual bool istEnde() const override;
-	// Reference Counting
-	virtual MiniGameV *getThis() override;
-	virtual MiniGameV *release() override;
+    virtual void doPublicMausEreignis( MausEreignis &me ) override;
+    virtual void doTastaturEreignis( TastaturEreignis &te ) override;
+    virtual bool tick( double zeit ) override;
+    virtual void render( Bild &zRObj ) override;
+    virtual void setUIFactory( UIInit &uiFactory ) override;
+    // constant
+    virtual bool istEnde() const override;
 };
 
 #endif

Blöcke/Initialisierung.cpp

@@ -3,182 +3,85 @@
 #include <Textfeld.h>
 #include <MausEreignis.h>
 
-Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *titel )
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel )
 {
-	Knopf *ret = new Knopf();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	ret->setText( titel );
-	return ret;
+    Knopf *ret = uiFactory.createKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    ret->setText( titel );
+    return ret;
 }
 
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt )
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
 {
-	KontrollKnopf *ret = new KontrollKnopf();
-	ret->setMausEreignis( _ret1ME );
-	ret->addStyle( style );
-	ret->setSchriftZ( zSchrift->getThis() );
-	ret->setText( txt );
-	ret->setSText( txt );
-	ret->setSFarbe( 0xFFFFFFFF );
-	ret->setSSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	ret->loadData( "data/bilder/system.ltdb" );
-	return ret;
+    KontrollKnopf *ret = uiFactory.createKontrollKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setText( txt );
+    ret->setSText( txt );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    ret->loadData( "data/bilder/system.ltdb" );
+    return ret;
 }
 
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt )
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
 {
-	TextFeld *ret = new TextFeld();
-	ret->setStyle( style );
-	ret->setSchriftZ( zSchrift->getThis() );
-	ret->setText( txt );
-	ret->setSchriftFarbe( 0xFFFFFFFF );
-	ret->setSchriftSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	return ret;
+    TextFeld *ret = uiFactory.createTextFeld( uiFactory.initParam );
+    ret->setStyle( style );
+    ret->setText( txt );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    return ret;
 }
 
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values )
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values )
 {
-	AuswahlBox *ret = new AuswahlBox();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | AuswahlBox::Style::Hintergrund ) == style )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	if( ( style | AuswahlBox::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( ( style | AuswahlBox::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | AuswahlBox::Style::MaxHeight ) == style )
-		ret->setMaxAuskappHeight( 100 );
-	if( ( style | AuswahlBox::Style::MausRahmen ) == style )
-	{
-		ret->setMausRahmenBreite( 1 );
-		ret->setMausRahmenFarbe( 0xFF005500 );
-	}
-	if( ( style | AuswahlBox::Style::MausBuffer ) == style )
-	{
-		ret->setMausAlphaFeldFarbe( 0x00008700 );
-		ret->setMausAlphaFeldStrength( -8 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlRahmen ) == style )
-	{
-		ret->setAuswRahmenBreite( 1 );
-		ret->setAuswRahmenFarbe( 0xFF00FF00 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlBuffer ) == style )
-	{
-		ret->setAuswAlphaFeldFarbe( 0x0000FF00 );
-		ret->setAuswAlphaFeldStrength( -8 );
-	}
-	for( auto i = values.begin(); i != values.end(); i++ )
-	{
-		ret->addEintrag( *i );
-	}
-	return ret;
+    AuswahlBox *ret = uiFactory.createAuswahlBox( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    for( auto i = values.begin(); i != values.end(); i++ )
+    {
+        ret->addEintrag( *i );
+    }
+    return ret;
 }
 
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHeight )
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHeight )
 {
-	ObjTabelle *ret = new ObjTabelle();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | ObjTabelle::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( ( style | ObjTabelle::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::Raster ) == style )
-	{
-		ret->setRasterBreite( 1 );
-		ret->setRasterFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::VScroll ) == style )
-		ret->setVertikalKlickScroll( 5 );
-	if( ( style | ObjTabelle::Style::HScroll ) == style )
-		ret->setHorizontalKlickScroll( 5 );
-	for( auto i = spalten.begin(); i != spalten.end(); i++ )
-	{
-		ret->addSpalte( i->name );
-		ret->setSpaltenBreite( i->name, i->breite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
-			ret->setMinSpaltenBreite( i->name, i->minBreite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
-			ret->setMaxSpaltenBreite( i->name, i->maxBreite );
-		if( überschriftHeight )
-		{
-			if( ret->getZeilenNummer( "Überschrift" ) < 0 )
-			{
-				ret->addZeile( 0, "Überschrift" );
-				ret->setZeilenHeight( 0, 20 );
-			}
-			ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, i->name ) );
-		}
-	}
-	return ret;
+    ObjTabelle *ret = uiFactory.createObjTabelle( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    for( auto i = spalten.begin(); i != spalten.end(); i++ )
+    {
+        ret->addSpalte( i->name );
+        ret->setSpaltenBreite( i->name, i->breite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
+            ret->setMinSpaltenBreite( i->name, i->minBreite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
+            ret->setMaxSpaltenBreite( i->name, i->maxBreite );
+        if( überschriftHeight )
+        {
+            if( ret->getZeilenNummer( "Überschrift" ) < 0 )
+            {
+                ret->addZeile( 0, "Überschrift" );
+                ret->setZeilenHeight( 0, 20 );
+            }
+            ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, i->name ) );
+        }
+    }
+    return ret;
 }
 
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, DiagDaten *data )
+LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data )
 {
-	LDiag *ret = new LDiag();
-	ret->setStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-	{
-		ret->setSchriftZ( zSchrift->getThis() );
-		ret->setSchriftSize( 12 );
-	}
-	if( data )
-		ret->setDiagDatenZ( data );
-	if( ret->hatStyle( LDiag::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( LDiag::Style::DatenRahmen ) )
-	{
-		ret->setDatenRahmenBreite( 1 );
-		ret->setDatenRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( LDiag::Style::Hintergrund ) )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	if( ret->hatStyle( LDiag::Style::DatenHintergrund ) )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	return ret;
+    LDiag *ret = uiFactory.createLDiag( uiFactory.initParam );
+    ret->setStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( data )
+        ret->setDiagDatenZ( data );
+    return ret;
 }

Blöcke/Initialisierung.h

@@ -7,22 +7,23 @@
 #include <Tabelle.h>
 #include <Diagramm.h>
 #include <initializer_list>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
 struct OBJTabelleSpalteIni
 {
-	char *name;
-	int breite;
-	int minBreite;
-	int maxBreite;
+    char *name;
+    int breite;
+    int minBreite;
+    int maxBreite;
 };
 
-Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *titel );
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt );
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt );
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values );
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHeight );
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, DiagDaten *data );
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel );
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values );
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHeight );
+LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data );
 
 #endif

Blöcke/Map.cpp

@@ -11,6 +11,7 @@
 // Inhalt der Map Klasse aus Map.h
 // Konstruktor
 Map::Map( KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
 {
     this->klient = klient;
     map = new RCArray< Array< int > >();
@@ -25,7 +26,6 @@ Map::Map( KSGClient::MinigameServerClient *klient )
     rend = 0;
     rGen = 0;
     gameTime = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -83,7 +83,7 @@ void Map::reset( Text *zOptionen )
     bool fortsetzen = (int)*tmp != 0;
     tmp->release();
     if( rGen )
-        rGen = rGen->release();
+        rGen = (RandomGenerator *)rGen->release();
     if( fortsetzen && DateiExistiert( "data/Minigames/Blöcke/data/game.save" ) && klient )
     {
         if( capture.istOffen() )
@@ -96,15 +96,15 @@ void Map::reset( Text *zOptionen )
         int br = 0;
         int hö = 0;
         __int64 seed;
-        save->lese( (char*)&seed, 8 );
+        save->lese( (char *)&seed, 8 );
         rGen = new RandomGenerator();
         rGen->setSeed( seed );
-        save->lese( (char*)&gameTime, 8 );
-        save->lese( (char*)&br, 4 );
-        save->lese( (char*)&hö, 4 );
+        save->lese( (char *)&gameTime, 8 );
+        save->lese( (char *)&br, 4 );
+        save->lese( (char *)&hö, 4 );
         if( br == breite && hö == höhe )
         {
-            save->lese( (char*)&score, 4 );
+            save->lese( (char *)&score, 4 );
             scoreCheck = score * 11197;
             for( int x = 0; x < breite; x++ )
             {
@@ -112,7 +112,7 @@ void Map::reset( Text *zOptionen )
                 for( int y = 0; y < höhe; y++ )
                 {
                     int f = 0;
-                    save->lese( (char*)&f, 4 );
+                    save->lese( (char *)&f, 4 );
                     map->z( x )->set( f, y );
                 }
             }
@@ -157,7 +157,7 @@ void Map::reset( Text *zOptionen )
             capture.erstellen();
             capture.open( Datei::Style::schreiben );
             __int64 seed = rGen->getSeed();
-            capture.schreibe( (char*)&seed, 8 );
+            capture.schreibe( (char *)&seed, 8 );
         }
         else
         {
@@ -178,7 +178,7 @@ void Map::doPublicMausEreignis( MausEreignis &me )
         next = 0;
         if( klient )
         {
-            capture.schreibe( (char*)&gameTime, 8 );
+            capture.schreibe( (char *)&gameTime, 8 );
             capture.schreibe( "\x1", 1 );
         }
     }
@@ -189,10 +189,10 @@ void Map::doPublicMausEreignis( MausEreignis &me )
     }
     if( klient )
     {
-        capture.schreibe( (char*)&gameTime, 8 );
+        capture.schreibe( (char *)&gameTime, 8 );
         capture.schreibe( "\x0", 1 );
-        capture.schreibe( (char*)&me.mx, 4 );
-        capture.schreibe( (char*)&me.my, 4 );
+        capture.schreibe( (char *)&me.mx, 4 );
+        capture.schreibe( (char *)&me.my, 4 );
     }
     int x = (int)( me.mx / ( 800.0 / breite ) );
     int y = (int)( höhe - ( me.my / ( 500.0 / höhe ) ) );
@@ -255,7 +255,7 @@ void Map::doTastaturEreignis( TastaturEreignis &te )
         next = 0;
         if( klient )
         {
-            capture.schreibe( (char*)&gameTime, 8 );
+            capture.schreibe( (char *)&gameTime, 8 );
             capture.schreibe( "\x1", 1 );
         }
     }
@@ -336,8 +336,8 @@ bool Map::tick( double tickVal )
                 DateiRemove( "data/Minigames/Blöcke/data/upload.mgc" );
                 DateiUmbenennen( "data/Minigames/Blöcke/data/game.mgc", "data/Minigames/Blöcke/data/upload.mgc" );
                 int tmpScore = score;
-                KSGClient::MinigameServerClient *tmpKlient = klient->getThis();
-                new AsynchronCall( [ tmpScore, tmpKlient ]()
+                KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
+                new AsynchronCall( [tmpScore, tmpKlient]()
                 {
                     InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
                     opd->laden();
@@ -433,11 +433,11 @@ void Map::speichern()
         d->erstellen();
         d->open( Datei::Style::schreiben );
         __int64 seed = rGen->getSeed();
-        d->schreibe( (char*)&seed, 8 );
-        d->schreibe( (char*)&gameTime, 8 );
-        d->schreibe( (char*)&breite, 4 );
-        d->schreibe( (char*)&höhe, 4 );
-        d->schreibe( (char*)&score, 4 );
+        d->schreibe( (char *)&seed, 8 );
+        d->schreibe( (char *)&gameTime, 8 );
+        d->schreibe( (char *)&breite, 4 );
+        d->schreibe( (char *)&höhe, 4 );
+        d->schreibe( (char *)&score, 4 );
         for( int x = 0; x < breite; x++ )
         {
             for( int y = 0; y < höhe; y++ )
@@ -445,7 +445,7 @@ void Map::speichern()
                 int f = 0;
                 if( map->z( x ) && map->z( x )->hat( y ) )
                     f = map->z( x )->get( y );
-                d->schreibe( (char*)&f, 4 );
+                d->schreibe( (char *)&f, 4 );
             }
         }
         d->close();
@@ -464,19 +464,4 @@ int Map::getScore() const
 bool Map::istBeendet() const
 {
     return beendet;
-}
-
-// Reference Counting
-Map *Map::getThis()
-{
-    ref++;
-    return this;
-}
-
-Map *Map::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Blöcke/Map.h

@@ -8,46 +8,42 @@
 
 using namespace Framework;
 
-class Map
+class Map : public virtual ReferenceCounter
 {
 private:
-	RCArray< Array< int > > *map;
-	int score;
+    RCArray< Array< int > > *map;
+    int score;
     int scoreCheck;
-	int breite;
-	int höhe;
-	int geschwindigkeit;
-	int bAnzahl;
-	double next;
-	bool beendet;
-	bool rend;
+    int breite;
+    int höhe;
+    int geschwindigkeit;
+    int bAnzahl;
+    double next;
+    bool beendet;
+    bool rend;
     double gameTime;
     Datei capture;
     Critical cs;
     KSGClient::MinigameServerClient *klient;
     RandomGenerator *rGen;
-	int ref;
-	// private
-	void remove( int x, int y );
+    // private
+    void remove( int x, int y );
 
 public:
-	// Konstruktor
-	Map( KSGClient::MinigameServerClient *klient );
-	// Destruktor
-	~Map();
-	// nicht constant
-	void reset( Text *zOptionen );
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
+    // Konstruktor
+    Map( KSGClient::MinigameServerClient *klient );
+    // Destruktor
+    ~Map();
+    // nicht constant
+    void reset( Text *zOptionen );
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
     void speichern();
-	// constant
-	int getScore() const;
-	bool istBeendet() const;
-	// Reference Counting
-	Map *getThis();
-	Map *release();
+    // constant
+    int getScore() const;
+    bool istBeendet() const;
 };
 
 #endif

Blöcke/Menü.cpp

@@ -15,16 +15,16 @@
 
 // Inhalt der MenüVerloren Klasse aus Menü.h
 // Kontruktor
-MenüVerloren::MenüVerloren( Schrift *zSchrift )
+MenüVerloren::MenüVerloren( UIInit &uiFactory )
+    : ReferenceCounter()
 {
     ram = new LRahmen();
     ram->setSize( 160, 100 );
     ram->setPosition( 320, 200 );
     ram->setFarbe( 0xFFFFFFFF );
-    verloren = initTextFeld( 325, 210, 150, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
-    neu = initKnopf( 350, 240, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
-    beenden = initKnopf( 350, 270, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
-    ref = 1;
+    verloren = initTextFeld( 325, 210, 150, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
+    neu = initKnopf( 350, 240, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
+    beenden = initKnopf( 350, 270, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
 }
 
 // Destruktor
@@ -67,33 +67,18 @@ void Men
     ram->render( zRObj );
 }
 
-// Reference Counting
-MenüVerloren *MenüVerloren::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüVerloren *MenüVerloren::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüSpiel Klasse aus Menü.h
 // Konstruktor
-MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
+MenüSpiel::MenüSpiel( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     map = new Map( klient );
-    verloren = new MenüVerloren( zSchrift );
+    verloren = new MenüVerloren( uiFactory );
     timePuffer = 0;
     beendet = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -228,33 +213,19 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüSpiel *MenüSpiel::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüSpiel *MenüSpiel::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüWiederhohlung Klasse
 // Konstruktor
-MenüWiederhohlung::MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen )
+MenüWiederhohlung::MenüWiederhohlung( UIInit &uiFactory, Datei *datei, Text *zOptionen )
+    : ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     this->datei = datei;
     if( !datei->istOffen() )
         datei->open( Datei::Style::lesen );
     __int64 seed;
-    datei->lese( (char*)&seed, 8 );
+    datei->lese( (char *)&seed, 8 );
     zOptionen->append( ",Fortsetzen=0,Seed=" );
     zOptionen->append( seed );
     map = new Map( 0 );
@@ -262,9 +233,8 @@ Men
     beendet = 0;
     nowTime = 0;
     nextTime = 0;
-    datei->lese( (char*)&nextTime, 8 );
+    datei->lese( (char *)&nextTime, 8 );
     timePuffer = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -309,14 +279,14 @@ bool Men
         me.id = ME_RRechts;
         if( ak == 0 )
         {
-            datei->lese( (char*)&me.mx, 4 );
-            datei->lese( (char*)&me.my, 4 );
+            datei->lese( (char *)&me.mx, 4 );
+            datei->lese( (char *)&me.my, 4 );
             me.id = ME_RLinks;
         }
         if( datei->istEnde() )
             nextTime = -1;
         else
-            datei->lese( (char*)&nextTime, 8 );
+            datei->lese( (char *)&nextTime, 8 );
         me.verarbeitet = 0;
         map->doPublicMausEreignis( me );
     }
@@ -345,40 +315,26 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüWiederhohlung *MenüWiederhohlung::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüWiederhohlung *MenüWiederhohlung::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
-}
-
 // Inhalt der MenüStatistik Klasse aus Menü.h
 // Konstruktor
-MenüStatistik::MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
+MenüStatistik::MenüStatistik( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
 {
     this->klient = klient;
     wiederH = 0;
-    ansichtT = initTextFeld( 245, 10, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
-    ansicht = initAuswahlBox( 295, 10, 120, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
-    optionen = initKontrollKnopf( 425, 10, 130, 20, zSchrift, KontrollKnopf::Style::Normal, "Optionen beachten" );
-    worldBestT = initObjTabelle( 150, 40, 500, 120, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, { "Ansehen", 55, 0, 0 }, { "Breite", 70, 0, 0 },{ "Height", 70, 0, 0 },{ "Farben", 65, 0, 0 },{ "Tempo", 60, 0, 0 } }, 20 );
-    gesammtT = initObjTabelle( 150, 170, 500, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 65, 0, 0 }, { "Tempo", 60, 0, 0 } }, 20 );
-    optionenT = initObjTabelle( 150, 170, 500, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 65, 0, 0 }, { "Tempo", 60, 0, 0 } }, 20 );
-    gesammtD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
-    optionenD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
-    removen = initKnopf( 10, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurücksetzen" );
-    zurück = initKnopf( 350, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurück" );
-    schrift = zSchrift->getThis();
-    tr = new TextRenderer( schrift->getThis() );
-    screen = zScreen->getThis();
+    ansichtT = initTextFeld( 245, 10, 50, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
+    ansicht = initAuswahlBox( 295, 10, 120, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
+    optionen = initKontrollKnopf( 425, 10, 130, 20, uiFactory, KontrollKnopf::Style::Normal, "Optionen beachten" );
+    worldBestT = initObjTabelle( 150, 40, 500, 120, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, { "Ansehen", 55, 0, 0 }, { "Breite", 70, 0, 0 },{ "Height", 70, 0, 0 },{ "Farben", 65, 0, 0 },{ "Tempo", 60, 0, 0 } }, 20 );
+    gesammtT = initObjTabelle( 150, 170, 500, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 65, 0, 0 }, { "Tempo", 60, 0, 0 } }, 20 );
+    optionenT = initObjTabelle( 150, 170, 500, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Height", 70, 0, 0 }, { "Farben", 65, 0, 0 }, { "Tempo", 60, 0, 0 } }, 20 );
+    gesammtD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
+    optionenD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
+    removen = initKnopf( 10, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurücksetzen" );
+    zurück = initKnopf( 350, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück" );
+    tr = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
     asyncFinished = 1;
+    this->uiFactory = uiFactory;
 }
 
 // Destruktor
@@ -399,21 +355,18 @@ Men
     optionenD->release();
     removen->release();
     zurück->release();
-    schrift->release();
     klient->release();
     if( wiederH )
         wiederH->release();
-    screen->release();
 }
 
 // nicht constant
 void MenüStatistik::reset()
 {
-    ObjTabelle *tmpWBT = (ObjTabelle*)worldBestT->getThis();
-    KSGClient::MinigameServerClient *tmpKlient = klient->getThis();
-    Schrift *tmpSchrift = schrift->getThis();
+    ObjTabelle *tmpWBT = dynamic_cast<ObjTabelle *>( worldBestT->getThis() );
+    KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
     asyncFinished = 0;
-    new AsynchronCall( [ this, tmpWBT, tmpKlient, tmpSchrift ]()
+    new AsynchronCall( [this, tmpWBT, tmpKlient]()
     {
         Array< int > score;
         RCArray< Text > player;
@@ -421,36 +374,36 @@ void Men
         int anz = tmpKlient->getMinigameBestscoreList( "Bloecke", &score, &player, &option );
         for( int i = 0; i < anz; i++ )
         {
-            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
-            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
+            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
+            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
             Text optionen = option.z( i )->getText();
             Text *breite = optionen.getTeilText( optionen.positionVon( '=' ) + 1, optionen.positionVon( ',' ) );
             Text *höhe = optionen.getTeilText( optionen.positionVon( '=', 1 ) + 1, optionen.positionVon( ',', 1 ) );
             Text *farben = optionen.getTeilText( optionen.positionVon( '=', 2 ) + 1, optionen.positionVon( ',', 2 ) );
             Text *geschwindigkeit = optionen.getTeilText( optionen.positionVon( '=', 3 ) + 1 );
-            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
+            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
             breite->release();
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
+            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
             höhe->release();
-            TextFeld *farbenT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, farben->getText() );
+            TextFeld *farbenT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, farben->getText() );
             farben->release();
-            TextFeld *geschwindigkeitT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, geschwindigkeit->getText() );
+            TextFeld *geschwindigkeitT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, geschwindigkeit->getText() );
             geschwindigkeit->release();
-            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, tmpSchrift, Knopf::Style::Normal, "Ansehen" );
-            ansehenK->setMausEreignis( [ this, optionen ]( void *p, void *obj, MausEreignis me ) -> bool
+            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, uiFactory, Knopf::Style::Normal, "Ansehen" );
+            ansehenK->setMausEreignis( [this, optionen]( void *p, void *obj, MausEreignis me ) -> bool
             {
                 if( me.id == ME_RLinks && !me.verarbeitet )
                 {
-                    ( (Knopf*)obj )->removeStyle( Knopf::Style::Erlaubt );
+                    ( (Knopf *)obj )->removeStyle( Knopf::Style::Erlaubt );
                     getThis();
-                    new AsynchronCall( [ this, optionen, obj ]()
+                    new AsynchronCall( [this, optionen, obj]()
                     {
                         Datei *d = klient->downloadGameCapture( "Bloecke", optionen );
-                        ( (Knopf*)obj )->addStyle( Knopf::Style::Erlaubt );
+                        ( (Knopf *)obj )->addStyle( Knopf::Style::Erlaubt );
                         if( wiederH )
-                            wiederH = wiederH->release();
+                            wiederH = (MenüWiederhohlung *)wiederH->release();
                         Text options = optionen.getText();
-                        wiederH = new MenüWiederhohlung( schrift, screen, d, &options );
+                        wiederH = new MenüWiederhohlung( uiFactory, d, &options );
                         release();
                     } );
                 }
@@ -467,7 +420,6 @@ void Men
         }
         tmpKlient->release();
         tmpWBT->release();
-        tmpSchrift->release();
     }, &asyncFinished );
     InitDatei *opd = new InitDatei( "data/Minigames/Blöcke/data/optionen.ini" );
     opd->laden();
@@ -505,12 +457,12 @@ void Men
         if( p >= 0 )
         {
             fertig[ p ] = 1;
-            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
-            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
-            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
-            TextFeld *farbenT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
-            TextFeld *tempoT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
+            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
+            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
+            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
+            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
+            TextFeld *farbenT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
+            TextFeld *tempoT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
             gesammtT->addZeile( Text() += p );
             gesammtT->setZeichnungZ( 0, i + 1, scoreT );
             gesammtT->setZeichnungZ( 1, i + 1, datumT );
@@ -525,12 +477,12 @@ void Men
             {
                 optionenT->addZeile( Text() += p );
                 int n = optionenT->getZeilenNummer( Text() += p );
-                optionenT->setZeichnungZ( 0, n, scoreT->getThis() );
-                optionenT->setZeichnungZ( 1, n, datumT->getThis() );
-                optionenT->setZeichnungZ( 2, n, breiteT->getThis() );
-                optionenT->setZeichnungZ( 3, n, höheT->getThis() );
-                optionenT->setZeichnungZ( 4, n, farbenT->getThis() );
-                optionenT->setZeichnungZ( 5, n, tempoT->getThis() );
+                optionenT->setZeichnungZ( 0, n, dynamic_cast<Zeichnung *>( scoreT->getThis() ) );
+                optionenT->setZeichnungZ( 1, n, dynamic_cast<Zeichnung *>( datumT->getThis() ) );
+                optionenT->setZeichnungZ( 2, n, dynamic_cast<Zeichnung *>( breiteT->getThis() ) );
+                optionenT->setZeichnungZ( 3, n, dynamic_cast<Zeichnung *>( höheT->getThis() ) );
+                optionenT->setZeichnungZ( 4, n, dynamic_cast<Zeichnung *>( farbenT->getThis() ) );
+                optionenT->setZeichnungZ( 5, n, dynamic_cast<Zeichnung *>( tempoT->getThis() ) );
                 if( !omS )
                     omS = maxScore;
                 oAnz++;
@@ -649,7 +601,7 @@ bool Men
     {
         bool ret = wiederH->tick( tickVal );
         if( wiederH->istBeendet() )
-            wiederH = wiederH->release();
+            wiederH = (MenüWiederhohlung *)wiederH->release();
         return ret;
     }
     bool ret = ansicht->tick( tickVal );
@@ -709,44 +661,29 @@ bool Men
     return wiederH != 0;
 }
 
-// Reference Counting
-MenüStatistik *MenüStatistik::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüStatistik *MenüStatistik::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüOptionen aus Menü.h
 // Konstruktor
-MenüOptionen::MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen )
+MenüOptionen::MenüOptionen( UIInit &uiFactory )
+    : ReferenceCounter()
 {
-    breiteT = initTextFeld( 310, 140, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
-    breite = initTextFeld( 440, 140, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    breiteT = initTextFeld( 310, 140, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
+    breite = initTextFeld( 440, 140, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     breite->setTastaturEreignis( _nurNummernTE );
-    höheT = initTextFeld( 310, 180, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Height:" );
-    höhe = initTextFeld( 440, 180, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    höheT = initTextFeld( 310, 180, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Height:" );
+    höhe = initTextFeld( 440, 180, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     höhe->setTastaturEreignis( _nurNummernTE );
-    bAnzahlT = initTextFeld( 310, 220, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Verschiedene Farben:" );
-    bAnzahl = initTextFeld( 440, 220, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    bAnzahlT = initTextFeld( 310, 220, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Verschiedene Farben:" );
+    bAnzahl = initTextFeld( 440, 220, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     bAnzahl->setTastaturEreignis( _nurNummernTE );
-    tempoT = initTextFeld( 310, 260, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
-    tempo = initTextFeld( 440, 260, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    tempoT = initTextFeld( 310, 260, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
+    tempo = initTextFeld( 440, 260, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     tempo->setTastaturEreignis( _nurNummernTE );
-    fortsetzen = initKontrollKnopf( 310, 300, 180, 20, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
+    fortsetzen = initKontrollKnopf( 310, 300, 180, 20, uiFactory, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
     fortsetzen->setMausEreignis( _ret1ME );
-    abbrechen = initKnopf( 310, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
-    ok = initKnopf( 405, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
+    abbrechen = initKnopf( 310, 340, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Abbrechen" );
+    ok = initKnopf( 405, 340, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Ok" );
     beendet = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -900,33 +837,19 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüOptionen *MenüOptionen::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüOptionen *MenüOptionen::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der Menü Klasse aus Menü.h
 // Konstruktor
-Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
-{
-    spielen = initKnopf( 350, 180, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Spielen" );
-    spielenF = new MenüSpiel( zSchrift, zScreen, klient->getThis() );
-    optionen = initKnopf( 350, 220, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Optionen" );
-    optionenF = new MenüOptionen( zSchrift, zScreen );
-    statistik = initKnopf( 350, 260, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Statistik" );
-    statistikF = new MenüStatistik( zSchrift, zScreen, klient );
-    beenden = initKnopf( 350, 300, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+Menü::Menü( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
+{
+    spielen = initKnopf( 350, 180, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Spielen" );
+    spielenF = new MenüSpiel( uiFactory, dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() ) );
+    optionen = initKnopf( 350, 220, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Optionen" );
+    optionenF = new MenüOptionen( uiFactory );
+    statistik = initKnopf( 350, 260, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Statistik" );
+    statistikF = new MenüStatistik( uiFactory, klient );
+    beenden = initKnopf( 350, 300, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     ram = new LRahmen();
     ram->setFarbe( 0xFFFFFFFF );
     beendet = 0;
@@ -936,7 +859,6 @@ Men
     bgd->leseDaten( 0 );
     hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
     bgd->release();
-    ref = 1;
 }
 
 // Destruktor
@@ -1089,19 +1011,4 @@ void Men
 bool Menü::istBeendet() const
 {
     return beendet;
-}
-
-// Reference Counting
-Menü *Menü::getThis()
-{
-    ref++;
-    return this;
-}
-
-Menü *Menü::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Blöcke/Menü.h

@@ -6,63 +6,56 @@
 #include <Diagramm.h>
 #include <AuswahlBox.h>
 #include <Datei.h>
+#include <UIInitialization.h>
 #include "Map.h"
 
 using namespace Framework;
 
-class MenüVerloren
+class MenüVerloren : public virtual ReferenceCounter
 {
 private:
-	Rahmen *ram;
-	TextFeld *verloren;
-	Knopf *neu;
-	Knopf *beenden;
-	int ref;
+    Rahmen *ram;
+    TextFeld *verloren;
+    Knopf *neu;
+    Knopf *beenden;
 
 public:
-	// Kontruktor
-	MenüVerloren( Schrift *zSchrift );
-	// Destruktor
-	~MenüVerloren();
-	// nicht constant
-	int doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// Reference Counting
-	MenüVerloren *getThis();
-	MenüVerloren *release();
+    // Kontruktor
+    MenüVerloren( UIInit &uiFactory );
+    // Destruktor
+    ~MenüVerloren();
+    // nicht constant
+    int doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
 };
 
-class MenüSpiel
+class MenüSpiel : public virtual ReferenceCounter
 {
 private:
-	TextFeld *scoreT;
-	Knopf *beenden;
-	Map *map;
-	MenüVerloren *verloren;
+    TextFeld *scoreT;
+    Knopf *beenden;
+    Map *map;
+    MenüVerloren *verloren;
     double timePuffer;
-	bool beendet;
-	int ref;
+    bool beendet;
 
 public:
-	// Konstruktor
-	MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
-	// Destruktor
-	~MenüSpiel();
-	// nicht constant
-	void reset();
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	bool istBeendet() const;
-	// Reference Counting
-	MenüSpiel *getThis();
-	MenüSpiel *release();
+    // Konstruktor
+    MenüSpiel( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
+    // Destruktor
+    ~MenüSpiel();
+    // nicht constant
+    void reset();
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    bool istBeendet() const;
 };
 
-class MenüWiederhohlung
+class MenüWiederhohlung : public virtual ReferenceCounter
 {
 private:
     TextFeld *scoreT;
@@ -73,11 +66,10 @@ private:
     double nextTime;
     bool beendet;
     double timePuffer;
-    int ref;
 
 public:
     // Konstruktor
-    MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen );
+    MenüWiederhohlung( UIInit &uiFactory, Datei *datei, Text *zOptionen );
     // Destruktor
     ~MenüWiederhohlung();
     // nicht constant
@@ -87,118 +79,102 @@ public:
     void render( Bild &zRObj );
     // constant
     bool istBeendet() const;
-    // Reference Counting
-    MenüWiederhohlung *getThis();
-    MenüWiederhohlung *release();
 };
 
-class MenüStatistik
+class MenüStatistik : public virtual ReferenceCounter
 {
 private:
-	TextFeld *ansichtT;
-	AuswahlBox *ansicht;
-	KontrollKnopf *optionen;
-	ObjTabelle *gesammtT;
-	ObjTabelle *optionenT;
+    TextFeld *ansichtT;
+    AuswahlBox *ansicht;
+    KontrollKnopf *optionen;
+    ObjTabelle *gesammtT;
+    ObjTabelle *optionenT;
     ObjTabelle *worldBestT;
-	LDiag *gesammtD;
-	LDiag *optionenD;
-	Knopf *removen;
-	Knopf *zurück;
-	Schrift *schrift;
+    LDiag *gesammtD;
+    LDiag *optionenD;
+    Knopf *removen;
+    Knopf *zurück;
     TextRenderer *tr;
     KSGClient::MinigameServerClient *klient;
     MenüWiederhohlung *wiederH;
-    Bildschirm *screen;
+    UIInit uiFactory;
     bool asyncFinished;
-	bool beendet;
-	int ref = 1;
+    bool beendet;
 
 public:
-	// Konstruktor
-	MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
-	// Destruktor
-	~MenüStatistik();
-	// nicht constant
-	void reset();
-	void doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	bool istBeendet() const;
+    // Konstruktor
+    MenüStatistik( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
+    // Destruktor
+    ~MenüStatistik();
+    // nicht constant
+    void reset();
+    void doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    bool istBeendet() const;
     bool istWiederhohlung() const;
-	// Reference Counting
-	MenüStatistik *getThis();
-	MenüStatistik *release();
 };
 
-class MenüOptionen
+class MenüOptionen : public virtual ReferenceCounter
 {
 private:
-	TextFeld *breiteT;
-	TextFeld *breite;
-	TextFeld *höheT;
-	TextFeld *höhe;
-	TextFeld *bAnzahlT;
-	TextFeld *bAnzahl;
-	TextFeld *tempoT;
-	TextFeld *tempo;
-	KontrollKnopf *fortsetzen;
-	Knopf *abbrechen;
-	Knopf *ok;
-	bool beendet;
-	int ref;
+    TextFeld *breiteT;
+    TextFeld *breite;
+    TextFeld *höheT;
+    TextFeld *höhe;
+    TextFeld *bAnzahlT;
+    TextFeld *bAnzahl;
+    TextFeld *tempoT;
+    TextFeld *tempo;
+    KontrollKnopf *fortsetzen;
+    Knopf *abbrechen;
+    Knopf *ok;
+    bool beendet;
 
 public:
-	// Konstruktor
-	MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen );
-	// Destruktor
-	~MenüOptionen();
-	// nicht constant
-	void reset();
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	bool istBeendet() const;
-	// Reference Counting
-	MenüOptionen *getThis();
-	MenüOptionen *release();
+    // Konstruktor
+    MenüOptionen( UIInit &uiFactory );
+    // Destruktor
+    ~MenüOptionen();
+    // nicht constant
+    void reset();
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    bool istBeendet() const;
 };
 
-class Menü
+class Menü : public virtual ReferenceCounter
 {
 private:
-	Knopf *spielen;
-	MenüSpiel *spielenF;
-	Knopf *optionen;
-	MenüOptionen *optionenF;
-	Knopf *statistik;
-	MenüStatistik *statistikF;
-	Knopf *beenden;
-	Bild *hintergrund;
-	Rahmen *ram;
-	bool beendet;
-	int status;
-	int ref;
+    Knopf *spielen;
+    MenüSpiel *spielenF;
+    Knopf *optionen;
+    MenüOptionen *optionenF;
+    Knopf *statistik;
+    MenüStatistik *statistikF;
+    Knopf *beenden;
+    Bild *hintergrund;
+    Rahmen *ram;
+    bool beendet;
+    int status;
 
 public:
-	// Konstruktor
-	Menü( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
-	// Destruktor
-	~Menü();
-	// nicht constant
-	void reset();
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double z );
-	void render( Bild &zRObj );
-	// constant
-	bool istBeendet() const;
-	// Reference Counting
-	Menü *getThis();
-	Menü *release();
+    // Konstruktor
+    Menü( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
+    // Destruktor
+    ~Menü();
+    // nicht constant
+    void reset();
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double z );
+    void render( Bild &zRObj );
+    // constant
+    bool istBeendet() const;
 };
 
 #endif