improved onNeedTooltip Event occurances

Zeichnung.cpp

@@ -1,417 +1,433 @@
 #include "Zeichnung.h"
-#include "MausEreignis.h"
-#include "TastaturEreignis.h"
+
+#include "AlphaFeld.h"
+#include "Bild.h"
+#include "Bildschirm.h"
 #include "Globals.h"
-#include "ToolTip.h"
+#include "MausEreignis.h"
+#include "Rahmen.h"
+#include "Schrift.h"
 #include "Scroll.h"
+#include "TastaturEreignis.h"
 #include "Text.h"
-#include "Rahmen.h"
-#include "AlphaFeld.h"
-#include "Bild.h"
 #include "TextFeld.h"
+#include "ToolTip.h"
 #include "UIInitialization.h"
-#include "Schrift.h"
-#include "Bildschirm.h"
 #ifdef WIN32
-#include <Windows.h>
+#    include <Windows.h>
 #endif
 
 using namespace Framework;
 
 // Inhalt der Zeichnung Klasse aus Zeichnung.h
-// Konstruktor 
+// Konstruktor
 Zeichnung::Zeichnung()
-	: ReferenceCounter(),
-	pos(0, 0),
-	gr(0, 0),
-	makParam(0),
-	takParam(0),
-	mak(0),
-	tak(0),
-	nmakParam(0),
-	ntakParam(0),
-	nMak(0),
-	nTak(0),
-	mausIn(0),
-	toolTip(0),
-	style(0),
-	rend(0),
-	onNeedToolTip(0)
+    : ReferenceCounter(),
+      pos(0, 0),
+      gr(0, 0),
+      makParam(0),
+      takParam(0),
+      mak(0),
+      tak(0),
+      nmakParam(0),
+      ntakParam(0),
+      nMak(0),
+      nTak(0),
+      mausIn(0),
+      toolTip(0),
+      style(0),
+      rend(0),
+      onNeedToolTip(0),
+      toolTipRequested(0)
 {}
 
-// Destruktor 
+// Destruktor
 Zeichnung::~Zeichnung()
 {
-	if (toolTip)
-		toolTip->release();
+    if (toolTip) toolTip->release();
 }
 
 void Zeichnung::doMausEreignis(MausEreignis& me, bool userRet)
 {
-	me.verarbeitet = userRet;
+    me.verarbeitet = userRet;
 }
 
-// Übergibt einen Void Funktionspointer auf eine Aktion die einmalig vom Hauptthread ausgeführt werden soll. (Passiert nach dem Tick)
-void Zeichnung::postAction(std::function< void() > action)
+// Übergibt einen Void Funktionspointer auf eine Aktion die einmalig vom
+// Hauptthread ausgeführt werden soll. (Passiert nach dem Tick)
+void Zeichnung::postAction(std::function<void()> action)
 {
-	actions.push(action);
+    actions.push(action);
 }
 
-// nicht constant 
+// nicht constant
 void Zeichnung::setRender()
 {
-	rend = 1;
-}
-
-void Zeichnung::setToolTipText(const char* txt, Bildschirm* zScreen, Schrift* zSchrift)
-{
-	if (!txt)
-		toolTip = (ToolTip*)toolTip->release();
-	else
-	{
-		if (!toolTip)
-		{
-			toolTip = new ToolTip(zScreen);
-			toolTip->addStyle(ZeichnungHintergrund::Style::Hintergrund | ZeichnungHintergrund::Style::HAlpha | ZeichnungHintergrund::Style::Rahmen | ZeichnungHintergrund::Style::Sichtbar);
-			toolTip->setHintergrundFarbe(0xA0000000);
-			toolTip->setRahmenFarbe(0xFFFFFFFF);
-			toolTip->setRahmenBreite(1);
-			if (mausIn && toolTip)
-				toolTip->setMausIn(1);
-		}
-		UIInit init = defaultUI(zSchrift, zScreen);
-		TextFeld* t = init.createTextFeld(init.initParam);
-		t->setText(txt);
-		t->setSize(t->zTextRenderer()->getTextBreite(txt), t->zTextRenderer()->getTextHeight(txt));
-		toolTip->addMember(t);
-	}
-}
-
-// setzt eine Funktion, die beim erstmaligen gebrauch des tooltips einen tooltip erstellt, falls es noch keinen gibt
+    rend = 1;
+}
+
+void Zeichnung::setToolTipText(
+    const char* txt, Bildschirm* zScreen, Schrift* zSchrift)
+{
+    if (!txt)
+        toolTip = (ToolTip*)toolTip->release();
+    else
+    {
+        if (!toolTip)
+        {
+            toolTip = new ToolTip(zScreen);
+            toolTip->addStyle(ZeichnungHintergrund::Style::Hintergrund
+                              | ZeichnungHintergrund::Style::HAlpha
+                              | ZeichnungHintergrund::Style::Rahmen
+                              | ZeichnungHintergrund::Style::Sichtbar);
+            toolTip->setHintergrundFarbe(0xA0000000);
+            toolTip->setRahmenFarbe(0xFFFFFFFF);
+            toolTip->setRahmenBreite(1);
+            if (mausIn && toolTip) toolTip->setMausIn(1);
+        }
+        UIInit init = defaultUI(zSchrift, zScreen);
+        TextFeld* t = init.createTextFeld(init.initParam);
+        t->setText(txt);
+        t->setSize(t->zTextRenderer()->getTextBreite(txt),
+            t->zTextRenderer()->getTextHeight(txt));
+        toolTip->addMember(t);
+    }
+    toolTipRequested = 0;
+}
+
+// setzt eine Funktion, die beim erstmaligen gebrauch des tooltips einen tooltip
+// erstellt, falls es noch keinen gibt
 //  initToolTip: die Funktion
-void Zeichnung::setNeedToolTipEvent(std::function< void(Zeichnung*, Punkt localPos) > onNeedToolTip)
+void Zeichnung::setNeedToolTipEvent(
+    std::function<bool(Zeichnung*, Punkt localPos)> onNeedToolTip)
 {
-	this->onNeedToolTip = onNeedToolTip;
+    this->onNeedToolTip = onNeedToolTip;
 }
 
 // legt den tooltip fest
 // tt: der tooltip
 void Zeichnung::setToolTipZ(ToolTip* tt)
 {
-	if (toolTip)
-		toolTip->release();
-	toolTip = tt;
-	if (mausIn && toolTip)
-		toolTip->setMausIn(1);
+    if (toolTip) toolTip->release();
+    toolTip = tt;
+    if (mausIn && toolTip) toolTip->setMausIn(1);
+    toolTipRequested = 0;
 }
 
 void Zeichnung::lockZeichnung()
 {
-	cs.lock();
+    cs.lock();
 }
 
 void Zeichnung::unlockZeichnung()
 {
-	cs.unlock();
+    cs.unlock();
 }
 
-void Zeichnung::setMausEreignisParameter(void* p) // setzt den Parameter vom Maus Ereignis
+void Zeichnung::setMausEreignisParameter(
+    void* p) // setzt den Parameter vom Maus Ereignis
 {
-	makParam = p;
+    makParam = p;
 }
 
-void Zeichnung::setTastaturEreignisParameter(void* p) // setzt den Parameter vom Tastatur Ereignis
+void Zeichnung::setTastaturEreignisParameter(
+    void* p) // setzt den Parameter vom Tastatur Ereignis
 {
-	takParam = p;
+    takParam = p;
 }
 
 void Zeichnung::setMausEreignis(MausAktion ak) // setzt das Maus Ereignis
 {
-	mak = ak;
+    mak = ak;
 }
 
-void Zeichnung::setTastaturEreignis(TastaturAktion ak) // setzt das TastaturEreignis
+void Zeichnung::setTastaturEreignis(
+    TastaturAktion ak) // setzt das TastaturEreignis
 {
-	tak = ak;
+    tak = ak;
 }
 
-void Zeichnung::setNMausEreignisParameter(void* p) // setzt den Parameter vom Maus Ereignis
+void Zeichnung::setNMausEreignisParameter(
+    void* p) // setzt den Parameter vom Maus Ereignis
 {
-	nmakParam = p;
+    nmakParam = p;
 }
 
-void Zeichnung::setNTastaturEreignisParameter(void* p) // setzt den Parameter vom Tastatur Ereignis
+void Zeichnung::setNTastaturEreignisParameter(
+    void* p) // setzt den Parameter vom Tastatur Ereignis
 {
-	ntakParam = p;
+    ntakParam = p;
 }
 
 void Zeichnung::setNMausEreignis(MausAktion ak) // setzt das Maus Ereignis
 {
-	nMak = ak;
+    nMak = ak;
 }
 
