#ifndef Bild_H
#define Bild_H

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

namespace Framework
{
    class Bild; //! aus dieser Datei
#ifdef WIN32
    class VScrollBar;    //! Scroll.h
    class HScrollBar;    //! Scroll.h
    class Rahmen;        //! Rahmen.h
    struct MausEreignis; //! Mausereignis.h
    class Text;          //! Text.h
#endif

    //! Verwaltet ein Bild als Array von Pixel Farben im A8R8G8B8 Format, in den
    //! gezeichnet werden kann
    class Bild : public virtual ReferenceCounter
    {
    private:
        int* fc;
        bool delFc;
        Punkt size;
        Punkt* drawOff;
        Punkt* dPosA;
        Punkt* dSizeA;
        int doa;
        unsigned char* alpha;
        int alphaAnzahl;
        bool rend;
        bool alpha3D;

        //! privat
        inline void alphaPixelP(int x, int y, int f);
        inline void alphaPixelP3D(int x, int y, int f);
        inline void alphaPixelP(int& fc, int f);
        inline void alphaPixelP3D(int& fc, int f);
        inline void alphaPixelAssozP(int& fc, int f);
        inline char getOutCode(Punkt p) const;
        void drawFlatDreieck(
            int y1, int y2, float m1, float b1, float m2, float b2, int farbe);
        void drawFlatDreieckTextur(int y1,
            int y2,
            double m1,
            double b1,
            double m2,
            double b2,
            double tx1,
            double ty1,
            double tx2,
            double ty2,
            double tx_1o,
            double ty_1o,
            double tx_2o,
            double ty_2o,
            double txf,
            double tyf,
            Bild& textur);
        void drawFlatDreieckAlpha(
            int y1, int y2, float m1, float b1, float m2, float b2, int farbe);
        void drawFlatDreieckTexturAlpha(int y1,
            int y2,
            double m1,
            double b1,
            double m2,
            double b2,
            double tx1,
            double ty1,
            double tx2,
            double ty2,
            double tx_1o,
            double ty_1o,
            double tx_2o,
            double ty_2o,
            double txf,
            double tyf,
            Bild& textur);
        void drawLinieHTextur(Vec2<double> p,
            double length,
            Vec2<double> ta,
            Vec2<double> tb,
            double txo,
            double tyo,
            Bild& textur);
        void drawLinieHTexturAlpha(Vec2<double> p,
            double length,
            Vec2<double> ta,
            Vec2<double> tb,
            double txo,
            double tyo,
            Bild& textur);

