translate more comments to english

Datei.cpp

@@ -70,8 +70,7 @@ void Datei::setDatei(Text* pfad)
     gr = 0;
 }
 
-bool Datei::umbenennen(
-const char* pfad) // renames and possibly moves the file
+bool Datei::umbenennen(const char* pfad) // renames and possibly moves the file
 {
     if (!pfad) return 0;
     if (DateiUmbenennen(this->pfad->getText(), pfad))
@@ -255,7 +254,8 @@ void Datei::close() // closes the file
 }
 
 #ifdef WIN32
-bool Datei::setLetzteAEnderung(Zeit* zeit) // sets the modification date of the file
+bool Datei::setLetzteAEnderung(
+    Zeit* zeit) // sets the modification date of the file
 {
     if (!pfad)
     {
@@ -421,8 +421,7 @@ int Datei::getUnterdateiAnzahl() const // returns the number of sub-files
 #endif
 }
 
-RCArray<Text>*
-Datei::getDateiListe() const // returns a list of sub-files
+RCArray<Text>* Datei::getDateiListe() const // returns a list of sub-files
 {
 #ifdef WIN32
     if (!pfad) return 0;
@@ -594,8 +593,7 @@ void Framework::GetFreePfad(Text* zPfad) // Searches for an unused filename
     zPfad->setText(txt);
 }
 
-bool Framework::DateiPfadErstellen(
-Text* pfad) // Creates a file in the path
+bool Framework::DateiPfadErstellen(Text* pfad) // Creates a file in the path
 {
     bool ret = DateiPfadErstellen(pfad->getText());
     pfad->release();
@@ -610,7 +608,7 @@ bool Framework::DateiRemove(Text* pfad) // Deletes the specified file
 }
 
 bool Framework::DateiUmbenennen(
-Text* pfad_alt, Text* pfad_neu) // Renames the file
+    Text* pfad_alt, Text* pfad_neu) // Renames the file
 {
     bool ret = DateiUmbenennen(pfad_alt->getText(), pfad_neu->getText());
     pfad_alt->release();
@@ -626,7 +624,7 @@ bool Framework::DateiExistiert(Text* pfad) // Checks if the file exists
 }
 
 bool Framework::DateiIstVerzeichnis(
-Text* pfad) // checks if the path is a directory
+    Text* pfad) // checks if the path is a directory
 {
     bool ret = DateiIstVerzeichnis(pfad->getText());
     pfad->release();
@@ -634,7 +632,7 @@ Text* pfad) // checks if the path is a directory
 }
 
 bool Framework::DateiPfadErstellen(
-const char* pfad) // Creates a file in the path
+    const char* pfad) // Creates a file in the path
 {
     Text pf = pfad;
     bool erst = 1;
@@ -750,7 +748,7 @@ bool Framework::DateiRemove(const char* pfad) // Deletes the specified file
 }
 
 bool Framework::DateiUmbenennen(
-const char* pfad_alt, const char* pfad_neu) // Renames the file
+    const char* pfad_alt, const char* pfad_neu) // Renames the file
 {
 #ifdef WIN32
     if (pfad_alt && pfad_neu && DateiExistiert(pfad_alt))
@@ -842,7 +840,7 @@ bool Framework::DateiExistiert(const char* pfad) // Checks if the file exists
 }
 
 bool Framework::DateiIstVerzeichnis(
-const char* pfad) // checks if the path is a directory
+    const char* pfad) // checks if the path is a directory
 {
 #ifdef WIN32
     WIN32_FIND_DATA wfd;

DateiSystem.cpp

@@ -99,8 +99,8 @@ char LTDBPixel::addByte(
                 {
 #ifdef WIN32
                     MessageBox(NULL,
-                        "Fehler, die Bilddatei ist beschädigt",
-                        "Fehler",
+                        "Error, the image file is corrupted",
+                        "Error",
                         MB_ICONERROR);
 #endif
                     exit(0);
@@ -118,70 +118,67 @@ char LTDBPixel::addByte(
                 if (!changeA) A = davor->getA();
                 maxIndex = (char)(maxIndex
                                   + (changeR + changeG + changeB + changeA)
-                                        * (8 - komp)); // Bestimmung der Laenge
-                // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
-                // durch komprimierung kanns kleiner sein
+                                        * (8 - komp)); // Determine the length
+                // of the pixel in bits. Each color has 8 bits by default,
+                // compression can make it smaller
             }
             else
-                maxIndex = (char)(maxIndex + 7); // Da der Pixel nicht die Werte
-                                                 // des vorherigen uebernimmt,
-                                                 // wird er um 7 Bits groesser
-            break;
-        case 1:         // Das zweite Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+                maxIndex
+                    = (char)(maxIndex + 7); // Since the pixel doesn't inherit
+                                            // values from the previous one,
+                                            // it is 7 bits larger
+            break;
+        case 1:         // The second bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 changeR = (bool)((byte >> (7 - i)) & 0x1);
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 2:         // Das dritte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 2:         // The third bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 changeG = (bool)((byte >> (7 - i)) & 0x1);
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 3:         // Das vierte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 3:         // The fourth bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 changeB = (bool)((byte >> (7 - i)) & 0x1);
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 4:         // Das fuenfte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 4:         // The fifth bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 changeA = (bool)((byte >> (7 - i)) & 0x1);
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 5:         // Das sechste Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 5:         // The sixth bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 komp = (unsigned char)(komp
                                        | ((unsigned char)((byte >> (7 - i))
                                                           & 0x1)
@@ -190,15 +187,14 @@ char LTDBPixel::addByte(
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 6:         // Das siebte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 6:         // The seventh bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
                 komp = (unsigned char)(komp
                                        | ((unsigned char)((byte >> (7 - i))
                                                           & 0x1)
@@ -207,42 +203,41 @@ char LTDBPixel::addByte(
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        case 7:         // Das achte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (change) // Das Bit gehoert zu den 7 Komprimierungsbits
+        case 7:         // The eighth bit of a pixel stores either the
+                        // compression type or already the color
+            if (change) // The bit belongs to the 7 compression bits
             {
                 komp = (unsigned char)(komp | ((byte >> (7 - i)) & 0x1)) & 7;
-                // Das war das letzte Komprimierungsbit
-                // Komprimierung auswerten
+                // That was the last compression bit
+                // Evaluate compression
                 miR = (char)(miR - komp), miG = (char)(miG - komp),
                 miB = (char)(miB - komp), miA = (char)(miA - komp);
                 if (!changeR) R = davor->getR();
                 if (!changeG) G = davor->getG();
                 if (!changeB) B = davor->getB();
                 if (!changeA) A = davor->getA();
-                maxIndex = (char)(maxIndex
-                                  + (changeR + changeG + changeB + changeA)
-                                        * (8 - komp)); // Bitlaenge des Pixels
+                maxIndex
+                    = (char)(maxIndex
+                             + (changeR + changeG + changeB + changeA)
+                                   * (8 - komp)); // Bit length of the pixel
             }
             else
             {
                 if (!addBitZuFarbe(
-                        (unsigned char)(byte
-                                        >> (7
-                                            - i)))) // Das Bit gehoert zur Farbe
+                        (unsigned char)(byte >> (7 - i)))) // The bit belongs to
+                                                           // the color
                     return (unsigned char)i;
             }
             break;
-        default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
-            if (!addBitZuFarbe(
-                    (unsigned char)(byte
-                                    >> (7 - i)))) // Das Bit gehoert zur Farbe
+        default: // The remaining bits all store the color values of the pixel
+            if (!addBitZuFarbe((
+                    unsigned char)(byte
+                                   >> (7 - i)))) // The bit belongs to the color
                 return (unsigned char)i;
             break;
         }
@@ -263,27 +258,25 @@ char LTDBPixel::addByte(
     return -1;
 }
 
-void LTDBPixel::setFarbe(int f) // setzt die Farbe des Pixels
-{ // Da diese Funktion aufgerufen wird, moechte man die Klasse nun zum speichern
-  // verwenden
-    // Werte zuruecksetzen, fals mit der Klasse schon geladen oder gespeichert
-    // wurde
+void LTDBPixel::setFarbe(int f) // sets the color of the pixel
+{ // Since this function is called, the class is now to be used for saving
+    // Reset values in case the class was already used for loading or saving
     index = 0, maxIndex = 1;
     change = 0, changeR = 0, changeG = 0, changeB = 0, changeA = 0, komp = 0;
     iR = 0, iG = 0, iB = 0, iA = 0;
     miR = 8, miG = 8, miB = 8, miA = 8;
-    // Farbwerte setzen
+    // Set color values
     R = (unsigned char)(f >> 16);
     G = (unsigned char)(f >> 8);
     B = (unsigned char)f;
     A = (unsigned char)(f >> 24);
 }
 
-void LTDBPixel::komprimieren() // Komprimiert den Pixel
+void LTDBPixel::komprimieren() // Compresses the pixel
 {
     maxIndex = 1;
     if (!davor)
-    { // Das ist der erste Pixel
+    { // This is the first pixel
         change = 1;
         changeR = 1;
         changeG = 1;
@@ -296,7 +289,7 @@ void LTDBPixel::komprimieren() // Komprimiert den Pixel
         miA = (char)getBits(A);
     }
     else
-    { // Es wird die differenz zum vorrigen Pixel gespeichert
+    { // The difference to the previous pixel is stored
         miR = (char)getBits((char)(R - davor->getR()));
         miG = (char)getBits((char)(G - davor->getG()));
         miB = (char)getBits((char)(B - davor->getB()));
@@ -305,7 +298,7 @@ void LTDBPixel::komprimieren() // Komprimiert den Pixel
         changeG = G != davor->getG();
         changeB = B != davor->getB();
         changeA = A != davor->getA();
-    } // Pruefen ob sich etwas aendert
+    } // Check if something changes
     if (!miR && changeR) ++miR;
     if (!miG && changeG) ++miG;
     if (!miB && changeB) ++miB;
@@ -321,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 aendert sich etwas
+        { // Something changes
             change = 1;
             maxIndex = (char)(maxIndex + 7);
         }
         else
-        { // Es aendert sich nichts
+        { // Nothing changes
             change = 0;
         }
     }
 }
 
 bool LTDBPixel::getNextFarbeBit(
-    char& byte, int i) // Speichert das naechste Farbbit in byte
+    char& byte, int i) // Stores the next color bit in byte
 {
     unsigned char RR = R;
     unsigned char GG = G;
@@ -346,110 +339,110 @@ bool LTDBPixel::getNextFarbeBit(
         BB = (unsigned char)(BB - davor->getB());
         AA = (unsigned char)(AA - davor->getA());
     }
-    if (changeR && iR != miR) // Das Bit gehoert zu Rot
+    if (changeR && iR != miR) // The bit belongs to red
     {
         byte |= (char)(((RR >> (7 - komp - iR)) & 0x1) << (7 - i));
         ++iR;
     }
-    else if (changeG && iG != miG) // Das Bit gehoert zu Gruen
+    else if (changeG && iG != miG) // The bit belongs to green
     {
         byte |= (char)(((GG >> (7 - komp - iG)) & 0x1) << (7 - i));
         ++iG;
     }
-    else if (changeB && iB != miB) // Das Bit gehoert zu Blau
+    else if (changeB && iB != miB) // The bit belongs to blue
     {
         byte |= (char)(((BB >> (7 - komp - iB)) & 0x1) << (7 - i));
         ++iB;
     }
-    else if (changeA && iA != miA) // Das Bit gehoert zu Alpha
+    else if (changeA && iA != miA) // The bit belongs to alpha
     {
         byte |= (char)(((AA >> (7 - komp - iA)) & 0x1) << (7 - i));
         ++iA;
     }
-    else // Der Pixel ist bereits zu ende
+    else // The pixel is already finished
         return false;
     return true;
 }
 
 char LTDBPixel::getNextByte(
-    char& byte, int begin) // Gibt die naechsten Bits Zurueck, -1 wenn der Pixel
-                           // nicht zu ende ist
+    char& byte, int begin) // Returns the next bits, -1 if the pixel
+                           // is not finished
 {
-    // bbegin gibt an wohin in die byte-variable geschrieben werden soll
-    // die Funktion gibt das ende des Pixels in der byte-variable zurueck
-    // -1 heisst, dass der Pixel nicht zu ende ist
+    // begin specifies where to write in the byte variable
+    // the function returns the end of the pixel in the byte variable
+    // -1 means the pixel is not finished
     for (int i = begin; i < 8; ++i)
     {
         switch (index)
         {
-        case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
-                // Komprimierung aendert
+        case 0: // The first bit of the pixel stores whether the
+                // compression changes
             byte |= (char)(((int)change & 0x1) << (7 - i));
             break;
-        case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 1: // The second bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((int)changeR & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 2: // Das dritte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 2: // The third bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((int)changeG & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 3: // Das vierte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 3: // The fourth bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((int)changeB & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 4: // Das fuenfte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 4: // The fifth bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((int)changeA & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 5: // Das sechste Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 5: // The sixth bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((komp >> 2) & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 6: // Das siebte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 6: // The seventh bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)(((komp >> 1) & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        case 7: // Das sechste Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (change) // Komprimierung
+        case 7: // The eighth bit of the pixel stores either the color
+                // or the compression
+            if (change) // Compression
                 byte |= (char)((komp & 0x1) << (7 - i));
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return (char)i;
             }
             break;
-        default: // Die restlichen Bits speichern die Farbe des Pixels
+        default: // The remaining bits store the color of the pixel
             if (!getNextFarbeBit(byte, i)) return (char)i;
             break;
         }
@@ -464,7 +457,7 @@ char LTDBPixel::getNextByte(
 }
 
 // constant
-int LTDBPixel::zuFarbe() const // gibt den Pixel als Farbe zurueck
+int LTDBPixel::zuFarbe() const // returns the pixel as color
 {
     return (((int)R << 16) | ((int)G << 8) | (int)B | ((int)A << 24));
 }
@@ -494,28 +487,28 @@ unsigned char LTDBPixel::getKomp() const
     return komp;
 }
 
-unsigned char LTDBPixel::getR() const // gibt Rot zurueck
+unsigned char LTDBPixel::getR() const // returns red
 {
     return R;
 }
 
-unsigned char LTDBPixel::getG() const // gibt Gruen zurueck
+unsigned char LTDBPixel::getG() const // returns green
 {
     return G;
 }
 
-unsigned char LTDBPixel::getB() const // gibt Blau zurueck
+unsigned char LTDBPixel::getB() const // returns blue
 {
     return B;
 }
 
-unsigned char LTDBPixel::getA() const // gibt Alpha zurueck
+unsigned char LTDBPixel::getA() const // returns alpha
 {
     return A;
 }
 
-// Inhalt der LTDBDateiKopf Klasse aus Dateisystem.h
-// konstructor
+// Content of the LTDBDateiKopf class from Dateisystem.h
+// Constructor
 LTDBDateiKopf::LTDBDateiKopf()
     : ReferenceCounter(),
       bilder(new RCArray<Text>()),
@@ -523,14 +516,14 @@ LTDBDateiKopf::LTDBDateiKopf()
       bAnzahl(0)
 {}
 
-// destructor
+// Destructor
 LTDBDateiKopf::~LTDBDateiKopf()
 {
     bilder->release();
     pos->release();
 }
 
-// nicht constant
+// non-constant
 void LTDBDateiKopf::removeBild(int i)
 {
     if (i >= bAnzahl) return;
@@ -608,12 +601,12 @@ void LTDBDateiKopf::laden(FBalken* f, std::ifstream* inF)
         for (int i = 0; i < bAnzahl; ++i)
         {
             LTDBKopf* kpf = new LTDBKopf();
-            kpf->laden(inF);              // bildname und halbe datei position
-            bilder->add(kpf->getTitel()); // setzt titel
+            kpf->laden(inF);              // image name and half file position
+            bilder->add(kpf->getTitel()); // sets title
             Punkt gr = kpf->getSize();
             kpf->release();
             char p[5];
-            inF->read((char*)p, 5); // andere haelfte der Dateiposition
+            inF->read((char*)p, 5); // other half of the file position
             unsigned __int64 position
                 = (((__int64)gr.x << 52) & 0xFFF0000000000000)
                 | (((__int64)gr.y << 40) & 0xFFF0000000000)
@@ -621,7 +614,7 @@ void LTDBDateiKopf::laden(FBalken* f, std::ifstream* inF)
                 | (((__int64)p[1] << 24) & 0xFF000000)
                 | (((__int64)p[2] << 16) & 0xFF0000)
                 | (((__int64)p[3] << 8) & 0xFF00) | ((__int64)p[4] & 0xFF);
-            pos->add(position, i); // setzt position
+            pos->add(position, i); // sets position
 #ifdef WIN32
             if (f) f->aktionPlus();
 #endif
@@ -714,14 +707,14 @@ RCArray<Text>* LTDBDateiKopf::zBildListe() const
     return bilder;
 }
 
-// Inhalt der LTDBKopf Klasse aus DateiSystem.h
-// Konstruktor
+// Content of the LTDBKopf class from DateiSystem.h
+// Constructor
 LTDBKopf::LTDBKopf()
     : ReferenceCounter()
 {}
 
-// nicht constant
-void LTDBKopf::laden(std::ifstream* f) // Laet die Daten aus einer Datei
+// non-constant
+void LTDBKopf::laden(std::ifstream* f) // Loads data from a file
 {
     if (f->is_open())
     {
@@ -744,7 +737,7 @@ void LTDBKopf::laden(std::ifstream* f) // Laet die Daten aus einer Datei
     }
 }
 
-int LTDBKopf::Init(Text* t, const Punkt& g) // Befuellt die Daten
+int LTDBKopf::Init(Text* t, const Punkt& g) // Fills the data
 {
     a = 0;
     b = 0;
@@ -760,13 +753,16 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Befuellt die Daten
             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] == SpecialCharacters::SMALL_UE
+                 || titel[i - skipped] == SpecialCharacters::BIG_UE)
             titel[i - skipped] = 27;
-        else if (titel[i - skipped] == 'ö' || titel[i - skipped] == 'Ö')
+        else if (titel[i - skipped] == SpecialCharacters::SMALL_OE
+                 || titel[i - skipped] == SpecialCharacters::BIG_OE)
             titel[i - skipped] = 28;
-        else if (titel[i - skipped] == 'ä' || titel[i - skipped] == 'Ä')
+        else if (titel[i - skipped] == SpecialCharacters::SMALL_AE
+                 || titel[i - skipped] == SpecialCharacters::BIG_AE)
             titel[i - skipped] = 29;
-        else if (titel[i - skipped] == 'ß')
+        else if (titel[i - skipped] == SpecialCharacters::SZ)
             titel[i - skipped] = 30;
         else if (titel[i - skipped] == '.')
             titel[i - skipped] = 31;
@@ -781,54 +777,54 @@ int LTDBKopf::Init(Text* t, const Punkt& g) // Befuellt die Daten
         switch (i)
         {
         case 0:
-            a |= (__int64)(titel[i] & 31) << 55; // ersten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 55; // store 1st character
             break;
         case 1:
-            a |= (__int64)(titel[i] & 31) << 50; // zweiten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 50; // store 2nd character
             break;
         case 2:
-            a |= (__int64)(titel[i] & 31) << 45; // dritten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 45; // store 3rd character
             break;
         case 3:
-            a |= (__int64)(titel[i] & 31) << 40; // vierten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 40; // store 4th character
             break;
         case 4:
             a |= (__int64)(titel[i] & 31)
-              << 35; // fuenften Buchstaben speichern
+              << 35; // store 5th character
             break;
         case 5:
             a |= (__int64)(titel[i] & 31)
-              << 30; // sechsten Buchstaben speichern
+              << 30; // store 6th character
             break;
         case 6:
-            a |= (__int64)(titel[i] & 31) << 25; // siebten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 25; // store 7th character
             break;
         case 7:
-            a |= (__int64)(titel[i] & 31) << 20; // achten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 20; // store 8th character
             break;
         case 8:
-            a |= (__int64)(titel[i] & 31) << 15; // neunten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 15; // store 9th character
             break;
         case 9:
-            a |= (__int64)(titel[i] & 31) << 10; // zenten Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 10; // store 10th character
             break;
         case 10:
-            a |= (__int64)(titel[i] & 31) << 5; // elften Buchstaben speichern
+            a |= (__int64)(titel[i] & 31) << 5; // store 11th character
             break;
         case 11:
-            a |= (__int64)(titel[i] & 31); // zwoelften Buchstaben speichern
+            a |= (__int64)(titel[i] & 31); // store 12th character
             break;
         case 12:
             b |= (__int32)(titel[i] & 31)
-              << 27; // dreizenten Buchstaben speichern
+              << 27; // store 13th character
             break;
         case 13:
             b |= (__int32)(titel[i] & 31)
-              << 22; // vierzenten Buchstaben speichern
+              << 22; // store 14th character
             break;
         case 14:
             b |= (__int32)(titel[i] & 31)
-              << 17; // fuenfzenten Buchstaben speichern
+              << 17; // store 15th character
             break;
         }
     }
@@ -886,13 +882,13 @@ void LTDBKopf::setBits(int BeginBit, int EndBit, __int16 bits)
 
 // constant
 void LTDBKopf::speichern(
-    std::ofstream* f) const // Speichert die Daten in eine Datei
+    std::ofstream* f) const // Saves data to a file
 {
     if (f->is_open())
     {
-        int bits = 4 /*Titellaenge*/ + getTitelLength() * 5 /*Titel*/
-                 + 24 /*Bildgroesse*/;
-        int bytes = bits / 8; // Bytelaenge des Dateikopfes
+        int bits = 4 /*title length*/ + getTitelLength() * 5 /*title*/
+                 + 24 /*image size*/;
+        int bytes = bits / 8; // byte length of the file header
         if (((float)bits / 8.0f) != (float)bytes) ++bytes;
         char c = 0;
         for (int i = 0; i < bytes; ++i)
@@ -903,13 +899,13 @@ void LTDBKopf::speichern(
     }
 }
 
-int LTDBKopf::getTitelLength() const // gibt die laenge des Bildnamens zurueck
+int LTDBKopf::getTitelLength() const // returns the length of the image name
 {
-    return (int)(a >> 60 & Bits(4)); // Die Laenge des Titels wird in den ersten
-                                     // 4 Bits der Tatei gespeichert
+    return (int)(a >> 60 & Bits(4)); // The title length is stored in the first
+                                     // 4 bits of the file
 }
 
-Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurueck
+Text* LTDBKopf::getTitel() const // returns the name of the image
 {
     Text* ret = new Text("");
     char c[2];
@@ -921,49 +917,49 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurueck
         switch (i)
         {
         case 0:
-            c[0] = (a >> 55) & 31; // ersten Buchstaben holen
+            c[0] = (a >> 55) & 31; // get 1st character
             break;
         case 1:
-            c[0] = (a >> 50) & 31; // zweiten Buchstaben holen
+            c[0] = (a >> 50) & 31; // get 2nd character
             break;
         case 2:
-            c[0] = (a >> 45) & 31; // dritten Buchstaben holen
+            c[0] = (a >> 45) & 31; // get 3rd character
             break;
         case 3:
-            c[0] = (a >> 40) & 31; // vierten Buchstaben holen
+            c[0] = (a >> 40) & 31; // get 4th character
             break;
         case 4:
-            c[0] = (a >> 35) & 31; // fuenften Buchstaben holen
+            c[0] = (a >> 35) & 31; // get 5th character
             break;
         case 5:
-            c[0] = (a >> 30) & 31; // sechsten Buchstaben holen
+            c[0] = (a >> 30) & 31; // get 6th character
             break;
         case 6:
-            c[0] = (a >> 25) & 31; // siebten Buchstaben holen
+            c[0] = (a >> 25) & 31; // get 7th character
             break;
         case 7:
-            c[0] = (a >> 20) & 31; // achten Buchstaben holen
+            c[0] = (a >> 20) & 31; // get 8th character
             break;
         case 8:
-            c[0] = (a >> 15) & 31; // neunten Buchstaben holen
+            c[0] = (a >> 15) & 31; // get 9th character
             break;
         case 9:
-            c[0] = (a >> 10) & 31; // zenten Buchstaben holen
+            c[0] = (a >> 10) & 31; // get 10th character
             break;
         case 10:
-            c[0] = (a >> 5) & 31; // elften Buchstaben holen
+            c[0] = (a >> 5) & 31; // get 11th character
             break;
         case 11:
-            c[0] = a & 31; // zwoelften Buchstaben holen
+            c[0] = a & 31; // get 12th character
             break;
         case 12:
-            c[0] = (char)((b >> 27) & 31); // dreizenten Buchstaben holen
+            c[0] = (char)((b >> 27) & 31); // get 13th character
             break;
         case 13:
-            c[0] = (char)((b >> 22) & 31); // vierzenten Buchstaben holen
+            c[0] = (char)((b >> 22) & 31); // get 14th character
             break;
         case 14:
-            c[0] = (char)((b >> 17) & 31); // fuenfzenten Buchstaben holen
+            c[0] = (char)((b >> 17) & 31); // get 15th character
             break;
         }
         if (c[0] == 27)
@@ -983,9 +979,9 @@ Text* LTDBKopf::getTitel() const // gibt den Namen des Bildes zurueck
     return ret;
 }
 
-Punkt LTDBKopf::getSize() const // gibt die Groesse des Bildes zurueck
+Punkt LTDBKopf::getSize() const // returns the size of the image
 {
-    int BeginBit = 4 /*Titellaenge*/ + getTitelLength() * 5 /*Titel*/;
+    int BeginBit = 4 /*title length*/ + getTitelLength() * 5 /*title*/;
     int EndBit = BeginBit + 24;
     __int16 grx = getBits(BeginBit, EndBit - 12);
     __int16 gry = getBits(BeginBit + 12, EndBit);
@@ -993,7 +989,7 @@ Punkt LTDBKopf::getSize() const // gibt die Groesse des Bildes zurueck
 }
 
 __int16 LTDBKopf::getBits(int begin,
-    int ende) const // gibt die Bits von begin bis ende zurueck( ohne ende );
+int ende) const // returns the bits from begin to ende (excluding ende)
 {
     if (ende < begin) return 0;
     if (ende - begin > 16) ende = begin + 16;
@@ -1037,15 +1033,15 @@ __int16 LTDBKopf::getBits(int begin,
     return ret;
 }
 
-// Inhalt der LTDBKoerper Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDBBody class from Dateisystem.h
+// Constructor
 LTDBBody::LTDBBody()
     : ReferenceCounter(),
       gr(0, 0),
       b(new Bild())
 {}
 
-LTDBBody::LTDBBody(LTDBKopf* k) // ruft Init auf
+LTDBBody::LTDBBody(LTDBKopf* k) // calls init
     : ReferenceCounter(),
       gr(0, 0),
       b(new Bild())
@@ -1053,14 +1049,14 @@ LTDBBody::LTDBBody(LTDBKopf* k) // ruft Init auf
     init(k);
 }
 
-// Destruktor
+// Destructor
 LTDBBody::~LTDBBody()
 {
     b->release();
 }
 
-// nicht constant
-void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden benoetigt
+// non-constant
+void LTDBBody::init(LTDBKopf k) // Initializes, required before loading
 {
     gr = k.getSize();
     int l = k.getTitelLength();
@@ -1068,7 +1064,7 @@ void LTDBBody::init(LTDBKopf k) // Initialisiert, wird vor dem laden benoetigt
     dateiSize = (l / 8.0 == l) ? (l / 8) : (l / 8 + 1);
 }
 
-void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden benoetigt
+void LTDBBody::init(LTDBKopf* k) // Initializes, required before loading
 {
     gr = k->getSize();
     int l = k->getTitelLength();
@@ -1077,16 +1073,16 @@ void LTDBBody::init(LTDBKopf* k) // Initialisiert, wird vor dem laden benoetigt
     k->release();
 }
 
-void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // laed das Bild
+void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // loads the image
 {
-    b->neuBild(gr.x, gr.y, 0xFF000000); // neues Bild erstellen
+    b->neuBild(gr.x, gr.y, 0xFF000000); // create new image
     int* buff = b->getBuffer();
     int breite = b->getBreite();
     char byte = 0;
     int index = 0;
-    LTDBPixel* davor = 0;                 // zuletzt geladener Pixel
-    LTDBPixel* dieser = new LTDBPixel(0); // momentan zu ladener Pixel
-    int begin = 0; // Pixelbegin, endposition in der byte variable
+    LTDBPixel* davor = 0;                 // last loaded pixel
+    LTDBPixel* dieser = new LTDBPixel(0); // pixel currently being loaded
+    int begin = 0; // pixel start, end position in the byte variable
 #ifdef WIN32
     if (zF)
     {
@@ -1094,15 +1090,15 @@ void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // laed das Bild
         zF->setAktionAnzahl(gr.x * gr.y);
     }
 #endif
-    while (index < gr.x * gr.y) // fuer jeden Pixel
+    while (index < gr.x * gr.y) // for each pixel
     {
-        if (!dieser) // wenn es nicht der erste Pixel ist
+        if (!dieser) // if it is not the first pixel
             dieser = new LTDBPixel(dynamic_cast<LTDBPixel*>(davor->getThis()));
         int ende = -1;
-        while (ende < 0) // Pixel laden
+        while (ende < 0) // load pixel
         {
             if (begin == 0) inF->read(&byte, 1);
-            ende = dieser->addByte(byte, (char)begin); // byte auswerten
+            ende = dieser->addByte(byte, (char)begin); // evaluate byte
             begin = 0;
         }
         begin = ende;
@@ -1119,7 +1115,7 @@ void LTDBBody::laden(FBalken* zF, std::ifstream* inF) // laed das Bild
     if (davor) davor = (LTDBPixel*)davor->release();
 }
 
-void LTDBBody::setBild(Bild* b) // setzt das zu speichernde Bild
+void LTDBBody::setBild(Bild* b) // sets the image to be saved
 {
     this->b->release();
     this->b = b;
@@ -1127,16 +1123,16 @@ void LTDBBody::setBild(Bild* b) // setzt das zu speichernde Bild
 
 // constant
 void LTDBBody::speichern(
-    FBalken* zF, std::ofstream* outF) const // speichert Bild
+    FBalken* zF, std::ofstream* outF) const // saves image
 {
     if (outF->is_open())
     {
-        LTDBPixel* letzter = 0; // Letzter gespeicherter Pixel
+        LTDBPixel* letzter = 0; // Last saved pixel
         LTDBPixel* dieser
-            = new LTDBPixel(0); // Der momentan zu speichernde Pixel
+            = new LTDBPixel(0); // The pixel currently being saved
         int begin = 0,
-            ende = 0;  // Pixelbeginn, endposition in der byte variable
-        char byte = 0; // Der naechste byte der Datei
+            ende = 0;  // pixel start, end position in the byte variable
+        char byte = 0; // The next byte of the file
         bool w = 0;
 #ifdef WIN32
         if (zF)
@@ -1146,31 +1142,31 @@ void LTDBBody::speichern(
         }
 #endif
         int* pBuff = b->getBuffer();
-        for (int i = 0; i < gr.x * gr.y; ++i) // fuer jeden Pixel
+        for (int i = 0; i < gr.x * gr.y; ++i) // for each pixel
         {
-            if (!dieser) // wenn es nicht der erste Pixel ist
+            if (!dieser) // if it is not the first pixel
                 dieser = new LTDBPixel(
                     dynamic_cast<LTDBPixel*>(letzter->getThis()));
-            dieser->setFarbe(pBuff[i]); // Farbe des Pixels setzen
-            dieser->komprimieren();     // Pixel komprimieren
+            dieser->setFarbe(pBuff[i]); // set pixel color
+            dieser->komprimieren();     // compress pixel
             ende = -1;
-            while (ende < 0) // byte befuellen
+            while (ende < 0) // fill byte
             {
                 ende = dieser->getNextByte(byte, begin);
                 begin = 0;
                 w = 0;
-                if (ende == -1 || ende == 8) // byte speichern
+                if (ende == -1 || ende == 8) // save byte
                 {
                     outF->write(&byte, 1);
                     w = 1;
                     byte = 0;
                 }
-            } // Pixel fertig
+            } // pixel finished
             begin = ende;
             if (begin == 8) begin = 0;
             if (letzter) letzter->release();
             letzter = dynamic_cast<LTDBPixel*>(
-                dieser->getThis()); // dieser wird zu letzter
+                dieser->getThis()); // dieser becomes letzter
             dieser = (LTDBPixel*)dieser->release();
 #ifdef WIN32
             if (zF) zF->aktionPlus();
@@ -1179,47 +1175,47 @@ void LTDBBody::speichern(
         if (letzter) letzter = (LTDBPixel*)letzter->release();
         if (!w)
         {
-            outF->write(&byte, 1); // Das letzte byte speichern
+            outF->write(&byte, 1); // save the last byte
         }
-        outF->flush(); // dateistream speichern
+        outF->flush(); // flush file stream
     }
 }
 
-Bild* LTDBBody::getBild() const // gibt das geladene Bild zurueck
+Bild* LTDBBody::getBild() const // returns the loaded image
 {
     return dynamic_cast<Bild*>(b->getThis());
 }
 
-const Punkt& LTDBBody::getSize() const // gibt die groesse des Bildes zurueck
+const Punkt& LTDBBody::getSize() const // returns the size of the image
 {
     return gr;
 }
 
-// Inhalt det LTDBDatei Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDBDatei class from Dateisystem.h
+// Constructor
 LTDBDatei::LTDBDatei()
     : ReferenceCounter(),
       pfad(new Text()),
       datKpf(0)
 {}
 
-// Destruktor
+// Destructor
 LTDBDatei::~LTDBDatei()
 {
     if (pfad) pfad->release();
     if (datKpf) datKpf->release();
 }
 
-// nicht constant
-void LTDBDatei::setDatei(Text* pfad) // Setzt den Pfad zur Datei
-{ // Werte der eventuellen vorherigen Datei loeschen
+// non-constant
+void LTDBDatei::setDatei(Text* pfad) // Sets the path to the file
+{ // Delete values of any previous file
     if (datKpf) datKpf = (LTDBDateiKopf*)datKpf->release();
-    // Pfad setzen
+    // Set path
     this->pfad->setText(*pfad);
     pfad->release();
 }
 
-void LTDBDatei::erstellen() // Erstellt die Datei
+void LTDBDatei::erstellen() // Creates the file
 {
     DateiPfadErstellen(dynamic_cast<Text*>(pfad->getThis()));
     std::ofstream* outF = new std::ofstream(pfad->getText(), std::ios::binary);
@@ -1229,10 +1225,10 @@ void LTDBDatei::erstellen() // Erstellt die Datei
 }
 
 void LTDBDatei::leseDaten(
-    FBalken* f) // Die Klasse liesst alle Bilder kurz ein, und merkt sich, an
-                // welcher stelle in der Datei was ist
-{ // Diese Funktion wird ein wenig Zeit in Anspruch nemen, dafueraber danach die
-  // anderen schneller machen
+    FBalken* f) // The class briefly reads all images and remembers
+                // where in the file each one is located
+{ // This function will take some time, but will make
+  // the other functions faster afterwards
     if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
     {
         if (datKpf) datKpf->release();
@@ -1244,7 +1240,7 @@ void LTDBDatei::leseDaten(
     }
 }
 
-void LTDBDatei::remove() // Loescht die Datei
+void LTDBDatei::remove() // Deletes the file
 {
     if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
     {
@@ -1253,24 +1249,24 @@ void LTDBDatei::remove() // Loescht die Datei
     }
 }
 
-void LTDBDatei::remove(FBalken* f, Text* name) // Loescht ein Bild aus der Datei
+void LTDBDatei::remove(FBalken* f, Text* name) // Deletes an image from the file
 {
     if (DateiExistiert(dynamic_cast<Text*>(pfad->getThis())) && name)
     {
-        if (!datKpf) leseDaten(0); // Daten einlesen
-        // Pruefen, ob Datei nicht vorhanden
+        if (!datKpf) leseDaten(0); // read data
+        // Check if file is not present
         if (!datKpf)
         {
             name->release();
             return;
         }
         int index = datKpf->getBildIndex(dynamic_cast<Text*>(name->getThis()));
-        if (index == -1) // das bild existiert nicht
+        if (index == -1) // the image does not exist
         {
             name->release();
             return;
         }
-        // Zwischenspeicherpfad ermitteln
+        // Determine temporary file path
         Text* pf_tmp = new Text(pfad->getText());
         char c = '0';
         pf_tmp->append("0");
@@ -1285,12 +1281,12 @@ void LTDBDatei::remove(FBalken* f, Text* name) // Loescht ein Bild aus der Datei
                 c);
         }
         std::ifstream* inF = new std::ifstream(
-            pfad->getText(), std::ios::binary); // Alte Datei oeffnen
+            pfad->getText(), std::ios::binary); // open old file
         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 oeffnen
+            pf_tmp->getText(), std::ios::binary); // open new file
         if (inF->is_open() && outF->is_open())
         {
             __int64 position = datKpf->getBildPosition(index);
@@ -1303,19 +1299,19 @@ void LTDBDatei::remove(FBalken* f, Text* name) // Loescht ein Bild aus der Datei
             __int64 pos_minus = inF->tellg() - outF->tellp();
             for (int i = 0; i < index; ++i)
                 datKpf->setBildPos(i, datKpf->getBildPosition(i) - pos_minus);
-            // Bytes bis zur Datei kopieren
+            // Copy bytes up to the file
             for (__int64 i = inF->tellg(); i < position; ++i)
             {
                 inF->read(&byte, 1);
                 outF->write(&byte, 1);
-            } // zu loeschendes Bild ueberspringen
+            } // skip image to be deleted
             LTDBKopf* delkpf = new LTDBKopf();
             delkpf->laden(inF);
             LTDBBody* delkpr
                 = new LTDBBody(dynamic_cast<LTDBKopf*>(delkpf->getThis()));
             delkpr->laden(f, inF);
             delkpf = (LTDBKopf*)delkpf->release();
-            delkpr = (LTDBBody*)delkpr->release(); // restliche bytes kopieren
+            delkpr = (LTDBBody*)delkpr->release(); // copy remaining bytes
             pos_minus = inF->tellg() - outF->tellp();
             for (__int64 i = (__int64)inF->tellg(); i < datlen; ++i)
             {
@@ -1339,7 +1335,7 @@ void LTDBDatei::remove(FBalken* f, Text* name) // Loescht ein Bild aus der Datei
     if (name) name = (Text*)name->release();
 }
 
-Bild* LTDBDatei::laden(FBalken* f, Text* name) // Laed ein Bild aus der Datei
+Bild* LTDBDatei::laden(FBalken* f, Text* name) // Loads an image from the file
 {
     if (name)
     {
@@ -1354,42 +1350,42 @@ Bild* LTDBDatei::laden(FBalken* f, Text* name) // Laed ein Bild aus der Datei
         int index = datKpf->getBildIndex(k_tmp->getTitel());
         k_tmp->release();
         if (index == -1)
-        { // Fehlermeldung
-            Text* fehler = new Text("Das Bild ");
+        { // Error message
+            Text* fehler = new Text("The image ");
             fehler->append(*name);
-            fehler->append(" wurde nicht in der Datei\n");
+            fehler->append(" was not found in the file\n");
             fehler->append(*pfad);
-            fehler->append(" gefunden!");
+            fehler->append("!");
             Logging::error() << fehler << "\n";
             name->release();
             return 0;
         }
         std::ifstream* inF
             = new std::ifstream(pfad->getText(), std::ios::binary);
-        // Begin der zu ladenden Datei ermitteln
+        // Determine start of the file to load
         __int64 position = datKpf->getBildPosition(index);
         inF->seekg(position, std::ios::beg);
         LTDBKopf* kpf = new LTDBKopf();
         kpf->laden(inF);
         Text* t = kpf->getTitel();
         if (!t->istGleich(*name))
-        { // Fehlermeldung
+        { // Error message
             t->release();
             kpf->release();
             inF->close();
             delete inF;
-            Text* fehler = new Text("Die Datei ");
+            Text* fehler = new Text("The file ");
             fehler->append(*pfad);
-            fehler->append(" ist ist keine gültige LTDB Datei!");
+            fehler->append(" is not a valid LTDB file!");
 #ifdef WIN32
-            WMessageBox(0, new Text("Fehler"), fehler, MB_ICONERROR);
+            WMessageBox(0, new Text("Error"), fehler, MB_ICONERROR);
 #endif
             name->release();
             return 0;
         }
         t->release();
         LTDBBody* kpr = new LTDBBody(dynamic_cast<LTDBKopf*>(kpf->getThis()));
-        kpr->laden(f, inF); // Bild laden
+        kpr->laden(f, inF); // load image
         Bild* ret = kpr->getBild();
         kpr->release();
         kpf->release();
@@ -1402,7 +1398,7 @@ Bild* LTDBDatei::laden(FBalken* f, Text* name) // Laed ein Bild aus der Datei
 }
 
 int LTDBDatei::speichern(
-    FBalken* f, Bild* bild, Text* name) // Speichert ein Bild in die Datei
+FBalken* f, Bild* bild, Text* name) // Saves an image to the file
 {
     int warn = -1;
     if (name && bild)
@@ -1421,13 +1417,13 @@ int LTDBDatei::speichern(
                 if (datKpf->getBildIndex(kpf->getTitel()) != -1)
                 {
                     Logging::error()
-                        << "Es existiert bereits ein Bild mit diesem Namen!\n";
+                        << "An image with this name already exists!\n";
                     bild->release();
                     name->release();
                     kpf->release();
                     return -1;
                 }
-                // zwischendateipfad suchen
+                // find temporary file path
                 Text* pf_tmp = new Text(pfad->getText());
                 char c = '0';
                 pf_tmp->append("0");
@@ -1468,11 +1464,11 @@ int LTDBDatei::speichern(
                     inF->read(&byte, 1);
                     outF->write(&byte, 1);
                 }
-                kpf->speichern(outF); // Bild Kopf speichern
+                kpf->speichern(outF); // save image header
                 LTDBBody* kpr
                     = new LTDBBody(dynamic_cast<LTDBKopf*>(kpf->getThis()));
                 kpr->setBild(dynamic_cast<Bild*>(bild->getThis()));
-                kpr->speichern(f, outF); // Bild speichern
+                kpr->speichern(f, outF); // save image
                 kpf->release();
                 kpr->release();
                 inF->close();
@@ -1490,7 +1486,7 @@ int LTDBDatei::speichern(
     return warn;
 }
 
-RCArray<Text>* LTDBDatei::zBildListe() // Listet alle Bilder in der datei auf
+RCArray<Text>* LTDBDatei::zBildListe() // Lists all images in the file
 {
     if (!datKpf) leseDaten(0);
     if (datKpf) return datKpf->zBildListe();
@@ -1498,7 +1494,7 @@ RCArray<Text>* LTDBDatei::zBildListe() // Listet alle Bilder in der datei auf
 }
 
 // constant
-Text* LTDBDatei::getPfad() const // Gibt den Pfad zur Datei zurueck
+Text* LTDBDatei::getPfad() const // Returns the path to the file
 {
     return dynamic_cast<Text*>(pfad->getThis());
 }
@@ -1509,15 +1505,15 @@ int LTDBDatei::getBildAnzahl() const
     return datKpf->getbAnzahl();
 }
 
-bool LTDBDatei::istOffen() const // Prueft, ob die Datei geoeffnet ist
+bool LTDBDatei::istOffen() const // Checks if the file is open
 {
     if (!pfad) return 0;
     return DateiExistiert(dynamic_cast<Text*>(pfad->getThis()));
 }
 #ifdef WIN32
-// LTDS Dateivormat
-// Inhalt der LTDSPixel Klasse aus DateiSystem.h
-// Konstruktor
+// LTDS File format
+// Content of the LTDSPixel class from DateiSystem.h
+// Constructor
 LTDSPixel::LTDSPixel(LTDSPixel* davor)
     : ReferenceCounter(),
       index(0),
@@ -1531,28 +1527,28 @@ LTDSPixel::LTDSPixel(LTDSPixel* davor)
       davor(davor)
 {}
 
-// Destruktor
+// Destructor
 LTDSPixel::~LTDSPixel()
 {
     if (davor) davor->release();
 }
 
-// nicht constant
-// zum Laden gedacht
+// non-constant
+// intended for loading
 bool LTDSPixel::addBitZuFarbe(unsigned char bit)
 {
-    if (aenderA && iA != miA) // Das Bit gehoert zu Alpha
+    if (aenderA && iA != miA) // The bit belongs to alpha
     {
         alpha |= ((bit & Bits(1))) << (7 - komp - iA);
         ++iA;
     }
-    else // Das Bit gehoert zum naechsten Pixel
+    else // The bit belongs to the next pixel
         return false;
     return true;
 }
 
 char LTDSPixel::addByte(char byte,
-    char begin) // gibt ende des Pixels zurueck, -1 wenn nicht zu ende
+char begin) // returns end of pixel, -1 if not finished
 {
     if (begin >= 8 || begin < 0) return -1;
     for (int i = begin; i < 8; ++i)
@@ -1560,18 +1556,18 @@ char LTDSPixel::addByte(char byte,
         switch (index)
         {
         case 0:
-            // Das erste Bit eines Pixels speichert, ob sich an der
-            // Komprimierung etwas aenderte
+            // The first bit of a pixel stores whether the
+            // compression changed
             aender = ((byte >> (7 - i)) & Bits(1)) == 1;
-            if (!aender) // AEndert sich nichts an der Komprimierung, so werden
-                         // die Werte vom vorherigen Pixel uebernommen
+            if (!aender) // If compression doesn't change, the values
+                         // from the previous pixel are inherited
             {
-                if (!davor) // Die Datei ist beschaedigt ( Der erste Pixel kann
-                            // nicht von dem davor UEbernemen )
+                if (!davor) // The file is corrupted (the first pixel cannot
+                            // inherit from the previous one)
                 {
                     MessageBox(NULL,
-                        "Fehler, die Bilddatei ist beschädigt",
-                        "Fehler",
+                        "Error, the image file is corrupted",
+                        "Error",
                         MB_ICONERROR);
                     exit(0);
                 }
@@ -1579,67 +1575,67 @@ char LTDSPixel::addByte(char byte,
                 komp = davor->getKomp();
                 miA -= komp;
                 if (!aenderA) alpha = davor->getA();
-                maxIndex += aenderA * (8 - komp); // Bestimmung der Laenge
-                // des Pixels in Bits. Jede Farbe hat von grund auf 8 Bits,
-                // durch komprimierung kanns kleiner sein
+                maxIndex += aenderA * (8 - komp); // Determine the length
+                // of the pixel in bits. Each color has 8 bits by default,
+                // compression can make it smaller
             }
             else
-                maxIndex += 4; // Da der Pixel nicht die Werte des vorherigen
-                               // uebernimmt, wird er um 4 Bits groesser
+                maxIndex += 4; // Since the pixel doesn't inherit values from
+                               // the previous one, it is 4 bits larger
             break;
-        case 1:         // Das zweite Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (aender) // Das Bit gehoert zu den 4 Komprimierungsbits
+        case 1:         // The second bit of a pixel stores either the
+                        // compression type or already the color
+            if (aender) // The bit belongs to the 4 compression bits
                 aenderA = ((byte >> (7 - i)) & Bits(1)) == 1;
             else
             {
                 if (!addBitZuFarbe(
-                        byte >> (7 - i))) // Das Bit gehoert zur Farbe
+                        byte >> (7 - i))) // The bit belongs to the color
                     return i;
             }
             break;
-        case 2:         // Das sechste Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (aender) // Das Bit gehoert zu den 4 Komprimierungsbits
+        case 2:         // The sixth bit of a pixel stores either the
+                        // compression type or already the color
+            if (aender) // The bit belongs to the 4 compression bits
                 komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 2;
             else
             {
                 if (!addBitZuFarbe(
-                        byte >> (7 - i))) // Das Bit gehoert zur Farbe
+                        byte >> (7 - i))) // The bit belongs to the color
                     return i;
             }
             break;
-        case 3:         // Das siebte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (aender) // Das Bit gehoert zu den 4 Komprimierungsbits
+        case 3:         // The seventh bit of a pixel stores either the
+                        // compression type or already the color
+            if (aender) // The bit belongs to the 4 compression bits
                 komp |= (unsigned char)((byte >> (7 - i)) & Bits(1)) << 1;
             else
             {
                 if (!addBitZuFarbe(
-                        byte >> (7 - i))) // Das Bit gehoert zur Farbe
+                        byte >> (7 - i))) // The bit belongs to the color
                     return i;
             }
             break;
-        case 4:         // Das achte Bit eines Pixels speichert entweder die
-                        // Komprimierungsart, oder schon die Farbe
-            if (aender) // Das Bit gehoert zu den 4 Komprimierungsbits
+        case 4:         // The eighth bit of a pixel stores either the
+                        // compression type or already the color
+            if (aender) // The bit belongs to the 4 compression bits
             {
                 komp |= (unsigned char)((byte >> (7 - i)) & Bits(1));
-                // Das war das letzte Komprimierungsbit
-                // Komprimierung auswerten
+                // That was the last compression bit
+                // Evaluate compression
                 miA -= komp;
                 if (!aenderA) alpha = davor->getA();
-                maxIndex += aenderA * (8 - komp); // Bitlaenge des Pixels
+                maxIndex += aenderA * (8 - komp); // bit length of the pixel
             }
             else
             {
                 if (!addBitZuFarbe(
-                        byte >> (7 - i))) // Das Bit gehoert zur Farbe
+                        byte >> (7 - i))) // The bit belongs to the color
                     return i;
             }
             break;
-        default: // Die restlichen Bits speichern alle die Farbwerte des Pixels
-            if (!addBitZuFarbe(byte >> (7 - i))) // Das Bit gehoert zur Farbe
+        default: // The remaining bits all store the color values of the pixel
+            if (!addBitZuFarbe(byte >> (7 - i))) // The bit belongs to the color
                 return i;
             break;
         }
