#ifndef DateiSystem_H
#define DateiSystem_H

#include <fstream>
#include "Array.h"
#include "Punkt.h"

namespace Framework
{
    class Bild; //! Bild.h
    class Text; //! Text.h
    class FBalken; //! Fortschritt.h
#ifdef WIN32
    class Buchstabe; //! Schrift.h
    class Alphabet; //! Schrift.h
    class Schrift; //! Schrift.h
#endif
    class LTDBPixel; //! aus dieser Datei
    class LTDBKopf; //! aus dieser Datei
    class LTDBBody; //! aus dieser Datei
    class LTDBDatei; //! aus dieser Datei
    class LTDSPixel; //! aus dieser Datei
#ifdef WIN32
    class LTDSDateiKopf; //! aus dieser Datei
    class LTDSSchriftKopf; //! aus dieser Datei
    class LTDSBuchstabenKopf; //! aus dieser Datei
    class LTDSBuchstabenKörper; //! aus dieser Datei
    class LTDSDatei; //! aus dieser Datei
#endif

    //! LTDB Dateivormat --- Dient zum speichern von mehreren Bildern in einer Datei.

    //! Dient zum Speichern und Laden eines einzelnen Pixels aus einem Bild im LTDB Dateiformat
    class LTDBPixel //! Pixel einer LTDB Datei
    {
    private:
        LTDBPixel *davor; //! Letzter Pixel
        char index; //! Bitlänge des Pixels
        char iR, iG, iB, iA;
        char miR, miG, miB, miA;
        char maxIndex; //! Länge des Pixels
        bool change : 1; //! Verändert sich etwas an den volgenden 5 Variablen
        bool changeR : 1; //! Ändert sich Rot
        bool changeG : 1; //! Ändert sich Grün
        bool changeB : 1; //! Ändert sich Blau
        bool changeA : 1; //! Ändert sich Alpha
        unsigned char komp : 3; //! Komprimierung der Farbwerte
        unsigned char R; //! Rot
        unsigned char G; //! Grün
        unsigned char B; //! Blau
        unsigned char A; //! Alpha
        bool addBitZuFarbe( unsigned char bit ); //! Fügt den Farbwerten ein Bit hinzu
        bool getNextFarbeBit( char &byte, int i ); //! Speichert das nächste Farbbit in byte
        int ref;

    public:
        //! Konstruktor
        //! \param davor Der Pixel, der Vorher geladen wurde. 0, falls dieß der Erste Pixel ist
        DLLEXPORT LTDBPixel( LTDBPixel *davor );
        //! Destruktor 
        DLLEXPORT ~LTDBPixel();
        //! zum Laden gedacht. Fügt dem Pixel einiege bits hinzu
        //! \param byte Das zuletzt aus der Datei gelesene Byte
        //! \param begin Der Index des ersten Bits im byte, wo der Pixel beginnt
        //! \return Der Index des Bits im Byte, wo der Pixel aufgehöhrt hat. -1, falls der Pixel am ende Des Bytes noch nicht zuende ist
        DLLEXPORT char addByte( char byte, char begin );
        //! zum speichern gedacht. Setzt die Farbe, die im Pixel gespeichert werden soll
        //! \param f Die zu speichernde Farbe
        DLLEXPORT void setFarbe( int f );
        //! Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
        DLLEXPORT void komprimieren();
        //! Gibt ein Teil der Bits zurück, die den Pixel representieren
        //! \param byte Eine Referens auf das Byte, dass als nächstes gespeichert werden soll
        //! \param begin Der Index des ersten Bits im zu speichernden Byte, wo der Pixel gespeichert werden soll
        //! \return Der Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte fortgesetzt werden muss
        DLLEXPORT char getNextByte( char &byte, int begin );
        //! Gibt den Farbwert des Pixels zurück
        DLLEXPORT int zuFarbe() const;
        //! Gibt zurück, ob sich der Anteil an Rot in der Farbe im Vergleich zum Pixel davor geändert hat
        DLLEXPORT bool getChangeR() const;
        //! Gibt zurück, ob sich der Anteil an Grün in der Farbe im Vergleich zum Pixel davor geändert hat
        DLLEXPORT bool getChangeG() const;
        //! Gibt zurück, ob sich der Anteil an Blau in der Farbe im Vergleich zum Pixel davor geändert hat
        DLLEXPORT bool getChangeB() const;
        //! Gibt zurück, ob sich der Anteil an Alpha in der Farbe im Vergleich zum Pixel davor geändert hat
        DLLEXPORT bool getChangeA() const;
        //! Gibt die Komprimierung des Pixels zurück
        DLLEXPORT unsigned char getKomp() const;
        //! Gibt den Anteil an Rot in der Farbe des Pixels zurück
        DLLEXPORT unsigned char getR() const;
        //! Gibt den Anteil an Grün in der Farbe des Pixels zurück
        DLLEXPORT unsigned char getG() const;
        //! Gibt den Anteil an Blau in der Farbe des Pixels zurück
        DLLEXPORT unsigned char getB() const;
        //! Gibt den Anteil an Alpha in der Farbe des Pixels zurück
        DLLEXPORT unsigned char getA() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDBPixel *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDBPixel *release();
    };

