KSG-Framework/Fenster.h

#ifndef Fenster_H
#define Fenster_H

#include "Array.h"
#include "Zeichnung.h"

namespace Framework
{
    class VScrollBar;    //! Scroll.h
    class HScrollBar;    //! Scroll.h
    class TextFeld;      //! TextFeld.h
    class Rahmen;        //! Rahmen.h
    class Bildschirm;    //! Bildschirm.h
    class AlphaFeld;     //! AlphaFeld.h
    class Schrift;       //! Schrift.h
    class Text;          //! Text.h
    class Bild;          //! Bild.h
    class WFenster;      //! aus dieser Datei
    class WFensterArray; //! aus dieser Datei
    class Fenster;       //! aus dieser Datei
#ifdef WIN32
    //! Erzeugt eine normale Fensterklasse der Windows API
    //! \param hInst Die HINSTANCE des Programms (Wird vom Framework an die
    //! Start funktion in der Startparam Struktur übergeben)
    DLLEXPORT WNDCLASS F_Normal(HINSTANCE hInst);
    //! Erzeugt eine normale Fensterklasse der Windows API
    //! \param hInst Die HINSTANCE des Programms (Wird vom Framework an die
    //! Start funktion in der Startparam Struktur übergeben)
    DLLEXPORT WNDCLASSEX F_NormalEx(HINSTANCE hInst);
    //! Funktion des Frameworks, die alle Nachichten von Windows oder anderen
    //! Prozessen verarbeitet
    DLLEXPORT LRESULT CALLBACK WindowProc(
        HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
    //! Startet eine Schleife, die die Benutzereingaben verarbeitet. Die
    //! Schleife läuft, bis irgendwo im Programm StopNachrichtenSchleife
    //! aufgerufen wird
    DLLEXPORT void StartNachrichtenSchleife();
    //! Stoppt die Ausführung der Nachrichten Schleife des Frameworks.
    //! \param hwnd Ein Handle auf ein beliebiges Fenster des Frameworks, das
    //! Nachrichten empfangen kann. Wird benötigt, um eine Nachricht zu senden,
    //! damit die funktion StartNachrichtenSchleife nicht mehr wartet und sofort
    //! beendet wird
    DLLEXPORT void StopNachrichtenSchleife(HWND hwnd);
    //! Übersetzt einen Keycode, der von Windows gesendet wurde in den
    //! Buchstaben der gedrückten Taste
    DLLEXPORT void CalculateEnteredString(
        int virtualKeyCode, int scanCode, TastaturEreignis& te);

    //! Klasse für ein Fenster der Windows API
    class WFenster : public virtual ReferenceCounter
    {
    private:
        HWND hWnd; //! Handel zum Fenster
        int style;
        void* makParam;
        void* sakParam;
        void* takParam;
        MausAktion mausAktion;
        std::function<void(void*, void*)> vCloseAktion;
        std::function<void(void*, void*)> nCloseAktion;
        TastaturAktion tastaturAktion;
        Bildschirm* screen;
        int mx, my;
        bool verschiebbar;
        HWND rahmen;
        HBITMAP bitmap;
        HDC hdc;

    public:
        //--Konstruktor--
        DLLEXPORT WFenster();
        //--Konstruktor--
        //! \param hwnd Ein Handle zum Fenster, das von dieser Klasse verwaltet
        //! werden soll
        DLLEXPORT WFenster(HWND hWnd);
        //--Destruktor--
        DLLEXPORT ~WFenster();
        //! erstellt das Fenster
        //! \param style Der Style des Fensters. Beispiel: WS_OVERLAPPEDWINDOW
        //! (Für ein normales Fenster wie man es kennt) \param wc Die
        //! Fensterklasse der Windows API, von der ein Fenster erstellt werden
        //! soll. Kann mit der Funktion F_Normal erstellt werden. Es muss
        //! lpszClassName gesetzt worden sein.
        DLLEXPORT void erstellen(int style, WNDCLASS wc);
        //! erstellt das Fenster
        //! \param exStyle Der EX Style des Fensters. Beispiel:
        //! WS_EX_OVERLAPPEDWINDOW (Für ein normales Fenster wie man es kennt)
        //! \param style Der Style des Fensters. Beispiel: WS_OVERLAPPEDWINDOW
        //! (Für ein normales Fenster wie man es kennt) \param wc Die
        //! Fensterklasse der Windows API, von der ein Fenster erstellt werden
        //! soll. Kann mit der Funktion F_Normal erstellt werden. Es muss
        //! lpszClassName gesetzt worden sein.
        DLLEXPORT void erstellenEx(int exStyle, int style, WNDCLASSEX wc);
        //! Setzt den Anzeigemodus des Fensters
        //! \param mod Der Modus. Beispiel: SW_SHOWNORMAL, um das Fenster
        //! anzuzeigen und SW_HIDE um es einzuklappen
        DLLEXPORT void setAnzeigeModus(int mod);
        //! Setzt den Fokus auf das Fenster, so dass Tastatureingaben empfangen
        //! werden
        DLLEXPORT bool setFokus();
        //! Setzt die Position des fensters auf dem Bildschirm
        //! \param pos Die Position in Pixeln
        DLLEXPORT void setPosition(const Punkt& pos);
        //! Setzt die Position des fensters auf dem Bildschirm
        //! \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 des Fensters auf dem Bildschirm
        //! \param größe Die Größe in Pixeln
        DLLEXPORT void setSize(Punkt& größe);
        //! Setzt die Größe des Fensters auf dem Bildschirm
        //! \param breite Die Breite in Pixeln
        //! \param höhe Die Höhe in Pixeln
        DLLEXPORT void setSize(int breite, int höhe);
        //! Setzt die Position und die Größe des Fensters
        //! \param pos Die Position in Pixeln
        //! \param größe Die Größe in Pixeln
        DLLEXPORT void setBounds(const Punkt& pos, const Punkt& größe);
        //! Setzt das Verwendete Bildschirm Objekt, um Tastatur und Maus
        //! Eingaben an die Objekte des Frameworks weiterzugeben. Muss vor dem
        //! Zerstören des Fensters mit 0 aufgerufen werden. \param screen Das
        //! Bildschirm Objekt
        DLLEXPORT void setBildschirm(Bildschirm* screen);
        //! Zerstört das Fenster
        DLLEXPORT void zerstören();
        //! Verarbeitet Maus Nachrichten. Ruft MausAktion auf und gibt die
        //! Ereignisse an den Bildschirm mit den Objekten weiter, wenn
        //! MausAktion 1 zurückgibt \param me Das Ereignis, was durch die
        //! Mauseingabe ausgelößt wurde
        DLLEXPORT void doMausAktion(MausEreignis& me);
        //! Ruft die VSchließAktion Rückruffunktion auf
        DLLEXPORT void doVSchließAktion();
        //! Ruft die NSchließAktion Rückruffunktion auf
        DLLEXPORT void doNSchließAktion();
        //! Verarbeitet Tastatur Nachrichten. Ruft TastaturAktion auf und gibt
        //! die Ereignisse an den Bildschirm mit den Objekten weiter, wenn
        //! TastaturAktion 1 zurückgibt \param me Das Ereignis, was durch die
        //! Tastatureingabe ausgelößt wurde
        DLLEXPORT void doTastaturAktion(TastaturEreignis& et);
        //! Macht den Rahmen des Fensters sichtbar, fals ladeRahmenFenster
        //! aufgerufen wurde
        DLLEXPORT void doRestoreMessage();
        //! 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 beim Schließen an die Rückruffunktion
        //! übergeben wird \param p Der Parameter
        DLLEXPORT void setSchließEreignisParameter(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 dem Fenster 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 setMausAktion(MausAktion ak);
        //! Setzt die Rückruffunktion, die bei vor dem Schließen aufgerufen
        //! werden soll. \param ak Ein Zeiger auf die Rückruffunktion
        DLLEXPORT void setVSchließAktion(std::function<void(void*, void*)> ak);
        //! Setzt die Rückruffunktion, die bei nach dem Schließen aufgerufen
        //! werden soll. \param ak Ein Zeiger auf die Rückruffunktion
        DLLEXPORT void setNSchließAktion(std::function<void(void*, void*)> 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 setTastaturAktion(TastaturAktion ak);
        //! Setzt das Handle zum Fenster, das von dieser Klasse verwaltet werden
        //! soll
        //! \param hwnd Das Handle
        DLLEXPORT void setFensterHandle(HWND hWnd);
        //! legt fest, ob das Fenster durch ziehen mit Maus verschoben werden
        //! kann \param verschiebbar 1, wenn das Fenster verschoben werden darf
        DLLEXPORT void setVerschiebbar(bool verschiebbar);
        //! Setzt einen Transparenten Rahmen um das Fenster
        //! \param zBild Ein Bild, was den Rahmen enthält
        //! \param hins Die HINSTANCE des Programms (Wird vom Framework an die
        //! Start funktion in der Startparam Struktur übergeben)
        DLLEXPORT void ladeRahmenFenster(Bild* zBild,
            HINSTANCE
                hinst); //! setzt einen Transpatenten Rahmen um das Fenster
        //! Gibt das Handle des verwalteten Fensters zurück
        DLLEXPORT HWND getFensterHandle() const;
        //! Gibt die Position des Fensters in Pixeln zurück
        DLLEXPORT Punkt getPosition() const;
        //! Gibt die Größe des Fensters in Pixeln zurück
        DLLEXPORT Punkt getGröße() const;
        //! Gibt die Größe des Fensterkörpers in Pixeln zurück
        DLLEXPORT Punkt getKörperGröße() const;
        //! Gibt die Breite des Fensterkörpers in Pixeln zurück
        DLLEXPORT int getKörperBreite() const;
        //! Gibt die Höhe des Fensterkörpers in Pixeln zurück
        DLLEXPORT int getKörperHöhe() const;
        //! Gibt zurück, ob eine Rückruffunktion für ein MausEreignis gesetzt
        //! wurde
        DLLEXPORT bool hatMausAktion() const;
        //! Gibt zurück, ob eine Rückruffunktion für das Ereignis vor dem
        //! Schließen des Fensters gesetzt wurde
        DLLEXPORT bool hatVSchließAktion() const;
        //! Gibt zurück, ob eine Rückruffunktion für das Ereignis nach dem
        //! Schließen des Fensters gesetzt wurde
        DLLEXPORT bool hatNSchließAktion() const;
        //! Gibt zurück, ob eine Rückruffunktion für ein TastaturEreignis
        //! gesetzt wurde
        DLLEXPORT bool hatTastaturAktion() const;
        //! Gibt den Bidschirm zurück, an dessen Zeichnungen die Ereignisse
        //! Weitergegeben werden
        DLLEXPORT Bildschirm* getBildschirm() const;
        //! Gibt den Bildschirm ohne erhöhten Reference Counter zurück, an
        //! dessen Zeichnungen die Ereignisse Weitergegeben werden
        DLLEXPORT Bildschirm* zBildschirm() const;
        //! Gibt zurück, ob das Fenster verschiebbar ist
        DLLEXPORT bool istVerschiebbar() const;
    };

    //! Verwaltet alle Windows API Fenster im Framework
    class WFensterArray
    {
    private:
        WFensterArray* next;
        WFenster* This;

    public:
        //! Konstruktor
        DLLEXPORT WFensterArray();
        //! Destruktor
        DLLEXPORT ~WFensterArray();
        //! Fügt ein neues Fenster hinzu
        //! \param fenster Das Fenster
        DLLEXPORT bool addFenster(WFenster* fenster);
        //! Entfernt ein Fenster
        //! \param fenster Das Fenster
        DLLEXPORT bool removeFenster(WFenster* fenster);
        //! gibt das nächste Element zurück
        DLLEXPORT WFensterArray* getNext();
        //! Setzt das nächste Element auf 0
        DLLEXPORT void setNext0();
        //! Löscht das Element
        DLLEXPORT void del();
        //! Sendet das Ereignis, was vor dem Schließen aufgerufen wird an ein
        //! bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendVSchließMessage(HWND hWnd);
        //! Sendet das Ereignis, was nach dem Schließen aufgerufen wird an ein
        //! bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendNSchließMessage(HWND hwnd);
        //! Sendet ein Maus Ereignis an ein bestimmtes Fenster
        //! \param hWnd Das Handle zum Fenster
        //! \param me Das Ereignis, was durch die Mauseingabe ausgelößt wurde
        DLLEXPORT bool sendMausMessage(HWND hWnd, MausEreignis& me);
        //! Sendet ein Tastatur Ereignis an ein bestimmtes Fenster
        //! \param hWnd Das Handle zum Fenster
        //! \param me Das Ereignis, was durch die Tastatureingabe ausgelößt
        //! wurde
        DLLEXPORT bool sendTastaturMessage(HWND hwnd, TastaturEreignis& te);
        //! Sendet das Ereignis, was durch das öffnen des Fensters ausgelößt
        //! wurde an ein bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendRestoreMessage(HWND hwnd);
        //! Gibt das Fenster dieses Eintrags zurück
        DLLEXPORT WFenster* getThis();
    };

    //! Erzeugt ein Windows API Popup Fenster, mit einer Meldung
    //! \param hWnd Ein Handle zu dem Fenster, was blockiert werden soll, bis
    //! das Popup Fenster geschlossen wurde. Kann 0 sein \param titel Der Titel
    //! des Popup Fensters \param meldung Die Meldung, die im Fenster angezeigt
    //! werden soll \param style Bestimmt das Icon, was im Fenster angezeigt
    //! wird. Beispiel: MB_ICONERROR, MB_ICONINFORMATION
    DLLEXPORT void WMessageBox(
        HWND hWnd, Text* titel, Text* meldung, UINT style);
#endif
    //! Fenster Klasse im Programm
    class Fenster : public Zeichnung
    {
    public:
        class Style : public Zeichnung::Style
        {
        public:
            //! Legt fest, ob der Körper des Fensters einen Hintergrund hat
            static const __int64 BodyHintergrund = 0x000000008;
            //! Legt fest, ob beim zeichnen des Körperhintergrundes alpha
            //! blending verwendet werden soll
            static const __int64 BodyHAlpha = 0x000000010;
            //! Legt fest, ob ein Bild als Hintergrund des Körpers verwendet
            //! werden soll
            static const __int64 BodyHBild = 0x000000020;
            //! Legt fest, ob der Körper einen Farbübergang besitzt
            static const __int64 BodyBuffered = 0x000000040;
            //! Legt fest, ob das Fenster eine Titelleiste hat
            static const __int64 Titel = 0x000000080;
            //! Legt fest, ob die titelleiste des Fensters einen Hintergrund hat
            static const __int64 TitelHintergrund = 0x000000100;
            //! Legt fest, ob zum zeichnen des Titel Hintergrundes alpha
            //! blending soll
            static const __int64 TitelHAlpha = 0x000000200;
            //! Legt fest, ob für den Titelhintergrund ein Bild verwendet werden
            //! soll
            static const __int64 TitelHBild = 0x000000400;
            //! Legt fest, ob die Titel Leiste einen Farbübergang besitzt
            static const __int64 TitelBuffered = 0x000000800;
            //! Legt fest, ob in der Titelleiste ein Knopf zum Schließen des
            //! Fensters angezeigt werden soll
            static const __int64 Closable = 0x000001000;
            //! Legt fest, ob der Schließen Knopf einen Hintergrund hat
            static const __int64 ClosingHintergrund = 0x000002000;
            //! Legt fest, ob beim Zeichnen des Hintergrunds des Schließen
            //! Knopfes alpha blending verwendet werden soll
            static const __int64 ClosingHAlpha = 0x000004000;
            //! Legt fest, ob für den Hintergrund des Schließen Knopfes ein Bild
            //! soll
            static const __int64 ClosingHBild = 0x000008000;
            //! Legt fest, ob der Schließen Knopf einen Farbübergang besitzt
            static const __int64 ClosingBuffer = 0x000010000;
            //! Legt fest, ob der Schließen Knopf einen Farbübergang besitzt,
            //! während er gedrückt wird
            static const __int64 ClosingKlickBuffer = 0x000020000;
            //! Legt fest, ob der Benutzer das Fenster durch gedrückt halten der
            //! linken Maustaste in der Titelleiste das Fenster verschieben kann
            static const __int64 Beweglich = 0x000040000;
            //! Legt fest, ob der Benutzer die Breite des Fensters durch das
            //! gedrückt halten der linken Maustaste auf dem rechten oder linken
            //! Fensterrand verändern kann
            static const __int64 BreiteChangeable = 0x000080000;
            //! Legt fest, ob der Benutzer die Höhe des Fensters durch das
            //! gedrückt halten der linken Maustaste auf dem oberen oder unteren
            //! Fensterrand verändern kann
            static const __int64 HeightChangeable = 0x000100000;
            //! Legt fest, ob der Benutzer die Höhe der Titel Leiste durch
            //! gedrückt halten der linken Maustaste auf dem unteren Rand der
            //! Titelleiste verändern kann
            static const __int64 TitelHeightChangeable = 0x000200000;
            //! Legt fest, ob es eine Minimale Breite des Fensters gibt
            static const __int64 MinBr = 0x000400000;
            //! Legt fest, ob es eine Maximale Breite des Fensters gibt
            static const __int64 MaxBr = 0x000800000;
            //! Legt fest, ob es eine Minimale Höhe des Fensters gibt
            static const __int64 MinHi = 0x001000000;
            //! Legt fest, ob es eine Maximale Höhe des Fensters gibt
            static const __int64 MaxHi = 0x002000000;
            //! Legt fest, ob es eine Minimale Breite des Körpers gibt
            static const __int64 BodyMinBr = 0x004000000;
            //! Legt fest, ob es eine Maximale Breite des Körpers gibt
            static const __int64 BodyMaxBr = 0x008000000;
            //! Legt fest, ob es eine Minimale Höhe des Körpers gibt
            static const __int64 BodyMinHi = 0x010000000;
            //! Legt fest, ob es eine Maximale Höhe des Körpers gibt
            static const __int64 BodyMaxHi = 0x020000000;
            //! Legt fest, ob eine ScrollBar am rechten Fensterrand erscheinen
            //! soll
            static const __int64 VScroll = 0x040000000;
            //! Legt fest, ob eine ScrollBar am unteren Fensterrand erscheinen
            //! soll
            static const __int64 HScroll = 0x080000000;
            //! Legt fest, ob die Mausereignisse auch noch von Zeichnungen
            //! hinter dem Fenster verarbeitet werden sollen
            static const __int64 METransparenz = 0x100000000;
            //! Legt fest, ob das Fenster einen Rahmen haben soll
            static const __int64 Rahmen = 0x200000000;
            //! Legt fest, ob die linke Seite des Fensters fixiert ist wenn die
            //! größe änderbar ist
            static const __int64 LeftPositionFixed = 0x400000000;
            //! Legt fest, ob die rechte Seite des Fensters fixiert ist wenn die
            //! größe änderbar ist
            static const __int64 RightPositionFixed = 0x800000000;
            //! Legt fest, ob die obere Seite des Fensters fixiert ist wenn die
            //! größe änderbar ist
            static const __int64 TopPositionFixed = 0x1000000000;
            //! Legt fest, ob die untere Seite des Fensters fixiert ist wenn die
            //! größe änderbar ist
            static const __int64 BottomPositionFixed = 0x2000000000;
            //! Legt fest, ob die Position und Größe des Titel Textfeldes
            //! unverändert bleiben soll
            static const __int64 CustomTitle = 0x4000000000;
            //! Vereint die Flags MinHö, MaxHö, MaxBr, MaxHö
            static const __int64 min_max = MinHi | MaxHi | MaxBr | MaxHi;
            //! Vereint die Flags Körper_minBr, Körper_maxBr, Körper_minHö,
            //! Körper_maxBr
            static const __int64 body_min_max
                = BodyMinBr | BodyMaxBr | BodyMinHi | BodyMaxBr;
            //! Vereint die Flags VScroll, HScroll
            static const __int64 scroll = VScroll | HScroll;
            //! Vereint die Flags TitelHöheÄnderbar, HöheÄnderbar,
            //! BreiteÄnderbar, Beweglich
            static const __int64 nichtfixiert = TitelHeightChangeable
                                              | HeightChangeable
                                              | BreiteChangeable | Beweglich;

            //! Vereint die Flags Sichtbar, Erlaubt, Rahmen, Titel,
            //! TitelBuffered, Schließbar, SchließHBild, SchließKlickBuffer,
            //! Beweglich
            static const __int64 normal
                = Sichtbar | Erlaubt | Rahmen | Titel | TitelBuffered | Closable
                | ClosingHBild | ClosingKlickBuffer | Beweglich
                | MEIgnoreVerarbeitet | MEIgnoreSichtbar | MEIgnoreParentInside
                | MEIgnoreInside;
        };

    private:
        MausAktion closingMe;
        void* closingMeParam;
        Rahmen* rahmen;
        TextFeld* titel;
        RCArray<Zeichnung>* members;
        int bgBodyColor;
        Bild* bgBodyPicture;
        AlphaFeld* bodyBuffer;
        int bgClosingFarbe;
        Bild* bgClosingBild;
        AlphaFeld* closeBuffer;
        AlphaFeld* closeKlickBuffer;
        VScrollBar* vScroll;
        HScrollBar* hScroll;
        Punkt min, max;
        Punkt kMin, kMax;
        bool closeKlick, klick;
        int moving;
        int mx, my;

    protected:
        //! Verarbeitet Maus Nachrichten
        //! \param me Das Ereignis, was durch die Mauseingabe ausgelößt wurde
        DLLEXPORT void doMausEreignis(MausEreignis& me, bool userRet) override;

    public:
        //! Konstruktor
        DLLEXPORT Fenster();
        //! Destruktor
        DLLEXPORT virtual ~Fenster();
        //! Setzt einen Zeiger auf den Rahmen des Fensters
        //! \param ram Der Rahmen
        DLLEXPORT void setRahmenZ(Rahmen* ram);
        //! Setzt die Farbe des Fensterrahmens
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setRFarbe(int f);
        //! Setzt die Breite des Fensterrahmens
        //! \param br Die Breite in Pixeln
        DLLEXPORT void setRBreite(int br);
        //! Setzt den Titel des Fensters
        //! \param txt Der Text
        DLLEXPORT void setTitel(Text* txt);
        //! Setzt einen Zeiger auf den Titel Text
        //! \param txt Der neue Text
        DLLEXPORT void setTitelZ(Text* txt);
        //! Setzt den Titel des Fensters
        //! \param txt Der Textv
        DLLEXPORT void setTitel(const char* txt);
        //! Setzt einen Zeiger auf das TextFeld, das den Titeltext zeichnet
        //! \param tf Das TextFeld
        DLLEXPORT void setTTextFeldZ(TextFeld* tf);
        //! Setzt die Schrift, die für den Titel verwendet werden soll
        //! \param schrift Die Schrift
        DLLEXPORT void setTSchriftZ(Schrift* schrift);
        //! Setzt die Farbe der Schrift, die für den Titel verwendet werden soll
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTSFarbe(int f);
        //! Setzt die Größe der Schrift, die für den Titel verwendet werden soll
        //! \param gr Die Höhe einer zeile in Pixeln
        DLLEXPORT void setTSSize(int gr);
        //! Setzt die Hintergrund Farbe des Titels
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTBgFarbe(int f);
        //! Setzt einen Zeiger auf den Farbübergang des Titels
        //! \param af Der Farbübergang
        DLLEXPORT void setTAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbübergangs des Titels
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTAfFarbe(int f);
        //! Setzt die Stärke des Farbübergangs des Titels
        //! \param st Die Stärke
        DLLEXPORT void setTAfStrength(int st);
        //! Setzt das Hintergrund Bild des Titels durch kopieren
        //! \param b Das Bild, was kopiert werden soll
        DLLEXPORT void setTBgBild(Bild* b);
        //! Setzt einen Zeiger auf das Hintergrund Bild des Titels
        //! \param b Das Bild
        DLLEXPORT void setTBgBildZ(Bild* b);
        //! Setzt einen Zeiger auf den Rahmen des Titels
        //! \param ram Der Rahmen
        DLLEXPORT void setTRahmenZ(Rahmen* ram);
        //! Setzt die Farbe des Rahmens des Titels
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTRFarbe(int f);
        //! Setzt die Breite des Rahmens des Titels
        //! \param br Die Breite in Pixeln
        DLLEXPORT void setTRBreite(int br);
        //! Setzt die Hintergrundfarbe des Körpers
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setKBgFarbe(int f);
        //! Setzt das Hintergrund Bild des Körpers durch kopieren
        //! \param b Das Bild, das kopiert werden soll
        DLLEXPORT void setKBgBild(Bild* b);
        //! Setzt einen Zeiger auf das Hintergrund Bild des Körpers
        //! \param b Das Bild
        DLLEXPORT void setKBgBildZ(Bild* b);
        //! Setzt einen Zeiger auf den Farbübergang des Körpers
        //! \param af Der Farbübergang
        DLLEXPORT void setKAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbübergangs des Körpers
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setKAfFarbe(int f);
        //! Setzt die Stärke des Farbübergangs des Körpers
        //! \param st Die Stärke
        DLLEXPORT void setKAfStrength(int st);
        //! Setzt den Parameter der Rückruffunktion, die aufgerufen wird, wenn
        //! der Schließen Knopf ein MausEreignis erhält \param param Der
        //! Parameter
        DLLEXPORT void setClosingMeParam(void* param);
        //! Setzt die Rückruffunktion, die Aufgerufen wird, wenn der Schließen
        //! Knopf ein MausEreignis erhält Wenn die Rückruffunktion 0
        //! zurückgiebt, oder nicht gesetzt wurde, wird ein Maus Ereignis von
        //! der Zeichnung nicht weiter beachtet Das Fenster wird nicht von
        //! selbst geschlossen, sondern sollte in der Rückruffunktion durch den
        //! aufruf von löscheStyle( Fenster::Style::Sichtbar ); geschlossen
        //! werden \param ak Ein Zeiger auf die Rückruffunktion
        DLLEXPORT void setClosingMe(MausAktion closingMe);
        //! Setzt die Hintergrund Farbe des Schließen Knopfes
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSBgFarbe(int f);
        //! Setzt das Hintergrund Bild des Schließen Knopfes durch kopieren
        //! \param b Das Bild, das kopiert werden soll
        DLLEXPORT void setSBgBild(Bild* b);
        //! Setzt einen Zeiger auf das Hintergrund Bild des Schließen Knopfes
        //! \param b Das Bild
        DLLEXPORT void setSBgBildZ(Bild* b);
        //! Setzt einen Zeiger auf den Farbübergang des Schließen Knopfes
        //! \param af Der Farbübergang
        DLLEXPORT void setSAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbübergangs des Schließen Knopfes
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSAfFarbe(int f);
        //! Setzt die Stärke des Farbübergangs des Schließen Knopfes
        //! \param st Die Stärke
        DLLEXPORT void setSAfStrength(int st);
        //! Setzt einen Zeiger auf den Farbübergang, der beim Klicken des
        //! Schließen Knopfes verwendet wird \param af Der Farbübergnag
        DLLEXPORT void setSKAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbübergangs, der beim Klicken des Schließen
        //! Knopfes verwendet wird \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSKAfFarbe(int f);
        //! Setzt die Stärke des Farbübergangs, der beim Klicken des Schließen
        //! Knopfes verwendet wird \param st Die Stärke
        DLLEXPORT void setSKAfStrength(int st);
        //! Setzt die Minimale Größe des Fensters
        //! \param mx Die Minimale Breite in Pixeln
        //! \param my Die Minimale Höhe in Pixeln
        DLLEXPORT void setMin(int mx, int my);
        //! Setzt die Minimale Größe des Fensters
        //! \param min Die Minimale Breite und Höhe in Pixeln
        DLLEXPORT void setMin(const Punkt& min);
        //! Setzt die Maximale Größe des Fensters
        //! \param mx Die Maximale Breite in Pixeln
        //! \param my Die Maximale Höhe in Pixeln
        DLLEXPORT void setMax(int mx, int my);
        //! Setzt die Maximale Größe des Fensters
        //! \param min Die Maximale Breite und Höhe in Pixeln
        DLLEXPORT void setMax(const Punkt& max);
        //! Setzt die Minimale Größe des Fenster Körpers
        //! \param mx Die Minimale Breite in Pixeln
        //! \param my Die Minimale Höhe in Pixeln
        DLLEXPORT void setKMin(int mx, int my);
        //! Setzt die Minimale Größe des Fenster Körpers
        //! \param min Die Minimale Breite und Höhe in Pixeln
        DLLEXPORT void setKMin(const Punkt& min);
        //! Setzt die Maximale Größe des Fenster Körpers
        //! \param mx Die Maximale Breite in Pixeln
        //! \param my Die Maximale Höhe in Pixeln
        DLLEXPORT void setKMax(int mx, int my);
        //! Setzt die Maximale Größe des Fenster Körpers
        //! \param min Die Maximale Breite und Höhe in Pixeln
        DLLEXPORT void setKMax(const Punkt& max);
        //! Setzt einen Zeiger auf die Scrollbar am unteren Rand des Fensters
        //! \param hScroll Die Scrollbar
        DLLEXPORT void setHScrollBarZ(HScrollBar* hScroll);
        //! Setzt einen Zeiger auf die Scrollbar am rechten Rand des Fensters
        //! \param vScroll Die Scrollbar
        DLLEXPORT void setVScrollBarZ(VScrollBar* vScroll);
        //! Setzt die Maximale Scroll breite des Fenster Körpers
        //! \param max Die Breite in Pixeln
        DLLEXPORT void setHSBMax(int max);
        //! Setzt die Maximale Scroll höhe des Fenster Körpers
        //! \param max Die Höhe in Pixeln
        DLLEXPORT void setVSBMax(int max);
        //! Scrollt zu einer bestimmten x Position im Fenster Körper
        //! \param scroll Die Anzahl der Pixel, die der Inhalt nach links
        //! verschoben werden soll
        DLLEXPORT void setHSBScroll(int scroll);
        //! Scrollt zu einer bestimmten y Position im Fenster Körper
        //! \param scroll Die Anzahl der Pixel, die der Inhalt nach oben
        //! verschoben werden soll
        DLLEXPORT void setVSBScroll(int scroll);
        //! Updates the horizontal scrollbar so that the max scroll size is set
        //! to the width of the content
        DLLEXPORT void updateHScroll();
        //! Updates the vertical scrollbar so that the max scroll size is set to
        //! the height of the content
        DLLEXPORT void updateVScroll();
        //! Fügt dem Fenster eine Zeichnung hinzu
        //! \param obj Die Zeichnung
        DLLEXPORT virtual void addMember(Zeichnung* obj);
        //! sets the position of a member to index. This changes the order of
        //! rendering and the order input events are processed
        DLLEXPORT void setMemberIndex(Zeichnung* zMember, int index);
        //! Entfernt eine Zeichnung aus dem Fenster
        //! \param zObj Die Zeichnung (ohne erhöhten reference Counter)
        DLLEXPORT virtual void removeMember(Zeichnung* zObj);
        //! Entfernt alle Zeichnungen aus dem Fenster
        DLLEXPORT virtual void removeAll();
        //! Aktualisiert das Objekt. Wird vom Framework aufgerufen
        //! \param tickVal Die Zeit in sekunden, die seit dem lezten Aufruf
        //! dieser Funktion vergangen ist \return 1, wenn sich etwas verändert
        //! hat und das Bild neu gezeichnet werden muss. 0 sonst
        DLLEXPORT bool tick(double tickval) override;
        //! Verarbeitet Tastatur Nachrichten
        //! \param me Das Ereignis, was durch die Tastatureingabe ausgelößt
        //! wurde
        DLLEXPORT void doTastaturEreignis(TastaturEreignis& te) override;
        //! Zeichnet das Fentster nach zRObj, falls es sichtbar ist
        //! \param zRObj Das Bild, in welches gezeichnet werden soll
        DLLEXPORT void render(Bild& zRObj) override;
        //! Gibt die Breite des Innenraumes in der Zeichnung in Pixeln zurück
        DLLEXPORT int getInnenBreite() const override;
        //! Gibt die Höhe des Innenraumes in der Zeichnung in Pixeln zurück
        DLLEXPORT int getInnenHeight() const override;
        //! Gibt den Rahmen des Fensters zurück
        DLLEXPORT Rahmen* getRahmen() const;
        //! Gibt den Rahmen des Fensters ohne erhöhen Reference Counter zurück
        DLLEXPORT Rahmen* zRahmen() const;
        //! Gibt die Farbe des Rahmens des Fensters im A8R8G8B8 Format zurück
        DLLEXPORT int getRFarbe() const;
        //! Gibt die Breite des Rahmens des Fensters in Pixeln zurück
        DLLEXPORT int getRBreite() const;
        //! Gibt den Titel des Fensters zurück
        DLLEXPORT Text* getTitel() const;
        //! Gibt den Titel des Fensters ohne erhöhten Reference Counter zurück
        DLLEXPORT Text* zTitel() const;
        //! Gibt das TextFeld zurück, das zum Zeichnen des Titels verwendet wird
        DLLEXPORT TextFeld* getTTextFeld() const;
        //! Gibt das TextFeld ohne erhöhten Reference Counter zurück, das zum
        //! Zeichnen des Titels verwendet wird
        DLLEXPORT TextFeld* zTTextFeld() const;
        //! Gibt die Schrift zurück, die für den Titel verwendet wird
        DLLEXPORT Schrift* getTSchrift() const;
        //! Gibt die Schrift ohne erhöten Reference Counter zurück, die für den
        //! Titel verwendet wird
        DLLEXPORT Schrift* zTSchrift() const;
        //! Gibt die Schrift Farbe des Titels im A8R8G8B8 Format zurück
        DLLEXPORT int getTSFarbe() const;
        //! Gibt die Höhe einer Zeile des Titels in Pixeln zurück
        DLLEXPORT int getTSSize() const;
        //! Gibt die Hintergrundfarbe des Titels im A8R8G8B8 Format zurück
        DLLEXPORT int getTBgFarbe() const;
        //! Gibt den Farbübergang des Titels zurück
        DLLEXPORT AlphaFeld* getTAlphaFeld() const;
        //! Gibt den Farbübergang des Titels ohne erhöhten Reference COunter
        //! zurück
        DLLEXPORT AlphaFeld* zTAlphaFeld() const;
        //! Gibt die Farbe des Farbübergangs des Titels im A8R8G8B8 Format
        //! zurück
        DLLEXPORT int getTAfFarbe() const;
        //! Gibt die Stärke des Farbübergangs des Titels zurück
        DLLEXPORT int getTAfStrength() const;
        //! Gibt das Hintergrund Bild des titels zurück
        DLLEXPORT Bild* getTBgBild() const;
        //! Gibt das Hintergrund Bild des titels ohne erhöhten Reference Counter
        //! zurück
        DLLEXPORT Bild* zTBgBild() const;
        //! Gibt den Rahmen des Titels zurück
        DLLEXPORT Rahmen* getTRahmen() const;
        //! Gibt den Rahmen des Titels ohne erhöhten Reference Counter zurück
        DLLEXPORT Rahmen* zTRahmen() const;
        //! Gibt die Farbe des Rahmens des Titels im A8R8G8B8 Format zurück
        DLLEXPORT int getTRFarbe() const;
        //! Gibt die Stärke des Rahmens des Titels zurück
        DLLEXPORT int getTRBreite() const;
        //! Gibt die Hintergrund Farbe des Körpers zurück
        DLLEXPORT int getKBgFarbe() const;
        //! Gibt das Hintergrund Bild des Körpers zurück
        DLLEXPORT Bild* getKBgBild() const;
        //! Gibt das Hintergrund Bild des Körpers ohne erhöhten Reference
        //! Counter zurück
        DLLEXPORT Bild* zKBgBild() const;
        //! Gibt den Farbübergang des Körpers zurück
        DLLEXPORT AlphaFeld* getKAlphaFeld() const;
        //! Gibt den Farbübergang des Körpers ohne erhöhten Reference Counter
        //! zurück
        DLLEXPORT AlphaFeld* zKAlphaFeld() const;
        //! Gibt die Farbe des Farbübergangs des Körpers im A8R8G8B8 Format
        //! zurück
        DLLEXPORT int getKAfFarbe() const;
        //! Gibt die Stärke des Farbübergangs des Körpers zurück
        DLLEXPORT int getKAfStrength() const;
        //! Gibt die Hintergrund Farbe des Schließen Knopfes im A8R8G8B8 Format
        //! zurück
        DLLEXPORT int getSBgFarbe() const;
        //! Gibt das Hintergrund Bild des Schließen Knopfes zurück
        DLLEXPORT Bild* getSBgBild() const;
        //! Gibt das Hintergrund Bild des Schließen Knopfes ohne erhöhten
        //! Reference COunter zurück
        DLLEXPORT Bild* zSBgBild() const;
        //! Gibt den Farbübergang des Schließen Knopfes zurück
        DLLEXPORT AlphaFeld* getSAlphaFeld() const;
        //! Gibt den Farbübergang des Schließen Knopfes ohne erhöhten Reference
        //! COunter zurück
        DLLEXPORT AlphaFeld* zSAlphaFeld() const;
        //! Gibt die Farbe des Farbübergangs des Schließen Knopfes im A8R8G8B8
        //! Format zurück
        DLLEXPORT int getSAfFarbe() const;
        //! Gibt die Stärke des Farbübergangs des Schließen Knopfes zurück
        DLLEXPORT int getSAfStrength() const;
        //! Gibt den Farbübergang zurück, der verwendet wird, wenn auf den
        //! Schließen Knopf gedrückt wird
        DLLEXPORT AlphaFeld* getSKAlphaFeld() const;
        //! Gibt den Farbübergang ohne erhöhten Reference Counter zurück, der
        //! verwendet wird, wenn auf den Schließen Knopf gedrückt wird
        DLLEXPORT AlphaFeld* zSKAlphaFeld() const;
        //! Gibt die Farbe des Farbübergangs im A8R8G8B8 Format zurück, der
        //! verwendet wird, wenn auf den Schließen Knopf gedrückt wird
        DLLEXPORT int getSKAfFarbe() const;
        //! Gibt die Stärke des Farbübergangs zurück, der verwendet wird, wenn
        //! auf den Schließen Knopf gedrückt wird
        DLLEXPORT int getSKAfStrength() const;
        //! Gibt die minimale Fenstergröße in Pixeln zurück
        DLLEXPORT const Punkt& getMin() const;
        //! Gibt die maximale Fenstergröße in Pixeln zurück
        DLLEXPORT const Punkt& getMax() const;
        //! Gibt die minimale Körpergröße in Pixeln zurück
        DLLEXPORT const Punkt& getKMin() const;
        //! Gibt die maximale Körpergröße in Pixeln zurück
        DLLEXPORT const Punkt& getKMax() const;
        //! Gibt die Scrollbar vom rechten Fensterrand zurück
        DLLEXPORT VScrollBar* getVScrollBar() const;
        //! Gibt die Scrollbar vom rechten Fensterrand ohne erhöhten Reference
        //! Counter zurück
        DLLEXPORT VScrollBar* zVScrollBar() const;
        //! Gibt die Scrollbar vom unteren Fensterrand zurück
        DLLEXPORT HScrollBar* getHScrollBar() const;
        //! Gibt die Scrollbar vom unteren Fensterrand ohne erhöhten Reference
        //! Counter zurück
        DLLEXPORT HScrollBar* zHScrollBar() const;
        //! Gibt eine Liste mit Zeichnungen zurück, die im Fenster sind
        DLLEXPORT const RCArray<Zeichnung>& getMembers() const;
        //! Gibt die von den kindern benötigte Breite des Fensters zurück
        DLLEXPORT int getNeededChildWidth() const;
        //! Gibt die von den kindern benötigte Höhe des Fensters zurück
        DLLEXPORT int getNeededChildHeight() const;
        //! Erzeugt eine Kopie des Fensters, die ohne Auswirkungen auf das
        //! Original verändert werden kann
        DLLEXPORT Zeichnung* dublizieren() const override;
    };
} // namespace Framework
#endif