@@ -1657,42 +1653,42 @@ char LTDSPixel::addByte(char byte,
     return -1;
 }
 
-// zum speichern gedacht
-void LTDSPixel::setAlpha(unsigned char alpha) // setzt die Farbe des Pixels
+// intended for saving
+void LTDSPixel::setAlpha(unsigned char alpha) // sets the color of the pixel
 {
     this->alpha = alpha;
 }
 
-void LTDSPixel::Komp() // Komprimiert den Pixel
+void LTDSPixel::Komp() // Compresses the pixel
 {
     maxIndex = 1;
     if (!davor)
-    { // Das ist der erste Pixel
+    { // This is the first pixel
         aender = 1;
         aenderA = 1;
         maxIndex += 4;
         miA = getBits(alpha);
     }
     else
-    { // Es wird die differenz zum vorrigen Pixel gespeichert
+    { // The difference to the previous pixel is stored
         miA = getBits(alpha - davor->getA());
         if (alpha != davor->getA())
             aenderA = 1;
         else
             aenderA = 0;
-    } // Pruefen ob sich etwas aendert
+    } // Check if something changes
     if (!miA && aenderA) ++miA;
     komp = 8 - miA;
     maxIndex += aenderA * miA;
     if (davor)
     {
         if (aenderA != davor->getAEnderA() || komp != davor->getKomp())
-        { // Es aendert sich etwas
+        { // Something changes
             aender = 1;
             maxIndex += 4;
         }
         else
-        { // Es aendert sich nichts
+        { // Nothing changes
             aender = 0;
         }
     }
@@ -1705,68 +1701,68 @@ bool LTDSPixel::getNextFarbeBit(char& byte, int i)
     {
         AA -= davor->getA();
     }
-    if (aenderA && iA != miA) // Das Bit gehoert zu Alpha
+    if (aenderA && iA != miA) // The bit belongs to alpha
     {
         byte |= ((AA >> (7 - komp - iA)) & Bits(1)) << (7 - i);
         ++iA;
     }
-    else // Der Pixel ist bereits zu ende
+    else // The pixel is already finished
         return false;
     return true;
 }
 
 char LTDSPixel::getNextByte(
-    char& byte, int bbegin) // Gibt die naechsten Bits Zurueck, -1 wenn der
-                            // Pixel nicht zu ende ist
+    char& byte, int bbegin) // Returns the next bits, -1 if the pixel
+                            // is not finished
 {
-    // bbegin gibt an wohin in die byte-variable geschrieben werden soll
-    // die Funktion gibt das ende des Pixels in der byte-variable zurueck
-    // -1 heisst, dass der Pixel nicht zu ende ist
+    // bbegin specifies where to write in the byte variable
+    // the function returns the end of the pixel in the byte variable
+    // -1 means the pixel is not finished
     for (int i = bbegin; i < 8; ++i)
     {
         switch (index)
         {
-        case 0: // Das erste Bit des Pixels speichert, ob sich etwas an der
-                // Komprimierung aendert
+        case 0: // The first bit of the pixel stores whether the
+                // compression changes
             byte |= ((int)aender & Bits(1)) << (7 - i);
             break;
-        case 1: // Das zweite Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (aender) // Komprimierung
+        case 1: // The second bit of the pixel stores either the color
+                // or the compression
+            if (aender) // Compression
                 byte |= ((int)aenderA & Bits(1)) << (7 - i);
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return i;
             }
             break;
-        case 2: // Das zweite Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (aender) // Komprimierung
+        case 2: // The second bit of the pixel stores either the color
+                // or the compression
+            if (aender) // Compression
                 byte |= ((komp >> 2) & Bits(1)) << (7 - i);
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return i;
             }
             break;
-        case 3: // Das dritte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (aender) // Komprimierung
+        case 3: // The third bit of the pixel stores either the color
+                // or the compression
+            if (aender) // Compression
                 byte |= ((komp >> 1) & Bits(1)) << (7 - i);
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return i;
             }
             break;
-        case 4: // Das vierte Bit des Pixels speichert entweder schon die Farbe
-                // oder die Komprimierung
-            if (aender) // Komprimierung
+        case 4: // The fourth bit of the pixel stores either the color
+                // or the compression
+            if (aender) // Compression
                 byte |= (komp & Bits(1)) << (7 - i);
-            else // Farbe
+            else // Color
             {
                 if (!getNextFarbeBit(byte, i)) return i;
             }
             break;
-        default: // Die restlichen Bits speichern die Farbe des Pixels
+        default: // The remaining bits store the color of the pixel
             if (!getNextFarbeBit(byte, i)) return i;
             break;
         }
@@ -1781,24 +1777,24 @@ char LTDSPixel::getNextByte(
 }
 
 // constant
-unsigned char LTDSPixel::getKomp() const // hat sich die Komprimierung geaendert
+unsigned char LTDSPixel::getKomp() const // has the compression changed
 {
     return komp;
 }
 
 bool LTDSPixel::getAEnderA()
-    const // gibt zurueck, ob sich der alphawert aendert
+    const // returns whether the alpha value changes
 {
     return aenderA;
 }
 
-unsigned char LTDSPixel::getA() const // gibt Alpha zurueck
+unsigned char LTDSPixel::getA() const // returns alpha
 {
     return alpha;
 }
 
-// Inhalt der LTDSDateiKopf Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDSDateiKopf class from Dateisystem.h
+// Constructor
 LTDSDateiKopf::LTDSDateiKopf()
     : ReferenceCounter(),
       sganzahl(0),
@@ -1806,15 +1802,15 @@ LTDSDateiKopf::LTDSDateiKopf()
       pos(0)
 {}
 
-// Destruktor
+// Destructor
 LTDSDateiKopf::~LTDSDateiKopf()
 {
     delete[] gr;
     delete[] pos;
 }
 
-// nicht constant
-void LTDSDateiKopf::laden(std::ifstream* inF) // Laet aus inF
+// non-constant
+void LTDSDateiKopf::laden(std::ifstream* inF) // Loads from inF
 {
     if (inF->good() && inF->is_open())
     {
@@ -1833,7 +1829,7 @@ void LTDSDateiKopf::laden(std::ifstream* inF) // Laet aus inF
     }
 }
 
-void LTDSDateiKopf::addSG(char sg) // Schriftgroesse hinzufuegen
+void LTDSDateiKopf::addSG(char sg) // Add font size
 {
     ++sganzahl;
     unsigned char* gr_tmp = gr;
@@ -1853,7 +1849,7 @@ void LTDSDateiKopf::addSG(char sg) // Schriftgroesse hinzufuegen
     gr[sganzahl - 1] = sg;
 }
 
-void LTDSDateiKopf::removeSG(char sg) // Schriftgroesse entfernen
+void LTDSDateiKopf::removeSG(char sg) // Remove font size
 {
     bool hatsg = 0;
     int sgpos = 0;
@@ -1888,7 +1884,7 @@ void LTDSDateiKopf::removeSG(char sg) // Schriftgroesse entfernen
 }
 
 // constant
-void LTDSDateiKopf::speichern(std::ofstream* outF) const // Speichert nach outF
+void LTDSDateiKopf::speichern(std::ofstream* outF) const // Saves to outF
 {
     if (outF->is_open() && outF->good())
     {
@@ -1902,25 +1898,25 @@ void LTDSDateiKopf::speichern(std::ofstream* outF) const // Speichert nach outF
 }
 
 unsigned char* LTDSDateiKopf::getSchriftGroesseList()
-    const // gibt eine Liste mit gespeicherten Schriftgroessen zurueck
+const // returns a list of stored font sizes
 {
     return gr;
 }
 
 int* LTDSDateiKopf::getPositionList()
-    const // gibt eine Positionsliste der gespeicherten Schriftgroessen zurueck
+const // returns a position list of stored font sizes
 {
     return pos;
 }
 
 int LTDSDateiKopf::getSchriftGroesseAnzahl()
-    const // gibt die Anzahl der gespeicherten Schriftgroessen zurueck
+const // returns the number of stored font sizes
 {
     return sganzahl;
 }
 
-// Inhalt der LTDSSchriftKopf Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDSSchriftKopf class from Dateisystem.h
+// Constructor
 LTDSSchriftKopf::LTDSSchriftKopf()
     : ReferenceCounter(),
       schriftSize(0),
@@ -1929,15 +1925,15 @@ LTDSSchriftKopf::LTDSSchriftKopf()
       zeichenAnzahl(0)
 {}
 
-// Destruktor
+// Destructor
 LTDSSchriftKopf::~LTDSSchriftKopf()
 {
     delete[] pos;
     delete[] zeichen;
 }
 
-// nicht constant
-void LTDSSchriftKopf::laden(std::ifstream* inF) // laeht von inF
+// non-constant
+void LTDSSchriftKopf::laden(std::ifstream* inF) // loads from inF
 {
     if (inF->good() && inF->is_open())
     {
@@ -1957,13 +1953,13 @@ void LTDSSchriftKopf::laden(std::ifstream* inF) // laeht von inF
 }
 
 void LTDSSchriftKopf::setSchriftgroesse(
-    unsigned char gr) // setze schriftgroesse
+unsigned char gr) // set font size
 {
     schriftSize = gr;
 }
 
 void LTDSSchriftKopf::setZeichenAlphabet(
-    Alphabet* alphabet) // setzt die Zeichen von alphabet
+Alphabet* alphabet) // sets the characters from alphabet
 {
     int count = 0;
     for (int i = 0; i < 256; ++i)
@@ -1993,7 +1989,7 @@ void LTDSSchriftKopf::setZeichenAlphabet(
     alphabet->release();
 }
 
-void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Zeichen hinzufuegen
+void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Add character
 {
     ++zeichenAnzahl;
     unsigned char* zeichen_tmp = this->zeichen;
@@ -2012,7 +2008,7 @@ void LTDSSchriftKopf::addZeichen(unsigned char zeichen) // Zeichen hinzufuegen
     pos[zeichenAnzahl] = 0;
 }
 
-void LTDSSchriftKopf::removeZeichen(unsigned char zeich) // Zeichen entfernen
+void LTDSSchriftKopf::removeZeichen(unsigned char zeich) // Remove character
 {
     bool hatZ = 0;
     int zPos = 0;
@@ -2047,7 +2043,7 @@ void LTDSSchriftKopf::removeZeichen(unsigned char zeich) // Zeichen entfernen
 
 // constant
 void LTDSSchriftKopf::speichern(
-    std::ofstream* outF) const // speichert nach outF
+std::ofstream* outF) const // saves to outF
 {
     if (outF->good() && outF->is_open())
     {
@@ -2062,38 +2058,38 @@ void LTDSSchriftKopf::speichern(
 }
 
 unsigned char
-LTDSSchriftKopf::getSchriftGroesse() const // gibt die Schriftgroesse zurueck
+LTDSSchriftKopf::getSchriftGroesse() const // returns the font size
 {
     return schriftSize;
 }
 
 unsigned char
-LTDSSchriftKopf::getZeichenAnzahl() const // gibt die Zeichenanzahl zurueck
+LTDSSchriftKopf::getZeichenAnzahl() const // returns the character count
 {
     return zeichenAnzahl;
 }
 
 int* LTDSSchriftKopf::getPositionen()
-    const // gibt die Zeichenpositionen zurueck
+const // returns the character positions
 {
     return pos;
 }
 
-unsigned char* LTDSSchriftKopf::getZeichen() const // gibt die zeichen zurueck
+unsigned char* LTDSSchriftKopf::getZeichen() const // returns the characters
 {
     return zeichen;
 }
 
-// Inhalt der LTDSBuchstabenKopf Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDSBuchstabenKopf class from Dateisystem.h
+// Constructor
 LTDSBuchstabenKopf::LTDSBuchstabenKopf()
     : ReferenceCounter(),
       zeichen(0),
       size(0, 0)
 {}
 
-// nicht constant
-void LTDSBuchstabenKopf::laden(std::ifstream* inF) // laet aus inF
+// non-constant
+void LTDSBuchstabenKopf::laden(std::ifstream* inF) // loads from inF
 {
     if (inF->good() && inF->is_open())
     {
@@ -2104,7 +2100,7 @@ void LTDSBuchstabenKopf::laden(std::ifstream* inF) // laet aus inF
 }
 
 void LTDSBuchstabenKopf::init(unsigned char zeichen,
-    const Punkt& groesse) // initialisierung( fuer speichern )
+const Punkt& groesse) // initialization (for saving)
 {
     this->zeichen = zeichen;
     this->size = groesse;
@@ -2118,7 +2114,7 @@ void LTDSBuchstabenKopf::init(unsigned char zeichen, int br, int hoe)
 
 // constant
 void LTDSBuchstabenKopf::speichern(
-    std::ofstream* outF) const // speichertn nach outF
+std::ofstream* outF) const // saves to outF
 {
     if (outF->good() && outF->is_open())
     {
@@ -2128,28 +2124,28 @@ void LTDSBuchstabenKopf::speichern(
     }
 }
 
-unsigned char LTDSBuchstabenKopf::getZeichen() const // gibt das Zeichen zurueck
+unsigned char LTDSBuchstabenKopf::getZeichen() const // returns the character
 {
     return zeichen;
 }
 
-int LTDSBuchstabenKopf::getBreite() const // gibt die Breite zurueck
+int LTDSBuchstabenKopf::getBreite() const // returns the width
 {
     return size.x;
 }
 
-int LTDSBuchstabenKopf::getHoehe() const // gibt die hoehe zurueck
+int LTDSBuchstabenKopf::getHoehe() const // returns the height
 {
     return size.y;
 }
 
-const Punkt& LTDSBuchstabenKopf::getGroesse() const // gibt die Groesse zurueck
+const Punkt& LTDSBuchstabenKopf::getGroesse() const // returns the size
 {
     return size;
 }
 
-// Inhalt der LTDSBuchstabenKoerper Klasse aus Dateisystem.h
-// Konstruktor
+// Content of the LTDSBuchstabenKoerper class from Dateisystem.h
+// Constructor
 LTDSBuchstabenKoerper::LTDSBuchstabenKoerper(LTDSBuchstabenKopf* kopf)
     : ReferenceCounter(),
       size(kopf->getGroesse()),
@@ -2160,21 +2156,21 @@ LTDSBuchstabenKoerper::LTDSBuchstabenKoerper(LTDSBuchstabenKopf* kopf)
     kopf->release();
 }
 
-// Destruktor
+// Destructor
 LTDSBuchstabenKoerper::~LTDSBuchstabenKoerper()
 {
     if (buchstabe) buchstabe->release();
 }
 
-// nicht constant
+// non-constant
 void LTDSBuchstabenKoerper::setBuchstabe(
-    Buchstabe* zeichen) // setzt den Buchstaben
+    Buchstabe* zeichen) // sets the character
 {
     if (buchstabe) buchstabe->release();
     buchstabe = zeichen;
 }
 
-void LTDSBuchstabenKoerper::laden(std::ifstream* inF) // Laeht aus inF
+void LTDSBuchstabenKoerper::laden(std::ifstream* inF) // Loads from inF
 {
     if (inF->good() && inF->is_open())
     {
@@ -2185,14 +2181,14 @@ void LTDSBuchstabenKoerper::laden(std::ifstream* inF) // Laeht aus inF
         int ende = -1;
         for (int i = 0; i < size.x * size.y; ++i)
         {
-            if (!jetzt) // wenn es nicht der erste Pixel ist
+            if (!jetzt) // if it is not the first pixel
                 jetzt = new LTDSPixel(
                     dynamic_cast<LTDSPixel*>(vorher->getThis()));
             int ende = -1;
-            while (ende < 0) // Pixel laden
+            while (ende < 0) // load pixel
             {
                 if (beg == 0) inF->read(&byte, 1);
-                ende = jetzt->addByte(byte, beg); // byte auswerten
+                ende = jetzt->addByte(byte, beg); // evaluate byte
                 beg = 0;
             }
             beg = ende;
@@ -2209,90 +2205,90 @@ void LTDSBuchstabenKoerper::laden(std::ifstream* inF) // Laeht aus inF
 
 // constant
 void LTDSBuchstabenKoerper::speichern(
-    std::ofstream* outF) const // speichert nach outF
+std::ofstream* outF) const // saves to outF
 {
     if (outF->good() && outF->is_open())
     {
-        LTDSPixel* vorher = 0; // Letzter gespeicherter Pixel
+        LTDSPixel* vorher = 0; // Last saved pixel
         LTDSPixel* jetzt
-            = new LTDSPixel(0); // Der momentan zu speichernde Pixel
+            = new LTDSPixel(0); // The pixel currently being saved
         int begin = 0,
-            ende = 0;  // Pixelbeginn, endposition in der byte variable
-        char byte = 0; // Der naechste byte der Datei
+            ende = 0;  // pixel start, end position in the byte variable
+        char byte = 0; // The next byte of the file
         bool w = 0;
         unsigned char* alphaBuff = buchstabe->getBuff();
-        for (int i = 0; i < size.x * size.y; ++i) // fuer jeden Pixel
+        for (int i = 0; i < size.x * size.y; ++i) // for each pixel
         {
-            if (!jetzt) // wenn es nicht der erste Pixel ist
+            if (!jetzt) // if it is not the first pixel
                 jetzt = new LTDSPixel(
                     dynamic_cast<LTDSPixel*>(vorher->getThis()));
-            jetzt->setAlpha(alphaBuff[i]); // Farbe des Pixels setzen
-            jetzt->Komp();                 // Pixel komprimieren
+            jetzt->setAlpha(alphaBuff[i]); // set pixel color
+            jetzt->Komp();                 // compress pixel
             ende = -1;
-            while (ende < 0) // byte befuellen
+            while (ende < 0) // fill byte
             {
                 ende = jetzt->getNextByte(byte, begin);
                 begin = 0;
                 w = 0;
-                if (ende == -1 || ende == 8) // byte speichern
+                if (ende == -1 || ende == 8) // save byte
                 {
                     outF->write(&byte, 1);
                     w = 1;
                     byte = 0;
                 }
-            } // Pixel fertig
+            } // pixel finished
             begin = ende;
             if (begin == 8) begin = 0;
             if (vorher) vorher->release();
             vorher = dynamic_cast<LTDSPixel*>(
-                jetzt->getThis()); // dieser wird zu letzter
+                jetzt->getThis()); // jetzt becomes vorher
             jetzt = (LTDSPixel*)jetzt->release();
         }
         if (vorher) vorher = (LTDSPixel*)vorher->release();
         if (!w)
         {
-            outF->write(&byte, 1); // Das letzte byte speichern
+            outF->write(&byte, 1); // save the last byte
         }
-        outF->flush(); // dateistream speichern
+        outF->flush(); // flush file stream
     }
 }
 
 Buchstabe*
-LTDSBuchstabenKoerper::getBuchstabe() const // gibt den Buchstaben zurueck
+LTDSBuchstabenKoerper::getBuchstabe() const // returns the character
 {
     return dynamic_cast<Buchstabe*>(buchstabe->getThis());
 }
 
 unsigned char
-LTDSBuchstabenKoerper::getZeichen() const // gibt das Zeichen zurueck
+LTDSBuchstabenKoerper::getZeichen() const // returns the character
 {
     return zeichen;
 }
 
-// Inhalt der LTDSDatei Klasse aus DAteisystem.h
-// Konstruktor
+// Content of the LTDSDatei class from Dateisystem.h
+// Constructor
 LTDSDatei::LTDSDatei()
     : ReferenceCounter(),
       pfad(new Text()),
       dateiKopf(0)
 {}
 
-// Destruktor
+// Destructor
 LTDSDatei::~LTDSDatei()
 {
     if (dateiKopf) dateiKopf->release();
     pfad->release();
 }
 
-// nicht constant
-void LTDSDatei::setPfad(Text* txt) // setzt den Pfad zur Datei
+// non-constant
+void LTDSDatei::setPfad(Text* txt) // sets the path to the file
 {
     if (dateiKopf) dateiKopf = (LTDSDateiKopf*)dateiKopf->release();
     pfad->setText(txt->getText());
     txt->release();
 }
 
-void LTDSDatei::leseDaten() // liesst den Dateikopf
+void LTDSDatei::leseDaten() // reads the file header
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
     if (dateiKopf) dateiKopf->release();
@@ -2304,24 +2300,24 @@ void LTDSDatei::leseDaten() // liesst den Dateikopf
 }
 
 void LTDSDatei::addSchriftgroesse(
-    Alphabet* alphabet) // fuegt eine Schriftgroesse hinzu
+    Alphabet* alphabet) // adds a font size
 {
     if (!DateiExistiert(dynamic_cast<Text*>(
-            pfad->getThis()))) // pruefen, ob die Datei existiert
+            pfad->getThis()))) // check if the file exists
         return;