    //! Der Kopf des LTDB Dateiformates. Hier werden informationen über alle Abgespeicherten Bilder verwaltet
    class LTDBDateiKopf
    {
    private:
        RCArray< Text > *bilder;
        Array< __int64 > *pos;
        int bAnzahl;
        int ref;

    public:
        //! konstructor
        DLLEXPORT LTDBDateiKopf();
        //! destructor 
        DLLEXPORT ~LTDBDateiKopf();
        //! Entfernt ein Bild aus dem Dateikopf
        //! \param i Der Index des Bildes, welches entfernt werden soll
        DLLEXPORT void removeBild( int i );
        //! Entfernt ein Bild aus dem Dateikopf
        //! \param txt Der Name des Bildes, welches entfernt werden soll
        DLLEXPORT void removeBild( Text *txt );
        //! Fügt dem Dateikopf ein Bild hinzu
        //! \param txt Der Name des Bildes.
        DLLEXPORT void addBild( Text *txt );
        //! Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
        //! \param i Der index Des Bildes
        //! \param pos Die Position des Bildes in der Datei
        DLLEXPORT void setBildPos( int i, __int64 pos );
        //! Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
        //! \param txt Der Name Des Bildes
        //! \param pos Die Position des Bildes in der Datei
        DLLEXPORT void setBildPos( Text *txt, __int64 pos );
        //! Lädt den Dateikopf einer LTDB Datei
        //! \param f Ein Zeiger auf einen Fortschrittsbalken, der zum Laden verwendet werden soll. Kann 0 sein.
        //! \param inF Der geöffnete ifstream der LTDB Datei, bei dem die Leseposition bereits auf das erste Byte des Dateiopfes zeigt.
        DLLEXPORT void laden( FBalken *f, std::ifstream *inF );
        //! Speichert den Dateikopf in einer LTDB Datei
        //! \param outF Der geöffnete ofstream der LTDB Datei, bei dem die Schreibposition bereits auf das erste Byte des Dateikopfes zeigt.
        DLLEXPORT void speichern( std::ofstream *outF ) const;
        //! Gibt den Namen eines bestimmten Bildes zurück
        //! \param i Der Index des Bildes, dessen Namen zurückgegeben werden soll
        //! \return Der Name des bildes
        DLLEXPORT Text *getBild( int i ) const;
        //! Gibt den Namen eines bestimmten Bildes zurück
        //! \param i Der Index des Bildes, dessen Namen zurückgegeben werden soll
        //! \return Der Name des bildes ohne erhöhten Reference Counter
        DLLEXPORT Text *zBild( int i ) const;
        //! Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
        //! \param txt Der Name des Bildes, dessen Beginn gefunden werden soll
        //! \return -1, falls das Bild nicht gefunden wurde.
        DLLEXPORT __int64 getBildPosition( Text *txt ) const;
        //! Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
        //! Fals der Index nicht existiert wird die Exception std::out_of_range geworfen.
        //! \param indes Der Indes des Bildes, dessen Beginn gefunden werden soll
        DLLEXPORT __int64 getBildPosition( int index ) const;
        //! Gibt den Index eines Bestimmten Bildes zurück
        //! \param txt Der Name des Bildes
        //! \return -1, falls das Bild nicht gefunden wurde
        DLLEXPORT int getBildIndex( Text *txt ) const;
        //! Gibt die Anzahl der Bilder in der Datei zurück
        DLLEXPORT int getbAnzahl() const;
        //! Gibt eine Liste mit Bildern in der Datei ohne erhöhten Reference Counter zurück.
        //! Die Liste sollte nicht verändert werden
        DLLEXPORT RCArray< Text > *zBildListe() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDBDateiKopf *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDBDateiKopf *release();
    };

