KSG-Framework/Diagramm.h

#ifndef Diagramm_H
#define Diagramm_H

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

namespace Framework
{
    class Rahmen;     //! Rahmen.h
    class AlphaFeld;  //! AlphaFeld.h
    class Text;       //! Text.h
    class Schrift;    //! Schrift.h
    class HScrollBar; //! Scroll.h
    class VScrollBar; //! Scroll.h
    class SLDiag;     //! aus dieser Datei
    class LDiag;      //! aus dieser Datei
    class TextRenderer;

    //! Eine Zeichnung de 2D GUI Frameworks, die ein live Diagramm von werten
    //! zeichnet
    class SLDiag : public ZeichnungHintergrund
    {
    public:
        class Style : public ZeichnungHintergrund::Style
        {
        public:
            static const __int64 Gitter
                = 0x01000; //! Es wird ein Gitter im Diagramm zur Orientierung
                           //! gezeichnet
            static const __int64 LinienName
                = 0x02000; //! Es werden die Namen der Graphen angezeigt

            static const __int64 normal
                = Sichtbar | Hintergrund | Rahmen | Gitter
                | LinienName; //! Vereinigung der Flags Sichtbar, Hintergrund,
                              //! Rahmen, Gitter, LinienName
        };

    private:
        int gF;
        Array<int>* lFarbe;
        RCArray<Text>* lName;
        RCArray<Array<int>>* ph;
        RCArray<Array<int>>* pb;
        Array<int>* lastValue;
        TextRenderer* textRd;
        Punkt gitterGr;
        int lines;

    public:
        //! Konstruktor
        DLLEXPORT SLDiag();
        //! Destruktor
        DLLEXPORT virtual ~SLDiag();
        //! Setzt den verwendeten TextRenderer
        //! \param textRd Der Textrenderer
        DLLEXPORT void setTextRendererZ(TextRenderer* textRd);
        //! Setzt einen Zeiger zur verwendeten Schrift
        //! \param schrift Die Schrift
        DLLEXPORT void setSchriftZ(Schrift* schrift);
        //! Setzt die Abstände zwischen den Linien des Gitters
        //! \param gr Für x den Abstand zwischen jeder vertikalen Linie in
        //! Pixeln und für y den Abstand zwischen jeder Horizontalen Linie in
        //! den dargestellen y Werten
        DLLEXPORT void setGSize(Punkt& gr);
        //! Setzt die Farbe der Raster Linien
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setGFarbe(int f);
        //! Fügt dem Diagramm einen neuen Graphen hinzu
        //! \param name Der Name des Graphen. Er wird bei dem Flag LinienName im
        //! Diagramm angezeigt
        DLLEXPORT void addLinie(const char* name);
        //! Fügt dem Diagramm einen neuen Graphen hinzu
        //! \param name Der Name des Graphen. Er wird bei dem Flag LinienName im
        //! Diagramm angezeigt
        DLLEXPORT void addLinie(Text* txt);
        //! Setzt die Farbe eines Graphen
        //! \param lNum Der Index des Graphen
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setLFarbe(int lNum, int f);
        //! Fügt einem Graphen einen Punkt hinzu. Hierdurch verschieben sich
        //! alle Punkte des Graphen so weit nach Links, dass der neue Punkt
        //! rechts auftaucht. Geht ein Punkt links aus dem Diagramm raus, wird
        //! er gelöscht. Auf diese Weise erscheint das Diagramm wie eine
        //! Abbildung einer Live Messung \param x Der Abstand zum Letzten Punkt
        //! in Pixeln \param y Den Wert der abgebildeten Funktion in dem Punkt
        DLLEXPORT void addPunkt(int lNum, int x, int h);
        //! Entfernt einen Graphen
        //! \param lNum Der Index des Graphen
        DLLEXPORT void removeLinie(int lNum);
        //! Zeichnet das Diagramm
        //! \param zRObj Das Bild, in das gezeichnet werden soll
        DLLEXPORT void render(Bild& zRObj) override;
        //! Gibt die verwendete Schrift zurück
        DLLEXPORT Schrift* getSchrift() const;
        //! Gibt die verwendete Schrift ohne erhöhten Reference Counter zurück
        DLLEXPORT Schrift* zSchrift() const;
        //! Gibt die Größe eines Quadrats des Gitters zurück, wobei die Braite
        //! in Pixeln und die Höhe in Werten der y Achse ist
        DLLEXPORT const Punkt& getGSize() const;
        //! Gibt die Farbe des Gitters in A8R8G8B8 Format zurück
        DLLEXPORT int getGFarbe() const;
        //! Gibt den Index eines Graphen zurück
        //! \param name Der Name des Graphen
        DLLEXPORT int getLinienNummer(const char* name) const;
        //! Gibt den Index eines Graphen zurück
        //! \param name Der Name des Graphen
        DLLEXPORT int getLinienNummer(Text* name) const;
        //! Gibt den Namen eines Graphen zurück
        //! \param lNum Der Index des Graphen
        DLLEXPORT Text* getLinienName(int lNum) const;
        //! Gibt den Namen eines Graphen ohne erhöhten Reference Counter zurück
        //! \param lNum Der Index des Graphen
        DLLEXPORT Text* zLinienNamen(int lNum) const;
        //! Gibt den Höchsten y Wert von allen Graphen zurück
        DLLEXPORT int getHighestValue() const;
        //! Gibt den Höchsten y Wert von einem Bestimmten Graphen zurück
        //! \param lNum Der Index des Graphen
        DLLEXPORT int getHighestValue(int lNum) const;
        //! Gibt den Durchschnittswert aller im Diagramm gespeicherten Punkten
        //! eines Graphen zurück \param lNum Der Index des Graphen
        DLLEXPORT int getMedian(int lNum) const;
        //! Gibt die Anzahl an Graphen zurück
        DLLEXPORT int getLAnzahl() const;
        //! Gibt den y Wert des letzten Punktes eines Graphen zurück
        //! \param lNum Der Index des Graphen
        DLLEXPORT int getLastValue(int lNum) const;
    };