-    if (!dateiKopf) // pruefen, ob der Dateikopf schon gelesen wurde
+    if (!dateiKopf) // check if the file header has been read
         leseDaten();
     int sgroesse
         = alphabet
-              ->getSchriftSize(); // Schriftgroesse die hinzugefuegt werden soll
+              ->getSchriftSize(); // font size to be added
     unsigned char* sglist
-        = dateiKopf->getSchriftGroesseList(); // Liste von bereits vorhandenen
-                                              // Schriftgroessen
+        = dateiKopf->getSchriftGroesseList(); // list of already existing
+                                              // font sizes
     unsigned char sganzahl
-        = dateiKopf->getSchriftGroesseAnzahl(); // Anzahl der bereits
-                                                // vorhandenen Schriftgroessen
+        = dateiKopf->getSchriftGroesseAnzahl(); // number of already
+                                                // existing font sizes
     for (int i = 0; i < sganzahl;
-        ++i) // pruefen, ob die Schriftgroesse bereits existiert
+        ++i) // check if the font size already exists
     {
         if (sglist[i] == sgroesse)
         {
@@ -2329,39 +2325,39 @@ void LTDSDatei::addSchriftgroesse(
             return;
         }
     }
-    dateiKopf->addSG(sgroesse); // Schriftgroesse dem Dateikopf hinzufuegen
+    dateiKopf->addSG(sgroesse); // add font size to file header
     int* sgPosList
         = dateiKopf
-              ->getPositionList(); // Liste mit positionen der Schriftgroessen
-    sglist = dateiKopf->getSchriftGroesseList(); // Liste von bereits
-                                                 // vorhandenen Schriftgroessen
+              ->getPositionList(); // list of font size positions
+    sglist = dateiKopf->getSchriftGroesseList(); // list of already
+                                                 // existing font sizes
     std::ifstream* inF
-        = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
+        = new std::ifstream(pfad->getText(), std::ios::binary); // old file
     pfad->append("0");
     std::ofstream* outF
-        = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
-    dateiKopf->speichern(outF); // Dateikopf in neue datei speichern
+        = new std::ofstream(pfad->getText(), std::ios::binary); // new file
+    dateiKopf->speichern(outF); // save file header to new file
     inF->seekg(1 + 5 * sganzahl,
-        std::ios::beg); // Position der ersten Schriftgroesse in der alten Datei
+        std::ios::beg); // position of the first font size in the old file
     for (int i = 0; i < sganzahl;
-        ++i) // Buchstabenpositionen aller Schriftgroessen aktualisieren
+        ++i) // update character positions of all font sizes
     {
         LTDSSchriftKopf* sgKpf_tmp
-            = new LTDSSchriftKopf(); // Schriftgroessen Kopf
-        sgKpf_tmp->laden(inF);       // aus alter Datei laden
+            = new LTDSSchriftKopf(); // font size header
+        sgKpf_tmp->laden(inF);       // load from old file
         int* zeichP_tmp
             = sgKpf_tmp
-                  ->getPositionen(); // Zeichenpositionen der Schriftgroesse
+                  ->getPositionen(); // character positions of the font size
         unsigned char zeichA_tmp
             = sgKpf_tmp
-                  ->getZeichenAnzahl(); // Anzahl von Zeichen der Schriftgroesse
+                  ->getZeichenAnzahl(); // number of characters in the font size
         for (int i1 = 0; i1 < zeichA_tmp; ++i1)
-            zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
+            zeichP_tmp[i1] += 5; // update character positions
         sgKpf_tmp->speichern(
-            outF); // Schriftgroesse Kopf in neue Datei speichern
+            outF); // save font size header to new file
         int beginByte
-            = (int)inF->tellg(); // Die restlichen bytes bis zur naechsten
-                                 // Schriftgroesse in neue Datei kopieren
+            = (int)inF->tellg(); // copy remaining bytes until the next
+                                 // font size to new file
         int endByte = sgPosList[i + 1];
         if (!endByte)
         {
@@ -2370,28 +2366,28 @@ void LTDSDatei::addSchriftgroesse(
             inF->seekg(beginByte, std::ios::beg);
         }
         char byte;
-        for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
+        for (int i1 = beginByte; i1 < endByte; ++i1) // copy operation
         {
             inF->read(&byte, 1);
             outF->write(&byte, 1);
         }
         sgKpf_tmp->release();
     }
-    inF->close(); // Alte datei schliessen
+    inF->close(); // close old file
     sgPosList[sganzahl] = (int)outF->tellp();
     outF->seekp(0, std::ios::beg);
-    for (int i = 0; i < sganzahl; ++i) // Positionen im Dateikopf aktualisieren
+    for (int i = 0; i < sganzahl; ++i) // update positions in file header
         sgPosList[i] += 5;
-    dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
+    dateiKopf->speichern(outF); // save updated file header
     outF->seekp(sgPosList[sganzahl], std::ios::beg);
     LTDSSchriftKopf* sgkopf
-        = new LTDSSchriftKopf(); // Kopf der neuen Schriftgroesse
+        = new LTDSSchriftKopf(); // header of the new font size
     sgkopf->setZeichenAlphabet(dynamic_cast<Alphabet*>(
-        alphabet->getThis())); // Kopf der Schriftgroesse initialisieren
-    sgkopf->speichern(outF);   // Kopf der Schriftgroesse speichern
+        alphabet->getThis())); // initialize font size header
+    sgkopf->speichern(outF);   // save font size header
     int* BuchstabenPosList
-        = sgkopf->getPositionen(); // positionen der verschiedenen Zeichen in
-                                   // der Datei( nuch 0 )
+        = sgkopf->getPositionen(); // positions of the different characters
+                                   // in the file (still 0)
     int count = 0;
     for (int i = 0; i < 256; ++i)
     {
@@ -2399,33 +2395,33 @@ void LTDSDatei::addSchriftgroesse(
         if (zeich)
         {
             BuchstabenPosList[count]
-                = (int)outF->tellp(); // position des Zeichens setzen
+                = (int)outF->tellp(); // set character position
             LTDSBuchstabenKopf* zeichKpf
-                = new LTDSBuchstabenKopf(); // Zeichenkopf
+                = new LTDSBuchstabenKopf(); // character header
             zeichKpf->init(i, zeich->getBreite(), zeich->getHeight());
-            zeichKpf->speichern(outF); // Zeichenkopf speichern
+            zeichKpf->speichern(outF); // save character header
             LTDSBuchstabenKoerper* zeichKoerp
                 = new LTDSBuchstabenKoerper(dynamic_cast<LTDSBuchstabenKopf*>(
-                    zeichKpf->getThis())); // Zeichenkoerper
+                    zeichKpf->getThis())); // character body
             zeichKpf->release();
             zeichKoerp->setBuchstabe(
                 dynamic_cast<Buchstabe*>(zeich->getThis()));
-            zeichKoerp->speichern(outF); // Zeichenkoerper speichern
+            zeichKoerp->speichern(outF); // save character body
             zeich->release();
             ++count;
         }
     }
     outF->seekp(sgPosList[sganzahl], std::ios::beg);
-    sgkopf->speichern(outF); // aktualisierter Schriftgroessen Kopf speichern
+    sgkopf->speichern(outF); // save updated font size header
     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 Loeschen
+    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // delete old file
     DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
         dynamic_cast<Text*>(
-            pfad->getThis())); // neue Datei nach alte umbenennen
-    pfad2->release();          // Speicher freigeben
+            pfad->getThis())); // rename new file to old
+    pfad2->release();          // free memory
     sgkopf->release();
     delete inF;
     delete outF;
@@ -2434,27 +2430,27 @@ void LTDSDatei::addSchriftgroesse(
 
 void LTDSDatei::addBuchstabe(int gr,
     Buchstabe* zeich,
-    unsigned char zeichen) // Fuegt einer Schriftgroesse einen Buchstaben hinzu
+    unsigned char zeichen) // Adds a character to a font size
 {
     if (!DateiExistiert(
-            dynamic_cast<Text*>(pfad->getThis()))) // pruefen ob Datei existiert
+            dynamic_cast<Text*>(pfad->getThis()))) // check if file exists
     {
         zeich->release();
         return;
     }
-    if (!dateiKopf) // pruefen, ob der DAteikopf geladen wurde
+    if (!dateiKopf) // check if the file header was loaded
         leseDaten();
     unsigned char* sgList
-        = dateiKopf->getSchriftGroesseList(); // Liste mit Schriftgroessen aus
-                                              // der Datei
-    int* sgPosList = dateiKopf->getPositionList(); // Liste mit Schriftgroessen
-                                                   // positionen aus Datei
+        = dateiKopf->getSchriftGroesseList(); // list of font sizes from
+                                              // the file
+    int* sgPosList = dateiKopf->getPositionList(); // list of font size
+                                                   // positions from file
     unsigned char sgAnzahl
-        = dateiKopf->getSchriftGroesseAnzahl(); // Anzahl von Schriftgroessen
-                                                // aus der Datei
+        = dateiKopf->getSchriftGroesseAnzahl(); // number of font sizes
+                                                // from the file
     int sgNum = -1;
     for (int i = 0; i < sgAnzahl;
-        ++i) // Position der richtigen Schriftgroesse ermitteln
+        ++i) // find the position of the correct font size
     {
         if (sgList[i] == gr)
         {
@@ -2463,40 +2459,40 @@ void LTDSDatei::addBuchstabe(int gr,
         }
     }
     std::ifstream* inF
-        = new std::ifstream(pfad->getText(), std::ios::binary); // Alte Datei
+        = new std::ifstream(pfad->getText(), std::ios::binary); // old file
     pfad->append("0");
     std::ofstream* outF
-        = new std::ofstream(pfad->getText(), std::ios::binary); // Neue Datei
+        = new std::ofstream(pfad->getText(), std::ios::binary); // new file
     inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
     if (sgNum
-        == -1) // Die Schriftgroesse existiert noch nicht und wird erstellt
+        == -1) // The font size does not exist yet and will be created
     {
-        dateiKopf->addSG(gr); // Schriftgroesse dem Dateikopf hinzufuegen
+        dateiKopf->addSG(gr); // add font size to file header
         sgPosList = dateiKopf->getPositionList();
         sgList = dateiKopf->getSchriftGroesseList();
-        dateiKopf->speichern(outF); // Dateikopf speichern
+        dateiKopf->speichern(outF); // save file header
         inF->seekg(1 + 5 * sgAnzahl,
-            std::ios::beg); // Position der ersten
-                            // Schriftgroesse in der alten Datei
+            std::ios::beg); // position of the first
+                            // font size in the old file
         for (int i = 0; i < sgAnzahl;
-            ++i) // Buchstabenpositionen aller Schriftgroessen aktualisieren
+            ++i) // update character positions of all font sizes
         {
             LTDSSchriftKopf* sgKpf_tmp
-                = new LTDSSchriftKopf(); // Schriftgroessen Kopf
-            sgKpf_tmp->laden(inF);       // aus alter Datei laden
+                = new LTDSSchriftKopf(); // font size header
+            sgKpf_tmp->laden(inF);       // load from old file
             int* zeichP_tmp
                 = sgKpf_tmp
-                      ->getPositionen(); // Zeichenpositionen der Schriftgroesse
+                      ->getPositionen(); // character positions of the font size
             unsigned char zeichA_tmp
-                = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
-                                                 // Schriftgroesse
+                = sgKpf_tmp->getZeichenAnzahl(); // number of characters in
+                                                 // the font size
             for (int i1 = 0; i1 < zeichA_tmp; ++i1)
-                zeichP_tmp[i1] += 5; // Buchstabenpositionen aktualisieren
+                zeichP_tmp[i1] += 5; // update character positions
             sgKpf_tmp->speichern(
-                outF); // Schriftgroesse Kopf in neue Datei speichern
+                outF); // save font size header to new file
             int beginByte
-                = (int)inF->tellg(); // Die restlichen bytes bis zur naechsten
-                                     // Schriftgroesse in neue Datei kopieren
+                = (int)inF->tellg(); // copy remaining bytes until the next
+                                     // font size to new file
             int endByte = sgPosList[i + 1];
             if (i + 1 >= sgAnzahl)
             {
@@ -2505,7 +2501,7 @@ void LTDSDatei::addBuchstabe(int gr,
                 inF->seekg(beginByte, std::ios::beg);
             }
             char byte;
-            for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
+            for (int i1 = beginByte; i1 < endByte; ++i1) // copy operation
             {
                 inF->read(&byte, 1);
                 outF->write(&byte, 1);
@@ -2515,50 +2511,50 @@ void LTDSDatei::addBuchstabe(int gr,
         sgPosList[sgAnzahl] = (int)outF->tellp();
         outF->seekp(0, std::ios::beg);
         for (int i = 0; i < sgAnzahl;
-            ++i) // Positionen im Dateikopf aktualisieren
+            ++i) // update positions in file header
             sgPosList[i] += 5;
-        dateiKopf->speichern(outF); // aktualisierter Dateikopf speichern
+        dateiKopf->speichern(outF); // save updated file header
         outF->seekp(sgPosList[sgAnzahl], std::ios::beg);
         LTDSSchriftKopf* sgKpf
-            = new LTDSSchriftKopf(); // Schriftgroesse Kopf initialisiern
+            = new LTDSSchriftKopf(); // initialize font size header
         sgKpf->setSchriftgroesse(gr);
         sgKpf->addZeichen(zeichen);
         sgKpf->getPositionen()[0] = (int)outF->tellp() + 7;
-        sgKpf->speichern(outF); // Schriftgroesse Kopf speichern
+        sgKpf->speichern(outF); // save font size header
         sgKpf->release();
         LTDSBuchstabenKopf* zeichKpf
-            = new LTDSBuchstabenKopf(); // Buchstabenkopf
+            = new LTDSBuchstabenKopf(); // character header
         zeichKpf->init(zeichen, zeich->getSize());
-        zeichKpf->speichern(outF); // Buchstabenkopf speichern
+        zeichKpf->speichern(outF); // save character header
         LTDSBuchstabenKoerper* zeichKoerp
             = new LTDSBuchstabenKoerper(dynamic_cast<LTDSBuchstabenKopf*>(
-                zeichKpf->getThis())); // Buchstabenkoerper
+                zeichKpf->getThis())); // character body
         zeichKpf->release();
         zeichKoerp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
-        zeichKoerp->speichern(outF); // Buchstabenkoerper speichern
+        zeichKoerp->speichern(outF); // save character body
         zeichKoerp->release();
     }
     else
     {
-        dateiKopf->speichern(outF); // Dateikopf speichern
+        dateiKopf->speichern(outF); // save file header
         int beginByte
-            = 1 + 5 * sgAnzahl; // Die restlichen bytes bis zur naechsten
-                                // Schriftgroesse in neue Datei kopieren
+            = 1 + 5 * sgAnzahl; // copy remaining bytes until the next
+                                // font size to new file
         int endByte = sgPosList[sgNum];
         char byte;
         for (int i1 = beginByte; i1 < endByte;
-            ++i1) // Kopiervorgang bis zur angegebenen groesse
+            ++i1) // copy operation up to the specified size
         {
             inF->read(&byte, 1);
             outF->write(&byte, 1);
         }
-        LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf(); // Schriftgroesse Kopf
+        LTDSSchriftKopf* sgKpf = new LTDSSchriftKopf(); // font size header
         sgKpf->laden(inF);
         for (int i = 0; i < sgKpf->getZeichenAnzahl(); ++i)
             sgKpf->getPositionen()[i] += 5;
         sgKpf->addZeichen(zeichen);
         int indexPlus = 5;
-        int zeichenPos = sgPosList[sgNum + 1]; // position des neuen Zeichens
+        int zeichenPos = sgPosList[sgNum + 1]; // position of the new character
         if (sgNum + 1 >= sgAnzahl)
         {
             int tmp = (int)inF->tellg();
@@ -2568,51 +2564,51 @@ void LTDSDatei::addBuchstabe(int gr,
         }
         zeichenPos += indexPlus;
         sgKpf->getPositionen()[sgKpf->getZeichenAnzahl() - 1] = zeichenPos;
-        sgKpf->speichern(outF); // Schriftgroesse Kopf speichern
+        sgKpf->speichern(outF); // save font size header
         sgKpf->release();
         for (int i = (int)inF->tellg() + indexPlus; i < zeichenPos;
-            ++i) // Kopiervorgang bis zum Zeichenbeginn
+            ++i) // copy operation up to the character start
         {
             inF->read(&byte, 1);
             outF->write(&byte, 1);
         }
-        LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf(); // Zeichenkopf
+        LTDSBuchstabenKopf* zeichKpf = new LTDSBuchstabenKopf(); // character header
         zeichKpf->init(zeichen, zeich->getSize());
-        zeichKpf->speichern(outF); // Zeichenkopf speichern
+        zeichKpf->speichern(outF); // save character header
         LTDSBuchstabenKoerper* zeichKoerp
             = new LTDSBuchstabenKoerper(dynamic_cast<LTDSBuchstabenKopf*>(
-                zeichKpf->getThis())); // Zeichenkoerper
+                zeichKpf->getThis())); // character body
         zeichKpf->release();
         zeichKoerp->setBuchstabe(dynamic_cast<Buchstabe*>(zeich->getThis()));
-        zeichKoerp->speichern(outF); // Zeichenkoerper speichern
+        zeichKoerp->speichern(outF); // save character body
         zeichKoerp->release();
         int nowPos = (int)outF->tellp();
         indexPlus += nowPos - zeichenPos;
-        for (int i = sgNum + 1; i < sgAnzahl; ++i) // Dateikopf aktualisieren
+        for (int i = sgNum + 1; i < sgAnzahl; ++i) // update file header
             sgPosList[i] += indexPlus;
         outF->seekp(0, std::ios::beg);
-        dateiKopf->speichern(outF); // Dateikopf speichern
+        dateiKopf->speichern(outF); // save file header
         outF->seekp(nowPos, std::ios::beg);
         for (int i = sgNum + 1; i < sgAnzahl;
-            ++i) // Restliche Schriftgroessen aktualisieren
+            ++i) // update remaining font sizes
         {
             LTDSSchriftKopf* sgKpf_tmp
-                = new LTDSSchriftKopf(); // Schriftgroessen Kopf
-            sgKpf_tmp->laden(inF);       // aus alter Datei laden
+                = new LTDSSchriftKopf(); // font size header
+            sgKpf_tmp->laden(inF);       // load from old file
             int* zeichP_tmp
                 = sgKpf_tmp
-                      ->getPositionen(); // Zeichenpositionen der Schriftgroesse
+                      ->getPositionen(); // character positions of the font size
             unsigned char zeichA_tmp
-                = sgKpf_tmp->getZeichenAnzahl(); // Anzahl von Zeichen der
-                                                 // Schriftgroesse
+                = sgKpf_tmp->getZeichenAnzahl(); // number of characters in
+                                                 // the font size
             for (int i1 = 0; i1 < zeichA_tmp; ++i1)
                 zeichP_tmp[i1]
-                    += indexPlus; // Buchstabenpositionen aktualisieren
+                    += indexPlus; // update character positions
             sgKpf_tmp->speichern(
-                outF); // Schriftgroesse Kopf in neue Datei speichern
+                outF); // save font size header to new file
             int beginByte
-                = (int)inF->tellg(); // Die restlichen bytes bis zur naechsten
-                                     // Schriftgroesse in neue Datei kopieren
+                = (int)inF->tellg(); // copy remaining bytes until the next
+                                     // font size to new file
             int endByte = sgPosList[i + 1];
             if (i + 1 >= sgAnzahl)
             {
@@ -2621,7 +2617,7 @@ void LTDSDatei::addBuchstabe(int gr,
                 inF->seekg(beginByte, std::ios::beg);
             }
             char byte;
-            for (int i1 = beginByte; i1 < endByte; ++i1) // Kopiervorgang
+            for (int i1 = beginByte; i1 < endByte; ++i1) // copy operation
             {
                 inF->read(&byte, 1);
                 outF->write(&byte, 1);
@@ -2633,29 +2629,29 @@ 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 loeschen
+    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // delete old file
     DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
-        dynamic_cast<Text*>(pfad->getThis())); // Neue Datei in alte umbenennen
-    pfad2->release();                          // Speicher freigeben
+        dynamic_cast<Text*>(pfad->getThis())); // rename new file to old
+    pfad2->release();                          // free memory
     delete inF;
     delete outF;
     zeich->release();
 }
 
 void LTDSDatei::loescheSchrifrGroesse(
-    int gr) // Loescht eine Schriftgroesse aus der Datei
+    int gr) // Deletes a font size from the file
 {
     if (!DateiExistiert(dynamic_cast<Text*>(
-            pfad->getThis()))) // pruefen, ob Datei existiert
+            pfad->getThis()))) // check if file exists
         return;