-void Zeichnung::setNTastaturEreignis(TastaturAktion ak) // setzt das TastaturEreignis
+void Zeichnung::setNTastaturEreignis(
+    TastaturAktion ak) // setzt das TastaturEreignis
 {
-	nTak = ak;
+    nTak = ak;
 }
 
 void Zeichnung::doPublicMausEreignis(MausEreignis& me) // ruft Mak auf
 {
-	bool lock = hatStyle(Style::MELockZeichnung);
-	if (lock)
-		lockZeichnung();
-	bool inside = istPunktInnen(me.mx, me.my);
-	if (!me.insideParent || me.verarbeitet || !inside)
-	{
-		if (mausIn)
-		{
-			mausIn = 0;
-			if (toolTip)
-				toolTip->setMausIn(0);
-			MausEreignis me2;
-			me2.id = ME_Leaves;
-			me2.mx = me.mx - pos.x;
-			me2.my = me.my - pos.y;
-			me2.verarbeitet = 0;
-			me2.insideParent = me.insideParent;
-			bool userRet = mak && mak(makParam, this, me2);
-			doMausEreignis(me2, userRet);
-		}
-	}
-	if (!inside && me.id == ME_PLinks)
-		removeStyle(Style::Fokus);
-	if ((me.verarbeitet && hatStyleNicht(Style::MEIgnoreVerarbeitet)) || (!inside && hatStyleNicht(Style::MEIgnoreInside)) ||
-		(hatStyleNicht(Style::Sichtbar) && hatStyleNicht(Style::MEIgnoreSichtbar)))
-	{
-		if (lock)
-			unlockZeichnung();
-		return;
-	}
-	if (inside && me.id == ME_PLinks)
-		addStyle(Style::Fokus);
-	if (me.insideParent && !mausIn && me.id != ME_Leaves && inside && !me.verarbeitet && hatStyle(Style::Sichtbar))
-	{
-		mausIn = 1;
-		if (toolTip)
-			toolTip->setMausIn(1);
-		else if (onNeedToolTip)
-			onNeedToolTip(this, Punkt(me.mx - pos.x, me.my - pos.y));
-		MausEreignis me2;
-		me2.id = ME_Betritt;
-		me2.mx = me.mx - pos.x;
-		me2.my = me.my - pos.y;
-		me2.verarbeitet = 0;
-		me2.insideParent = 1;
-		bool userRet = mak && mak(makParam, this, me2);
-		doMausEreignis(me2, userRet);
-	}
-	Punkt old = Punkt(me.mx, me.my);
-	me.mx -= pos.x, me.my -= pos.y;
-	if (me.insideParent || hatStyle(Style::MEIgnoreParentInside))
-	{
-		bool userRet = hatStyle(Style::Erlaubt) && (me.verarbeitet || !me.insideParent || (inside && mak && mak(makParam, this, me)));
-		bool vera = me.verarbeitet;
-		doMausEreignis(me, userRet);
-		if (nMak && me.verarbeitet && !vera && hatStyle(Style::Erlaubt) && me.insideParent && inside)
-			me.verarbeitet = nMak(nmakParam, this, me);
-	}
-	me.mx = old.x, me.my = old.y;
-	if (lock)
-		unlockZeichnung();
+    bool lock = hatStyle(Style::MELockZeichnung);
+    if (lock) lockZeichnung();
+    bool inside = istPunktInnen(me.mx, me.my);
+    if (!me.insideParent || me.verarbeitet || !inside)
+    {
+        if (mausIn)
+        {
+            mausIn = 0;
+            if (toolTip) toolTip->setMausIn(0);
+            MausEreignis me2;
+            me2.id = ME_Leaves;
+            me2.mx = me.mx - pos.x;
+            me2.my = me.my - pos.y;
+            me2.verarbeitet = 0;
+            me2.insideParent = me.insideParent;
+            bool userRet = mak && mak(makParam, this, me2);
+            doMausEreignis(me2, userRet);
+        }
+    }
+    if (!inside && me.id == ME_PLinks) removeStyle(Style::Fokus);
+    if ((me.verarbeitet && hatStyleNicht(Style::MEIgnoreVerarbeitet))
+        || (!inside && hatStyleNicht(Style::MEIgnoreInside))
+        || (hatStyleNicht(Style::Sichtbar)
+            && hatStyleNicht(Style::MEIgnoreSichtbar)))
+    {
+        if (lock) unlockZeichnung();
+        return;
+    }
+    if (inside && me.id == ME_PLinks) addStyle(Style::Fokus);
+    if (me.insideParent && !mausIn && me.id != ME_Leaves && inside
+        && !me.verarbeitet && hatStyle(Style::Sichtbar))
+    {
+        mausIn = 1;
+        if (toolTip)
+            toolTip->setMausIn(1);
+        else if (onNeedToolTip && !toolTipRequested)
+        {
+            toolTipRequested
+                = onNeedToolTip(this, Punkt(me.mx - pos.x, me.my - pos.y));
+        }
+        MausEreignis me2;
+        me2.id = ME_Betritt;
+        me2.mx = me.mx - pos.x;
+        me2.my = me.my - pos.y;
+        me2.verarbeitet = 0;
+        me2.insideParent = 1;
+        bool userRet = mak && mak(makParam, this, me2);
+        doMausEreignis(me2, userRet);
+    }
+    else if (me.insideParent && mausIn && me.id != ME_Leaves && inside
+             && !me.verarbeitet && hatStyle(Style::Sichtbar) && !toolTip
+             && onNeedToolTip && !toolTipRequested)
+    {
+        toolTipRequested
+            = onNeedToolTip(this, Punkt(me.mx - pos.x, me.my - pos.y));
+    }
+    Punkt old = Punkt(me.mx, me.my);
+    me.mx -= pos.x, me.my -= pos.y;
+    if (me.insideParent || hatStyle(Style::MEIgnoreParentInside))
+    {
+        bool userRet = hatStyle(Style::Erlaubt)
+                    && (me.verarbeitet || !me.insideParent
+                        || (inside && mak && mak(makParam, this, me)));
+        bool vera = me.verarbeitet;
+        doMausEreignis(me, userRet);
+        if (nMak && me.verarbeitet && !vera && hatStyle(Style::Erlaubt)
+            && me.insideParent && inside)
+            me.verarbeitet = nMak(nmakParam, this, me);
+    }
+    me.mx = old.x, me.my = old.y;
+    if (lock) unlockZeichnung();
 }
 
 void Zeichnung::doTastaturEreignis(TastaturEreignis& te) // ruft Tak auf
 {
-	if (te.verarbeitet)
-		return;
-	if (tak)
-		te.verarbeitet |= tak(takParam, this, te);
-	if (nTak && te.verarbeitet)
-		te.verarbeitet = nTak(ntakParam, this, te);
+    if (te.verarbeitet) return;
+    if (tak) te.verarbeitet |= tak(takParam, this, te);
+    if (nTak && te.verarbeitet) te.verarbeitet = nTak(ntakParam, this, te);
 }
 
 void Zeichnung::setPosition(const Punkt& pos) // setzt die position
 {
-	lockZeichnung();
-	if (this->pos != pos)
-		rend = 1;
-	this->pos = pos;
-	unlockZeichnung();
+    lockZeichnung();
+    if (this->pos != pos) rend = 1;
+    this->pos = pos;
+    unlockZeichnung();
 }
 
 void Zeichnung::setX(int xPos)
 {
-	lockZeichnung();
-	if (pos.x != xPos)
-	{
-		rend = 1;
-		pos.x = xPos;
-	}
-	unlockZeichnung();
+    lockZeichnung();
+    if (pos.x != xPos)
+    {
+        rend = 1;
+        pos.x = xPos;
+    }
+    unlockZeichnung();
 }
 
 void Zeichnung::setY(int yPos)
 {
-	lockZeichnung();
-	if (pos.y != yPos)
-	{
-		rend = 1;
-		pos.y = yPos;
-	}
-	unlockZeichnung();
+    lockZeichnung();
+    if (pos.y != yPos)
+    {
+        rend = 1;
+        pos.y = yPos;
+    }
+    unlockZeichnung();
 }
 
 void Zeichnung::setSize(const Punkt& gr) // setzt die Größe
 {
-	lockZeichnung();
-	if (this->gr != gr)
-		rend = 1;
-	this->gr = gr;
-	unlockZeichnung();
+    lockZeichnung();
+    if (this->gr != gr) rend = 1;
+    this->gr = gr;
+    unlockZeichnung();
 }
 
 void Zeichnung::setPosition(int x, int y) // setzt die position
 {
-	setPosition(Punkt(x, y));
+    setPosition(Punkt(x, y));
 }
 
 void Zeichnung::setSize(int x, int y) // setzt die Größe
 {
-	setSize(Punkt(x, y));
+    setSize(Punkt(x, y));
 }
 
 void Zeichnung::setWidth(int width)
 {
-	lockZeichnung();
-	if (this->gr.x != width)
-		rend = 1;
-	gr.x = width;
-	unlockZeichnung();
+    lockZeichnung();
+    if (this->gr.x != width) rend = 1;
+    gr.x = width;
+    unlockZeichnung();
 }
 
 void Zeichnung::setHeight(int height)
 {
-	lockZeichnung();
-	if (this->gr.y != height)
-		rend = 1;
-	gr.y = height;
-	unlockZeichnung();
+    lockZeichnung();
+    if (this->gr.y != height) rend = 1;
+    gr.y = height;
+    unlockZeichnung();
 }
 
 bool Zeichnung::tick(double tickval)
 {
-	while (!actions.empty())
-	{
-		actions.front()();
-		actions.pop();
-	}
-	bool r = rend;
-	rend = 0;
-	return r;
+    while (!actions.empty())
+    {
+        actions.front()();
+        actions.pop();
+    }
+    bool r = rend;
+    rend = 0;
+    return r;
 }
 
 void Zeichnung::setStyle(__int64 style) // setzt den Style des Text Feldes
 {
-	if (this->style != style)
-	{
-		this->style = style;
-		rend = 1;
-	}
+    if (this->style != style)
+    {
+        this->style = style;
+        rend = 1;
+    }
 }
 
 void Zeichnung::setStyle(__int64 style, bool add_remove)
 {
-	if (add_remove && (this->style | style) != this->style)
-	{
-		this->style |= style;
-		rend = 1;
-	}
-	else if (!add_remove && (this->style & ~style) != this->style)
-	{
-		if (toolTip && (style | Style::Sichtbar) == style)
-			toolTip->setMausIn(0);
-		this->style &= ~style;
-		rend = 1;
-	}
+    if (add_remove && (this->style | style) != this->style)
+    {
+        this->style |= style;
+        rend = 1;
+    }
+    else if (!add_remove && (this->style & ~style) != this->style)
+    {
+        if (toolTip && (style | Style::Sichtbar) == style)
+            toolTip->setMausIn(0);
+        this->style &= ~style;
+        rend = 1;
+    }
 }
 
 void Zeichnung::addStyle(__int64 style)
 {
-	if ((this->style | style) != this->style)
-	{
-		this->style |= style;
-		rend = 1;
-	}
+    if ((this->style | style) != this->style)
+    {
+        this->style |= style;
+        rend = 1;
+    }
 }
 
 void Zeichnung::removeStyle(__int64 style)
 {
-	if ((this->style & ~style) != this->style)
-	{
-		if (toolTip && (style | Style::Sichtbar) == style)
-			toolTip->setMausIn(0);
-		this->style &= ~style;
-		rend = 1;
-	}
+    if ((this->style & ~style) != this->style)
+    {
+        if (toolTip && (style | Style::Sichtbar) == style)
+            toolTip->setMausIn(0);
+        this->style &= ~style;
+        rend = 1;
+    }
 }
 
 void Zeichnung::render(Bild& zRObj)
 {
-	if (toolTip && (style | Style::Sichtbar) == style)
-		toolTip->setZeichnen();
+    if (toolTip && (style | Style::Sichtbar) == style) toolTip->setZeichnen();
 }
 
-// constant 
+// constant
 bool Zeichnung::hatMausEreignis() const // prüft, ob Mak gesetzt ist
 {
-	return mak != 0;
+    return mak != 0;
 }
 
 bool Zeichnung::hatTastaturEreignis() const // prüft, ob Tak gesetzt ist
 {
-	return tak != 0;
+    return tak != 0;
 }
 
 const Punkt& Zeichnung::getPosition() const // gibt die Position zurück
 {
-	return pos;
+    return pos;
 }
 
 const Punkt& Zeichnung::getSize() const // gibt die Größe zurück
 {
-	return gr;
+    return gr;
 }
 
 int Zeichnung::getBreite() const // gibt die Breite zurück
 {
-	return gr.x;
+    return gr.x;
 }
 
 int Zeichnung::getHeight() const // gibt die Höhe zurück
 {
-	return gr.y;
+    return gr.y;
 }
 
 // Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
 int Zeichnung::getInnenBreite() const
 {
-	return gr.x;
+    return gr.x;
 }
 
 // Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
 int Zeichnung::getInnenHeight() const
 {
-	return gr.y;
+    return gr.y;
 }
 
 int Zeichnung::getX() const // gibt X zurück
 {
-	return pos.x;
+    return pos.x;
 }
 
 int Zeichnung::getY() const // gibt Y zurück
 {
-	return pos.y;
+    return pos.y;
 }
 
 // Prüft, ob ein Punkt in diesem Objekt liegt
@@ -419,7 +435,7 @@ int Zeichnung::getY() const // gibt Y zur
 //  return: 1, wenn der punkt innen ist, 0 sonst
 bool Zeichnung::istPunktInnen(Punkt p) const
 {
-	return istPunktInnen(p.x, p.y);
+    return istPunktInnen(p.x, p.y);
 }
 
 // Prüft, ob ein Punkt in diesem Objekt liegt
@@ -428,530 +444,553 @@ bool Zeichnung::istPunktInnen(Punkt p) const
 //  return: 1, wenn der punkt innen ist, 0 sonst
 bool Zeichnung::istPunktInnen(int x, int y) const
 {
-	return x >= pos.x && x <= pos.x + gr.x && y >= pos.y && y <= pos.y + gr.y;
+    return x >= pos.x && x <= pos.x + gr.x && y >= pos.y && y <= pos.y + gr.y;
 }
 
 ToolTip* Zeichnung::getToolTip() const // gibt den ToolTip Text
 {
-	return dynamic_cast<ToolTip*>(toolTip->getThis());
+    return dynamic_cast<ToolTip*>(toolTip->getThis());
 }
 
 ToolTip* Zeichnung::zToolTip() const
 {
-	return toolTip;
+    return toolTip;
 }
 
 bool Zeichnung::hatStyle(__int64 style) const // prüft, ob style vorhanden
 {
-	return (this->style | style) == this->style;
+    return (this->style | style) == this->style;
 }
 
-bool Zeichnung::hatStyleNicht(__int64 style) const // prüft, ob style nicht vorhanden
+bool Zeichnung::hatStyleNicht(
+    __int64 style) const // prüft, ob style nicht vorhanden
 {
-	return (this->style | style) != this->style;
+    return (this->style | style) != this->style;
 }
 
 Zeichnung* Zeichnung::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
 {
-	Zeichnung* obj = new Zeichnung();
-	obj->setPosition(pos);
-	obj->setSize(gr);
-	obj->setMausEreignisParameter(makParam);
-	obj->setTastaturEreignisParameter(takParam);
-	obj->setMausEreignis(mak);
-	obj->setTastaturEreignis(tak);
-	if (toolTip)
-		obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
-	return obj;
+    Zeichnung* obj = new Zeichnung();
+    obj->setPosition(pos);
+    obj->setSize(gr);
+    obj->setMausEreignisParameter(makParam);
+    obj->setTastaturEreignisParameter(takParam);
+    obj->setMausEreignis(mak);
+    obj->setTastaturEreignis(tak);
+    if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
+    return obj;
 }
 
-
 // Inhalt der ZeichnungHintergrund Klasse aus Zeichnung.h
-// Konstruktor 
+// Konstruktor
 ZeichnungHintergrund::ZeichnungHintergrund()
-	: Zeichnung()
+    : Zeichnung()
 {
-	hintergrundFarbe = 0xFF000000;
-	rahmen = 0;
-	hintergrundBild = 0;
-	hintergrundFeld = 0;
-	horizontalScrollBar = 0;
-	vertikalScrollBar = 0;
-	innenPosition.x = 0;
-	innenPosition.y = 0;
-	innenSize.x = 0;
-	innenSize.y = 0;
+    hintergrundFarbe = 0xFF000000;
+    rahmen = 0;
+    hintergrundBild = 0;
+    hintergrundFeld = 0;
+    horizontalScrollBar = 0;
+    vertikalScrollBar = 0;
+    innenPosition.x = 0;
+    innenPosition.y = 0;
+    innenSize.x = 0;
+    innenSize.y = 0;
 }
 