    //! Die im LTDB Dateikopf gespeicherten Informationen für ein einzelnes Bild
    class LTDBKopf
    {
    private:
        __int64 a; //! Det LTDB Dateikopf ist maximal 104 Bits lang
        __int32 b; //! - bis zu 75 Bits für den Titel
        __int8 c;  //! - 12 Bits für breite
        int ref;   //! - 12 Bits för höhe

    public:
        //! Konstruktor 
        DLLEXPORT LTDBKopf();
        //! Lähdt die Informationen über ein Bild
        //! \param f Der geöffnette und an die richtiege Stelle zeigende ifstream der LTDB Datei
        DLLEXPORT void laden( std::ifstream *f );
        //! Setzt die Informationen die gespeichert werden sollen
        //! \param titel Der Titel des Bildes
        //! \param size Die Größe des Bildes
        //! \return Die Anzahl der Buchstaben aus dem Titel, die im LTDB Dateiformat nicht gespeichert werden können. Erlaubt ist nur a-z und A-Z und ä ü ö ß und Ä Ü Ö und .
        //! Alle großbuchstaben im Titel werden in Kleinbuchstaben umgewandelt
        DLLEXPORT int Init( Text *titel, const Punkt &size );
        //! Lähd informationen aus geladenen Bits. Wird von der laden( std::ifstream ) Funktion verwendet.
        //! \param BeginBit Der Index des ersten Bits, welches ausgewertet werden soll
        //! \param EndBit Der Index des letzten Bits, welches nichtmehr ausgewertet werden soll
        //! \param bits Die Bits, von denen alle von BeginBit bis EndBit ausgewertet werden sollen
        //! Insgesamt müssen 104 Bits gesetzt werden. Hierauf bezihen sich BeginBit und EndBit
        DLLEXPORT void setBits( int BeginBit, int EndBit, __int16 bits );
        //! Speichert die Informationen in eine Datei
        //! \param f Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDB Datei
        DLLEXPORT void speichern( std::ofstream *f ) const;
        //! Gibt die Länge des Titels zurück
        DLLEXPORT int getTitelLength() const;
        //! Gibt den Titel des Bildes zurück
        DLLEXPORT Text *getTitel() const;
        //! Gibt die Größe des Bildes zurück
        DLLEXPORT Punkt getSize() const;
        //! Gibt die nächsten zu speichernden Bits zurück
        //! \param begin Der Index des ersten Bits, in das gespeichert werden soll
        //! \param end Der Index des letzten Bits, in das gespeichert werden soll
        //! \return 16 Bits, in denen die Informationen zwischen begin und end stehen
        //! Insgesamt müssen 104 Bits gelesen werden. Hierauf bezihen sich BeginBit und EndBit
        DLLEXPORT __int16 getBits( int begin, int end )const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDBKopf *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDBKopf *release();
    };