-    if (!dateiKopf) // pruefen, ob der Dateikopf geladen wurde
+    if (!dateiKopf) // check if the file header was loaded
         leseDaten();
     unsigned char* sgList
-        = dateiKopf->getSchriftGroesseList(); // Liste mit Schriftgroessen
+        = dateiKopf->getSchriftGroesseList(); // list of font sizes
     unsigned char sgAnzahl
-        = dateiKopf->getSchriftGroesseAnzahl(); // Anzahl der Schriftgroessen
+        = dateiKopf->getSchriftGroesseAnzahl(); // number of font sizes
     int sgNum = -1;
-    for (int i = 0; i < sgAnzahl; ++i) // zu loeschende Schriftgroesse suchen
+    for (int i = 0; i < sgAnzahl; ++i) // search for font size to delete
     {
         if (sgList[i] == gr)
         {
@@ -2663,34 +2659,34 @@ void LTDSDatei::loescheSchrifrGroesse(
             break;
         }
     }
-    if (sgNum == -1) // Die Schriftgroesse ist nicht vorhanden
+    if (sgNum == -1) // the font size is not present
         return;
     int* sgPosList
         = dateiKopf
-              ->getPositionList(); // Liste von Positionen der Schriftgroessen
+              ->getPositionList(); // list of font size positions
     std::ifstream* inF
-        = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
+        = new std::ifstream(pfad->getText(), std::ios::binary); // old file
     pfad->append("0");
     std::ofstream* outF
-        = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
+        = new std::ofstream(pfad->getText(), std::ios::binary); // new file
     outF->seekp(1 + 5 * (sgAnzahl - 1), std::ios::beg);
     inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
-    for (int i = 0; i < sgNum; ++i) // Schriftgroessen vor der zu loeschenden
-                                    // Schriftgroesse aktualisieren
+    for (int i = 0; i < sgNum; ++i) // update font sizes before the one
+                                    // being deleted
     {
         LTDSSchriftKopf* sgKpf_tmp
-            = new LTDSSchriftKopf(); // Schriftgroessen Kopf
-        sgKpf_tmp->laden(inF);       // Schriftgroessen Kopf laden
-        int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
+            = new LTDSSchriftKopf(); // font size header
+        sgKpf_tmp->laden(inF);       // load font size header
+        int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // character positions
         unsigned char zeichATmp
-            = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
+            = sgKpf_tmp->getZeichenAnzahl(); // character count
         for (int i1 = 0; i1 < zeichATmp;
-            ++i1) // Position der Zeichen um 5 bytes zuruecksetzen
+            ++i1) // move character positions back by 5 bytes
             zeichPosLTmp[i1] -= 5;
-        sgKpf_tmp->speichern(outF); // speichern in Neue Datei
+        sgKpf_tmp->speichern(outF); // save to new file
         char byte = 0;
         for (int i1 = (int)inF->tellg(); i1 < sgPosList[i + 1];
-            ++i1) // Den Koerper des Zeichens Kopieren
+            ++i1) // copy the character body
         {
             inF->read(&byte, 1);
             outF->write(&byte, 1);
@@ -2700,18 +2696,18 @@ void LTDSDatei::loescheSchrifrGroesse(
     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 Schriftgroesse nach der zu loeschenden Schriftgroesse
+        ++i) // font sizes after the one being deleted
     {
         LTDSSchriftKopf* sgKpf_tmp
-            = new LTDSSchriftKopf(); // Schriftgroessen Kopf
-        sgKpf_tmp->laden(inF);       // Schriftgroessen Kopf laden
-        int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // Zeichenpositionen
+            = new LTDSSchriftKopf(); // font size header
+        sgKpf_tmp->laden(inF);       // load font size header
+        int* zeichPosLTmp = sgKpf_tmp->getPositionen(); // character positions
         unsigned char zeichATmp
-            = sgKpf_tmp->getZeichenAnzahl(); // Zeichenanzahl
+            = sgKpf_tmp->getZeichenAnzahl(); // character count
         for (int i1 = 0; i1 < zeichATmp;
-            ++i1) // Position der Zeichen aktualisieren
+            ++i1) // update character positions
             zeichPosLTmp[i1] -= indexMinus;
-        sgKpf_tmp->speichern(outF); // speichern in Neue Datei
+        sgKpf_tmp->speichern(outF); // save to new file
         char byte = 0;
         int BeginByte = (int)inF->tellg();
         int EndByte = sgPosList[i + 1];
@@ -2722,48 +2718,48 @@ void LTDSDatei::loescheSchrifrGroesse(
             inF->seekg(BeginByte, std::ios::beg);
         }
         for (int i1 = BeginByte; i1 < EndByte;
-            ++i1) // Den Koerper des Zeichens Kopieren
+            ++i1) // copy the character body
         {
             inF->read(&byte, 1);
             outF->write(&byte, 1);
         }
     }
-    for (int i = 0; i < sgNum; ++i) // Dateikopf aktualisieren
+    for (int i = 0; i < sgNum; ++i) // update file header
         sgPosList[i] -= 5;
     for (int i = sgNum + 1; i < sgAnzahl; ++i)
         sgPosList[i] -= indexMinus;
     dateiKopf->removeSG(gr);
     outF->seekp(0, std::ios::beg);
-    dateiKopf->speichern(outF); // Dateikopf speichern
+    dateiKopf->speichern(outF); // save file header
     inF->close();
     outF->close();
     Text* pfad2 = new Text(pfad->getText());
     pfad->remove(pfad->getLength() - 1, pfad->getLength());
-    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei loeschen
+    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // delete old file
     DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
-        dynamic_cast<Text*>(pfad->getThis())); // neue Datei zu alter umbenennen
+        dynamic_cast<Text*>(pfad->getThis())); // rename new file to old
     pfad2->release();
     delete inF;
     delete outF;
 }
 
 void LTDSDatei::loescheBuchstabe(
-    int gr, unsigned char zeichen) // Loescht einen Buchstaben aus der Datei
+    int gr, unsigned char zeichen) // Deletes a character from the file
 {
     if (!DateiExistiert(dynamic_cast<Text*>(
-            pfad->getThis()))) // pruefen, ob die Datei existiert
+            pfad->getThis()))) // check if the file exists
         return;
-    if (!dateiKopf) // pruefen, ob der Dateikopf gelesen wurde
+    if (!dateiKopf) // check if the file header was read
         leseDaten();
     unsigned char* sgList
-        = dateiKopf->getSchriftGroesseList(); // Liste mit Schriftgroessen
+        = dateiKopf->getSchriftGroesseList(); // list of font sizes
     unsigned char sgAnzahl
-        = dateiKopf->getSchriftGroesseAnzahl(); // Anzahl der Schriftgroessen
+        = dateiKopf->getSchriftGroesseAnzahl(); // number of font sizes
     int* sgPosList
         = dateiKopf
-              ->getPositionList(); // Liste mit Positionen der Schriftgroessen
+              ->getPositionList(); // list of font size positions
     int sgNum = -1;
-    for (int i = 0; i < sgAnzahl; ++i) // Schriftgroesse suchen
+    for (int i = 0; i < sgAnzahl; ++i) // search for font size
     {
         if (sgList[i] == gr)
         {
@@ -2771,28 +2767,28 @@ void LTDSDatei::loescheBuchstabe(
             break;
         }
     }
-    if (sgNum == -1) // Schriftgroesse nicht gefunden
+    if (sgNum == -1) // font size not found
         return;
     std::ifstream* inF
-        = new std::ifstream(pfad->getText(), std::ios::binary); // alte Datei
+        = new std::ifstream(pfad->getText(), std::ios::binary); // old file
     pfad->append("0");
     std::ofstream* outF
-        = new std::ofstream(pfad->getText(), std::ios::binary); // neue Datei
+        = new std::ofstream(pfad->getText(), std::ios::binary); // new file
     int indexMinus = 0;
     inF->seekg(1 + 5 * sgAnzahl, std::ios::beg);
-    dateiKopf->speichern(outF); // DateiKopf peichern
+    dateiKopf->speichern(outF); // save file header
     for (int i = 0; i < sgAnzahl; ++i)
     {
-        LTDSSchriftKopf* sgKopf = new LTDSSchriftKopf(); // Schriftkopf
-        sgKopf->laden(inF);                              // Schriftkopf laden
+        LTDSSchriftKopf* sgKopf = new LTDSSchriftKopf(); // font header
+        sgKopf->laden(inF);                              // load font header
         unsigned char sgZeichAnzahl
-            = sgKopf->getZeichenAnzahl();                    // Zeichenanzahl
-        unsigned char* sgZeichenList = sgKopf->getZeichen(); // Zeichen Liste
-        int* sgZPosList = sgKopf->getPositionen();           // Positions Liste
-        if (i == sgNum) // Zeichen befindet sich in dieser Schriftgroesse
+            = sgKopf->getZeichenAnzahl();                    // character count
+        unsigned char* sgZeichenList = sgKopf->getZeichen(); // character list
+        int* sgZPosList = sgKopf->getPositionen();           // position list
+        if (i == sgNum) // character is in this font size
         {
             int sgZNum = -1;
-            for (int i1 = 0; i1 < sgZeichAnzahl; ++i1) // Zeichen suchen
+            for (int i1 = 0; i1 < sgZeichAnzahl; ++i1) // search for character
             {
                 if (sgZeichenList[i1] == zeichen)
                 {
@@ -2800,7 +2796,7 @@ void LTDSDatei::loescheBuchstabe(
                     break;
                 }
             }
-            if (sgZNum == -1) // Zeichen nicht gefunden
+            if (sgZNum == -1) // character not found
             {
                 sgKopf->release();
                 inF->close();
@@ -2809,22 +2805,22 @@ void LTDSDatei::loescheBuchstabe(
                 delete outF;
                 DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
                 pfad->remove(pfad->getLength() - 1, pfad->getLength());
-                return; // abbruch
+                return; // abort
             }
             outF->seekp(2 + 5 * (sgZeichAnzahl - 1), std::ios::cur);
             indexMinus += 5;
             for (int i1 = 0; i1 < sgZNum;
-                ++i1) // Zeichen vor dem zu loeschenden Zeichen
+                ++i1) // characters before the one being deleted
             {
                 char byte = 0;
                 for (int i2 = sgZPosList[i1]; i2 < sgZPosList[i1 + 1];
-                    ++i2) // Kopieren
+                    ++i2) // copy
                 {
                     inF->read(&byte, 1);
                     outF->write(&byte, 1);
                 }
                 sgZPosList[i1]
-                    -= indexMinus; // Schriftgroesse Kopf aktualisieren
+                    -= indexMinus; // update font size header
             }
             if (!sgZPosList[sgZNum + 1])
             {
@@ -2843,7 +2839,7 @@ void LTDSDatei::loescheBuchstabe(
             if (sgZNum + 1 < sgZeichAnzahl)
                 inF->seekg(sgZPosList[sgZNum + 1], std::ios::beg);
             for (int i1 = sgZNum + 1; i1 < sgZeichAnzahl;
-                ++i1) // Zeichen nach dem geloeschten Zeichen
+                ++i1) // characters after the deleted character
             {
                 int beginByte = (int)inF->tellg();
                 int endByte = sgZPosList[i1 + 1];
@@ -2854,22 +2850,22 @@ void LTDSDatei::loescheBuchstabe(
                     inF->seekg(beginByte, std::ios::beg);
                 }
                 char byte = 0;
-                for (int i2 = beginByte; i2 < endByte; ++i2) // Kopieren
+                for (int i2 = beginByte; i2 < endByte; ++i2) // copy
                 {
                     inF->read(&byte, 1);
                     outF->write(&byte, 1);
                 }
                 sgZPosList[i1]
-                    -= indexMinus; // Schriftgroesse Kopf aktualisieren
+                    -= indexMinus; // update font size header
             }
             sgKopf->removeZeichen(zeichen);
         }
         else
         {
             for (int i1 = 0; i1 < sgZeichAnzahl;
-                ++i1) // Schriftgroesse Kopf aktualisieren
+                ++i1) // update font size header
                 sgZPosList[i] -= indexMinus;
-            sgKopf->speichern(outF); // Schriftgroesse Kopf speichern
+            sgKopf->speichern(outF); // save font size header
             int beginByte = (int)inF->tellg();
             int endByte = sgPosList[i + 1];
             if (!endByte)
@@ -2879,7 +2875,7 @@ void LTDSDatei::loescheBuchstabe(
                 inF->seekg(beginByte, std::ios::beg);
             }
             char byte;
-            for (int i1 = beginByte; i1 < endByte; ++i1) // Kopieren
+            for (int i1 = beginByte; i1 < endByte; ++i1) // copy
             {
                 inF->read(&byte, 1);
                 outF->write(&byte, 1);
@@ -2887,7 +2883,7 @@ void LTDSDatei::loescheBuchstabe(
             sgPosList[i] -= indexMinus;
         }
         outF->seekp(sgPosList[i], std::ios::beg);
-        sgKopf->speichern(outF); // Schriftgroesse Kopf speichern
+        sgKopf->speichern(outF); // save font size header
         outF->seekp(sgPosList[i + 1], std::ios::beg);
         sgKopf->release();
     }
@@ -2895,23 +2891,23 @@ void LTDSDatei::loescheBuchstabe(
     outF->close();
     Text* pfad2 = new Text(pfad->getText());
     pfad->remove(pfad->getLength() - 1, pfad->getLength());
-    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // alte Datei loeschen
+    DateiRemove(dynamic_cast<Text*>(pfad->getThis())); // delete old file
     DateiUmbenennen(dynamic_cast<Text*>(pfad2->getThis()),
         dynamic_cast<Text*>(
-            pfad->getThis())); // neue Datei nach alte umbenennen
-    pfad2->release();          // Speicher freigeben
+            pfad->getThis())); // rename new file to old
+    pfad2->release();          // free memory
     delete inF;
     delete outF;
 }
 
-void LTDSDatei::loescheDatei() // Loescht die gesamte Datei
+void LTDSDatei::loescheDatei() // Deletes the entire file
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return;
     if (!dateiKopf) leseDaten();
     DateiRemove(dynamic_cast<Text*>(pfad->getThis()));
 }
 
-void LTDSDatei::erstelleDatei() // erstellt die Datei
+void LTDSDatei::erstelleDatei() // creates the file
 {
     DateiPfadErstellen(dynamic_cast<Text*>(pfad->getThis()));
     if (dateiKopf) dateiKopf->release();
@@ -2923,7 +2919,7 @@ void LTDSDatei::erstelleDatei() // erstellt die Datei
 }
 
 void LTDSDatei::speicherSchrift(
-    Schrift* schrift) // Speichert die uebergebene Schrift
+Schrift* schrift) // Saves the provided font
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis())))
     {
@@ -2987,7 +2983,7 @@ void LTDSDatei::speicherSchrift(
 }
 
 // constant
-Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurueck
+Schrift* LTDSDatei::ladeSchrift() // returns the loaded font
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3022,8 +3018,8 @@ Schrift* LTDSDatei::ladeSchrift() // gibt die geladene Schrift zurueck
 }
 
 Alphabet* LTDSDatei::ladeAlphabet(
-    int schriftgroesse) // gibt eine geladene Schrift nur mit der angegebenen
-                        // Schriftgroesse zurueck
+int schriftgroesse) // returns a loaded font with only the specified
+                    // font size
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3063,7 +3059,7 @@ Alphabet* LTDSDatei::ladeAlphabet(
 }
 
 Buchstabe* LTDSDatei::ladeBuchstabe(int schriftgroesse,
-    unsigned char zeichen) // Laed einen bestimmten Buchstaben
+unsigned char zeichen) // Loads a specific character
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3113,13 +3109,13 @@ Buchstabe* LTDSDatei::ladeBuchstabe(int schriftgroesse,
     return ret;
 }
 
-Text* LTDSDatei::getPfad() const // gibt den Dateipfad zurueck
+Text* LTDSDatei::getPfad() const // returns the file path
 {
     return dynamic_cast<Text*>(pfad->getThis());
 }
 
 int LTDSDatei::getAnzahlSchriftgroessen()
-    const // gibt die Anzahl der Schriftgroessen aus der Datei zurueck
+const // returns the number of font sizes from the file
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3127,7 +3123,7 @@ int LTDSDatei::getAnzahlSchriftgroessen()
 }
 
 unsigned char* LTDSDatei::getSchriftGroessen()
-    const // gibt einen Array von Schriftgroessen zurueck
+const // returns an array of font sizes
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3135,8 +3131,7 @@ unsigned char* LTDSDatei::getSchriftGroessen()
 }
 
 unsigned char LTDSDatei::getAnzahlBuchstaben(
-    int sg) // gibt die anzahl gespeicherter Buchstaben einer Schriftgroesse
-            // zurueck
+int sg) // returns the number of stored characters for a font size
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3169,7 +3164,7 @@ unsigned char LTDSDatei::getAnzahlBuchstaben(
 }
 
 unsigned char* LTDSDatei::getBuchstaben(
-    int sg) // gibt einen Array von Buchstaben einer Schriftgroesse zurueck
+int sg) // returns an array of characters for a font size
 {
     if (!DateiExistiert(dynamic_cast<Text*>(pfad->getThis()))) return 0;
     if (!dateiKopf) return 0;
@@ -3204,8 +3199,8 @@ unsigned char* LTDSDatei::getBuchstaben(
     return ret;
 }
 #endif
-// Bit Funktionen
-int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zurueck
+// Bit functions
+int Framework::Bits(int a) // returns 1-bits in the desired count
 {
     int ret = 0;
     for (int i = 0; i < a; ++i)
@@ -3216,7 +3211,7 @@ int Framework::Bits(int a) // gibt 1-bits in gewinschter anzahl zurueck
     return ret;
 }
 
-int Framework::getBits(char c) // gibt zurueck, wie viele Bits c benoetigt
+int Framework::getBits(char c) // returns how many bits c requires
 {
     int ret = 0;
     for (int i = 0; (c & (char)Bits(i)) != c; ++i)

Text.cpp

@@ -47,11 +47,11 @@ Text::Text(char* t, int l)
       stringWriter(0)
 {
     length = l;
-    txt = t; // neuen Text erstellen
+    txt = t; // create new text
 }
 
-// inhalt der Text Klasse aus Text.h
-// Konstruktor
+// Content of the Text class from Text.h
+// Constructor
 Text::Text()
     : ReferenceCounter(),
       txt(0),
@@ -85,7 +85,7 @@ Text::Text(const char* t)
       precision(-1),
       stringWriter(0)
 {
-    setText(t); // Text setzen
+    setText(t); // set text
 }
 
 Framework::Text::Text(const char* txt, int offset, int length)
@@ -115,23 +115,23 @@ Text::Text(int zahl)
     *this = zahl;
 }
 
-// Erstellt ein neues Text Objekt mit einer zahl als text
-//  num: Die Zahl, die im Text sein soll
+// Creates a new Text object with a number as text
+//  num: The number that should be in the text
 Text::Text(double num)
     : Text()
 {
     *this = num;
 }
 
-// Erstellt ein neues Text Objekt mit einer zahl als text
-//  num: Die Zahl, die im Text sein soll
+// Creates a new Text object with a number as text
+//  num: The number that should be in the text
 Text::Text(float num)
     : Text()
 {
     *this = num;
 }
 
-// Destruktor
+// Destructor
 Text::~Text()
 {
     if (stringWriter) delete stringWriter;
@@ -140,9 +140,9 @@ Text::~Text()
 
 void Framework::Text::setTextZ(char* t, int l)
 {
-    delete[] txt; // alter Text loeschen
+    delete[] txt; // delete old text
     length = l;
-    txt = t; // neuen Text erstellen
+    txt = t; // create new text
 }
 
 void Text::toUpperCase()
@@ -187,54 +187,54 @@ void Text::toLowerCase()
     }
 }
 
-// nicht constant
+// non-constant
 void Text::setSuchGrenzen(
-    char gBeg, char gEnd) // sucht bei jeder suchfunktion nicht zwischen den
-                          // Zeichen gBeg und gEnd
+char gBeg, char gEnd) // for every search function, does not search between
+                      // the characters gBeg and gEnd
 {
     suchGBeg = gBeg;
     suchGEnd = gEnd;
 }
 
-void Text::setText(const char* t) // ersetzt den Text
+void Text::setText(const char* t) // replaces the text
 {
-    setText(t, textLength(t)); // Text setzen
+    setText(t, textLength(t)); // set text
 }
 
-// unconstant
-void Text::setText(const char* t, int l) // ersetzt den Text
+// non-constant
+void Text::setText(const char* t, int l) // replaces the text
 {
-    delete[] txt; // alter Text loeschen
+    delete[] txt; // delete old text
     length = l;
-    txt = new char[(__int64)length + 1]; // neuen Text erstellen
-    for (int i = 0; i < length; ++i)     // Text befuellen
+    txt = new char[(__int64)length + 1]; // create new text
+    for (int i = 0; i < length; ++i)     // fill text
         txt[i] = t[i];
-    txt[length] = '\0'; // Textende Festlegen
+    txt[length] = '\0'; // set text end
 }
 
 void Text::setText(const Text& t)
 {
-    setText(t, t.getLength()); // Text setzen
+    setText(t, t.getLength()); // set text
 }
 
-void Text::append(char c) // haengt an den Text an
+void Text::append(char c) // appends to the text
 {
     append(&c, 1);
 }
 
-void Text::append(const char* t) // haengt an den Text an
+void Text::append(const char* t) // appends to the text
 {
-    int tl = (int)textLength(t);                    // laenge der uebergabe
-    char* res = new char[(__int64)tl + length + 1]; // neuen Text erstellen
-    for (int i = 0; i < length; ++i)                // mit jetzigem Text fuellen
+    int tl = (int)textLength(t);                    // length of the argument
+    char* res = new char[(__int64)tl + length + 1]; // create new text
+    for (int i = 0; i < length; ++i)                // fill with current text
         res[i] = txt[i];
-    for (int i = 0; i < tl; ++i) // UEbergabe anhaengen
+    for (int i = 0; i < tl; ++i) // append argument
         res[length + i] = t[i];
-    res[length + tl] = '\0';    // Textende festlegen
-    setTextZ(res, length + tl); // Test setzen
+    res[length + tl] = '\0';    // set text end
+    setTextZ(res, length + tl); // set text
 }
 
-void Text::appendHex(char num) // haengt die zahl in hex anden Text an
+void Text::appendHex(char num) // appends the number in hex to the text
 {
     char* res = new char[(__int64)length + sizeof(char) * 2 + 1];
     for (int i = 0; i < length; ++i)
@@ -264,7 +264,7 @@ void Framework::Text::appendHex(short num)
     setTextZ(res, length + sizeof(short) * 2);
 }
 
-void Text::appendHex(int num) // haengt die zahl in hex anden Text an
+void Text::appendHex(int num) // appends the number in hex to the text
 {
     char* res = new char[(__int64)length + sizeof(int) * 2 + 1];
     for (int i = 0; i < length; ++i)
@@ -279,7 +279,7 @@ void Text::appendHex(int num) // haengt die zahl in hex anden Text an
     setTextZ(res, length + sizeof(int) * 2);
 }
 
-void Text::appendHex(__int64 num) // haengt die zahl in hex anden Text an
+void Text::appendHex(__int64 num) // appends the number in hex to the text
 {
     char* res = new char[(__int64)length + sizeof(__int64) * 2 + 1];
     for (int i = 0; i < length; ++i)
@@ -294,21 +294,21 @@ void Text::appendHex(__int64 num) // haengt die zahl in hex anden Text an
     setTextZ(res, length + sizeof(__int64) * 2);
 }
 
-void Text::append(const char* t, int l)            // haengt an den Text an
-{                                                  // laenge des Textes
-    char* res = new char[(__int64)l + length + 1]; // neuen Text erstellen
-    for (int i = 0; i < length; ++i)               // mit jetzigem Text fuellen
+void Text::append(const char* t, int l)            // appends to the text
+{                                                  // length of the text
+    char* res = new char[(__int64)l + length + 1]; // create new text
+    for (int i = 0; i < length; ++i)               // fill with current text
         res[i] = txt[i];
-    for (int i = 0; i < l; ++i) // UEbergabe anhaengen
+    for (int i = 0; i < l; ++i) // append argument
         res[length + i] = t[i];
-    res[length + l] = '\0';    // Textende festlegen
-    setTextZ(res, length + l); // Test setzen
+    res[length + l] = '\0';    // set text end
+    setTextZ(res, length + l); // set text
 }
 
 void Text::append(const Text& t)
 {
-    if (t.getLength() > 0)        // Auf unsinnige uebergabe pruefen
-        append(t, t.getLength()); // Text anhaengen
+    if (t.getLength() > 0)        // check for invalid argument
+        append(t, t.getLength()); // append text
 }
 
 void Text::append(int num)
@@ -319,9 +319,8 @@ void Text::append(int num)
     append(string.c_str(), (int)string.length());
 }
 
-// Haengt eine Zahl ans Ende Des Textes an
-//  num: Die Zahl, die in einen Text umgewandelt und am Ende angehaengt werden
-//  soll
+// Appends a number to the end of the text
+//  num: The number to convert to text and append at the end
 void Text::append(__int64 num)
 {
     std::stringstream ss;
@@ -380,7 +379,7 @@ void Text::append(float num)
     append(str, len);
 }
 
-//! Gibt einen ostream zurueck, der alle ausgaben an diesen Text anhaengt
+//! Returns an ostream that appends all output to this text
 FlushingOStream Text::append()
 {
     if (!stringWriter)
@@ -395,43 +394,43 @@ FlushingOStream Text::append()
     return FlushingOStream(stringWriter);
 }
 
-void Text::insert(int p, char c) // Fuegt an stelle p ein
+void Text::insert(int p, char c) // inserts at position p
 {
-    if (p > length || p < 0) // Auf unsinnige uebergabe pruefen
+    if (p > length || p < 0) // check for invalid argument
         return;
-    char* res = new char[(__int64)length + 2]; // neuer Text erstellen
-    for (int i = 0; i < p; ++i)                // Text fuellen
+    char* res = new char[(__int64)length + 2]; // create new text
+    for (int i = 0; i < p; ++i)                // fill text
         res[i] = txt[i];
     res[p] = c;
-    for (int i = p; i < length; ++i) // Text fuellen
+    for (int i = p; i < length; ++i) // fill text
         res[i + 1] = txt[i];
-    res[length + 1] = '\0';    // Text ende festlegen
-    setTextZ(res, length + 1); // Text setzen
+    res[length + 1] = '\0';    // set text end
+    setTextZ(res, length + 1); // set text
 }
 
-void Text::insert(int p, const char* t) // Fuegt an stelle p ein
+void Text::insert(int p, const char* t) // inserts at position p
 {
-    insert(p, t, textLength(t)); // Text einfuegen
+    insert(p, t, textLength(t)); // insert text
 }
 
 void Framework::Text::insert(int p, const char* t, int len)
 {
-    if (p > length || p < 0 || len <= 0) // Auf unsinnige uebergabe pruefen
-        return;                          // Laenge der uebergabe
-    char* res = new char[(__int64)len + length + 1]; // neuer Text erstellen
-    for (int i = 0; i < p; ++i)                      // Text fuellen
+    if (p > length || p < 0 || len <= 0) // check for invalid argument
+        return;                          // length of argument
+    char* res = new char[(__int64)len + length + 1]; // create new text
+    for (int i = 0; i < p; ++i)                      // fill text
         res[i] = txt[i];
-    for (int i = 0; i < len; ++i) // Text einfuegen
+    for (int i = 0; i < len; ++i) // insert text
         res[i + p] = t[i];
-    for (int i = p; i < length; ++i) // Text fuellen
+    for (int i = p; i < length; ++i) // fill text
         res[i + len] = txt[i];
-    res[len + length] = '\0';    // Text ende festlegen
-    setTextZ(res, length + len); // Text setzen
+    res[len + length] = '\0';    // set text end
+    setTextZ(res, length + len); // set text
 }
 
 void Text::insert(int p, const Text& t)
 {
-    insert(p, t, t.getLength()); // Text einfuegen
+    insert(p, t, t.getLength()); // insert text
 }
 
 void Framework::Text::regexReplace(
@@ -502,89 +501,89 @@ void Framework::Text::regexReplace(const char* regex,
 }
 
 void Text::ersetzen(
-    int p1, int p2, const char* t) // Ersetzt den Text von p1 bis p2
+    int p1, int p2, const char* t) // replaces text from p1 to p2
 {
-    ersetzen(p1, p2, t, textLength(t)); // Text ersetzen
+    ersetzen(p1, p2, t, textLength(t)); // replace text
 }
 
 void Framework::Text::ersetzen(int p1, int p2, const char* t, int len)
 {
     if (p1 > p2)
     {
-        int x = p1; // p1 und p2 tauschen
+        int x = p1; // swap p1 and p2
         p1 = p2;
         p2 = x;
     }
-    remove(p1, p2); // Textabschnitt von p1 zu p2 loeschen
+    remove(p1, p2); // delete text section from p1 to p2
     if (len > 0)
     {
-        insert(p1, t, len); // UEbergabe bei p1 einfuegen}
+        insert(p1, t, len); // insert argument at p1
     }
 }
 
 void Text::ersetzen(int p1, int p2, const Text& t)
 {
-    ersetzen(p1, p2, t, t.getLength()); // Text ersetzen
+    ersetzen(p1, p2, t, t.getLength()); // replace text
 }
 
-void Text::ersetzen(char c1, char c2) // ersetzt jedes c1 durch c2
+void Text::ersetzen(char c1, char c2) // replaces every c1 with c2
 {
-    if (c1 == '\0' || c2 == '\0') // Auf unsinnige uebergabe pruefen
+    if (c1 == '\0' || c2 == '\0') // check for invalid argument
         return;
-    if (!hat(c1)) // pruefen ob c1 vorhanden
+    if (!hat(c1)) // check if c1 exists
         return;
     int suchGCount = 0;
     if (suchGBeg && suchGEnd)
     {
-        for (int i = 0; i < length; ++i) // Text durchsuchen
+        for (int i = 0; i < length; ++i) // search text
         {
             bool b = suchGCount != 0;
-            if (txt[i] == c1 && !suchGCount) txt[i] = c2; // Text ersetzen
+            if (txt[i] == c1 && !suchGCount) txt[i] = c2; // replace text
             if (txt[i] == suchGBeg) ++suchGCount;
             if (txt[i] == suchGEnd) --suchGCount;
-            if (txt[i] == c1 && !suchGCount && b) txt[i] = c2; // Text ersetzen
+            if (txt[i] == c1 && !suchGCount && b) txt[i] = c2; // replace text
         }
     }
     else
     {
-        for (int i = 0; i < length; ++i) // Text durchsuchen
+        for (int i = 0; i < length; ++i) // search text
         {
-            if (txt[i] == c1) txt[i] = c2; // Text ersetzen
+            if (txt[i] == c1) txt[i] = c2; // replace text
         }
     }
 }
 