-// Destruktor 
+// Destruktor
 ZeichnungHintergrund::~ZeichnungHintergrund()
 {
-	if (rahmen)
-		rahmen->release();
-	if (hintergrundBild)
-		hintergrundBild->release();
-	if (hintergrundFeld)
-		hintergrundFeld->release();
-	if (horizontalScrollBar)
-		horizontalScrollBar->release();
-	if (vertikalScrollBar)
-		vertikalScrollBar->release();
-}
-
-void ZeichnungHintergrund::setHintergrundBild(Bild* bild) // setzt das Hintergrund Bild
+    if (rahmen) rahmen->release();
+    if (hintergrundBild) hintergrundBild->release();
+    if (hintergrundFeld) hintergrundFeld->release();
+    if (horizontalScrollBar) horizontalScrollBar->release();
+    if (vertikalScrollBar) vertikalScrollBar->release();
+}
+
+void ZeichnungHintergrund::setHintergrundBild(
+    Bild* bild) // setzt das Hintergrund Bild
 {
-	if (!hintergrundBild)
-		hintergrundBild = new Bild();
-	hintergrundBild->neuBild(bild->getBreite(), bild->getHeight(), 0);
-	int* buff1 = hintergrundBild->getBuffer();
-	int* buff2 = bild->getBuffer();
-	for (int i = 0; i < bild->getBreite() * bild->getHeight(); ++i)
-		buff1[i] = buff2[i];
-	bild->release();
-	rend = 1;
+    if (!hintergrundBild) hintergrundBild = new Bild();
+    hintergrundBild->neuBild(bild->getBreite(), bild->getHeight(), 0);
+    int* buff1 = hintergrundBild->getBuffer();
+    int* buff2 = bild->getBuffer();
+    for (int i = 0; i < bild->getBreite() * bild->getHeight(); ++i)
+        buff1[i] = buff2[i];
+    bild->release();
+    rend = 1;
 }
 