    //! Verwaltet die Pixeldaten eines einzelnen Bildes einer LTDB Datei
    class LTDBBody
    {
    private:
        Punkt gr;
        Bild *b;
        int dateiSize;
        int ref;

    public:
        //! Konstruktor 
        DLLEXPORT LTDBBody();
        //! Konstruktor
        //! \param k Der LTDB Kopf des Bildes, der Informationen über die Größe des Bildes enthält
        DLLEXPORT LTDBBody( LTDBKopf *k );
        //! Destruktor 
        DLLEXPORT ~LTDBBody();
        //! Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
        //! \param k Der LTDB Kopf des Bildes
        DLLEXPORT void init( LTDBKopf k );
        //! Setzt die Informationen über die Größe des Bildes. Wird zum Laden benötigt.
        //! \param k Der LTDB Kopf des Bildes
        DLLEXPORT void init( LTDBKopf *k );
        //! Lädt die Pixeldaten aus der Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param inF Der geöffnete und an die richtiege Stelle zeigende ifstream der LTDB Datei
        DLLEXPORT void laden( FBalken *zF, std::ifstream *inF );
        //! Setzt das Bild, welches gespeichert werden soll
        //! \param b Das zu speichernde Bild
        DLLEXPORT void setBild( Bild *b );
        //! Speichert die Pixeldaten des Bildes in einer LTDB Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param outF Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDB Datei
        DLLEXPORT void speichern( FBalken *zF, std::ofstream *outF ) const;
        //! Gibt das geladene Bild zurück
        DLLEXPORT Bild *getBild() const;
        //! Gibt die Größe des Bildes zurück
        DLLEXPORT const Punkt &getSize() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDBBody *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDBBody *release();
    };

    //! Verwaltet eine LTDB Datei
    class LTDBDatei
    {
    private:
        Text *pfad;
        LTDBDateiKopf *datKpf;
        int ref;

    public:
        //! Konstruktor 
        DLLEXPORT LTDBDatei();
        //! Destruktor 
        DLLEXPORT ~LTDBDatei();
        //! Setzt den Pfad zu Datei
        //! \param pfad Der Pfad
        DLLEXPORT void setDatei( Text *pfad );
        //! Erstellt eine neue LTDB Datei
        DLLEXPORT void erstellen();
        //! Ließt grundlegende Informationen aus der Datei.
        //! Wird benötigt, bevor mit der Datei gearbeitet wird
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        DLLEXPORT void leseDaten( FBalken *zF );
        //! Löscht die LTDB Datei
        DLLEXPORT void remove();
        //! Löscht ein Bild aus der LTDB Datei
        //! \param zF Ein Fortschrittsbalken der 0 sein kann
        //! \param name Der Name des zu löschenden Bildes
        DLLEXPORT void remove( FBalken *zF, Text *name );
        //! Lädt ein Bild aus der LTDB Datei
        //! \param zF Ein Fortschrittsbalken, der 0 sein kann
        //! \param name Der Name des Bildes, welches geladen werden soll
        //! \return Das geladene Bild. 0, falls das Bild nicht gefunden wurde
        DLLEXPORT Bild *laden( FBalken *zF, Text *name );
        //! Speichert ein neues Bild in der LTDB Datei
        //! \param zF Ein Fortscrittsbalken, der 0 sein kann
        //! \param bild Das Bild, welches gelöscht werden soll
        //! \param name Der Name, unter dem das Bild gespeichert werden soll
        //! \return Anzahl der Warnungen, die beim Konvertieren des Namens in einen gültigen Namen aufgetreten sind. -1, falls bereis ein Bild mit dem selben Namen existiert
        DLLEXPORT int speichern( FBalken *zF, Bild *bild, Text *name );
        //! Gibt eine Liste mit gespeicherten Bildern zurück
        //! Die Liste sollte nicht verändert werden
        DLLEXPORT RCArray< Text > *zBildListe();
        //! Gibt den Pfad zur LTDB Datei zurück
        DLLEXPORT Text *getPfad() const;
        //! Gibt die Anzahl der Bilder in der LTDB Datei zurück
        DLLEXPORT int getBildAnzahl() const;
        //! Prüft, ob die LTDB Datei existiert
        DLLEXPORT bool istOffen() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDBDatei *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDBDatei *release();
    };

#ifdef WIN32
    //! LTDS Dateivormat --- Dient zum speichern von Schriftarten