-void Text::ersetzen(const char* t1, const char* t2) // ersetzt jedes t1 durch t2
+void Text::ersetzen(const char* t1, const char* t2) // replaces every t1 with t2
 {
-    ersetzen(t1, textLength(t1), t2, textLength(t2)); // Text ersetzen
+    ersetzen(t1, textLength(t1), t2, textLength(t2)); // replace text
 }
 
 void Framework::Text::ersetzen(
     const char* t1, int len1, const char* t2, int len2)
 {
-    if (len1 > length || len1 <= 0) // Auf unsinnige uebergabe pruefen
+    if (len1 > length || len1 <= 0) // check for invalid argument
         return;
-    if (!hat(t1, len1)) // pruefen ob t1 vorhanden
+    if (!hat(t1, len1)) // check if t1 exists
         return;
-    int anz = anzahlVon(t1, len1); // Anzahl von t1 im Text
+    int anz = anzahlVon(t1, len1); // count of t1 in text
     int* begin = new int[anz];
     int* end = new int[anz];
     int searchStart = 0;
-    for (int i = 0; i < anz; ++i) // Positionen von t1 speichern
+    for (int i = 0; i < anz; ++i) // save positions of t1
     {
         begin[i] = positionVon(searchStart, t1, len1);
         end[i] = begin[i] + len1;
         searchStart = end[i];
     }
     int resl
-        = (length - (anz * len1)) + (anz * len2) + 1; // Laenge des Ergebneses
-    char* res = new char[resl];                       // neuer Text erstellen
-    int rep = 0;              // Speichert bei welchen t1 man sich befindet
-    int last = 0;             // Fuellposition von txt
-    int neu = 0;              // Fuellporition von res
-    for (; neu < resl; ++neu) // Text befuellen
+        = (length - (anz * len1)) + (anz * len2) + 1; // length of result
+    char* res = new char[resl];                       // create new text
+    int rep = 0;              // stores which t1 we are at
+    int last = 0;             // fill position in txt
+    int neu = 0;              // fill position in res
+    for (; neu < resl; ++neu) // fill text
     {
-        if (rep < anz && last == begin[rep]) // Text ersetzen
+        if (rep < anz && last == begin[rep]) // replace text
         {
             last = end[rep];
             ++rep;
@@ -597,87 +596,87 @@ void Framework::Text::ersetzen(
             if (neu >= resl) break;
             --neu;
         }
-        else // Text Kopieren
+        else // copy text
         {
             res[neu] = txt[last];
             ++last;
         }
     }
-    res[resl - 1] = '\0'; // Textende festlegen
-    setTextZ(res, resl);  // Text setzen
-    delete[] begin;       // Speicher freigeben
+    res[resl - 1] = '\0'; // set text end
+    setTextZ(res, resl);  // set text
+    delete[] begin;       // free memory
     delete[] end;
 }
 
 void Text::ersetzen(const Text& t1, const char* t2)
 {
-    ersetzen(t1, t1.getLength(), t2, textLength(t2)); // Text ersetzen
+    ersetzen(t1, t1.getLength(), t2, textLength(t2)); // replace text
 }
 
 void Text::ersetzen(const char* t1, const Text& t2)
 {
-    ersetzen(t1, textLength(t1), t2, t2.getLength()); // Text ersetzen
+    ersetzen(t1, textLength(t1), t2, t2.getLength()); // replace text
 }
 
 void Text::ersetzen(const Text& t1, const Text& t2)
 {
-    ersetzen(t1, t1.getLength(), t2, t2.getLength()); // Text ersetzen
+    ersetzen(t1, t1.getLength(), t2, t2.getLength()); // replace text
 }
 
-void Text::ersetzen(int index, char c1, char c2) // ersetzt das i-te c1 durch c2
+void Text::ersetzen(int index, char c1, char c2) // replaces the i-th c1 with c2
 {
     if (c1 == '\0' || c2 == '\0'
-        || index < 0) // Auf unsinnige uebergabe pruefen
+        || index < 0) // check for invalid argument
         return;
-    if (!hat(c1)) // pruefen ob c1 vorhanden
+    if (!hat(c1)) // check if c1 exists
         return;
     int anz = anzahlVon(c1);
-    if (index >= anz) // pruefen ob es ein i-tes c1 gibt
+    if (index >= anz) // check if an i-th c1 exists
         return;
     txt[positionVon(c1, index)] = c2;
 }
 
 void Text::ersetzen(int index,
     const char* t1,
-    const char* t2) // ersetzt das i-te t1 durch t2
+    const char* t2) // replaces the i-th t1 with t2
 {
-    ersetzen(index, t1, textLength(t1), t2, textLength(t2)); // Text ersetzen
+    ersetzen(index, t1, textLength(t1), t2, textLength(t2)); // replace text
 }
 
 void Framework::Text::ersetzen(
     int index, const char* t1, int len1, const char* t2, int len2)
 {
     if (len1 >= length || len1 <= 0
-        || index < 0) // Auf unsinnige uebergabe pruefen
+        || index < 0) // check for invalid argument
         return;
-    if (!hat(t1)) // pruefen ob t1 vorhanden
+    if (!hat(t1)) // check if t1 exists
         return;
-    int anz = anzahlVon(t1, len1); // Anzahl von t1 im Text
-    if (index >= anz)              // pruefen ob es ein i-tes t1 gibt
+    int anz = anzahlVon(t1, len1); // count of t1 in text
+    if (index >= anz)              // check if an i-th t1 exists
         return;
     int begin = positionVon(index, len1, t1);
     int end = begin + len1;
-    ersetzen(begin, end, t2, len2); // ersetzen
+    ersetzen(begin, end, t2, len2); // replace
 }
 
 void Text::ersetzen(int i, const Text& t1, const char* t2)
 {
-    ersetzen(i, t1, t1.getLength(), t2, textLength(t2)); // ersetzen
+    ersetzen(i, t1, t1.getLength(), t2, textLength(t2)); // replace
 }
 
 void Text::ersetzen(int i, const char* t1, const Text& t2)
 {
-    ersetzen(i, t1, textLength(t1), t2, t2.getLength()); // ersetzen
+    ersetzen(i, t1, textLength(t1), t2, t2.getLength()); // replace
 }
 
 void Text::ersetzen(int i, const Text& t1, const Text& t2)
 {
     ersetzen(i, t1, t1.getLength(), t2,
-        t2.getLength()); // ersetzen
+        t2.getLength()); // replace
 }
 
 void Text::fillText(
-    char c, int len) // setzt den Text zu so vielen c wie laen gross ist
+char c, int len) // sets the text to as many c as len is large
 {
     char* res = new char[(__int64)len + 1];
     for (int i = 0; i < len; ++i)
@@ -686,48 +685,48 @@ void Text::fillText(
     setTextZ(res, len);
 }
 
-void Text::remove(int p) // loescht p
+void Text::remove(int p) // deletes p
 {
-    if (p < 0 || p >= length) // Auf unsinnige uebergabe pruefen
+    if (p < 0 || p >= length) // check for invalid argument
         return;
-    char* res = new char[length];             // neuen Text anlegen
-    for (int i = 0; i < p && i < length; ++i) // Text befuellen
+    char* res = new char[length];             // create new text
+    for (int i = 0; i < p && i < length; ++i) // fill text
         res[i] = txt[i];
     for (int i = p + 1; i < length; ++i)
         res[i - 1] = txt[i];
     res[length - 1] = 0;
-    setTextZ(res, length - 1); // Text setzen
+    setTextZ(res, length - 1); // set text
 }
 
-void Text::remove(int p1, int p2) // loescht von p1 zu p2 ( p2 bleibt )
+void Text::remove(int p1, int p2) // deletes from p1 to p2 (p2 is kept)
 {
     if (p1 == p2) return;
-    if (p1 > p2) // p1 und p2 tauschen
+    if (p1 > p2) // swap p1 and p2
     {
         int x = p1;
         p1 = p2;
         p2 = x;
     }
-    if (p1 < 0) // Auf unsinnige uebergabe pruefen
+    if (p1 < 0) // check for invalid argument
         p1 = 0;
     if (p2 > length) p2 = length;
-    int resl = length - (p2 - p1);           // Laenge vom Ergebnis
-    char* res = new char[(__int64)resl + 1]; // Neuen Text erstellen
+    int resl = length - (p2 - p1);           // length of result
+    char* res = new char[(__int64)resl + 1]; // create new text
     memcpy(res, txt, p1);
     memcpy(res + p1, txt + p2, length - p2);
-    res[resl] = '\0';    // Testende festlegen
-    setTextZ(res, resl); // Text setzen
+    res[resl] = '\0';    // set text end
+    setTextZ(res, resl); // set text
 }
 
-void Text::remove(char c) // loescht jetes c
+void Text::remove(char c) // deletes every c
 {
-    if (!hat(c)) // pruefen ob c vorhanden
+    if (!hat(c)) // check if c exists
         return;
-    int anz = anzahlVon(c);                          // Anzahl von c
-    char* res = new char[(__int64)length - anz + 1]; // neuen Text erstellen
+    int anz = anzahlVon(c);                          // count of c
+    char* res = new char[(__int64)length - anz + 1]; // create new text
     int anz2 = 0;
     int suchGCount = 0;
-    for (int i = 0; i < length; ++i) // Text befuellen
+    for (int i = 0; i < length; ++i) // fill text
     {
         bool b = suchGCount != 0;
         if (txt[i] == c && !suchGCount)
@@ -744,99 +743,99 @@ void Text::remove(char c) // loescht jetes c
                 res[i - anz2] = txt[i];
         }
     }
-    res[length - anz] = '\0';    // Textende festlegen
-    setTextZ(res, length - anz); // Text setzen
+    res[length - anz] = '\0';    // set text end
+    setTextZ(res, length - anz); // set text
 }
 
-void Text::remove(const char* t) // loescht jetes t
+void Text::remove(const char* t) // deletes every t
 {
-    remove(t, textLength(t)); // Text loeschen
+    remove(t, textLength(t)); // delete text
 }
 
 void Framework::Text::remove(const char* t, int len)
 {
-    if (len <= 0 || len > length) // Auf unsinnige uebergabe pruefen
+    if (len <= 0 || len > length) // check for invalid argument
         return;
-    if (!hat(t, len)) // pruefen ob Text ein t enthaelt
+    if (!hat(t, len)) // check if text contains t
         return;
-    int anz = anzahlVon(t, len); // anzahl von t
+    int anz = anzahlVon(t, len); // count of t
     int* begin = new int[anz];
-    for (int i = 0; i < anz; ++i) // begin aller t-s finden
+    for (int i = 0; i < anz; ++i) // find start of all t's
         begin[i] = positionVon(i, len, t);
-    int resl = length - (anz * len);         // Laenge vom Ergebnes
-    char* res = new char[(__int64)resl + 1]; // neuen Text erzeugen
+    int resl = length - (anz * len);         // length of result
+    char* res = new char[(__int64)resl + 1]; // create new text
     int del = 0;
-    for (int i = 0; i < length; ++i) // Text befuellen
+    for (int i = 0; i < length; ++i) // fill text
     {
-        if (del < anz && i == begin[del]) // Text auslassen
+        if (del < anz && i == begin[del]) // skip text
         {
             i += len - 1;
             ++del;
         }
         else
-            res[i - (del * len)] = txt[i]; // Text befuellen
+            res[i - (del * len)] = txt[i]; // fill text
     }
-    res[resl] = '\0';    // Text ende festlegen
-    setTextZ(res, resl); // Text setzen
+    res[resl] = '\0';    // set text end
+    setTextZ(res, resl); // set text
     delete[] begin;
 }
 
 void Text::remove(const Text& t)
 {
-    remove(t, t.getLength()); // Text loeschen
+    remove(t, t.getLength()); // delete text
 }
 
 void Text::remove(int index, char c)
 {
-    if (index < 0 || !hat(c)) // Auf unsinnige uebergabe pruefen
+    if (index < 0 || !hat(c)) // check for invalid argument
         return;
-    int anz = anzahlVon(c); // anzahl der i-s
-    if (index >= anz)       // pruefen ob ein i-tes c vorhanden ist
+    int anz = anzahlVon(c); // count of c's
+    if (index >= anz)       // check if an i-th c exists
         return;
-    int pos = positionVon(c, index); // Position vom i-ten c
+    int pos = positionVon(c, index); // position of the i-th c
     if (pos < 0) return;
     if (!length) return;
-    char* res = new char[length];               // neuen Text erzeugen
-    for (int i = 0; i < pos && i < length; ++i) // Text befuellen
+    char* res = new char[length];               // create new text
+    for (int i = 0; i < pos && i < length; ++i) // fill text
         res[i] = txt[i];
     for (int i = pos + 1; i < length; ++i)
         res[i - 1] = txt[i];
-    res[length - 1] = '\0';    // Text ende festlegen
-    setTextZ(res, length - 1); // Text setzen
+    res[length - 1] = '\0';    // set text end
+    setTextZ(res, length - 1); // set text
 }
 
-void Text::remove(int index, const char* t) // loescht das i-te t
+void Text::remove(int index, const char* t) // deletes the i-th t
 {
-    remove(index, t, textLength(t)); // Text loeschen
+    remove(index, t, textLength(t)); // delete text
 }
 
 void Framework::Text::remove(int index, const char* t, int len)
 {
     if (index < 0 || !hat(t, len)
-        || len <= 0) // Auf unsinnige uebergabe pruefen
+        || len <= 0) // check for invalid argument
         return;
-    int anz = anzahlVon(t, len); // anzahl der i-s
-    if (index >= anz)            // pruefen ob ein i-tes c vorhanden ist
+    int anz = anzahlVon(t, len); // count of t's
+    if (index >= anz)            // check if an i-th t exists
         return;
-    int pos = positionVon(index, len, t); // Position vom i-ten c
+    int pos = positionVon(index, len, t); // position of the i-th t
     if (pos < 0) return;
     if (!length) return;
-    char* res = new char[(__int64)length - len + 1];      // neuen Text erzeugen
-    for (int i = 0; i < pos && i < length - len + 1; ++i) // Text befuellen
+    char* res = new char[(__int64)length - len + 1];      // create new text
+    for (int i = 0; i < pos && i < length - len + 1; ++i) // fill text
         res[i] = txt[i];
     for (int i = pos + len; i < length; ++i)
         res[i - len] = txt[i];
-    res[length - len] = '\0';    // Text ende festlegen
-    setTextZ(res, length - len); // Text setzen
+    res[length - len] = '\0';    // set text end
+    setTextZ(res, length - len); // set text
 }
 
 void Text::remove(int i, const Text& t)
 {
-    remove(i, t, t.getLength()); // Text loeschen
+    remove(i, t, t.getLength()); // delete text
 }
 
-// Loescht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
-//  pos: Die Position des ersten zeichens
+// Deletes all ' ', '\n', '\r', '\t' until a different character
+//  pos: The position of the first character
 int Text::removeWhitespaceAfter(int pos)
 {
     int removedLength = 0;
@@ -851,8 +850,8 @@ int Text::removeWhitespaceAfter(int pos)
     return length;
 }
 
-// Loescht alle ' ', '\n', '\r', '\t' bis zu einem anderen buchstaben
-//  pos: Die Position des ersten zeichens (beginnt bei pos-1)
+// Deletes all ' ', '\n', '\r', '\t' until a different character
+//  pos: The position of the first character (starts at pos-1)
 int Text::removeWhitespaceBefore(int pos)
 {
     int length = 0;
@@ -868,13 +867,13 @@ int Text::removeWhitespaceBefore(int pos)
 }
 
 void Text::setPrecision(
-    int p) // setzt die Anzahl der Nachkommastellen bei doubles
+int p) // sets the number of decimal places for doubles
 {
     precision = p;
 }
 
 // constant
-int Text::getLength() const // gibt die Text laenge zurueck
+int Text::getLength() const // returns the text length
 {
     return length;
 }
@@ -956,14 +955,14 @@ int Text::getUKick(int pos) const
     return pos + llen + lpos;
 }
 
-bool Text::hat(const Text& t) const // enthaelt der Text t
+bool Text::hat(const Text& t) const // does the text contain t
 {
-    return hat(t, t.getLength()); // Text ueberpruefen
+    return hat(t, t.getLength()); // check text
 }
 
 bool Text::hat(const char* t) const
 {
-    return hat(t, textLength(t)); // Text ueberpruefen
+    return hat(t, textLength(t)); // check text
 }
 
 bool Framework::Text::hat(const char* t, int len) const
@@ -973,22 +972,22 @@ bool Framework::Text::hat(const char* t, int len) const
 
 bool Framework::Text::hat(int searchStartIndex, const char* t) const
 {
-    return hat(searchStartIndex, t, textLength(t)); // Text ueberpruefen
+    return hat(searchStartIndex, t, textLength(t)); // check text
 }
 
 bool Framework::Text::hat(int searchStartIndex, const char* t, int len) const
 {
     if (len <= 0
-        || len > length - searchStartIndex) // Auf unsinnige uebergabe pruefen
+        || len > length - searchStartIndex) // check for invalid argument
         return 0;
     int suchGCount = 0;
-    for (int i = searchStartIndex; i + len <= length; ++i) // Text durchsuchen
+    for (int i = searchStartIndex; i + len <= length; ++i) // search text
     {
         bool searched = 0;
         if (!suchGCount)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // Text ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check text
                 b &= txt[i + ii] == t[ii];
             if (b) return 1;
             searched = 1;
@@ -998,7 +997,7 @@ bool Framework::Text::hat(int searchStartIndex, const char* t, int len) const
         if (!suchGCount && !searched)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // Text ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check text
                 b &= txt[i + ii] == t[ii];
             if (b) return 1;
         }
@@ -1006,46 +1005,46 @@ bool Framework::Text::hat(int searchStartIndex, const char* t, int len) const
     return 0;
 }
 
-// UEberprueft, ob im Text der Inhalt eines anderen Textes vorkommt
-//  t: Der Text, nach dessen Inhalt gesucht werden soll
-//  return: (true), wenn der Inhalt des Textes vorkommt. (false) sonnst
-//  pos: die position an der die zeichenkette im string beginnen soll
+// Checks whether the text contains the content of another text
+//  t: The text whose content to search for
+//  return: (true) if the content is found. (false) otherwise
+//  pos: the position where the string should begin
 bool Text::hatAt(int pos, const Text& t) const
 {
-    return hatAt(pos, t, t.getLength()); // Text ueberpruefen
+    return hatAt(pos, t, t.getLength()); // check text
 }
 
-// UEberprueft, ob im Text eine bestimmte Zeichenkette vorkommt
-//  t: Die Zeichenkette, nach der gesucht werden soll
-//  return: (true), wenn die Zeichenkette vorkommt. (false) sonnst
-//  pos: die position an der die zeichenkette im string beginnen soll
+// Checks whether the text contains a specific string
+//  t: The string to search for
+//  return: (true) if the string is found. (false) otherwise
+//  pos: the position where the string should begin
 bool Text::hatAt(int pos, const char* t) const
 {
-    return hatAt(pos, t, textLength(t)); // Text ueberpruefen
+    return hatAt(pos, t, textLength(t)); // check text
 }
 
 bool Framework::Text::hatAt(int pos, const char* t, int len) const
 {
-    if (len <= 0 || len + pos > length) // Auf unsinnige uebergabe pruefen
+    if (len <= 0 || len + pos > length) // check for invalid argument
         return 0;
     bool b = 1;
-    for (int i = 0; i < len; ++i) // Text ueberpruefen
+    for (int i = 0; i < len; ++i) // check text
         b &= txt[pos + i] == t[i];
     return b;
 }
 
-bool Text::hat(char c) const // enthaelt c
+bool Text::hat(char c) const // contains c
 {
     bool ret = 0;
     int suchGCount = 0;
-    for (int i = 0; i < length; ++i) // suchen
+    for (int i = 0; i < length; ++i) // search
     {
         bool b = suchGCount != 0;
-        if (!suchGCount) // ueberpruefen
+        if (!suchGCount) // check
             ret |= txt[i] == c;
         if (txt[i] == suchGBeg) ++suchGCount;
         if (txt[i] == suchGEnd) --suchGCount;
-        if (!suchGCount && b) // ueberpruefen
+        if (!suchGCount && b) // check
             ret |= txt[i] == c;
     }
     return ret;
@@ -1062,88 +1061,88 @@ bool Text::endsWith(const char* t) const
     return hatAt(length - len, t, len);
 }
 
-bool Text::istGleich(const char* t) const // prueft ob det Text gleich t ist
+bool Text::istGleich(const char* t) const // checks if the text equals t
 {
-    return istGleich(t, textLength(t)); // Text ueberpruefen
+    return istGleich(t, textLength(t)); // check text
 }
 
 bool Text::istGleich(
-    const char* t, int len) const // prueft ob det Text gleich t ist
+    const char* t, int len) const // checks if the text equals t
 {
-    if (length != len) // Auf unsinniege UEbergabe pruefen
+    if (length != len) // check for invalid argument
         return 0;
     if (length == -1) return 1;
     bool ret = true;
-    for (int i = 0; i < len; ++i) // pruefen
+    for (int i = 0; i < len; ++i) // check
         ret &= txt[i] == t[i];
     return ret;
 }
 
 bool Text::istGleich(const Text& t) const
 {
-    return istGleich(t, t.getLength()); // Text ueberpruefen
+    return istGleich(t, t.getLength()); // check text
 }
 
-const char* Text::getText() const // gibt Text zurueck
+const char* Text::getText() const // returns the text
 {
     return txt;
 }
 
-int Text::anzahlVon(char c) const // gibt die Anzahl von c im Text zurueck
+int Text::anzahlVon(char c) const // returns the count of c in the text
 {
     int ret = 0;
     int suchGCount = 0;
     if (suchGBeg && suchGEnd)
     {
-        for (int i = 0; i < length; ++i) // suchen
+        for (int i = 0; i < length; ++i) // search
         {
             bool b = suchGCount != 0;
-            ret += txt[i] == c && !suchGCount; // zaehlen
+            ret += txt[i] == c && !suchGCount; // count
             if (txt[i] == suchGBeg) ++suchGCount;
             if (txt[i] == suchGEnd) --suchGCount;
-            ret += txt[i] == c && !suchGCount && b; // zaehlen
+            ret += txt[i] == c && !suchGCount && b; // count
         }
     }
     else
     {
-        for (int i = 0; i < length; ++i) // suchen
+        for (int i = 0; i < length; ++i) // search
         {
-            ret += txt[i] == c; // zaehlen
+            ret += txt[i] == c; // count
         }
     }
     return ret;
 }
 
 int Text::anzahlVon(
-    const char* t) const // gibt die Anzahl von t im Text zurueck
+    const char* t) const // returns the count of t in the text
 {
-    return anzahlVon(t, textLength(t)); // Text ueberpruefen
+    return anzahlVon(t, textLength(t)); // check text
 }
 
 int Framework::Text::anzahlVon(const char* t, int len) const
 {
-    if (len <= 0 || len > length) // Auf unsinnige uebergabe pruefen
+    if (len <= 0 || len > length) // check for invalid argument
         return 0;
     int ret = 0;
     int suchGCount = 0;
-    for (int i = 0; i + len <= length; ++i) // suchen
+    for (int i = 0; i + len <= length; ++i) // search
     {
         bool b = suchGCount != 0;
         if (!suchGCount)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
-            if (b) ++ret; // zaehlen
+            if (b) ++ret; // count
         }
         if (txt[i] == suchGBeg) ++suchGCount;
         if (txt[i] == suchGEnd) --suchGCount;
         if (!suchGCount && b)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
-            if (b) ++ret; // zaehlen
+            if (b) ++ret; // count
         }
     }
     return ret;
@@ -1151,27 +1150,27 @@ int Framework::Text::anzahlVon(const char* t, int len) const
 
 int Text::anzahlVon(const Text& t) const
 {
-    return anzahlVon(t, t.getLength()); // Text ueberpruefen
+    return anzahlVon(t, t.getLength()); // check text
 }
 
-int Text::positionVon(char c) const // gibt die Position des ersten c zurueck
+int Text::positionVon(char c) const // returns the position of the first c
 {
     int suchGCount = 0;
-    for (int i = 0; i < length; ++i) // suchen
+    for (int i = 0; i < length; ++i) // search
     {
         bool b = suchGCount != 0;
-        if (txt[i] == c && !suchGCount) // ueberpruefen
+        if (txt[i] == c && !suchGCount) // check
             return i;
         if (txt[i] == suchGBeg) ++suchGCount;
         if (txt[i] == suchGEnd) --suchGCount;
-        if (txt[i] == c && !suchGCount && b) // ueberpruefen
+        if (txt[i] == c && !suchGCount && b) // check
             return i;
     }
     return -1;
 }
 
 int Text::positionVon(
-    const char* t) const // gibt die Position des ersten t zurueck
+const char* t) const // returns the position of the first t
 {
     return positionVon(textLength(t), t);
 }
@@ -1184,16 +1183,16 @@ int Framework::Text::positionVon(int len, const char* t) const
 int Text::positionVon(int searchStart, const char* t, int len) const
 {
     if (len <= 0
-        || len > length - searchStart) // Auf unsinnige uebergabe pruefen
+        || len > length - searchStart) // check for invalid argument
         return -1;
     int suchGCount = 0;
-    for (int i = searchStart; i + len <= length; ++i) // suchen
+    for (int i = searchStart; i + len <= length; ++i) // search
     {
         bool b = suchGCount != 0;
         if (!suchGCount)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
             if (b) return i;
         }
@@ -1202,7 +1201,7 @@ int Text::positionVon(int searchStart, const char* t, int len) const
         if (!suchGCount && b)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
             if (b) return i;
         }
