DateiSystem.h 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623
  1. #ifndef DateiSystem_H
  2. #define DateiSystem_H
  3. #include <fstream>
  4. #include "Array.h"
  5. #include "Punkt.h"
  6. namespace Framework
  7. {
  8. class Bild; //! Bild.h
  9. class Text; //! Text.h
  10. class FBalken; //! Fortschritt.h
  11. #ifdef WIN32
  12. class Buchstabe; //! Schrift.h
  13. class Alphabet; //! Schrift.h
  14. class Schrift; //! Schrift.h
  15. #endif
  16. class LTDBPixel; //! aus dieser Datei
  17. class LTDBKopf; //! aus dieser Datei
  18. class LTDBBody; //! aus dieser Datei
  19. class LTDBDatei; //! aus dieser Datei
  20. class LTDSPixel; //! aus dieser Datei
  21. #ifdef WIN32
  22. class LTDSDateiKopf; //! aus dieser Datei
  23. class LTDSSchriftKopf; //! aus dieser Datei
  24. class LTDSBuchstabenKopf; //! aus dieser Datei
  25. class LTDSBuchstabenKörper; //! aus dieser Datei
  26. class LTDSDatei; //! aus dieser Datei
  27. #endif
  28. //! LTDB Dateivormat --- Dient zum speichern von mehreren Bildern in einer
  29. //! Datei.
  30. //! Dient zum Speichern und Laden eines einzelnen Pixels aus einem Bild im
  31. //! LTDB Dateiformat
  32. class LTDBPixel : public virtual ReferenceCounter //! Pixel einer LTDB Datei
  33. {
  34. private:
  35. LTDBPixel* davor; //! Letzter Pixel
  36. char index; //! Bitlänge des Pixels
  37. char iR, iG, iB, iA;
  38. char miR, miG, miB, miA;
  39. char maxIndex; //! Länge des Pixels
  40. bool change : 1; //! Verändert sich etwas an den volgenden 5 Variablen
  41. bool changeR : 1; //! Ändert sich Rot
  42. bool changeG : 1; //! Ändert sich Grün
  43. bool changeB : 1; //! Ändert sich Blau
  44. bool changeA : 1; //! Ändert sich Alpha
  45. unsigned char komp : 3; //! Komprimierung der Farbwerte
  46. unsigned char R; //! Rot
  47. unsigned char G; //! Grün
  48. unsigned char B; //! Blau
  49. unsigned char A; //! Alpha
  50. bool addBitZuFarbe(
  51. unsigned char bit); //! Fügt den Farbwerten ein Bit hinzu
  52. bool getNextFarbeBit(
  53. char& byte, int i); //! Speichert das nächste Farbbit in byte
  54. public:
  55. //! Konstruktor
  56. //! \param davor Der Pixel, der Vorher geladen wurde. 0, falls dieß der
  57. //! Erste Pixel ist
  58. DLLEXPORT LTDBPixel(LTDBPixel* davor);
  59. //! Destruktor
  60. DLLEXPORT ~LTDBPixel();
  61. //! zum Laden gedacht. Fügt dem Pixel einiege bits hinzu
  62. //! \param byte Das zuletzt aus der Datei gelesene Byte
  63. //! \param begin Der Index des ersten Bits im byte, wo der Pixel beginnt
  64. //! \return Der Index des Bits im Byte, wo der Pixel aufgehöhrt hat. -1,
  65. //! falls der Pixel am ende Des Bytes noch nicht zuende ist
  66. DLLEXPORT char addByte(char byte, char begin);
  67. //! zum speichern gedacht. Setzt die Farbe, die im Pixel gespeichert
  68. //! werden soll \param f Die zu speichernde Farbe
  69. DLLEXPORT void setFarbe(int f);
  70. //! Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
  71. DLLEXPORT void komprimieren();
  72. //! Gibt ein Teil der Bits zurück, die den Pixel representieren
  73. //! \param byte Eine Referens auf das Byte, dass als nächstes
  74. //! gespeichert werden soll \param begin Der Index des ersten Bits im zu
  75. //! speichernden Byte, wo der Pixel gespeichert werden soll \return Der
  76. //! Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1,
  77. //! falls der Pixel im nächsten Byte fortgesetzt werden muss
  78. DLLEXPORT char getNextByte(char& byte, int begin);
  79. //! Gibt den Farbwert des Pixels zurück
  80. DLLEXPORT int zuFarbe() const;
  81. //! Gibt zurück, ob sich der Anteil an Rot in der Farbe im Vergleich zum
  82. //! Pixel davor geändert hat
  83. DLLEXPORT bool getChangeR() const;
  84. //! Gibt zurück, ob sich der Anteil an Grün in der Farbe im Vergleich
  85. //! zum Pixel davor geändert hat
  86. DLLEXPORT bool getChangeG() const;
  87. //! Gibt zurück, ob sich der Anteil an Blau in der Farbe im Vergleich
  88. //! zum Pixel davor geändert hat
  89. DLLEXPORT bool getChangeB() const;
  90. //! Gibt zurück, ob sich der Anteil an Alpha in der Farbe im Vergleich
  91. //! zum Pixel davor geändert hat
  92. DLLEXPORT bool getChangeA() const;
  93. //! Gibt die Komprimierung des Pixels zurück
  94. DLLEXPORT unsigned char getKomp() const;
  95. //! Gibt den Anteil an Rot in der Farbe des Pixels zurück
  96. DLLEXPORT unsigned char getR() const;
  97. //! Gibt den Anteil an Grün in der Farbe des Pixels zurück
  98. DLLEXPORT unsigned char getG() const;
  99. //! Gibt den Anteil an Blau in der Farbe des Pixels zurück
  100. DLLEXPORT unsigned char getB() const;
  101. //! Gibt den Anteil an Alpha in der Farbe des Pixels zurück
  102. DLLEXPORT unsigned char getA() const;
  103. };
  104. //! Der Kopf des LTDB Dateiformates. Hier werden informationen über alle
  105. //! Abgespeicherten Bilder verwaltet
  106. class LTDBDateiKopf : public virtual ReferenceCounter
  107. {
  108. private:
  109. RCArray<Text>* bilder;
  110. Array<__int64>* pos;
  111. int bAnzahl;
  112. public:
  113. //! konstructor
  114. DLLEXPORT LTDBDateiKopf();
  115. //! destructor
  116. DLLEXPORT ~LTDBDateiKopf();
  117. //! Entfernt ein Bild aus dem Dateikopf
  118. //! \param i Der Index des Bildes, welches entfernt werden soll
  119. DLLEXPORT void removeBild(int i);
  120. //! Entfernt ein Bild aus dem Dateikopf
  121. //! \param txt Der Name des Bildes, welches entfernt werden soll
  122. DLLEXPORT void removeBild(Text* txt);
  123. //! Fügt dem Dateikopf ein Bild hinzu
  124. //! \param txt Der Name des Bildes.
  125. DLLEXPORT void addBild(Text* txt);
  126. //! Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
  127. //! \param i Der index Des Bildes
  128. //! \param pos Die Position des Bildes in der Datei
  129. DLLEXPORT void setBildPos(int i, __int64 pos);
  130. //! Legt den Index des Bytes aus der Datei fest, wo das Bild anfängt
  131. //! \param txt Der Name Des Bildes
  132. //! \param pos Die Position des Bildes in der Datei
  133. DLLEXPORT void setBildPos(Text* txt, __int64 pos);
  134. //! Lädt den Dateikopf einer LTDB Datei
  135. //! \param f Ein Zeiger auf einen Fortschrittsbalken, der zum Laden
  136. //! verwendet werden soll. Kann 0 sein. \param inF Der geöffnete
  137. //! ifstream der LTDB Datei, bei dem die Leseposition bereits auf das
  138. //! erste Byte des Dateiopfes zeigt.
  139. DLLEXPORT void laden(FBalken* f, std::ifstream* inF);
  140. //! Speichert den Dateikopf in einer LTDB Datei
  141. //! \param outF Der geöffnete ofstream der LTDB Datei, bei dem die
  142. //! Schreibposition bereits auf das erste Byte des Dateikopfes zeigt.
  143. DLLEXPORT void speichern(std::ofstream* outF) const;
  144. //! Gibt den Namen eines bestimmten Bildes zurück
  145. //! \param i Der Index des Bildes, dessen Namen zurückgegeben werden
  146. //! soll \return Der Name des bildes
  147. DLLEXPORT Text* getBild(int i) const;
  148. //! Gibt den Namen eines bestimmten Bildes zurück
  149. //! \param i Der Index des Bildes, dessen Namen zurückgegeben werden
  150. //! soll \return Der Name des bildes ohne erhöhten Reference Counter
  151. DLLEXPORT Text* zBild(int i) const;
  152. //! Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
  153. //! \param txt Der Name des Bildes, dessen Beginn gefunden werden soll
  154. //! \return -1, falls das Bild nicht gefunden wurde.
  155. DLLEXPORT __int64 getBildPosition(Text* txt) const;
  156. //! Gibt den Index des Ersten Bytes eines Bildes in der Datei zurück
  157. //! Fals der Index nicht existiert wird die Exception std::out_of_range
  158. //! geworfen. \param indes Der Indes des Bildes, dessen Beginn gefunden
  159. //! werden soll
  160. DLLEXPORT __int64 getBildPosition(int index) const;
  161. //! Gibt den Index eines Bestimmten Bildes zurück
  162. //! \param txt Der Name des Bildes
  163. //! \return -1, falls das Bild nicht gefunden wurde
  164. DLLEXPORT int getBildIndex(Text* txt) const;
  165. //! Gibt die Anzahl der Bilder in der Datei zurück
  166. DLLEXPORT int getbAnzahl() const;
  167. //! Gibt eine Liste mit Bildern in der Datei ohne erhöhten Reference
  168. //! Counter zurück. Die Liste sollte nicht verändert werden
  169. DLLEXPORT RCArray<Text>* zBildListe() const;
  170. };
  171. //! Die im LTDB Dateikopf gespeicherten Informationen für ein einzelnes Bild
  172. class LTDBKopf : public virtual ReferenceCounter
  173. {
  174. private:
  175. __int64 a; //! Det LTDB Dateikopf ist maximal 104 Bits lang
  176. __int32 b; //! - bis zu 75 Bits für den Titel
  177. __int8 c; //! - 12 Bits für breite
  178. public:
  179. //! Konstruktor
  180. DLLEXPORT LTDBKopf();
  181. //! Lähdt die Informationen über ein Bild
  182. //! \param f Der geöffnette und an die richtiege Stelle zeigende
  183. //! ifstream der LTDB Datei
  184. DLLEXPORT void laden(std::ifstream* f);
  185. //! Setzt die Informationen die gespeichert werden sollen
  186. //! \param titel Der Titel des Bildes
  187. //! \param size Die Größe des Bildes
  188. //! \return Die Anzahl der Buchstaben aus dem Titel, die im LTDB
  189. //! Dateiformat nicht gespeichert werden können. Erlaubt ist nur a-z und
  190. //! A-Z und ä ü ö ß und Ä Ü Ö und . Alle großbuchstaben im Titel werden
  191. //! in Kleinbuchstaben umgewandelt
  192. DLLEXPORT int Init(Text* titel, const Punkt& size);
  193. //! Lähd informationen aus geladenen Bits. Wird von der laden(
  194. //! std::ifstream ) Funktion verwendet. \param BeginBit Der Index des
  195. //! ersten Bits, welches ausgewertet werden soll \param EndBit Der Index
  196. //! des letzten Bits, welches nichtmehr ausgewertet werden soll \param
  197. //! bits Die Bits, von denen alle von BeginBit bis EndBit ausgewertet
  198. //! werden sollen Insgesamt müssen 104 Bits gesetzt werden. Hierauf
  199. //! bezihen sich BeginBit und EndBit
  200. DLLEXPORT void setBits(int BeginBit, int EndBit, __int16 bits);
  201. //! Speichert die Informationen in eine Datei
  202. //! \param f Der geöffnete und an die richtiege Stelle zeigende ofstream
  203. //! der LTDB Datei
  204. DLLEXPORT void speichern(std::ofstream* f) const;
  205. //! Gibt die Länge des Titels zurück
  206. DLLEXPORT int getTitelLength() const;
  207. //! Gibt den Titel des Bildes zurück
  208. DLLEXPORT Text* getTitel() const;
  209. //! Gibt die Größe des Bildes zurück
  210. DLLEXPORT Punkt getSize() const;
  211. //! Gibt die nächsten zu speichernden Bits zurück
  212. //! \param begin Der Index des ersten Bits, in das gespeichert werden
  213. //! soll \param end Der Index des letzten Bits, in das gespeichert
  214. //! werden soll \return 16 Bits, in denen die Informationen zwischen
  215. //! begin und end stehen Insgesamt müssen 104 Bits gelesen werden.
  216. //! Hierauf bezihen sich BeginBit und EndBit
  217. DLLEXPORT __int16 getBits(int begin, int end) const;
  218. };
  219. //! Verwaltet die Pixeldaten eines einzelnen Bildes einer LTDB Datei
  220. class LTDBBody : public virtual ReferenceCounter
  221. {
  222. private:
  223. Punkt gr;
  224. Bild* b;
  225. int dateiSize;
  226. public:
  227. //! Konstruktor
  228. DLLEXPORT LTDBBody();
  229. //! Konstruktor
  230. //! \param k Der LTDB Kopf des Bildes, der Informationen über die Größe
  231. //! des Bildes enthält
  232. DLLEXPORT LTDBBody(LTDBKopf* k);
  233. //! Destruktor
  234. DLLEXPORT ~LTDBBody();
  235. //! Setzt die Informationen über die Größe des Bildes. Wird zum Laden
  236. //! benötigt. \param k Der LTDB Kopf des Bildes
  237. DLLEXPORT void init(LTDBKopf k);
  238. //! Setzt die Informationen über die Größe des Bildes. Wird zum Laden
  239. //! benötigt. \param k Der LTDB Kopf des Bildes
  240. DLLEXPORT void init(LTDBKopf* k);
  241. //! Lädt die Pixeldaten aus der Datei
  242. //! \param zF Ein Fortschrittsbalken, der 0 sein kann
  243. //! \param inF Der geöffnete und an die richtiege Stelle zeigende
  244. //! ifstream der LTDB Datei
  245. DLLEXPORT void laden(FBalken* zF, std::ifstream* inF);
  246. //! Setzt das Bild, welches gespeichert werden soll
  247. //! \param b Das zu speichernde Bild
  248. DLLEXPORT void setBild(Bild* b);
  249. //! Speichert die Pixeldaten des Bildes in einer LTDB Datei
  250. //! \param zF Ein Fortschrittsbalken, der 0 sein kann
  251. //! \param outF Der geöffnete und an die richtiege Stelle zeigende
  252. //! ofstream der LTDB Datei
  253. DLLEXPORT void speichern(FBalken* zF, std::ofstream* outF) const;
  254. //! Gibt das geladene Bild zurück
  255. DLLEXPORT Bild* getBild() const;
  256. //! Gibt die Größe des Bildes zurück
  257. DLLEXPORT const Punkt& getSize() const;
  258. };
  259. //! Verwaltet eine LTDB Datei
  260. class LTDBDatei : public virtual ReferenceCounter
  261. {
  262. private:
  263. Text* pfad;
  264. LTDBDateiKopf* datKpf;
  265. public:
  266. //! Konstruktor
  267. DLLEXPORT LTDBDatei();
  268. //! Destruktor
  269. DLLEXPORT ~LTDBDatei();
  270. //! Setzt den Pfad zu Datei
  271. //! \param pfad Der Pfad
  272. DLLEXPORT void setDatei(Text* pfad);
  273. //! Erstellt eine neue LTDB Datei
  274. DLLEXPORT void erstellen();
  275. //! Ließt grundlegende Informationen aus der Datei.
  276. //! Wird benötigt, bevor mit der Datei gearbeitet wird
  277. //! \param zF Ein Fortschrittsbalken, der 0 sein kann
  278. DLLEXPORT void leseDaten(FBalken* zF);
  279. //! Löscht die LTDB Datei
  280. DLLEXPORT void remove();
  281. //! Löscht ein Bild aus der LTDB Datei
  282. //! \param zF Ein Fortschrittsbalken der 0 sein kann
  283. //! \param name Der Name des zu löschenden Bildes
  284. DLLEXPORT void remove(FBalken* zF, Text* name);
  285. //! Lädt ein Bild aus der LTDB Datei
  286. //! \param zF Ein Fortschrittsbalken, der 0 sein kann
  287. //! \param name Der Name des Bildes, welches geladen werden soll
  288. //! \return Das geladene Bild. 0, falls das Bild nicht gefunden wurde
  289. DLLEXPORT Bild* laden(FBalken* zF, Text* name);
  290. //! Speichert ein neues Bild in der LTDB Datei
  291. //! \param zF Ein Fortscrittsbalken, der 0 sein kann
  292. //! \param bild Das Bild, welches gelöscht werden soll
  293. //! \param name Der Name, unter dem das Bild gespeichert werden soll
  294. //! \return Anzahl der Warnungen, die beim Konvertieren des Namens in
  295. //! einen gültigen Namen aufgetreten sind. -1, falls bereis ein Bild mit
  296. //! dem selben Namen existiert
  297. DLLEXPORT int speichern(FBalken* zF, Bild* bild, Text* name);
  298. //! Gibt eine Liste mit gespeicherten Bildern zurück
  299. //! Die Liste sollte nicht verändert werden
  300. DLLEXPORT RCArray<Text>* zBildListe();
  301. //! Gibt den Pfad zur LTDB Datei zurück
  302. DLLEXPORT Text* getPfad() const;
  303. //! Gibt die Anzahl der Bilder in der LTDB Datei zurück
  304. DLLEXPORT int getBildAnzahl() const;
  305. //! Prüft, ob die LTDB Datei existiert
  306. DLLEXPORT bool istOffen() const;
  307. };
  308. #ifdef WIN32
  309. //! LTDS Dateivormat --- Dient zum speichern von Schriftarten
  310. //! Verwaltet einen einzelnen Pixel von einem Buchstaben
  311. class LTDSPixel : public virtual ReferenceCounter
  312. {
  313. private:
  314. char index;
  315. char iA;
  316. char miA;
  317. char maxIndex; //! Länge des Pixels
  318. bool änder;
  319. bool änderA;
  320. unsigned char komp : 3; //! Komprimierung der Farbwerte
  321. unsigned char alpha;
  322. LTDSPixel* davor;
  323. bool addBitZuFarbe(
  324. unsigned char bit); //! Fügt den Farbwerten ein Bit hinzu
  325. bool getNextFarbeBit(
  326. char& byte, int i); //! Speichert das nächste Farbbit in byte
  327. public:
  328. //! Konstruktor
  329. //! \param davor Der Pixel, der vor diesem geladen wurde. 0, fals dieß
  330. //! der erste Pixel ist
  331. DLLEXPORT LTDSPixel(LTDSPixel* davor);
  332. //! Destruktor
  333. DLLEXPORT ~LTDSPixel();
  334. //! Fügt dem Pixel einiege geladene Bits hinzu. Zum Laden gedacht.
  335. //! \param byte Das letzte aus der Datei geladene Byte.
  336. //! \param begin Der Index des ersten Bits im Byte, wo der Pixel beginnt
  337. //! \return Der Index des Letzten Bits in Byte, wo der Pixel aufhöhrt.
  338. //! -1, falls der Pixel im nächsten Byte weitergeht
  339. DLLEXPORT char addByte(char byte, char begin);
  340. //! Setzt den Alpha Wert des Pixels. Zum speichern gedacht.
  341. //! \param alpha Der Alpha Wert des Pixels.
  342. DLLEXPORT void setAlpha(unsigned char alpha);
  343. //! Komprimiert den Pixel. Muss vor dem Speichern aufgerufen werden.
  344. DLLEXPORT void Komp();
  345. //! Gibt ein Teil der Bits zurück, die den Pixel representieren
  346. //! \param byte Eine Referens auf das Byte, dass als nächstes
  347. //! gespeichert werden soll \param begin Der Index des ersten Bits im zu
  348. //! speichernden Byte, wo der Pixel gespeichert werden soll \return Der
  349. //! Index des Bits im zu speichernden Byte, wo der Pixel aufhöhrt. -1,
  350. //! falls der Pixel im nächsten Byte fortgesetzt werden muss
  351. DLLEXPORT char getNextByte(char& byte, int bbegin);
  352. //! Gibt die Komprimierung des Pixels zurück
  353. DLLEXPORT unsigned char getKomp() const;
  354. //! Gibt zurück, ob sich der Alpha Wert im Vergleich zu dem Pixel davor
  355. //! geändert hat
  356. DLLEXPORT bool getÄnderA() const;
  357. //! Gibt den Alpha Wert des Pixels zurück
  358. DLLEXPORT unsigned char getA() const;
  359. };
  360. //! Verwaltet den Kopf einer LTDS Datei. Er enthält Informationen über die
  361. //! in der Datei gespeicherten Schriftgrößen
  362. class LTDSDateiKopf : public virtual ReferenceCounter
  363. {
  364. private:
  365. unsigned char sganzahl;
  366. unsigned char* gr;
  367. int* pos;
  368. public:
  369. //! Konstruktor
  370. DLLEXPORT LTDSDateiKopf();
  371. //! Destruktor
  372. DLLEXPORT ~LTDSDateiKopf();
  373. //! Lädt den Kopf aus der LTDS Datei
  374. //! \param inF Der geöffnete und an die richtige Stelle zeigende
  375. //! ifstream der LTDS Datei
  376. DLLEXPORT void laden(std::ifstream* inF);
  377. //! Fügt eine Schriftgröße hinzu
  378. //! \param sg Die Schriftgröße, die hinzugefügt werden soll
  379. DLLEXPORT void addSG(char sg);
  380. //! Löscht eine Schriftgröße
  381. //! \param sg Die Schriftgröße, die gelöscht werden soll
  382. DLLEXPORT void removeSG(char sg);
  383. //! Speichert den LTDS Kopf in der Datei
  384. //! \param outF Der geöffnete und an die richtiege Stelle zeigende
  385. //! ofstream der LTDS Datei
  386. DLLEXPORT void speichern(std::ofstream* outF) const;
  387. //! Gibt einen Array von gespeicherten Schriftgrößen zurück
  388. //! Der Array sollte nicht verädert werden
  389. DLLEXPORT unsigned char* getSchriftGrößeList() const;
  390. //! Gibt einen Array mit positionen der ersten Bytes für jede
  391. //! Schriftgröße aus der Datei zurück
  392. DLLEXPORT int* getPositionList() const;
  393. //! Gibt die Anzahl der gespeicherten Schriftgrößen zurück
  394. DLLEXPORT int getSchriftGrößeAnzahl() const;
  395. };
  396. //! Der Kopf einer Schriftgröße. Enthält Informationen über die
  397. //! gespeicherten Zeichen
  398. class LTDSSchriftKopf : public virtual ReferenceCounter
  399. {
  400. private:
  401. unsigned char schriftSize;
  402. unsigned char* zeichen;
  403. int* pos;
  404. unsigned char zeichenAnzahl;
  405. public:
  406. //! Konstruktor
  407. DLLEXPORT LTDSSchriftKopf();
  408. //! Destruktor
  409. DLLEXPORT ~LTDSSchriftKopf();
  410. //! Lädt den Kopf einer Schriftgröße aus der Datei
  411. //! \param inF Der geöffnete und an de richtiege Stelle zeigende
  412. //! ifstream der LTDS Datei
  413. DLLEXPORT void laden(std::ifstream* inF);
  414. //! Setzt die Schriftgröße. Zum speichern gedacht
  415. //! \param gr Die Schriftgröße
  416. DLLEXPORT void setSchriftgröße(unsigned char gr);
  417. //! Setzt das Alphabet, welches in der Schriftgröße gespeichert werden
  418. //! soll \param alphabet Das Alphabet, welches alle zu speichernden
  419. //! Zeichen in der Schriftgröße enthält
  420. DLLEXPORT void setZeichenAlphabet(Alphabet* alphabet);
  421. //! Fügt der Schriftgröße ein Zeichen hinzu, welches gespeichert werden
  422. //! soll \param zeichen Der ASCII code des Zeichens, welches hinzugefügt
  423. //! werden soll
  424. DLLEXPORT void addZeichen(unsigned char zeichen);
  425. //! Löscht ein Zeichen aus der Schriftgröße
  426. //! \param zeich Der ASCII code des Zeichens, welches gelöscht werden
  427. //! soll
  428. DLLEXPORT void removeZeichen(unsigned char zeich);
  429. //! Speichert den Kopf der Schriftgröße in der LTDS Datei
  430. //! \param outF Der geöffnete und an die richtiege Stelle zeigende
  431. //! ofstream der LTDS Datei
  432. DLLEXPORT void speichern(std::ofstream* outF) const;
  433. //! Gibt die Schriftgröße zurück, zu der dieser Kopf gehöhrt
  434. DLLEXPORT unsigned char getSchriftGröße() const;
  435. //! Gibt die Anzahl der in der Schriftgröße gespeicherten Zeichen zurück
  436. DLLEXPORT unsigned char getZeichenAnzahl() const;
  437. //! Gibt einen Array mit den Positionen der ersten Bytes von den
  438. //! gespeicherten Zeichen aus der LTDS Datei zurück
  439. DLLEXPORT int* getPositionen() const;
  440. //! Gibt einen Array mit den ASCII codes der Gespeicherten Zeichen
  441. //! zurück
  442. DLLEXPORT unsigned char* getZeichen() const;
  443. };
  444. //! Der Kopf eines einzelnen Zeichens aus der LTDS Datei. Enthält
  445. //! informationen über die Pixelgröße des Zeichens
  446. class LTDSBuchstabenKopf : public virtual ReferenceCounter
  447. {
  448. private:
  449. unsigned char zeichen;
  450. Punkt size;
  451. public:
  452. //! Konstruktor
  453. DLLEXPORT LTDSBuchstabenKopf();
  454. //! Lädt die Daten aus der LTDS Datei
  455. //! \param inF Der geöffnete und an die richtiege Stelle zeigende
  456. //! ifstream der LTDS Datei
  457. DLLEXPORT void laden(std::ifstream* inF);
  458. //! Setzt die Daten, die gespeichert werden sollen.
  459. //! \param zeichen Der ASCII code des Zeichens
  460. //! \param größe Die Größe des Zeichens in Pixeln
  461. DLLEXPORT void init(unsigned char zeichen, const Punkt& größe);
  462. //! Setzt die Daten, die gespeichert werden sollen.
  463. //! \param zeichen Der ASCII code des Zeichens
  464. //! \param br Die Breite des Zeichens in Pixeln
  465. //! \param hö Die Höhe des Zeichens in Pixeln
  466. DLLEXPORT void init(unsigned char zeichen, int br, int hö );
  467. //! Speichert die Daten in der LTDS Datei
  468. //! \param outF Der geöffnete und auf die richtiege Stelle zeigende
  469. //! ofstream der LTDS Datei
  470. DLLEXPORT void speichern(std::ofstream* outF) const;
  471. //! Gibt den ASCII code des Zeichens zurück
  472. DLLEXPORT unsigned char getZeichen() const;
  473. //! Gibt die Breite des Zeichens in Pixeln zurück
  474. DLLEXPORT int getBreite() const;
  475. //! Gibt die Höhe des Zeichens in Pixeln zurück
  476. DLLEXPORT int getHöhe() const;
  477. //! Gib t die Größe des Zeichens in Pixeln zurück
  478. DLLEXPORT const Punkt& getGröße() const;
  479. };
  480. //! Verwaltet die Pixeldaten eines Zeichens
  481. class LTDSBuchstabenKörper : public virtual ReferenceCounter
  482. {
  483. private:
  484. Punkt size;
  485. unsigned char zeichen;
  486. Buchstabe* buchstabe;
  487. public:
  488. //! Konstruktor
  489. //! \param kopf Der Kopf des Zeichens
  490. DLLEXPORT LTDSBuchstabenKörper(LTDSBuchstabenKopf * kopf);
  491. //! Destruktor
  492. DLLEXPORT ~LTDSBuchstabenKörper();
  493. //! Setzt den Buchstaben, der gespeichert werden soll
  494. //! \param zeichen Der zu speichernde Buchstabe
  495. DLLEXPORT void setBuchstabe(Buchstabe * zeichen);
  496. //! Lädt die Pixel aus der LTDS Datei
  497. //! \param inF Der geöffnete und auf die richtiege Stelle zeigende
  498. //! ifstream der LTDS Datei
  499. DLLEXPORT void laden(std::ifstream * inF);
  500. //! Speichert die Pixel in die LTDS Datei
  501. //! \param outF der geöffnete und an die richtiege Stelle zeigende
  502. //! ofstream der LTDS Datei
  503. DLLEXPORT void speichern(std::ofstream * outF) const;
  504. //! Gibt den geladenen Buchstaben zurück
  505. DLLEXPORT Buchstabe* getBuchstabe() const;
  506. //! Gibt den ASCII code des Buchstabens zurück
  507. DLLEXPORT unsigned char getZeichen() const;
  508. };
  509. //! Verwaltet eine LTDS Datei
  510. class LTDSDatei : public virtual ReferenceCounter
  511. {
  512. private:
  513. Text* pfad;
  514. LTDSDateiKopf* dateiKopf;
  515. public:
  516. //! Konstruktor
  517. DLLEXPORT LTDSDatei();
  518. //! Destruktor
  519. DLLEXPORT ~LTDSDatei();
  520. //! Setzt den Pfad zur Datei
  521. //! \param txt Der Pfad
  522. DLLEXPORT void setPfad(Text* txt);
  523. //! Lädt wichtiege Informationen aus der Datei. Muss vor dem Verwenden
  524. //! der Datei aufgerufen werden
  525. DLLEXPORT void leseDaten();
  526. //! Fügt der Datei eine Schriftgröße hinzu, fals diese noch nicht
  527. //! existiert \param alphabet Das Alphabet, welches die Zeichen in der
  528. //! gewünschten Schriftgrö0e enthält
  529. DLLEXPORT void addSchriftgröße(Alphabet* alphabet);
  530. //! Fügt einer Schriftgröße einen Buchstaben hinzu
  531. //! \param gr Die Schriftgröße des Buchstabens
  532. //! \param zeich Der Buchstabe, der gespeichert werden soll
  533. //! \param zeichen Der ASCII code des Buchstabens
  534. DLLEXPORT void addBuchstabe(
  535. int gr, Buchstabe* zeich, unsigned char zeichen);
  536. //! Löscht eine bestimmte Schriftgröße aus der Datei
  537. //! \param gr Die Schriftgröße, die entfernt werden soll
  538. DLLEXPORT void löscheSchrifrGröße(int gr);
  539. //! Löscht einen Buchstaben aus einer Schriftgröße
  540. //! \param gr Die Schriftgröße, aus der der Buchstabe entfernt werden
  541. //! soll \param zeichen Der ASCII code des Zeichens, welches gelöscht
  542. //! werden soll
  543. DLLEXPORT void löscheBuchstabe(int gr, unsigned char zeichen);
  544. //! Löscht die LTDS Datei
  545. DLLEXPORT void löscheDatei();
  546. //! Erstellt die LTDS Datei
  547. DLLEXPORT void erstelleDatei();
  548. //! Speichert eine gesammte Schrift in der Datei
  549. //! \param schrift Die schrift, die gespeichert werden soll
  550. DLLEXPORT void speicherSchrift(Schrift* schrift);
  551. //! Lädt die gesammte Schrift aus der Datei
  552. //! \return Die geladene Schrift. 0, falls ein Fehler beim Laden
  553. //! aufgetreten ist
  554. DLLEXPORT Schrift* ladeSchrift();
  555. //! Lädt eine einzelne Schriftgröße aus der Datei
  556. //! \param schriftgröße Die zu ladende Schriftgröße
  557. //! \return Ein Alphabet mit den Zeichen in der Schriftgröße. 0, falls
  558. //! die Schriftgröße nicht gefunden wurde
  559. DLLEXPORT Alphabet* ladeAlphabet(int schriftgröße);
  560. //! Lädt ein bestimmtes Zeichen einer bestimmten Schriftgröße
  561. //! \param schriftgröße Die Schriftgröße, zu dem das Zeichen gehört
  562. //! \param zeichen Der ASCII code des zu ladenden Zeichens
  563. //! \return Der geladene Buchstabe. 0, falls das Zeichen nicht gefunden
  564. //! wurde.
  565. DLLEXPORT Buchstabe* ladeBuchstabe(
  566. int schriftgröße, unsigned char zeichen);
  567. //! Gibt den Pfad zur LTDS Datei zurück
  568. DLLEXPORT Text* getPfad() const;
  569. //! Gibt die Anzahl der gespeicherten Schriftgrößen zurück
  570. DLLEXPORT int getAnzahlSchriftgrößen() const;
  571. //! Gibt einen Array mit den gespeicherten Schriftgrößen zurück
  572. //! Der Array sollte nicht verändert werden
  573. DLLEXPORT unsigned char* getSchriftGrößen() const;
  574. //! Gibt die Anzahl an gespeicherten Zeichen in einer Schriftgröße
  575. //! zurück \param sg Die Schriftgröße, von der die Anzahl der ZEichen
  576. //! ermittelt werden soll \return Die Anzahl der Zeichen.
  577. DLLEXPORT unsigned char getAnzahlBuchstaben(int sg);
  578. //! Gibt einen Array mit Buchstaben einer bestimmten Schriftgröße zurück
  579. //! \param sg Die Schriftgröße
  580. //! \return Der Array mit den ASCII codes der Zeichen. 0, falls die
  581. //! Schriftgröße nicht gefunden wurde.
  582. DLLEXPORT unsigned char* getBuchstaben(int sg);
  583. };
  584. #endif
  585. //! Bit Funktionen
  586. //! gibt 1-bits in gewinschter anzahl zurück.
  587. //! \param a Die Anzahl der Bits, die 1 sein sollen
  588. //! \return 32 Bits, wobei die einser Bits von rechts beginnen
  589. DLLEXPORT int Bits(int a);
  590. //! Gibt zurück, wie viele Bits benötigt werden um eine Zahl darzustellen
  591. //! \param c Die Zahl, die dargestellt werden soll
  592. //! \return Die Anzahl der benötigten Bits
  593. DLLEXPORT int getBits(char c);
  594. } // namespace Framework
  595. #endif