KSG-Framework/Diagramm.h

#ifndef Diagramm_H
#define Diagramm_H

#include "Zeichnung.h"
#include "Array.h"
#include "Critical.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:
            const static __int64 Gitter = 0x01000; //! Es wird ein Gitter im Diagramm zur Orientierung gezeichnet
            const static __int64 LinienName = 0x02000; //! Es werden die Namen der Graphen angezeigt

            const static __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:
            const static int Sichtbar = 0x01; //! Legt fest, ob der Wert angezeigt werden soll
            const static int Alpha = 0x02; //! Legt fest, ob beim zeichnen des Wertes Alphablending verwendet werden soll
            const static int Hintergrund = 0x04; //! Legt fest, ob der Wert einen Hintergrund hat
            const static int HAlpha = 0x08; //! Legt fest, ob beim zeichnen des Hintergrundes Alphablending verwendet werden soll
            const static 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:
            const static int Sichtbar = 0x0001; //! Legt Fest, ob die Daten sichtbar sein sollen
            const static int Raster = 0x0002; //! Legt fest, ob ein Raster zur Orientierung angezeigt werden soll
            const static int RasterAlpha = 0x0004; //! Legt fest, ob zum Zeichnen des Rasters Alphablending verwendet werden soll
            const static 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
            const static 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
            const static int HIntervall = 0x0020; //! Legt fest, ob die X Achse gezeichnet werden soll
            const static int VIntervall = 0x0040; //! Legt fest, ob die Y Achse gezeichnet werden soll
            const static int HIntervallTexte = 0x0200; //! Legt fest, ob spezielle Texte für die Werte der X Achse gezeichnet werden sollen
            const static int VIntervallTexte = 0x0400; //! Left fest, ob spezielle Texte für die Werte der Y Achse gezeichnet werden sollen
            const static int AutoRasterBreite = 0x0800; //! Legt fest, ob der Abstand zwischen den Vertikalen Linien des Rasters automatisch gewählt werden soll
            const static int AutoRasterHeight = 0x1000; //! Legt fest, ob der Abstand zwischen den Horizontalen Rasterlinien automatisch gewählt werden soll

            const static int intervalle = HIntervall | VIntervall; //! Vereiniegt die Flags HIntervall, VIntervall
            const static int intervallTexte = HIntervallTexte | VIntervallTexte; //! Vereint die Flags HIntervallTexte, VIntervallTexte
            const static int autoRaster = AutoRasterHeight | AutoRasterBreite | Raster; //! Vereint die Flags AutoRasterHöhe, AutoRasterBreite, Raster
            const static 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( 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( 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, 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, 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, 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, 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( 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( char *name ) const;
        //! Gibt die Daten eines Wertes ohne erhöhten Reference Counter zurück
        //! \param name Der Name des Wertes
        DLLEXPORT DiagWert *zDiagWert( char *name ) const;
        //! Gibt den Index eines Wertes zurück
        //! \param name Der Name des Wertes
        DLLEXPORT int getDiagWertPos( 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:
            const static __int64 DatenRahmen = 0x0001000; //! Legt fest, ob um die daten ein Rahmen gezeichnet wird
            const static __int64 DatenHintergrund = 0x02000; //! legt fest, ob die Daten einen Hintergrund haben
            const static __int64 DatenHAlpha = 0x04000; //! legt fest, ob beim zeichnen des Hintergrunds der Daten alpha blending benutzt wird
            const static __int64 DatenHBild = 0x008000; //! Legt fest, ob für den Hintergrund der Daten ein Bild verwendet werden soll
            const static __int64 DatenBuffered = 0x010000; //! Legt fest, ob die Daten einen Farbübergang haben

            const static __int64 scroll = VScroll | HScroll; //! Vereint die Flags VScroll und HScroll
            const static __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;
    };
}

#endif