    //! Punkt eines Wertes eines Diagramms
    struct DiagPunkt
    {
        //! Position des Punktes auf dem Horizontalen Intervall des Diagramms
        double hIntervall;
        //! Position des punktes auf dem Vertikalen Intervall des Diagramms
        double vIntervall;
    };

    //! Wert der in einem Diagramm visualisiert wird
    struct DiagWert : public virtual ReferenceCounter
    {
        //! Style eines Diagramm Wertes
        class Style
        {
        public:
            static const int Sichtbar
                = 0x01; //! Legt fest, ob der Wert angezeigt werden soll
            static const int Alpha
                = 0x02; //! Legt fest, ob beim zeichnen des Wertes Alphablending
                        //! verwendet werden soll
            static const int Hintergrund
                = 0x04; //! Legt fest, ob der Wert einen Hintergrund hat
            static const int HAlpha
                = 0x08; //! Legt fest, ob beim zeichnen des Hintergrundes
                        //! Alphablending verwendet werden soll
            static const int Name = 0x10; //! Legt fest, ob der Name des Wertes
                                          //! gezeichnet werden soll
        };

        //! Style des Wertes
        int style;
        //! Farbe des Wertes
        int farbe;
        //! Hintergrundfarbe des Wertes
        int hintergrund;
        //! Name des Wertes
        Text* name;
        //! Punkte des Wertes
        Array<DiagPunkt*>* punkte;

        //! Konstruktor
        DLLEXPORT DiagWert();
        //! Destruktor
        DLLEXPORT ~DiagWert();
    };

    //! Daten für ein Diagramm
    struct DiagDaten : public virtual ReferenceCounter
    {
        class Style
        {
        public:
            static const int Sichtbar
                = 0x0001; //! Legt Fest, ob die Daten sichtbar sein sollen
            static const int Raster
                = 0x0002; //! Legt fest, ob ein Raster zur Orientierung
                          //! angezeigt werden soll
            static const int RasterAlpha
                = 0x0004; //! Legt fest, ob zum Zeichnen des Rasters
                          //! Alphablending verwendet werden soll
            static const int AutoIntervallHeight
                = 0x0008; //! Legt fest, dass alle Werte automatisch so auf der
                          //! y Achse Skalliert werden, dass immer die komplette
                          //! Höhe des Diagramms genutzt wird
            static const int AutoIntervallBreite
                = 0x0010; //! Legt fest, dass alle Wert automatisch so auf der x
                          //! Achse Skalliert werden, dass immer die komplette
                          //! Breite des Diagramms genutzt wird
            static const int HIntervall
                = 0x0020; //! Legt fest, ob die X Achse gezeichnet werden soll
            static const int VIntervall
                = 0x0040; //! Legt fest, ob die Y Achse gezeichnet werden soll
            static const int HIntervallTexte
                = 0x0200; //! Legt fest, ob spezielle Texte für die Werte der X
                          //! Achse gezeichnet werden sollen
            static const int VIntervallTexte
                = 0x0400; //! Left fest, ob spezielle Texte für die Werte der Y
                          //! Achse gezeichnet werden sollen
            static const int AutoRasterBreite
                = 0x0800; //! Legt fest, ob der Abstand zwischen den Vertikalen
                          //! Linien des Rasters automatisch gewählt werden soll
            static const int AutoRasterHeight
                = 0x1000; //! Legt fest, ob der Abstand zwischen den
                          //! Horizontalen Rasterlinien automatisch gewählt
                          //! werden soll