    //! Verwaltet einen einzelnen Pixel von einem Buchstaben
    class LTDSPixel
    {
    private:
        int ref;
        char index;
        char iA;
        char miA;
        char maxIndex; //! Länge des Pixels
        bool änder;
        bool änderA;
        unsigned char komp : 3; //! Komprimierung der Farbwerte
        unsigned char alpha;
        LTDSPixel *davor;
        bool addBitZuFarbe( unsigned char bit ); //! Fügt den Farbwerten ein Bit hinzu
        bool getNextFarbeBit( char &byte, int i ); //! Speichert das nächste Farbbit in byte

    public:
        //! Konstruktor
        //! \param davor Der Pixel, der vor diesem geladen wurde. 0, fals dieß der erste Pixel ist
        DLLEXPORT LTDSPixel( LTDSPixel *davor );
        //! Destruktor 
        DLLEXPORT ~LTDSPixel();
        //! Fügt dem Pixel einiege geladene Bits hinzu. Zum Laden gedacht.
        //! \param byte Das letzte aus der Datei geladene Byte.
        //! \param begin Der Index des ersten Bits im Byte, wo der Pixel beginnt
        //! \return Der Index des Letzten Bits in Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte weitergeht
        DLLEXPORT char addByte( char byte, char begin );
        //! Setzt den Alpha Wert des Pixels. Zum speichern gedacht.
        //! \param alpha Der Alpha Wert des Pixels.
        DLLEXPORT void setAlpha( unsigned char alpha );
        //! Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
        DLLEXPORT void Komp();
        //! Gibt ein Teil der Bits zurück, die den Pixel representieren
        //! \param byte Eine Referens auf das Byte, dass als nächstes gespeichert werden soll
        //! \param begin Der Index des ersten Bits im zu speichernden Byte, wo der Pixel gespeichert werden soll
        //! \return Der Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1, falls der Pixel im nächsten Byte fortgesetzt werden muss
        DLLEXPORT char getNextByte( char &byte, int bbegin );
        //! Gibt die Komprimierung des Pixels zurück
        DLLEXPORT unsigned char getKomp() const;
        //! Gibt zurück, ob sich der Alpha Wert im Vergleich zu dem Pixel davor geändert hat
        DLLEXPORT bool getÄnderA() const;
        //! Gibt den Alpha Wert des Pixels zurück
        DLLEXPORT unsigned char getA() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSPixel *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSPixel *release();
    };

    //! Verwaltet den Kopf einer LTDS Datei. Er enthält Informationen über die in der Datei gespeicherten Schriftgrößen
    class LTDSDateiKopf
    {
    private:
        int ref;
        unsigned char sganzahl;
        unsigned char *gr;
        int *pos;

