KSG-Framework/DateiSystem.h

#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 : public virtual ReferenceCounter //! 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

    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;
    };

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

    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;
    };

    //! Die im LTDB Dateikopf gespeicherten Informationen für ein einzelnes Bild
    class LTDBKopf : public virtual ReferenceCounter
    {
    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

    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;
    };

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

    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;
    };

    //! Verwaltet eine LTDB Datei
    class LTDBDatei : public virtual ReferenceCounter
    {
    private:
        Text* pfad;
        LTDBDateiKopf* datKpf;

    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;
    };

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

    //! Verwaltet einen einzelnen Pixel von einem Buchstaben
    class LTDSPixel : public virtual ReferenceCounter
    {
    private:
        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;
    };

    //! Verwaltet den Kopf einer LTDS Datei. Er enthält Informationen über die
    //! in der Datei gespeicherten Schriftgrößen
    class LTDSDateiKopf : public virtual ReferenceCounter
    {
    private:
        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;
    };

    //! Der Kopf einer Schriftgröße. Enthält Informationen über die
    //! gespeicherten Zeichen
    class LTDSSchriftKopf : public virtual ReferenceCounter
    {
    private:
        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;
    };

    //! Der Kopf eines einzelnen Zeichens aus der LTDS Datei. Enthält
    //! informationen über die Pixelgröße des Zeichens
    class LTDSBuchstabenKopf : public virtual ReferenceCounter
    {
    private:
        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;
    };

    //! Verwaltet die Pixeldaten eines Zeichens
    class LTDSBuchstabenKörper : public virtual ReferenceCounter
    {
    private:
        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;
    };

    //! Verwaltet eine LTDS Datei
    class LTDSDatei : public virtual ReferenceCounter
    {
    private:
        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);
    };
#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);
} // namespace Framework
#endif