            static const int intervalle
                = HIntervall
                | VIntervall; //! Vereiniegt die Flags HIntervall, VIntervall
            static const int intervallTexte
                = HIntervallTexte
                | VIntervallTexte; //! Vereint die Flags HIntervallTexte,
                                   //! VIntervallTexte
            static const int autoRaster
                = AutoRasterHeight | AutoRasterBreite
                | Raster; //! Vereint die Flags AutoRasterHöhe,
                          //! AutoRasterBreite, Raster
            static const int autoIntervall
                = AutoIntervallHeight
                | AutoIntervallBreite; //! Vereint die Flags AutoIntervallHöhe,
                                       //! AutoIntervallBreite
        };

        //! Style eines Diagramms
        int style;
        //! Breite einer Rasterlinie
        int rasterDicke;
        //! Breite eines Rasterkästchens
        double rasterBreite;
        //! Höhe eines Rasterkästchens
        double rasterHeight;
        //! Farbe des Rasters
        int rasterFarbe;
        //! Schriftfarbe des Horizontalen Intervalls
        int hIntervallFarbe;
        //! Schriftfarbe des Vertikalen Intervalls
        int vIntervallFarbe;
        //! Name des Horizontalen Intervalls
        Text* hIntervallName;
        //! Name des Vertikalen Intervalls
        Text* vIntervallName;
        //! Anzeigen des Horizontalen Intervalls
        RCArray<Text>* hIntervallTexte;
        //! Anzeigen des Vertikalen Intervalls
        RCArray<Text>* vIntervallTexte;
        //! einzelne Horizontale Intervalle
        Array<double>* hIntervallWerte;
        //! einzelne Vertikale Intervalle
        Array<double>* vIntervallWerte;
        //! Breite des Wertes 1 in Pixeln bei dem horizontalen Intervall ( wird
        //! durch das setzen von AutoIntervallBreite überschrieben )
        double hIntervallBreite;
        //! Höhe des Wertes 1 in Pixeln bei dem vertikalen Intervall ( wird
        //! durch das setzen von AutoIntervallHöhe überschrieben )
        double vIntervallHeight;
        //! Werte, die in dem Diagramm visualisiert werden
        RCArray<DiagWert>* werte;

        //! Konstruktor
        DLLEXPORT DiagDaten();
        //! Destruktor
        DLLEXPORT ~DiagDaten();
    };

    //! Basisklasse der verschiedenen Diagramm Arten
    class BaseDiag
    {
    protected:
        DiagDaten* daten;
        bool changed;
        Critical* lock;