    public:
        //! Konstruktor 
        DLLEXPORT LTDSDateiKopf();
        //! Destruktor 
        DLLEXPORT ~LTDSDateiKopf();
        //! Lädt den Kopf aus der LTDS Datei
        //! \param inF Der geöffnete und an die richtige Stelle zeigende ifstream der LTDS Datei
        DLLEXPORT void laden( std::ifstream *inF );
        //! Fügt eine Schriftgröße hinzu
        //! \param sg Die Schriftgröße, die hinzugefügt werden soll
        DLLEXPORT void addSG( char sg );
        //! Löscht eine Schriftgröße
        //! \param sg Die Schriftgröße, die gelöscht werden soll
        DLLEXPORT void removeSG( char sg );
        //! Speichert den LTDS Kopf in der Datei
        //! \param outF Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
        DLLEXPORT void speichern( std::ofstream *outF ) const;
        //! Gibt einen Array von gespeicherten Schriftgrößen zurück
        //! Der Array sollte nicht verädert werden
        DLLEXPORT unsigned char *getSchriftGrößeList() const;
        //! Gibt einen Array mit positionen der ersten Bytes für jede Schriftgröße aus der Datei zurück
        DLLEXPORT int *getPositionList() const;
        //! Gibt die Anzahl der gespeicherten Schriftgrößen zurück
        DLLEXPORT int getSchriftGrößeAnzahl() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSDateiKopf *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSDateiKopf *release();
    };

    //! Der Kopf einer Schriftgröße. Enthält Informationen über die gespeicherten Zeichen
    class LTDSSchriftKopf
    {
    private:
        int ref;
        unsigned char schriftSize;
        unsigned char *zeichen;
        int *pos;
        unsigned char zeichenAnzahl;

    public:
        //! Konstruktor 
        DLLEXPORT LTDSSchriftKopf();
        //! Destruktor 
        DLLEXPORT ~LTDSSchriftKopf();
        //! Lädt den Kopf einer Schriftgröße aus der Datei
        //! \param inF Der geöffnete und an de richtiege Stelle zeigende ifstream der LTDS Datei
        DLLEXPORT void laden( std::ifstream *inF );
        //! Setzt die Schriftgröße. Zum speichern gedacht
        //! \param gr Die Schriftgröße
        DLLEXPORT void setSchriftgröße( unsigned char gr );
        //! Setzt das Alphabet, welches in der Schriftgröße gespeichert werden soll
        //! \param alphabet Das Alphabet, welches alle zu speichernden Zeichen in der Schriftgröße enthält
        DLLEXPORT void setZeichenAlphabet( Alphabet *alphabet );
        //! Fügt der Schriftgröße ein Zeichen hinzu, welches gespeichert werden soll
        //! \param zeichen Der ASCII code des Zeichens, welches hinzugefügt werden soll
        DLLEXPORT void addZeichen( unsigned char zeichen );
        //! Löscht ein Zeichen aus der Schriftgröße
        //! \param zeich Der ASCII code des Zeichens, welches gelöscht werden soll
        DLLEXPORT void removeZeichen( unsigned char zeich );
        //! Speichert den Kopf der Schriftgröße in der LTDS Datei
        //! \param outF Der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
        DLLEXPORT void speichern( std::ofstream *outF ) const;
        //! Gibt die Schriftgröße zurück, zu der dieser Kopf gehöhrt
        DLLEXPORT unsigned char getSchriftGröße() const;
        //! Gibt die Anzahl der in der Schriftgröße gespeicherten Zeichen zurück
        DLLEXPORT unsigned char getZeichenAnzahl() const;
        //! Gibt einen Array mit den Positionen der ersten Bytes von den gespeicherten Zeichen aus der LTDS Datei zurück 
        DLLEXPORT int *getPositionen() const;
        //! Gibt einen Array mit den ASCII codes der Gespeicherten Zeichen zurück
        DLLEXPORT unsigned char *getZeichen() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSSchriftKopf *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSSchriftKopf *release();
    };

    //! Der Kopf eines einzelnen Zeichens aus der LTDS Datei. Enthält informationen über die Pixelgröße des Zeichens
    class LTDSBuchstabenKopf
    {
    private:
        int ref;
        unsigned char zeichen;
        Punkt size;