@@ -1212,18 +1211,18 @@ int Text::positionVon(int searchStart, const char* t, int len) const
 
 int Text::positionVon(const Text& t) const
 {
-    return positionVon(t.getLength(), t); // Text ueberpruefen
+    return positionVon(t.getLength(), t); // check text
 }
 
 int Text::positionVon(
-    char c, int index) const // gibt die Position des i-ten c zurueck
+    char c, int index) const // returns the position of the i-th c
 {
     int ii = 0;
     int suchGCount = 0;
-    for (int i = 0; i < length; ++i) // suchen
+    for (int i = 0; i < length; ++i) // search
     {
         bool b = suchGCount != 0;
-        if (txt[i] == c && !suchGCount) // ueberpruefen
+        if (txt[i] == c && !suchGCount) // check
         {
             if (ii == index)
                 return i;
@@ -1232,7 +1231,7 @@ int Text::positionVon(
         }
         if (txt[i] == suchGBeg) ++suchGCount;
         if (txt[i] == suchGEnd) --suchGCount;
-        if (txt[i] == c && !suchGCount && b) // ueberpruefen
+        if (txt[i] == c && !suchGCount && b) // check
         {
             if (ii == index)
                 return i;
@@ -1244,24 +1243,24 @@ int Text::positionVon(
 }
 
 int Text::positionVon(
-    const char* t, int index) const // gibt die Position des i-ten t zurueck
+    const char* t, int index) const // returns the position of the i-th t
 {
-    return positionVon(index, textLength(t), t); // Text ueberpruefen
+    return positionVon(index, textLength(t), t); // check text
 }
 
 int Framework::Text::positionVon(int index, int len, const char* t) const
 {
-    if (len <= 0 || len > length) // Auf unsinnige uebergabe pruefen
+    if (len <= 0 || len > length) // check for invalid argument
         return 0;
     int i2 = 0;
     int suchGCount = 0;
-    for (int i = 0; i + len <= length; ++i) // suchen
+    for (int i = 0; i + len <= length; ++i) // search
     {
         bool b = suchGCount != 0;
         if (!suchGCount)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
             if (b)
             {
@@ -1276,7 +1275,7 @@ int Framework::Text::positionVon(int index, int len, const char* t) const
         if (!suchGCount && b)
         {
             bool b = 1;
-            for (int ii = 0; ii < len; ++ii) // ueberpruefen
+            for (int ii = 0; ii < len; ++ii) // check
                 b &= txt[i + ii] == t[ii];
             if (b)
             {
@@ -1292,35 +1291,35 @@ int Framework::Text::positionVon(int index, int len, const char* t) const
 
 int Text::positionVon(const Text& t, int i) const
 {
-    return positionVon(i, t.getLength(), t); // Text ueberpruefen
+    return positionVon(i, t.getLength(), t); // check text
 }
 
 Text* Text::getTeilText(
-    int p1, int p2) const // gibt den Text von p1 bis p2 zurueck
+    int p1, int p2) const // returns the text from p1 to p2
 {
-    if (p1 > p2) // p1 und p2 tauschen
+    if (p1 > p2) // swap p1 and p2
     {
         int x = p1;
         p1 = p2;
         p2 = x;
     }
-    if (p1 < 0 || p2 > length) // Auf unsinnige uebergabe pruefen
+    if (p1 < 0 || p2 > length) // check for invalid argument
         return new Text("");
-    char* cp = new char[(__int64)p2 - p1 + 1]; // neuen Text erstellen
-    for (int i = p1; i < p2; ++i)              // Text befuellen
+    char* cp = new char[(__int64)p2 - p1 + 1]; // create new text
+    for (int i = p1; i < p2; ++i)              // fill text
     {
         cp[i - p1] = txt[i];
     }
     cp[p2 - p1] = '\0';
-    return new Text(cp, p2 - p1); // Text zurueckgeben
+    return new Text(cp, p2 - p1); // return text
 }
 
-Text* Text::getTeilText(int p) const // gibt den Text von p bis zum Ende zurueck
+Text* Text::getTeilText(int p) const // returns the text from p to the end
 {
-    return getTeilText(p, getLength()); // Text zurueckgeben
+    return getTeilText(p, getLength()); // return text
 }
 
-// berechnet den Hash code des textes
+// calculates the hash code of the text
 int Text::hashCode() const
 {
     int result = 0;
@@ -1329,14 +1328,14 @@ int Text::hashCode() const
     return result;
 }
 
-// Operatoren
+// Operators
 Text& Text::operator+=(const int num)
 {
     append(num);
     return *this;
 }
 
-// Haengt eine Zahl ans Ende des Textes an
+// Appends a number to the end of the text
 Text& Text::operator+=(const __int64 num)
 {
     append(num);
@@ -1455,37 +1454,37 @@ bool Text::operator<(Text& t) const
     return 0;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und t2
+// Creates a new text consisting of this and t2
 Text Text::operator+(const Text& t2) const
 {
     return Text(*this) += t2;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und t2
+// Creates a new text consisting of this and t2
 Text Text::operator+(const char* t2) const
 {
     return Text(*this) += t2;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und num
+// Creates a new text consisting of this and num
 Text Text::operator+(const int num) const
 {
     return Text(*this) += num;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und num
+// Creates a new text consisting of this and num
 Text Text::operator+(const __int64 num) const
 {
     return Text(*this) += num;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und num
+// Creates a new text consisting of this and num
 Text Text::operator+(const double num) const
 {
     return Text(*this) += num;
 }
 
-// Erstellt einen neuen Text bestehend aus diesem und num
+// Creates a new text consisting of this and num
 Text Text::operator+(const float num) const
 {
     return Text(*this) += num;
@@ -1503,10 +1502,9 @@ Text Text::fromArray(char* arr, int len)
 
 const Text Text::EMPTY = "";
 
-// Inhalt der TextReader Klasse
-// Konstructor
-//  txt: Der Text der gelesen werden soll. Er wird nicht kopiert sondern
-//  direkt gelesen.
+// Content of the TextReader class
+// Constructor
+//  txt: The text to be read. It is not copied but read directly.
 TextReader::TextReader(Text* txt)
     : ReferenceCounter()
 {
@@ -1520,10 +1518,9 @@ TextReader::~TextReader()
     txt->release();
 }
 
-// Setzt die Position des Bytes, das als naechstes gelesen werden soll
-//  pos: Der Index des Bytes
-//  ende: 1, wenn der Index vom ende des Textes zaehlt. 0, wenn der Index vom
-//  Beginn des Textes zaehlt
+// Sets the position of the byte to be read next
+//  pos: The index of the byte
+//  ende: 1 if the index counts from the end of the text. 0 if from the beginning
 void TextReader::setLPosition(__int64 pos, bool ende)
 {
     int l = txt->getLength();
@@ -1532,9 +1529,9 @@ void TextReader::setLPosition(__int64 pos, bool ende)
     if (lPos > l) lPos = l;
 }
 
-// Liesst aus der Datei
-//  bytes: Ein Array, der mit Bytes aus dem Text gefuellt werden soll
-//  len: Wie viele Bytes aus dem Text gelesen werden sollen
+// Reads from the text
+//  bytes: An array to be filled with bytes from the text
+//  len: How many bytes to read from the text
 void TextReader::lese(char* bytes, int len)
 {
     int l = txt->getLength();
@@ -1544,8 +1541,8 @@ void TextReader::lese(char* bytes, int len)
     lPos += len;
 }
 
-// Liesst die naechste zeile des Textes ein
-//  return: Die gelesene Zeile als Text mit zeilenumbruch
+// Reads the next line of the text
+//  return: The read line as text with line break
 Text* TextReader::leseZeile()
 {
     if (istEnde()) return 0;
@@ -1559,22 +1556,21 @@ Text* TextReader::leseZeile()
     return ret;
 }
 
-// Prueft, ob die Resource vollstaendig gelesen wurde
-//  return 1, wenn die Resource vollstaendig gelesen wurde. 0, sonst
+// Checks whether the resource has been fully read
+//  return 1 if the resource has been fully read. 0 otherwise
 bool TextReader::istEnde() const
 {
     return lPos >= txt->getLength();
 }
 
-// Gibt den Index des Bytes aus dem Text zurueck, welches als naechstes
-// gelesen werden wuerde return -1, falls ein Fehler aufgetreten ist. Sonst
-// die Position des Lesezeigers
+// Returns the index of the byte from the text that would be read next
+// return -1 if an error occurred. Otherwise the position of the read pointer
 __int64 TextReader::getLPosition() const
 {
     return lPos;
 }
 
-//! Gibt die Anzahl der zu lesenden Bytes zurueck
+//! Returns the number of bytes to read
 __int64 TextReader::getSize() const
 {
     return txt->getLength();
@@ -1582,9 +1578,9 @@ __int64 TextReader::getSize() const
 
 // char* operationen
 int Framework::stringPositionVonChar(const char* string,
-    char c,
-    int num) // sucht die position des num-ten c-s
-             // in string, -1 bei nicht gefunden
+char c,
+int num) // finds the position of the num-th c
+         // in string, -1 if not found
 {
     int gef = 0;
     int p = 0;
@@ -1603,32 +1599,32 @@ int Framework::stringPositionVonChar(const char* string,
 }
 
 int Framework::stringPositionVonString(const char* string,
-    char* suche,
-    int sBegPos) // sucht die position von 'suche' in 'string' ab der
-                 // Position 'sBegPos', -1 bei nicht gefunden
+char* suche,
+int sBegPos) // finds the position of 'suche' in 'string' starting at
+             // position 'sBegPos', -1 if not found
 {
     for (int i = 0; i < sBegPos; ++i)
     {
         if (!*string) return -1;
         ++string;
     }
-    int tl = textLength(suche);   // Laenge der UEbergabe
-    int txl = textLength(string); // Laenge des Textes
-    if (tl <= 0 || tl > txl)      // Auf unsinnige uebergabe pruefen
+    int tl = textLength(suche);   // length of the argument
+    int txl = textLength(string); // length of the text
+    if (tl <= 0 || tl > txl)      // check for invalid argument
         return -1;
-    for (int i = 0; i + tl <= txl; ++i) // suchen
+    for (int i = 0; i + tl <= txl; ++i) // search
     {
         bool b = 1;
-        for (int ii = 0; ii < tl; ++ii) // ueberpruefen
+        for (int ii = 0; ii < tl; ++ii) // check
             if (b) b = string[i + ii] == suche[ii];
         if (b) return i + sBegPos;
     }
     return -1;
 }
 
-//---Andere Funktionen---
+//---Other Functions---
 void Framework::TextKopieren(
-    const char* txt) // kopiert den Text in den Zwischenspeicher
+const char* txt) // copies the text to the clipboard
 {
 #ifdef WIN32
     int laen = textLength(txt) + 1;
@@ -1645,7 +1641,7 @@ void Framework::TextKopieren(
 }
 
 const char*
-Framework::TextInsert() // gibt den Text aus der Zwischenablage zurueck
+Framework::TextInsert() // returns the text from the clipboard
 {
 #ifdef WIN32
     if (!OpenClipboard(0)) return "";
@@ -1776,7 +1772,7 @@ char Framework::smallOrBig(char c, bool gr)
 }
 
 bool Framework::istSchreibbar(
-    unsigned char zeichen) // prueft, ob zeichen ein Schreibbarer Buchstabe ist
+unsigned char zeichen) // checks if zeichen is a printable character
 {
     if (zeichen > 32 && zeichen < 127) return 1;
     if (zeichen == 128 || zeichen == 181 || zeichen == 178 || zeichen == 179)
@@ -1794,7 +1790,7 @@ bool Framework::istSchreibbar(
 }
 
 unsigned int Framework::TextZuInt(
-    const char* c, int system) // Konvertiert c zu int
+const char* c, int system) // converts c to int
 {
     if (system == 16) return (unsigned int)strtoul(c, 0, system);
     return (unsigned int)strtol(c, 0, system);
@@ -1819,12 +1815,12 @@ unsigned __int64 Framework::TextZuInt64(
     return (unsigned __int64)strtoll(c, c_ende, system);
 }
 
-double Framework::TextZuDouble(const char* c) // Konvertiert c zu double
+double Framework::TextZuDouble(const char* c) // converts c to double
 {
     return strtod(c, 0);
 }
 
-float Framework::TextZuFloat(const char* c) // Konvertiert c zu double
+float Framework::TextZuFloat(const char* c) // converts c to float
 {
     return strtof(c, 0);
 }
@@ -1839,7 +1835,7 @@ float Framework::TextZuFloat(const char* c, char** c_ende)
     return strtof(c, c_ende);
 }
 
-int Framework::textLength(const char* txt) // gibt die Laenge von txt zurueck
+int Framework::textLength(const char* txt) // returns the length of txt
 {
     if (!txt) return 0;
     int ret = 0;

UIInitialization.cpp

@@ -1,4 +1,4 @@
-#include "UIInitialization.h"
+#include "UIInitialization.h"
 
 #include "Animation.h"
 #include "AuswahlBox.h"

Zeit.cpp

@@ -21,8 +21,8 @@
 
 struct timeval
 {
-    long tv_sec;  // Sekunden seit dem 1.1.1970
-    long tv_usec; // und Mikrosekunden
+    long tv_sec;  // seconds since 1/1/1970
+    long tv_usec; // and microseconds
 };
 
 struct timezone
@@ -71,9 +71,9 @@ int gettimeofday(struct timeval* tv, struct timezone* tz)
 
 using namespace Framework;
 
-// Inhalt der Uhrzeit Klasse aus Zeit.h
-// Privat
-int Uhrzeit::update() // berechnet die neue Zeit
+// Content of the Uhrzeit class from Zeit.h
+// Private
+int Uhrzeit::update() // calculates the new time
 {
     __int64 mins = sekunde / 60;
     minute = minute + mins;
@@ -108,7 +108,7 @@ Uhrzeit::Uhrzeit()
       sekunde(0)
 {}
 
-int Uhrzeit::setUhrzeit(Uhrzeit* zeit) // setzt die Uhrzeit
+int Uhrzeit::setUhrzeit(Uhrzeit* zeit) // sets the time
 {
     stunde = zeit->getStunde();
     minute = zeit->getMinute();
@@ -126,8 +126,8 @@ int Uhrzeit::setUhrzeit(int stunde, int minute, int sekunde)
 }
 
 int Uhrzeit::setUhrzeit(
-    const char* format, const char* zeit) // format Beispiele: "H:i:s", "H-i-s"
-                                          // (H=stunde,i=minute,s=sekunde)
+const char* format, const char* zeit) // format examples: "H:i:s", "H-i-s"
+                                      // (H=hour,i=minute,s=second)
 {
     int flen = textLength(format);
     char* ende = 0;
@@ -165,25 +165,25 @@ int Uhrzeit::setUhrzeit(const char* format, Text* zeit)
     return ret;
 }
 
-int Uhrzeit::setStunde(int stunde) // setzt die Stunde
+int Uhrzeit::setStunde(int stunde) // sets the hour
 {
     this->stunde = stunde;
     return update();
 }
 
-int Uhrzeit::setMinute(int minute) // setzt die Minute
+int Uhrzeit::setMinute(int minute) // sets the minute
 {
     this->minute = minute;
     return update();
 }
 
-int Uhrzeit::setSekunde(int sekunde) // setzt die Sekunde
+int Uhrzeit::setSekunde(int sekunde) // sets the second
 {
     this->sekunde = sekunde;
     return update();
 }
 
-int Uhrzeit::plusUhrzeit(Uhrzeit* zeit) // addiert die zeiten
+int Uhrzeit::plusUhrzeit(Uhrzeit* zeit) // adds the times
 {
     stunde += zeit->getStunde();
     minute += zeit->getMinute();
@@ -237,25 +237,25 @@ int Uhrzeit::plusUhrzeit(const char* format, Text* zeit)
     return ret;
 }
 
-int Uhrzeit::plusStunde(__int64 stunde) // addiert stunde Stunden
+int Uhrzeit::plusStunde(__int64 stunde) // adds stunde hours
 {
     this->stunde += stunde;
     return update();
 }
 
-int Uhrzeit::plusMinute(__int64 minute) // addiert minute Minuten
+int Uhrzeit::plusMinute(__int64 minute) // adds minute minutes
 {
     this->minute += minute;
     return update();
 }
 
-int Uhrzeit::plusSekunde(__int64 sekunde) // addiert sekunde Sekunden
+int Uhrzeit::plusSekunde(__int64 sekunde) // adds sekunde seconds
 {
     this->sekunde += sekunde;
     return update();
 }
 
-int Uhrzeit::minusUhrzeit(Uhrzeit* zeit) // subtrahiert die zeiten
+int Uhrzeit::minusUhrzeit(Uhrzeit* zeit) // subtracts the times
 {
     stunde -= zeit->getStunde();
     minute -= zeit->getMinute();
@@ -310,42 +310,42 @@ int Uhrzeit::minusUhrzeit(const char* format, Text* zeit)
     return ret;
 }
 
-int Uhrzeit::minusStunde(__int64 stunde) // subtrahiert stunde Stunden
+int Uhrzeit::minusStunde(__int64 stunde) // subtracts stunde hours
 {
     this->stunde -= stunde;
     return update();
 }
 
-int Uhrzeit::minusMinute(__int64 minute) // subtrahiert minute Minuten
+int Uhrzeit::minusMinute(__int64 minute) // subtracts minute minutes
 {
     this->minute -= minute;
     return update();
 }
 
-int Uhrzeit::minusSekunde(__int64 sekunde) // subtrahiert sekunde Sekunden
+int Uhrzeit::minusSekunde(__int64 sekunde) // subtracts sekunde seconds
 {
     this->sekunde -= sekunde;
     return update();
 }
 
 // constant
-int Uhrzeit::getStunde() const // gibt die Stunde zurueck
+int Uhrzeit::getStunde() const // returns the hour
 {
     return (int)stunde;
 }
 
-int Uhrzeit::getMinute() const // gibt die Minute zurueck
+int Uhrzeit::getMinute() const // returns the minute
 {
     return (int)minute;
 }
 
-int Uhrzeit::getSekunde() const // gibt die Sekunde zurueck
+int Uhrzeit::getSekunde() const // returns the second
 {
     return (int)sekunde;
 }
 
 Text* Uhrzeit::getUhrzeit(
-    const char* format) const // gibt die Uhrzeit als Text formatiert zurueck
+const char* format) const // returns the time formatted as text
 {
     Text* ret = new Text("");
     int flen = textLength(format);
@@ -371,7 +371,7 @@ Text* Uhrzeit::getUhrzeit(
 }
 
 bool Uhrzeit::istGleich(
-    Uhrzeit* zeit) const // prueft, ob die Uhrzeit gleich zeit ist
+Uhrzeit* zeit) const // checks if the time equals zeit
 {
     bool ret = stunde == zeit->getStunde() && minute == zeit->getMinute()
             && sekunde == zeit->getSekunde();
@@ -426,25 +426,25 @@ bool Uhrzeit::istGleich(int stunde, int minute, int sekunde) const
 }
 
 bool Uhrzeit::stundeGleich(
-    int stunde) const // prueft, ob die Stunde gleich stunde ist
+int stunde) const // checks if the hour equals stunde
 {
     return this->stunde == stunde;
 }
 
 bool Uhrzeit::minuteGleich(
-    int minute) const // prueft, ob die Minute gleich minute ist
+int minute) const // checks if the minute equals minute
 {
     return this->minute == minute;
 }
 
 bool Uhrzeit::sekundeGleich(
-    int sekunde) const // prueft, ob die Sekunde gleich sekunde ist
+int sekunde) const // checks if the second equals sekunde
 {
     return this->sekunde == sekunde;
 }
 
 bool Uhrzeit::istKleiner(
-    Uhrzeit* zeit) const // prueft, ob die Zeit kleiner als zeit ist
+Uhrzeit* zeit) const // checks if the time is less than zeit
 {
     bool ret
         = istKleiner(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
@@ -516,7 +516,7 @@ bool Uhrzeit::istKleiner(const char* format, Text* zeit) const
 }
 
 bool Uhrzeit::istLater(
-    Uhrzeit* zeit) const // prueft, ob die Zeit groesser als zeit ist
+Uhrzeit* zeit) const // checks if the time is greater than zeit
 {
     bool ret
         = istLater(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
@@ -587,9 +587,9 @@ bool Uhrzeit::istLater(const char* format, Text* zeit) const
     return ret;
 }
 
-// Inhalt der Datum Klasse aus Zeit.h
-// Privat
-void Datum::update() // berechnet die neue Zeit
+// Content of the Datum class from Zeit.h
+// Private
+void Datum::update() // calculates the new date
 {
     while (monat > 12)
     {
@@ -635,7 +635,7 @@ void Datum::update() // berechnet die neue Zeit
     }
 }
 
-// Konstruktor
+// Constructor
 Datum::Datum()
     : ReferenceCounter(),
       jahr(0),
@@ -647,14 +647,14 @@ Datum::Datum()
     memcpy(maxTage, maxT, 12 * sizeof(int));
 }
 
-// Destruktor
+// Destructor
 Datum::~Datum()
 {
     delete[] maxTage;
 }
 
-// nicht constant
-void Datum::setDatum(Datum* datum) // setzt das Datum
+// non-constant
+void Datum::setDatum(Datum* datum) // sets the date
 {
     jahr = datum->getJahr();
     monat = datum->getMonat();
@@ -672,8 +672,8 @@ void Datum::setDatum(int jahr, int monat, int tag)
 }
 
 void Datum::setDatum(const char* format,
-    const char*
-        datum) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
+const char*
+    datum) // format examples: "Y:m:d", "Y-m-d" (Y=year,m=month,d=day)
 {
     int flen = textLength(format);
     char* ende = 0;
@@ -710,25 +710,25 @@ void Datum::setDatum(const char* format, Text* datum)
     datum->release();
 }
 
-void Datum::setJahr(int jahr) // setzt das Jahr
+void Datum::setJahr(int jahr) // sets the year
 {
     this->jahr = jahr;
     update();
 }
 
-void Datum::setMonat(int monat) // setzt den Monat
+void Datum::setMonat(int monat) // sets the month
 {
     this->monat = monat;
     update();
 }
 
-void Datum::setTag(int tag) // setzt den Tag
+void Datum::setTag(int tag) // sets the day
 {
     this->tag = tag;
     update();
 }
 
-void Datum::plusDatum(Datum* datum) // addiert das datum
+void Datum::plusDatum(Datum* datum) // adds the date
 {
     this->jahr += datum->getJahr();
     this->monat += datum->getMonat();
@@ -782,25 +782,25 @@ void Datum::plusDatum(const char* format, Text* datum)
     datum->release();
 }
 
-void Datum::plusJahr(int jahr) // addiert jahr Jahre
+void Datum::plusJahr(int jahr) // adds jahr years
 {
     this->jahr += jahr;
     update();
 }
 
-void Datum::plusMonat(int monat) // addiert monat Monate
+void Datum::plusMonat(int monat) // adds monat months
 {
     this->monat = monat;
     update();
 }
 
-void Datum::plusTag(int tag) // addiert tag Tage
+void Datum::plusTag(int tag) // adds tag days
 {
     this->tag += tag;
     update();
 }
 
-void Datum::minusDatum(Datum* datum) // subtrahiert das datum
+void Datum::minusDatum(Datum* datum) // subtracts the date
 {
     jahr -= datum->getJahr();
     monat -= datum->getMonat();
@@ -854,42 +854,42 @@ void Datum::minusDatum(const char* format, Text* datum)
     datum->release();
 }
 
-void Datum::minusJahr(int jahr) // subtrahiert jahr Jahre
+void Datum::minusJahr(int jahr) // subtracts jahr years
 {
     this->jahr -= jahr;
     update();
 }
 
-void Datum::minusMonat(int monat) // subtrahiert monat Monate
+void Datum::minusMonat(int monat) // subtracts monat months
 {
     this->monat -= monat;
     update();
 }
 
-void Datum::minusTag(int tag) // subtrahiert tag Tage
+void Datum::minusTag(int tag) // subtracts tag days
 {
     this->tag -= tag;
     update();
 }
 
 // constant
-int Datum::getJahr() const // gibt das Jahr zurueck
+int Datum::getJahr() const // returns the year
 {
     return jahr;
 }
 
-int Datum::getMonat() const // gibt der Monat zurueck
+int Datum::getMonat() const // returns the month
 {
     return monat;
 }
 
-int Datum::getTag() const // gibt der Tag zurueck
+int Datum::getTag() const // returns the day
 {
     return tag;
 }
 
 Text* Datum::getDatum(
-    const char* format) const // gibt das Datum als Text formatiert zurueck
+const char* format) const // returns the date formatted as text
 {
     Text* ret = new Text("");
     int flen = textLength(format);
@@ -915,7 +915,7 @@ Text* Datum::getDatum(
 }
 
 bool Datum::istGleich(
-    Datum* datum) const // prueft, ob das Datum gleich datum ist
+Datum* datum) const // checks if the date equals datum
 {
     bool ret = jahr == datum->getJahr() && monat == datum->getMonat()
             && tag == datum->getTag();
@@ -968,23 +968,24 @@ bool Datum::istGleich(int jahr, int monat, int tag) const
     return this->jahr == jahr && this->monat == monat && this->tag == tag;
 }
 
-bool Datum::jahrGleich(int jahr) const // prueft, ob das Jahr gleich jahr ist
+bool Datum::jahrGleich(int jahr) const // checks if the year equals jahr
 {
     return this->jahr == jahr;
 }
 
-bool Datum::monatGleich(int monat) const // prueft, ob der Monat gleich monat ist
+bool Datum::monatGleich(
+int monat) const // checks if the month equals monat
 {
     return this->monat == monat;
 }
 
-bool Datum::tagGleich(int tag) const // prueft, ob der Tag gleich tag ist
+bool Datum::tagGleich(int tag) const // checks if the day equals tag
 {
     return this->tag == tag;
 }
 
 bool Datum::istKleiner(
-    Datum* datum) const // prueft, ob die Datum kleiner als datum ist
+Datum* datum) const // checks if the date is less than datum
 {
     bool ret = istKleiner(datum->getJahr(), datum->getMonat(), datum->getTag());
     datum->release();
@@ -1055,7 +1056,7 @@ bool Datum::istKleiner(const char* format, Text* datum) const
 }
 
 bool Datum::istLater(
-    Datum* datum) const // prueft, ob die Datum groesser als datum ist
+Datum* datum) const // checks if the date is greater than datum
 {
     bool ret = istLater(datum->getJahr(), datum->getMonat(), datum->getTag());
     datum->release();
@@ -1125,15 +1126,15 @@ bool Datum::istLater(const char* format, Text* datum) const
     return ret;
 }
 
-// Inhalt der Zeit Klasse aus Zeit.h
-// Konstruktor
+// Content of the Zeit class from Zeit.h
+// Constructor
 Zeit::Zeit()
     : ReferenceCounter(),
       datum(new Datum()),
       uhrzeit(new Uhrzeit())
 {}
 
-//! Erzeugt eine neue Zeit mit den vergangenen sekunden seit 1970.
+//! Creates a new Zeit with the elapsed seconds since 1970.
 Zeit::Zeit(__int64 timestamp)
     : ReferenceCounter(),
       datum(new Datum()),
@@ -1143,15 +1144,15 @@ Zeit::Zeit(__int64 timestamp)
     plusSekunde(timestamp);
 }
 
-// Destruktor
+// Destructor
 Zeit::~Zeit()
 {
     datum->release();
     uhrzeit->release();
 }
 
-// nicht constant
-void Zeit::setZeit(Zeit* zeit) // setzt die Zeit
+// non-constant
+void Zeit::setZeit(Zeit* zeit) // sets the time
 {
     datum->setDatum(zeit->getDatum());
     datum->plusTag(uhrzeit->setUhrzeit(zeit->getUhrzeit()));
@@ -1166,8 +1167,8 @@ void Zeit::setZeit(
 }
 
 void Zeit::setZeit(const char* format,
-    const char* zeit) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s"
-                      // (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
+const char* zeit) // format examples: "Y:m:d H-i-s", "Y-m-d H:i:s"
+                  // (Y=year,m=month,d=day,H=hour,i=minute,s=second)
 {
     int y = datum->getJahr();
     int m = datum->getMonat();
@@ -1227,37 +1228,37 @@ void Zeit::setZeit(const char* format, Text* zeit)
     zeit->release();
 }
 
-void Zeit::setJahr(int jahr) // setzt das Jahr
+void Zeit::setJahr(int jahr) // sets the year
 {
     datum->setJahr(jahr);
 }
 
-void Zeit::setMonat(int monat) // setzt den Monat
+void Zeit::setMonat(int monat) // sets the month
 {
     datum->setMonat(monat);
 }
 
-void Zeit::setTag(int tag) // setzt den Tag
+void Zeit::setTag(int tag) // sets the day
 {
     datum->setTag(tag);
 }
 
-void Zeit::setStunde(int stunde) // setzt die Stunde
+void Zeit::setStunde(int stunde) // sets the hour
 {
     datum->plusTag(uhrzeit->setStunde(stunde));
 }
 
-void Zeit::setMinute(int minute) // setzt die Minute
+void Zeit::setMinute(int minute) // sets the minute
 {
     datum->plusTag(uhrzeit->setMinute(minute));
 }
 
-void Zeit::setSekunde(int sekunde) // setzt die Sekunde
+void Zeit::setSekunde(int sekunde) // sets the second
 {
     datum->plusTag(uhrzeit->setSekunde(sekunde));
 }
 
-void Zeit::plusZeit(Zeit* zeit) // addiert die zeit
+void Zeit::plusZeit(Zeit* zeit) // adds the time
 {
     datum->plusDatum(zeit->getDatum());
     datum->plusTag(uhrzeit->plusUhrzeit(zeit->getUhrzeit()));
@@ -1331,37 +1332,37 @@ void Zeit::plusZeit(const char* format, Text* zeit)
     zeit->release();
 }
 
-void Zeit::plusJahr(int jahr) // addiert jahr Jahre
+void Zeit::plusJahr(int jahr) // adds jahr years
 {
     datum->plusJahr(jahr);
 }
 
-void Zeit::plusMonat(int monat) // addiert monat Monate
+void Zeit::plusMonat(int monat) // adds monat months
 {
     datum->plusMonat(monat);
 }
 
-void Zeit::plusTag(int tag) // addiert tag Tage
+void Zeit::plusTag(int tag) // adds tag days
 {
     datum->plusTag(tag);
 }
 
-void Zeit::plusStunde(__int64 stunde) // addiert stunde Stunden
+void Zeit::plusStunde(__int64 stunde) // adds stunde hours
 {
     datum->plusTag(uhrzeit->plusStunde(stunde));
 }
 
-void Zeit::plusMinute(__int64 minute) // addiert minute Minuten
+void Zeit::plusMinute(__int64 minute) // adds minute minutes
 {
     datum->plusTag(uhrzeit->plusMinute(minute));
 }
 
-void Zeit::plusSekunde(__int64 sekunde) // addiert sekunde Sekunden
+void Zeit::plusSekunde(__int64 sekunde) // adds sekunde seconds
 {
     datum->plusTag(uhrzeit->plusSekunde(sekunde));
 }
 
-void Zeit::minusZeit(Zeit* zeit) // subtrahiert die zeit
+void Zeit::minusZeit(Zeit* zeit) // subtracts the time
 {
     datum->minusDatum(zeit->getDatum());
     datum->plusTag(uhrzeit->minusUhrzeit(zeit->getUhrzeit()));
@@ -1435,39 +1436,39 @@ void Zeit::minusZeit(const char* format, Text* zeit)
     zeit->release();
 }
 
-void Zeit::minusJahr(int jahr) // subtrahiert jahr Jahre
+void Zeit::minusJahr(int jahr) // subtracts jahr years
 {
     datum->minusJahr(jahr);
 }
 
-void Zeit::minusMonat(int monat) // subtrahiert monat Monate
+void Zeit::minusMonat(int monat) // subtracts monat months
 {
     datum->minusMonat(monat);
 }
 
-void Zeit::minusTag(int tag) // subtrahiert tag Tage
+void Zeit::minusTag(int tag) // subtracts tag days
 {
     datum->minusTag(tag);
 }
 
-void Zeit::minusStunde(__int64 stunde) // subtrahiert stunde Stunden
+void Zeit::minusStunde(__int64 stunde) // subtracts stunde hours
 {
     datum->plusTag(uhrzeit->minusStunde(stunde));
 }
 
-void Zeit::minusMinute(__int64 minute) // subtrahiert minute Minuten
+void Zeit::minusMinute(__int64 minute) // subtracts minute minutes
 {
     datum->plusTag(uhrzeit->minusMinute(minute));
 }
 
-void Zeit::minusSekunde(__int64 sekunde) // subtrahiert sekunde Sekunden
+void Zeit::minusSekunde(__int64 sekunde) // subtracts sekunde seconds
 {
     datum->plusTag(uhrzeit->minusSekunde(sekunde));
 }
 
 // constant
 Text* Zeit::getZeit(
-    const char* format) const // gibt die Zeit als Text formatiert zurueck
+const char* format) const // returns the time formatted as text
 {
     Text* ret = new Text("");
     int flen = textLength(format);
@@ -1505,7 +1506,7 @@ Text* Zeit::getZeit(
     return ret;
 }
 
-bool Zeit::istGleich(Zeit* zeit) const // prueft, ob die Uhrzeit gleich zeit ist
+bool Zeit::istGleich(Zeit* zeit) const // checks if the time equals zeit
 {
     bool ret = datum->istGleich(zeit->getDatum())
             && uhrzeit->istGleich(zeit->getUhrzeit());
@@ -1580,7 +1581,7 @@ bool Zeit::istGleich(
         && uhrzeit->istGleich(stunde, minute, sekunde);
 }
 
-Datum* Zeit::getDatum() const // gibt das Datum zurueck
+Datum* Zeit::getDatum() const // returns the date
 {
     return dynamic_cast<Datum*>(datum->getThis());
 }
@@ -1590,7 +1591,7 @@ Datum* Zeit::zDatum() const
     return datum;
 }
 
-Uhrzeit* Zeit::getUhrzeit() const // gibt die Uhrzeit zurueck
+Uhrzeit* Zeit::getUhrzeit() const // returns the time of day
 {
     return dynamic_cast<Uhrzeit*>(uhrzeit->getThis());
 }
@@ -1601,7 +1602,7 @@ Uhrzeit* Zeit::zUhrzeit() const
 }
 
 bool Zeit::istKleiner(
-    Zeit* zeit) const // prueft, ob die Zeit kleiner als zeit ist
+Zeit* zeit) const // checks if the time is less than zeit
 {
     if (datum->istKleiner(zeit->getDatum()))
     {
@@ -1714,7 +1715,8 @@ bool Zeit::istKleiner(const char* format, Text* zeit) const
     return ret;
 }
 
-bool Zeit::istLater(Zeit* zeit) const // prueft, ob die Zeit groesser als zeit ist
+bool Zeit::istLater(
+Zeit* zeit) const // checks if the time is greater than zeit
 {
     if (datum->istLater(zeit->getDatum()))
     {
@@ -1827,8 +1829,8 @@ bool Zeit::istLater(const char* format, Text* zeit) const
     return ret;
 }
 
-// Inhalt der ZeitMesser Klasse aus Zeit.h
-// Konstruktor
+// Content of the ZeitMesser class from Zeit.h
+// Constructor
 ZeitMesser::ZeitMesser()
     : ReferenceCounter(),
       start(0),
@@ -1836,18 +1838,18 @@ ZeitMesser::ZeitMesser()
       messung(0)
 {}
 
-// Destruktor
+// Destructor
 ZeitMesser::~ZeitMesser() {}
 
-// nicht constant
-void ZeitMesser::messungStart() // legt des Startpunkt der Zeitmessung fest
+// non-constant
+void ZeitMesser::messungStart() // sets the start point of the time measurement
 {
     timeval tv;
     gettimeofday(&tv, 0);
     start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
 }
 
-void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
+void ZeitMesser::messungEnde() // sets the end point of the time measurement
 {
     timeval tv;
     gettimeofday(&tv, 0);
@@ -1856,32 +1858,32 @@ void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
 }
 
 // constant
-double ZeitMesser::getSekunden()
-    const // gibt den sekundenabstand zwischen start und ende der Messung zurueck
+double ZeitMesser::getSekunden() const // returns the second difference between
+// start and end of the measurement
 {
     return messung;
 }
 
 double ZeitMesser::getMinuten()
-    const // gibt den minutenabstand zwischen start und ende der Messung zurueck
+const // returns the minute difference between start and end of the measurement
 {
     return messung / 60;
 }
 
 double ZeitMesser::getStunden()
-    const // gibt den stundenabstand zwischen start und ende der Messung zurueck
+const // returns the hour difference between start and end of the measurement
 {
     return messung / 3600;
 }
 
-//! gibt true zurueck, wenn aktuell eine MEssung laeuft
+//! returns true if a measurement is currently running
 DLLEXPORT bool ZeitMesser::isMeasuring() const
 {
     return start != 0;
 }
 
-// Globale Funktionen
-Uhrzeit* Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurueck
+// Global functions
+Uhrzeit* Framework::getUhrzeit() // returns the current time of day
 {
 #ifdef WIN32
     Uhrzeit* ret = new Uhrzeit();
@@ -1899,7 +1901,7 @@ Uhrzeit* Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurueck
 #endif
 }
 
-Datum* Framework::getDatum() // gibt das aktuelle Datum zurueck
+Datum* Framework::getDatum() // returns the current date
 {
 #ifdef WIN32
     Datum* ret = new Datum();
@@ -1917,7 +1919,7 @@ Datum* Framework::getDatum() // gibt das aktuelle Datum zurueck
 #endif
 }
 
-Zeit* Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurueck
+Zeit* Framework::getZeit() // returns the current time (date and time of day)
 {
 #ifdef WIN32
     Zeit* ret = new Zeit();
@@ -1945,7 +1947,7 @@ Zeit* Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zuruec
 #endif
 }
 
-bool Framework::istSchaltjahr(int jahr) // prueft, ob jahr ein Schaltjahr ist
+bool Framework::istSchaltjahr(int jahr) // checks if jahr is a leap year
 {
     if (jahr % 4 == 0)
     {

Zeit.h

@@ -9,13 +9,13 @@
 namespace Framework
 {
     class Text;       //! Text.h
-    class Uhrzeit;    //! Aus dieser Datei
-    class Datum;      //! Aus dieser Datei
-    class Zeit;       //! Aus dieser Datei
-    class ZeitMesser; //! Aus dieser Datei
+    class Uhrzeit;    //! From this file
+    class Datum;      //! From this file
+    class Zeit;       //! From this file
+    class ZeitMesser; //! From this file
 
-    //! Diese Klasse speichert eine Uhrzeit in form von Stunden, Minuten und
-    //! Sekunden
+    //! This class stores a time of day in the form of hours, minutes and
+    //! seconds
     class Uhrzeit : public virtual ReferenceCounter
     {
     private:
@@ -23,267 +23,265 @@ namespace Framework
         int update();
 
     public:
-        //! Erzeugt ein neues Uhrzeit Zeichnung mit den Standartwerten 00:00:00
+        //! Creates a new Uhrzeit object with the default values 00:00:00
         DLLEXPORT Uhrzeit();
 
-        //! Setzt die Uhrzeit durch kopieren.
-        //! \param zeit Aus diesem Zeichnung werden die Werte fuer Stunde, Minute
-        //! und Sekunde kopiert.
+        //! Sets the time by copying.
+        //! \param zeit The values for hour, minute and second are
+        //! copied from this object.
         DLLEXPORT int setUhrzeit(Uhrzeit* zeit);
-        //! Setzt die Uhrzeit.
-        //! \param stunde Die Stunde der neuen Uhrzeit.
-        //! \param minute Die Minute der neuen Uhrzeit.
-        //! \param sekunde Die Sekunde der neuen Uhrzeit.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: setUhrzeit( 30, 30, 30 ); return: 1, gespeichert: 6:30:30
+        //! Sets the time.
+        //! \param stunde The hour of the new time.
+        //! \param minute The minute of the new time.
+        //! \param sekunde The second of the new time.
+        //! \return The number of remaining days.
+        //! Example: setUhrzeit( 30, 30, 30 ); return: 1, stored: 6:30:30
         DLLEXPORT int setUhrzeit(int stunde, int minute, int sekunde);
-        //! Setzt die Uhrzeit.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Eine Zeichenfolge die die neue Uhrzeit enthaelt. \return Die
-        //! Anzahl uebriger Tage. Beispiel: setUhrzeit( "h:i:s", "05:30:00" );
-        //! Beispiel: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, gespeichert:
+        //! Sets the time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A string containing the new time. \return The
+        //! number of remaining days. Example: setUhrzeit( "h:i:s", "05:30:00" );
+        //! Example: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, stored:
         //! 6:30:00
         DLLEXPORT int setUhrzeit(const char* format, const char* zeit);
-        //! Setzt die Uhrzeit.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Ein Text Zeichnung, dass die neue Uhrzeit enthaelt. \return Die
-        //! Anzahl uebriger Tage. Beispiel: setUhrzeit( "h:i:s", new Text(
-        //! "05:30:00" ) ); Beispiel: setUhrzeit( "h:i:s", new Text( "30:30:00"
-        //! ) ); return: 1, gespeichert: 6:30:00
+        //! Sets the time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A Text object containing the new time. \return The
+        //! number of remaining days. Example: setUhrzeit( "h:i:s", new Text(
+        //! "05:30:00" ) ); Example: setUhrzeit( "h:i:s", new Text( "30:30:00"
+        //! ) ); return: 1, stored: 6:30:00
         DLLEXPORT int setUhrzeit(const char* format, Text* zeit);
-        //! setzt die Stunde.
-        //! \param stunde Die Stunde, die gespeichert werden soll.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: setStunde( 30 ); return: 1 Tag, gespeicherte Stunden: 6
+        //! Sets the hour.
+        //! \param stunde The hour to be stored.
+        //! \return The number of remaining days.
+        //! Example: setStunde( 30 ); return: 1 day, stored hours: 6
         DLLEXPORT int setStunde(int stunde);
-        //! setzt die Minute.
-        //! \param minute Die Minute, die gespeichert werden soll.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 23:50:10, setMinute( 80 ); return: 1,
-        //! gespeicherte Zeit: 01:10:10
+        //! Sets the minute.
+        //! \param minute The minute to be stored.
+        //! \return The number of remaining days.
+        //! Example: Old time: 23:50:10, setMinute( 80 ); return: 1,
+        //! stored time: 01:10:10
         DLLEXPORT int setMinute(int minute);
-        //! setzt die Sekunde.
-        //! \param minute Die Sekunde, die gespeichert werden soll.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 23:59:10, setSekunde( 80 ); return: 1,
-        //! gespeicherte Zeit: 00:00:30
+        //! Sets the second.
+        //! \param minute The second to be stored.
+        //! \return The number of remaining days.
+        //! Example: Old time: 23:59:10, setSekunde( 80 ); return: 1,
+        //! stored time: 00:00:30
         DLLEXPORT int setSekunde(int sekunde);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param zeit Die Uhrzeit, deren Werte addiert werden
-        //! sollen. \return Die Anzahl uebriger Tage. Beispiel: Alte Zeit:
-        //! 19:40:18, plusZeit( (10:05:30) ); return 1, gespeicherte Zeit:
-        //! 05:45:48
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param zeit The time whose values are to be added.
+        //! \return The number of remaining days.
+        //! Example: Old time: 19:40:18, plusUhrzeit( (10:05:30) ); return 1,
+        //! stored time: 05:45:48
         DLLEXPORT int plusUhrzeit(Uhrzeit* zeit);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param stunde Die Stunden die Werte addiert werden
-        //! sollen. \param minute Die Minute die Werte addiert werden sollen.
-        //! \param sekunde Die Sekunde die Werte addiert werden sollen.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( 10, 5, 30 ); return 1,
-        //! gespeicherte Zeit: 05:45:48
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param stunde The hours to be added.
+        //! \param minute The minutes to be added.
+        //! \param sekunde The seconds to be added.
+        //! \return The number of remaining days.
+        //! Example: Old time: 19:40:18, plusUhrzeit( 10, 5, 30 ); return 1,
+        //! stored time: 05:45:48
         DLLEXPORT int plusUhrzeit(int stunde, int minute, int sekunde);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
-        //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
-        //! i=Minute,s=Sekunde. \param zeit Eine Zeichenfolge die die neue
-        //! Uhrzeit enthaelt. \return Die Anzahl uebriger Tage. Beispiel:
-        //! plusUhrzeit( "h:i:s", "05:20:00" ); Beispiel: Alte Zeit: 19:40:18,
-        //! plusZeit( "h:i:s", "10:05:30" ); return 1, gespeicherte Zeit:
-        //! 05:45:48
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second.
+        //! \param zeit A string containing the time to add.
+        //! \return The number of remaining days.
+        //! Example: Old time: 19:40:18, plusUhrzeit( "h:i:s", "10:05:30" );
+        //! return 1, stored time: 05:45:48
         DLLEXPORT int plusUhrzeit(const char* format, const char* zeit);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
-        //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
-        //! i=Minute,s=Sekunde. \param zeit Ein Text Zeichnung, welches die neue
-        //! Uhrzeit enthaelt. \return Die Anzahl uebriger Tage. Beispiel:
-        //! plusUhrzeit( "h:i:s", new Text( "05:20:00" ) ); Beispiel: Alte Zeit:
-        //! 19:40:18, plusZeit( "h:i:s", new Text( "10:05:30" ) ); return 1,
-        //! gespeicherte Zeit: 05:45:48
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second.
+        //! \param zeit A Text object containing the time to add.
+        //! \return The number of remaining days.
+        //! Example: Old time: 19:40:18, plusUhrzeit( "h:i:s", new Text(
+        //! "10:05:30" ) ); return 1, stored time: 05:45:48
         DLLEXPORT int plusUhrzeit(const char* format, Text* zeit);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param stunde die draufzurechnenden Stunden.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 20:50:30, plusStunde( 10 ); return 1,
-        //! gespeicherte Zeit: 6:50:30
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param stunde The hours to add.
+        //! \return The number of remaining days.
+        //! Example: Old time: 20:50:30, plusStunde( 10 ); return 1,
+        //! stored time: 6:50:30
         DLLEXPORT int plusStunde(__int64 stunde);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param minute die draufzurechnenden Minuten.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 23:50:30, plusMinute( 11 ); return 1,
-        //! gespeicherte Zeit: 00:01:30
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param minute The minutes to add.
+        //! \return The number of remaining days.
+        //! Example: Old time: 23:50:30, plusMinute( 11 ); return 1,
+        //! stored time: 00:01:30
         DLLEXPORT int plusMinute(__int64 minute);
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
-        //! speichert diese. \param sekunde die draufzurechnenden Sekunden.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel: Alte Zeit: 23:59:30, plusSekunde( 40 ); return 1,
-        //! gespeicherte Zeit: 00:00:10
+        //! Calculates the sum of this and another time and stores the result.
+        //! \param sekunde The seconds to add.
+        //! \return The number of remaining days.
+        //! Example: Old time: 23:59:30, plusSekunde( 40 ); return 1,
+        //! stored time: 00:00:10
         DLLEXPORT int plusSekunde(__int64 sekunde);
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
-        //! Ergebnis. \param zeit Die Uhrzeit, die von dieser abgezogen werden
-        //! soll. \return Die Anzahl uebriger Tage. Beispiel Alte Zeit: 10:40:18,
-        //! minusUhrzeit( (19:05:30) ); return -1, gespeicherte Zeit: 15:34:48
+        //! Subtracts a given time from this one and stores the result.
+        //! \param zeit The time to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 10:40:18, minusUhrzeit( (19:05:30) ); return -1,
+        //! stored time: 15:34:48
         DLLEXPORT int minusUhrzeit(Uhrzeit* zeit);
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
-        //! Ergebnis. \param stunde Die Stunden, die von dieser Uhrzeit
-        //! abgezogen werden sollen. \param minute Die Minuten, die von dieser
-        //! Uhrzeit abgezogen werden sollen. \param sekunde Die Sekunden, die
-        //! von dieser Uhrzeit abgezogen werden sollen. \return Die Anzahl
-        //! uebriger Tage. Beispiel Alte Zeit: 10:40:18, minusUhrzeit( 19, 05, 30
-        //! ); return -1, gespeicherte Zeit: 15:34:48
+        //! Subtracts a given time from this one and stores the result.
+        //! \param stunde The hours to subtract.
+        //! \param minute The minutes to subtract.
+        //! \param sekunde The seconds to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 10:40:18, minusUhrzeit( 19, 05, 30 );
+        //! return -1, stored time: 15:34:48
         DLLEXPORT int minusUhrzeit(int stunde, int minute, int sekunde);
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
-        //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
-        //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthaelt.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" );
-        //! return -1, gespeicherte Zeit: 15:34:48
+        //! Subtracts a given time from this one and stores the result.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second.
+        //! \param zeit A string containing the time to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" );
+        //! return -1, stored time: 15:34:48
         DLLEXPORT int minusUhrzeit(const char* format, const char* zeit);
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
-        //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
-        //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthaelt.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", new Text(
-        //! "19:05:30" ) ); return -1, gespeicherte Zeit: 15:34:48
+        //! Subtracts a given time from this one and stores the result.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second.
+        //! \param zeit A Text object containing the time to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 10:40:18, minusUhrzeit( "h:i:s", new Text(
+        //! "19:05:30" ) ); return -1, stored time: 15:34:48
         DLLEXPORT int minusUhrzeit(const char* format, Text* zeit);
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param stunde Die abzuziehenden Stunden.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusStunde( 19 ); return -1,
-        //! gespeicherte Zeit: 15:40:18
+        //! Subtracts a given time from this one and stores the result.
+        //! \param stunde The hours to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 10:40:18, minusStunde( 19 ); return -1,
+        //! stored time: 15:40:18
         DLLEXPORT int minusStunde(__int64 stunde);
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param minute Die abzuziehenden Minuten.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel Alte Zeit: 00:40:18, minusStunde( 50 ); return -1,
-        //! gespeicherte Zeit: 23:50:18
+        //! Subtracts a given time from this one and stores the result.
+        //! \param minute The minutes to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 00:40:18, minusMinute( 50 ); return -1,
+        //! stored time: 23:50:18
         DLLEXPORT int minusMinute(__int64 minute);
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param sekunde Die abzuziehenden Sekunden.
-        //! \return Die Anzahl uebriger Tage.
-        //! Beispiel Alte Zeit: 00:00:20, minusStunde( 50 ); return -1,
-        //! gespeicherte Zeit: 23:59:30
+        //! Subtracts a given time from this one and stores the result.
+        //! \param sekunde The seconds to subtract.
+        //! \return The number of remaining days.
+        //! Example: Old time: 00:00:20, minusSekunde( 50 ); return -1,
+        //! stored time: 23:59:30
         DLLEXPORT int minusSekunde(__int64 sekunde);
 
-        //! gibt die Stunde zurueck.
+        //! Returns the hour.
         DLLEXPORT int getStunde() const;
-        //! gibt die Minute zurueck.
+        //! Returns the minute.
         DLLEXPORT int getMinute() const;
-        //! gibt die Sekunde zurueck.
+        //! Returns the second.
         DLLEXPORT int getSekunde() const;
-        //! gibt die Uhrzeit als Text formatiert zurueck.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit zurueckgegeben werden soll. h=Stunde, i=Minute,s=Sekunde.
-        //! Beispiel: Zeit: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
+        //! Returns the time formatted as text.
+        //! \param format A string that determines the format of the
+        //! returned time. h=hour, i=minute, s=second.
+        //! Example: Time: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
         DLLEXPORT Text* getUhrzeit(const char* format) const;
-        //! prueft, ob die Uhrzeit gleich zeit ist.
-        //! \param zeit Die Uhrzeit, mit der diese verglichen werden soll.
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
-        //! Zeiten nicht gleich sind.
+        //! Checks if the time equals zeit.
+        //! \param zeit The time to compare with.
+        //! \return (true) if both times are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool istGleich(Uhrzeit* zeit) const;
-        //! prueft, ob die Uhrzeit gleich zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
-        //! nicht gleich sind.
+        //! Checks if the time equals zeit.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A string containing the other time. \return
+        //! (true) if both times are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
-        //! prueft, ob die Uhrzeit gleich zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
-        //! nicht gleich sind.
+        //! Checks if the time equals zeit.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A Text object containing the other time.
+        //! \return (true) if both times are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
-        //! prueft, ob die Uhrzeit gleich der uebergebenen Zeit ist. Hier wird
-        //! nicht beachtet, ob die gegebene Zeit eine gueltige Uhrzeit ist.
-        //! \param stunde Die Stunden der zu ueberpruefenden Uhrzeit
-        //! \param minute Die Minuten der zu ueberpruefenden Uhrzeit
-        //! \param sekunde Die Sekunden der zu ueberpruefenden Uhrzeit
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
-        //! Zeiten nicht gleich sind.
+        //! Checks if the time equals the given time. Does not validate
+        //! whether the given time is a valid time of day.
+        //! \param stunde The hours of the time to check.
+        //! \param minute The minutes of the time to check.
+        //! \param sekunde The seconds of the time to check.
+        //! \return (true) if both times are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool istGleich(int stunde, int minute, int sekunde) const;
-        //! prueft, ob die Stunde gleich der gegebenen Stunde ist.
-        //! \param stunde die zu pruefende Stunde.
-        //! \return (true), wenn die Stunden gleich sind. (false), wenn sie
-        //! nicht gleich sind.
+        //! Checks if the hour equals the given hour.
+        //! \param stunde The hour to check.
+        //! \return (true) if the hours are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool stundeGleich(int stunde) const;
-        //! prueft, ob die Minute gleich der gegebenen Minute ist.
-        //! \param minute die zu pruefende Minute.
-        //! \return (true), wenn die Minuten gleich sind. (false), wenn sie
-        //! nicht gleich sind.
+        //! Checks if the minute equals the given minute.
+        //! \param minute The minute to check.
+        //! \return (true) if the minutes are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool minuteGleich(int minute) const;
-        //! prueft, ob die Sekunde gleich der gegebenen Sekunde ist.
-        //! \param sekunde die zu pruefende Sekunde.
-        //! \return (true), wenn die Sekunden gleich sind. (false), wenn sie
-        //! nicht gleich sind.
+        //! Checks if the second equals the given second.
+        //! \param sekunde The second to check.
+        //! \return (true) if the seconds are equal. (false) if they
+        //! are not equal.
         DLLEXPORT bool sekundeGleich(int sekunde) const;
-        //! prueft, ob die Uhrzeit kleiner als zeit ist.
-        //! \param zeit Die zu pruefende Uhrzeit.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die
-        //! uebergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
-        //! (10:40:29) ); return true
+        //! Checks if the time is less than zeit.
+        //! \param zeit The time to check against.
+        //! \return (true) if the stored time is less than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istKleiner( (10:40:29) ); return true
         DLLEXPORT bool istKleiner(Uhrzeit* zeit) const;
-        //! prueft, ob die Uhrzeit kleiner als die uebergebene Zeit ist.
-        //! \param stunde Die Stunden der zu pruefenden Zeit.
-        //! \param minute Die Minute der zu pruefenden Zeit.
-        //! \param sekunde Die Sekunde der zu pruefenden Zeit.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die
-        //! uebergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
-        //! 10, 40, 29 ); return true
+        //! Checks if the time is less than the given time.
+        //! \param stunde The hours of the time to check.
+        //! \param minute The minutes of the time to check.
+        //! \param sekunde The seconds of the time to check.
+        //! \return (true) if the stored time is less than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istKleiner( 10, 40, 29 ); return true
         DLLEXPORT bool istKleiner(int stunde, int minute, int sekunde) const;
-        //! prueft, ob die Uhrzeit kleiner als die uebergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
-        //! "10:40:29" ); return true
+        //! Checks if the time is less than the given time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A string containing the other time. \return
+        //! (true) if the stored time is less than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istKleiner( "h:i:s", "10:40:29" ); return true
         DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
-        //! prueft, ob die Uhrzeit kleiner als die uebergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
-        //! "10:40:29" ); return true
+        //! Checks if the time is less than the given time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A Text object containing the other time.
+        //! \return (true) if the stored time is less than the given
+        //! time. (false) otherwise.
         DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
-        //! prueft, ob die Uhrzeit groesser als zeit ist.
-        //! \param zeit Die zu pruefende Uhrzeit.
-        //! \return (true), wenn die gespeicherte Zeit groesser als die uebergebene
-        //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGroesser( (10:40:29)
-        //! ); return false
+        //! Checks if the time is greater than zeit.
+        //! \param zeit The time to check against.
+        //! \return (true) if the stored time is greater than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istLater( (10:40:29) ); return false
         DLLEXPORT bool istLater(Uhrzeit* zeit) const;
-        //! prueft, ob die Uhrzeit groesser als die uebergebene Zeit ist.
-        //! \param stunde Die Stunden der zu pruefenden Zeit.
-        //! \param minute Die Minute der zu pruefenden Zeit.
-        //! \param sekunde Die Sekunde der zu pruefenden Zeit.
-        //! \return (true), wenn die gespeicherte Zeit groesser als die uebergebene
-        //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGroesser( 10, 40, 29
-        //! ); return false
+        //! Checks if the time is greater than the given time.
+        //! \param stunde The hours of the time to check.
+        //! \param minute The minutes of the time to check.
+        //! \param sekunde The seconds of the time to check.
+        //! \return (true) if the stored time is greater than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istLater( 10, 40, 29 ); return false
         DLLEXPORT bool istLater(int stunde, int minute, int sekunde) const;
-        //! prueft, ob die Uhrzeit groesser als die uebergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. (false) sonst. Beispiel: (5:30:00).istGroesser( "h:i:s",
-        //! "10:40:29" ); return false
+        //! Checks if the time is greater than the given time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A string containing the other time. \return
+        //! (true) if the stored time is greater than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istLater( "h:i:s", "10:40:29" ); return false
         DLLEXPORT bool istLater(const char* format, const char* zeit) const;
-        //! prueft, ob die Uhrzeit groesser als die uebergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
-        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
-        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthaelt. \return
-        //! (true), wenn die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. (false) sonst. Beispiel: (5:30:00).istGroesser( "h:i:s",
-        //! "10:40:29" ); return false
+        //! Checks if the time is greater than the given time.
+        //! \param format A string that determines the format of the
+        //! time in (zeit). h=hour, i=minute, s=second. \param
+        //! zeit A Text object containing the other time.
+        //! \return (true) if the stored time is greater than the given
+        //! time. (false) otherwise.
+        //! Example: (5:30:00).istLater( "h:i:s", "10:40:29" ); return false
         DLLEXPORT bool istLater(const char* format, Text* zeit) const;
     };
 
-    //! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
+    //! This class stores a date in the form of year, month and day
     class Datum : public virtual ReferenceCounter
     {
     private:
@@ -292,230 +290,230 @@ namespace Framework
         void update();
 
     public:
-        //! Erzeugt ein neues Datum Zeichnung mit den Standartwerten 0.0.0.
+        //! Creates a new Datum object with the default values 0.0.0.
         DLLEXPORT Datum();
-        //! Loescht das Datum.
+        //! Deletes the date.
         DLLEXPORT ~Datum();
 
-        //! Setzt das Datum durch kopieren.
-        //! \param datum Das zu speichernde Datum.
+        //! Sets the date by copying.
+        //! \param datum The date to store.
         DLLEXPORT void setDatum(Datum* datum);
-        //! Setzt das Datum zu den uebergebenen Werten.
-        //! \param jahr Das Jahr des neuen Datums.
-        //! \param monat Der Monat des neuen Datums.
-        //! \param tag Der Tag des neuen Datums.
+        //! Sets the date to the given values.
+        //! \param jahr The year of the new date.
+        //! \param monat The month of the new date.
+        //! \param tag The day of the new date.
         DLLEXPORT void setDatum(int jahr, int monat, int tag);
-        //! Setzt das Datum zu dem uebergebenen Wert.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Eine Zeichenkette, die das neue Datum enthaelt. Beispiel: setDatum(
-        //! "y-m-d", "2016-01-25" );
+        //! Sets the date to the given value.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A string containing the new date.
+        //! Example: setDatum( "y-m-d", "2016-01-25" );
         DLLEXPORT void setDatum(const char* format, const char* datum);
-        //! Setzt das Datum zu dem uebergebenen Wert.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Ein Text Zeichnung, welches das neue Datum enthaelt. Beispiel:
-        //! setDatum( "y-m-d", new Text(  "2016-01-25" ) );
+        //! Sets the date to the given value.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A Text object containing the new date.
+        //! Example: setDatum( "y-m-d", new Text( "2016-01-25" ) );
         DLLEXPORT void setDatum(const char* format, Text* datum);
-        //! AEndert das Jahr des Datums.
-        //! \param jahr Das neue Jahr.
+        //! Changes the year of the date.
+        //! \param jahr The new year.
         DLLEXPORT void setJahr(int jahr);
-        //! AEndert den Monat des Datums.
-        //! \param monat Der neue Monat.
+        //! Changes the month of the date.
+        //! \param monat The new month.
         DLLEXPORT void setMonat(int monat);
-        //! AEndert den Tag des Datums.
-        //! \param tag Der neue Tag.
+        //! Changes the day of the date.
+        //! \param tag The new day.
         DLLEXPORT void setTag(int tag);
-        //! Addiert zum aktuellen Datum das uebergebene Datum dazu und speichert
-        //! das Ergebnis. \param datum Das zu addierende Datum. Beispiel:
-        //! ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); neues Datum: 6.1.2003
+        //! Adds the given date to the current date and stores the result.
+        //! \param datum The date to add.
+        //! Example: ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); new date: 6.1.2003
         DLLEXPORT void plusDatum(Datum* datum);
-        //! Addiert zum aktuellen Datum das uebergebene Datum dazu und speichert
-        //! das Ergebnis. \param jahr Das zu addierende Jahr. \param monat Der
-        //! zu addierende Monat. \param tag Der zu addierende Tag. Beispiel:
-        //! ( 1.11.1995 ).plusDatum( ( 7, 2, 5 ) ); neues Datum: 6.1.2003
+        //! Adds the given date to the current date and stores the result.
+        //! \param jahr The year to add. \param monat The month to add.
+        //! \param tag The day to add.
+        //! Example: ( 1.11.1995 ).plusDatum( 7, 2, 5 ); new date: 6.1.2003
         DLLEXPORT void plusDatum(int jahr, int monat, int tag);
-        //! Addiert zum aktuellen Datum das uebergebene Datum dazu und speichert
-        //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
-        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das zu addierende Datum enthaelt.
-        //! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" ); neues
-        //! Datum: 6.1.2003
+        //! Adds the given date to the current date and stores the result.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day.
+        //! \param datum A string containing the date to add.
+        //! Example: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" );
+        //! new date: 6.1.2003
         DLLEXPORT void plusDatum(const char* format, const char* datum);
-        //! Addiert zum aktuellen Datum das uebergebene Datum dazu und speichert
-        //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
-        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das zu addierende Datum
-        //! enthaelt. Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", new Text(
-        //! "5.2.7" ) ); neues Datum: 6.1.2003
+        //! Adds the given date to the current date and stores the result.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day.
+        //! \param datum A Text object containing the date to add.
+        //! Example: ( 1.11.1995 ).plusDatum( "d.m.y", new Text(
+        //! "5.2.7" ) ); new date: 6.1.2003
         DLLEXPORT void plusDatum(const char* format, Text* datum);
-        //! Addiert zum aktuellen Datum das uebergebene Jahr dazu und speichert
-        //! das Ergebnis. \param jahr Das zu addierende Jahr. Beispiel:
-        //! ( 1.11.1995 ).plusJahr( 21 ); neues Datum: 1.11.2016
+        //! Adds the given year to the current date and stores the result.
+        //! \param jahr The year to add.
+        //! Example: ( 1.11.1995 ).plusJahr( 21 ); new date: 1.11.2016
         DLLEXPORT void plusJahr(int jahr);
-        //! Addiert zum aktuellen Datum den uebergebenen Monat dazu und speichert
-        //! das Ergebnis. \param monat Der zu addierende Monat. Beispiel:
-        //! ( 1.11.1995 ).plusMonat( 13 ); neues Datum: 1.12.1996
+        //! Adds the given month to the current date and stores the result.
+        //! \param monat The month to add.
+        //! Example: ( 1.11.1995 ).plusMonat( 13 ); new date: 1.12.1996
         DLLEXPORT void plusMonat(int monat);
-        //! Addiert zum aktuellen Datum den uebergebenen Tag dazu und speichert
-        //! das Ergebnis. \param tag Der zu addierende Tag. Beispiel: ( 1.1.2000
-        //! ).plusTag( 32 ); neues Datum: 2.2.2000
+        //! Adds the given day to the current date and stores the result.
+        //! \param tag The day to add.
+        //! Example: ( 1.1.2000 ).plusTag( 32 ); new date: 2.2.2000
         DLLEXPORT void plusTag(int tag);
-        //! Zieht vom aktuellen Datum das uebergebene Datum ab und speichert das
-        //! Ergebnis. \param datum Das abzuzuehende Datum. Beispiel: ( 2.12.1996
-        //! ).minusDatum( ( 1.1.1 ) ); neues Datum: 1.11.1995
+        //! Subtracts the given date from the current date and stores the result.
+        //! \param datum The date to subtract.
+        //! Example: ( 2.12.1996 ).minusDatum( ( 1.1.1 ) ); new date: 1.11.1995
         DLLEXPORT void minusDatum(Datum* datum);
-        //! Zieht vom aktuellen Datum das uebergebene Datum ab und speichert das
-        //! Ergebnis. \param jahr Das abzuzuehende Jahr. \param monat Der
-        //! abzuzuehende Monat. \param tag Der abzuzuehende Tag. Beispiel:
-        //! ( 2.12.1996 ).minusDatum( 1, 1, 1 ); neues Datum: 1.11.1995
+        //! Subtracts the given date from the current date and stores the result.
+        //! \param jahr The year to subtract. \param monat The month to subtract.
+        //! \param tag The day to subtract.
+        //! Example: ( 2.12.1996 ).minusDatum( 1, 1, 1 ); new date: 1.11.1995
         DLLEXPORT void minusDatum(int jahr, int monat, int tag);
-        //! Zieht vom aktuellen Datum das uebergebene Datum ab und speichert das
-        //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
-        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das abzuziehende Datum enthaelt.
-        //! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" ); neues
-        //! Datum: 1.11.1995
+        //! Subtracts the given date from the current date and stores the result.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day.
+        //! \param datum A string containing the date to subtract.
+        //! Example: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" );
+        //! new date: 1.11.1995
         DLLEXPORT void minusDatum(const char* format, const char* datum);
-        //! Zieht vom aktuellen Datum das uebergebene Datum ab und speichert das
-        //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
-        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das abzuziehende Datum
-        //! enthaelt. Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", new Text(
-        //! "1.1.1" ) ); neues Datum: 1.11.1995
+        //! Subtracts the given date from the current date and stores the result.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day.
+        //! \param datum A Text object containing the date to subtract.
+        //! Example: ( 2.12.1996 ).minusDatum( "d.m.y", new Text(
+        //! "1.1.1" ) ); new date: 1.11.1995
         DLLEXPORT void minusDatum(const char* format, Text* datum);
-        //! Zieht vom aktuellen Datum das uebergebene Jahr ab und speichert das
-        //! Ergebnis. \param jahr Das abzuzuehende Jahr. Beispiel: ( 1.11.1996
-        //! ).minusJahr( 1 ); neues Datum: 1.11.1995
+        //! Subtracts the given year from the current date and stores the result.
+        //! \param jahr The year to subtract.
+        //! Example: ( 1.11.1996 ).minusJahr( 1 ); new date: 1.11.1995
         DLLEXPORT void minusJahr(int jahr);
-        //! Zieht vom aktuellen Datum den uebergebenen Monat ab und speichert das
-        //! Ergebnis. \param monat Der abzuzuehende Monat. Beispiel: ( 1.12.1996
-        //! ).minusMonat( 13 ); neues Datum: 1.11.1995
+        //! Subtracts the given month from the current date and stores the result.
+        //! \param monat The month to subtract.
+        //! Example: ( 1.12.1996 ).minusMonat( 13 ); new date: 1.11.1995
         DLLEXPORT void minusMonat(int monat);
-        //! Zieht vom aktuellen Datum den uebergebenen Tag ab und speichert das
-        //! Ergebnis. \param monat Der abzuzuehende Tag. Beispiel: ( 5.2.2016
-        //! ).minusMonat( 11 ); neues Datum: 25.1.2016
+        //! Subtracts the given day from the current date and stores the result.
+        //! \param tag The day to subtract.
+        //! Example: ( 5.2.2016 ).minusTag( 11 ); new date: 25.1.2016
         DLLEXPORT void minusTag(int tag);
 
-        //! gibt das Jahr zurueck.
+        //! Returns the year.
         DLLEXPORT int getJahr() const;
-        //! gibt der Monat zurueck.
+        //! Returns the month.
         DLLEXPORT int getMonat() const;
-        //! gibt der Tag zurueck.
+        //! Returns the day.
         DLLEXPORT int getTag() const;
-        //! Gibt das Datum als Text Zeichnung zurueck.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum zurueckgegeben werden soll. y=Jahr, m=Monat, d=Tag. Beispiel:
-        //! ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
+        //! Returns the date as a Text object.
+        //! \param format A string specifying the format of the
+        //! returned date. y=year, m=month, d=day.
+        //! Example: ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
         DLLEXPORT Text* getDatum(const char* format) const;
-        //! Prueft, ob das Datum gleich dem uebergebenen Datum ist.
-        //! \param datum das zu pruefende Datum.
-        //! \return (true), wenn das uebergebene Datum dem gespeicherten
-        //! entspricht. (false) sonnst.
+        //! Checks if the date equals the given date.
+        //! \param datum The date to check.
+        //! \return (true) if the given date matches the stored one.
+        //! (false) otherwise.
         DLLEXPORT bool istGleich(Datum* datum) const;
-        //! Prueft, ob das Datum gleich dem uebergebenen Datum ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Eine Zeichenkette, die das zu ueberpruefende Datum enthaelt. \return
-        //! (true), wenn das uebergebene Datum dem gespeicherten entspricht.
-        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( "y-m-d",
-        //! "1995-11-1" ); return: true
+        //! Checks if the date equals the given date.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A string containing the date to check. \return
+        //! (true) if the given date matches the stored one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istGleich( "y-m-d", "1995-11-1" ); return: true
         DLLEXPORT bool istGleich(const char* format, const char* datum) const;
-        //! Prueft, ob das Datum gleich dem uebergebenen Datum ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Ein Text Zeichnung, welches das zu ueberpruefende Datum enthaelt.
-        //! \return (true), wenn das uebergebene Datum dem gespeicherten
-        //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich(
-        //! "y-m-d", new Text( "1995-11-1" ) ); return: true
+        //! Checks if the date equals the given date.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A Text object containing the date to check.
+        //! \return (true) if the given date matches the stored one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istGleich( "y-m-d", new Text( "1995-11-1" ) ); return: true
         DLLEXPORT bool istGleich(const char* format, Text* datum) const;
-        //! Prueft, ob das Datum gleich dem uebergebenen Datum ist.
-        //! \param jahr Das Jahr des zu ueberpruefenden Datums.
-        //! \param monat Der Monat des zu ueberpruefenden Datums.
-        //! \param tag Der Tag des zu ueberpruefenden Datums.
-        //! \return (true), wenn das uebergebene Datum dem gespeicherten
-        //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( 1995,
-        //! 11, 1 ); return: true
+        //! Checks if the date equals the given date.
+        //! \param jahr The year of the date to check.
+        //! \param monat The month of the date to check.
+        //! \param tag The day of the date to check.
+        //! \return (true) if the given date matches the stored one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istGleich( 1995, 11, 1 ); return: true
         DLLEXPORT bool istGleich(int jahr, int monat, int tag) const;
-        //! Prueft, ob das Jahr gleich dem uebergebenen Jahr ist.
-        //! \param jahr Das zu pruefende Jahr.
-        //! \return (true), wenn das uebergebene Jahr dem gespeicherten
-        //! entspricht. (false) sonnst.
+        //! Checks if the year equals the given year.
+        //! \param jahr The year to check.
+        //! \return (true) if the given year matches the stored one.
+        //! (false) otherwise.
         DLLEXPORT bool jahrGleich(int jahr) const;
-        //! Prueft, ob der Monat gleich dem uebergebenen Monat ist.
-        //! \param monat Der zu pruefende Monat.
-        //! \return (true), wenn der uebergebene Monat dem gespeicherten
-        //! entspricht. (false) sonnst.
+        //! Checks if the month equals the given month.
+        //! \param monat The month to check.
+        //! \return (true) if the given month matches the stored one.
+        //! (false) otherwise.
         DLLEXPORT bool monatGleich(int monat) const;
-        //! Prueft, ob der Tag gleich dem uebergebenen Tag ist.
-        //! \param tag Der zu pruefende Tag.
-        //! \return (true), wenn der uebergebene Tag dem gespeicherten
-        //! entspricht. (false) sonnst.
+        //! Checks if the day equals the given day.
+        //! \param tag The day to check.
+        //! \return (true) if the given day matches the stored one.
+        //! (false) otherwise.
         DLLEXPORT bool tagGleich(int tag) const;
-        //! Prueft, ob das gespeicherte Datum kleiner als das uebergebene ist.
-        //! \param datum Das zu pruefende Datum.
-        //! \return (true), wenn das gespeicherte Datum vor dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner(
-        //! ( 23.1.2016 ) ); return true
+        //! Checks if the stored date is less than the given one.
+        //! \param datum The date to check.
+        //! \return (true) if the stored date is before the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istKleiner( ( 23.1.2016 ) ); return true
         DLLEXPORT bool istKleiner(Datum* datum) const;
-        //! Prueft, ob das gespeicherte Datum kleiner als das uebergebene ist.
-        //! \param jahr Das Jahr des zu pruefenden Datums.
-        //! \param monat Der Monat des zu pruefenden Datums.
-        //! \param tag Der Tag des zu pruefenden Datums.
-        //! \return (true), wenn das gespeicherte Datum vor dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( 2016, 1,
-        //! 23 ); return true
+        //! Checks if the stored date is less than the given one.
+        //! \param jahr The year of the date to check.
+        //! \param monat The month of the date to check.
+        //! \param tag The day of the date to check.
+        //! \return (true) if the stored date is before the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istKleiner( 2016, 1, 23 ); return true
         DLLEXPORT bool istKleiner(int jahr, int monat, int tag) const;
-        //! Prueft, ob das gespeicherte Datum kleiner als das uebergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Eine Zeichenkette, die das zu ueberpruefende Datum enthaelt. \return
-        //! (true), wenn das gespeicherte Datum vor dem uebergebenen liegt.
-        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d",
-        //! "2016, 1, 23" ); return true
+        //! Checks if the stored date is less than the given one.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A string containing the date to check. \return
+        //! (true) if the stored date is before the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istKleiner( "y, m, d", "2016, 1, 23" ); return true
         DLLEXPORT bool istKleiner(const char* format, const char* datum) const;
-        //! Prueft, ob das gespeicherte Datum kleiner als das uebergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Ein Text Zeichnung, welches das zu ueberpruefende Datum enthaelt.
-        //! \return (true), wenn das gespeicherte Datum vor dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m,
-        //! d", new Text( "2016, 1, 23" ) ); return true
+        //! Checks if the stored date is less than the given one.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A Text object containing the date to check.
+        //! \return (true) if the stored date is before the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istKleiner( "y, m, d", new Text( "2016, 1, 23" ) ); return true
         DLLEXPORT bool istKleiner(const char* format, Text* datum) const;
-        //! Prueft, ob das gespeicherte Datum groesser als das uebergebene ist.
-        //! \param datum Das zu pruefende Datum.
-        //! \return (true), wenn das gespeicherte Datum hinter dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGroesser(
-        //! ( 23.1.2016 ) ); return false
+        //! Checks if the stored date is greater than the given one.
+        //! \param datum The date to check.
+        //! \return (true) if the stored date is after the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istLater( ( 23.1.2016 ) ); return false
         DLLEXPORT bool istLater(Datum* datum) const;
-        //! Prueft, ob das gespeicherte Datum groesser als das uebergebene ist.
-        //! \param jahr Das Jahr des zu pruefenden Datums.
-        //! \param monat Der Monat des zu pruefenden Datums.
-        //! \param tag Der Tag des zu pruefenden Datums.
-        //! \return (true), wenn das gespeicherte Datum hinter dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGroesser( 2016, 1,
-        //! 23 ); return false
+        //! Checks if the stored date is greater than the given one.
+        //! \param jahr The year of the date to check.
+        //! \param monat The month of the date to check.
+        //! \param tag The day of the date to check.
+        //! \return (true) if the stored date is after the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istLater( 2016, 1, 23 ); return false
         DLLEXPORT bool istLater(int jahr, int monat, int tag) const;
-        //! Prueft, ob das gespeicherte Datum groesser als das uebergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Eine Zeichenkette, die das zu ueberpruefende Datum enthaelt. \return
-        //! (true), wenn das gespeicherte Datum hinter dem uebergebenen liegt.
-        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGroesser( "y, m, d", "2016,
-        //! 1, 23" ); return false
+        //! Checks if the stored date is greater than the given one.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A string containing the date to check. \return
+        //! (true) if the stored date is after the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istLater( "y, m, d", "2016, 1, 23" ); return false
         DLLEXPORT bool istLater(const char* format, const char* datum) const;
-        //! Prueft, ob das gespeicherte Datum groesser als das uebergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das
-        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
-        //! Ein Text Zeichnung, welches das zu ueberpruefende Datum enthaelt.
-        //! \return (true), wenn das gespeicherte Datum hinter dem uebergebenen
-        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGroesser( "y, m, d",
-        //! new Text( "2016, 1, 23" ) ) ); return true
+        //! Checks if the stored date is greater than the given one.
+        //! \param format A string specifying the format of the
+        //! date in (datum). y=year, m=month, d=day. \param datum
+        //! A Text object containing the date to check.
+        //! \return (true) if the stored date is after the given one.
+        //! (false) otherwise.
+        //! Example: ( 1.11.1995 ).istLater( "y, m, d", new Text( "2016, 1, 23" ) ); return true
         DLLEXPORT bool istLater(const char* format, Text* datum) const;
     };
 
-    //! Diese Klasse vereint die beiden Klassen Datum und Uhrzeit und speichert
-    //! somit einen Zeitstempel mit Jahr, Monat, Tag, Stunde, Minute und Sekunde
+    //! This class combines the Datum and Uhrzeit classes and thus stores
+    //! a timestamp with year, month, day, hour, minute and second
     class Zeit : public virtual ReferenceCounter
     {
     private:
@@ -523,250 +521,247 @@ namespace Framework
         Uhrzeit* uhrzeit;
 
     public:
-        //! Erzeugt eine neue Zeit mit den Standartwerten 0.0.0 0:0:0.
+        //! Creates a new Zeit with the default values 0.0.0 0:0:0.
         DLLEXPORT Zeit();
-        //! Erzeugt eine neue Zeit mit den vergangenen sekunden seit 1970.
+        //! Creates a new Zeit with the elapsed seconds since 1970.
         DLLEXPORT Zeit(__int64 timestamp);
-        //! Loescht das aktuelle Zeichnung.
+        //! Deletes the current object.
         DLLEXPORT ~Zeit();
-        //! AEndert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
-        //! \param zeit Die neue Zeit.
+        //! Changes the stored time by copying the values from (zeit).
+        //! \param zeit The new time.
         DLLEXPORT void setZeit(Zeit* zeit);
-        //! AEndert die gespeicherte Zeit.
-        //! \param jahr Das neue Jahr.
-        //! \param monat Der neue Monat.
-        //! \param tag Det neue Tag.
-        //! \param stunde Die neue Stunde.
-        //! \param minute Die neue Minute.
-        //! \param sekunde Die neue Sekunde.
+        //! Changes the stored time.
+        //! \param jahr The new year.
+        //! \param monat The new month.
+        //! \param tag The new day.
+        //! \param stunde The new hour.
+        //! \param minute The new minute.
+        //! \param sekunde The new second.
         DLLEXPORT void setZeit(
             int jahr, int monat, int tag, int stunde, int minute, int sekunde);
-        //! AEndert die gespeicherte Zeit.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die neue
-        //! Zeit enthaelt. Beispiel: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30"
-        //! );
+        //! Changes the stored time.
+        //! \param format A string specifying the format of the new
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the new
+        //! time. Example: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30" );
         DLLEXPORT void setZeit(const char* format, const char* zeit);
-        //! AEndert die gespeicherte Zeit.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die
-        //! neue Zeit enthaelt. Beispiel: setZeit( "y-m-d h:i:s", new Text(
+        //! Changes the stored time.
+        //! \param format A string specifying the format of the new
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! new time. Example: setZeit( "y-m-d h:i:s", new Text(
         //! "2016-1-25 21:59:30" ) );
         DLLEXPORT void setZeit(const char* format, Text* zeit);
-        //! AEndert das gespeicherte Jahr.
-        //! \param jahr Das neue Jahr.
+        //! Changes the stored year.
+        //! \param jahr The new year.
         DLLEXPORT void setJahr(int jahr);
-        //! AEndert den gespeicherten Monat.
-        //! \param monat Der neue Monat.
+        //! Changes the stored month.
+        //! \param monat The new month.
         DLLEXPORT void setMonat(int monat);
-        //! AEndert den gespeicherten Tag.
-        //! \param tag Der neue Tag.
+        //! Changes the stored day.
+        //! \param tag The new day.
         DLLEXPORT void setTag(int tag);
-        //! AEndert die gespeicherte Stunde.
-        //! \param stunde Die neue Stunde.
+        //! Changes the stored hour.
+        //! \param stunde The new hour.
         DLLEXPORT void setStunde(int stunde);
-        //! AEndert die gespeicherte Minute.
-        //! \param minute Die neue Minute.
+        //! Changes the stored minute.
+        //! \param minute The new minute.
         DLLEXPORT void setMinute(int minute);
-        //! AEndert die gespeicherte Sekunde.
-        //! \param sekunde Die neue Sekunde.
+        //! Changes the stored second.
+        //! \param sekunde The new second.
         DLLEXPORT void setSekunde(int sekunde);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param zeit Die zu Addierende Zeit.
+        //! Adds the given time and stores the result.
+        //! \param zeit The time to add.
         DLLEXPORT void plusZeit(Zeit* zeit);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
-        //! \param monat Der zu addierende Monat.
-        //! \param tag Der zu addierende Tag.
-        //! \param stunde Die zu addierende Stunde.
-        //! \param minute Die zu addierende Minute.
-        //! \param sekunde Die zu addierende Sekunde.
+        //! Adds the given time and stores the result.
+        //! \param jahr The year to add.
+        //! \param monat The month to add.
+        //! \param tag The day to add.
+        //! \param stunde The hour to add.
+        //! \param minute The minute to add.
+        //! \param sekunde The second to add.
         DLLEXPORT void plusZeit(
             int jahr, int monat, int tag, int stunde, int minute, int sekunde);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
-        //! addierende Zeit enthaelt.
+        //! Adds the given time and stores the result.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the
+        //! time to add.
         DLLEXPORT void plusZeit(const char* format, const char* zeit);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die zu
-        //! addierende Zeit enthaelt.
+        //! Adds the given time and stores the result.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! time to add.
         DLLEXPORT void plusZeit(const char* format, Text* zeit);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
+        //! Adds the given time and stores the result.
+        //! \param jahr The year to add.
         DLLEXPORT void plusJahr(int jahr);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param monat Der zu addierende Monat.
+        //! Adds the given time and stores the result.
+        //! \param monat The month to add.
         DLLEXPORT void plusMonat(int monat);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param tag Der zu addierende Tag.
+        //! Adds the given time and stores the result.
+        //! \param tag The day to add.
         DLLEXPORT void plusTag(int tag);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param stunde Die zu addierende Stunde.
+        //! Adds the given time and stores the result.
+        //! \param stunde The hour to add.
         DLLEXPORT void plusStunde(__int64 stunde);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param minute Die zu addierende Minute.
+        //! Adds the given time and stores the result.
+        //! \param minute The minute to add.
         DLLEXPORT void plusMinute(__int64 minute);
-        //! Addiert die uebergebene Zeit und speichert das Ergebnis.
-        //! \param sekunde Die zu addierende Sekunde.
+        //! Adds the given time and stores the result.
+        //! \param sekunde The second to add.
         DLLEXPORT void plusSekunde(__int64 sekunde);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param zeit Die abzuziehende Zeit.
+        //! Subtracts the given time and stores the result.
+        //! \param zeit The time to subtract.
         DLLEXPORT void minusZeit(Zeit* zeit);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param jahr Das abzuziehende Jahr.
-        //! \param monat Der abzuziehende Monat.
-        //! \param tag Der abzuziehende Tag.
-        //! \param stunde Die abzuziehende Stunde.
-        //! \param minute Die abzuziehende Minute.
-        //! \param sekunde Die abzuziehende Sekunde.
+        //! Subtracts the given time and stores the result.
+        //! \param jahr The year to subtract.
+        //! \param monat The month to subtract.
+        //! \param tag The day to subtract.
+        //! \param stunde The hour to subtract.
+        //! \param minute The minute to subtract.
+        //! \param sekunde The second to subtract.
         DLLEXPORT void minusZeit(
             int jahr, int monat, int tag, int stunde, int minute, int sekunde);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die
-        //! abzuziehende Zeit enthaelt.
+        //! Subtracts the given time and stores the result.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the
+        //! time to subtract.
         DLLEXPORT void minusZeit(const char* format, const char* zeit);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die
-        //! abzuziehende Zeit enthaelt.
+        //! Subtracts the given time and stores the result.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! time to subtract.
         DLLEXPORT void minusZeit(const char* format, Text* zeit);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param jahr Das abzuziehende Jahr.
+        //! Subtracts the given time and stores the result.
+        //! \param jahr The year to subtract.
         DLLEXPORT void minusJahr(int jahr);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param monat Der abzuziehende Monat.
+        //! Subtracts the given time and stores the result.
+        //! \param monat The month to subtract.
         DLLEXPORT void minusMonat(int monat);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param tag Der abzuziehende Tag.
+        //! Subtracts the given time and stores the result.
+        //! \param tag The day to subtract.
         DLLEXPORT void minusTag(int tag);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param stunde Die abzuziehende Stunde.
+        //! Subtracts the given time and stores the result.
+        //! \param stunde The hour to subtract.
         DLLEXPORT void minusStunde(__int64 stunde);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param minute Die abzuziehende Minute.
+        //! Subtracts the given time and stores the result.
+        //! \param minute The minute to subtract.
         DLLEXPORT void minusMinute(__int64 minute);
-        //! Zieht die uebergebene Zeit ab und speichert das Ergebnis.
-        //! \param sekunde Die abzuziehende Sekunde.
+        //! Subtracts the given time and stores the result.
+        //! \param sekunde The second to subtract.
         DLLEXPORT void minusSekunde(__int64 sekunde);
-        //! Gibt die gespeicherte Zeit als Text zurueck.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit zurueckgegeben werden soll. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde.
+        //! Returns the stored time as text.
+        //! \param format A string specifying the format of the
+        //! returned time. y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second.
         DLLEXPORT Text* getZeit(const char* format) const;
-        //! UEberprueft, ob die Zeit gleich der uebergebenen Zeit ist.
-        //! \param zeit die zu ueberpruefende Zeit.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+        //! Checks if the time equals the given time.
+        //! \param zeit The time to check.
+        //! \return (true) if the times are equal. (false) otherwise.
         DLLEXPORT bool istGleich(Zeit* zeit) const;
-        //! UEberprueft, ob die Zeit gleich der uebergebenen Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
-        //! ueberpruefende Zeit enthaelt. \return (true), wenn die Zeiten gleich
-        //! sind. (false) sonst.
+        //! Checks if the time equals the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the
+        //! time to check. \return (true) if the times are equal.
+        //! (false) otherwise.
         DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
-        //! UEberprueft, ob die Zeit gleich der uebergebenen Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
-        //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
-        //! ueberpruefende Zeit enthaelt. \return (true), wenn die Zeiten gleich
-        //! sind. (false) sonst.
+        //! Checks if the time equals the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! time to check. \return (true) if the times are equal.
+        //! (false) otherwise.
         DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
-        //! UEberprueft, ob die Zeit gleich der uebergebenen Zeit ist.
-        //! \param jahr Das zu ueberpruefende Jahr.
-        //! \param monat Der zu ueberpruefende Monat.
-        //! \param tag Der zu ueberpruefende Tag.
-        //! \param stunde Die zu ueberpruefende Stunde.
-        //! \param minute Die zu ueberpruefende Minute.
-        //! \param sekunde Die zu ueberpruefende Sekunde.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+        //! Checks if the time equals the given time.
+        //! \param jahr The year to check.
+        //! \param monat The month to check.
+        //! \param tag The day to check.
+        //! \param stunde The hour to check.
+        //! \param minute The minute to check.
+        //! \param sekunde The second to check.
+        //! \return (true) if the times are equal. (false) otherwise.
         DLLEXPORT bool istGleich(int jahr,
             int monat,
             int tag,
             int stunde,
             int minute,
             int sekunde) const;
-        //! Gibt das Zeichnung zurueck, in dem das Datum gespeichert wird mit
-        //! erhoehtem Reference Counter.
+        //! Returns the object storing the date with increased reference counter.
         DLLEXPORT Datum* getDatum() const;
-        //! Gibt das Zeichnung zurueck, in dem das Datum gespeichert wird ohne
-        //! erhoehten Reference Counter.
+        //! Returns the object storing the date without increased reference counter.
         DLLEXPORT Datum* zDatum() const;
-        //! Gibt das Zeichnung zurueck, in dem die Uhrzeit gespeichert wird mit
-        //! erhoehtem Reference Counter.
+        //! Returns the object storing the time of day with increased reference counter.
         DLLEXPORT Uhrzeit* getUhrzeit() const;
-        //! Gibt das Zeichnung zurueck, in dem die uhrzeit gespeichert wird ohne
-        //! erhoehten Reference Counter.
+        //! Returns the object storing the time of day without increased reference counter.
         DLLEXPORT Uhrzeit* zUhrzeit() const;
-        //! UEberprueft, ob die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. \param zeit Die zu ueberpruefende Zeit. \return (true) wenn die
-        //! gespeicherte Zeit vor der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is less than the given time.
+        //! \param zeit The time to check. \return (true)
+        //! if the stored time is before the given time. (false)
+        //! otherwise.
         DLLEXPORT bool istKleiner(Zeit* zeit) const;
-        //! UEberprueft, ob die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. \param jahr Das zu ueberpruefende Jahr. \param monat Der zu
-        //! ueberpruefende Monat. \param tag Der zu ueberpruefende Tag. \param
-        //! stunde Die zu ueberpruefende Stunde. \param minute Die zu ueberpruefende
-        //! Minute. \param sekunde Die zu ueberpruefende Sekunde. \return (true)
-        //! wenn die gespeicherte Zeit vor der uebergebenen Zeit liegt. (false)
-        //! sonnst.
+        //! Checks if the stored time is less than the given time.
+        //! \param jahr The year to check. \param monat The
+        //! month to check. \param tag The day to check.
+        //! \param stunde The hour to check. \param minute The
+        //! minute to check. \param sekunde The second to check.
+        //! \return (true) if the stored time is before the given time.
+        //! (false) otherwise.
         DLLEXPORT bool istKleiner(int jahr,
             int monat,
             int tag,
             int stunde,
             int minute,
             int sekunde) const;
-        //! UEberprueft, ob die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
-        //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
-        //! ueberpruefende Zeit enthaelt. \return (true) wenn die gespeicherte Zeit
-        //! vor der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is less than the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the
+        //! time to check. \return (true) if the stored time is before
+        //! the given time. (false) otherwise.
         DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
-        //! UEberprueft, ob die gespeicherte Zeit kleiner als die uebergebene Zeit
-        //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
-        //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
-        //! ueberpruefende Zeit enthaelt. \return (true) wenn die gespeicherte Zeit
-        //! vor der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is less than the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! time to check. \return (true) if the stored time is before
+        //! the given time. (false) otherwise.
         DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
-        //! UEberprueft, ob die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. \param zeit Die zu ueberpruefende Zeit. \return (true) wenn die
-        //! gespeicherte Zeit nach der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is greater than the given time.
+        //! \param zeit The time to check. \return (true)
+        //! if the stored time is after the given time. (false)
+        //! otherwise.
         DLLEXPORT bool istLater(Zeit* zeit) const;
-        //! UEberprueft, ob die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. \param jahr Das zu ueberpruefende Jahr. \param monat Der zu
-        //! ueberpruefende Monat. \param tag Der zu ueberpruefende Tag. \param
-        //! stunde Die zu ueberpruefende Stunde. \param minute Die zu ueberpruefende
-        //! Minute. \param sekunde Die zu ueberpruefende Sekunde. \return (true)
-        //! wenn die gespeicherte Zeit nach der uebergebenen Zeit liegt. (false)
-        //! sonnst.
+        //! Checks if the stored time is greater than the given time.
+        //! \param jahr The year to check. \param monat The
+        //! month to check. \param tag The day to check.
+        //! \param stunde The hour to check. \param minute The
+        //! minute to check. \param sekunde The second to check.
+        //! \return (true) if the stored time is after the given time.
+        //! (false) otherwise.
         DLLEXPORT bool istLater(int jahr,
             int monat,
             int tag,
             int stunde,
             int minute,
             int sekunde) const;
-        //! UEberprueft, ob die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
-        //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
-        //! ueberpruefende Zeit enthaelt. \return (true) wenn die gespeicherte Zeit
-        //! nach der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is greater than the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A string containing the
+        //! time to check. \return (true) if the stored time is after
+        //! the given time. (false) otherwise.
         DLLEXPORT bool istLater(const char* format, const char* zeit) const;
-        //! UEberprueft, ob die gespeicherte Zeit groesser als die uebergebene Zeit
-        //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
-        //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
-        //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
-        //! ueberpruefende Zeit enthaelt. \return (true) wenn die gespeicherte Zeit
-        //! nach der uebergebenen Zeit liegt. (false) sonnst.
+        //! Checks if the stored time is greater than the given time.
+        //! \param format A string specifying the format of the
+        //! time in (zeit). y=year, m=month, d=day, h=hour,
+        //! i=minute, s=second. \param zeit A Text object containing the
+        //! time to check. \return (true) if the stored time is after
+        //! the given time. (false) otherwise.
         DLLEXPORT bool istLater(const char* format, Text* zeit) const;
     };