    public:
        //! Konstruktor
        //! \param options 1, wenn das Bild Buffer zum Zeichnen anlegen soll,
        //! wie zum Beispiel für temporäre Zeichnenflächen Begrenzungen und
        //! Transparenz Filter
        //!  Verbraucht etwa 50 kb mehr Arbeitsspeicher pro Bild
        DLLEXPORT Bild(bool options = 0);
        //! Destruktor
        DLLEXPORT ~Bild();
        //! Prüft ob ein Rechteck vollständig oder teilweise in der Zeichen
        //! Fläche liegt.
        //!  return 0, falls das Rechteck nicht in der Zeichenfläche liegt, 1
        //!  sonst
        DLLEXPORT bool isAreaDrawable(int x, int y, int width, int height);
        //! Wird dieser Flag gesetzt, so wird beim Alpha Blending wenn die
        //! vorheriege Farbe 0 ist nur die neue mit ihrem Alpha Wert kopiert.
        //! Das ist sinnvoll für die Verwendung im 3DBildschirm, wo das
        //! Gezeichnette Bild später mittels Alpha Blending angezeigt wird. Der
        //! Flag wird im 3DBildschirm automatisch gesetzt
        DLLEXPORT void setAlpha3D(bool erlaubt);
        //! Setzt die mindest Transparenz von allem was als nächstes gezeichnet
        //! wird, bis der zugehörige releaseAlpha() aufruf erfolgt.
        DLLEXPORT void setAlpha(unsigned char alpha);
        //! Entfernt die als letztes mit setAlpha() gesetzte Alpha grenze
        DLLEXPORT void releaseAlpha();
        //! Setzt einen Zeiger auf die Pixel, in die gezeichnet werden soll
        //! \param buffer Ein Array mit den A8R8G8B8 Farbwerten
        //! \param deleteBuffer 1, fals der Array vom Bild gelöscht werden soll
        //! \param breite Die Breite in Pixeln
        //! \param height Die Höhe in Pixeln
        DLLEXPORT void setPixelBuffer(
            int* buffer, bool deleteBuffer, int breite, int height);
        //! Erstellt ein neues Bild
        //! \param breite Die Breite des Bildes in Pixeln
        //! \param höhe Die Höhe des Bildes in Pixeln
        //! \param fillColor Die startfarbe, auf die alle Pixel gesetzt werden
        DLLEXPORT void neuBild(int breite, int height, int fillColor);
        //! Blendet mittels Alphablending eine Farbe auf einen bestimmten Pixel
        //! Beachtet nicht die begrenzung der Zeichnenfläche und das Skroll
        //! Offset \param x Die X Koordinate des Pixels \param y Die Y
        //! Koordinate des Pixels \param f Die Farbe in A8R8G8B8 Format, die
        //! geblendet werden soll
        DLLEXPORT void alphaPixel2D(int x, int y, int f);
        DLLEXPORT void alphaPixel3D(int x, int y, int f);
        //! Blendet mittels Alphablending eine Farbe auf einen bestimmten Pixel
        //! Beachtet nicht die begrenzung der Zeichnenfläche und das Skroll
        //! Offset \param i Der Index des Pixels im Pixel Array \param f Die
        //! Farbe in A8R8G8B8 Format, die geblendet werden soll
        DLLEXPORT void alphaPixel2D(int i, int f);
        DLLEXPORT void alphaPixel3D(int i, int f);
        //! Blendet mittels Alphablending eine Farbe auf einen bestimmten Pixel
        //! \param x Die X Koordinate des Pixels
        //! \param y Die Y Koordinate des Pixels
        //! \param f Die Farbe in A8R8G8B8 Format, die geblendet werden soll
        DLLEXPORT void alphaPixelDP2D(int x, int y, int f);
        DLLEXPORT void alphaPixelDP3D(int x, int y, int f);
        //! Blendet mittels Alphablending eine Farbe auf einen bestimmten Pixel
        //! \param i Der Index des Pixels im Pixel Array
        //! \param f Die Farbe in A8R8G8B8 Format, die geblendet werden soll
        DLLEXPORT void alphaPixelDP2D(int i, int f);
        DLLEXPORT void alphaPixelDP3D(int i, int f);
        //! Setzt die Farbe eines besimmten Pixels
        //! \param x Die X Koordinate des Pixels
        //! \param y Die Y Koordinate des Pixels
        //! \param f Die neue Farbe in A8R8G8B8 Format
        DLLEXPORT void setPixelDP(int x, int y, int f);
        //! Setzt die Farbe eines besimmten Pixels
        //! \param i Der Index des Pixels im Pixel Array
        //! \param f Die neue Farbe in A8R8G8B8 Format
        DLLEXPORT void setPixelDP(int i, int f);
        //! Setzt die Farbe aller Pixel des Bildes
        //! \param f Die neue Farbe
        DLLEXPORT void setFarbe(int f);
        //! Setzt die Farben aller Pixel in einem Rechteck
        //! \param x Die X Koordinate
        //! \param y Die Y Koordinate
        //! \param b Die Breite des Rechtecks
        //! \param h Die Höhe des Rechtecks
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void fillRegion(int x, int y, int b, int h, int fc);
        //! Blendet eine Farbe mit Alphablending in einem Rechteck
        //! \param x Die X Koordinate
        //! \param y Die Y Koordinate
        //! \param b Die Breite des Rechtecks
        //! \param h Die Höhe des Rechtecks
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void alphaRegion(int x, int y, int b, int h, int fc);
        //! Zeichnet eine horizontale Linie
        //! \param x Die X Koordinate des Startpunktes der Linie
        //! \param y Die Y Koordinate des Startpunktes der Linie
        //! \param length Die Länge der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieH(int x, int y, int length, int fc);
        //! Zeichnet eine vertikale Linie
        //! \param x Die X Koordinate des Startpunktes der Linie
        //! \param y Die Y Koordinate des Startpunktes der Linie
        //! \param length Die Länge der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieV(int x, int y, int length, int fc);
        //! Zeichnet eine horizontale Linie mit Alpha blending
        //! \param x Die X Koordinate des Startpunktes der Linie
        //! \param y Die Y Koordinate des Startpunktes der Linie
        //! \param length Die Länge der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieHAlpha(int x, int y, int length, int fc);
        //! Zeichnet eine vertikale Linie mit Alpha Blending
        //! \param x Die X Koordinate des Startpunktes der Linie
        //! \param y Die Y Koordinate des Startpunktes der Linie
        //! \param length Die Länge der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieVAlpha(int x, int y, int length, int fc);
        //! Zeichnet eine Linie
        //! \param a Der Startpunkt der Linie
        //! \param b der Endpunkt der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieBordered(Punkt a, Punkt b, int bc, int fc);
        //! Zeichnet eine Linie
        //! \param a Der Startpunkt der Linie
        //! \param b der Endpunkt der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieBorderedAlpha(Punkt a, Punkt b, int bc, int fc);
        //! Zeichnet eine Linie
        //! \param a Der Startpunkt der Linie
        //! \param b der Endpunkt der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinie(Punkt a, Punkt b, int fc);
        //! Zeichnet eine Linie mit Alpha Blending
        //! \param a Der Startpunkt der Linie
        //! \param b der Endpunkt der Linie
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawLinieAlpha(Punkt a, Punkt b, int fc);
        //! Füllt einen Kreis mit einer Farbe. (Unfertig)
        //! \param xOff Die X Koordinate des Kreismittelpunktes
        //! \param yOff Die Y Koordinate des Kreismittelpunktes
        //! \param r Der Radius des Kreises in Pixeln
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void fillCircle(int xOff, int yOff, int r, int fc);
        //! Zeichnet den Umriss eines Kreises
        //! \param xOff Die X Koordinate des Kreismittelpunktes
        //! \param yOff Die Y Koordinate des Kreismittelpunktes
        //! \param r Der Radius des Kreises in Pixeln
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawKreis(int xOff, int yOff, int r, int fc);
        //! Zeichnet den Umriss eines Kreises mit Alpha Blending
        //! \param xOff Die X Koordinate des Kreismittelpunktes
        //! \param yOff Die Y Koordinate des Kreismittelpunktes
        //! \param r Der Radius des Kreises in Pixeln
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawKreisAlpha(int xOff, int yOff, int r, int fc);
        //! Zeichnet ein Bild in ein bestimmtes Feld ohne Skallierung
        //! \param x Die X Koordinate der linken oberen Ecke des Rechtecks in
        //! dem das Bild gezeichnet werden soll \param y Die Y Koordinate der
        //! linken oberen Ecke des Rechtecks in dem das Bild gezeichnet werden
        //! soll \param br Die Breite des Rechecks in dem das Bild gezeichnet
        //! werden soll \param hi Die Höhe des Rechecks in dem das Bild
        //! gezeichnet werden soll \param zBild Das Bild, was gezeichnet werden
        //! soll
        DLLEXPORT void drawBild(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild in ein bestimmtes Feld ohne Skallierung mit alpha
        //! blending \param x Die X Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param y Die Y
        //! Koordinate der linken oberen Ecke des Rechtecks in dem das Bild
        //! gezeichnet werden soll \param br Die Breite des Rechecks in dem das
        //! Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in dem
        //! das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void alphaBild(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild in ein bestimmtes Feld ohne Skallierung mit alpha
        //! blending \param x Die X Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param y Die Y
        //! Koordinate der linken oberen Ecke des Rechtecks in dem das Bild
        //! gezeichnet werden soll \param br Die Breite des Rechecks in dem das
        //! Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in dem
        //! das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void alphaBildAssoz(
            int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 90 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung \param x Die X Koordinate der linken oberen
        //! Ecke des Rechtecks in dem das Bild gezeichnet werden soll \param y
        //! Die Y Koordinate der linken oberen Ecke des Rechtecks in dem das
        //! Bild gezeichnet werden soll \param br Die Breite des Rechecks in dem
        //! das Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in
        //! dem das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void drawBild90(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 90 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung mit alpha Blending \param x Die X Koordinate
        //! der linken oberen Ecke des Rechtecks in dem das Bild gezeichnet
        //! werden soll \param y Die Y Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param br Die
        //! Breite des Rechecks in dem das Bild gezeichnet werden soll \param hi
        //! Die Höhe des Rechecks in dem das Bild gezeichnet werden soll \param
        //! zBild Das Bild, was gezeichnet werden soll
        DLLEXPORT void alphaBild90(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 180 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung \param x Die X Koordinate der linken oberen
        //! Ecke des Rechtecks in dem das Bild gezeichnet werden soll \param y
        //! Die Y Koordinate der linken oberen Ecke des Rechtecks in dem das
        //! Bild gezeichnet werden soll \param br Die Breite des Rechecks in dem
        //! das Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in
        //! dem das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void drawBild180(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 180 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung mit alpha Blending \param x Die X Koordinate
        //! der linken oberen Ecke des Rechtecks in dem das Bild gezeichnet
        //! werden soll \param y Die Y Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param br Die
        //! Breite des Rechecks in dem das Bild gezeichnet werden soll \param hi
        //! Die Höhe des Rechecks in dem das Bild gezeichnet werden soll \param
        //! zBild Das Bild, was gezeichnet werden soll
        DLLEXPORT void alphaBild180(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 270 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung \param x Die X Koordinate der linken oberen
        //! Ecke des Rechtecks in dem das Bild gezeichnet werden soll \param y
        //! Die Y Koordinate der linken oberen Ecke des Rechtecks in dem das
        //! Bild gezeichnet werden soll \param br Die Breite des Rechecks in dem
        //! das Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in
        //! dem das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void drawBild270(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild um 270 grad nach rechts gedreht in ein bestimmtes
        //! Feld ohne Skallierung mit alpha Blending \param x Die X Koordinate
        //! der linken oberen Ecke des Rechtecks in dem das Bild gezeichnet
        //! werden soll \param y Die Y Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param br Die
        //! Breite des Rechecks in dem das Bild gezeichnet werden soll \param hi
        //! Die Höhe des Rechecks in dem das Bild gezeichnet werden soll \param
        //! zBild Das Bild, was gezeichnet werden soll
        DLLEXPORT void alphaBild270(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild in ein bestimmtes Feld mit Skallierung
        //! \param x Die X Koordinate der linken oberen Ecke des Rechtecks in
        //! dem das Bild gezeichnet werden soll \param y Die Y Koordinate der
        //! linken oberen Ecke des Rechtecks in dem das Bild gezeichnet werden
        //! soll \param br Die Breite des Rechecks in dem das Bild gezeichnet
        //! werden soll \param hi Die Höhe des Rechecks in dem das Bild
        //! gezeichnet werden soll \param zBild Das Bild, was gezeichnet werden
        //! soll
        DLLEXPORT void drawBildSkall(int x, int y, int br, int hi, Bild& zBild);
        //! Zeichnet ein Bild in ein bestimmtes Feld mit Skallierung mit Alpha
        //! Blending \param x Die X Koordinate der linken oberen Ecke des
        //! Rechtecks in dem das Bild gezeichnet werden soll \param y Die Y
        //! Koordinate der linken oberen Ecke des Rechtecks in dem das Bild
        //! gezeichnet werden soll \param br Die Breite des Rechecks in dem das
        //! Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in dem
        //! das Bild gezeichnet werden soll \param zBild Das Bild, was
        //! gezeichnet werden soll
        DLLEXPORT void alphaBildSkall(
            int x, int y, int br, int hi, Bild& zBild);
        //! Füllt ein Dreieck mit einer bestimmten Farbe
        //! \param a Eine Ecke des Dreiecks
        //! \param b Eine Ecke des Dreiecks
        //! \param c Eine Ecke des Dreiecks
        //! \param farbe die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawDreieck(Punkt a, Punkt b, Punkt c, int farbe);
        //! Füllt ein Dreieck mit einer bestimmten Textur
        //! \param a Eine Ecke des Dreiecks
        //! \param b Eine Ecke des Dreiecks
        //! \param c Eine Ecke des Dreiecks
        //! \param ta Die Koordinaten von a in der Textur
        //! \param tb Die Koordinaten von b in der Textur
        //! \param tc Die Koordinaten von c in der Textur
        //! \param textur Das Bild, was als Textur verwendet werden soll
        DLLEXPORT void drawDreieckTextur(Punkt a,
            Punkt b,
            Punkt c,
            Punkt ta,
            Punkt tb,
            Punkt tc,
            Bild& textur);
        //! Füllt ein Dreieck mit einer bestimmten Farbe mit alpha blending
        //! \param a Eine Ecke des Dreiecks
        //! \param b Eine Ecke des Dreiecks
        //! \param c Eine Ecke des Dreiecks
        //! \param farbe die Farbe im A8R8G8B8 Format
        DLLEXPORT void drawDreieckAlpha(Punkt a, Punkt b, Punkt c, int farbe);
        //! Füllt ein Dreieck mit einer bestimmten Textur mit alpha blending
        //! \param a Eine Ecke des Dreiecks
        //! \param b Eine Ecke des Dreiecks
        //! \param c Eine Ecke des Dreiecks
        //! \param ta Die Koordinaten von a in der Textur
        //! \param tb Die Koordinaten von b in der Textur
        //! \param tc Die Koordinaten von c in der Textur
        //! \param textur Das Bild, was als Textur verwendet werden soll
        DLLEXPORT void drawDreieckTexturAlpha(Punkt a,
            Punkt b,
            Punkt c,
            Punkt ta,
            Punkt tb,
            Punkt tc,
            Bild& textur);
        //! Ersetzt eine bestimmte Farbe durch Transparenz
        DLLEXPORT void replaceColorWithAlpha(int color);
        //! Begrenzt die Zeichenfläche in die bis zum nächsten aufruf von
        //! releaseDrawOptions() gezeichnet werden kann. Alles außerhalb der
        //! Fläche wird automatisch ignoriert. Wenn die Zeichenfläche über den
        //! Rand einer bestehenden Zeichenfläche hinausragt, wird sie
        //! automatisch auf die bestehende Zeichnenfläche beschnitten. \param
        //! pos Die Koordinaten der linken oberen Ecke der Zeichenfläche \param
        //! gr Die Größe der Zeichenfläche \return 1, falls die neue
        //! Zeichenfläche ganz oder teilweise innerhalb der bestehenden
        //! Zeichenfläche ligt. Wenn 0 zurückgegeben wird, wurde die
        //! Zeichenfläche nicht gesetzt und es braucht nicht
        //! releaseDrawOptions() aufgerufen werden
        DLLEXPORT bool setDrawOptions(const Punkt& pos, const Punkt& gr);
        //! Begrenzt die Zeichenfläche in die bis zum nächsten aufruf von
        //! releaseDrawOptions() gezeichnet werden kann. Alles außerhalb der
        //! Fläche wird automatisch ignoriert. Wenn die Zeichenfläche über den
        //! Rand einer bestehenden Zeichenfläche hinausragt, wird sie
        //! automatisch auf die bestehende Zeichnenfläche beschnitten. \param x
        //! Die X Koordinate der linken oberen Ecke der Zeichenfläche \param y
        //! Die X Koordinate der linken oberen Ecke der Zeichenfläche \param br
        //! Die Breite der Zeichenfläche \param hi Die Höhe der Zeichenfläche
        //! \return 1, falls die neue Zeichenfläche ganz oder teilweise
        //! innerhalb der bestehenden Zeichenfläche ligt. Wenn 0 zurückgegeben
        //! wird, wurde die Zeichenfläche nicht gesetzt und es braucht nicht
        //! releaseDrawOptions() aufgerufen werden
        DLLEXPORT bool setDrawOptions(int x, int y, int br, int hi);
        //! Begrenzt die Zeichenfläche in die bis zum nächsten aufruf von
        //! releaseDrawOptions() gezeichnet werden kann. Alles außerhalb der
        //! Fläche wird automatisch ignoriert. Wenn die Zeichenfläche darf über
        //! den Rand einer bestehenden Zeichenfläche hinausragen \param pos Die
        //! Koordinaten der linken oberen Ecke der Zeichenfläche \param gr Die
        //! Größe der Zeichenfläche \return 1, falls die neue Zeichenfläche ganz
        //! oder teilweise innerhalb des Bildes ligt. Wenn 0 zurückgegeben wird,
        //! wurde die Zeichenfläche nicht gesetzt und es braucht nicht
        //! releaseDrawOptions() aufgerufen werden
        DLLEXPORT bool setDrawOptionsErzwingen(
            const Punkt& pos, const Punkt& gr);
        //! Begrenzt die Zeichenfläche in die bis zum nächsten aufruf von
        //! releaseDrawOptions() gezeichnet werden kann. Alles außerhalb der
        //! Fläche wird automatisch ignoriert. Wenn die Zeichenfläche darf über
        //! den Rand einer bestehenden Zeichenfläche hinausragen \param x Die X
        //! Koordinate der linken oberen Ecke der Zeichenfläche \param y Die X
        //! Koordinate der linken oberen Ecke der Zeichenfläche \param br Die
        //! Breite der Zeichenfläche \param hi Die Höhe der Zeichenfläche
        //! \return 1, falls die neue Zeichenfläche ganz oder teilweise
        //! innerhalb des Bildes ligt. Wenn 0 zurückgegeben wird, wurde die
        //! Zeichenfläche nicht gesetzt und es braucht nicht
        //! releaseDrawOptions() aufgerufen werden
        DLLEXPORT bool setDrawOptionsErzwingen(int x, int y, int br, int hi);
        //! Setzt neue Draw options auf bildgröße
        DLLEXPORT void setDrawOptionsReset();
        //! Setzt Koordinaten, die bei den Zeichenfunktionen von den Positionen
        //! abgezogen werden Vorher sollte eine Zeichenfläche mit SetDrawOptions
        //! gesetzt worden sein. Die Werte werden mit dem aufruf von
        //! releaseDrawOptions() wieder zurückgesetzt. \param xOff Ein Wert, der
        //! von allen X Koordinaten abgezogen wird \param yOff Ein Wert, der von
        //! allen Y Koordinaten abgezogen wird
        DLLEXPORT void addScrollOffset(int xOff, int yOff);
        //! Entfernt die als letztes gesetzte begrenzung der Zeichenfläche und
        //! alle seit dem gesetzten Scroll Offsets Stellt die vorherige
        //! Zeichenfläche und die zugehörigen Scroll Offsets wieder her
        DLLEXPORT void releaseDrawOptions();
        //! Gibt zurück, ob sich das Bild seit dem letzten Aufruf dieser
        //! Funktion verändert hat
        DLLEXPORT bool getRend();
        //! Gibt den Array mit A8R8G8B8 Farbwerten der Pixel zurück
        //! Der Index eines Pixels berechnet sich durch x + y * Bildbreite
        DLLEXPORT int* getBuffer() const;
        //! Gibt den A8R8G8B8 Farbwert eines Pixels zurück
        //! \param x Die X Koordinate des Pixels
        //! \param y Die Y Koordinate des Pixels
        DLLEXPORT int getPixel(int x, int y) const;
        //! Gibt die Größe des Bildes zurück
        DLLEXPORT const Punkt& getSize() const;
        //! Gibt die Breite des Bildes zurück
        DLLEXPORT int getBreite() const;
        //! Gibt die Höhe des Bildes zurück
        DLLEXPORT int getHeight() const;
        //! Gibt den aktuellen mindest Transparenz Wert zurück
        DLLEXPORT unsigned char getAlpha() const;
        //! Gibt die Koordinaten der linken oberen Ecke der aktuellen
        //! Zeichenfläche zurück
        DLLEXPORT const Punkt& getDrawPos() const;
        //! Gibt die Größe der aktuelen Zeichenfläche zurück
        DLLEXPORT const Punkt& getDrawGr() const;
        //! Gibt die Koordinaten zurück, die zu allen Positionen vor dem
        //! Zeichnen hinzugefügt werden
        DLLEXPORT const Punkt& getDrawOff() const;
        //! Wird dieser Flag gesetzt, so wird beim Alpha Blending wenn die
        //! vorheriege Farbe 0 ist nur die neue mit ihrem Alpha Wert kopiert.
        //! Das ist sinnvoll für die Verwendung im 3DBildschirm, wo das
        //! Gezeichnette Bild später mittels Alpha Blending angezeigt wird. Der
        //! Flag wird im 3DBildschirm automatisch gesetzt
        DLLEXPORT bool hasAlpha3D();
    };

    //! Eine Zeichnung des 2d GUI Frameworks, die ein Bild anzeigt.
    class BildZ : public ZeichnungHintergrund
    {
    public:
        class Style : public ZeichnungHintergrund::Style
        {
        public:
            static const __int64 Alpha
                = 0x1000; //! Wenn dieser Flag gesetzt ist, wird zum Zeichnen
                          //! des Bildes Alpha Blending verwendet
            static const __int64 Skalliert
                = 0x2000; //! Wenn dieser Flag gesetzt ist, wird das Bild in die
                          //! Zeichenfläche skalliert

            static const __int64 normal
                = HScroll | Sichtbar | Erlaubt | Rahmen
                | VScroll; //! Der Normale Style einer Bild Zeichnung Bestehend
                           //! aus HScroll, Sichtbar, Erlaubt, Rahmen, VScroll
        };

    private:
        Bild* bild;

    protected:
        //! Verarbeitet ein Maus Ereignis. Wird vom Framework automatisch
        //! aufgerufen. \param me Das Ereignis
        DLLEXPORT void doMausEreignis(MausEreignis& me, bool userRet) override;

    public:
        //! Konstruktor
        DLLEXPORT BildZ();
        //! Destruktor
        DLLEXPORT virtual ~BildZ();
        //! Setzt einen Zeiger auf das Bild, was angezeigt werden soll
        //! \param b Das Bild
        DLLEXPORT void setBildZ(Bild* b);
        //! Setzt das Bild, was angezeigt werden soll. Der Inhalt des Bildes
        //! wird Kopiert \param b Das Bild
        DLLEXPORT void setBild(Bild* b);
        //! 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 die Zeihnung in ein bestimmtes Bild
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        DLLEXPORT void render(Bild& zRObj) override;
        //! Gibt das angezeigte Bild zurück
        DLLEXPORT Bild* getBild() const;
        //! Gbt das angezeigte Bild ohne erhöhten Reference Counter zurück
        DLLEXPORT Bild* zBild() const;
        //! Kopiert die Komplette Zeichnung, so dass sie ohne Effekt auf das
        //! Original verändert werden kann
        DLLEXPORT Zeichnung* dublizieren() const override;
    };

#ifdef WIN32
    //! Lädt ein Bild aus einer .bmp, .jpg, .gif oder .png Datei
    //! \param pfad Der Pfad zur Bilddatei
    //! \param zError Ein Zeiger auf ein Text Objekt, in dem ein möglicher
    //! Fehler zurückgegeben wird \return Das geladene Bild
    DLLEXPORT Bild* ladeBild(const char* pfad, Text* zError);
#endif
} // namespace Framework
#endif