    public:
        //! Konstruktor 
        DLLEXPORT LTDSBuchstabenKopf();
        //! Lädt die Daten aus der LTDS Datei
        //! \param inF Der geöffnete und an die richtiege Stelle zeigende ifstream der LTDS Datei
        DLLEXPORT void laden( std::ifstream *inF );
        //! Setzt die Daten, die gespeichert werden sollen.
        //! \param zeichen Der ASCII code des Zeichens
        //! \param größe Die Größe des Zeichens in Pixeln
        DLLEXPORT void init( unsigned char zeichen, const Punkt &größe );
        //! Setzt die Daten, die gespeichert werden sollen.
        //! \param zeichen Der ASCII code des Zeichens
        //! \param br Die Breite des Zeichens in Pixeln
        //! \param hö Die Höhe des Zeichens in Pixeln
        DLLEXPORT void init( unsigned char zeichen, int br, int hö );
        //! Speichert die Daten in der LTDS Datei
        //! \param outF Der geöffnete und auf die richtiege Stelle zeigende ofstream der LTDS Datei
        DLLEXPORT void speichern( std::ofstream *outF ) const;
        //! Gibt den ASCII code des Zeichens zurück
        DLLEXPORT unsigned char getZeichen() const;
        //! Gibt die Breite des Zeichens in Pixeln zurück
        DLLEXPORT int getBreite() const;
        //! Gibt die Höhe des Zeichens in Pixeln zurück
        DLLEXPORT int getHöhe() const;
        //! Gib t die Größe des Zeichens in Pixeln zurück
        DLLEXPORT const Punkt &getGröße() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSBuchstabenKopf *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSBuchstabenKopf *release();
    };

    //! Verwaltet die Pixeldaten eines Zeichens
    class LTDSBuchstabenKörper
    {
    private:
        int ref;
        Punkt size;
        unsigned char zeichen;
        Buchstabe *buchstabe;

    public:
        //! Konstruktor
        //! \param kopf Der Kopf des Zeichens
        DLLEXPORT LTDSBuchstabenKörper( LTDSBuchstabenKopf *kopf );
        //! Destruktor 
        DLLEXPORT ~LTDSBuchstabenKörper();
        //! Setzt den Buchstaben, der gespeichert werden soll
        //! \param zeichen Der zu speichernde Buchstabe
        DLLEXPORT void setBuchstabe( Buchstabe *zeichen );
        //! Lädt die Pixel aus der LTDS Datei
        //! \param inF Der geöffnete und auf die richtiege Stelle zeigende ifstream der LTDS Datei
        DLLEXPORT void laden( std::ifstream *inF );
        //! Speichert die Pixel in die LTDS Datei
        //! \param outF der geöffnete und an die richtiege Stelle zeigende ofstream der LTDS Datei
        DLLEXPORT void speichern( std::ofstream *outF ) const;
        //! Gibt den geladenen Buchstaben zurück
        DLLEXPORT Buchstabe *getBuchstabe() const;
        //! Gibt den ASCII code des Buchstabens zurück
        DLLEXPORT unsigned char getZeichen() const;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSBuchstabenKörper *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSBuchstabenKörper *release();
    };

    //! Verwaltet eine LTDS Datei
    class LTDSDatei
    {
    private:
        int ref;
        Text *pfad;
        LTDSDateiKopf *dateiKopf;

