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; //! from this file
    class LTDBKopf;  //! from this file
    class LTDBBody;  //! from this file
    class LTDBDatei; //! from this file
    class LTDSPixel; //! from this file
#ifdef WIN32
    class LTDSDateiKopf;        //! from this file
    class LTDSSchriftKopf;      //! from this file
    class LTDSBuchstabenKopf;   //! from this file
    class LTDSBuchstabenKörper; //! from this file
    class LTDSDatei;            //! from this file
#endif

    //! LTDB File format --- Used for storing multiple images in one file.

    //! Used for storing and loading a single pixel from an image in the
    //! LTDB file format
    class LTDBPixel : public virtual ReferenceCounter //! Pixel of an LTDB file
    {
    private:
        LTDBPixel* davor; //! Previous pixel
        char index;       //! Bit length of the pixel
        char iR, iG, iB, iA;
        char miR, miG, miB, miA;
        char maxIndex;    //! Length of the pixel
        bool change  : 1; //! Whether something changes in the following 5 variables
        bool changeR : 1; //! Whether Red changes
        bool changeG : 1; //! Whether Green changes
        bool changeB : 1; //! Whether Blue changes
        bool changeA : 1; //! Whether Alpha changes
        unsigned char komp : 3; //! Compression of color values
        unsigned char R;        //! Red
        unsigned char G;        //! Green
        unsigned char B;        //! Blue
        unsigned char A;        //! Alpha
        bool addBitZuFarbe(
            unsigned char bit); //! Adds a bit to the color values
        bool getNextFarbeBit(
            char& byte, int i); //! Stores the next color bit in byte

    public:
        //! Constructor
        //! \param davor The pixel that was loaded before. 0 if this is the
        //! first pixel
        DLLEXPORT LTDBPixel(LTDBPixel* davor);
        //! Destructor
        DLLEXPORT ~LTDBPixel();
        //! For loading. Adds some bits to the pixel
        //! \param byte The last byte read from the file
        //! \param begin The index of the first bit in byte where the pixel begins
        //! \return The index of the bit in byte where the pixel ended. -1 if
        //! the pixel is not finished at the end of the byte
        DLLEXPORT char addByte(char byte, char begin);
        //! For saving. Sets the color to be stored in the pixel
        //! \param f The color to store
        DLLEXPORT void setFarbe(int f);
        //! Compresses the pixel. Must be called before saving.
        DLLEXPORT void komprimieren();
        //! Returns a part of the bits that represent the pixel
        //! \param byte A reference to the byte to be saved next
        //! \param begin The index of the first bit in the byte where the pixel
        //! should be stored \return The index of the bit where the pixel ends.
        //! -1 if the pixel must continue in the next byte
        DLLEXPORT char getNextByte(char& byte, int begin);
        //! Returns the color value of the pixel
        DLLEXPORT int zuFarbe() const;
        //! Returns whether the red component changed compared to the previous pixel
        DLLEXPORT bool getChangeR() const;
        //! Returns whether the green component changed compared to the previous pixel
        DLLEXPORT bool getChangeG() const;
        //! Returns whether the blue component changed compared to the previous pixel
        DLLEXPORT bool getChangeB() const;
        //! Returns whether the alpha component changed compared to the previous pixel
        DLLEXPORT bool getChangeA() const;
        //! Returns the compression of the pixel
        DLLEXPORT unsigned char getKomp() const;
        //! Returns the red component of the pixel's color
        DLLEXPORT unsigned char getR() const;
        //! Returns the green component of the pixel's color
        DLLEXPORT unsigned char getG() const;
        //! Returns the blue component of the pixel's color
        DLLEXPORT unsigned char getB() const;
        //! Returns the alpha component of the pixel's color
        DLLEXPORT unsigned char getA() const;
    };

    //! The header of the LTDB file format. Stores information about all
    //! saved images
    class LTDBDateiKopf : public virtual ReferenceCounter
    {
    private:
        RCArray<Text>* bilder;
        Array<__int64>* pos;
        int bAnzahl;

    public:
        //! Constructor
        DLLEXPORT LTDBDateiKopf();
        //! Destructor
        DLLEXPORT ~LTDBDateiKopf();
        //! Removes an image from the file header
        //! \param i The index of the image to remove
        DLLEXPORT void removeBild(int i);
        //! Removes an image from the file header
        //! \param txt The name of the image to remove
        DLLEXPORT void removeBild(Text* txt);
        //! Adds an image to the file header
        //! \param txt The name of the image
        DLLEXPORT void addBild(Text* txt);
        //! Sets the byte index in the file where the image begins
        //! \param i The index of the image
        //! \param pos The position of the image in the file
        DLLEXPORT void setBildPos(int i, __int64 pos);
        //! Sets the byte index in the file where the image begins
        //! \param txt The name of the image
        //! \param pos The position of the image in the file
        DLLEXPORT void setBildPos(Text* txt, __int64 pos);
        //! Loads the file header of an LTDB file
        //! \param f A pointer to a progress bar to use for loading. Can be 0.
        //! \param inF The opened ifstream of the LTDB file with the read
        //! position already pointing to the first byte of the file header.
        DLLEXPORT void laden(FBalken* f, std::ifstream* inF);
        //! Saves the file header to an LTDB file
        //! \param outF The opened ofstream of the LTDB file with the write
        //! position already pointing to the first byte of the file header.
        DLLEXPORT void speichern(std::ofstream* outF) const;
        //! Returns the name of a specific image
        //! \param i The index of the image whose name should be returned
        //! \return The name of the image
        DLLEXPORT Text* getBild(int i) const;
        //! Returns the name of a specific image
        //! \param i The index of the image whose name should be returned
        //! \return The name of the image without increased reference counter
        DLLEXPORT Text* zBild(int i) const;
        //! Returns the index of the first byte of an image in the file
        //! \param txt The name of the image whose start should be found
        //! \return -1 if the image was not found.
        DLLEXPORT __int64 getBildPosition(Text* txt) const;
        //! Returns the index of the first byte of an image in the file.
        //! If the index does not exist, std::out_of_range is thrown.
        //! \param index The index of the image whose start should be found
        DLLEXPORT __int64 getBildPosition(int index) const;
        //! Returns the index of a specific image
        //! \param txt The name of the image
        //! \return -1 if the image was not found
        DLLEXPORT int getBildIndex(Text* txt) const;
        //! Returns the number of images in the file
        DLLEXPORT int getbAnzahl() const;
        //! Returns a list of images in the file without increased reference
        //! counter. The list should not be modified
        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