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(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:
			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