    public:
        //! Konstruktor 
        DLLEXPORT LTDSDatei();
        //! Destruktor 
        DLLEXPORT ~LTDSDatei();
        //! Setzt den Pfad zur Datei
        //! \param txt Der Pfad
        DLLEXPORT void setPfad( Text *txt );
        //! Lädt wichtiege Informationen aus der Datei. Muss vor dem Verwenden der Datei aufgerufen werden
        DLLEXPORT void leseDaten();
        //! Fügt der Datei eine Schriftgröße hinzu, fals diese noch nicht existiert
        //! \param alphabet Das Alphabet, welches die Zeichen in der gewünschten Schriftgrö0e enthält
        DLLEXPORT void addSchriftgröße( Alphabet *alphabet );
        //! Fügt einer Schriftgröße einen Buchstaben hinzu
        //! \param gr Die Schriftgröße des Buchstabens
        //! \param zeich Der Buchstabe, der gespeichert werden soll
        //! \param zeichen Der ASCII code des Buchstabens
        DLLEXPORT void addBuchstabe( int gr, Buchstabe *zeich, unsigned char zeichen );
        //! Löscht eine bestimmte Schriftgröße aus der Datei
        //! \param gr Die Schriftgröße, die entfernt werden soll
        DLLEXPORT void löscheSchrifrGröße( int gr );
        //! Löscht einen Buchstaben aus einer Schriftgröße
        //! \param gr Die Schriftgröße, aus der der Buchstabe entfernt werden soll
        //! \param zeichen Der ASCII code des Zeichens, welches gelöscht werden soll
        DLLEXPORT void löscheBuchstabe( int gr, unsigned char zeichen );
        //! Löscht die LTDS Datei
        DLLEXPORT void löscheDatei();
        //! Erstellt die LTDS Datei
        DLLEXPORT void erstelleDatei();
        //! Speichert eine gesammte Schrift in der Datei
        //! \param schrift Die schrift, die gespeichert werden soll
        DLLEXPORT void speicherSchrift( Schrift *schrift );
        //! Lädt die gesammte Schrift aus der Datei
        //! \return Die geladene Schrift. 0, falls ein Fehler beim Laden aufgetreten ist
        DLLEXPORT Schrift *ladeSchrift();
        //! Lädt eine einzelne Schriftgröße aus der Datei
        //! \param schriftgröße Die zu ladende Schriftgröße
        //! \return Ein Alphabet mit den Zeichen in der Schriftgröße. 0, falls die Schriftgröße nicht gefunden wurde
        DLLEXPORT Alphabet *ladeAlphabet( int schriftgröße );
        //! Lädt ein bestimmtes Zeichen einer bestimmten Schriftgröße
        //! \param schriftgröße Die Schriftgröße, zu dem das Zeichen gehört
        //! \param zeichen Der ASCII code des zu ladenden Zeichens
        //! \return Der geladene Buchstabe. 0, falls das Zeichen nicht gefunden wurde.
        DLLEXPORT Buchstabe *ladeBuchstabe( int schriftgröße, unsigned char zeichen );
        //! Gibt den Pfad zur LTDS Datei zurück
        DLLEXPORT Text *getPfad() const;
        //! Gibt die Anzahl der gespeicherten Schriftgrößen zurück
        DLLEXPORT int getAnzahlSchriftgrößen() const;
        //! Gibt einen Array mit den gespeicherten Schriftgrößen zurück
        //! Der Array sollte nicht verändert werden
        DLLEXPORT unsigned char *getSchriftGrößen() const;
        //! Gibt die Anzahl an gespeicherten Zeichen in einer Schriftgröße zurück
        //! \param sg Die Schriftgröße, von der die Anzahl der ZEichen ermittelt werden soll
        //! \return Die Anzahl der Zeichen.
        DLLEXPORT unsigned char getAnzahlBuchstaben( int sg );
        //! Gibt einen Array mit Buchstaben einer bestimmten Schriftgröße zurück
        //! \param sg Die Schriftgröße
        //! \return Der Array mit den ASCII codes der Zeichen. 0, falls die Schriftgröße nicht gefunden wurde.
        DLLEXPORT unsigned char *getBuchstaben( int sg );
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT LTDSDatei *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT LTDSDatei *release();
    };
#endif
    //! Bit Funktionen 

    //! gibt 1-bits in gewinschter anzahl zurück.
    //! \param a Die Anzahl der Bits, die 1 sein sollen
    //! \return 32 Bits, wobei die einser Bits von rechts beginnen
    DLLEXPORT int Bits( int a );
    //! Gibt zurück, wie viele Bits benötigt werden um eine Zahl darzustellen
    //! \param c Die Zahl, die dargestellt werden soll
    //! \return Die Anzahl der benötigten Bits
    DLLEXPORT int getBits( char c );
}
#endif