|
|
@@ -1,4 +1,4 @@
|
|
|
-//---Include---
|
|
|
+//---Include---
|
|
|
#include "DateiSystem.h"
|
|
|
|
|
|
#include <iostream>
|
|
|
@@ -52,35 +52,35 @@ LTDBPixel::~LTDBPixel()
|
|
|
|
|
|
// nicht constant
|
|
|
bool LTDBPixel::addBitZuFarbe(
|
|
|
- unsigned char bit) // Fügt den Farbwerten ein Bit hinzu
|
|
|
+ unsigned char bit) // Fügt den Farbwerten ein Bit hinzu
|
|
|
{
|
|
|
- if (changeR && iR != miR) // Das Bit gehört zu Rot
|
|
|
+ if (changeR && iR != miR) // Das Bit gehört zu Rot
|
|
|
{
|
|
|
R = (unsigned char)(R | ((bit & 0x1) << (7 - komp - iR)));
|
|
|
++iR;
|
|
|
}
|
|
|
- else if (changeG && iG != miG) // Das Bit gehört zu Grün
|
|
|
+ else if (changeG && iG != miG) // Das Bit gehört zu Grün
|
|
|
{
|
|
|
G = (unsigned char)(G | ((bit & 0x1) << (7 - komp - iG)));
|
|
|
++iG;
|
|
|
}
|
|
|
- else if (changeB && iB != miB) // Das Bit gehört zu Blau
|
|
|
+ else if (changeB && iB != miB) // Das Bit gehört zu Blau
|
|
|
{
|
|
|
B = (unsigned char)(B | ((bit & 0x1) << (7 - komp - iB)));
|
|
|
++iB;
|
|
|
}
|
|
|
- else if (changeA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
+ else if (changeA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
{
|
|
|
A = (unsigned char)(A | ((bit & 0x1) << (7 - komp - iA)));
|
|
|
++iA;
|
|
|
}
|
|
|
- else // Das Bit gehört zum nächsten Pixel
|
|
|
+ else // Das Bit gehört zum nächsten Pixel
|
|
|
return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
char LTDBPixel::addByte(
|
|
|
- char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
|
|
|
+ char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
|
|
|
{
|
|
|
if (begin >= 8 || begin < 0) return -1;
|
|
|
for (int i = begin; i < 8; ++i)
|
|
|
@@ -89,17 +89,17 @@ char LTDBPixel::addByte(
|
|
|
{
|
|
|
case 0:
|
|
|
// Das erste Bit eines Pixels speichert, ob sich an der
|
|
|
- // Komprimierung etwas änderte
|
|
|
+ // Komprimierung etwas änderte
|
|
|
change = (bool)((byte >> (7 - i)) & 0x1);
|
|
|
- if (!change) // Ändert sich nichts an der Komprimierung, so werden
|
|
|
- // die Werte vom vorherigen Pixel übernommen
|
|
|
+ if (!change) // Ändert sich nichts an der Komprimierung, so werden
|
|
|
+ // die Werte vom vorherigen Pixel übernommen
|
|
|
{
|
|
|
- if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
|
|
|
- // nicht von dem davor Übernemen )
|
|
|
+ if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
|
|
|
+ // nicht von dem davor Übernemen )
|
|
|
{
|
|
|
#ifdef WIN32
|
|
|
MessageBox(NULL,
|
|
|
- "Fehler, die Bilddatei ist beschädigt",
|
|
|
+ "Fehler, die Bilddatei ist beschädigt",
|
|
|
"Fehler",
|
|
|
MB_ICONERROR);
|
|
|
#endif
|
|
|
@@ -118,66 +118,66 @@ char LTDBPixel::addByte(
|
|
|
if (!changeA) A = davor->getA();
|
|
|
maxIndex = (char)(maxIndex
|
|
|
+ (changeR + changeG + changeB + changeA)
|
|
|
- * (8 - komp)); // Bestimmung der Länge
|
|
|
+ * (8 - komp)); // Bestimmung der Länge
|
|
|
// des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
|
|
|
// durch komprimierung kanns kleiner sein
|
|
|
}
|
|
|
else
|
|
|
maxIndex = (char)(maxIndex + 7); // Da der Pixel nicht die Werte
|
|
|
- // des vorherigen übernimmt,
|
|
|
- // wird er um 7 Bits größer
|
|
|
+ // des vorherigen übernimmt,
|
|
|
+ // wird er um 7 Bits größer
|
|
|
break;
|
|
|
case 1: // Das zweite Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
changeR = (bool)((byte >> (7 - i)) & 0x1);
|
|
|
else
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
case 2: // Das dritte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
changeG = (bool)((byte >> (7 - i)) & 0x1);
|
|
|
else
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
case 3: // Das vierte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
changeB = (bool)((byte >> (7 - i)) & 0x1);
|
|
|
else
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
- case 4: // Das fünfte Bit eines Pixels speichert entweder die
|
|
|
+ case 4: // Das fünfte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
changeA = (bool)((byte >> (7 - i)) & 0x1);
|
|
|
else
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
case 5: // Das sechste Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
komp = (unsigned char)(komp
|
|
|
| ((unsigned char)((byte >> (7 - i))
|
|
|
& 0x1)
|
|
|
@@ -187,13 +187,13 @@ char LTDBPixel::addByte(
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
case 6: // Das siebte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
komp = (unsigned char)(komp
|
|
|
| ((unsigned char)((byte >> (7 - i))
|
|
|
& 0x1)
|
|
|
@@ -203,13 +203,13 @@ char LTDBPixel::addByte(
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
case 7: // Das achte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
+ if (change) // Das Bit gehört zu den 7 Komprimierungsbits
|
|
|
{
|
|
|
komp = (unsigned char)(komp | ((byte >> (7 - i)) & 0x1)) & 7;
|
|
|
// Das war das letzte Komprimierungsbit
|
|
|
@@ -222,20 +222,20 @@ char LTDBPixel::addByte(
|
|
|
if (!changeA) A = davor->getA();
|
|
|
maxIndex = (char)(maxIndex
|
|
|
+ (changeR + changeG + changeB + changeA)
|
|
|
- * (8 - komp)); // Bitlänge des Pixels
|
|
|
+ * (8 - komp)); // Bitlänge des Pixels
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (!addBitZuFarbe((
|
|
|
unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
}
|
|
|
break;
|
|
|
default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
|
|
|
if (!addBitZuFarbe(
|
|
|
(unsigned char)(byte
|
|
|
- >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
+ >> (7 - i)))) // Das Bit gehört zur Farbe
|
|
|
return (unsigned char)i;
|
|
|
break;
|
|
|
}
|
|
|
@@ -257,9 +257,9 @@ char LTDBPixel::addByte(
|
|
|
}
|
|
|
|
|
|
void LTDBPixel::setFarbe(int f) // setzt die Farbe des Pixels
|
|
|
-{ // Da diese Funktion aufgerufen wird, möchte man die Klasse nun zum speichern
|
|
|
+{ // Da diese Funktion aufgerufen wird, möchte man die Klasse nun zum speichern
|
|
|
// verwenden
|
|
|
- // Werte zurücksetzen, fals mit der Klasse schon geladen oder gespeichert
|
|
|
+ // Werte zurücksetzen, fals mit der Klasse schon geladen oder gespeichert
|
|
|
// wurde
|
|
|
index = 0, maxIndex = 1;
|
|
|
change = 0, changeR = 0, changeG = 0, changeB = 0, changeA = 0, komp = 0;
|
|
|
@@ -298,7 +298,7 @@ void LTDBPixel::komprimieren() // Komprimiert den Pixel
|
|
|
changeG = G != davor->getG();
|
|
|
changeB = B != davor->getB();
|
|
|
changeA = A != davor->getA();
|
|
|
- } // Prüfen ob sich etwas ändert
|
|
|
+ } // Prüfen ob sich etwas ändert
|
|
|
if (!miR && changeR) ++miR;
|
|
|
if (!miG && changeG) ++miG;
|
|
|
if (!miB && changeB) ++miB;
|
|
|
@@ -314,19 +314,19 @@ void LTDBPixel::komprimieren() // Komprimiert den Pixel
|
|
|
if (changeR != davor->getChangeR() || changeG != davor->getChangeG()
|
|
|
|| changeB != davor->getChangeB() || changeA != davor->getChangeA()
|
|
|
|| komp != davor->getKomp())
|
|
|
- { // Es ändert sich etwas
|
|
|
+ { // Es ändert sich etwas
|
|
|
change = 1;
|
|
|
maxIndex = (char)(maxIndex + 7);
|
|
|
}
|
|
|
else
|
|
|
- { // Es ändert sich nichts
|
|
|
+ { // Es ändert sich nichts
|
|
|
change = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool LTDBPixel::getNextFarbeBit(
|
|
|
- char& byte, int i) // Speichert das nächste Farbbit in byte
|
|
|
+ char& byte, int i) // Speichert das nächste Farbbit in byte
|
|
|
{
|
|
|
unsigned char RR = R;
|
|
|
unsigned char GG = G;
|
|
|
@@ -339,22 +339,22 @@ bool LTDBPixel::getNextFarbeBit(
|
|
|
BB = (unsigned char)(BB - davor->getB());
|
|
|
AA = (unsigned char)(AA - davor->getA());
|
|
|
}
|
|
|
- if (changeR && iR != miR) // Das Bit gehört zu Rot
|
|
|
+ if (changeR && iR != miR) // Das Bit gehört zu Rot
|
|
|
{
|
|
|
byte |= (char)(((RR >> (7 - komp - iR)) & 0x1) << (7 - i));
|
|
|
++iR;
|
|
|
}
|
|
|
- else if (changeG && iG != miG) // Das Bit gehört zu Grün
|
|
|
+ else if (changeG && iG != miG) // Das Bit gehört zu Grün
|
|
|
{
|
|
|
byte |= (char)(((GG >> (7 - komp - iG)) & 0x1) << (7 - i));
|
|
|
++iG;
|
|
|
}
|
|
|
- else if (changeB && iB != miB) // Das Bit gehört zu Blau
|
|
|
+ else if (changeB && iB != miB) // Das Bit gehört zu Blau
|
|
|
{
|
|
|
byte |= (char)(((BB >> (7 - komp - iB)) & 0x1) << (7 - i));
|
|
|
++iB;
|
|
|
}
|
|
|
- else if (changeA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
+ else if (changeA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
{
|
|
|
byte |= (char)(((AA >> (7 - komp - iA)) & 0x1) << (7 - i));
|
|
|
++iA;
|
|
|
@@ -365,18 +365,18 @@ bool LTDBPixel::getNextFarbeBit(
|
|
|
}
|
|
|
|
|
|
char LTDBPixel::getNextByte(
|
|
|
- char& byte, int begin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
|
|
|
+ char& byte, int begin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
|
|
|
// nicht zu ende ist
|
|
|
{
|
|
|
// bbegin gibt an wohin in die byte-variable geschrieben werden soll
|
|
|
- // die Funktion gibt das ende des Pixels in der byte-variable zurück
|
|
|
- // -1 heißt, dass der Pixel nicht zu ende ist
|
|
|
+ // die Funktion gibt das ende des Pixels in der byte-variable zurück
|
|
|
+ // -1 heißt, dass der Pixel nicht zu ende ist
|
|
|
for (int i = begin; i < 8; ++i)
|
|
|
{
|
|
|
switch (index)
|
|
|
{
|
|
|
case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
|
|
|
- // Komprimierung ändert
|
|
|
+ // Komprimierung ändert
|
|
|
byte |= (char)(((int)change & 0x1) << (7 - i));
|
|
|
break;
|
|
|
case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
|
|
|
@@ -406,7 +406,7 @@ char LTDBPixel::getNextByte(
|
|
|
if (!getNextFarbeBit(byte, i)) return (char)i;
|
|
|
}
|
|
|
break;
|
|
|
- case 4: // Das fünfte Bit des Pixels speichert entweder schon die Farbe
|
|
|
+ case 4: // Das fünfte Bit des Pixels speichert entweder schon die Farbe
|
|
|
// oder die Komprimierung
|
|
|
if (change) // Komprimierung
|
|
|
byte |= (char)(((int)changeA & 0x1) << (7 - i));
|
|
|
@@ -457,7 +457,7 @@ char LTDBPixel::getNextByte(
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-int LTDBPixel::zuFarbe() const // gibt den Pixel als Farbe zurück
|
|
|
+int LTDBPixel::zuFarbe() const // gibt den Pixel als Farbe zurück
|
|
|
{
|
|
|
return (((int)R << 16) | ((int)G << 8) | (int)B | ((int)A << 24));
|
|
|
}
|
|
|
@@ -487,22 +487,22 @@ unsigned char LTDBPixel::getKomp() const
|
|
|
return komp;
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDBPixel::getR() const // gibt Rot zurück
|
|
|
+unsigned char LTDBPixel::getR() const // gibt Rot zurück
|
|
|
{
|
|
|
return R;
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDBPixel::getG() const // gibt Grün zurück
|
|
|
+unsigned char LTDBPixel::getG() const // gibt Grün zurück
|
|
|
{
|
|
|
return G;
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDBPixel::getB() const // gibt Blau zurück
|
|
|
+unsigned char LTDBPixel::getB() const // gibt Blau zurück
|
|
|
{
|
|
|
return B;
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDBPixel::getA() const // gibt Alpha zurück
|
|
|
+unsigned char LTDBPixel::getA() const // gibt Alpha zurück
|
|
|
{
|
|
|
return A;
|
|
|
}
|
|
|
@@ -606,7 +606,7 @@ void LTDBDateiKopf::laden(FBalken* f, std::ifstream* inF)
|
|
|
Punkt gr = kpf->getSize();
|
|
|
kpf->release();
|
|
|
char p[5];
|
|
|
- inF->read((char*)p, 5); // andere hälfte der Dateiposition
|
|
|
+ inF->read((char*)p, 5); // andere hälfte der Dateiposition
|
|
|
unsigned __int64 position
|
|
|
= (((__int64)gr.x << 52) & 0xFFF0000000000000)
|
|
|
| (((__int64)gr.y << 40) & 0xFFF0000000000)
|
|
|
@@ -714,7 +714,7 @@ LTDBKopf::LTDBKopf()
|
|
|
{}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDBKopf::laden(std::ifstream* f) // Lät die Daten aus einer Datei
|
|
|
+void LTDBKopf::laden(std::ifstream* f) // Lät die Daten aus einer Datei
|
|
|
{
|
|
|
if (f->is_open())
|
|
|
{
|
|
|
@@ -737,7 +737,7 @@ void LTDBKopf::laden(std::ifstream* f) // L
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-int LTDBKopf::Init(Text* t, const Punkt& g) // Befüllt die Daten
|
|
|
+int LTDBKopf::Init(Text* t, const Punkt& g) // Befüllt die Daten
|
|
|
{
|
|
|
a = 0;
|
|
|
b = 0;
|
|
|
@@ -753,13 +753,13 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Bef
|
|
|
titel[i - skipped] = (char)(titel[i - skipped] - 96);
|
|
|
else if (titel[i - skipped] > 64 && titel[i - skipped] < 91)
|
|
|
titel[i - skipped] = (char)(titel[i - skipped] - 64);
|
|
|
- else if (titel[i - skipped] == 'ü' || titel[i - skipped] == 'Ü')
|
|
|
+ else if (titel[i - skipped] == 'ü' || titel[i - skipped] == 'Ü')
|
|
|
titel[i - skipped] = 27;
|
|
|
- else if (titel[i - skipped] == 'ö' || titel[i - skipped] == 'Ö')
|
|
|
+ else if (titel[i - skipped] == 'ö' || titel[i - skipped] == 'Ö')
|
|
|
titel[i - skipped] = 28;
|
|
|
- else if (titel[i - skipped] == 'ä' || titel[i - skipped] == 'Ä')
|
|
|
+ else if (titel[i - skipped] == 'ä' || titel[i - skipped] == 'Ä')
|
|
|
titel[i - skipped] = 29;
|
|
|
- else if (titel[i - skipped] == 'ß')
|
|
|
+ else if (titel[i - skipped] == 'ß')
|
|
|
titel[i - skipped] = 30;
|
|
|
else if (titel[i - skipped] == '.')
|
|
|
titel[i - skipped] = 31;
|
|
|
@@ -786,7 +786,7 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Bef
|
|
|
a |= (__int64)(titel[i] & 31) << 40; // vierten Buchstaben speichern
|
|
|
break;
|
|
|
case 4:
|
|
|
- a |= (__int64)(titel[i] & 31) << 35; // fünften Buchstaben speichern
|
|
|
+ a |= (__int64)(titel[i] & 31) << 35; // fünften Buchstaben speichern
|
|
|
break;
|
|
|
case 5:
|
|
|
a |= (__int64)(titel[i] & 31)
|
|
|
@@ -808,7 +808,7 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Bef
|
|
|
a |= (__int64)(titel[i] & 31) << 5; // elften Buchstaben speichern
|
|
|
break;
|
|
|
case 11:
|
|
|
- a |= (__int64)(titel[i] & 31); // zwölften Buchstaben speichern
|
|
|
+ a |= (__int64)(titel[i] & 31); // zwölften Buchstaben speichern
|
|
|
break;
|
|
|
case 12:
|
|
|
b |= (__int32)(titel[i] & 31)
|
|
|
@@ -820,7 +820,7 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Bef
|
|
|
break;
|
|
|
case 14:
|
|
|
b |= (__int32)(titel[i] & 31)
|
|
|
- << 17; // fünfzenten Buchstaben speichern
|
|
|
+ << 17; // fünfzenten Buchstaben speichern
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
@@ -882,9 +882,9 @@ void LTDBKopf::speichern(
|
|
|
{
|
|
|
if (f->is_open())
|
|
|
{
|
|
|
- int bits = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/
|
|
|
- + 24 /*Bildgröße*/;
|
|
|
- int bytes = bits / 8; // Bytelänge des Dateikopfes
|
|
|
+ int bits = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/
|
|
|
+ + 24 /*Bildgröße*/;
|
|
|
+ int bytes = bits / 8; // Bytelänge des Dateikopfes
|
|
|
if (((float)bits / 8.0f) != (float)bytes) ++bytes;
|
|
|
char c = 0;
|
|
|
for (int i = 0; i < bytes; ++i)
|
|
|
@@ -895,13 +895,13 @@ void LTDBKopf::speichern(
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-int LTDBKopf::getTitelLength() const // gibt die länge des Bildnamens zurück
|
|
|
+int LTDBKopf::getTitelLength() const // gibt die länge des Bildnamens zurück
|
|
|
{
|
|
|
- return (int)(a >> 60 & Bits(4)); // Die Länge des Titels wird in den ersten
|
|
|
+ return (int)(a >> 60 & Bits(4)); // Die Länge des Titels wird in den ersten
|
|
|
// 4 Bits der Tatei gespeichert
|
|
|
}
|
|
|
|
|
|
-Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurück
|
|
|
+Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurück
|
|
|
{
|
|
|
Text* ret = new Text("");
|
|
|
char c[2];
|
|
|
@@ -925,7 +925,7 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zur
|
|
|
c[0] = (a >> 40) & 31; // vierten Buchstaben holen
|
|
|
break;
|
|
|
case 4:
|
|
|
- c[0] = (a >> 35) & 31; // fünften Buchstaben holen
|
|
|
+ c[0] = (a >> 35) & 31; // fünften Buchstaben holen
|
|
|
break;
|
|
|
case 5:
|
|
|
c[0] = (a >> 30) & 31; // sechsten Buchstaben holen
|
|
|
@@ -946,7 +946,7 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zur
|
|
|
c[0] = (a >> 5) & 31; // elften Buchstaben holen
|
|
|
break;
|
|
|
case 11:
|
|
|
- c[0] = a & 31; // zwölften Buchstaben holen
|
|
|
+ c[0] = a & 31; // zwölften Buchstaben holen
|
|
|
break;
|
|
|
case 12:
|
|
|
c[0] = (char)((b >> 27) & 31); // dreizenten Buchstaben holen
|
|
|
@@ -955,17 +955,17 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zur
|
|
|
c[0] = (char)((b >> 22) & 31); // vierzenten Buchstaben holen
|
|
|
break;
|
|
|
case 14:
|
|
|
- c[0] = (char)((b >> 17) & 31); // fünfzenten Buchstaben holen
|
|
|
+ c[0] = (char)((b >> 17) & 31); // fünfzenten Buchstaben holen
|
|
|
break;
|
|
|
}
|
|
|
if (c[0] == 27)
|
|
|
- c[0] = 'ü';
|
|
|
+ c[0] = 'ü';
|
|
|
else if (c[0] == 28)
|
|
|
- c[0] = 'ö';
|
|
|
+ c[0] = 'ö';
|
|
|
else if (c[0] == 29)
|
|
|
- c[0] = 'ä';
|
|
|
+ c[0] = 'ä';
|
|
|
else if (c[0] == 30)
|
|
|
- c[0] = 'ß';
|
|
|
+ c[0] = 'ß';
|
|
|
else if (c[0] == 31)
|
|
|
c[0] = '.';
|
|
|
else
|
|
|
@@ -975,9 +975,9 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zur
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
-Punkt LTDBKopf::getSize() const // gibt die Größe des Bildes zurück
|
|
|
+Punkt LTDBKopf::getSize() const // gibt die Größe des Bildes zurück
|
|
|
{
|
|
|
- int BeginBit = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/;
|
|
|
+ int BeginBit = 4 /*Titellänge*/ + getTitelLength() * 5 /*Titel*/;
|
|
|
int EndBit = BeginBit + 24;
|
|
|
__int16 grx = getBits(BeginBit, EndBit - 12);
|
|
|
__int16 gry = getBits(BeginBit + 12, EndBit);
|
|
|
@@ -985,7 +985,7 @@ Punkt LTDBKopf::getSize() const // gibt die Gr
|
|
|
}
|
|
|
|
|
|
__int16 LTDBKopf::getBits(int begin,
|
|
|
- int ende) const // gibt die Bits von begin bis ende zurück( ohne ende );
|
|
|
+ int ende) const // gibt die Bits von begin bis ende zurück( ohne ende );
|
|
|
{
|
|
|
if (ende < begin) return 0;
|
|
|
if (ende - begin > 16) ende = begin + 16;
|
|
|
@@ -1029,7 +1029,7 @@ __int16 LTDBKopf::getBits(int begin,
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
-// Inhalt der LTDBKörper Klasse aus Dateisystem.h
|
|
|
+// Inhalt der LTDBKörper Klasse aus Dateisystem.h
|
|
|
// Konstruktor
|
|
|
LTDBBody::LTDBBody()
|
|
|
: ReferenceCounter(),
|
|
|
@@ -1052,7 +1052,7 @@ LTDBBody::~LTDBBody()
|
|
|
}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden benötigt
|
|
|
+void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden benötigt
|
|
|
{
|
|
|
gr = k.getSize();
|
|
|
int l = k.getTitelLength();
|
|
|
@@ -1060,7 +1060,7 @@ void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden ben
|
|
|
dateiSize = (l / 8.0 == l) ? (l / 8) : (l / 8 + 1);
|
|
|
}
|
|
|
|
|
|
-void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden benötigt
|
|
|
+void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden benötigt
|
|
|
{
|
|
|
gr = k->getSize();
|
|
|
int l = k->getTitelLength();
|
|
|
@@ -1069,7 +1069,7 @@ void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden ben
|
|
|
k->release();
|
|
|
}
|
|
|
|
|
|
-void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // läd das Bild
|
|
|
+void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // läd das Bild
|
|
|
{
|
|
|
b->neuBild(gr.x, gr.y, 0xFF000000); // neues Bild erstellen
|
|
|
int* buff = b->getBuffer();
|
|
|
@@ -1086,7 +1086,7 @@ void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // l
|
|
|
zF->setAktionAnzahl(gr.x * gr.y);
|
|
|
}
|
|
|
#endif
|
|
|
- while (index < gr.x * gr.y) // für jeden Pixel
|
|
|
+ while (index < gr.x * gr.y) // für jeden Pixel
|
|
|
{
|
|
|
if (!dieser) // wenn es nicht der erste Pixel ist
|
|
|
dieser = new LTDBPixel(dynamic_cast<LTDBPixel*>(davor->getThis()));
|
|
|
@@ -1128,7 +1128,7 @@ void LTDBBody::speichern(
|
|
|
= new LTDBPixel(0); // Der momentan zu speichernde Pixel
|
|
|
int begin = 0,
|
|
|
ende = 0; // Pixelbeginn, endposition in der byte variable
|
|
|
- char byte = 0; // Der nächste byte der Datei
|
|
|
+ char byte = 0; // Der nächste byte der Datei
|
|
|
bool w = 0;
|
|
|
#ifdef WIN32
|
|
|
if (zF)
|
|
|
@@ -1138,7 +1138,7 @@ void LTDBBody::speichern(
|
|
|
}
|
|
|
#endif
|
|
|
int* pBuff = b->getBuffer();
|
|
|
- for (int i = 0; i < gr.x * gr.y; ++i) // für jeden Pixel
|
|
|
+ for (int i = 0; i < gr.x * gr.y; ++i) // für jeden Pixel
|
|
|
{
|
|
|
if (!dieser) // wenn es nicht der erste Pixel ist
|
|
|
dieser = new LTDBPixel(
|
|
|
@@ -1146,7 +1146,7 @@ void LTDBBody::speichern(
|
|
|
dieser->setFarbe(pBuff[i]); // Farbe des Pixels setzen
|
|
|
dieser->komprimieren(); // Pixel komprimieren
|
|
|
ende = -1;
|
|
|
- while (ende < 0) // byte befüllen
|
|
|
+ while (ende < 0) // byte befüllen
|
|
|
{
|
|
|
ende = dieser->getNextByte(byte, begin);
|
|
|
begin = 0;
|
|
|
@@ -1177,12 +1177,12 @@ void LTDBBody::speichern(
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-Bild* LTDBBody::getBild() const // gibt das geladene Bild zurück
|
|
|
+Bild* LTDBBody::getBild() const // gibt das geladene Bild zurück
|
|
|
{
|
|
|
return dynamic_cast<Bild*>(b->getThis());
|
|
|
}
|
|
|
|
|
|
-const Punkt& LTDBBody::getSize() const // gibt die größe des Bildes zurück
|
|
|
+const Punkt& LTDBBody::getSize() const // gibt die größe des Bildes zurück
|
|
|
{
|
|
|
return gr;
|
|
|
}
|
|
|
@@ -1204,7 +1204,7 @@ LTDBDatei::~LTDBDatei()
|
|
|
|
|
|
// nicht constant
|
|
|
void LTDBDatei::setDatei(Text* pfad) // Setzt den Pfad zur Datei
|
|
|
-{ // Werte der eventuellen vorherigen Datei löschen
|
|
|
+{ // Werte der eventuellen vorherigen Datei löschen
|
|
|
if (datKpf) datKpf = (LTDBDateiKopf*)datKpf->release();
|
|
|
// Pfad setzen
|
|
|
this->pfad->setText(*pfad);
|
|
|
@@ -1221,9 +1221,9 @@ void LTDBDatei::erstellen() // Erstellt die Datei
|
|
|
}
|
|
|
|
|
|
void LTDBDatei::leseDaten(
|
|
|
- FBalken* f) // Die Klasse ließt alle Bilder kurz ein, und merkt sich, an
|
|
|
+ FBalken* f) // Die Klasse ließt alle Bilder kurz ein, und merkt sich, an
|
|
|
// welcher stelle in der Datei was ist
|
|
|
-{ // Diese Funktion wird ein wenig Zeit in Anspruch nemen, dafüraber danach die
|
|
|
+{ // Diese Funktion wird ein wenig Zeit in Anspruch nemen, dafüraber danach die
|
|
|
// anderen schneller machen
|
|
|
if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
|
|
|
{
|
|
|
@@ -1236,7 +1236,7 @@ void LTDBDatei::leseDaten(
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void LTDBDatei::remove() // Löscht die Datei
|
|
|
+void LTDBDatei::remove() // Löscht die Datei
|
|
|
{
|
|
|
if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
|
|
|
{
|
|
|
@@ -1245,12 +1245,12 @@ void LTDBDatei::remove() // L
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void LTDBDatei::remove(FBalken* f, Text* name) // Löscht ein Bild aus der Datei
|
|
|
+void LTDBDatei::remove(FBalken* f, Text* name) // Löscht ein Bild aus der Datei
|
|
|
{
|
|
|
if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())) && name)
|
|
|
{
|
|
|
if (!datKpf) leseDaten(0); // Daten einlesen
|
|
|
- // Prüfen, ob Datei nicht vorhanden
|
|
|
+ // Prüfen, ob Datei nicht vorhanden
|
|
|
if (!datKpf)
|
|
|
{
|
|
|
name->release();
|
|
|
@@ -1277,12 +1277,12 @@ void LTDBDatei::remove(FBalken* f, Text* name) // L
|
|
|
c);
|
|
|
}
|
|
|
std::ifstream* inF = new std::ifstream(
|
|
|
- pfad->getText(), std::ios::binary); // Alte Datei öffnen
|
|
|
+ pfad->getText(), std::ios::binary); // Alte Datei öffnen
|
|
|
inF->seekg(0, std::ios::end);
|
|
|
__int64 datlen = inF->tellg();
|
|
|
inF->seekg(0, std::ios::beg);
|
|
|
std::ofstream* outF = new std::ofstream(
|
|
|
- pf_tmp->getText(), std::ios::binary); // Neue Datei öffnen
|
|
|
+ pf_tmp->getText(), std::ios::binary); // Neue Datei öffnen
|
|
|
if (inF->is_open() && outF->is_open())
|
|
|
{
|
|
|
__int64 position = datKpf->getBildPosition(index);
|
|
|
@@ -1300,7 +1300,7 @@ void LTDBDatei::remove(FBalken* f, Text* name) // L
|
|
|
{
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
- } // zu löschendes Bild überspringen
|
|
|
+ } // zu löschendes Bild überspringen
|
|
|
LTDBKopf* delkpf = new LTDBKopf();
|
|
|
delkpf->laden(inF);
|
|
|
LTDBBody* delkpr
|
|
|
@@ -1331,7 +1331,7 @@ void LTDBDatei::remove(FBalken* f, Text* name) // L
|
|
|
if (name) name = (Text*)name->release();
|
|
|
}
|
|
|
|
|
|
-Bild* LTDBDatei::laden(FBalken* f, Text* name) // Läd ein Bild aus der Datei
|
|
|
+Bild* LTDBDatei::laden(FBalken* f, Text* name) // Läd ein Bild aus der Datei
|
|
|
{
|
|
|
if (name)
|
|
|
{
|
|
|
@@ -1372,7 +1372,7 @@ Bild* LTDBDatei::laden(FBalken* f, Text* name) // L
|
|
|
delete inF;
|
|
|
Text* fehler = new Text("Die Datei ");
|
|
|
fehler->append(*pfad);
|
|
|
- fehler->append(" ist ist keine gültige LTDB Datei!");
|
|
|
+ fehler->append(" ist ist keine gültige LTDB Datei!");
|
|
|
#ifdef WIN32
|
|
|
WMessageBox(0, new Text("Fehler"), fehler, MB_ICONERROR);
|
|
|
#endif
|
|
|
@@ -1490,7 +1490,7 @@ RCArray<Text>* LTDBDatei::zBildListe() // Listet alle Bilder in der datei auf
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-Text* LTDBDatei::getPfad() const // Gibt den Pfad zur Datei zurück
|
|
|
+Text* LTDBDatei::getPfad() const // Gibt den Pfad zur Datei zurück
|
|
|
{
|
|
|
return dynamic_cast<Text*>(pfad->getThis());
|
|
|
}
|
|
|
@@ -1501,7 +1501,7 @@ int LTDBDatei::getBildAnzahl() const
|
|
|
return datKpf->getbAnzahl();
|
|
|
}
|
|
|
|
|
|
-bool LTDBDatei::istOffen() const // Prüft, ob die Datei geöffnet ist
|
|
|
+bool LTDBDatei::istOffen() const // Prüft, ob die Datei geöffnet ist
|
|
|
{
|
|
|
if (!pfad) return 0;
|
|
|
return DateiExistiert(dynamic_cast<Text*>(pfad->getThis()));
|
|
|
@@ -1516,8 +1516,8 @@ LTDSPixel::LTDSPixel(LTDSPixel* davor)
|
|
|
iA(0),
|
|
|
miA(8),
|
|
|
maxIndex(1),
|
|
|
- änder(0),
|
|
|
- änderA(0),
|
|
|
+ änder(0),
|
|
|
+ änderA(0),
|
|
|
komp(0),
|
|
|
alpha(0),
|
|
|
davor(davor)
|
|
|
@@ -1533,18 +1533,18 @@ LTDSPixel::~LTDSPixel()
|
|
|
// zum Laden gedacht
|
|
|
bool LTDSPixel::addBitZuFarbe(unsigned char bit)
|
|
|
{
|
|
|
- if (änderA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
+ if (änderA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
{
|
|
|
alpha |= ((bit & Bits(1))) << (7 - komp - iA);
|
|
|
++iA;
|
|
|
}
|
|
|
- else // Das Bit gehört zum nächsten Pixel
|
|
|
+ else // Das Bit gehört zum nächsten Pixel
|
|
|
return false;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
char LTDSPixel::addByte(
|
|
|
- char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
|
|
|
+ char byte, char begin) // gibt ende des Pixels zurück, -1 wenn nicht zu ende
|
|
|
{
|
|
|
if (begin >= 8 || begin < 0) return -1;
|
|
|
for (int i = begin; i < 8; ++i)
|
|
|
@@ -1553,81 +1553,81 @@ char LTDSPixel::addByte(
|
|
|
{
|
|
|
case 0:
|
|
|
// Das erste Bit eines Pixels speichert, ob sich an der
|
|
|
- // Komprimierung etwas änderte
|
|
|
- änder = ((byte >> (7 - i)) & Bits(1)) == 1;
|
|
|
- if (!änder) // Ändert sich nichts an der Komprimierung, so werden
|
|
|
- // die Werte vom vorherigen Pixel übernommen
|
|
|
+ // Komprimierung etwas änderte
|
|
|
+ änder = ((byte >> (7 - i)) & Bits(1)) == 1;
|
|
|
+ if (!änder) // Ändert sich nichts an der Komprimierung, so werden
|
|
|
+ // die Werte vom vorherigen Pixel übernommen
|
|
|
{
|
|
|
- if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
|
|
|
- // nicht von dem davor Übernemen )
|
|
|
+ if (!davor) // Die Datei ist beschädigt ( Der erste Pixel kann
|
|
|
+ // nicht von dem davor Übernemen )
|
|
|
{
|
|
|
MessageBox(NULL,
|
|
|
- "Fehler, die Bilddatei ist beschädigt",
|
|
|
+ "Fehler, die Bilddatei ist beschädigt",
|
|
|
"Fehler",
|
|
|
MB_ICONERROR);
|
|
|
exit(0);
|
|
|
}
|
|
|
- änderA = davor->getÄnderA();
|
|
|
+ änderA = davor->getÄnderA();
|
|
|
komp = davor->getKomp();
|
|
|
miA -= komp;
|
|
|
- if (!änderA) alpha = davor->getA();
|
|
|
- maxIndex += änderA * (8 - komp); // Bestimmung der Länge
|
|
|
+ if (!änderA) alpha = davor->getA();
|
|
|
+ maxIndex += änderA * (8 - komp); // Bestimmung der Länge
|
|
|
// des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
|
|
|
// durch komprimierung kanns kleiner sein
|
|
|
}
|
|
|
else
|
|
|
maxIndex += 4; // Da der Pixel nicht die Werte des vorherigen
|
|
|
- // übernimmt, wird er um 4 Bits größer
|
|
|
+ // übernimmt, wird er um 4 Bits größer
|
|
|
break;
|
|
|
case 1: // Das zweite Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
- änderA = ((byte >> (7 - i)) & Bits(1)) == 1;
|
|
|
+ if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
+ änderA = ((byte >> (7 - i)) & Bits(1)) == 1;
|
|
|
else
|
|
|
{
|
|
|
- if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
+ if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
return i;
|
|
|
}
|
|
|
break;
|
|
|
case 2: // Das sechste Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
+ if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 2;
|
|
|
else
|
|
|
{
|
|
|
- if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
+ if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
return i;
|
|
|
}
|
|
|
break;
|
|
|
case 3: // Das siebte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
+ if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 1;
|
|
|
else
|
|
|
{
|
|
|
- if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
+ if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
return i;
|
|
|
}
|
|
|
break;
|
|
|
case 4: // Das achte Bit eines Pixels speichert entweder die
|
|
|
// Komprimierungsart, oder schon die Farbe
|
|
|
- if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
+ if (änder) // Das Bit gehört zu den 4 Komprimierungsbits
|
|
|
{
|
|
|
komp |= (unsigned char)((byte >> (7 - i)) & Bits(1));
|
|
|
// Das war das letzte Komprimierungsbit
|
|
|
// Komprimierung auswerten
|
|
|
miA -= komp;
|
|
|
- if (!änderA) alpha = davor->getA();
|
|
|
- maxIndex += änderA * (8 - komp); // Bitlänge des Pixels
|
|
|
+ if (!änderA) alpha = davor->getA();
|
|
|
+ maxIndex += änderA * (8 - komp); // Bitlänge des Pixels
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
- if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
+ if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
return i;
|
|
|
}
|
|
|
break;
|
|
|
default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
|
|
|
- if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
+ if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehört zur Farbe
|
|
|
return i;
|
|
|
break;
|
|
|
}
|
|
|
@@ -1636,7 +1636,7 @@ char LTDSPixel::addByte(
|
|
|
{
|
|
|
if (davor)
|
|
|
{
|
|
|
- if (änderA) alpha = davor->getA() + alpha;
|
|
|
+ if (änderA) alpha = davor->getA() + alpha;
|
|
|
davor = (LTDSPixel*)davor->release();
|
|
|
}
|
|
|
return i + 1;
|
|
|
@@ -1656,8 +1656,8 @@ void LTDSPixel::Komp() // Komprimiert den Pixel
|
|
|
maxIndex = 1;
|
|
|
if (!davor)
|
|
|
{ // Das ist der erste Pixel
|
|
|
- änder = 1;
|
|
|
- änderA = 1;
|
|
|
+ änder = 1;
|
|
|
+ änderA = 1;
|
|
|
maxIndex += 4;
|
|
|
miA = getBits(alpha);
|
|
|
}
|
|
|
@@ -1665,23 +1665,23 @@ void LTDSPixel::Komp() // Komprimiert den Pixel
|
|
|
{ // Es wird die differenz zum vorrigen Pixel gespeichert
|
|
|
miA = getBits(alpha - davor->getA());
|
|
|
if (alpha != davor->getA())
|
|
|
- änderA = 1;
|
|
|
+ änderA = 1;
|
|
|
else
|
|
|
- änderA = 0;
|
|
|
- } // Prüfen ob sich etwas ändert
|
|
|
- if (!miA && änderA) ++miA;
|
|
|
+ änderA = 0;
|
|
|
+ } // Prüfen ob sich etwas ändert
|
|
|
+ if (!miA && änderA) ++miA;
|
|
|
komp = 8 - miA;
|
|
|
- maxIndex += änderA * miA;
|
|
|
+ maxIndex += änderA * miA;
|
|
|
if (davor)
|
|
|
{
|
|
|
- if (änderA != davor->getÄnderA() || komp != davor->getKomp())
|
|
|
- { // Es ändert sich etwas
|
|
|
- änder = 1;
|
|
|
+ if (änderA != davor->getÄnderA() || komp != davor->getKomp())
|
|
|
+ { // Es ändert sich etwas
|
|
|
+ änder = 1;
|
|
|
maxIndex += 4;
|
|
|
}
|
|
|
else
|
|
|
- { // Es ändert sich nichts
|
|
|
- änder = 0;
|
|
|
+ { // Es ändert sich nichts
|
|
|
+ änder = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
@@ -1693,7 +1693,7 @@ bool LTDSPixel::getNextFarbeBit(char& byte, int i)
|
|
|
{
|
|
|
AA -= davor->getA();
|
|
|
}
|
|
|
- if (änderA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
+ if (änderA && iA != miA) // Das Bit gehört zu Alpha
|
|
|
{
|
|
|
byte |= ((AA >> (7 - komp - iA)) & Bits(1)) << (7 - i);
|
|
|
++iA;
|
|
|
@@ -1704,24 +1704,24 @@ bool LTDSPixel::getNextFarbeBit(char& byte, int i)
|
|
|
}
|
|
|
|
|
|
char LTDSPixel::getNextByte(
|
|
|
- char& byte, int bbegin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
|
|
|
+ char& byte, int bbegin) // Gibt die nächsten Bits Zurück, -1 wenn der Pixel
|
|
|
// nicht zu ende ist
|
|
|
{
|
|
|
// bbegin gibt an wohin in die byte-variable geschrieben werden soll
|
|
|
- // die Funktion gibt das ende des Pixels in der byte-variable zurück
|
|
|
- // -1 heißt, dass der Pixel nicht zu ende ist
|
|
|
+ // die Funktion gibt das ende des Pixels in der byte-variable zurück
|
|
|
+ // -1 heißt, dass der Pixel nicht zu ende ist
|
|
|
for (int i = bbegin; i < 8; ++i)
|
|
|
{
|
|
|
switch (index)
|
|
|
{
|
|
|
case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
|
|
|
- // Komprimierung ändert
|
|
|
- byte |= ((int)änder & Bits(1)) << (7 - i);
|
|
|
+ // Komprimierung ändert
|
|
|
+ byte |= ((int)änder & Bits(1)) << (7 - i);
|
|
|
break;
|
|
|
case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
|
|
|
// oder die Komprimierung
|
|
|
- if (änder) // Komprimierung
|
|
|
- byte |= ((int)änderA & Bits(1)) << (7 - i);
|
|
|
+ if (änder) // Komprimierung
|
|
|
+ byte |= ((int)änderA & Bits(1)) << (7 - i);
|
|
|
else // Farbe
|
|
|
{
|
|
|
if (!getNextFarbeBit(byte, i)) return i;
|
|
|
@@ -1729,7 +1729,7 @@ char LTDSPixel::getNextByte(
|
|
|
break;
|
|
|
case 2: // Das zweite Bit des Pixels speichert entweder schon die Farbe
|
|
|
// oder die Komprimierung
|
|
|
- if (änder) // Komprimierung
|
|
|
+ if (änder) // Komprimierung
|
|
|
byte |= ((komp >> 2) & Bits(1)) << (7 - i);
|
|
|
else // Farbe
|
|
|
{
|
|
|
@@ -1738,7 +1738,7 @@ char LTDSPixel::getNextByte(
|
|
|
break;
|
|
|
case 3: // Das dritte Bit des Pixels speichert entweder schon die Farbe
|
|
|
// oder die Komprimierung
|
|
|
- if (änder) // Komprimierung
|
|
|
+ if (änder) // Komprimierung
|
|
|
byte |= ((komp >> 1) & Bits(1)) << (7 - i);
|
|
|
else // Farbe
|
|
|
{
|
|
|
@@ -1747,7 +1747,7 @@ char LTDSPixel::getNextByte(
|
|
|
break;
|
|
|
case 4: // Das vierte Bit des Pixels speichert entweder schon die Farbe
|
|
|
// oder die Komprimierung
|
|
|
- if (änder) // Komprimierung
|
|
|
+ if (änder) // Komprimierung
|
|
|
byte |= (komp & Bits(1)) << (7 - i);
|
|
|
else // Farbe
|
|
|
{
|
|
|
@@ -1769,17 +1769,17 @@ char LTDSPixel::getNextByte(
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-unsigned char LTDSPixel::getKomp() const // hat sich die Komprimierung geändert
|
|
|
+unsigned char LTDSPixel::getKomp() const // hat sich die Komprimierung geändert
|
|
|
{
|
|
|
return komp;
|
|
|
}
|
|
|
|
|
|
-bool LTDSPixel::getÄnderA() const // gibt zurück, ob sich der alphawert ändert
|
|
|
+bool LTDSPixel::getÄnderA() const // gibt zurück, ob sich der alphawert ändert
|
|
|
{
|
|
|
- return änderA;
|
|
|
+ return änderA;
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDSPixel::getA() const // gibt Alpha zurück
|
|
|
+unsigned char LTDSPixel::getA() const // gibt Alpha zurück
|
|
|
{
|
|
|
return alpha;
|
|
|
}
|
|
|
@@ -1801,7 +1801,7 @@ LTDSDateiKopf::~LTDSDateiKopf()
|
|
|
}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDSDateiKopf::laden(std::ifstream* inF) // Lät aus inF
|
|
|
+void LTDSDateiKopf::laden(std::ifstream* inF) // Lät aus inF
|
|
|
{
|
|
|
if (inF->good() && inF->is_open())
|
|
|
{
|
|
|
@@ -1820,7 +1820,7 @@ void LTDSDateiKopf::laden(std::ifstream* inF) // L
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void LTDSDateiKopf::addSG(char sg) // Schriftgröße hinzufügen
|
|
|
+void LTDSDateiKopf::addSG(char sg) // Schriftgröße hinzufügen
|
|
|
{
|
|
|
++sganzahl;
|
|
|
unsigned char* gr_tmp = gr;
|
|
|
@@ -1840,7 +1840,7 @@ void LTDSDateiKopf::addSG(char sg) // Schriftgr
|
|
|
gr[sganzahl - 1] = sg;
|
|
|
}
|
|
|
|
|
|
-void LTDSDateiKopf::removeSG(char sg) // Schriftgröße entfernen
|
|
|
+void LTDSDateiKopf::removeSG(char sg) // Schriftgröße entfernen
|
|
|
{
|
|
|
bool hatsg = 0;
|
|
|
int sgpos = 0;
|
|
|
@@ -1888,20 +1888,20 @@ void LTDSDateiKopf::speichern(std::ofstream* outF) const // Speichert nach outF
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-unsigned char* LTDSDateiKopf::getSchriftGrößeList()
|
|
|
- const // gibt eine Liste mit gespeicherten Schriftgrößen zurück
|
|
|
+unsigned char* LTDSDateiKopf::getSchriftGrößeList()
|
|
|
+ const // gibt eine Liste mit gespeicherten Schriftgrößen zurück
|
|
|
{
|
|
|
return gr;
|
|
|
}
|
|
|
|
|
|
int* LTDSDateiKopf::getPositionList()
|
|
|
- const // gibt eine Positionsliste der gespeicherten Schriftgrößen zurück
|
|
|
+ const // gibt eine Positionsliste der gespeicherten Schriftgrößen zurück
|
|
|
{
|
|
|
return pos;
|
|
|
}
|
|
|
|
|
|
-int LTDSDateiKopf::getSchriftGrößeAnzahl()
|
|
|
- const // gibt die Anzahl der gespeicherten Schriftgrößen zurück
|
|
|
+int LTDSDateiKopf::getSchriftGrößeAnzahl()
|
|
|
+ const // gibt die Anzahl der gespeicherten Schriftgrößen zurück
|
|
|
{
|
|
|
return sganzahl;
|
|
|
}
|
|
|
@@ -1924,7 +1924,7 @@ LTDSSchriftKopf::~LTDSSchriftKopf()
|
|
|
}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDSSchriftKopf::laden(std::ifstream* inF) // läht von inF
|
|
|
+void LTDSSchriftKopf::laden(std::ifstream* inF) // läht von inF
|
|
|
{
|
|
|
if (inF->good() && inF->is_open())
|
|
|
{
|
|
|
@@ -1943,7 +1943,7 @@ void LTDSSchriftKopf::laden(std::ifstream* inF) // l
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void LTDSSchriftKopf::setSchriftgröße(unsigned char gr) // setze schriftgröße
|
|
|
+void LTDSSchriftKopf::setSchriftgröße(unsigned char gr) // setze schriftgröße
|
|
|
{
|
|
|
schriftSize = gr;
|
|
|
}
|
|
|
@@ -1979,7 +1979,7 @@ void LTDSSchriftKopf::setZeichenAlphabet(
|
|
|
alphabet->release();
|
|
|
}
|
|
|
|
|
|
-void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Zeichen hinzufügen
|
|
|
+void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Zeichen hinzufügen
|
|
|
{
|
|
|
++zeichenAnzahl;
|
|
|
unsigned char* zeichen_tmp = this->zeichen;
|
|
|
@@ -2048,23 +2048,23 @@ void LTDSSchriftKopf::speichern(
|
|
|
}
|
|
|
|
|
|
unsigned char
|
|
|
-LTDSSchriftKopf::getSchriftGröße() const // gibt die Schriftgröße zurück
|
|
|
+LTDSSchriftKopf::getSchriftGröße() const // gibt die Schriftgröße zurück
|
|
|
{
|
|
|
return schriftSize;
|
|
|
}
|
|
|
|
|
|
unsigned char
|
|
|
-LTDSSchriftKopf::getZeichenAnzahl() const // gibt die Zeichenanzahl zurück
|
|
|
+LTDSSchriftKopf::getZeichenAnzahl() const // gibt die Zeichenanzahl zurück
|
|
|
{
|
|
|
return zeichenAnzahl;
|
|
|
}
|
|
|
|
|
|
-int* LTDSSchriftKopf::getPositionen() const // gibt die Zeichenpositionen zurück
|
|
|
+int* LTDSSchriftKopf::getPositionen() const // gibt die Zeichenpositionen zurück
|
|
|
{
|
|
|
return pos;
|
|
|
}
|
|
|
|
|
|
-unsigned char* LTDSSchriftKopf::getZeichen() const // gibt die zeichen zurück
|
|
|
+unsigned char* LTDSSchriftKopf::getZeichen() const // gibt die zeichen zurück
|
|
|
{
|
|
|
return zeichen;
|
|
|
}
|
|
|
@@ -2078,7 +2078,7 @@ LTDSBuchstabenKopf::LTDSBuchstabenKopf()
|
|
|
{}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDSBuchstabenKopf::laden(std::ifstream* inF) // lät aus inF
|
|
|
+void LTDSBuchstabenKopf::laden(std::ifstream* inF) // lät aus inF
|
|
|
{
|
|
|
if (inF->good() && inF->is_open())
|
|
|
{
|
|
|
@@ -2089,16 +2089,16 @@ void LTDSBuchstabenKopf::laden(std::ifstream* inF) // l
|
|
|
}
|
|
|
|
|
|
void LTDSBuchstabenKopf::init(unsigned char zeichen,
|
|
|
- const Punkt& größe) // initialisierung( für speichern )
|
|
|
+ const Punkt& größe) // initialisierung( für speichern )
|
|
|
{
|
|
|
this->zeichen = zeichen;
|
|
|
- this->size = größe;
|
|
|
+ this->size = größe;
|
|
|
}
|
|
|
|
|
|
-void LTDSBuchstabenKopf::init(unsigned char zeichen, int br, int hö)
|
|
|
+void LTDSBuchstabenKopf::init(unsigned char zeichen, int br, int hö)
|
|
|
{
|
|
|
this->zeichen = zeichen;
|
|
|
- size.x = br, size.y = hö;
|
|
|
+ size.x = br, size.y = hö;
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
@@ -2113,31 +2113,31 @@ void LTDSBuchstabenKopf::speichern(
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-unsigned char LTDSBuchstabenKopf::getZeichen() const // gibt das Zeichen zurück
|
|
|
+unsigned char LTDSBuchstabenKopf::getZeichen() const // gibt das Zeichen zurück
|
|
|
{
|
|
|
return zeichen;
|
|
|
}
|
|
|
|
|
|
-int LTDSBuchstabenKopf::getBreite() const // gibt die Breite zurück
|
|
|
+int LTDSBuchstabenKopf::getBreite() const // gibt die Breite zurück
|
|
|
{
|
|
|
return size.x;
|
|
|
}
|
|
|
|
|
|
-int LTDSBuchstabenKopf::getHöhe() const // gibt die höhe zurück
|
|
|
+int LTDSBuchstabenKopf::getHöhe() const // gibt die höhe zurück
|
|
|
{
|
|
|
return size.y;
|
|
|
}
|
|
|
|
|
|
-const Punkt& LTDSBuchstabenKopf::getGröße() const // gibt die Größe zurück
|
|
|
+const Punkt& LTDSBuchstabenKopf::getGröße() const // gibt die Größe zurück
|
|
|
{
|
|
|
return size;
|
|
|
}
|
|
|
|
|
|
-// Inhalt der LTDSBuchstabenKörper Klasse aus Dateisystem.h
|
|
|
+// Inhalt der LTDSBuchstabenKörper Klasse aus Dateisystem.h
|
|
|
// Konstruktor
|
|
|
-LTDSBuchstabenKörper::LTDSBuchstabenKörper(LTDSBuchstabenKopf* kopf)
|
|
|
+LTDSBuchstabenKörper::LTDSBuchstabenKörper(LTDSBuchstabenKopf* kopf)
|
|
|
: ReferenceCounter(),
|
|
|
- size(kopf->getGröße()),
|
|
|
+ size(kopf->getGröße()),
|
|
|
zeichen(kopf->getZeichen()),
|
|
|
buchstabe(new Buchstabe())
|
|
|
{
|
|
|
@@ -2146,20 +2146,20 @@ LTDSBuchstabenK
|
|
|
}
|
|
|
|
|
|
// Destruktor
|
|
|
-LTDSBuchstabenKörper::~LTDSBuchstabenKörper()
|
|
|
+LTDSBuchstabenKörper::~LTDSBuchstabenKörper()
|
|
|
{
|
|
|
if (buchstabe) buchstabe->release();
|
|
|
}
|
|
|
|
|
|
// nicht constant
|
|
|
-void LTDSBuchstabenKörper::setBuchstabe(
|
|
|
+void LTDSBuchstabenKörper::setBuchstabe(
|
|
|
Buchstabe* zeichen) // setzt den Buchstaben
|
|
|
{
|
|
|
if (buchstabe) buchstabe->release();
|
|
|
buchstabe = zeichen;
|
|
|
}
|
|
|
|
|
|
-void LTDSBuchstabenKörper::laden(std::ifstream* inF) // Läht aus inF
|
|
|
+void LTDSBuchstabenKörper::laden(std::ifstream* inF) // Läht aus inF
|
|
|
{
|
|
|
if (inF->good() && inF->is_open())
|
|
|
{
|
|
|
@@ -2193,7 +2193,7 @@ void LTDSBuchstabenK
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-void LTDSBuchstabenKörper::speichern(
|
|
|
+void LTDSBuchstabenKörper::speichern(
|
|
|
std::ofstream* outF) const // speichert nach outF
|
|
|
{
|
|
|
if (outF->good() && outF->is_open())
|
|
|
@@ -2203,10 +2203,10 @@ void LTDSBuchstabenK
|
|
|
= new LTDSPixel(0); // Der momentan zu speichernde Pixel
|
|
|
int begin = 0,
|
|
|
ende = 0; // Pixelbeginn, endposition in der byte variable
|
|
|
- char byte = 0; // Der nächste byte der Datei
|
|
|
+ char byte = 0; // Der nächste byte der Datei
|
|
|
bool w = 0;
|
|
|
unsigned char* alphaBuff = buchstabe->getBuff();
|
|
|
- for (int i = 0; i < size.x * size.y; ++i) // für jeden Pixel
|
|
|
+ for (int i = 0; i < size.x * size.y; ++i) // für jeden Pixel
|
|
|
{
|
|
|
if (!jetzt) // wenn es nicht der erste Pixel ist
|
|
|
jetzt = new LTDSPixel(
|
|
|
@@ -2214,7 +2214,7 @@ void LTDSBuchstabenK
|
|
|
jetzt->setAlpha(alphaBuff[i]); // Farbe des Pixels setzen
|
|
|
jetzt->Komp(); // Pixel komprimieren
|
|
|
ende = -1;
|
|
|
- while (ende < 0) // byte befüllen
|
|
|
+ while (ende < 0) // byte befüllen
|
|
|
{
|
|
|
ende = jetzt->getNextByte(byte, begin);
|
|
|
begin = 0;
|
|
|
@@ -2243,13 +2243,13 @@ void LTDSBuchstabenK
|
|
|
}
|
|
|
|
|
|
Buchstabe*
|
|
|
-LTDSBuchstabenKörper::getBuchstabe() const // gibt den Buchstaben zurück
|
|
|
+LTDSBuchstabenKörper::getBuchstabe() const // gibt den Buchstaben zurück
|
|
|
{
|
|
|
return dynamic_cast<Buchstabe*>(buchstabe->getThis());
|
|
|
}
|
|
|
|
|
|
unsigned char
|
|
|
-LTDSBuchstabenKörper::getZeichen() const // gibt das Zeichen zurück
|
|
|
+LTDSBuchstabenKörper::getZeichen() const // gibt das Zeichen zurück
|
|
|
{
|
|
|
return zeichen;
|
|
|
}
|
|
|
@@ -2277,7 +2277,7 @@ void LTDSDatei::setPfad(Text* txt) // setzt den Pfad zur Datei
|
|
|
txt->release();
|
|
|
}
|
|
|
|
|
|
-void LTDSDatei::leseDaten() // ließt den Dateikopf
|
|
|
+void LTDSDatei::leseDaten() // ließt den Dateikopf
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
|
|
|
if (dateiKopf) dateiKopf->release();
|
|
|
@@ -2288,38 +2288,38 @@ void LTDSDatei::leseDaten() // lie
|
|
|
delete inF;
|
|
|
}
|
|
|
|
|
|
-void LTDSDatei::addSchriftgröße(
|
|
|
- Alphabet* alphabet) // fügt eine Schriftgröße hinzu
|
|
|
+void LTDSDatei::addSchriftgröße(
|
|
|
+ Alphabet* alphabet) // fügt eine Schriftgröße hinzu
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(
|
|
|
- pfad->getThis()))) // prüfen, ob die Datei existiert
|
|
|
+ pfad->getThis()))) // prüfen, ob die Datei existiert
|
|
|
return;
|
|
|
- if (!dateiKopf) // prüfen, ob der Dateikopf schon gelesen wurde
|
|
|
+ if (!dateiKopf) // prüfen, ob der Dateikopf schon gelesen wurde
|
|
|
leseDaten();
|
|
|
- int sgröße
|
|
|
+ int sgröße
|
|
|
= alphabet
|
|
|
- ->getSchriftSize(); // Schriftgröße die hinzugefügt werden soll
|
|
|
+ ->getSchriftSize(); // Schriftgröße die hinzugefügt werden soll
|
|
|
unsigned char* sglist
|
|
|
- = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
|
|
|
- // Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
|
|
|
+ // Schriftgrößen
|
|
|
unsigned char sganzahl
|
|
|
- = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der bereits vorhandenen
|
|
|
- // Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der bereits vorhandenen
|
|
|
+ // Schriftgrößen
|
|
|
for (int i = 0; i < sganzahl;
|
|
|
- ++i) // prüfen, ob die Schriftgröße bereits existiert
|
|
|
+ ++i) // prüfen, ob die Schriftgröße bereits existiert
|
|
|
{
|
|
|
- if (sglist[i] == sgröße)
|
|
|
+ if (sglist[i] == sgröße)
|
|
|
{
|
|
|
alphabet->release();
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
- dateiKopf->addSG(sgröße); // Schriftgröße dem Dateikopf hinzufügen
|
|
|
+ dateiKopf->addSG(sgröße); // Schriftgröße dem Dateikopf hinzufügen
|
|
|
int* sgPosList
|
|
|
= dateiKopf
|
|
|
- ->getPositionList(); // Liste mit positionen der Schriftgrößen
|
|
|
- sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
|
|
|
- // Schriftgrößen
|
|
|
+ ->getPositionList(); // Liste mit positionen der Schriftgrößen
|
|
|
+ sglist = dateiKopf->getSchriftGrößeList(); // Liste von bereits vorhandenen
|
|
|
+ // Schriftgrößen
|
|
|
std::ifstream* inF
|
|
|
= new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
|
|
|
pfad->append("0");
|
|
|
@@ -2327,24 +2327,24 @@ void LTDSDatei::addSchriftgr
|
|
|
= new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
|
|
|
dateiKopf->speichern(outF); // Dateikopf in neue datei speichern
|
|
|
inF->seekg(1 + 5 * sganzahl,
|
|
|
- std::ios::beg); // Position der ersten Schriftgröße in der alten Datei
|
|
|
+ std::ios::beg); // Position der ersten Schriftgröße in der alten Datei
|
|
|
for (int i = 0; i < sganzahl;
|
|
|
- ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
|
|
|
+ ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf_tmp
|
|
|
- = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
sgKpf_tmp->laden(inF); // aus alter Datei laden
|
|
|
int* zeichP_tmp
|
|
|
- = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
+ = sgKpf_tmp->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
unsigned char zeichA_tmp
|
|
|
= sgKpf_tmp
|
|
|
- ->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
|
|
|
+ ->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgröße
|
|
|
for (int i1 = 0; i1 < zeichA_tmp; ++i1)
|
|
|
zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
|
|
|
- sgKpf_tmp->speichern(outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
+ sgKpf_tmp->speichern(outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
int beginByte
|
|
|
- = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
- // Schriftgröße in neue Datei kopieren
|
|
|
+ = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
+ // Schriftgröße in neue Datei kopieren
|
|
|
int endByte = sgPosList[i + 1];
|
|
|
if (!endByte)
|
|
|
{
|
|
|
@@ -2360,7 +2360,7 @@ void LTDSDatei::addSchriftgr
|
|
|
}
|
|
|
sgKpf_tmp->release();
|
|
|
}
|
|
|
- inF->close(); // Alte datei schließen
|
|
|
+ inF->close(); // Alte datei schließen
|
|
|
sgPosList[sganzahl] = (int)outF->tellp();
|
|
|
outF->seekp(0, std::ios::beg);
|
|
|
for (int i = 0; i < sganzahl; ++i) // Positionen im Dateikopf aktualisieren
|
|
|
@@ -2368,10 +2368,10 @@ void LTDSDatei::addSchriftgr
|
|
|
dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
|
|
|
outF->seekp(sgPosList[sganzahl], std::ios::beg);
|
|
|
LTDSSchriftKopf* sgkopf
|
|
|
- = new LTDSSchriftKopf(); // Kopf der neuen Schriftgröße
|
|
|
+ = new LTDSSchriftKopf(); // Kopf der neuen Schriftgröße
|
|
|
sgkopf->setZeichenAlphabet(dynamic_cast<Alphabet*>(
|
|
|
- alphabet->getThis())); // Kopf der Schriftgröße initialisieren
|
|
|
- sgkopf->speichern(outF); // Kopf der Schriftgröße speichern
|
|
|
+ alphabet->getThis())); // Kopf der Schriftgröße initialisieren
|
|
|
+ sgkopf->speichern(outF); // Kopf der Schriftgröße speichern
|
|
|
int* BuchstabenPosList
|
|
|
= sgkopf->getPositionen(); // positionen der verschiedenen Zeichen in
|
|
|
// der Datei( nuch 0 )
|
|
|
@@ -2387,23 +2387,23 @@ void LTDSDatei::addSchriftgr
|
|
|
= new LTDSBuchstabenKopf(); // Zeichenkopf
|
|
|
zeichKpf->init(i, zeich->getBreite(), zeich->getHeight());
|
|
|
zeichKpf->speichern(outF); // Zeichenkopf speichern
|
|
|
- LTDSBuchstabenKörper* zeichKörp
|
|
|
- = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
- zeichKpf->getThis())); // Zeichenkörper
|
|
|
+ LTDSBuchstabenKörper* zeichKörp
|
|
|
+ = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
+ zeichKpf->getThis())); // Zeichenkörper
|
|
|
zeichKpf->release();
|
|
|
- zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
- zeichKörp->speichern(outF); // Zeichenkörper speichern
|
|
|
+ zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
+ zeichKörp->speichern(outF); // Zeichenkörper speichern
|
|
|
zeich->release();
|
|
|
++count;
|
|
|
}
|
|
|
}
|
|
|
outF->seekp(sgPosList[sganzahl], std::ios::beg);
|
|
|
- sgkopf->speichern(outF); // aktualisierter Schriftgrößen Kopf speichern
|
|
|
+ sgkopf->speichern(outF); // aktualisierter Schriftgrößen Kopf speichern
|
|
|
outF->close();
|
|
|
Text* pfad2 = new Text();
|
|
|
pfad2->setText(pfad->getText());
|
|
|
pfad->remove(pfad->getLength() - 1, pfad->getLength());
|
|
|
- DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte datei Löschen
|
|
|
+ DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte datei Löschen
|
|
|
DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
|
|
|
dynamic_cast<Text*>(
|
|
|
pfad->getThis())); // neue Datei nach alte umbenennen
|
|
|
@@ -2416,27 +2416,27 @@ void LTDSDatei::addSchriftgr
|
|
|
|
|
|
void LTDSDatei::addBuchstabe(int gr,
|
|
|
Buchstabe* zeich,
|
|
|
- unsigned char zeichen) // Fügt einer Schriftgröße einen Buchstaben hinzu
|
|
|
+ unsigned char zeichen) // Fügt einer Schriftgröße einen Buchstaben hinzu
|
|
|
{
|
|
|
if (!DateiExistiert(
|
|
|
- dynamic_cast<Text*>(pfad->getThis()))) // prüfen ob Datei existiert
|
|
|
+ dynamic_cast<Text*>(pfad->getThis()))) // prüfen ob Datei existiert
|
|
|
{
|
|
|
zeich->release();
|
|
|
return;
|
|
|
}
|
|
|
- if (!dateiKopf) // prüfen, ob der DAteikopf geladen wurde
|
|
|
+ if (!dateiKopf) // prüfen, ob der DAteikopf geladen wurde
|
|
|
leseDaten();
|
|
|
unsigned char* sgList
|
|
|
= dateiKopf
|
|
|
- ->getSchriftGrößeList(); // Liste mit Schriftgrößen aus der Datei
|
|
|
- int* sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgrößen
|
|
|
+ ->getSchriftGrößeList(); // Liste mit Schriftgrößen aus der Datei
|
|
|
+ int* sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgrößen
|
|
|
// positionen aus Datei
|
|
|
unsigned char sgAnzahl
|
|
|
- = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl von Schriftgrößen aus
|
|
|
+ = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl von Schriftgrößen aus
|
|
|
// der Datei
|
|
|
int sgNum = -1;
|
|
|
for (int i = 0; i < sgAnzahl;
|
|
|
- ++i) // Position der richtigen Schriftgröße ermitteln
|
|
|
+ ++i) // Position der richtigen Schriftgröße ermitteln
|
|
|
{
|
|
|
if (sgList[i] == gr)
|
|
|
{
|
|
|
@@ -2450,34 +2450,34 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
std::ofstream* outF
|
|
|
= new std::ofstream(pfad->getText(), std::ios::binary); // Neue Datei
|
|
|
inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
|
|
|
- if (sgNum == -1) // Die Schriftgröße existiert noch nicht und wird erstellt
|
|
|
+ if (sgNum == -1) // Die Schriftgröße existiert noch nicht und wird erstellt
|
|
|
{
|
|
|
- dateiKopf->addSG(gr); // Schriftgröße dem Dateikopf hinzufügen
|
|
|
+ dateiKopf->addSG(gr); // Schriftgröße dem Dateikopf hinzufügen
|
|
|
sgPosList = dateiKopf->getPositionList();
|
|
|
- sgList = dateiKopf->getSchriftGrößeList();
|
|
|
+ sgList = dateiKopf->getSchriftGrößeList();
|
|
|
dateiKopf->speichern(outF); // Dateikopf speichern
|
|
|
inF->seekg(
|
|
|
1 + 5 * sgAnzahl, std::ios::beg); // Position der ersten
|
|
|
- // Schriftgröße in der alten Datei
|
|
|
+ // Schriftgröße in der alten Datei
|
|
|
for (int i = 0; i < sgAnzahl;
|
|
|
- ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
|
|
|
+ ++i) // Buchstabenpositionen aller Schriftgrößen aktualisieren
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf_tmp
|
|
|
- = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
sgKpf_tmp->laden(inF); // aus alter Datei laden
|
|
|
int* zeichP_tmp
|
|
|
= sgKpf_tmp
|
|
|
- ->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
+ ->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
unsigned char zeichA_tmp
|
|
|
= sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
|
|
|
- // Schriftgröße
|
|
|
+ // Schriftgröße
|
|
|
for (int i1 = 0; i1 < zeichA_tmp; ++i1)
|
|
|
zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
|
|
|
sgKpf_tmp->speichern(
|
|
|
- outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
+ outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
int beginByte
|
|
|
- = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
- // Schriftgröße in neue Datei kopieren
|
|
|
+ = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
+ // Schriftgröße in neue Datei kopieren
|
|
|
int endByte = sgPosList[i + 1];
|
|
|
if (i + 1 >= sgAnzahl)
|
|
|
{
|
|
|
@@ -2501,39 +2501,39 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
|
|
|
outF->seekp(sgPosList[sgAnzahl], std::ios::beg);
|
|
|
LTDSSchriftKopf* sgKpf
|
|
|
- = new LTDSSchriftKopf(); // Schriftgröße Kopf initialisiern
|
|
|
- sgKpf->setSchriftgröße(gr);
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgröße Kopf initialisiern
|
|
|
+ sgKpf->setSchriftgröße(gr);
|
|
|
sgKpf->addZeichen(zeichen);
|
|
|
sgKpf->getPositionen()[0] = (int)outF->tellp() + 7;
|
|
|
- sgKpf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
+ sgKpf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
sgKpf->release();
|
|
|
LTDSBuchstabenKopf* zeichKpf
|
|
|
= new LTDSBuchstabenKopf(); // Buchstabenkopf
|
|
|
zeichKpf->init(zeichen, zeich->getSize());
|
|
|
zeichKpf->speichern(outF); // Buchstabenkopf speichern
|
|
|
- LTDSBuchstabenKörper* zeichKörp
|
|
|
- = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
- zeichKpf->getThis())); // Buchstabenkörper
|
|
|
+ LTDSBuchstabenKörper* zeichKörp
|
|
|
+ = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
+ zeichKpf->getThis())); // Buchstabenkörper
|
|
|
zeichKpf->release();
|
|
|
- zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
- zeichKörp->speichern(outF); // Buchstabenkörper speichern
|
|
|
- zeichKörp->release();
|
|
|
+ zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
+ zeichKörp->speichern(outF); // Buchstabenkörper speichern
|
|
|
+ zeichKörp->release();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
dateiKopf->speichern(outF); // Dateikopf speichern
|
|
|
int beginByte
|
|
|
- = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur nächsten
|
|
|
- // Schriftgröße in neue Datei kopieren
|
|
|
+ = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur nächsten
|
|
|
+ // Schriftgröße in neue Datei kopieren
|
|
|
int endByte = sgPosList[sgNum];
|
|
|
char byte;
|
|
|
for (int i1 = beginByte; i1 < endByte;
|
|
|
- ++i1) // Kopiervorgang bis zur angegebenen größe
|
|
|
+ ++i1) // Kopiervorgang bis zur angegebenen größe
|
|
|
{
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
}
|
|
|
- LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf
|
|
|
+ LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf(); // Schriftgröße Kopf
|
|
|
sgKpf->laden(inF);
|
|
|
for (int i = 0; i < sgKpf->getZeichenAnzahl(); ++i)
|
|
|
sgKpf->getPositionen()[i] += 5;
|
|
|
@@ -2549,7 +2549,7 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
}
|
|
|
zeichenPos += indexPlus;
|
|
|
sgKpf->getPositionen()[sgKpf->getZeichenAnzahl() - 1] = zeichenPos;
|
|
|
- sgKpf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
+ sgKpf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
sgKpf->release();
|
|
|
for (int i = (int)inF->tellg() + indexPlus; i < zeichenPos;
|
|
|
++i) // Kopiervorgang bis zum Zeichenbeginn
|
|
|
@@ -2560,13 +2560,13 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
|
|
|
zeichKpf->init(zeichen, zeich->getSize());
|
|
|
zeichKpf->speichern(outF); // Zeichenkopf speichern
|
|
|
- LTDSBuchstabenKörper* zeichKörp
|
|
|
- = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
- zeichKpf->getThis())); // Zeichenkörper
|
|
|
+ LTDSBuchstabenKörper* zeichKörp
|
|
|
+ = new LTDSBuchstabenKörper(dynamic_cast<LTDSBuchstabenKopf*>(
|
|
|
+ zeichKpf->getThis())); // Zeichenkörper
|
|
|
zeichKpf->release();
|
|
|
- zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
- zeichKörp->speichern(outF); // Zeichenkörper speichern
|
|
|
- zeichKörp->release();
|
|
|
+ zeichKörp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
|
|
|
+ zeichKörp->speichern(outF); // Zeichenkörper speichern
|
|
|
+ zeichKörp->release();
|
|
|
int nowPos = (int)outF->tellp();
|
|
|
indexPlus += nowPos - zeichenPos;
|
|
|
for (int i = sgNum + 1; i < sgAnzahl; ++i) // Dateikopf aktualisieren
|
|
|
@@ -2575,25 +2575,25 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
dateiKopf->speichern(outF); // Dateikopf speichern
|
|
|
outF->seekp(nowPos, std::ios::beg);
|
|
|
for (int i = sgNum + 1; i < sgAnzahl;
|
|
|
- ++i) // Restliche Schriftgrößen aktualisieren
|
|
|
+ ++i) // Restliche Schriftgrößen aktualisieren
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf_tmp
|
|
|
- = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
sgKpf_tmp->laden(inF); // aus alter Datei laden
|
|
|
int* zeichP_tmp
|
|
|
= sgKpf_tmp
|
|
|
- ->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
+ ->getPositionen(); // Zeichenpositionen der Schriftgröße
|
|
|
unsigned char zeichA_tmp
|
|
|
= sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
|
|
|
- // Schriftgröße
|
|
|
+ // Schriftgröße
|
|
|
for (int i1 = 0; i1 < zeichA_tmp; ++i1)
|
|
|
zeichP_tmp[i1]
|
|
|
+= indexPlus; // Buchstabenpositionen aktualisieren
|
|
|
sgKpf_tmp->speichern(
|
|
|
- outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
+ outF); // Schriftgröße Kopf in neue Datei speichern
|
|
|
int beginByte
|
|
|
- = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
- // Schriftgröße in neue Datei kopieren
|
|
|
+ = (int)inF->tellg(); // Die restlichen bytes bis zur nächsten
|
|
|
+ // Schriftgröße in neue Datei kopieren
|
|
|
int endByte = sgPosList[i + 1];
|
|
|
if (i + 1 >= sgAnzahl)
|
|
|
{
|
|
|
@@ -2614,7 +2614,7 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
outF->close();
|
|
|
Text* pfad2 = new Text(pfad->getText());
|
|
|
pfad->remove(pfad->getLength() - 1, pfad->getLength());
|
|
|
- DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte Datei löschen
|
|
|
+ DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // Alte Datei löschen
|
|
|
DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
|
|
|
dynamic_cast<Text*>(pfad->getThis())); // Neue Datei in alte umbenennen
|
|
|
pfad2->release(); // Speicher freigeben
|
|
|
@@ -2623,20 +2623,20 @@ void LTDSDatei::addBuchstabe(int gr,
|
|
|
zeich->release();
|
|
|
}
|
|
|
|
|
|
-void LTDSDatei::löscheSchrifrGröße(
|
|
|
- int gr) // Löscht eine Schriftgröße aus der Datei
|
|
|
+void LTDSDatei::löscheSchrifrGröße(
|
|
|
+ int gr) // Löscht eine Schriftgröße aus der Datei
|
|
|
{
|
|
|
if (!DateiExistiert(
|
|
|
- dynamic_cast<Text*>(pfad->getThis()))) // prüfen, ob Datei existiert
|
|
|
+ dynamic_cast<Text*>(pfad->getThis()))) // prüfen, ob Datei existiert
|
|
|
return;
|
|
|
- if (!dateiKopf) // prüfen, ob der Dateikopf geladen wurde
|
|
|
+ if (!dateiKopf) // prüfen, ob der Dateikopf geladen wurde
|
|
|
leseDaten();
|
|
|
unsigned char* sgList
|
|
|
- = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
|
|
|
unsigned char sgAnzahl
|
|
|
- = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
|
|
|
int sgNum = -1;
|
|
|
- for (int i = 0; i < sgAnzahl; ++i) // zu löschende Schriftgröße suchen
|
|
|
+ for (int i = 0; i < sgAnzahl; ++i) // zu löschende Schriftgröße suchen
|
|
|
{
|
|
|
if (sgList[i] == gr)
|
|
|
{
|
|
|
@@ -2644,11 +2644,11 @@ void LTDSDatei::l
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
- if (sgNum == -1) // Die Schriftgröße ist nicht vorhanden
|
|
|
+ if (sgNum == -1) // Die Schriftgröße ist nicht vorhanden
|
|
|
return;
|
|
|
int* sgPosList
|
|
|
= dateiKopf
|
|
|
- ->getPositionList(); // Liste von Positionen der Schriftgrößen
|
|
|
+ ->getPositionList(); // Liste von Positionen der Schriftgrößen
|
|
|
std::ifstream* inF
|
|
|
= new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
|
|
|
pfad->append("0");
|
|
|
@@ -2657,21 +2657,21 @@ void LTDSDatei::l
|
|
|
outF->seekp(1 + 5 * (sgAnzahl - 1), std::ios::beg);
|
|
|
inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
|
|
|
for (int i = 0; i < sgNum;
|
|
|
- ++i) // Schriftgrößen vor der zu löschenden Schriftgröße aktualisieren
|
|
|
+ ++i) // Schriftgrößen vor der zu löschenden Schriftgröße aktualisieren
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf_tmp
|
|
|
- = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
- sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
+ sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
|
|
|
int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
|
|
|
unsigned char zeichATmp
|
|
|
= sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
|
|
|
for (int i1 = 0; i1 < zeichATmp;
|
|
|
- ++i1) // Position der Zeichen um 5 bytes zurücksetzen
|
|
|
+ ++i1) // Position der Zeichen um 5 bytes zurücksetzen
|
|
|
zeichPosLTmp[i1] -= 5;
|
|
|
sgKpf_tmp->speichern(outF); // speichern in Neue Datei
|
|
|
char byte = 0;
|
|
|
for (int i1 = (int)inF->tellg(); i1 < sgPosList[i + 1];
|
|
|
- ++i1) // Den Körper des Zeichens Kopieren
|
|
|
+ ++i1) // Den Körper des Zeichens Kopieren
|
|
|
{
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
@@ -2681,11 +2681,11 @@ void LTDSDatei::l
|
|
|
int indexMinus = 5 + sgPosList[sgNum + 1] - (int)inF->tellg();
|
|
|
inF->seekg(sgPosList[sgNum + 1], std::ios::beg);
|
|
|
for (int i = sgNum + 1; i < sgAnzahl;
|
|
|
- ++i) // Die Schriftgröße nach der zu löschenden Schriftgröße
|
|
|
+ ++i) // Die Schriftgröße nach der zu löschenden Schriftgröße
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf_tmp
|
|
|
- = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
- sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
|
|
|
+ = new LTDSSchriftKopf(); // Schriftgrößen Kopf
|
|
|
+ sgKpf_tmp->laden(inF); // Schriftgrößen Kopf laden
|
|
|
int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
|
|
|
unsigned char zeichATmp
|
|
|
= sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
|
|
|
@@ -2703,7 +2703,7 @@ void LTDSDatei::l
|
|
|
inF->seekg(BeginByte, std::ios::beg);
|
|
|
}
|
|
|
for (int i1 = BeginByte; i1 < EndByte;
|
|
|
- ++i1) // Den Körper des Zeichens Kopieren
|
|
|
+ ++i1) // Den Körper des Zeichens Kopieren
|
|
|
{
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
@@ -2720,7 +2720,7 @@ void LTDSDatei::l
|
|
|
outF->close();
|
|
|
Text* pfad2 = new Text(pfad->getText());
|
|
|
pfad->remove(pfad->getLength() - 1, pfad->getLength());
|
|
|
- DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
|
|
|
+ DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
|
|
|
DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
|
|
|
dynamic_cast<Text*>(pfad->getThis())); // neue Datei zu alter umbenennen
|
|
|
pfad2->release();
|
|
|
@@ -2728,23 +2728,23 @@ void LTDSDatei::l
|
|
|
delete outF;
|
|
|
}
|
|
|
|
|
|
-void LTDSDatei::löscheBuchstabe(
|
|
|
- int gr, unsigned char zeichen) // Löscht einen Buchstaben aus der Datei
|
|
|
+void LTDSDatei::löscheBuchstabe(
|
|
|
+ int gr, unsigned char zeichen) // Löscht einen Buchstaben aus der Datei
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(
|
|
|
- pfad->getThis()))) // prüfen, ob die Datei existiert
|
|
|
+ pfad->getThis()))) // prüfen, ob die Datei existiert
|
|
|
return;
|
|
|
- if (!dateiKopf) // prüfen, ob der Dateikopf gelesen wurde
|
|
|
+ if (!dateiKopf) // prüfen, ob der Dateikopf gelesen wurde
|
|
|
leseDaten();
|
|
|
unsigned char* sgList
|
|
|
- = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeList(); // Liste mit Schriftgrößen
|
|
|
unsigned char sgAnzahl
|
|
|
- = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
|
|
|
+ = dateiKopf->getSchriftGrößeAnzahl(); // Anzahl der Schriftgrößen
|
|
|
int* sgPosList
|
|
|
= dateiKopf
|
|
|
- ->getPositionList(); // Liste mit Positionen der Schriftgrößen
|
|
|
+ ->getPositionList(); // Liste mit Positionen der Schriftgrößen
|
|
|
int sgNum = -1;
|
|
|
- for (int i = 0; i < sgAnzahl; ++i) // Schriftgröße suchen
|
|
|
+ for (int i = 0; i < sgAnzahl; ++i) // Schriftgröße suchen
|
|
|
{
|
|
|
if (sgList[i] == gr)
|
|
|
{
|
|
|
@@ -2752,7 +2752,7 @@ void LTDSDatei::l
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
- if (sgNum == -1) // Schriftgröße nicht gefunden
|
|
|
+ if (sgNum == -1) // Schriftgröße nicht gefunden
|
|
|
return;
|
|
|
std::ifstream* inF
|
|
|
= new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
|
|
|
@@ -2770,7 +2770,7 @@ void LTDSDatei::l
|
|
|
= sgKopf->getZeichenAnzahl(); // Zeichenanzahl
|
|
|
unsigned char* sgZeichenList = sgKopf->getZeichen(); // Zeichen Liste
|
|
|
int* sgZPosList = sgKopf->getPositionen(); // Positions Liste
|
|
|
- if (i == sgNum) // Zeichen befindet sich in dieser Schriftgröße
|
|
|
+ if (i == sgNum) // Zeichen befindet sich in dieser Schriftgröße
|
|
|
{
|
|
|
int sgZNum = -1;
|
|
|
for (int i1 = 0; i1 < sgZeichAnzahl; ++i1) // Zeichen suchen
|
|
|
@@ -2795,7 +2795,7 @@ void LTDSDatei::l
|
|
|
outF->seekp(2 + 5 * (sgZeichAnzahl - 1), std::ios::cur);
|
|
|
indexMinus += 5;
|
|
|
for (int i1 = 0; i1 < sgZNum;
|
|
|
- ++i1) // Zeichen vor dem zu löschenden Zeichen
|
|
|
+ ++i1) // Zeichen vor dem zu löschenden Zeichen
|
|
|
{
|
|
|
char byte = 0;
|
|
|
for (int i2 = sgZPosList[i1]; i2 < sgZPosList[i1 + 1];
|
|
|
@@ -2804,7 +2804,7 @@ void LTDSDatei::l
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
}
|
|
|
- sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
|
|
|
+ sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
|
|
|
}
|
|
|
if (!sgZPosList[sgZNum + 1])
|
|
|
{
|
|
|
@@ -2823,7 +2823,7 @@ void LTDSDatei::l
|
|
|
if (sgZNum + 1 < sgZeichAnzahl)
|
|
|
inF->seekg(sgZPosList[sgZNum + 1], std::ios::beg);
|
|
|
for (int i1 = sgZNum + 1; i1 < sgZeichAnzahl;
|
|
|
- ++i1) // Zeichen nach dem gelöschten Zeichen
|
|
|
+ ++i1) // Zeichen nach dem gelöschten Zeichen
|
|
|
{
|
|
|
int beginByte = (int)inF->tellg();
|
|
|
int endByte = sgZPosList[i1 + 1];
|
|
|
@@ -2839,16 +2839,16 @@ void LTDSDatei::l
|
|
|
inF->read(&byte, 1);
|
|
|
outF->write(&byte, 1);
|
|
|
}
|
|
|
- sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
|
|
|
+ sgZPosList[i1] -= indexMinus; // Schriftgröße Kopf aktualisieren
|
|
|
}
|
|
|
sgKopf->removeZeichen(zeichen);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
for (int i1 = 0; i1 < sgZeichAnzahl;
|
|
|
- ++i1) // Schriftgröße Kopf aktualisieren
|
|
|
+ ++i1) // Schriftgröße Kopf aktualisieren
|
|
|
sgZPosList[i] -= indexMinus;
|
|
|
- sgKopf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
+ sgKopf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
int beginByte = (int)inF->tellg();
|
|
|
int endByte = sgPosList[i + 1];
|
|
|
if (!endByte)
|
|
|
@@ -2866,7 +2866,7 @@ void LTDSDatei::l
|
|
|
sgPosList[i] -= indexMinus;
|
|
|
}
|
|
|
outF->seekp(sgPosList[i], std::ios::beg);
|
|
|
- sgKopf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
+ sgKopf->speichern(outF); // Schriftgröße Kopf speichern
|
|
|
outF->seekp(sgPosList[i + 1], std::ios::beg);
|
|
|
sgKopf->release();
|
|
|
}
|
|
|
@@ -2874,7 +2874,7 @@ void LTDSDatei::l
|
|
|
outF->close();
|
|
|
Text* pfad2 = new Text(pfad->getText());
|
|
|
pfad->remove(pfad->getLength() - 1, pfad->getLength());
|
|
|
- DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
|
|
|
+ DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei löschen
|
|
|
DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
|
|
|
dynamic_cast<Text*>(
|
|
|
pfad->getThis())); // neue Datei nach alte umbenennen
|
|
|
@@ -2883,7 +2883,7 @@ void LTDSDatei::l
|
|
|
delete outF;
|
|
|
}
|
|
|
|
|
|
-void LTDSDatei::löscheDatei() // Löscht die gesamte Datei
|
|
|
+void LTDSDatei::löscheDatei() // Löscht die gesamte Datei
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
|
|
|
if (!dateiKopf) leseDaten();
|
|
|
@@ -2902,14 +2902,14 @@ void LTDSDatei::erstelleDatei() // erstellt die Datei
|
|
|
}
|
|
|
|
|
|
void LTDSDatei::speicherSchrift(
|
|
|
- Schrift* schrift) // Speichert die übergebene Schrift
|
|
|
+ Schrift* schrift) // Speichert die übergebene Schrift
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
|
|
|
{
|
|
|
schrift->release();
|
|
|
return;
|
|
|
}
|
|
|
- löscheDatei();
|
|
|
+ löscheDatei();
|
|
|
if (dateiKopf) dateiKopf->release();
|
|
|
dateiKopf = new LTDSDateiKopf();
|
|
|
for (int i = 0; i < 256; ++i)
|
|
|
@@ -2941,12 +2941,12 @@ void LTDSDatei::speicherSchrift(
|
|
|
zeichen->getBreite(),
|
|
|
zeichen->getHeight());
|
|
|
zeichKpf->speichern(outF);
|
|
|
- LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
|
|
|
+ LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
|
|
|
dynamic_cast<LTDSBuchstabenKopf*>(zeichKpf->getThis()));
|
|
|
- zeichKörp->setBuchstabe(
|
|
|
+ zeichKörp->setBuchstabe(
|
|
|
dynamic_cast<Buchstabe*>(zeichen->getThis()));
|
|
|
- zeichKörp->speichern(outF);
|
|
|
- zeichKörp->release();
|
|
|
+ zeichKörp->speichern(outF);
|
|
|
+ zeichKörp->release();
|
|
|
zeichen->release();
|
|
|
zeichKpf->release();
|
|
|
}
|
|
|
@@ -2966,29 +2966,29 @@ void LTDSDatei::speicherSchrift(
|
|
|
}
|
|
|
|
|
|
// constant
|
|
|
-Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurück
|
|
|
+Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
Schrift* ret = new Schrift();
|
|
|
std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
|
|
|
inF->seekg(dateiKopf->getPositionList()[0], std::ios::beg);
|
|
|
- for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
+ for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
{
|
|
|
LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
|
|
|
sgKpf->laden(inF);
|
|
|
Alphabet* alphabet = new Alphabet();
|
|
|
- alphabet->setSchriftSize(sgKpf->getSchriftGröße());
|
|
|
+ alphabet->setSchriftSize(sgKpf->getSchriftGröße());
|
|
|
for (int i1 = 0; i1 < sgKpf->getZeichenAnzahl(); ++i1)
|
|
|
{
|
|
|
LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf();
|
|
|
zeichKpf->laden(inF);
|
|
|
- LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
|
|
|
+ LTDSBuchstabenKörper* zeichKörp = new LTDSBuchstabenKörper(
|
|
|
dynamic_cast<LTDSBuchstabenKopf*>(zeichKpf->getThis()));
|
|
|
- zeichKörp->laden(inF);
|
|
|
+ zeichKörp->laden(inF);
|
|
|
alphabet->setBuchstabe(
|
|
|
- zeichKpf->getZeichen(), zeichKörp->getBuchstabe());
|
|
|
- zeichKörp->release();
|
|
|
+ zeichKpf->getZeichen(), zeichKörp->getBuchstabe());
|
|
|
+ zeichKörp->release();
|
|
|
zeichKpf->release();
|
|
|
}
|
|
|
ret->addAlphabet(dynamic_cast<Alphabet*>(alphabet->getThis()));
|
|
|
@@ -3001,16 +3001,16 @@ Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zur
|
|
|
}
|
|
|
|
|
|
Alphabet* LTDSDatei::ladeAlphabet(
|
|
|
- int schriftgröße) // gibt eine geladene Schrift nur mit der angegebenen
|
|
|
- // Schriftgröße zurück
|
|
|
+ int schriftgröße) // gibt eine geladene Schrift nur mit der angegebenen
|
|
|
+ // Schriftgröße zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
Alphabet* ret = 0;
|
|
|
int sgNum = -1;
|
|
|
- for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
+ for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
{
|
|
|
- if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
|
|
|
+ if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
|
|
|
{
|
|
|
sgNum = i;
|
|
|
break;
|
|
|
@@ -3019,7 +3019,7 @@ Alphabet* LTDSDatei::ladeAlphabet(
|
|
|
if (sgNum == -1) return 0;
|
|
|
ret = new Alphabet();
|
|
|
ret->NeuAlphabet();
|
|
|
- ret->setSchriftSize(schriftgröße);
|
|
|
+ ret->setSchriftSize(schriftgröße);
|
|
|
std::ifstream* inF = new std::ifstream(pfad->getText(), std::ios::binary);
|
|
|
inF->seekg(dateiKopf->getPositionList()[sgNum], std::ios::beg);
|
|
|
LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf();
|
|
|
@@ -3028,11 +3028,11 @@ Alphabet* LTDSDatei::ladeAlphabet(
|
|
|
{
|
|
|
LTDSBuchstabenKopf* sgZKpf = new LTDSBuchstabenKopf();
|
|
|
sgZKpf->laden(inF);
|
|
|
- LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
|
|
|
+ LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
|
|
|
dynamic_cast<LTDSBuchstabenKopf*>(sgZKpf->getThis()));
|
|
|
- sgZKörp->laden(inF);
|
|
|
- ret->setBuchstabe(sgZKpf->getZeichen(), sgZKörp->getBuchstabe());
|
|
|
- sgZKörp->release();
|
|
|
+ sgZKörp->laden(inF);
|
|
|
+ ret->setBuchstabe(sgZKpf->getZeichen(), sgZKörp->getBuchstabe());
|
|
|
+ sgZKörp->release();
|
|
|
sgZKpf->release();
|
|
|
}
|
|
|
sgKpf->release();
|
|
|
@@ -3042,15 +3042,15 @@ Alphabet* LTDSDatei::ladeAlphabet(
|
|
|
}
|
|
|
|
|
|
Buchstabe* LTDSDatei::ladeBuchstabe(
|
|
|
- int schriftgröße, unsigned char zeichen) // Läd einen bestimmten Buchstaben
|
|
|
+ int schriftgröße, unsigned char zeichen) // Läd einen bestimmten Buchstaben
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
Buchstabe* ret = 0;
|
|
|
int sgNum = -1;
|
|
|
- for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
+ for (int i = 0; i < dateiKopf->getSchriftGrößeAnzahl(); ++i)
|
|
|
{
|
|
|
- if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
|
|
|
+ if (dateiKopf->getSchriftGrößeList()[i] == schriftgröße)
|
|
|
{
|
|
|
sgNum = i;
|
|
|
break;
|
|
|
@@ -3075,11 +3075,11 @@ Buchstabe* LTDSDatei::ladeBuchstabe(
|
|
|
inF->seekg(sgKpf->getPositionen()[sgZNum], std::ios::beg);
|
|
|
LTDSBuchstabenKopf* sgZKpf = new LTDSBuchstabenKopf();
|
|
|
sgZKpf->laden(inF);
|
|
|
- LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
|
|
|
+ LTDSBuchstabenKörper* sgZKörp = new LTDSBuchstabenKörper(
|
|
|
dynamic_cast<LTDSBuchstabenKopf*>(sgZKpf->getThis()));
|
|
|
- sgZKörp->laden(inF);
|
|
|
- ret = sgZKörp->getBuchstabe();
|
|
|
- sgZKörp->release();
|
|
|
+ sgZKörp->laden(inF);
|
|
|
+ ret = sgZKörp->getBuchstabe();
|
|
|
+ sgZKörp->release();
|
|
|
sgZKpf->release();
|
|
|
}
|
|
|
sgKpf->release();
|
|
|
@@ -3087,45 +3087,45 @@ Buchstabe* LTDSDatei::ladeBuchstabe(
|
|
|
delete inF;
|
|
|
if (ret)
|
|
|
{
|
|
|
- ret->setSchriftSize(schriftgröße);
|
|
|
+ ret->setSchriftSize(schriftgröße);
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
-Text* LTDSDatei::getPfad() const // gibt den Dateipfad zurück
|
|
|
+Text* LTDSDatei::getPfad() const // gibt den Dateipfad zurück
|
|
|
{
|
|
|
return dynamic_cast<Text*>(pfad->getThis());
|
|
|
}
|
|
|
|
|
|
-int LTDSDatei::getAnzahlSchriftgrößen()
|
|
|
- const // gibt die Anzahl der Schriftgrößen aus der Datei zurück
|
|
|
+int LTDSDatei::getAnzahlSchriftgrößen()
|
|
|
+ const // gibt die Anzahl der Schriftgrößen aus der Datei zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
- return dateiKopf->getSchriftGrößeAnzahl();
|
|
|
+ return dateiKopf->getSchriftGrößeAnzahl();
|
|
|
}
|
|
|
|
|
|
unsigned char*
|
|
|
-LTDSDatei::getSchriftGrößen() const // gibt einen Array von Schriftgrößen zurück
|
|
|
+LTDSDatei::getSchriftGrößen() const // gibt einen Array von Schriftgrößen zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
- return dateiKopf->getSchriftGrößeList();
|
|
|
+ return dateiKopf->getSchriftGrößeList();
|
|
|
}
|
|
|
|
|
|
unsigned char LTDSDatei::getAnzahlBuchstaben(
|
|
|
- int sg) // gibt die anzahl gespeicherter Buchstaben einer Schriftgröße
|
|
|
- // zurück
|
|
|
+ int sg) // gibt die anzahl gespeicherter Buchstaben einer Schriftgröße
|
|
|
+ // zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
int ret = 0;
|
|
|
- unsigned char* größen = dateiKopf->getSchriftGrößeList();
|
|
|
- unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
|
|
|
+ unsigned char* größen = dateiKopf->getSchriftGrößeList();
|
|
|
+ unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
|
|
|
int grpos = -1;
|
|
|
for (int i = 0; i < granzahl; ++i)
|
|
|
{
|
|
|
- if (größen[i] == sg)
|
|
|
+ if (größen[i] == sg)
|
|
|
{
|
|
|
grpos = i;
|
|
|
break;
|
|
|
@@ -3148,17 +3148,17 @@ unsigned char LTDSDatei::getAnzahlBuchstaben(
|
|
|
}
|
|
|
|
|
|
unsigned char* LTDSDatei::getBuchstaben(
|
|
|
- int sg) // gibt einen Array von Buchstaben einer Schriftgröße zurück
|
|
|
+ int sg) // gibt einen Array von Buchstaben einer Schriftgröße zurück
|
|
|
{
|
|
|
if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
|
|
|
if (!dateiKopf) return 0;
|
|
|
unsigned char* ret = 0;
|
|
|
- unsigned char* größen = dateiKopf->getSchriftGrößeList();
|
|
|
- unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
|
|
|
+ unsigned char* größen = dateiKopf->getSchriftGrößeList();
|
|
|
+ unsigned char granzahl = dateiKopf->getSchriftGrößeAnzahl();
|
|
|
int grpos = -1;
|
|
|
for (int i = 0; i < granzahl; ++i)
|
|
|
{
|
|
|
- if (größen[i] == sg)
|
|
|
+ if (größen[i] == sg)
|
|
|
{
|
|
|
grpos = i;
|
|
|
break;
|
|
|
@@ -3184,7 +3184,7 @@ unsigned char* LTDSDatei::getBuchstaben(
|
|
|
}
|
|
|
#endif
|
|
|
// Bit Funktionen
|
|
|
-int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zurück
|
|
|
+int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zurück
|
|
|
{
|
|
|
int ret = 0;
|
|
|
for (int i = 0; i < a; ++i)
|
|
|
@@ -3195,7 +3195,7 @@ int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zur
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
-int Framework::getBits(char c) // gibt zurück, wie viele Bits c benötigt
|
|
|
+int Framework::getBits(char c) // gibt zurück, wie viele Bits c benötigt
|
|
|
{
|
|
|
int ret = 0;
|
|
|
for (int i = 0; (c & (char)Bits(i)) != c; ++i)
|