    public:
        //! Konstruktor
        //! \param lock Ein Zeiger zur Critical, mit der die Diagramm Klasse,
        //! die von dieser Klasse erbt Multithread sicher gemacht wird
        DLLEXPORT BaseDiag(Critical* lock);
        //! Destruktor
        DLLEXPORT virtual ~BaseDiag();
        //! Setzt einen Zeiger auf die Daten des Diagramms
        //! \param dd Die Daten
        DLLEXPORT void setDiagDatenZ(DiagDaten* dd);
        //! Kopiert die Daten eines Diagramms
        //! \param dd Die Daten
        DLLEXPORT void setDiagDaten(DiagDaten* dd);
        //! Rasterdicke setzen
        //! \param d Die Breite einer Rasterlinie in Pixeln
        DLLEXPORT void setRasterDicke(int d);
        //! Rasterbreite setzen
        //! \param br Der Abstand zwischen zwei Vertikalen Rasterlinien in
        //! Pixeln
        DLLEXPORT void setRasterBreite(int br);
        //! Rasterhöhe setzen
        //! \param hi Der Abstand zwischen zwei Horizontalen Rasterlinien in
        //! Pixeln
        DLLEXPORT void setRasterHeight(int hi);
        //! Rasterfarbe setzen
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setRasterFarbe(int f);
        //! Setzt die Intervall Breite
        //! \param br Der Abstand zwischen den Werten 0 und 1 auf der X Achse in
        //! Pixeln
        DLLEXPORT void setHIntervallBreite(double br);
        //! Setzt die Intervall Höhe
        //! \param hi Der Abstand zwischen den Werten 0 und 1 auf der Y Achse in
        //! Pixeln
        DLLEXPORT void setVIntervallHeight(double hi);
        //! Setzt die Farbe der X Achse
        //! \param f Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setHIntervallFarbe(int f);
        //! Setzt die Farbe der Y Achse
        //! \param f Die Farbe im A8R8G8B8 Formats
        DLLEXPORT void setVIntervallFarbe(int f);
        //! Setzt den Namen der X Achse
        //! \param name Der Name
        DLLEXPORT void setHIntervallName(const char* name);
        //! Setzt den Namen der X Achse
        //! \param name Der Name
        DLLEXPORT void setHIntervallName(Text* name);
        //! Setzt den Namen der Y Achse
        //! \param name Der Name
        DLLEXPORT void setVIntervallName(const char* name);
        //! Setzt den Namen der Y Achse
        //! \param name Der Name
        DLLEXPORT void setVIntervallName(Text* name);
        //! Beschriftet einen Betimmten Wert der X Achse, falls der Flag
        //! HIntervallTexte in den DiagDaten gesetzt wurde \param hIntervall Der
        //! Wert, der beschriftet werden soll \param text Die Beschriftung
        DLLEXPORT void addHIntervallText(double hIntervall, const char* text);
        //! Beschriftet einen Betimmten Wert der X Achse, falls der Flag
        //! HIntervallTexte in den DiagDaten gesetzt wurde \param hIntervall Der
        //! Wert, der beschriftet werden soll \param text Die Beschriftung
        DLLEXPORT void addHIntervallText(double hIntervall, Text* text);
        //! setzt den Zeiger auf eine Beschriftung in einen Betimmten Wert der X
        //! Achse, falls der Flag HIntervallTexte in den DiagDaten gesetzt wurde
        //! \param hIntervall Der Wert, der beschriftet werden soll
        //! \param text Die Beschriftung
        DLLEXPORT void setHIntervallTextZ(double hIntervall, Text* text);
        //! Ändert eine Beschriftung in einen Betimmten Wert der X Achse, falls
        //! der Flag HIntervallTexte in den DiagDaten gesetzt wurde \param
        //! hIntervall Der Wert, der beschriftet werden soll \param text Die
        //! Beschriftung
        DLLEXPORT void setHIntervallText(double hIntervall, Text* text);
        //! Ändert eine Beschriftung in einen Betimmten Wert der X Achse, falls
        //! der Flag HIntervallTexte in den DiagDaten gesetzt wurde \param
        //! hIntervall Der Wert, der beschriftet werden soll \param text Die
        //! Beschriftung
        DLLEXPORT void setHIntervallText(double hIntervall, const char* text);
        //! Entfernt eine Beschriftung in einen Betimmten Wert der X Achse,
        //! falls der Flag HIntervallTexte in den DiagDaten gesetzt wurde \param
        //! hIntervall Der Wert, der nicht mehr beschriftet sein soll
        DLLEXPORT void removeHIntervallText(double hIntervall);
        //! Beschriftet einen Betimmten Wert der Y Achse, falls der Flag
        //! VIntervallTexte in den DiagDaten gesetzt wurde \param vIntervall Der
        //! Wert, der beschriftet werden soll \param text Die Beschriftung
        DLLEXPORT void addVIntervallText(double vIntervall, const char* text);
        //! Beschriftet einen Betimmten Wert der Y Achse, falls der Flag
        //! VIntervallTexte in den DiagDaten gesetzt wurde \param vIntervall Der
        //! Wert, der beschriftet werden soll \param text Die Beschriftung
        DLLEXPORT void addVIntervallText(double vIntervall, Text* text);
        //! setzt den Zeiger auf eine Beschriftung in einen Betimmten Wert der Y
        //! Achse, falls der Flag VIntervallTexte in den DiagDaten gesetzt wurde
        //! \param vIntervall Der Wert, der beschriftet werden soll
        //! \param text Die Beschriftung
        DLLEXPORT void setVIntervallTextZ(double vIntervall, Text* text);
        //! Ändert eine Beschriftung in einen Betimmten Wert der Y Achse, falls
        //! der Flag VIntervallTexte in den DiagDaten gesetzt wurde \param
        //! vIntervall Der Wert, der beschriftet werden soll \param text Die
        //! Beschriftung
        DLLEXPORT void setVIntervallText(double vIntervall, Text* text);
        //! Ändert eine Beschriftung in einen Betimmten Wert der Y Achse, falls
        //! der Flag VIntervallTexte in den DiagDaten gesetzt wurde \param
        //! vIntervall Der Wert, der beschriftet werden soll \param text Die
        //! Beschriftung
        DLLEXPORT void setVIntervallText(double vIntervall, const char* text);
        //! Entfernt eine Beschriftung in einen Betimmten Wert der Y Achse,
        //! falls der Flag VIntervallTexte in den DiagDaten gesetzt wurde \param
        //! vIntervall Der Wert, der nicht mehr beschriftet sein soll
        DLLEXPORT void removeVIntervallText(double vIntervall);
        //! Fügt einen im Diagramm dargestellten Wert (Graph) hinzu
        //! \param w Der neue Wert
        DLLEXPORT void addWertZ(DiagWert* w);
        //! Fügt einen im Diagramm dargestellten Wert (Graph) hinzu, indem ein
        //! anderer Kopiert wird \param w Der Wert, der Kopiert werden soll
        DLLEXPORT void addWert(DiagWert* w);
        //! Fügt einen im Diagramm dargestellten Wert (Graph) hinzu
        //! \param name Der Name des Wertes
        DLLEXPORT void addWert(const char* name);
        //! Fügt einen im Diagramm dargestellten Wert (Graph) hinzu
        //! \param name Der Name des Wertes
        DLLEXPORT void addWert(Text* txt);
        //! setzt die Farbe eines Wertes
        //! \param wNum Der Index des Wertes
        //! \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setWertFarbe(int wNum, int fc);
        //! fügt einem Wert einen Punkt hinzu
        //! \param wNum Der Index des Wertes
        //! \param p Der neue Punkt
        DLLEXPORT void addPunktZ(int wNum, DiagPunkt* p);
        //! fügt einem Wert einen Punkt hinzu, indem ein Punkt kopiert wird
        //! \param wNum Der Index des Wertes
        //! \param p Der Punkt, der kopiert werden soll
        DLLEXPORT void addPunkt(int wNum, DiagPunkt* p);
        //! Fügt einem Wert einen Punkt hinzu
        //! \param wNum Der Index des Wertes
        //! \param hI Der Wert des Punktes auf der X Achse
        //! \param vI Der Wert des Punktes auf der Y Achse
        DLLEXPORT void addPunkt(int wNum, double hI, double vI);
        //! Setzt einen Zeiger auf einen vorhandenen Punkt eines Wertes
        //! \param wNum Der Index des Wertes
        //! \param hI Der Wert des Punktes auf der X Achse, der ersetzt werden
        //! soll \param p Der neue Punkt
        DLLEXPORT void setPunktZ(int wNum, double hI, DiagPunkt* p);
        //! Setzt einen vorhandenen Punkt eines Wertes, indem ein Punkt kopiert
        //! wird \param wNum Der Index des Wertes \param hI Der Wert des Punktes
        //! auf der X Achse, der ersetzt werden soll \param p Der neue Punkt
        DLLEXPORT void setPunkt(int wNum, double hI, DiagPunkt* p);
        //! Setzt einen vorhandenen Punkt eines Wertes
        //! \param wNum Der Index des Wertes
        //! \param hI Der Wert des Punktes auf der X Achse, der ersetzt werden
        //! soll \param h Der Wert auf der X Achse des neuen Punktes \param v
        //! Der Wert auf der Y Achse des neuen Punktes
        DLLEXPORT void setPunkt(int wNum, double hI, double h, double v);
        //! Setzt einen Zeiger auf einen vorhandenen Punkt eines Wertes
        //! \param wNum Der Index des Wertes
        //! \param pNum Der Index des Punktes im Wert
        //! \param p Der neue Punkt
        DLLEXPORT void setPunktZ(int wNum, int pNum, DiagPunkt* p);
        //! Setzt einen vorhandenen Punkt eines Wertes, indem ein Punkt kopiert
        //! wird \param wNum Der Index des Wertes \param pNum Der Index des
        //! Punktes im Wert \param p Der neue Punkt
        DLLEXPORT void setPunkt(int wNum, int pNum, DiagPunkt* p);
        //! Setzt einen vorhandenen Punkt eines Wertes
        //! \param wNum Der Index des Wertes
        //! \param pNum Der Index des Punktes im Wert
        //! \param h Der Wert auf der X Achse des neuen Punktes
        //! \param v Der Wert auf der Y Achse des neuen Punktes
        DLLEXPORT void setPunkt(int wNum, int pNum, double h, double v);
        //! Löscht einen vorhandenen Punkt
        //! \param wNum Der Index des Wertes
        //! \param hI Der Wert auf der X Achse des Punktes, der gelöscht werden
        //! soll
        DLLEXPORT void removePunkt(int wNum, double hI);
        //! Löscht einen vorhandenen Punkt
        //! \param wNum Der Index des Wertes
        //! \param pNum Der Index des Punktes im Wert
        DLLEXPORT void removePunkt(int wNum, int pNum);
        //! entfernt einen Wert
        //! \param wNum Der Index des Wertes
        DLLEXPORT void removeWert(int wNum);
        //! entfernt einen Wert
        //! \param name Der Name des Wertes
        DLLEXPORT void removeWert(const char* name);
        //! entfernt einen Wert
        //! \param name Der Name des Wertes
        DLLEXPORT void removeWert(Text* name);
        //! Fügt den DiagDaten bestimmte Styles hinzu
        //! \param style Die neuen Styles
        DLLEXPORT void addDatenStyle(int style);
        //! Setzt die Styles der DiagDaten
        //! \param style Die neuen Styles
        DLLEXPORT void setDatenStyle(int style);
        //! Setzt die Styles der DiagDaten
        //! \param style Die Styles
        //! \param addRemove 1, falls die Styles hinzugefügt werden sollem. 0,
        //! falls die Styles entfernt werden sollen
        DLLEXPORT void setDatenStyle(int style, bool addRemove);
        //! Entfernt Styles der DiagDaten
        //! \param style Die Styles, die entfernt werden sollen
        DLLEXPORT void removeDatenStyle(int style);
        //! Fügt einem bestimmten Wert bestimmte Styles hinzu
        //! \param wNum Der Index des Wertes
        //! \param style Die neuen Styles
        DLLEXPORT void addWertStyle(int wNum, int style);
        //! Setzt die Styles eines Bestimmten Wertes
        //! \param wNum Der Index des Wertes
        //! \param style Die neuen Styles
        DLLEXPORT void setWertStyle(int wNum, int style);
        //! Setzt die Styles eines Bestimmten Wertes
        //! \param wNum Der Index des Wertes
        //! \param style Die Styles
        //! \param addRemove 1, falls die Styles hinzugefügt werden sollem. 0,
        //! falls die Styles entfernt werden sollen
        DLLEXPORT void setWertStyle(int wNum, int style, bool addRemove);
        //! Entfernt Styles eines Bestimmten Wertes
        //! \param wNum Der Index des Wertes
        //! \param style Die Styles, die entfernt werden sollen
        DLLEXPORT void removeWertStyle(int wNum, int style);
        //! Gibt die Daten des Diagramms zurück
        DLLEXPORT DiagDaten* getDiagDaten() const;
        //! Gibt die Daten des Diagramms ohne erhöhten Reference Counter zurück
        DLLEXPORT DiagDaten* zDiagDaten() const;
        //! Gibt die Daten eines Wertes zurück
        //! \param wNum Der Index des Wertes
        DLLEXPORT DiagWert* getDiagWert(int wNum) const;
        //! Gibt die Daten eines Wertes ohne erhöhten Reference Counter zurück
        //! \param wNum Der Index des Wertes
        DLLEXPORT DiagWert* zDiagWert(int wNum) const;
        //! Gibt die Daten eines Wertes zurück
        //! \param name Der Name des Wertes
        DLLEXPORT DiagWert* getDiagWert(const char* name) const;
        //! Gibt die Daten eines Wertes ohne erhöhten Reference Counter zurück
        //! \param name Der Name des Wertes
        DLLEXPORT DiagWert* zDiagWert(const char* name) const;
        //! Gibt den Index eines Wertes zurück
        //! \param name Der Name des Wertes
        DLLEXPORT int getDiagWertPos(const char* name) const;
        //! Gibt den Index eines Punktes von einem Wert zurück
        //! \param wNum Der Index des Wertes
        //! \param hI Der Wert auf der X Achse des Punktes
        DLLEXPORT int getDiagPunktPos(int wNum, double hI) const;
        //! Gibt den Index eines Punktes von einem Wert zurück
        //! \param wName Der Name des Wertes
        //! \param hI Der Wert auf der X Achse des Punktes
        DLLEXPORT int getDiagPunktPos(char* wName, double hI) const;
        //! Prüft, ob bestimmte Styles in den DiagDaten gesetzt wurden
        //! \param style Die Styles
        DLLEXPORT inline bool hatDatenStyle(int style) const;
        //! Prüft, ob bestimmte Styles in den DiagDaten nicht gesetzt wurden
        //! \param style Die Styles
        DLLEXPORT inline bool hatDatenStyleNicht(int style) const;
        //! Prüft, ob bestimmte Styles für einen bestimmten Wert gesetzt wurden
        //! \param wNum Der Index des Wertes
        //! \param style Die Styles
        DLLEXPORT inline bool hatWertStyle(int wNum, int style) const;
        //! Prüft, ob bestimmte Styles für einen bestimmten Wert nicht gesetzt
        //! wurden \param wNum Der Index des Wertes \param style Die Styles
        DLLEXPORT inline bool hatWertStyleNicht(int wNum, int style) const;
    };

