#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;      //! from this file
    class WFensterArray; //! from this file
    class Fenster;       //! from this file
#ifdef WIN32
    //! Creates a normal window class of the Windows API
    //! \param hInst The HINSTANCE of the program (passed by the Framework to
    //! the start function in the Startparam structure)
    DLLEXPORT WNDCLASS F_Normal(HINSTANCE hInst);
    //! Creates a normal window class of the Windows API
    //! \param hInst The HINSTANCE of the program (passed by the Framework to
    //! the start function in the Startparam structure)
    DLLEXPORT WNDCLASSEX F_NormalEx(HINSTANCE hInst);
    //! Framework function that processes all messages from Windows or other
    //! processes
    DLLEXPORT LRESULT CALLBACK WindowProc(
        HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
    //! Starts a loop that processes user input. The loop runs until
    //! StopNachrichtenSchleife is called somewhere in the program
    DLLEXPORT void StartNachrichtenSchleife();
    //! Stops the execution of the framework's message loop.
    //! \param hwnd A handle to any framework window that can receive
    //! messages. Required to send a message so that StartNachrichtenSchleife
    //! stops waiting and exits immediately
    DLLEXPORT void StopNachrichtenSchleife(HWND hwnd);
    //! Translates a keycode sent by Windows into the character of the
    //! pressed key
    DLLEXPORT void CalculateEnteredString(
        int virtualKeyCode, int scanCode, TastaturEreignis& te);

    //! Class for a Windows API window
    class WFenster : public virtual ReferenceCounter
    {
    private:
        HWND hWnd; //! Handle to the window
        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:
        //--Constructor--
        DLLEXPORT WFenster();
        //--Constructor--
        //! \param hwnd A handle to the window that should be managed by this
        //! class
        DLLEXPORT WFenster(HWND hWnd);
        //--Destructor--
        DLLEXPORT ~WFenster();
        //! Creates the window
        //! \param style The style of the window. Example: WS_OVERLAPPEDWINDOW
        //! (for a normal window) \param wc The Windows API window class from
        //! which a window should be created. Can be created with the F_Normal
        //! function. lpszClassName must have been set.
        DLLEXPORT void erstellen(int style, WNDCLASS wc);
        //! Creates the window
        //! \param exStyle The EX style of the window. Example:
        //! WS_EX_OVERLAPPEDWINDOW (for a normal window)
        //! \param style The style of the window. Example: WS_OVERLAPPEDWINDOW
        //! (for a normal window) \param wc The Windows API window class from
        //! which a window should be created. Can be created with the F_Normal
        //! function. lpszClassName must have been set.
        DLLEXPORT void erstellenEx(int exStyle, int style, WNDCLASSEX wc);
        //! Sets the display mode of the window
        //! \param mod The mode. Example: SW_SHOWNORMAL to show the window
        //! and SW_HIDE to minimize it
        DLLEXPORT void setAnzeigeModus(int mod);
        //! Sets the focus to the window so that keyboard input is received
        DLLEXPORT bool setFokus();
        //! Sets the position of the window on the screen
        //! \param pos The position in pixels
        DLLEXPORT void setPosition(const Punkt& pos);
        //! Sets the position of the window on the screen
        //! \param x The X position in pixels
        //! \param y The Y position in pixels
        DLLEXPORT void setPosition(int x, int y);
        //! Sets the size of the window on the screen
        //! \param gr\u00f6\u00dfe The size in pixels
        DLLEXPORT void setSize(Punkt& groesse);
        //! Sets the size of the window on the screen
        //! \param breite The width in pixels
        //! \param h\u00f6he The height in pixels
        DLLEXPORT void setSize(int breite, int hoehe);
        //! Sets the position and size of the window
        //! \param pos The position in pixels
        //! \param gr\u00f6\u00dfe The size in pixels
        DLLEXPORT void setBounds(const Punkt& pos, const Punkt& groesse);
        //! Sets the screen object used to forward keyboard and mouse input
        //! to the framework's objects. Must be called with 0 before the
        //! window is destroyed. \param screen The screen object
        DLLEXPORT void setBildschirm(Bildschirm* screen);
        //! Destroys the window
        DLLEXPORT void zerstoeren();
        //! Processes mouse messages. Calls MausAktion and forwards events
        //! to the screen with objects if MausAktion returns 1
        //! \param me The event triggered by the mouse input
        DLLEXPORT void doMausAktion(MausEreignis& me);
        //! Calls the pre-close callback function
        DLLEXPORT void doVSchliessAktion();
        //! Calls the post-close callback function
        DLLEXPORT void doNSchliessAktion();
        //! Processes keyboard messages. Calls TastaturAktion and forwards
        //! events to the screen with objects if TastaturAktion returns 1
        //! \param me The event triggered by the keyboard input
        DLLEXPORT void doTastaturAktion(TastaturEreignis& et);
        //! Makes the window frame visible if ladeRahmenFenster was called
        DLLEXPORT void doRestoreMessage();
        //! Sets the parameter passed to the callback function on a mouse event
        //! \param p The parameter
        DLLEXPORT void setMausEreignisParameter(void* p);
        //! Sets the parameter passed to the callback function on close
        //! \param p The parameter
        DLLEXPORT void setSchliessEreignisParameter(void* p);
        //! Sets the parameter passed to the callback function on a keyboard
        //! event
        //! \param p The parameter
        DLLEXPORT void setTastaturEreignisParameter(void* p);
        //! Sets the callback function to be called on a mouse event.
        //! If the callback returns 0 or was not set, the mouse event is not
        //! further processed by the window. The standard function __ret1ME
        //! can be used, defined in MausEreignis.h and always returns 1
        //! \param ak A pointer to the callback function
        DLLEXPORT void setMausAktion(MausAktion ak);
        //! Sets the callback function to be called before closing.
        //! \param ak A pointer to the callback function
        DLLEXPORT void setVSchliessAktion(std::function<void(void*, void*)> ak);
        //! Sets the callback function to be called after closing.
        //! \param ak A pointer to the callback function
        DLLEXPORT void setNSchliessAktion(std::function<void(void*, void*)> ak);
        //! Sets the callback function to be called on a keyboard event.
        //! If the callback returns 0 or was not set, the keyboard event is not
        //! further processed. The standard function __ret1TE can be used,
        //! defined in TastaturEreignis.h and always returns 1. Other standard
        //! functions are _nurNummernTE and _nurHexTE also from
        //! TastaturEreignis.h \param ak A pointer to the callback function
        DLLEXPORT void setTastaturAktion(TastaturAktion ak);
        //! Sets the handle to the window that should be managed by this class
        //! \param hwnd The handle
        DLLEXPORT void setFensterHandle(HWND hWnd);
        //! Specifies whether the window can be moved by dragging with the mouse
        //! \param verschiebbar 1 if the window may be moved
        DLLEXPORT void setVerschiebbar(bool verschiebbar);
        //! Setzt einen Transparenten Rahmen um das Fenster
        //! \param zBild Ein Bild, was den Rahmen enthaelt
        //! \param hins Die HINSTANCE des Programms (Wird vom Framework an die
        //! Start funktion in der Startparam Struktur uebergeben)
        DLLEXPORT void ladeRahmenFenster(Bild* zBild,
            HINSTANCE
                hinst); //! setzt einen Transpatenten Rahmen um das Fenster
        //! Gibt das Handle des verwalteten Fensters zurueck
        DLLEXPORT HWND getFensterHandle() const;
        //! Gibt die Position des Fensters in Pixeln zurueck
        DLLEXPORT Punkt getPosition() const;
        //! Gibt die Groesse des Fensters in Pixeln zurueck
        DLLEXPORT Punkt getGroesse() const;
        //! Gibt die Groesse des Fensterkoerpers in Pixeln zurueck
        DLLEXPORT Punkt getKoerperGroesse() const;
        //! Gibt die Breite des Fensterkoerpers in Pixeln zurueck
        DLLEXPORT int getKoerperBreite() const;
        //! Gibt die Hoehe des Fensterkoerpers in Pixeln zurueck
        DLLEXPORT int getKoerperHoehe() const;
        //! Gibt zurueck, ob eine Rueckruffunktion fuer ein MausEreignis gesetzt
        //! wurde
        DLLEXPORT bool hatMausAktion() const;
        //! Gibt zurueck, ob eine Rueckruffunktion fuer das Ereignis vor dem
        //! Schliessen des Fensters gesetzt wurde
        DLLEXPORT bool hatVSchliessAktion() const;
        //! Gibt zurueck, ob eine Rueckruffunktion fuer das Ereignis nach dem
        //! Schliessen des Fensters gesetzt wurde
        DLLEXPORT bool hatNSchliessAktion() const;
        //! Gibt zurueck, ob eine Rueckruffunktion fuer ein TastaturEreignis
        //! gesetzt wurde
        DLLEXPORT bool hatTastaturAktion() const;
        //! Gibt den Bidschirm zurueck, an dessen Zeichnungen die Ereignisse
        //! Weitergegeben werden
        DLLEXPORT Bildschirm* getBildschirm() const;
        //! Gibt den Bildschirm ohne erhoehten Reference Counter zurueck, an
        //! dessen Zeichnungen die Ereignisse Weitergegeben werden
        DLLEXPORT Bildschirm* zBildschirm() const;
        //! Gibt zurueck, 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();
        //! Fuegt 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 naechste Element zurueck
        DLLEXPORT WFensterArray* getNext();
        //! Setzt das naechste Element auf 0
        DLLEXPORT void setNext0();
        //! Loescht das Element
        DLLEXPORT void del();
        //! Sendet das Ereignis, was vor dem Schliessen aufgerufen wird an ein
        //! bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendVSchliessMessage(HWND hWnd);
        //! Sendet das Ereignis, was nach dem Schliessen aufgerufen wird an ein
        //! bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendNSchliessMessage(HWND hwnd);
        //! Sendet ein Maus Ereignis an ein bestimmtes Fenster
        //! \param hWnd Das Handle zum Fenster
        //! \param me Das Ereignis, was durch die Mauseingabe ausgeloesst 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 ausgeloesst
        //! wurde
        DLLEXPORT bool sendTastaturMessage(HWND hwnd, TastaturEreignis& te);
        //! Sendet das Ereignis, was durch das oeffnen des Fensters ausgeloesst
        //! wurde an ein bestimmtes Fenster \param hWnd Das Handle zum Fenster
        DLLEXPORT bool sendRestoreMessage(HWND hwnd);
        //! Gibt das Fenster dieses Eintrags zurueck
        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 Koerper des Fensters einen Hintergrund hat
            static const __int64 BodyHintergrund = 0x000000008;
            //! Legt fest, ob beim zeichnen des Koerperhintergrundes alpha
            //! blending verwendet werden soll
            static const __int64 BodyHAlpha = 0x000000010;
            //! Legt fest, ob ein Bild als Hintergrund des Koerpers verwendet
            //! werden soll
            static const __int64 BodyHBild = 0x000000020;
            //! Legt fest, ob der Koerper einen Farbuebergang 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 fuer den Titelhintergrund ein Bild verwendet werden
            //! soll
            static const __int64 TitelHBild = 0x000000400;
            //! Legt fest, ob die Titel Leiste einen Farbuebergang besitzt
            static const __int64 TitelBuffered = 0x000000800;
            //! Legt fest, ob in der Titelleiste ein Knopf zum Schliessen des
            //! Fensters angezeigt werden soll
            static const __int64 Closable = 0x000001000;
            //! Legt fest, ob der Schliessen Knopf einen Hintergrund hat
            static const __int64 ClosingHintergrund = 0x000002000;
            //! Legt fest, ob beim Zeichnen des Hintergrunds des Schliessen
            //! Knopfes alpha blending verwendet werden soll
            static const __int64 ClosingHAlpha = 0x000004000;
            //! Legt fest, ob fuer den Hintergrund des Schliessen Knopfes ein
            //! Bild soll
            static const __int64 ClosingHBild = 0x000008000;
            //! Legt fest, ob der Schliessen Knopf einen Farbuebergang besitzt
            static const __int64 ClosingBuffer = 0x000010000;
            //! Legt fest, ob der Schliessen Knopf einen Farbuebergang besitzt,
            //! waehrend er gedrueckt wird
            static const __int64 ClosingKlickBuffer = 0x000020000;
            //! Legt fest, ob der Benutzer das Fenster durch gedrueckt 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
            //! gedrueckt halten der linken Maustaste auf dem rechten oder linken
            //! Fensterrand veraendern kann
            static const __int64 BreiteChangeable = 0x000080000;
            //! Legt fest, ob der Benutzer die Hoehe des Fensters durch das
            //! gedrueckt halten der linken Maustaste auf dem oberen oder unteren
            //! Fensterrand veraendern kann
            static const __int64 HeightChangeable = 0x000100000;
            //! Legt fest, ob der Benutzer die Hoehe der Titel Leiste durch
            //! gedrueckt halten der linken Maustaste auf dem unteren Rand der
            //! Titelleiste veraendern 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 Hoehe des Fensters gibt
            static const __int64 MinHi = 0x001000000;
            //! Legt fest, ob es eine Maximale Hoehe des Fensters gibt
            static const __int64 MaxHi = 0x002000000;
            //! Legt fest, ob es eine Minimale Breite des Koerpers gibt
            static const __int64 BodyMinBr = 0x004000000;
            //! Legt fest, ob es eine Maximale Breite des Koerpers gibt
            static const __int64 BodyMaxBr = 0x008000000;
            //! Legt fest, ob es eine Minimale Hoehe des Koerpers gibt
            static const __int64 BodyMinHi = 0x010000000;
            //! Legt fest, ob es eine Maximale Hoehe des Koerpers 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
            //! groesse aenderbar ist
            static const __int64 LeftPositionFixed = 0x400000000;
            //! Legt fest, ob die rechte Seite des Fensters fixiert ist wenn die
            //! groesse aenderbar ist
            static const __int64 RightPositionFixed = 0x800000000;
            //! Legt fest, ob die obere Seite des Fensters fixiert ist wenn die
            //! groesse aenderbar ist
            static const __int64 TopPositionFixed = 0x1000000000;
            //! Legt fest, ob die untere Seite des Fensters fixiert ist wenn die
            //! groesse aenderbar ist
            static const __int64 BottomPositionFixed = 0x2000000000;
            //! Legt fest, ob die Position und Groesse des Titel Textfeldes
            //! unveraendert bleiben soll
            static const __int64 CustomTitle = 0x4000000000;
            //! Vereint die Flags MinHoe, MaxHoe, MaxBr, MaxHoe
            static const __int64 min_max = MinHi | MaxHi | MaxBr | MaxHi;
            //! Vereint die Flags Koerper_minBr, Koerper_maxBr, Koerper_minHoe,
            //! Koerper_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 TitelHoeheAEnderbar, HoeheAEnderbar,
            //! BreiteAEnderbar, Beweglich
            static const __int64 nichtfixiert = TitelHeightChangeable
                                              | HeightChangeable
                                              | BreiteChangeable | Beweglich;

            //! Vereint die Flags Sichtbar, Erlaubt, Rahmen, Titel,
            //! TitelBuffered, Schliessbar, SchliessHBild, SchliessKlickBuffer,
            //! 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 ausgeloesst 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 fuer den Titel verwendet werden soll
        //! \param schrift Die Schrift
        DLLEXPORT void setTSchriftZ(Schrift* schrift);
        //! Setzt die Farbe der Schrift, die fuer den Titel verwendet werden soll
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTSFarbe(int f);
        //! Setzt die Groesse der Schrift, die fuer den Titel verwendet werden
        //! soll
        //! \param gr Die Hoehe 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 Farbuebergang des Titels
        //! \param af Der Farbuebergang
        DLLEXPORT void setTAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbuebergangs des Titels
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setTAfFarbe(int f);
        //! Setzt die Staerke des Farbuebergangs des Titels
        //! \param st Die Staerke
        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 Koerpers
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setKBgFarbe(int f);
        //! Setzt das Hintergrund Bild des Koerpers durch kopieren
        //! \param b Das Bild, das kopiert werden soll
        DLLEXPORT void setKBgBild(Bild* b);
        //! Setzt einen Zeiger auf das Hintergrund Bild des Koerpers
        //! \param b Das Bild
        DLLEXPORT void setKBgBildZ(Bild* b);
        //! Setzt einen Zeiger auf den Farbuebergang des Koerpers
        //! \param af Der Farbuebergang
        DLLEXPORT void setKAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbuebergangs des Koerpers
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setKAfFarbe(int f);
        //! Setzt die Staerke des Farbuebergangs des Koerpers
        //! \param st Die Staerke
        DLLEXPORT void setKAfStrength(int st);
        //! Setzt den Parameter der Rueckruffunktion, die aufgerufen wird, wenn
        //! der Schliessen Knopf ein MausEreignis erhaelt \param param Der
        //! Parameter
        DLLEXPORT void setClosingMeParam(void* param);
        //! Setzt die Rueckruffunktion, die Aufgerufen wird, wenn der Schliessen
        //! Knopf ein MausEreignis erhaelt Wenn die Rueckruffunktion 0
        //! zurueckgiebt, 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 Rueckruffunktion durch den
        //! aufruf von loescheStyle( Fenster::Style::Sichtbar ); geschlossen
        //! werden \param ak Ein Zeiger auf die Rueckruffunktion
        DLLEXPORT void setClosingMe(MausAktion closingMe);
        //! Setzt die Hintergrund Farbe des Schliessen Knopfes
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSBgFarbe(int f);
        //! Setzt das Hintergrund Bild des Schliessen Knopfes durch kopieren
        //! \param b Das Bild, das kopiert werden soll
        DLLEXPORT void setSBgBild(Bild* b);
        //! Setzt einen Zeiger auf das Hintergrund Bild des Schliessen Knopfes
        //! \param b Das Bild
        DLLEXPORT void setSBgBildZ(Bild* b);
        //! Setzt einen Zeiger auf den Farbuebergang des Schliessen Knopfes
        //! \param af Der Farbuebergang
        DLLEXPORT void setSAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbuebergangs des Schliessen Knopfes
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSAfFarbe(int f);
        //! Setzt die Staerke des Farbuebergangs des Schliessen Knopfes
        //! \param st Die Staerke
        DLLEXPORT void setSAfStrength(int st);
        //! Setzt einen Zeiger auf den Farbuebergang, der beim Klicken des
        //! Schliessen Knopfes verwendet wird \param af Der Farbuebergnag
        DLLEXPORT void setSKAlphaFeldZ(AlphaFeld* af);
        //! Setzt die Farbe des Farbuebergangs, der beim Klicken des Schliessen
        //! Knopfes verwendet wird \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setSKAfFarbe(int f);
        //! Setzt die Staerke des Farbuebergangs, der beim Klicken des Schliessen
        //! Knopfes verwendet wird \param st Die Staerke
        DLLEXPORT void setSKAfStrength(int st);
        //! Setzt die Minimale Groesse des Fensters
        //! \param mx Die Minimale Breite in Pixeln
        //! \param my Die Minimale Hoehe in Pixeln
        DLLEXPORT void setMin(int mx, int my);
        //! Setzt die Minimale Groesse des Fensters
        //! \param min Die Minimale Breite und Hoehe in Pixeln
        DLLEXPORT void setMin(const Punkt& min);
        //! Setzt die Maximale Groesse des Fensters
        //! \param mx Die Maximale Breite in Pixeln
        //! \param my Die Maximale Hoehe in Pixeln
        DLLEXPORT void setMax(int mx, int my);
        //! Setzt die Maximale Groesse des Fensters
        //! \param min Die Maximale Breite und Hoehe in Pixeln
        DLLEXPORT void setMax(const Punkt& max);
        //! Setzt die Minimale Groesse des Fenster Koerpers
        //! \param mx Die Minimale Breite in Pixeln
        //! \param my Die Minimale Hoehe in Pixeln
        DLLEXPORT void setKMin(int mx, int my);
        //! Setzt die Minimale Groesse des Fenster Koerpers
        //! \param min Die Minimale Breite und Hoehe in Pixeln
        DLLEXPORT void setKMin(const Punkt& min);
        //! Setzt die Maximale Groesse des Fenster Koerpers
        //! \param mx Die Maximale Breite in Pixeln
        //! \param my Die Maximale Hoehe in Pixeln
        DLLEXPORT void setKMax(int mx, int my);
        //! Setzt die Maximale Groesse des Fenster Koerpers
        //! \param min Die Maximale Breite und Hoehe 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 Koerpers
        //! \param max Die Breite in Pixeln
        DLLEXPORT void setHSBMax(int max);
        //! Setzt die Maximale Scroll hoehe des Fenster Koerpers
        //! \param max Die Hoehe in Pixeln
        DLLEXPORT void setVSBMax(int max);
        //! Scrollt zu einer bestimmten x Position im Fenster Koerper
        //! \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 Koerper
        //! \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();
        //! Fuegt 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 erhoehten 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 veraendert
        //! 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 ausgeloesst
        //! 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 zurueck
        DLLEXPORT int getInnenBreite() const override;
        //! Gibt die Hoehe des Innenraumes in der Zeichnung in Pixeln zurueck
        DLLEXPORT int getInnenHeight() const override;
        //! Gibt den Rahmen des Fensters zurueck
        DLLEXPORT Rahmen* getRahmen() const;
        //! Gibt den Rahmen des Fensters ohne erhoehen Reference Counter zurueck
        DLLEXPORT Rahmen* zRahmen() const;
        //! Gibt die Farbe des Rahmens des Fensters im A8R8G8B8 Format zurueck
        DLLEXPORT int getRFarbe() const;
        //! Gibt die Breite des Rahmens des Fensters in Pixeln zurueck
        DLLEXPORT int getRBreite() const;
        //! Gibt den Titel des Fensters zurueck
        DLLEXPORT Text* getTitel() const;
        //! Gibt den Titel des Fensters ohne erhoehten Reference Counter zurueck
        DLLEXPORT Text* zTitel() const;
        //! Gibt das TextFeld zurueck, das zum Zeichnen des Titels verwendet wird
        DLLEXPORT TextFeld* getTTextFeld() const;
        //! Gibt das TextFeld ohne erhoehten Reference Counter zurueck, das zum
        //! Zeichnen des Titels verwendet wird
        DLLEXPORT TextFeld* zTTextFeld() const;
        //! Gibt die Schrift zurueck, die fuer den Titel verwendet wird
        DLLEXPORT Schrift* getTSchrift() const;
        //! Gibt die Schrift ohne erhoeten Reference Counter zurueck, die fuer den
        //! Titel verwendet wird
        DLLEXPORT Schrift* zTSchrift() const;
        //! Gibt die Schrift Farbe des Titels im A8R8G8B8 Format zurueck
        DLLEXPORT int getTSFarbe() const;
        //! Gibt die Hoehe einer Zeile des Titels in Pixeln zurueck
        DLLEXPORT int getTSSize() const;
        //! Gibt die Hintergrundfarbe des Titels im A8R8G8B8 Format zurueck
        DLLEXPORT int getTBgFarbe() const;
        //! Gibt den Farbuebergang des Titels zurueck
        DLLEXPORT AlphaFeld* getTAlphaFeld() const;
        //! Gibt den Farbuebergang des Titels ohne erhoehten Reference COunter
        //! zurueck
        DLLEXPORT AlphaFeld* zTAlphaFeld() const;
        //! Gibt die Farbe des Farbuebergangs des Titels im A8R8G8B8 Format
        //! zurueck
        DLLEXPORT int getTAfFarbe() const;
        //! Gibt die Staerke des Farbuebergangs des Titels zurueck
        DLLEXPORT int getTAfStrength() const;
        //! Gibt das Hintergrund Bild des titels zurueck
        DLLEXPORT Bild* getTBgBild() const;
        //! Gibt das Hintergrund Bild des titels ohne erhoehten Reference Counter
        //! zurueck
        DLLEXPORT Bild* zTBgBild() const;
        //! Gibt den Rahmen des Titels zurueck
        DLLEXPORT Rahmen* getTRahmen() const;
        //! Gibt den Rahmen des Titels ohne erhoehten Reference Counter zurueck
        DLLEXPORT Rahmen* zTRahmen() const;
        //! Gibt die Farbe des Rahmens des Titels im A8R8G8B8 Format zurueck
        DLLEXPORT int getTRFarbe() const;
        //! Gibt die Staerke des Rahmens des Titels zurueck
        DLLEXPORT int getTRBreite() const;
        //! Gibt die Hintergrund Farbe des Koerpers zurueck
        DLLEXPORT int getKBgFarbe() const;
        //! Gibt das Hintergrund Bild des Koerpers zurueck
        DLLEXPORT Bild* getKBgBild() const;
        //! Gibt das Hintergrund Bild des Koerpers ohne erhoehten Reference
        //! Counter zurueck
        DLLEXPORT Bild* zKBgBild() const;
        //! Gibt den Farbuebergang des Koerpers zurueck
        DLLEXPORT AlphaFeld* getKAlphaFeld() const;
        //! Gibt den Farbuebergang des Koerpers ohne erhoehten Reference Counter
        //! zurueck
        DLLEXPORT AlphaFeld* zKAlphaFeld() const;
        //! Gibt die Farbe des Farbuebergangs des Koerpers im A8R8G8B8 Format
        //! zurueck
        DLLEXPORT int getKAfFarbe() const;
        //! Gibt die Staerke des Farbuebergangs des Koerpers zurueck
        DLLEXPORT int getKAfStrength() const;
        //! Gibt die Hintergrund Farbe des Schliessen Knopfes im A8R8G8B8 Format
        //! zurueck
        DLLEXPORT int getSBgFarbe() const;
        //! Gibt das Hintergrund Bild des Schliessen Knopfes zurueck
        DLLEXPORT Bild* getSBgBild() const;
        //! Gibt das Hintergrund Bild des Schliessen Knopfes ohne erhoehten
        //! Reference COunter zurueck
        DLLEXPORT Bild* zSBgBild() const;
        //! Gibt den Farbuebergang des Schliessen Knopfes zurueck
        DLLEXPORT AlphaFeld* getSAlphaFeld() const;
        //! Gibt den Farbuebergang des Schliessen Knopfes ohne erhoehten Reference
        //! COunter zurueck
        DLLEXPORT AlphaFeld* zSAlphaFeld() const;
        //! Gibt die Farbe des Farbuebergangs des Schliessen Knopfes im A8R8G8B8
        //! Format zurueck
        DLLEXPORT int getSAfFarbe() const;
        //! Gibt die Staerke des Farbuebergangs des Schliessen Knopfes zurueck
        DLLEXPORT int getSAfStrength() const;
        //! Gibt den Farbuebergang zurueck, der verwendet wird, wenn auf den
        //! Schliessen Knopf gedrueckt wird
        DLLEXPORT AlphaFeld* getSKAlphaFeld() const;
        //! Gibt den Farbuebergang ohne erhoehten Reference Counter zurueck, der
        //! verwendet wird, wenn auf den Schliessen Knopf gedrueckt wird
        DLLEXPORT AlphaFeld* zSKAlphaFeld() const;
        //! Gibt die Farbe des Farbuebergangs im A8R8G8B8 Format zurueck, der
        //! verwendet wird, wenn auf den Schliessen Knopf gedrueckt wird
        DLLEXPORT int getSKAfFarbe() const;
        //! Gibt die Staerke des Farbuebergangs zurueck, der verwendet wird, wenn
        //! auf den Schliessen Knopf gedrueckt wird
        DLLEXPORT int getSKAfStrength() const;
        //! Gibt die minimale Fenstergroesse in Pixeln zurueck
        DLLEXPORT const Punkt& getMin() const;
        //! Gibt die maximale Fenstergroesse in Pixeln zurueck
        DLLEXPORT const Punkt& getMax() const;
        //! Gibt die minimale Koerpergroesse in Pixeln zurueck
        DLLEXPORT const Punkt& getKMin() const;
        //! Gibt die maximale Koerpergroesse in Pixeln zurueck
        DLLEXPORT const Punkt& getKMax() const;
        //! Gibt die Scrollbar vom rechten Fensterrand zurueck
        DLLEXPORT VScrollBar* getVScrollBar() const;
        //! Gibt die Scrollbar vom rechten Fensterrand ohne erhoehten Reference
        //! Counter zurueck
        DLLEXPORT VScrollBar* zVScrollBar() const;
        //! Gibt die Scrollbar vom unteren Fensterrand zurueck
        DLLEXPORT HScrollBar* getHScrollBar() const;
        //! Gibt die Scrollbar vom unteren Fensterrand ohne erhoehten Reference
        //! Counter zurueck
        DLLEXPORT HScrollBar* zHScrollBar() const;
        //! Gibt eine Liste mit Zeichnungen zurueck, die im Fenster sind
        DLLEXPORT const RCArray<Zeichnung>& getMembers() const;
        //! Gibt die von den kindern benoetigte Breite des Fensters zurueck
        DLLEXPORT int getNeededChildWidth() const;
        //! Gibt die von den kindern benoetigte Hoehe des Fensters zurueck
        DLLEXPORT int getNeededChildHeight() const;
        //! Erzeugt eine Kopie des Fensters, die ohne Auswirkungen auf das
        //! Original veraendert werden kann
        DLLEXPORT Zeichnung* dublizieren() const override;
    };
} // namespace Framework
#endif