-void ZeichnungHintergrund::setHintergrundBildZ(Bild* bild) // setzt einen Zeiger zum Hintergrund Bild
+void ZeichnungHintergrund::setHintergrundBildZ(
+    Bild* bild) // setzt einen Zeiger zum Hintergrund Bild
 {
-	if (hintergrundBild != bild)
-	{
-		if (hintergrundBild)
-			hintergrundBild->release();
-		hintergrundBild = bild;
-		rend = 1;
-	}
+    if (hintergrundBild != bild)
+    {
+        if (hintergrundBild) hintergrundBild->release();
+        hintergrundBild = bild;
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setHintergrundFarbe(int fc) // setzt die Hintergrundfarbe
+void ZeichnungHintergrund::setHintergrundFarbe(
+    int fc) // setzt die Hintergrundfarbe
 {
-	if (hintergrundFarbe != fc)
-	{
-		hintergrundFarbe = fc;
-		rend = 1;
-	}
+    if (hintergrundFarbe != fc)
+    {
+        hintergrundFarbe = fc;
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setAlphaFeldZ(AlphaFeld* buff) // setzt einen Zeiger zum Hintergrund Buffer
+void ZeichnungHintergrund::setAlphaFeldZ(
+    AlphaFeld* buff) // setzt einen Zeiger zum Hintergrund Buffer
 {
-	if (hintergrundFeld != buff)
-	{
-		if (hintergrundFeld)
-			hintergrundFeld->release();
-		hintergrundFeld = buff;
-		rend = 1;
-	}
+    if (hintergrundFeld != buff)
+    {
+        if (hintergrundFeld) hintergrundFeld->release();
+        hintergrundFeld = buff;
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setAlphaFeldStrength(int st) // setzt die Stärke des Hintergrund Buffers
+void ZeichnungHintergrund::setAlphaFeldStrength(
+    int st) // setzt die Stärke des Hintergrund Buffers
 {
-	if (!hintergrundFeld)
-	{
-		hintergrundFeld = new AlphaFeld();
-		rend = 1;
-	}
-	if (hintergrundFeld->getStrength() != st)
-	{
-		hintergrundFeld->setStrength(st);
-		rend = 1;
-	}
+    if (!hintergrundFeld)
+    {
+        hintergrundFeld = new AlphaFeld();
+        rend = 1;
+    }
+    if (hintergrundFeld->getStrength() != st)
+    {
+        hintergrundFeld->setStrength(st);
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setAlphaFeldFarbe(int fc) // setzt die Farbe des Hintergrund Buffers
+void ZeichnungHintergrund::setAlphaFeldFarbe(
+    int fc) // setzt die Farbe des Hintergrund Buffers
 {
-	if (!hintergrundFeld)
-	{
-		hintergrundFeld = new AlphaFeld();
-		rend = 1;
-	}
-	if (hintergrundFeld->getFarbe() != fc)
-	{
-		hintergrundFeld->setFarbe(fc);
-		rend = 1;
-	}
+    if (!hintergrundFeld)
+    {
+        hintergrundFeld = new AlphaFeld();
+        rend = 1;
+    }
+    if (hintergrundFeld->getFarbe() != fc)
+    {
+        hintergrundFeld->setFarbe(fc);
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setRahmenZ(Rahmen* ram) // setzt einen Zeiger zum Rahmen
+void ZeichnungHintergrund::setRahmenZ(
+    Rahmen* ram) // setzt einen Zeiger zum Rahmen
 {
-	if (rahmen != ram)
-	{
-		if (rahmen)
-			rahmen->release();
-		rahmen = ram;
-		rend = 1;
-	}
+    if (rahmen != ram)
+    {
+        if (rahmen) rahmen->release();
+        rahmen = ram;
+        rend = 1;
+    }
 }
 
-void ZeichnungHintergrund::setRahmenBreite(int br) // setzt die Breite des Rahmens
+void ZeichnungHintergrund::setRahmenBreite(
+    int br) // setzt die Breite des Rahmens
 {
-	if (!rahmen)
-	{
-		rahmen = new LRahmen();
-		rend = 1;
-	}
-	if (rahmen->getRBreite() != br)
-	{
-		rahmen->setRamenBreite(br);
-		rend = 1;
-	}
+    if (!rahmen)
+    {
+        rahmen = new LRahmen();
+        rend = 1;
+    }
+    if (rahmen->getRBreite() != br)
+    {
+        rahmen->setRamenBreite(br);
+        rend = 1;
+    }
 }
 
 void ZeichnungHintergrund::setRahmenFarbe(int fc) // setzt die Farbe des Rahmens
 {
-	if (!rahmen)
-	{
-		rahmen = new LRahmen();
-		rend = 1;
-	}
-	if (rahmen->getFarbe() != fc)
-	{
-		rahmen->setFarbe(fc);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setVertikalKlickScroll(int ks) // setzt die vertikale Scroll geschwindigkeit
-{
-	if (!vertikalScrollBar)
-	{
-		vertikalScrollBar = new VScrollBar();
-		rend = 1;
-	}
-	if (vertikalScrollBar->getKlickScroll() != ks)
-	{
-		vertikalScrollBar->setKlickScroll(ks);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setVertikalScrollPos(int pos) // setzt die vertikale Scroll Position
-{
-	if (!vertikalScrollBar)
-	{
-		vertikalScrollBar = new VScrollBar();
-		rend = 1;
-	}
-	if (vertikalScrollBar && vertikalScrollBar->getScroll() != pos)
-	{
-		vertikalScrollBar->scroll(pos);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setVertikalScrollFarbe(int f, int bgF) // setzt die scroll Farbe
-{
-	if (!vertikalScrollBar)
-	{
-		vertikalScrollBar = new VScrollBar();
-		rend = 1;
-	}
-	if (vertikalScrollBar && (vertikalScrollBar->getFarbe() != f || vertikalScrollBar->getBgFarbe() != bgF))
-	{
-		vertikalScrollBar->setFarbe(f);
-		vertikalScrollBar->setBgFarbe(bgF, bgF != 0);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setHorizontalKlickScroll(int ks) // setzt die horizontale Scroll geschwindigkeit
-{
-	if (!horizontalScrollBar)
-	{
-		horizontalScrollBar = new HScrollBar();
-		rend = 1;
-	}
-	if (horizontalScrollBar && horizontalScrollBar->getKlickScroll() != ks)
-	{
-		horizontalScrollBar->setKlickScroll(ks);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setHorizontalScrollPos(int pos) // setzt die horizontale Scroll Position
-{
-	if (!horizontalScrollBar)
-	{
-		horizontalScrollBar = new HScrollBar();
-		rend = 1;
-	}
-	if (horizontalScrollBar && horizontalScrollBar->getScroll() != pos)
-	{
-		horizontalScrollBar->scroll(pos);
-		rend = 1;
-	}
-}
-
-void ZeichnungHintergrund::setHorizontalScrollFarbe(int f, int bgF) // setzt die scroll Farbe
-{
-	if (!horizontalScrollBar)
-	{
-		horizontalScrollBar = new HScrollBar();
-		rend = 1;
-	}
-	if (horizontalScrollBar && (horizontalScrollBar->getFarbe() != f || horizontalScrollBar->getBgFarbe() != bgF))
-	{
-		horizontalScrollBar->setFarbe(f);
-		horizontalScrollBar->setBgFarbe(bgF, bgF != 0);
-		rend = 1;
-	}
+    if (!rahmen)
+    {
+        rahmen = new LRahmen();
+        rend = 1;
+    }
+    if (rahmen->getFarbe() != fc)
+    {
+        rahmen->setFarbe(fc);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setVertikalKlickScroll(
+    int ks) // setzt die vertikale Scroll geschwindigkeit
+{
+    if (!vertikalScrollBar)
+    {
+        vertikalScrollBar = new VScrollBar();
+        rend = 1;
+    }
+    if (vertikalScrollBar->getKlickScroll() != ks)
+    {
+        vertikalScrollBar->setKlickScroll(ks);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setVertikalScrollPos(
+    int pos) // setzt die vertikale Scroll Position
+{
+    if (!vertikalScrollBar)
+    {
+        vertikalScrollBar = new VScrollBar();
+        rend = 1;
+    }
+    if (vertikalScrollBar && vertikalScrollBar->getScroll() != pos)
+    {
+        vertikalScrollBar->scroll(pos);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setVertikalScrollFarbe(
+    int f, int bgF) // setzt die scroll Farbe
+{
+    if (!vertikalScrollBar)
+    {
+        vertikalScrollBar = new VScrollBar();
+        rend = 1;
+    }
+    if (vertikalScrollBar
+        && (vertikalScrollBar->getFarbe() != f
+            || vertikalScrollBar->getBgFarbe() != bgF))
+    {
+        vertikalScrollBar->setFarbe(f);
+        vertikalScrollBar->setBgFarbe(bgF, bgF != 0);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setHorizontalKlickScroll(
+    int ks) // setzt die horizontale Scroll geschwindigkeit
+{
+    if (!horizontalScrollBar)
+    {
+        horizontalScrollBar = new HScrollBar();
+        rend = 1;
+    }
+    if (horizontalScrollBar && horizontalScrollBar->getKlickScroll() != ks)
+    {
+        horizontalScrollBar->setKlickScroll(ks);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setHorizontalScrollPos(
+    int pos) // setzt die horizontale Scroll Position
+{
+    if (!horizontalScrollBar)
+    {
+        horizontalScrollBar = new HScrollBar();
+        rend = 1;
+    }
+    if (horizontalScrollBar && horizontalScrollBar->getScroll() != pos)
+    {
+        horizontalScrollBar->scroll(pos);
+        rend = 1;
+    }
+}
+
+void ZeichnungHintergrund::setHorizontalScrollFarbe(
+    int f, int bgF) // setzt die scroll Farbe
+{
+    if (!horizontalScrollBar)
+    {
+        horizontalScrollBar = new HScrollBar();
+        rend = 1;
+    }
+    if (horizontalScrollBar
+        && (horizontalScrollBar->getFarbe() != f
+            || horizontalScrollBar->getBgFarbe() != bgF))
+    {
+        horizontalScrollBar->setFarbe(f);
+        horizontalScrollBar->setBgFarbe(bgF, bgF != 0);
+        rend = 1;
+    }
 }
 
 bool ZeichnungHintergrund::tick(double tickVal)
 {
-	if (vertikalScrollBar && hatStyle(Style::VScroll))
-		rend |= vertikalScrollBar->getRend();
-	if (horizontalScrollBar && hatStyle(Style::HScroll))
-		rend |= horizontalScrollBar->getRend();
-	return Zeichnung::tick(tickVal);
+    if (vertikalScrollBar && hatStyle(Style::VScroll))
+        rend |= vertikalScrollBar->getRend();
+    if (horizontalScrollBar && hatStyle(Style::HScroll))
+        rend |= horizontalScrollBar->getRend();
+    return Zeichnung::tick(tickVal);
 }
 
 void ZeichnungHintergrund::render(Bild& rObj)
 {
-	innenPosition.x = pos.x;
-	innenPosition.y = pos.y;
-	innenSize.x = gr.x;
-	innenSize.y = gr.y;
-	if (hatStyleNicht(Style::Sichtbar))
-		return;
-	lockZeichnung();
-	if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y))
-	{
-		unlockZeichnung();
-		return;
-	}
-	Zeichnung::render(rObj);
-	int rbr = 0;
-	if (hatStyle(Style::Rahmen) && rahmen)
-	{
-		rahmen->setSize(gr);
-		rahmen->render(rObj);
-		rbr = rahmen->getRBreite();
-	}
-	innenPosition.x += rbr;
-	innenPosition.y += rbr;
-	innenSize.x -= rbr * 2;
-	innenSize.y -= rbr * 2;
-	if (!rObj.setDrawOptions(rbr, rbr, gr.x - rbr * 2, gr.y - rbr * 2))
-	{
-		rObj.releaseDrawOptions();
-		unlockZeichnung();
-		return;
-	}
-	bool vs = vertikalScrollBar && hatStyle(Style::VScroll);
-	bool hs = horizontalScrollBar && hatStyle(Style::HScroll);
-	if (vs)
-	{
-		vertikalScrollBar->render(gr.x - rbr * 2 - 15, 0, 15, gr.y - rbr * 2, rObj);
-		innenSize.x -= 15;
-		if (hs)
-		{
-			horizontalScrollBar->render(0, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - 15, 15, rObj);
-			innenSize.y -= 15;
-			if (!rObj.setDrawOptions(0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2 - 15))
-			{
-				rObj.releaseDrawOptions();
-				rObj.releaseDrawOptions();
-				unlockZeichnung();
-				return;
-			}
-			horizontalScrollBar->update(horizontalScrollBar->getScrollData()->max, innenSize.x);
-		}
-		else
-		{
-			if (!rObj.setDrawOptions(0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2))
-			{
-				rObj.releaseDrawOptions();
-				rObj.releaseDrawOptions();
-				unlockZeichnung();
-				return;
-			}
-		}
-		vertikalScrollBar->update(vertikalScrollBar->getScrollData()->max, innenSize.y);
-	}
-	else if (hs)
-	{
-		horizontalScrollBar->render(rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2, 15, rObj);
-		innenSize.y -= 15;
-		if (!rObj.setDrawOptions(0, 0, gr.x - rbr * 2, gr.y - rbr * 2 - 15))
-		{
-			rObj.releaseDrawOptions();
-			rObj.releaseDrawOptions();
-			unlockZeichnung();
-			return;
-		}
-	}
-	if (hatStyle(Style::Hintergrund))
-	{
-		if (hatStyle(Style::HAlpha))
-			rObj.alphaRegion(0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe);
-		else
-			rObj.fillRegion(0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe);
-		if (hatStyle(Style::HBild) && hintergrundBild)
-		{
-			if (hatStyle(Style::HAlpha))
-				rObj.alphaBildSkall(0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
-			else
-				rObj.drawBildSkall(0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
-		}
-	}
-	if (hatStyle(Style::Buffered) && hintergrundFeld)
-	{
-		hintergrundFeld->setSize(gr.x - rbr * 2, gr.y - rbr * 2);
-		hintergrundFeld->render(rObj);
-	}
-	if (vs || hs)
-		rObj.releaseDrawOptions();
-	rObj.releaseDrawOptions();
-	rObj.releaseDrawOptions();
-	unlockZeichnung();
+    innenPosition.x = pos.x;
+    innenPosition.y = pos.y;
+    innenSize.x = gr.x;
+    innenSize.y = gr.y;
+    if (hatStyleNicht(Style::Sichtbar)) return;
+    lockZeichnung();
+    if (!rObj.setDrawOptions(pos.x, pos.y, gr.x, gr.y))
+    {
+        unlockZeichnung();
+        return;
+    }
+    Zeichnung::render(rObj);
+    int rbr = 0;
+    if (hatStyle(Style::Rahmen) && rahmen)
+    {
+        rahmen->setSize(gr);
+        rahmen->render(rObj);
+        rbr = rahmen->getRBreite();
+    }
+    innenPosition.x += rbr;
+    innenPosition.y += rbr;
+    innenSize.x -= rbr * 2;
+    innenSize.y -= rbr * 2;
+    if (!rObj.setDrawOptions(rbr, rbr, gr.x - rbr * 2, gr.y - rbr * 2))
+    {
+        rObj.releaseDrawOptions();
+        unlockZeichnung();
+        return;
+    }
+    bool vs = vertikalScrollBar && hatStyle(Style::VScroll);
+    bool hs = horizontalScrollBar && hatStyle(Style::HScroll);
+    if (vs)
+    {
+        vertikalScrollBar->render(
+            gr.x - rbr * 2 - 15, 0, 15, gr.y - rbr * 2, rObj);
+        innenSize.x -= 15;
+        if (hs)
+        {
+            horizontalScrollBar->render(
+                0, gr.y - rbr * 2 - 15, gr.x - rbr * 2 - 15, 15, rObj);
+            innenSize.y -= 15;
+            if (!rObj.setDrawOptions(
+                    0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2 - 15))
+            {
+                rObj.releaseDrawOptions();
+                rObj.releaseDrawOptions();
+                unlockZeichnung();
+                return;
+            }
+            horizontalScrollBar->update(
+                horizontalScrollBar->getScrollData()->max, innenSize.x);
+        }
+        else
+        {
+            if (!rObj.setDrawOptions(0, 0, gr.x - rbr * 2 - 15, gr.y - rbr * 2))
+            {
+                rObj.releaseDrawOptions();
+                rObj.releaseDrawOptions();
+                unlockZeichnung();
+                return;
+            }
+        }
+        vertikalScrollBar->update(
+            vertikalScrollBar->getScrollData()->max, innenSize.y);
+    }
+    else if (hs)
+    {
+        horizontalScrollBar->render(
+            rbr, gr.y - rbr * 2 - 15, gr.x - rbr * 2, 15, rObj);
+        innenSize.y -= 15;
+        if (!rObj.setDrawOptions(0, 0, gr.x - rbr * 2, gr.y - rbr * 2 - 15))
+        {
+            rObj.releaseDrawOptions();
+            rObj.releaseDrawOptions();
+            unlockZeichnung();
+            return;
+        }
+    }
+    if (hatStyle(Style::Hintergrund))
+    {
+        if (hatStyle(Style::HAlpha))
+            rObj.alphaRegion(
+                0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe);
+        else
+            rObj.fillRegion(
+                0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe);
+        if (hatStyle(Style::HBild) && hintergrundBild)
+        {
+            if (hatStyle(Style::HAlpha))
+                rObj.alphaBildSkall(
+                    0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+            else
+                rObj.drawBildSkall(
+                    0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+        }
+    }
+    if (hatStyle(Style::Buffered) && hintergrundFeld)
+    {
+        hintergrundFeld->setSize(gr.x - rbr * 2, gr.y - rbr * 2);
+        hintergrundFeld->render(rObj);
+    }
+    if (vs || hs) rObj.releaseDrawOptions();
+    rObj.releaseDrawOptions();
+    rObj.releaseDrawOptions();
+    unlockZeichnung();
 }
 
 // Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
 int ZeichnungHintergrund::getInnenBreite() const
 {
-	return getBreite() - 2 * getRahmenBreite();
+    return getBreite() - 2 * getRahmenBreite();
 }
 
 // Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
 int ZeichnungHintergrund::getInnenHeight() const
 {
-	return getHeight() - 2 * getRahmenBreite();
+    return getHeight() - 2 * getRahmenBreite();
 }
 
-Bild* ZeichnungHintergrund::getHintergrundBild() const // gibt getThis vom Hintergrund Bild zurück
+Bild* ZeichnungHintergrund::getHintergrundBild()
+    const // gibt getThis vom Hintergrund Bild zurück
 {
-	if (!hintergrundBild)
-		return 0;
-	return dynamic_cast<Bild*>(hintergrundBild->getThis());
+    if (!hintergrundBild) return 0;
+    return dynamic_cast<Bild*>(hintergrundBild->getThis());
 }
 
-Bild* ZeichnungHintergrund::zHintergrundBild() const // gibt das Hintergrund Bild zurück
+Bild* ZeichnungHintergrund::zHintergrundBild()
+    const // gibt das Hintergrund Bild zurück
 {
-	return hintergrundBild;
+    return hintergrundBild;
 }
 
-int ZeichnungHintergrund::getHintergrundFarbe() const // giebt getThis der Hintergrundfarbe zurück
+int ZeichnungHintergrund::getHintergrundFarbe()
+    const // giebt getThis der Hintergrundfarbe zurück
 {
-	return hintergrundFarbe;
+    return hintergrundFarbe;
 }
 
-AlphaFeld* ZeichnungHintergrund::getAlphaFeld() const // gibt getThir vom Hintergrund Buffer zurück
+AlphaFeld* ZeichnungHintergrund::getAlphaFeld()
+    const // gibt getThir vom Hintergrund Buffer zurück
 {
-	if (!hintergrundFeld)
-		return 0;
-	return dynamic_cast<AlphaFeld*>(hintergrundFeld->getThis());
+    if (!hintergrundFeld) return 0;
+    return dynamic_cast<AlphaFeld*>(hintergrundFeld->getThis());
 }
 
-AlphaFeld* ZeichnungHintergrund::zAlphaFeld() const // gibt den Hintergrund Buffer zurück
+AlphaFeld*
+ZeichnungHintergrund::zAlphaFeld() const // gibt den Hintergrund Buffer zurück
 {
-	return hintergrundFeld;
+    return hintergrundFeld;
 }
 
-int ZeichnungHintergrund::getAlphaFeldStrength() const // gibt die Stärke des Hintergrund Buffers zurück
+int ZeichnungHintergrund::getAlphaFeldStrength()
+    const // gibt die Stärke des Hintergrund Buffers zurück
 {
-	if (!hintergrundFeld)
-		return 0;
-	return hintergrundFeld->getStrength();
+    if (!hintergrundFeld) return 0;
+    return hintergrundFeld->getStrength();
 }
 
-int ZeichnungHintergrund::getAlphaFeldFarbe() const // gibt getThis von der Farbe des Hintergrund Buffers zurück
+int ZeichnungHintergrund::getAlphaFeldFarbe()
+    const // gibt getThis von der Farbe des Hintergrund Buffers zurück
 {
-	return hintergrundFeld->getFarbe();
+    return hintergrundFeld->getFarbe();
 }
 
-Rahmen* ZeichnungHintergrund::getRahmen() const // gibt getThis des Rahmens zurück
+Rahmen*
+ZeichnungHintergrund::getRahmen() const // gibt getThis des Rahmens zurück
 {
-	if (!rahmen)
-		return 0;
-	return dynamic_cast<Rahmen*>(rahmen->getThis());
+    if (!rahmen) return 0;
+    return dynamic_cast<Rahmen*>(rahmen->getThis());
 }
 
 Rahmen* ZeichnungHintergrund::zRahmen() const // gibt den Rahmen zurück
 {
-	return rahmen;
+    return rahmen;
 }
 
-int ZeichnungHintergrund::getRahmenBreite() const // gibt die Breite des Rahmens zurück
+int ZeichnungHintergrund::getRahmenBreite()
+    const // gibt die Breite des Rahmens zurück
 {
-	if (!rahmen || hatStyleNicht(Style::Rahmen))
-		return 0;
-	return rahmen->getRBreite();
+    if (!rahmen || hatStyleNicht(Style::Rahmen)) return 0;
+    return rahmen->getRBreite();
 }
 
-int ZeichnungHintergrund::getRahmenFarbe() const // gibt getThis der Farbe des Rahmens zurück
+int ZeichnungHintergrund::getRahmenFarbe()
+    const // gibt getThis der Farbe des Rahmens zurück
 {
-	return rahmen->getFarbe();
+    return rahmen->getFarbe();
 }
 
 int ZeichnungHintergrund::getVertikalKlickScroll() const
 {
-	return vertikalScrollBar ? vertikalScrollBar->getKlickScroll() : 0;
+    return vertikalScrollBar ? vertikalScrollBar->getKlickScroll() : 0;
 }
 
 int ZeichnungHintergrund::getVertikalScrollPos() const
 {
-	return vertikalScrollBar ? vertikalScrollBar->getScroll() : 0;
+    return vertikalScrollBar ? vertikalScrollBar->getScroll() : 0;
 }
 
 int ZeichnungHintergrund::getVertikalScrollFarbe() const
 {
-	return vertikalScrollBar ? vertikalScrollBar->getFarbe() : 0;
+    return vertikalScrollBar ? vertikalScrollBar->getFarbe() : 0;
 }
 
 int ZeichnungHintergrund::getVertikalScrollHintergrund() const
 {
-	return vertikalScrollBar ? vertikalScrollBar->getBgFarbe() : 0;
+    return vertikalScrollBar ? vertikalScrollBar->getBgFarbe() : 0;
 }
 
 int ZeichnungHintergrund::getHorizontalKlickScroll() const
 {
-	return horizontalScrollBar ? horizontalScrollBar->getKlickScroll() : 0;
+    return horizontalScrollBar ? horizontalScrollBar->getKlickScroll() : 0;
 }
 
 int ZeichnungHintergrund::getHorizontalScrollPos() const
 {
-	return horizontalScrollBar ? horizontalScrollBar->getScroll() : 0;
+    return horizontalScrollBar ? horizontalScrollBar->getScroll() : 0;
 }
 
 int ZeichnungHintergrund::getHorizontalScrollFarbe() const
 {
-	return horizontalScrollBar ? horizontalScrollBar->getFarbe() : 0;
+    return horizontalScrollBar ? horizontalScrollBar->getFarbe() : 0;
 }
 
 int ZeichnungHintergrund::getHorizontalScrollHintergrund() const
 {
-	return horizontalScrollBar ? horizontalScrollBar->getBgFarbe() : 0;
-}
-
-Zeichnung* ZeichnungHintergrund::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
-{
-	ZeichnungHintergrund* obj = new ZeichnungHintergrund();
-	obj->setPosition(pos);
-	obj->setSize(gr);
-	obj->setMausEreignisParameter(makParam);
-	obj->setTastaturEreignisParameter(takParam);
-	obj->setMausEreignis(mak);
-	obj->setTastaturEreignis(tak);
-	if (toolTip)
-		obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
-	obj->setStyle(style);
-	obj->setHintergrundFarbe(hintergrundFarbe);
-	if (hintergrundFeld)
-		obj->setAlphaFeldZ((AlphaFeld*)hintergrundFeld->dublizieren());
-	if (rahmen)
-		obj->setRahmenZ((Rahmen*)rahmen->dublizieren());
-	if (hintergrundBild)
-		obj->setHintergrundBild(dynamic_cast<Bild*>(hintergrundBild->getThis()));
-	if (vertikalScrollBar)
-	{
-		obj->setVertikalKlickScroll(vertikalScrollBar->getKlickScroll());
-		obj->setVertikalScrollPos(vertikalScrollBar->getScroll());
-		obj->setVertikalScrollFarbe(vertikalScrollBar->getFarbe(), vertikalScrollBar->getBgFarbe());
-	}
-	if (horizontalScrollBar)
-	{
-		obj->setHorizontalKlickScroll(horizontalScrollBar->getKlickScroll());
-		obj->setHorizontalScrollPos(horizontalScrollBar->getScroll());
-		obj->setHorizontalScrollFarbe(horizontalScrollBar->getFarbe(), horizontalScrollBar->getBgFarbe());
-	}
-	return obj;
+    return horizontalScrollBar ? horizontalScrollBar->getBgFarbe() : 0;
+}
+
+Zeichnung*
+ZeichnungHintergrund::dublizieren() const // Erzeugt eine Kopie des Zeichnungs
+{
+    ZeichnungHintergrund* obj = new ZeichnungHintergrund();
+    obj->setPosition(pos);
+    obj->setSize(gr);
+    obj->setMausEreignisParameter(makParam);
+    obj->setTastaturEreignisParameter(takParam);
+    obj->setMausEreignis(mak);
+    obj->setTastaturEreignis(tak);
+    if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
+    obj->setStyle(style);
+    obj->setHintergrundFarbe(hintergrundFarbe);
+    if (hintergrundFeld)
+        obj->setAlphaFeldZ((AlphaFeld*)hintergrundFeld->dublizieren());
+    if (rahmen) obj->setRahmenZ((Rahmen*)rahmen->dublizieren());
+    if (hintergrundBild)
+        obj->setHintergrundBild(
+            dynamic_cast<Bild*>(hintergrundBild->getThis()));
+    if (vertikalScrollBar)
+    {
+        obj->setVertikalKlickScroll(vertikalScrollBar->getKlickScroll());
+        obj->setVertikalScrollPos(vertikalScrollBar->getScroll());
+        obj->setVertikalScrollFarbe(
+            vertikalScrollBar->getFarbe(), vertikalScrollBar->getBgFarbe());
+    }
+    if (horizontalScrollBar)
+    {
+        obj->setHorizontalKlickScroll(horizontalScrollBar->getKlickScroll());
+        obj->setHorizontalScrollPos(horizontalScrollBar->getScroll());
+        obj->setHorizontalScrollFarbe(
+            horizontalScrollBar->getFarbe(), horizontalScrollBar->getBgFarbe());
+    }
+    return obj;
 }

Zeichnung.h

@@ -1,368 +1,449 @@
 #ifndef Zeichnung_H
 #define Zeichnung_H
 
-#include "Punkt.h"
-#include "MausEreignis.h"
-#include "TastaturEreignis.h"
+#include <functional>
+#include <queue>
+
 #include "Critical.h"
+#include "MausEreignis.h"
+#include "Punkt.h"
 #include "ReferenceCounter.h"
-#include <queue>
-#include <functional>
+#include "TastaturEreignis.h"
 
 namespace Framework
 {
-	struct MausEreignis; //! MausEreignis.h
-	struct TastaturEreignis; //! TastaturEreignis.h
-	class Bild; //! Bild.h
-	class Zeichnung; //! Aus dieser Datei
-	class ToolTip; //! ToopTip.h
-	class Bildschirm; //! Bildschirm.h
-	class Rahmen; //! Rahmen.h
-	class AlphaFeld; //! AlphaFeld.h
-	class VScrollBar; //! Scroll.h
-	class HScrollBar; //! Scroll.h
-	class Schrift;
+    struct MausEreignis;     //! MausEreignis.h
+    struct TastaturEreignis; //! TastaturEreignis.h
+    class Bild;              //! Bild.h
+    class Zeichnung;         //! Aus dieser Datei
+    class ToolTip;           //! ToopTip.h
+    class Bildschirm;        //! Bildschirm.h
+    class Rahmen;            //! Rahmen.h
+    class AlphaFeld;         //! AlphaFeld.h
+    class VScrollBar;        //! Scroll.h
+    class HScrollBar;        //! Scroll.h
+    class Schrift;
+
+    //! Eine Zeichnung für das 2D GUI Framework
+    class Zeichnung : public virtual ReferenceCounter
+    {
+    public:
+        class Style
+        {
+        public:
+            //! Wenn dieser Style gesetzt ist, wird die Zeichnung beim Zeichnen
+            //! angezeigt
+            static const __int64 Sichtbar = 0x00001;
+            //! Wenn dieser Style gesetzt ist, kann der Benutzer mit der
+            //! Zeichnung interagieren
+            static const __int64 Erlaubt = 0x00002;
+            //! Wenn dieser Style gesetzt ist, wird ein TastaturEreignis von der
+            //! Zeichnung verarbeitet
+            static const __int64 Fokus = 0x00004;
+            //! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch
+            //! verarbeitet, wenn das Objekt nicht sichtbar ist
+            static const __int64 MEIgnoreSichtbar = 0x0800000000000000;
+            //! Wenn dieser Style gesetzt ist, lockt der Thread das Objekt
+            //! während das MausEreignis verarbeitet wird
+            static const __int64 MELockZeichnung = 0x1000000000000000;
+            //! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch
+            //! verarbeitet, wenn es außerhalb der Zeichnung liegt
+            static const __int64 MEIgnoreInside = 0x2000000000000000;
+            //! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch
+            //! verarbeitet, wenn es bereits von einer anderen Zeichnung
+            //! verarbeitet wurde
+            static const __int64 MEIgnoreVerarbeitet = 0x4000000000000000;
+            //! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch
+            //! verarbeitet, wenn es sich außerhalb der Zeichnung befindet, zu
+            //! der diese Zeichnung gehört
+            static const __int64 MEIgnoreParentInside = 0x8000000000000000;
+        };
 
-	//! Eine Zeichnung für das 2D GUI Framework
-	class Zeichnung : public virtual ReferenceCounter
-	{
-	public:
-		class Style
-		{
-		public:
-			//! Wenn dieser Style gesetzt ist, wird die Zeichnung beim Zeichnen angezeigt
-			const static __int64 Sichtbar = 0x00001;
-			//! Wenn dieser Style gesetzt ist, kann der Benutzer mit der Zeichnung interagieren
-			const static __int64 Erlaubt = 0x00002;
-			//! Wenn dieser Style gesetzt ist, wird ein TastaturEreignis von der Zeichnung verarbeitet
-			const static __int64 Fokus = 0x00004;
-			//! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch verarbeitet, wenn das Objekt nicht sichtbar ist
-			const static __int64 MEIgnoreSichtbar = 0x0800000000000000;
-			//! Wenn dieser Style gesetzt ist, lockt der Thread das Objekt während das MausEreignis verarbeitet wird
-			const static __int64 MELockZeichnung = 0x1000000000000000;
-			//! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch verarbeitet, wenn es außerhalb der Zeichnung liegt
-			const static __int64 MEIgnoreInside = 0x2000000000000000;
-			//! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch verarbeitet, wenn es bereits von einer anderen Zeichnung verarbeitet wurde
-			const static __int64 MEIgnoreVerarbeitet = 0x4000000000000000;
-			//! Wenn dieser Style gesetzt ist, wird ein MausEreignis auch verarbeitet, wenn es sich außerhalb der Zeichnung befindet, zu der diese Zeichnung gehört
-			const static __int64 MEIgnoreParentInside = 0x8000000000000000;
-		};
-	protected:
-		Punkt pos;
-		Punkt gr;
-		void* makParam;
-		void* takParam;
-		MausAktion mak;
-		TastaturAktion tak;
-		void* nmakParam;
-		void* ntakParam;
-		MausAktion nMak;
-		TastaturAktion nTak;
-		bool mausIn;
-		Critical cs;
-		ToolTip* toolTip;
-		__int64 style;
-		bool rend;
-		std::queue< std::function< void() > > actions;
-		std::function< void(Zeichnung*, Punkt localPos) > onNeedToolTip;
+    protected:
+        Punkt pos;
+        Punkt gr;
+        void* makParam;
+        void* takParam;
+        MausAktion mak;
+        TastaturAktion tak;
+        void* nmakParam;
+        void* ntakParam;
+        MausAktion nMak;
+        TastaturAktion nTak;
+        bool mausIn;
+        Critical cs;
+        ToolTip* toolTip;
+        __int64 style;
+        bool rend;
+        std::queue<std::function<void()>> actions;
+        std::function<bool(Zeichnung*, Punkt localPos)> onNeedToolTip;
+        bool toolTipRequested;
 
-		//! Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
-		//! \param me Das MausEreignis
-		//! \param userRet true wenn MausEreignis::verarbeitet auf true gesetzt werden soll
-		DLLEXPORT virtual void doMausEreignis(MausEreignis& me, bool userRet);
+        //! Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch
+        //! aufgerufen. \param me Das MausEreignis \param userRet true wenn
+        //! MausEreignis::verarbeitet auf true gesetzt werden soll
+        DLLEXPORT virtual void doMausEreignis(MausEreignis& me, bool userRet);
 
-	public:
-		//! Konstruktor 
-		DLLEXPORT Zeichnung();
-		//! Destruktor 
-		DLLEXPORT virtual ~Zeichnung();
-		//! Übergibt einen void Funktionszeiger auf eine Aktion die einmalig vom Hauptthread ausgeführt werden soll. Wird am ende von tick() aufgerufen
-		DLLEXPORT void postAction(std::function< void() > action);
-		//! Legt fest, ob sich die Zeichnung seit des letzten Bildes verändert hat und neu gezeichnet werden muss
-		DLLEXPORT void setRender();
-		//! Setzt den Text, der erscheint, wenn der Benutzer für längere Zeit mit der Maus in der Zeichnung verweilt
-		//! \param txt Der Text, der angezeigt werden soll
-		//! \param zScreen Ein Zeiger auf das Verwendete Bildschirm Objekt ohne erhöhten Reference Counter
-		//! \param zSchrift Ein Zeiger auf die Schrift, die verwendet werden soll ohne erhöhten Reference Counter
-		DLLEXPORT void setToolTipText(const char* txt, Bildschirm* zScreen, Schrift* zSchrift);
-		//! setzt eine Funktion, die aufgerufen wird, falls ein Tooltip benötigt wird und noch keiner gesetzt wurde
-		//! \param initToolTip die Funktion
-		DLLEXPORT void setNeedToolTipEvent(std::function< void(Zeichnung*, Punkt localPos) > onNeedTooltip);
-		//! legt den tooltip fest
-		//! \param tt der tooltip
-		DLLEXPORT void setToolTipZ(ToolTip* tt);
-		//! 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.
-		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.
-		DLLEXPORT void unlockZeichnung();
-		//! setzt den Parameter, der bei einem Maus Ereignis an die Rückruffunktion übergeben wird
-		//! \param p Der Parameter
-		DLLEXPORT void setMausEreignisParameter(void* p);
-		//! Setzt den Parameter, der bei einem Tastatur Ereignis an die Rückruffunktion übergeben wird
-		//! \param p Der Parameter
-		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
-		//! \param ak Ein Zeiger auf die Rückruffunktion
-		DLLEXPORT void setMausEreignis(MausAktion ak);
-		//! 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
-		//! \param ak Ein Zeiger auf die Rückruffunktion
-		DLLEXPORT void setTastaturEreignis(TastaturAktion ak);
-		//! 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
-		//! \param p Der Parameter
-		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
-		//! \param p Der Parameter
-		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
-		//! \param ak Ein Zeiger auf die Rückruffunktion
-		DLLEXPORT void setNMausEreignis(MausAktion ak);
-		//! 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
-		//! \param ak Ein Zeiger auf die Rückruffunktion
-		DLLEXPORT void setNTastaturEreignis(TastaturAktion ak);
-		//! Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch aufgerufen.
-		//! \param me Das Ereignis
-		DLLEXPORT virtual void doPublicMausEreignis(MausEreignis& me);
-		//! Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch aufgerufen
-		//! \param te Das Ereignis
-		DLLEXPORT virtual void doTastaturEreignis(TastaturEreignis& te);
-		//! Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion vergangen ist
-		//! \param tickVal Die vergangene Zeit in Sekunden
-		DLLEXPORT virtual bool tick(double tickval);
-		//! Setzt die Position der Zeichnung
-		//! \param pos Die Position in Pixeln
-		DLLEXPORT void setPosition(const Punkt& pos);
-		//! Setzt die X Position der Zeichnung
-		//! \param xPos Die Position in Pixeln
-		DLLEXPORT void setX(int xPos);
-		//! Setzt die Y Position der Zeichnung
-		//! \param yPos Die Position in Pixeln
-		DLLEXPORT void setY(int yPos);
-		//! Setzt die Größe der Zeichnung
-		//! \param gr Ein Punkt mit x als Breite und y als Höhe in Pixeln
-		DLLEXPORT void setSize(const Punkt& gr);
-		//! Setzt die Position der Zeichnung
-		//! \param x Die X Position in Pixeln
-		//! \param y Die Y Position in Pixeln
-		DLLEXPORT void setPosition(int x, int y);
-		//! Setzt die Größe der Zeichnung
-		//! \param br Die Breite in Pixeln
-		//! \param height Die Höhe in Pixeln
-		DLLEXPORT void setSize(int br, int height);
-		//! Set the width in pixel
-		//! \param width the width
-		DLLEXPORT void setWidth(int width);
-		//! Set the height in pixel
-		//! \param width the height
-		DLLEXPORT void setHeight(int height);
-		//! Setzt den Style der Zeichnung
-		//! \param style Der neue Style bestehend aus den Flags aus der zugehörigen Style Klasse
-		DLLEXPORT void setStyle(__int64 style);
-		//! Setzt den Style der Zeichnung
-		//! \param style Alle Style Flags, die verändert werden sollen
-		//! \param add_remove 1, falls der Style hinzugefügt werden soll. 0, falls der Style entfernt weden soll
-		DLLEXPORT void setStyle(__int64 style, bool add_remove);
-		//! Fügt Style Flags hinzu
-		//! \param style Der Style, der hinzugefügt werden soll
-		DLLEXPORT void addStyle(__int64 style);
-		//! Entfernt Style Flags
-		//! \param style Der Style, der entfernt werden soll
-		DLLEXPORT void removeStyle(__int64 style);
-		//! Zeichnet die Zeihnung in ein bestimmtes Bild
-		//! \param zRObj Das Bild, in das gezeichnet werden soll
-		DLLEXPORT virtual void render(Bild& zRObj);
-		//! Gibt zurück, ob eine Rückruffunktion für Maus Ereignisse gesetzt wurde
-		DLLEXPORT bool hatMausEreignis() const;
-		//! Gibt zurück, ob eine Rückruffunktion für Tastatur Ereignisse gesetzt wurde
-		DLLEXPORT bool hatTastaturEreignis() const;
-		//! Gibt die Position der Zeichnung in Pixeln zurück
-		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
-		DLLEXPORT const Punkt& getSize() const;
-		//! Gibt die Breite der Zeichnung in Pixeln zurück
-		DLLEXPORT int getBreite() const;
-		//! Gibt die Höhe der Zeichnung in Pixeln zurück
-		DLLEXPORT int getHeight() const;
-		//! Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
-		DLLEXPORT virtual int getInnenBreite() const;
-		//! Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
-		DLLEXPORT virtual int getInnenHeight() const;
-		//! Gibt die X Position der Zeichnung in Pixeln zurück
-		DLLEXPORT int getX() const;
-		//! Gibt die Y Position der Zeichnung in Pixeln zurück
-		DLLEXPORT int getY() const;
-		//! Prüft, ob ein Punkt in diesem Objekt liegt
-		//! \param p der Punkt
-		//! \return 1, wenn der punkt innen ist, 0 sonst
-		DLLEXPORT virtual bool istPunktInnen(Punkt p) const;
-		//! Prüft, ob ein Punkt in diesem Objekt liegt
-		//! \param x die x koordinate des punktes
-		//! \param y die y koordinate des punktes
-		//! \return 1, wenn der punkt innen ist, 0 sonst
-		DLLEXPORT virtual bool istPunktInnen(int x, int y) const;
-		//! Gibt einen Zeiger auf das Tooltip Objekt zurück, walls es verwendet wird
-		DLLEXPORT ToolTip* getToolTip() const;
-		//! Gibt einen Zeiger auf das Tooltip Objekt ohne erhöhten Reference Counter zurück, walls es verwendet wird
-		DLLEXPORT ToolTip* zToolTip() const;
-		//! Gibt zurück, ob bestimmte Styles gesetzt wurden
-		//! \param style Die Styles, die überprüft werden sollen
-		//! \return 1, falls alle Styles in style gesetzt wurden
-		DLLEXPORT bool hatStyle(__int64 style) const;
-		//! Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
-		//! \param style Die Styles, die geprüft werden sollen
-		//! \return 1, falls alle Styles in style nicht gesetzt wurden
-		DLLEXPORT bool hatStyleNicht(__int64 style) const;
-		//! Kopiert die Komplette Zeichnung, so dass sie ohne Effekt auf das Original verändert werden kann
-		DLLEXPORT virtual Zeichnung* dublizieren() const;
-	};
+    public:
+        //! Konstruktor
+        DLLEXPORT Zeichnung();
+        //! Destruktor
+        DLLEXPORT virtual ~Zeichnung();
+        //! Übergibt einen void Funktionszeiger auf eine Aktion die einmalig vom
+        //! Hauptthread ausgeführt werden soll. Wird am ende von tick()
+        //! aufgerufen
+        DLLEXPORT void postAction(std::function<void()> action);
+        //! Legt fest, ob sich die Zeichnung seit des letzten Bildes verändert
+        //! hat und neu gezeichnet werden muss
+        DLLEXPORT void setRender();
+        //! Setzt den Text, der erscheint, wenn der Benutzer für längere Zeit
+        //! mit der Maus in der Zeichnung verweilt \param txt Der Text, der
+        //! angezeigt werden soll \param zScreen Ein Zeiger auf das Verwendete
+        //! Bildschirm Objekt ohne erhöhten Reference Counter \param zSchrift
+        //! Ein Zeiger auf die Schrift, die verwendet werden soll ohne erhöhten
+        //! Reference Counter
+        DLLEXPORT void setToolTipText(
+            const char* txt, Bildschirm* zScreen, Schrift* zSchrift);
+        //! setzt eine Funktion, die aufgerufen wird, falls ein Tooltip benötigt
+        //! wird und noch keiner gesetzt wurde \param initToolTip die Funktion
+        DLLEXPORT void setNeedToolTipEvent(
+            std::function<bool(Zeichnung*, Punkt localPos)> onNeedTooltip);
+        //! legt den tooltip fest
+        //! \param tt der tooltip
+        DLLEXPORT void setToolTipZ(ToolTip* tt);
+        //! 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.
+        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.
+        DLLEXPORT void unlockZeichnung();
+        //! setzt den Parameter, der bei einem Maus Ereignis an die
+        //! Rückruffunktion übergeben wird \param p Der Parameter
+        DLLEXPORT void setMausEreignisParameter(void* p);
+        //! Setzt den Parameter, der bei einem Tastatur Ereignis an die
+        //! Rückruffunktion übergeben wird \param p Der Parameter
+        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 \param ak Ein
+        //! Zeiger auf die Rückruffunktion
+        DLLEXPORT void setMausEreignis(MausAktion ak);
+        //! 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 \param ak Ein Zeiger auf
+        //! die Rückruffunktion
+        DLLEXPORT void setTastaturEreignis(TastaturAktion ak);
+        //! 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 \param p Der Parameter
+        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 \param p Der Parameter
+        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 \param ak Ein
+        //! Zeiger auf die Rückruffunktion
+        DLLEXPORT void setNMausEreignis(MausAktion ak);
+        //! 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 \param ak Ein Zeiger auf
+        //! die Rückruffunktion
+        DLLEXPORT void setNTastaturEreignis(TastaturAktion ak);
+        //! Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch
+        //! aufgerufen. \param me Das Ereignis
+        DLLEXPORT virtual void doPublicMausEreignis(MausEreignis& me);
+        //! Verarbeitet ein Tastatur Ereignis. Wird vom Framework automatisch
+        //! aufgerufen \param te Das Ereignis
+        DLLEXPORT virtual void doTastaturEreignis(TastaturEreignis& te);
+        //! Verarbeitet die Zeit, die seit dem letzten aufruf dieser Funktion
+        //! vergangen ist \param tickVal Die vergangene Zeit in Sekunden
+        DLLEXPORT virtual bool tick(double tickval);
+        //! Setzt die Position der Zeichnung
+        //! \param pos Die Position in Pixeln
+        DLLEXPORT void setPosition(const Punkt& pos);
+        //! Setzt die X Position der Zeichnung
+        //! \param xPos Die Position in Pixeln
+        DLLEXPORT void setX(int xPos);
+        //! Setzt die Y Position der Zeichnung
+        //! \param yPos Die Position in Pixeln
+        DLLEXPORT void setY(int yPos);
+        //! Setzt die Größe der Zeichnung
+        //! \param gr Ein Punkt mit x als Breite und y als Höhe in Pixeln
+        DLLEXPORT void setSize(const Punkt& gr);
+        //! Setzt die Position der Zeichnung
+        //! \param x Die X Position in Pixeln
+        //! \param y Die Y Position in Pixeln
+        DLLEXPORT void setPosition(int x, int y);
+        //! Setzt die Größe der Zeichnung
+        //! \param br Die Breite in Pixeln
+        //! \param height Die Höhe in Pixeln
+        DLLEXPORT void setSize(int br, int height);
+        //! Set the width in pixel
+        //! \param width the width
+        DLLEXPORT void setWidth(int width);
+        //! Set the height in pixel
+        //! \param width the height
+        DLLEXPORT void setHeight(int height);
+        //! Setzt den Style der Zeichnung
+        //! \param style Der neue Style bestehend aus den Flags aus der
+        //! zugehörigen Style Klasse
+        DLLEXPORT void setStyle(__int64 style);
+        //! Setzt den Style der Zeichnung
+        //! \param style Alle Style Flags, die verändert werden sollen
+        //! \param add_remove 1, falls der Style hinzugefügt werden soll. 0,
+        //! falls der Style entfernt weden soll
+        DLLEXPORT void setStyle(__int64 style, bool add_remove);
+        //! Fügt Style Flags hinzu
+        //! \param style Der Style, der hinzugefügt werden soll
+        DLLEXPORT void addStyle(__int64 style);
+        //! Entfernt Style Flags
+        //! \param style Der Style, der entfernt werden soll
+        DLLEXPORT void removeStyle(__int64 style);
+        //! Zeichnet die Zeihnung in ein bestimmtes Bild
+        //! \param zRObj Das Bild, in das gezeichnet werden soll
+        DLLEXPORT virtual void render(Bild& zRObj);
+        //! Gibt zurück, ob eine Rückruffunktion für Maus Ereignisse gesetzt
+        //! wurde
+        DLLEXPORT bool hatMausEreignis() const;
+        //! Gibt zurück, ob eine Rückruffunktion für Tastatur Ereignisse gesetzt
+        //! wurde
+        DLLEXPORT bool hatTastaturEreignis() const;
+        //! Gibt die Position der Zeichnung in Pixeln zurück
+        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
+        DLLEXPORT const Punkt& getSize() const;
+        //! Gibt die Breite der Zeichnung in Pixeln zurück
+        DLLEXPORT int getBreite() const;
+        //! Gibt die Höhe der Zeichnung in Pixeln zurück
+        DLLEXPORT int getHeight() const;
+        //! Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
+        DLLEXPORT virtual int getInnenBreite() const;
+        //! Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
+        DLLEXPORT virtual int getInnenHeight() const;
+        //! Gibt die X Position der Zeichnung in Pixeln zurück
+        DLLEXPORT int getX() const;
+        //! Gibt die Y Position der Zeichnung in Pixeln zurück
+        DLLEXPORT int getY() const;
+        //! Prüft, ob ein Punkt in diesem Objekt liegt
+        //! \param p der Punkt
+        //! \return 1, wenn der punkt innen ist, 0 sonst
+        DLLEXPORT virtual bool istPunktInnen(Punkt p) const;
+        //! Prüft, ob ein Punkt in diesem Objekt liegt
+        //! \param x die x koordinate des punktes
+        //! \param y die y koordinate des punktes
+        //! \return 1, wenn der punkt innen ist, 0 sonst
+        DLLEXPORT virtual bool istPunktInnen(int x, int y) const;
+        //! Gibt einen Zeiger auf das Tooltip Objekt zurück, walls es verwendet
+        //! wird
+        DLLEXPORT ToolTip* getToolTip() const;
+        //! Gibt einen Zeiger auf das Tooltip Objekt ohne erhöhten Reference
+        //! Counter zurück, walls es verwendet wird
+        DLLEXPORT ToolTip* zToolTip() const;
+        //! Gibt zurück, ob bestimmte Styles gesetzt wurden
+        //! \param style Die Styles, die überprüft werden sollen
+        //! \return 1, falls alle Styles in style gesetzt wurden
+        DLLEXPORT bool hatStyle(__int64 style) const;
+        //! Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
+        //! \param style Die Styles, die geprüft werden sollen
+        //! \return 1, falls alle Styles in style nicht gesetzt wurden
+        DLLEXPORT bool hatStyleNicht(__int64 style) const;
+        //! Kopiert die Komplette Zeichnung, so dass sie ohne Effekt auf das
+        //! Original verändert werden kann
+        DLLEXPORT virtual Zeichnung* dublizieren() const;
+    };
 
-	//! Eine Zeichnung für das 2D GUI Framework mit Hintergrund, Rahmen und Scroll Balken
-	class ZeichnungHintergrund : public Zeichnung
-	{
-	public:
-		class Style : public Zeichnung::Style
-		{
-		public:
-			const static __int64 Rahmen = 0x00010; //! Wenn dieser Flag gesetzt wird, bekommt die Zeichnugn einen Rahmen
-			const static __int64 Hintergrund = 0x00020; //! Wenn dieser Flag gesetzt wird, bekommt die Zeichnung einen Hintergrund
-			const static __int64 HAlpha = 0x00040; //! Wenn dieser Flag gesetzt wird, wird der Hintergrund durchsichtig. Benötigt Flag Hintergrund
-			const static __int64 HBild = 0x00080; //! Wenn dieser Flag gesetzt wird, wird ein Bild als hintergrund verwendet. Benötigt Flag Hintergrund
-			const static __int64 Buffered = 0x00100; //! Wenn dieser Flag gesetzt wird, Erscheint ein Farbübergang als Rahmen
-			const static __int64 VScroll = 0x00200; //! Wenn dieser Flag gesetzt wird, erscheint eine Scrollbar am rechten Rand
-			const static __int64 HScroll = 0x00400; //! Wenn dieser Flag gesetzt wird, erscheint eine Scrollbar am unteren Rand
-		};
+    //! Eine Zeichnung für das 2D GUI Framework mit Hintergrund, Rahmen und
+    //! Scroll Balken
+    class ZeichnungHintergrund : public Zeichnung
+    {
+    public:
+        class Style : public Zeichnung::Style
+        {
+        public:
+            static const __int64 Rahmen
+                = 0x00010; //! Wenn dieser Flag gesetzt wird, bekommt die
+                           //! Zeichnugn einen Rahmen
+            static const __int64 Hintergrund
+                = 0x00020; //! Wenn dieser Flag gesetzt wird, bekommt die
+                           //! Zeichnung einen Hintergrund
+            static const __int64 HAlpha
+                = 0x00040; //! Wenn dieser Flag gesetzt wird, wird der
+                           //! Hintergrund durchsichtig. Benötigt Flag
+                           //! Hintergrund
+            static const __int64 HBild
+                = 0x00080; //! Wenn dieser Flag gesetzt wird, wird ein Bild als
+                           //! hintergrund verwendet. Benötigt Flag Hintergrund
+            static const __int64 Buffered
+                = 0x00100; //! Wenn dieser Flag gesetzt wird, Erscheint ein
+                           //! Farbübergang als Rahmen
+            static const __int64 VScroll
+                = 0x00200; //! Wenn dieser Flag gesetzt wird, erscheint eine
+                           //! Scrollbar am rechten Rand
+            static const __int64 HScroll
+                = 0x00400; //! Wenn dieser Flag gesetzt wird, erscheint eine
+                           //! Scrollbar am unteren Rand
+        };
 
-	protected:
-		int hintergrundFarbe;
-		Rahmen* rahmen;
-		Bild* hintergrundBild;
-		AlphaFeld* hintergrundFeld;
-		VScrollBar* vertikalScrollBar;
-		HScrollBar* horizontalScrollBar;
-		Punkt innenPosition;
-		Punkt innenSize;
+    protected:
+        int hintergrundFarbe;
+        Rahmen* rahmen;
+        Bild* hintergrundBild;
+        AlphaFeld* hintergrundFeld;
+        VScrollBar* vertikalScrollBar;
+        HScrollBar* horizontalScrollBar;
+        Punkt innenPosition;
+        Punkt innenSize;
 
-	public:
-		//! Konstruktor 
-		DLLEXPORT ZeichnungHintergrund();
-		//! Destruktor 
-		DLLEXPORT virtual ~ZeichnungHintergrund();
-		//! Setzt das Hintergrund Bild (benötigt Flag zum Zeichnen: Style::Hintergrund, HBild)
-		//! \param bild Das Bild wird kopiert und als Hintergrundbild verwendet
-		DLLEXPORT void setHintergrundBild(Bild* bild);
-		//! Setzt einen Zeiger auf das Hintergrund Bild (benötigt Flag zum Zeichnen: Style::Hintergrund)
-		//! \param bild Das Bild wid ohne es zu kopieren verwendet
-		DLLEXPORT void setHintergrundBildZ(Bild* bild);
-		//! Setzt die Hintergrund Farbe (benötigt Flag zum Zeichnen: Style::Hintergrund)
-		//! \param fc Die Hintergrundfarbe im A8R8G8B8 Format
-		DLLEXPORT void setHintergrundFarbe(int fc);
-		//! Setzt einen Zeiger auf das AlphaFeld (benötigt Flag zum Zeichnen: Style::Buffered)
-		//! \param buff Das AlphaFeld, das über den Hintergrund gezeichnet werden soll
-		DLLEXPORT void setAlphaFeldZ(AlphaFeld* buff);
-		//! Setzt die Stärke des AlphaFeldes (benötigt Flag zum Zeichnen: Style::Buffered)
-		//! \param st Die Stärke des AlphaFeldes, welches über dem Hintergrund gezeichnet werden soll
-		DLLEXPORT void setAlphaFeldStrength(int st);
-		//! Setzt die Farbe des AlphaFeldes (benötigt Flag zum Zeichnen: Style::Buffered)
-		//! \param fc Die Farbe des AlphaFeldes, welches über dem Hintergrund gezeichnet werden soll
-		DLLEXPORT void setAlphaFeldFarbe(int fc);
-		//! Setzt einen Zeiger zu dem Linien Rahmen, der um das TextFeld gezeichnet werden soll (benötigt Flag zum Zeichnen: Style::Rahmen)
-		//! \param ram Der Rahmen
-		DLLEXPORT void setRahmenZ(Rahmen* ram);
-		//! Setzt die Breite des Linien Rahmens (benötigt Flag zum Zeichnen: Style::Rahmen)
-		//! \param br Die Breite in Pixeln
-		DLLEXPORT void setRahmenBreite(int br);
-		//! Setzt die Farbe des Linien Rahmens (benötigt Flag zum Zeichnen: Style::Rahmen)
-		//! \param fc Die Farbe im A8R8G8B8 Format
-		DLLEXPORT void setRahmenFarbe(int fc);
-		//! Setzt die Scrollgeschwindigkeit der vertikalen ScrollBar (benötigt Flag zum Zeichnen: Style::VScroll)
-		//! \param ks Die Scrollgeschwindigkeit in Pixeln für jeden Maus Klick
-		DLLEXPORT void setVertikalKlickScroll(int ks);
-		//! Scrollt an eine Bestimmte Stelle bei der vertikalen ScrollBar (benötigt Flag zum Zeichnen: Style::VScroll)
-		//! \param pos Das Scroll Offset in Pixeln.
-		DLLEXPORT void setVertikalScrollPos(int pos);
-		//! Setzt die Farbe der vertikalen ScrollBar (benötigt Flag zum Zeichnen: Style::VScroll)
-		//! \param f Die Fordergrundfarbe der ScrollBar im A8R8G8B8 Format
-		//! \param bgF Die Hintergrundfarbe der ScrollBar im A8R8G8B8 Format
-		DLLEXPORT void setVertikalScrollFarbe(int f, int bgF);
-		//! Setzt die Scrollgeschwindigkeit der horizontalen ScrollBar (benötigt Flag zum Zeichnen: Style::HScroll)
-		//! \param ks Die Scrollgeschwindigkeit in Pixeln für jeden Maus Klick
-		DLLEXPORT void setHorizontalKlickScroll(int ks);
-		//! Scrollt an eine Bestimmte Stelle bei der horizontalen ScrollBar (benötigt Flag zum Zeichnen: Style::HScroll)
-		//! \param pos Das Scroll Offset in Pixeln.
-		DLLEXPORT void setHorizontalScrollPos(int pos);
-		//! Setzt die Farbe der horizontalen ScrollBar (benötigt Flag zum Zeichnen: Style::HScroll)
-		//! \param f Die Fordergrundfarbe der ScrollBar im A8R8G8B8 Format
-		//! \param bgF Die Hintergrundfarbe der ScrollBar im A8R8G8B8 Format
-		DLLEXPORT void setHorizontalScrollFarbe(int f, int bgF);
-		//! Updated den Zeichenhintergrund
-		//! \param tickVal Die vergangene Zeit in Sekunden, die seit dem Letzten Aufruf dieser Funktion verstrichen ist
-		//! \return 1, wenn das Bild neu gezeichnet werden muss. 0 sonnst
-		DLLEXPORT bool tick(double tickVal) override;
-		//! Zeichnet den Hintergrund eines Zeichnunges nach rObj
-		DLLEXPORT void render(Bild& rObj) override;
+    public:
+        //! Konstruktor
+        DLLEXPORT ZeichnungHintergrund();
+        //! Destruktor
+        DLLEXPORT virtual ~ZeichnungHintergrund();
+        //! Setzt das Hintergrund Bild (benötigt Flag zum Zeichnen:
+        //! Style::Hintergrund, HBild) \param bild Das Bild wird kopiert und als
+        //! Hintergrundbild verwendet
+        DLLEXPORT void setHintergrundBild(Bild* bild);
+        //! Setzt einen Zeiger auf das Hintergrund Bild (benötigt Flag zum
+        //! Zeichnen: Style::Hintergrund) \param bild Das Bild wid ohne es zu
+        //! kopieren verwendet
+        DLLEXPORT void setHintergrundBildZ(Bild* bild);
+        //! Setzt die Hintergrund Farbe (benötigt Flag zum Zeichnen:
+        //! Style::Hintergrund) \param fc Die Hintergrundfarbe im A8R8G8B8
+        //! Format
+        DLLEXPORT void setHintergrundFarbe(int fc);
+        //! Setzt einen Zeiger auf das AlphaFeld (benötigt Flag zum Zeichnen:
+        //! Style::Buffered) \param buff Das AlphaFeld, das über den Hintergrund
+        //! gezeichnet werden soll
+        DLLEXPORT void setAlphaFeldZ(AlphaFeld* buff);
+        //! Setzt die Stärke des AlphaFeldes (benötigt Flag zum Zeichnen:
+        //! Style::Buffered) \param st Die Stärke des AlphaFeldes, welches über
+        //! dem Hintergrund gezeichnet werden soll
+        DLLEXPORT void setAlphaFeldStrength(int st);
+        //! Setzt die Farbe des AlphaFeldes (benötigt Flag zum Zeichnen:
+        //! Style::Buffered) \param fc Die Farbe des AlphaFeldes, welches über
+        //! dem Hintergrund gezeichnet werden soll
+        DLLEXPORT void setAlphaFeldFarbe(int fc);
+        //! Setzt einen Zeiger zu dem Linien Rahmen, der um das TextFeld
+        //! gezeichnet werden soll (benötigt Flag zum Zeichnen: Style::Rahmen)
+        //! \param ram Der Rahmen
+        DLLEXPORT void setRahmenZ(Rahmen* ram);
+        //! Setzt die Breite des Linien Rahmens (benötigt Flag zum Zeichnen:
+        //! Style::Rahmen) \param br Die Breite in Pixeln
+        DLLEXPORT void setRahmenBreite(int br);
+        //! Setzt die Farbe des Linien Rahmens (benötigt Flag zum Zeichnen:
+        //! Style::Rahmen) \param fc Die Farbe im A8R8G8B8 Format
+        DLLEXPORT void setRahmenFarbe(int fc);
+        //! Setzt die Scrollgeschwindigkeit der vertikalen ScrollBar (benötigt
+        //! Flag zum Zeichnen: Style::VScroll) \param ks Die
+        //! Scrollgeschwindigkeit in Pixeln für jeden Maus Klick
+        DLLEXPORT void setVertikalKlickScroll(int ks);
+        //! Scrollt an eine Bestimmte Stelle bei der vertikalen ScrollBar
+        //! (benötigt Flag zum Zeichnen: Style::VScroll) \param pos Das Scroll
+        //! Offset in Pixeln.
+        DLLEXPORT void setVertikalScrollPos(int pos);
+        //! Setzt die Farbe der vertikalen ScrollBar (benötigt Flag zum
+        //! Zeichnen: Style::VScroll) \param f Die Fordergrundfarbe der
+        //! ScrollBar im A8R8G8B8 Format \param bgF Die Hintergrundfarbe der
+        //! ScrollBar im A8R8G8B8 Format
+        DLLEXPORT void setVertikalScrollFarbe(int f, int bgF);
+        //! Setzt die Scrollgeschwindigkeit der horizontalen ScrollBar (benötigt
+        //! Flag zum Zeichnen: Style::HScroll) \param ks Die
+        //! Scrollgeschwindigkeit in Pixeln für jeden Maus Klick
+        DLLEXPORT void setHorizontalKlickScroll(int ks);
+        //! Scrollt an eine Bestimmte Stelle bei der horizontalen ScrollBar
+        //! (benötigt Flag zum Zeichnen: Style::HScroll) \param pos Das Scroll
+        //! Offset in Pixeln.
+        DLLEXPORT void setHorizontalScrollPos(int pos);
+        //! Setzt die Farbe der horizontalen ScrollBar (benötigt Flag zum
+        //! Zeichnen: Style::HScroll) \param f Die Fordergrundfarbe der
+        //! ScrollBar im A8R8G8B8 Format \param bgF Die Hintergrundfarbe der
+        //! ScrollBar im A8R8G8B8 Format
+        DLLEXPORT void setHorizontalScrollFarbe(int f, int bgF);
+        //! Updated den Zeichenhintergrund
+        //! \param tickVal Die vergangene Zeit in Sekunden, die seit dem Letzten
+        //! Aufruf dieser Funktion verstrichen ist \return 1, wenn das Bild neu
+        //! gezeichnet werden muss. 0 sonnst
+        DLLEXPORT bool tick(double tickVal) override;
+        //! Zeichnet den Hintergrund eines Zeichnunges nach rObj
+        DLLEXPORT void render(Bild& rObj) override;
 
-		//! Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
-		DLLEXPORT virtual int getInnenBreite() const override;
-		//! Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
-		DLLEXPORT virtual int getInnenHeight() const override;
-		//! Gibt das Hintergrundbild zurück.
-		//! \return 0, falls kein Hintergrundbild verwendet wird
-		DLLEXPORT Bild* getHintergrundBild() const;
-		//! Gibt das Hintergrundbild ohne erhöhten reference Counter zurück.
-		//! \return 0, falls kein Hintergrundbild verwendet wird
-		DLLEXPORT Bild* zHintergrundBild() const;
-		//! Gibt die Hintergrundfarbe im A8R8G8B8 Format zurück
-		DLLEXPORT int getHintergrundFarbe() const;
-		//! Gibt das AlphaFeld zurück, das über den Hintergrund gezeichnet wird.
-		//! \return 0, falls das AlphaFeld nicht definiert wurde
-		DLLEXPORT AlphaFeld* getAlphaFeld() const;
-		//! Gibt das AlphaFeld ohne erhöhten Reference Counter zurück, das über den Hintergrund gezeichnet wird.
-		//! \return 0, falls das AlphaFeld nicht definiert wurde
-		DLLEXPORT AlphaFeld* zAlphaFeld() const;
-		//! Git die Stärke des Alphafeldes zurück
-		DLLEXPORT int getAlphaFeldStrength() const;
-		//! Gibt die Farbe des Alphafedes im A8R8G8B8 Format zurück
-		DLLEXPORT int getAlphaFeldFarbe() const;
-		//! Gibt den Rahmen zurück
-		//! \return 0, falls kein Rahmen definiert wurde
-		DLLEXPORT Rahmen* getRahmen() const;
-		//! Gibt den Rahmen ohne erhöhten Reference Counter zurück
-		//! \return 0, falls kein Rahmen definiert wurde
-		DLLEXPORT Rahmen* zRahmen() const;
-		//! Gibt die Breite des Rahmens in Pixeln zurück
-		DLLEXPORT int getRahmenBreite() const;
-		//! Gibt die Farbe des Rahmens im A8R8G8B8 Format zurück
-		DLLEXPORT int getRahmenFarbe() const;
-		//! Gibt die Scroll geschwindigkeit der vertikalen Scroll Bar zurück
-		DLLEXPORT int getVertikalKlickScroll() const;
-		//! Gibt die Scroll Position der vertikalen Scroll Bar zurück
-		DLLEXPORT int getVertikalScrollPos() const;
-		//! Gibt die Farbe der vertikalen Scroll Bar im A8R8G8B8 Format zurück
-		DLLEXPORT int getVertikalScrollFarbe() const;
-		//! Gibt die Hintergrundfarbe der vertikalen Scroll Bar im A8R8G8B8 Format zurück
-		DLLEXPORT int getVertikalScrollHintergrund() const;
-		//! Gibt die Scroll geschwindigkeit der horizontalen Scroll Bar zurück
-		DLLEXPORT int getHorizontalKlickScroll() const;
-		//! Gibt die Scroll Position der horizontalen Scroll Bar zurück
-		DLLEXPORT int getHorizontalScrollPos() const;
-		//! Gibt die Farbe der horizontalen Scroll Bar im A8R8G8B8 Format zurück
-		DLLEXPORT int getHorizontalScrollFarbe() const;
-		//! Gibt die Hintergrundfarbe der horizontalen Scroll Bar im A8R8G8B8 Format zurück
-		DLLEXPORT int getHorizontalScrollHintergrund() const;
-		//! Erzeugt eine Kopie der Zeichnung, die ohne Auswirkungen auf das Original verändert werden kann
-		DLLEXPORT virtual Zeichnung* dublizieren() const;
-	};
-}
+        //! Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
+        DLLEXPORT virtual int getInnenBreite() const override;
+        //! Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
+        DLLEXPORT virtual int getInnenHeight() const override;
+        //! Gibt das Hintergrundbild zurück.
+        //! \return 0, falls kein Hintergrundbild verwendet wird
+        DLLEXPORT Bild* getHintergrundBild() const;
+        //! Gibt das Hintergrundbild ohne erhöhten reference Counter zurück.
+        //! \return 0, falls kein Hintergrundbild verwendet wird
+        DLLEXPORT Bild* zHintergrundBild() const;
+        //! Gibt die Hintergrundfarbe im A8R8G8B8 Format zurück
+        DLLEXPORT int getHintergrundFarbe() const;
+        //! Gibt das AlphaFeld zurück, das über den Hintergrund gezeichnet wird.
+        //! \return 0, falls das AlphaFeld nicht definiert wurde
+        DLLEXPORT AlphaFeld* getAlphaFeld() const;
+        //! Gibt das AlphaFeld ohne erhöhten Reference Counter zurück, das über
+        //! den Hintergrund gezeichnet wird. \return 0, falls das AlphaFeld
+        //! nicht definiert wurde
+        DLLEXPORT AlphaFeld* zAlphaFeld() const;
+        //! Git die Stärke des Alphafeldes zurück
+        DLLEXPORT int getAlphaFeldStrength() const;
+        //! Gibt die Farbe des Alphafedes im A8R8G8B8 Format zurück
+        DLLEXPORT int getAlphaFeldFarbe() const;
+        //! Gibt den Rahmen zurück
+        //! \return 0, falls kein Rahmen definiert wurde
+        DLLEXPORT Rahmen* getRahmen() const;
+        //! Gibt den Rahmen ohne erhöhten Reference Counter zurück
+        //! \return 0, falls kein Rahmen definiert wurde
+        DLLEXPORT Rahmen* zRahmen() const;
+        //! Gibt die Breite des Rahmens in Pixeln zurück
+        DLLEXPORT int getRahmenBreite() const;
+        //! Gibt die Farbe des Rahmens im A8R8G8B8 Format zurück
+        DLLEXPORT int getRahmenFarbe() const;
+        //! Gibt die Scroll geschwindigkeit der vertikalen Scroll Bar zurück
+        DLLEXPORT int getVertikalKlickScroll() const;
+        //! Gibt die Scroll Position der vertikalen Scroll Bar zurück
+        DLLEXPORT int getVertikalScrollPos() const;
+        //! Gibt die Farbe der vertikalen Scroll Bar im A8R8G8B8 Format zurück
+        DLLEXPORT int getVertikalScrollFarbe() const;
+        //! Gibt die Hintergrundfarbe der vertikalen Scroll Bar im A8R8G8B8
+        //! Format zurück
+        DLLEXPORT int getVertikalScrollHintergrund() const;
+        //! Gibt die Scroll geschwindigkeit der horizontalen Scroll Bar zurück
+        DLLEXPORT int getHorizontalKlickScroll() const;
+        //! Gibt die Scroll Position der horizontalen Scroll Bar zurück
+        DLLEXPORT int getHorizontalScrollPos() const;
+        //! Gibt die Farbe der horizontalen Scroll Bar im A8R8G8B8 Format zurück
+        DLLEXPORT int getHorizontalScrollFarbe() const;
+        //! Gibt die Hintergrundfarbe der horizontalen Scroll Bar im A8R8G8B8
+        //! Format zurück
+        DLLEXPORT int getHorizontalScrollHintergrund() const;
+        //! Erzeugt eine Kopie der Zeichnung, die ohne Auswirkungen auf das
+        //! Original verändert werden kann
+        DLLEXPORT virtual Zeichnung* dublizieren() const;
+    };
+} // namespace Framework
 
 #endif