    //! Eine Zeichnung des 2D GUI Frameworks, die die Diagrammdaten als
    //! Liniengraphen darstellt
    class LDiag : public ZeichnungHintergrund,
                  public BaseDiag
    {
    public:
        class Style : public ZeichnungHintergrund::Style
        {
        public:
            static const __int64 DatenRahmen
                = 0x0001000; //! Legt fest, ob um die daten ein Rahmen
                             //! gezeichnet wird
            static const __int64 DatenHintergrund
                = 0x02000; //! legt fest, ob die Daten einen Hintergrund haben
            static const __int64 DatenHAlpha
                = 0x04000; //! legt fest, ob beim zeichnen des Hintergrunds der
                           //! Daten alpha blending benutzt wird
            static const __int64 DatenHBild
                = 0x008000; //! Legt fest, ob für den Hintergrund der Daten ein
                            //! Bild verwendet werden soll
            static const __int64 DatenBuffered
                = 0x010000; //! Legt fest, ob die Daten einen Farbübergang haben

            static const __int64 scroll
                = VScroll | HScroll; //! Vereint die Flags VScroll und HScroll
            static const __int64 normal
                = Hintergrund | scroll
                | DatenRahmen; //! Vereint die Flags Hintergrund, scroll,
                               //! DatenRahmen
        };

    private:
        TextRenderer* textRd;
        Rahmen* dRam;
        int dBgF;
        Bild* dBgB;
        AlphaFeld* dAf;
        Bild* vIntervallRB;
        Bild* hIntervallRB;
        int schriftGr;
        //! 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 LDiag();
        //! Destruktor
        DLLEXPORT virtual ~LDiag();
        //! Setzt den verwendeten TextRenderer
        //! \param textRd Der Textrenderer
        DLLEXPORT void setTextRendererZ(TextRenderer* textRd);
        //! Setzt die Schrift
        //! \param schrift Die Schrift
        DLLEXPORT void setSchriftZ(Schrift* schrift);
        //! Setzt die größe der Schrift
        //! \param gr Die Höhe einer Zeile in Pixeln
        DLLEXPORT void setSchriftSize(int gr);
        //! Setzt den inneren Rahmen um das eigentliche Diagramm (Rahmen um die
        //! Daten) \param ram Der Rahmen
        DLLEXPORT void setDatenRahmenZ(Rahmen* ram);
        //! Setzt den inneren Rahmen um das eigentliche Diagramm (Rahmen um die
        //! Daten), indem ein Rahmen kopiert wird \param ram Der Rahmen, der
        //! kopiert werden soll
        DLLEXPORT void setDatenRahmen(Rahmen* ram);
        //! Setzt die Breite des inneren Rahmen um das eigentliche Diagramm
        //! (Rahmen um die Daten) \param br Die Breite in Pixeln
        DLLEXPORT void setDatenRahmenBreite(int br);
        //! Setzt die Farbe des inneren Rahmen um das eigentliche Diagramm
        //! (Rahmen um die Daten) \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setDatenRahmenFarbe(int fc);
        //! Setzt den Hintergrund des eigentlichen Diagramms
        DLLEXPORT void setDatenHintergrundFarbe(int fc);
        DLLEXPORT void setDatenHintergrundBildZ(Bild* b);
        DLLEXPORT void setDatenHintergrundBild(Bild* b);
        //! Setzt den Farbübergang des eigentlichen Diagramms (Farbübergang der
        //! Daten) \param af Der Farbübergang
        DLLEXPORT void setDatenAlphaFeldZ(AlphaFeld* af);
        //! Setzt den Farbübergang des eigentlichen Diagramms (Farbübergang der
        //! Daten), indem ein Farbübergang kopiert wird \param af Der
        //! Farbübergang, der Kopiert werden soll
        DLLEXPORT void setDatenAlphaFeld(AlphaFeld* af);
        //! Setzt die Farbe des Farbübergangs des eigentlichen Diagramms
        //! (Farbübergang der Daten) \param fc Die Farbe im A8R8G8B8 Format
        DLLEXPORT void setDatenAlphaFeldFarbe(int fc);
        //! Setzt die FaStärkerbe des Farbübergangs des eigentlichen Diagramms
        //! (Farbübergang der Daten) \param st Die Stärke
        DLLEXPORT void setDatenAlphaFeldStrength(int st);
        //! Zeichnet das Objekt nach zRObj, falls es sichtbar ist
        //! \param zRObj Das Bild, in welches gezeichnet werden soll
        DLLEXPORT void render(Bild& zRObj) override;
        //! Gibt die Schrift zurück
        DLLEXPORT Schrift* getSchrift() const;
        //! Gibt die Schrift ohne erhöhten Reference Counter zurück
        DLLEXPORT Schrift* zSchrift() const;
        //! Gibt den inneren Rahmen um das eigentliche Diagramm zurück (Rahmen
        //! um die Daten)
        DLLEXPORT Rahmen* getDatenRahmen() const;
        //! Gibt den inneren Rahmen um das eigentliche Diagramm ohne erhöhten
        //! Reference Counter zurück (Rahmen um die Daten)
        DLLEXPORT Rahmen* zDatenRahmen() const;
        //! Gibt die Farbe des inneren Rahmens um das eigentliche Diagramm im
        //! A8R8G8B8 Format zurück (Rahmen um die Daten)
        DLLEXPORT int getDatenRahmenFarbe() const;
        //! Gibt die Breite des inneren Rahmens um das eigentliche Diagramm in
        //! Pixeln zurück (Rahmen um die Daten)
        DLLEXPORT int getDatenRahmenBreite() const;
        //! Gibt die Farbe des Hintergrunds des eigentlichen Diagramms im
        //! A8R8G8B8 Format zurück (Hintergrund der Daten)
        DLLEXPORT int getDatenHintergrundFarbe() const;
        //! Gibt das Hintergrund Bild des eigentlichen Diagramms zurück
        //! (Hintergrund Bild der Daten)
        DLLEXPORT Bild* getDatenHintergrundBild() const;
        //! Gibt das Hintergrund Bild des eigentlichen Diagramms ohne erhöhten
        //! Reference Counter zurück (Hintergrund Bild der Daten)
        DLLEXPORT Bild* zDatenHintergrundBild() const;
        //! Gibt den Farbübergang des eigentlichen Diagramms zurück
        //! (Farbübergang der Daten)
        DLLEXPORT AlphaFeld* getDatenAlphaFeld() const;
        //! Gibt den Farbübergang des eigentlichen Diagramms ohne erhöhten
        //! Reference Counter zurück (Farbübergang der Daten)
        DLLEXPORT AlphaFeld* zDatenAlphaFeld() const;
        //! Gibt die Farbe des Farbübergangs des eigentlichen Diagramms im
        //! A8R8G8B8 Format zurück (Farbübergang der Daten)
        DLLEXPORT int getDatenAlphaFeldFarbe() const;
        //! Gibt die Stärke des Farbübergangs des eigentlichen Diagramms zurück
        //! (Farbübergang der Daten)
        DLLEXPORT int getDatenAlphaFeldStrength() const;
    };
} // namespace Framework

#endif