improve 3d alpha blending and add support for HBildScale style in ZeichnungHintergrund

AuswahlBox.h

@@ -23,80 +23,68 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 FeldRahmen
-                = 0x000001000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! aus der Liste einen Rahmen
-            static const __int64 FeldHintergrund
-                = 0x000002000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! aus der Liste einen Hintergrund
-            static const __int64 FeldHBild
-                = 0x000004000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! aus der Liste ein Bild als Hintergrund
-            static const __int64 FeldHAlpha
-                = 0x000008000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! aus der Liste einen Transparenten Hintergrund
-            static const __int64 FeldBuffer
-                = 0x000010000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! aus der Liste einen Farbübergang
-            static const __int64 AuswahlHintergrund
-                = 0x000020000; //! Wenn dieser Flag gesetzt ist, bekommt der
-                               //! Wert, der gerade ausgewählt ist einen
-                               //! Hintergrund
-            static const __int64 AuswahlHBild
-                = 0x000040000; //! Wenn dieser Flag gesetzt ist, bekommt der
-                               //! Wert, der gerade ausgewählt ist ein
-                               //! Hintergrundbild
-            static const __int64 AuswahlHAlpha
-                = 0x000080000; //! Wenn dieser Flag gesetzt ist, bekommt der
-                               //! Wert, der gerade ausgewählt ist einen
-                               //! transparenten Hintergrund
-            static const __int64 AuswahlBuffer
-                = 0x000100000; //! Wenn dieser Flag gesetzt ist, bekommt der
-                               //! Wert, der gerade ausgewählt ist einen
-                               //! Farbübergang
-            static const __int64 AuswahlRahmen
-                = 0x000200000; //! Wenn dieser Flag gesetzt ist, bekommt der
-                               //! Wert, der gerade ausgewählt ist einen Rahmen
-            static const __int64 MultiStyled
-                = 0x000400000; //! Wenn dieser Flag gesetzt ist, hat jeder Wert
-                               //! seine eigenen Hintergründe unt Rahmen und
-                               //! nicht alle die selben
-            static const __int64 MaxHeight
-                = 0x004000000; //! Legt eine maximale Höhe der ausgeklappten
-                               //! Liste fest. Es erscheint automatisch eine
-                               //! Scrollbar wenn mehr Elemente da sind als
-                               //! sichtbar sein können
-            static const __int64 MausHintergrund
-                = 0x008000000; //! Wenn dieser Flag gesetzt ist, hat ein
-                               //! Element, wo die Maus drau zeigt, einen
-                               //! Hintergrund
-            static const __int64 MausHBild
-                = 0x010000000; //! Wenn dieser Flag gesetzt ist, hat ein
-                               //! Element, wo die Maus drauf zeigt, ein
-                               //! Hintergrundbild
-            static const __int64 MausHAlpha
-                = 0x020000000; //! Wenn dieser Flag gesetzt ist, hat ein
-                               //! Element, wo die Maus drauf zeigt, einen
-                               //! transparenten Hintergrund
-            static const __int64 MausBuffer
-                = 0x040000000; //! Wenn dieser Flag gesetzt ist, hat ein
-                               //! Element, wo die Maus drauf zeigt, einen
-                               //! Farbübergang
-            static const __int64 MausRahmen
-                = 0x080000000; //! Wenn dieser Flag gesetzt ist, hat ein
-                               //! Element, wo die Maus drauf zeigt, einen
-                               //! Rahmen
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert aus der Liste einen
+            // Rahmen
+            static const __int64 FeldRahmen = 0x000001000;
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert aus der Liste einen
+            // Hintergrund
+            static const __int64 FeldHintergrund = 0x000002000;
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert aus der Liste ein
+            // Bild als Hintergrund
+            static const __int64 FeldHBild = 0x000004000;
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert aus der Liste einen
+            // Transparenten Hintergrund
+            static const __int64 FeldHAlpha = 0x000008000;
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert aus der Liste einen
+            // Farbübergang
+            static const __int64 FeldBuffer = 0x000010000;
+            // Wenn dieser Flag gesetzt ist, bekommt der Wert, der gerade
+            // ausgewählt  Hintergrund
+            static const __int64 AuswahlHintergrund = 0x000020000;
+            // Wenn dieser Flag gesetzt ist, bekommt der Wert, der gerade
+            // ausgewählt ist ein Hintergrundbild
+            static const __int64 AuswahlHBild = 0x000040000;
+            // Wenn dieser Flag gesetzt ist, bekommt der Wert, der gerade
+            // ausgewählt ist einen transparenten Hintergrund
+            static const __int64 AuswahlHAlpha = 0x000080000;
+            // Wenn dieser Flag gesetzt ist, bekommt der Wert, der gerade
+            // ausgewählt ist einen Farbübergang
+            static const __int64 AuswahlBuffer = 0x000100000;
+            // Wenn dieser Flag gesetzt ist, bekommt der Wert, der gerade
+            // ausgewählt ist einen Rahmen
+            static const __int64 AuswahlRahmen = 0x000200000;
+            // Wenn dieser Flag gesetzt ist, hat jeder Wert seine eigenen
+            // Hintergründe unt Rahmen und nicht alle die selben
+            static const __int64 MultiStyled = 0x000400000;
+            // Legt eine maximale Höhe der ausgeklappten Liste fest. Es
+            // erscheint automatisch eine Scrollbar wenn mehr Elemente da sind
+            // als sichtbar sein können
+            static const __int64 MaxHeight = 0x004000000;
+            // Wenn dieser Flag gesetzt ist, hat ein Element, wo die Maus drau
+            // zeigt, einen Hintergrund
+            static const __int64 MausHintergrund = 0x008000000;
+            // Wenn dieser Flag gesetzt ist, hat ein Element, wo die Maus drauf
+            // zeigt, ein Hintergrundbild
+            static const __int64 MausHBild = 0x010000000;
+            // Wenn dieser Flag gesetzt ist, hat ein Element, wo die Maus drauf
+            // zeigt, einen transparenten Hintergrund
+            static const __int64 MausHAlpha = 0x020000000;
+            // Wenn dieser Flag gesetzt ist, hat ein Element, wo die Maus drauf
+            // zeigt, einen Farbübergang
+            static const __int64 MausBuffer = 0x040000000;
+            // Wenn dieser Flag gesetzt ist, hat ein Element, wo die Maus drauf
+            // zeigt, einen Rahmen
+            static const __int64 MausRahmen = 0x080000000;
             // const int NachObenAusklappen	= 0x100000000;
             // const int AutoAusklappRichtung	= 0x200000000;
 
+            // Normaler Style: Sichtbar, Erlaubt, Rahmen, FeldRahmen,
+            // AuswahlBuffer, AuswahlRahmen, MaxHöhe, VScroll, MausRahmen,
+            // MausBuffer
             static const __int64 Normal
                 = Sichtbar | Erlaubt | Rahmen | FeldRahmen | AuswahlBuffer
                 | AuswahlRahmen | MaxHeight | VScroll | MausRahmen | MausBuffer
-                | Hintergrund | MEIgnoreParentInside
-                | MEIgnoreVerarbeitet; //! Normaler Style: Sichtbar, Erlaubt,
-                                       //! Rahmen, FeldRahmen, AuswahlBuffer,
-                                       //! AuswahlRahmen, MaxHöhe, VScroll,
-                                       //! MausRahmen, MausBuffer
+                | Hintergrund | MEIgnoreParentInside | MEIgnoreVerarbeitet;
         };
 
     private:

Bild.cpp

@@ -98,6 +98,8 @@ inline void Bild::alphaPixelP3D(int& fc, int colorb)
     // alphaPixelAssozP( fc, colorb );
     // return;
     int alpha = ((colorb >> 24) & 0xFF);
+    int oldAlpha = ((fc >> 24) & 0xFF);
+    bool newAlpha = alpha > oldAlpha;
     int na = (0x100 - alpha);
     fc = (((((na * (fc & 0xFF00FF)) >> 8)
                + ((alpha * (colorb & 0xFF00FF)) >> 8))
@@ -105,7 +107,8 @@ inline void Bild::alphaPixelP3D(int& fc, int colorb)
              | ((((na * (fc & 0x00FF00)) >> 8)
                     + ((alpha * (colorb & 0x00FF00)) >> 8))
                  & 0x00FF00)
-             | ((fc & 0xFF000000)))
+             | ((colorb & 0xFF000000) * newAlpha)
+             | ((fc & 0xFF000000) * !newAlpha))
            * (fc != 0)
        | (fc == 0) * colorb;
     // unsigned char *fc1 = (unsigned char*)&fc;
@@ -124,13 +127,13 @@ inline void Bild::alphaPixelP(int& fc, int colorb)
     // return;
     int alpha = ((colorb >> 24) & 0xFF);
     int na = (0x100 - alpha);
-    fc = (((((na * (fc & 0xFF00FF)) >> 8)
+    fc = ((((na * (fc & 0xFF00FF)) >> 8)
                + ((alpha * (colorb & 0xFF00FF)) >> 8))
               & 0xFF00FF)
           | ((((na * (fc & 0x00FF00)) >> 8)
                  + ((alpha * (colorb & 0x00FF00)) >> 8))
               & 0x00FF00)
-          | ((fc & 0xFF000000)));
+          | ((fc & 0xFF000000));
     // unsigned char *fc1 = (unsigned char*)&fc;
     // unsigned char *fc2 = (unsigned char*)&colorb;
     // unsigned char na = 255-fc2[ 3 ];
@@ -556,22 +559,13 @@ void Bild::alphaRegion(int x, int y, int b, int h, int ff)
     }
     int* pixel = fc + y * size.x + x;
     int* rowEnd = pixel + b;
-    int alpha = ((ff >> 24) & 0xFF);
-    int na = (0x100 - alpha);
-    int i1 = (alpha * (ff & 0xFF00FF)) >> 8;
-    int i2 = (alpha * (ff & 0x00FF00)) >> 8;
     if (alpha3D)
     {
         for (int i = 0; i < h; pixel += size.x - b, ++i, rowEnd += size.x)
         {
             for (; pixel < rowEnd; ++pixel)
             {
-                *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                             | ((((na * (*pixel & 0x00FF00)) >> 8) + i2)
-                                 & 0x00FF00)
-                             | ((*pixel & 0xFF000000)))
-                           * (*pixel != 0)
-                       | (*pixel == 0) * ff;
+                alphaPixelP3D(*pixel, ff);
             }
         }
     }
@@ -581,10 +575,7 @@ void Bild::alphaRegion(int x, int y, int b, int h, int ff)
         {
             for (; pixel < rowEnd; ++pixel)
             {
-                *pixel
-                    = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                        | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                        | ((*pixel & 0xFF000000)));
+                alphaPixelP(*pixel, ff);
             }
         }
     }
@@ -835,17 +826,19 @@ void Bild::drawLinieHAlpha(
         cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
                                 * (cf[3] - alpha[alphaAnzahl]));
     }
-    int alpha = ((f >> 24) & 0xFF);
-    int na = (0x100 - alpha);
-    int i1 = (alpha * (f & 0xFF00FF)) >> 8;
-    int i2 = (alpha * (f & 0x00FF00)) >> 8;
-    for (int i = x + y * br; end < len; ++end, i += pval)
+    if (alpha3D)
+    {
+        for (int i = x + y * br; end < len; ++end, i += pval)
+        {
+            alphaPixelP3D(fc[i], f);
+        }
+    }
+    else
     {
-        fc[i] = (((((na * (fc[i] & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                    | ((((na * (fc[i] & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                    | ((fc[i] & 0xFF000000)))
-                  * (fc[i] != 0 || !alpha3D)
-              | (fc[i] == 0 && alpha3D) * f;
+        for (int i = x + y * br; end < len; ++end, i += pval)
+        {
+            alphaPixelP(fc[i], f);
+        }
     }
     rend = 1;
 }
@@ -882,17 +875,19 @@ void Bild::drawLinieVAlpha(
         cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
                                 * (cf[3] - alpha[alphaAnzahl]));
     }
-    int alpha = ((f >> 24) & 0xFF);
-    int na = (0x100 - alpha);
-    int i1 = (alpha * (f & 0xFF00FF)) >> 8;
-    int i2 = (alpha * (f & 0x00FF00)) >> 8;
-    for (int i = x + y * br; end < len; ++end, i += pval)
+    if (alpha3D)
+    {
+        for (int i = x + y * br; end < len; ++end, i += pval)
+        {
+            alphaPixelP3D(fc[i], f);
+        }
+    }
+    else
     {
-        fc[i] = (((((na * (fc[i] & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                    | ((((na * (fc[i] & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                    | (fc[i] & 0xFF000000))
-                  * (fc[i] != 0 || !alpha3D)
-              | (fc[i] == 0 && alpha3D) * f;
+        for (int i = x + y * br; end < len; ++end, i += pval)
+        {
+            alphaPixelP(fc[i], f);
+        }
     }
     rend = 1;
 }
@@ -1079,74 +1074,91 @@ void Bild::drawLinieBorderedAlpha(Punkt a, Punkt b, int bc, int fc)
                                     * (cf[3] - alpha[alphaAnzahl]));
         }
         int maxP = (int)(sqrt((float)(xlen * xlen + ylen * ylen)) + 0.5);
-        int alpha = ((fc >> 24) & 0xFF);
-        int alpha2 = ((bc >> 24) & 0xFF);
-        int na = (0x100 - alpha);
-        int na2 = (0x100 - alpha2);
-        int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
-        int i2 = (alpha * (fc & 0x00FF00)) >> 8;
-        int j1 = (alpha2 * (bc & 0xFF00FF)) >> 8;
-        int j2 = (alpha2 * (bc & 0x00FF00)) >> 8;
         int count = 0;
         int maxPixel = size.x * size.y;
-        while (
-            !((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
+        if (alpha3D)
         {
-            ++count;
-            if ((int)((int)(x - 0.5) + (int)(y + 0.5) * size.x) < maxPixel)
-            {
-                int& pixel = this->fc[(int)(x - 0.5) + (int)(y + 0.5) * size.x];
-                pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF)
-                            | ((((na2 * (pixel & 0x00FF00)) >> 8) + j2)
-                                & 0x00FF00)
-                            | (pixel & 0xFF000000))
-                          * (pixel != 0 || !alpha3D)
-                      | (pixel == 0 && alpha3D) * bc;
-            }
-            if ((int)((int)(x + 1.5) + (int)(y + 0.5) * size.x) < maxPixel)
-            {
-                int& pixel = this->fc[(int)(x + 1.5) + (int)(y + 0.5) * size.x];
-                pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF)
-                            | ((((na2 * (pixel & 0x00FF00)) >> 8) + j2)
-                                & 0x00FF00)
-                            | (pixel & 0xFF000000))
-                          * (pixel != 0 || !alpha3D)
-                      | (pixel == 0 && alpha3D) * bc;
-            }
-            if ((int)((int)(x + 0.5) + (int)(y - 0.5) * size.x) < maxPixel)
-            {
-                int& pixel = this->fc[(int)(x + 0.5) + (int)(y - 0.5) * size.x];
-                pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF)
-                            | ((((na2 * (pixel & 0x00FF00)) >> 8) + j2)
-                                & 0x00FF00)
-                            | (pixel & 0xFF000000))
-                          * (pixel != 0 || !alpha3D)
-                      | (pixel == 0 && alpha3D) * bc;
-            }
-            if ((int)((int)(x + 0.5) + (int)(y + 1.5) * size.x) < maxPixel)
-            {
-                int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 1.5) * size.x];
-                pixel = (((((na2 * (pixel & 0xFF00FF)) >> 8) + j1) & 0xFF00FF)
-                            | ((((na2 * (pixel & 0x00FF00)) >> 8) + j2)
-                                & 0x00FF00)
-                            | (pixel & 0xFF000000))
-                          * (pixel != 0 || !alpha3D)
-                      | (pixel == 0 && alpha3D) * bc;
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                if ((int)((int)(x - 0.5) + (int)(y + 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x - 0.5) + (int)(y + 0.5) * size.x];
+                    alphaPixelP3D(pixel, bc);
+                }
+                if ((int)((int)(x + 1.5) + (int)(y + 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 1.5) + (int)(y + 0.5) * size.x];
+                    alphaPixelP3D(pixel, bc);
+                }
+                if ((int)((int)(x + 0.5) + (int)(y - 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 0.5) + (int)(y - 0.5) * size.x];
+                    alphaPixelP3D(pixel, bc);
+                }
+                if ((int)((int)(x + 0.5) + (int)(y + 1.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 0.5) + (int)(y + 1.5) * size.x];
+                    alphaPixelP3D(pixel, bc);
+                }
+                x += xf, y += yf;
+            }
+            count = 0;
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
+                alphaPixelP3D(pixel, fc);
+                x += xf, y += yf;
             }
-            x += xf, y += yf;
         }
-        count = 0;
-        while (
-            !((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
+        else
         {
-            ++count;
-            int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
-            pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                        | ((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                        | (pixel & 0xFF000000))
-                      * (pixel != 0 || !alpha3D)
-                  | (pixel == 0 && alpha3D) * fc;
-            x += xf, y += yf;
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                if ((int)((int)(x - 0.5) + (int)(y + 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x - 0.5) + (int)(y + 0.5) * size.x];
+                    alphaPixelP(pixel, bc);
+                }
+                if ((int)((int)(x + 1.5) + (int)(y + 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 1.5) + (int)(y + 0.5) * size.x];
+                    alphaPixelP(pixel, bc);
+                }
+                if ((int)((int)(x + 0.5) + (int)(y - 0.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 0.5) + (int)(y - 0.5) * size.x];
+                    alphaPixelP(pixel, bc);
+                }
+                if ((int)((int)(x + 0.5) + (int)(y + 1.5) * size.x) < maxPixel)
+                {
+                    int& pixel
+                        = this->fc[(int)(x + 0.5) + (int)(y + 1.5) * size.x];
+                    alphaPixelP(pixel, bc);
+                }
+                x += xf, y += yf;
+            }
+            count = 0;
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
+                alphaPixelP(pixel, fc);
+                x += xf, y += yf;
+            }
         }
         rend = 1;
     }
@@ -1325,24 +1337,32 @@ void Bild::drawLinieAlpha(Punkt a, Punkt b, int fc)
         int na = (0x100 - alpha);
         int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
         int i2 = (alpha * (fc & 0x00FF00)) >> 8;
-        while (
-            !((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y) && count < maxP)
+        if (alpha3D)
         {
-            ++count;
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
+                alphaPixelP3D(pixel, fc);
+                x += xf, y += yf;
+            }
             int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
-            pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                        | ((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                        | (pixel & 0xFF000000))
-                      * (pixel != 0 || !alpha3D)
-                  | (pixel == 0 && alpha3D) * fc;
-            x += xf, y += yf;
+            alphaPixelP3D(pixel, fc);
+        }
+        else
+        {
+            while (!((int)(x + 0.5) == b.x && (int)(y + 0.5) == b.y)
+                   && count < maxP)
+            {
+                ++count;
+                int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
+                alphaPixelP(pixel, fc);
+                x += xf, y += yf;
+            }
+            int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
+            alphaPixelP(pixel, fc);
         }
-        int& pixel = this->fc[(int)(x + 0.5) + (int)(y + 0.5) * size.x];
-        pixel = (((((na * (pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                    | ((((na * (pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                    | (pixel & 0xFF000000))
-                  * (pixel != 0 || !alpha3D)
-              | (pixel == 0 && alpha3D) * fc;
         rend = 1;
     }
 }
@@ -1424,93 +1444,116 @@ void Bild::drawKreisAlpha(int xOff, int yOff, int r, int fc)
         cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
                                 * (cf[3] - alpha[alphaAnzahl]));
     }
-    int alpha = ((fc >> 24) & 0xFF);
-    int na = (0x100 - alpha);
-    int i1 = (alpha * (fc & 0xFF00FF)) >> 8;
-    int i2 = (alpha * (fc & 0x00FF00)) >> 8;
-    for (int a = 0; a < r; ++a)
+    if (alpha3D)
     {
-        int b = (int)(sqrt((float)(long)(r * r - a * a)) + 0.5);
-        int* pixel = 0;
-        if (xOff + a < dgx && xOff + a > dpx && yOff + b < dgy
-            && yOff + b > dpy)
-        {
-            pixel = &this->fc[xOff + a + (yOff + b) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy
-            && yOff + b > dpy)
-        {
-            pixel = &this->fc[xOff - a + (yOff + b) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy
-            && yOff - b > dpy)
-        {
-            pixel = &this->fc[xOff + a + (yOff - b) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy
-            && yOff - b > dpy)
+        for (int a = 0; a < r; ++a)
         {
-            pixel = &this->fc[xOff - a + (yOff - b) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy
-            && yOff + a > dpy)
-        {
-            pixel = &this->fc[xOff + b + (yOff + a) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy
-            && yOff + a > dpy)
-        {
-            pixel = &this->fc[xOff - b + (yOff + a) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
-        }
-        if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy
-            && yOff - a > dpy)
-        {
-            pixel = &this->fc[xOff + b + (yOff - a) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
+            int b = (int)(sqrt((float)(long)(r * r - a * a)) + 0.5);
+            int* pixel = 0;
+            if (xOff + a < dgx && xOff + a > dpx && yOff + b < dgy
+                && yOff + b > dpy)
+            {
+                pixel = &this->fc[xOff + a + (yOff + b) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy
+                && yOff + b > dpy)
+            {
+                pixel = &this->fc[xOff - a + (yOff + b) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy
+                && yOff - b > dpy)
+            {
+                pixel = &this->fc[xOff + a + (yOff - b) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy
+                && yOff - b > dpy)
+            {
+                pixel = &this->fc[xOff - a + (yOff - b) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy
+                && yOff + a > dpy)
+            {
+                pixel = &this->fc[xOff + b + (yOff + a) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy
+                && yOff + a > dpy)
+            {
+                pixel = &this->fc[xOff - b + (yOff + a) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy
+                && yOff - a > dpy)
+            {
+                pixel = &this->fc[xOff + b + (yOff - a) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
+            if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy
+                && yOff - a > dpy)
+            {
+                pixel = &this->fc[xOff - b + (yOff - a) * size.x];
+                alphaPixelP3D(*pixel, fc);
+            }
         }
-        if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy
-            && yOff - a > dpy)
+    }
+    else
+    {
+        for (int a = 0; a < r; ++a)
         {
-            pixel = &this->fc[xOff - b + (yOff - a) * size.x];
-            *pixel = (((((na * (*pixel & 0xFF00FF)) >> 8) + i1) & 0xFF00FF)
-                         | ((((na * (*pixel & 0x00FF00)) >> 8) + i2) & 0x00FF00)
-                         | (*pixel & 0xFF000000))
-                       * (*pixel != 0 || !alpha3D)
-                   | (*pixel == 0 && alpha3D) * fc;
+            int b = (int)(sqrt((float)(long)(r * r - a * a)) + 0.5);
+            int* pixel = 0;
+            if (xOff + a < dgx && xOff + a > dpx && yOff + b < dgy
+                && yOff + b > dpy)
+            {
+                pixel = &this->fc[xOff + a + (yOff + b) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff - a < dgx && xOff - a > dpx && yOff + b < dgy
+                && yOff + b > dpy)
+            {
+                pixel = &this->fc[xOff - a + (yOff + b) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff + a < dgx && xOff + a > dpx && yOff - b < dgy
+                && yOff - b > dpy)
+            {
+                pixel = &this->fc[xOff + a + (yOff - b) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff - a < dgx && xOff - a > dpx && yOff - b < dgy
+                && yOff - b > dpy)
+            {
+                pixel = &this->fc[xOff - a + (yOff - b) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff + b < dgx && xOff + b > dpx && yOff + a < dgy
+                && yOff + a > dpy)
+            {
+                pixel = &this->fc[xOff + b + (yOff + a) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff - b < dgx && xOff - b > dpx && yOff + a < dgy
+                && yOff + a > dpy)
+            {
+                pixel = &this->fc[xOff - b + (yOff + a) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff + b < dgx && xOff + b > dpx && yOff - a < dgy
+                && yOff - a > dpy)
+            {
+                pixel = &this->fc[xOff + b + (yOff - a) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
+            if (xOff - b < dgx && xOff - b > dpx && yOff - a < dgy
+                && yOff - a > dpy)
+            {
+                pixel = &this->fc[xOff - b + (yOff - a) * size.x];
+                alphaPixelP(*pixel, fc);
+            }
         }
     }
     rend = 1;
@@ -1667,7 +1710,7 @@ void Bild::alphaBild(int x, int y, int br, int hi, const Bild& zBild)
                     unsigned char* cf = (unsigned char*)&fc;
                     cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
                                             * (cf[3] - alpha[alphaAnzahl]));
-                    alphaPixelP(this->fc[xx + ygr], fc);
+                    alphaPixelP3D(this->fc[xx + ygr], fc);
                 }
             }
         }
@@ -1683,7 +1726,7 @@ void Bild::alphaBild(int x, int y, int br, int hi, const Bild& zBild)
                     unsigned char* cf = (unsigned char*)&fc;
                     cf[3] = (unsigned char)((cf[3] > alpha[alphaAnzahl])
                                             * (cf[3] - alpha[alphaAnzahl]));
-                    alphaPixelP3D(this->fc[xx + ygr], fc);
+                    alphaPixelP(this->fc[xx + ygr], fc);
                 }
             }
         }

Bild.h

@@ -250,7 +250,8 @@ namespace Framework
         //! werden soll \param hi Die Höhe des Rechecks in dem das Bild
         //! gezeichnet werden soll \param zBild Das Bild, was gezeichnet werden
         //! soll
-        DLLEXPORT void drawBild(int x, int y, int br, int hi, const Bild& zBild);
+        DLLEXPORT void drawBild(
+            int x, int y, int br, int hi, const Bild& zBild);
         //! Zeichnet ein Bild in ein bestimmtes Feld ohne Skallierung mit alpha
         //! blending \param x Die X Koordinate der linken oberen Ecke des
         //! Rechtecks in dem das Bild gezeichnet werden soll \param y Die Y
@@ -259,7 +260,8 @@ namespace Framework
         //! Bild gezeichnet werden soll \param hi Die Höhe des Rechecks in dem
         //! das Bild gezeichnet werden soll \param zBild Das Bild, was
         //! gezeichnet werden soll
-        DLLEXPORT void alphaBild(int x, int y, int br, int hi, const Bild& zBild);
+        DLLEXPORT void alphaBild(
+            int x, int y, int br, int hi, const Bild& zBild);
         //! Zeichnet ein Bild in ein bestimmtes Feld ohne Skallierung mit alpha
         //! blending \param x Die X Koordinate der linken oberen Ecke des
         //! Rechtecks in dem das Bild gezeichnet werden soll \param y Die Y
@@ -498,17 +500,17 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 Alpha
-                = 0x1000; //! Wenn dieser Flag gesetzt ist, wird zum Zeichnen
-                          //! des Bildes Alpha Blending verwendet
-            static const __int64 Skalliert
-                = 0x2000; //! Wenn dieser Flag gesetzt ist, wird das Bild in die
-                          //! Zeichenfläche skalliert
+            // Wenn dieser Flag gesetzt ist, wird zum Zeichnen des Bildes Alpha
+            // Blending verwendet
+            static const __int64 Alpha = 0x1000;
+            // Wenn dieser Flag gesetzt ist, wird das Bild in die Zeichenfläche
+            // skalliert
+            static const __int64 Skalliert = 0x2000;
 
+            // Der Normale Style einer Bild Zeichnung Bestehend aus HScroll,
+            // Sichtbar, Erlaubt, Rahmen, VScroll
             static const __int64 normal
-                = HScroll | Sichtbar | Erlaubt | Rahmen
-                | VScroll; //! Der Normale Style einer Bild Zeichnung Bestehend
-                           //! aus HScroll, Sichtbar, Erlaubt, Rahmen, VScroll
+                = HScroll | Sichtbar | Erlaubt | Rahmen | VScroll;
         };
 
     private:

Diagramm.h

@@ -25,16 +25,16 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 Gitter
-                = 0x01000; //! Es wird ein Gitter im Diagramm zur Orientierung
-                           //! gezeichnet
-            static const __int64 LinienName
-                = 0x02000; //! Es werden die Namen der Graphen angezeigt
+            //! Es wird ein Gitter im Diagramm zur Orientierung
+            //! gezeichnet
+            static const __int64 Gitter = 0x01000;
+            //! Es werden die Namen der Graphen angezeigt
+            static const __int64 LinienName = 0x02000;
 
+            //! Vereinigung der Flags Sichtbar, Hintergrund,
+            //! Rahmen, Gitter, LinienName
             static const __int64 normal
-                = Sichtbar | Hintergrund | Rahmen | Gitter
-                | LinienName; //! Vereinigung der Flags Sichtbar, Hintergrund,
-                              //! Rahmen, Gitter, LinienName
+                = Sichtbar | Hintergrund | Rahmen | Gitter | LinienName;
         };
 
     private:
@@ -548,26 +548,25 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 DatenRahmen
-                = 0x0001000; //! Legt fest, ob um die daten ein Rahmen
-                             //! gezeichnet wird
-            static const __int64 DatenHintergrund
-                = 0x02000; //! legt fest, ob die Daten einen Hintergrund haben
-            static const __int64 DatenHAlpha
-                = 0x04000; //! legt fest, ob beim zeichnen des Hintergrunds der
-                           //! Daten alpha blending benutzt wird
-            static const __int64 DatenHBild
-                = 0x008000; //! Legt fest, ob für den Hintergrund der Daten ein
-                            //! Bild verwendet werden soll
-            static const __int64 DatenBuffered
-                = 0x010000; //! Legt fest, ob die Daten einen Farbübergang haben
+            //! Legt fest, ob um die daten ein Rahmen
+            //! gezeichnet wird
+            static const __int64 DatenRahmen = 0x0001000;
+            //! legt fest, ob die Daten einen Hintergrund haben
+            static const __int64 DatenHintergrund = 0x02000;
+            //! legt fest, ob beim zeichnen des Hintergrunds der
+            //! Daten alpha blending benutzt wird
+            static const __int64 DatenHAlpha = 0x04000;
+            //! Legt fest, ob für den Hintergrund der Daten ein
+            //! Bild verwendet werden soll
+            static const __int64 DatenHBild = 0x008000;
+            //! Legt fest, ob die Daten einen Farbübergang haben
+            static const __int64 DatenBuffered = 0x010000;
 
-            static const __int64 scroll
-                = VScroll | HScroll; //! Vereint die Flags VScroll und HScroll
-            static const __int64 normal
-                = Hintergrund | scroll
-                | DatenRahmen; //! Vereint die Flags Hintergrund, scroll,
-                               //! DatenRahmen
+            //! Vereint die Flags VScroll und HScroll
+            static const __int64 scroll = VScroll | HScroll;
+            //! Vereint die Flags Hintergrund, scroll,
+            //! DatenRahmen
+            static const __int64 normal = Hintergrund | scroll | DatenRahmen;
         };
 
     private:

Fenster.cpp

@@ -1936,7 +1936,8 @@ void Fenster::render(Bild& zRObj) // zeichent nach zRObj
                     closeKlickBuffer->render(zRObj);
                 }
             }
-            titel->setSize(gr.x - rbr * 2 - sbr, th);
+            if (!hatStyle(Style::CustomTitle))
+                titel->setSize(gr.x - rbr * 2 - sbr, th);
             titel->render(zRObj);
             zRObj.releaseDrawOptions();
         }

Fenster.h

@@ -373,6 +373,8 @@ namespace Framework
             // Legt fest, ob die untere Seite des Fensters fixiert ist wenn die
             // größe änderbar ist
             static const __int64 BottomPositionFixed = 0x2000000000;
+            // Legt fest, ob die Position und Größe des Titel Textfeldes unverändert bleiben soll
+            static const __int64 CustomTitle = 0x4000000000;
             // Vereint die Flags MinHö, MaxHö, MaxBr, MaxHö
             static const __int64 min_max = MinHi | MaxHi | MaxBr | MaxHi;
             // Vereint die Flags Körper_minBr, Körper_maxBr, Körper_minHö,

Fortschritt.h

@@ -20,47 +20,42 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 Prozent
-                = 0x001000; //! Legt fest, ob eine Prozentangebe gezechnet wird
-            static const __int64 Aktionen
-                = 0x01000000; //! Legt fest, ob die Aktionsschritte gezeichnet
-                              //! werden
+            // Legt fest, ob eine Prozentangebe gezechnet wird
+            static const __int64 Prozent = 0x001000;
+            // Legt fest, ob die Aktionsschritte gezeichnet werden
+            static const __int64 Aktionen = 0x01000000;
+            // Legt fest, ob der vom fortschritt erfasste Teil des Balkens einen
+            // eigenen Rahmen hat
+            static const __int64 FRahmen = 0x002000;
+            // Legt fest, ob der vom fortschritt erfasste Teil des Balkens eine
+            // eigene Hintergrund Farbe hat
+            static const __int64 FFarbe = 0x004000;
+            // Legt fest, ob der vom fortschritt erfasste Teil des Balkens ein
+            // eigenes Hintergrund Bild hat
+            static const __int64 FBild = 0x008000;
+            // Legt fest, ob der vom fortschritt erfasste Teil des Balkens zum
+            // zeichnen seines Hintergrundes alpha blending verwendet
+            static const __int64 FAlpha = 0x10000;
+            // Legt fest, ob der vom fortschritt erfasste Teil des Balkens einen
+            // eigenen Frbübergang hat
+            static const __int64 FBuffered = 0x20000;
 
-            static const __int64 FRahmen
-                = 0x002000; //! Legt fest, ob der vom fortschritt erfasste Teil
-                            //! des Balkens einen eigenen Rahmen hat
-            static const __int64 FFarbe
-                = 0x004000; //! Legt fest, ob der vom fortschritt erfasste Teil
-                            //! des Balkens eine eigene Hintergrund Farbe hat
-            static const __int64 FBild
-                = 0x008000; //! Legt fest, ob der vom fortschritt erfasste Teil
-                            //! des Balkens ein eigenes Hintergrund Bild hat
-            static const __int64 FAlpha
-                = 0x10000; //! Legt fest, ob der vom fortschritt erfasste Teil
-                           //! des Balkens zum zeichnen seines Hintergrundes
-                           //! alpha blending verwendet
-            static const __int64 FBuffered
-                = 0x20000; //! Legt fest, ob der vom fortschritt erfasste Teil
-                           //! des Balkens einen eigenen Frbübergang hat
+            // Legt fest, ob sich der Fortschritt von lenks nach rechts
+            // ausbreitet
+            static const __int64 L_R = 0x0100000;
+            // Legt fest, ob sich der Fortschritt von rechts nach links
+            // ausbreitet
+            static const __int64 R_L = 0x0200000;
+            // Legt fest, ob sich der Fortschritt von unten nach oben ausbreitet
+            static const __int64 U_O = 0x0400000;
+            // Legt fest, ob sich der Fortschritt von oben nach unten ausbreitet
+            static const __int64 O_U = 0x0800000;
 
-            static const __int64 L_R
-                = 0x0100000; //! Legt fest, ob sich der Fortschritt von lenks
-                             //! nach rechts ausbreitet
-            static const __int64 R_L
-                = 0x0200000; //! Legt fest, ob sich der Fortschritt von rechts
-                             //! nach links ausbreitet
-            static const __int64 U_O
-                = 0x0400000; //! Legt fest, ob sich der Fortschritt von unten
-                             //! nach oben ausbreitet
-            static const __int64 O_U
-                = 0x0800000; //! Legt fest, ob sich der Fortschritt von oben
-                             //! nach unten ausbreitet
-
-            static const __int64 normal
-                = Sichtbar | Rahmen | Hintergrund | HBild | FRahmen | FBild
-                | L_R | Prozent
-                | Aktionen; //! Vereint die Flags Sichtbar, Rahmen, Hintergrund,
-                            //! HBild, FRahmen, FBild, L_R, Prozent
+            // Vereint die Flags Sichtbar, Rahmen, Hintergrund, HBild, FRahmen,
+            // FBild, L_R, Prozent
+            static const __int64 normal = Sichtbar | Rahmen | Hintergrund
+                                        | HBild | FRahmen | FBild | L_R
+                                        | Prozent | Aktionen;
         };
 
     private:

Knopf.h

@@ -23,27 +23,27 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 MehrfarbigText
-                = 0x0010000; //! Legt fest, ob der Text des Knopfes mehrere
-                             //! Farben haben darf
-            static const __int64 KlickFarbe
-                = 0x0020000; //! Legt fest, ob der Knopf während er gedrückt
-                             //! wird eine Hintergrund Farbe hat
-            static const __int64 KlickBild
-                = 0x0040000; //! Legt fest, ob der Knopf während er gedrückt
-                             //! wird ein Bild als Hintergrund hat
-            static const __int64 KlickAlpha
-                = 0x0080000; //! Legt fest, ob der Knopf während er gedrückt
-                             //! wird für das Zeichnen des Hintergrundes alpha
-                             //! blending verwendet
-            static const __int64 KlickBuffer
-                = 0x0100000; //! Legt fest, ob der Knopf während er gedrückt
-                             //! wird einen Farbübergang besitzt
+            //! Legt fest, ob der Text des Knopfes mehrere
+            //! Farben haben darf
+            static const __int64 MehrfarbigText = 0x0010000;
+            //! Legt fest, ob der Knopf während er gedrückt
+            //! wird eine Hintergrund Farbe hat
+            static const __int64 KlickFarbe = 0x0020000;
+            //! Legt fest, ob der Knopf während er gedrückt
+            //! wird ein Bild als Hintergrund hat
+            static const __int64 KlickBild = 0x0040000;
+            //! Legt fest, ob der Knopf während er gedrückt
+            //! wird für das Zeichnen des Hintergrundes alpha
+            //! blending verwendet
+            static const __int64 KlickAlpha = 0x0080000;
+            //! Legt fest, ob der Knopf während er gedrückt
+            //! wird einen Farbübergang besitzt
+            static const __int64 KlickBuffer = 0x0100000;
 
-            static const __int64 Normal
-                = Sichtbar | Erlaubt | Rahmen | Buffered | MehrfarbigText
-                | KlickBuffer; //! Vereint di Flags Sichtbar, Erlaubt, Rahmen,
-                               //! Buffered, MehrfarbigText, KlickBuffer
+            //! Vereint di Flags Sichtbar, Erlaubt, Rahmen,
+            //! Buffered, MehrfarbigText, KlickBuffer
+            static const __int64 Normal = Sichtbar | Erlaubt | Rahmen | Buffered
+                                        | MehrfarbigText | KlickBuffer;
         };
 
     private:
@@ -120,52 +120,50 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 Selected
-                = 0x1000000; //! Legt fest, ob das Kästchen ausgewählt ist
-
-            static const __int64 MehrfarbigText
-                = 0x001000; //! Legt Fest, ob der Beschriftungs Text mehrfarbig
-                            //! sein kann
-            static const __int64 KlickFarbe
-                = 0x002000; //! Legt fest, ob das Kästchen während ed gedrückt
-                            //! wird eine Hintergrund Farbe hat
-            static const __int64 KlickBild
-                = 0x004000; //! Legt fest, ob das Kästchen beim Klicken ein
-                            //! Hintergrund Bild hat
-            static const __int64 KlickAlpha
-                = 0x008000; //! Legt fest, ob für den Hintergrund des Kästchens
-                            //! beim Klicken alpha blending verwendet wird
-            static const __int64 KlickBuffer
-                = 0x010000; //! Legt fest, ob das Kästchen beim Klicken einen
-                            //! Farbübergang hat
-            static const __int64 SelectFarbe
-                = 0x020000; //! Legt fest, ob das Kästchen wärhend es ausgewählt
-                            //! ist eine Hintergrund Farbe hat
-            static const __int64 SelectBild
-                = 0x040000; //! Legt fest, ob das Kästchen wärhend es ausgewählt
-                            //! ist ein Hintergrund Bild hat
-            static const __int64 SelectAlpha
-                = 0x080000; //! Legt fest, ob das Kästchen wärhend es ausgewählt
-                            //! ist für den Hintergrund alpha blending verwendet
-            static const __int64 SelectBuffer
-                = 0x100000; //! Legt fest, ob das Kästchen wärhend es ausgewählt
-                            //! ist einen Farbübergang hat
-            static const __int64 SelectText
-                = 0x200000; //! Legt fest, ob das Kästchen wärhend es ausgewählt
-                            //! ist eine andere Beschriftung hat
-            static const __int64 MehrzeiligText
-                = 0x400000; //! Legt fest, ob das Kästchen eine Mehrzeilige
-                            //! Beschriftung haben kann
-
-            static const __int64 MausKlick
-                = 0x800000; //! Legt fest, ob gerade mit der Maus auf das
-                            //! Kästchen geklickt wird. (Wird vom Kästchen
-                            //! selbst verwaltet)
+            //! Legt fest, ob das Kästchen ausgewählt ist
+            static const __int64 Selected = 0x1000000;
+            //! Legt Fest, ob der Beschriftungs Text mehrfarbig
+            //! sein kann
+            static const __int64 MehrfarbigText = 0x001000;
+            //! Legt fest, ob das Kästchen während ed gedrückt
+            //! wird eine Hintergrund Farbe hat
+            static const __int64 KlickFarbe = 0x002000;
+            //! Legt fest, ob das Kästchen beim Klicken ein
+            //! Hintergrund Bild hat
+            static const __int64 KlickBild = 0x004000;
+            //! Legt fest, ob für den Hintergrund des Kästchens
+            //! beim Klicken alpha blending verwendet wird
+            static const __int64 KlickAlpha = 0x008000;
+            //! Legt fest, ob das Kästchen beim Klicken einen
+            //! Farbübergang hat
+            static const __int64 KlickBuffer = 0x010000;
+            //! Legt fest, ob das Kästchen wärhend es ausgewählt
+            //! ist eine Hintergrund Farbe hat
+            static const __int64 SelectFarbe = 0x020000;
+            //! Legt fest, ob das Kästchen wärhend es ausgewählt
+            //! ist ein Hintergrund Bild hat
+            static const __int64 SelectBild = 0x040000;
+            //! Legt fest, ob das Kästchen wärhend es ausgewählt
+            //! ist für den Hintergrund alpha blending verwendet
+            static const __int64 SelectAlpha = 0x080000;
+            //! Legt fest, ob das Kästchen wärhend es ausgewählt
+            //! ist einen Farbübergang hat
+            static const __int64 SelectBuffer = 0x100000;
+            //! Legt fest, ob das Kästchen wärhend es ausgewählt
+            //! ist eine andere Beschriftung hat
+            static const __int64 SelectText = 0x200000;
+            //! Legt fest, ob das Kästchen eine Mehrzeilige
+            //! Beschriftung haben kann
+            static const __int64 MehrzeiligText = 0x400000;
+            //! Legt fest, ob gerade mit der Maus auf das
+            //! Kästchen geklickt wird. (Wird vom Kästchen
+            //! selbst verwaltet)
+            static const __int64 MausKlick = 0x800000;
 
+            //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
+            //! KlickBuffer
             static const __int64 Normal
-                = Sichtbar | Erlaubt | Rahmen
-                | KlickBuffer; //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
-                               //! KlickBuffer
+                = Sichtbar | Erlaubt | Rahmen | KlickBuffer;
         };
 
     private:

Liste.h

@@ -25,55 +25,45 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 FeldRahmen
-                = 0x0001000; //! Legt fest, ob die Einträge der Liste einen
-                             //! Rahmen haben
-            static const __int64 FeldHintergrund
-                = 0x0002000; //! Legt fest, ob die Einträge einen Hintergrund
-                             //! haben
-            static const __int64 FeldHBild
-                = 0x0004000; //! Legt fest, ob die Einträge ein Hintergrund Bild
-                             //! haben
-            static const __int64 FeldHAlpha
-                = 0x0008000; //! Legt fest, ob beim zeichnen der Eintrag
-                             //! Hintergründe alpha blending verwendet werden
-                             //! soll
-            static const __int64 FeldBuffer
-                = 0x0010000; //! Legt fest, ob die Einträge einen Farbübergang
-                             //! besitzen
-            static const __int64 AuswahlHintergrund
-                = 0x0020000; //! Legt fest, ob die ausgewählten Einträge einen
-                             //! Hintergrund haben
-            static const __int64 AuswahlHBild
-                = 0x0040000; //! Legt fest, ob die ausgewählten einträge ein
-                             //! Bild als Hintergrund haben
-            static const __int64 AuswahlHAlpha
-                = 0x0080000; //! Legt fest, ob für das Zeichnen der Hintergründe
-                             //! der ausgewählten Einträge alpha blending
-                             //! verwendet wird
-            static const __int64 AuswahlBuffer
-                = 0x0100000; //! Legt fest, ob die ausgewählten Einträge einen
-                             //! Farbübergang besitzen
-            static const __int64 AuswahlRahmen
-                = 0x0200000; //! Legt fest, ob die ausgewählten Einträge einen
-                             //! Rahmen besitzen
-            static const __int64 MultiStyled
-                = 0x0400000; //! Legt fest, ob jeder Eintrag seine eigenen
-                             //! Hintergrund, Farbübergang und Rahmen hat, fals
-                             //! er ausgewählt ist
-            static const __int64 MultiSelect
-                = 0x0800000; //! Legt fest, das mehrere Einträge gleichzeitig
-                             //! ausgewählt sein können
-            static const __int64 Selected
-                = 0x1000000; //! Legt fest, ob ein bestimmter Eintrag ausgewählt
-                             //! ist, falls MultiSelect gesetzt wurde.
+            // Legt fest, ob die Einträge der Liste einen Rahmen haben
+            static const __int64 FeldRahmen = 0x0001000;
+            // Legt fest, ob die Einträge einen Hintergrund haben
+            static const __int64 FeldHintergrund = 0x0002000;
+            // Legt fest, ob die Einträge ein Hintergrund Bild haben
+            static const __int64 FeldHBild = 0x0004000;
+            // Legt fest, ob beim zeichnen der Eintrag Hintergründe alpha
+            // blending verwendet werden soll
+            static const __int64 FeldHAlpha = 0x0008000;
+            // Legt fest, ob die Einträge einen Farbübergang besitzen
+            static const __int64 FeldBuffer = 0x0010000;
+            // Legt fest, ob die ausgewählten Einträge einen Hintergrund haben
+            static const __int64 AuswahlHintergrund = 0x0020000;
+            // Legt fest, ob die ausgewählten einträge ein Bild als Hintergrund
+            // haben
+            static const __int64 AuswahlHBild = 0x0040000;
+            // Legt fest, ob für das Zeichnen der Hintergründe der ausgewählten
+            // Einträge alpha blending verwendet wird
+            static const __int64 AuswahlHAlpha = 0x0080000;
+            // Legt fest, ob die ausgewählten Einträge einen Farbübergang
+            // besitzen
+            static const __int64 AuswahlBuffer = 0x0100000;
+            // Legt fest, ob die ausgewählten Einträge einen Rahmen besitzen
+            static const __int64 AuswahlRahmen = 0x0200000;
+            // Legt fest, ob jeder Eintrag seine eigenen Hintergrund,
+            // Farbübergang und Rahmen hat, fals er ausgewählt ist
+            static const __int64 MultiStyled = 0x0400000;
+            // Legt fest, das mehrere Einträge gleichzeitig ausgewählt sein
+            // können
+            static const __int64 MultiSelect = 0x0800000;
+            // Legt fest, ob ein bestimmter Eintrag ausgewählt ist, falls
+            // MultiSelect gesetzt wurde.
+            static const __int64 Selected = 0x1000000;
 
+            // Vereint die Flags Sichtbar, Erlaubt, Rahmen, FeldHAlpha,
+            // FeldHintergrund, FeldRahmen, AuswahlBuffer, AuswahlRahmen
             static const __int64 Normal
                 = Sichtbar | Erlaubt | Rahmen | FeldHAlpha | FeldHintergrund
-                | FeldRahmen | AuswahlBuffer
-                | AuswahlRahmen; //! Vereint die Flags Sichtbar, Erlaubt,
-                                 //! Rahmen, FeldHAlpha, FeldHintergrund,
-                                 //! FeldRahmen, AuswahlBuffer, AuswahlRahmen
+                | FeldRahmen | AuswahlBuffer | AuswahlRahmen;
         };
 
     private:
@@ -344,12 +334,12 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 EntrySeperator
-                = 0x0001000; // draws a seperation line between the entries
+            // draws a seperation line between the entries
+            static const __int64 EntrySeperator = 0x0001000;
+            //! Vereint die Flags Sichtbar, Erlaubt,
+            //! Rahmen, Hintergrund
             static const __int64 Normal
-                = Sichtbar | Erlaubt | Rahmen | Hintergrund
-                | EntrySeperator; //! Vereint die Flags Sichtbar, Erlaubt,
-                                  //! Rahmen, Hintergrund
+                = Sichtbar | Erlaubt | Rahmen | Hintergrund | EntrySeperator;
         };
 
     private:

M2DVorschau.h

@@ -17,15 +17,15 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 UsrScale
-                = 0x001000; //! Wenn dieser Style gesetzt ist, kann der Benutzer
-                            //! das Model Skallieren, indem er scrollt
-            static const __int64 UsrMove
-                = 0x002000; //! Wenn dieser Style gesetzt ist, kann der Benutzer
-                            //! das Model per Drag and Drop verschieben
-            static const __int64 UsrRot
-                = 0x004000; //! Wenn dieser Style gesetzt idt, kann der Benutzer
-                            //! das Model mit der rechten Maustaste drehen
+            //! Wenn dieser Style gesetzt ist, kann der Benutzer
+            //! das Model Skallieren, indem er scrollt
+            static const __int64 UsrScale = 0x001000;
+            //! Wenn dieser Style gesetzt ist, kann der Benutzer
+            //! das Model per Drag and Drop verschieben
+            static const __int64 UsrMove = 0x002000;
+            //! Wenn dieser Style gesetzt idt, kann der Benutzer
+            //! das Model mit der rechten Maustaste drehen
+            static const __int64 UsrRot = 0x004000;
         };
 
     private:

Tabelle.h

@@ -20,78 +20,78 @@ namespace Framework
         class Style : public ZeichnungHintergrund::Style
         {
         public:
-            static const __int64 SpaltenBreiteChangeable
-                = 0x00001000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Benutzer die Spalten mit der Maus vergrößern
-                              //! und verkleinern
-            static const __int64 ZeilenHeightChangeable
-                = 0x00002000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Benutzer die Spalten mit der Maus vergrößern
-                              //! und verkleinern
-            static const __int64 SpaltenBreiteMin
-                = 0x00004000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer trotz des Flags SpaltenBreiteÄnderbar
-                              //! die Spaltenbreite nicht kleiner machen als
-                              //! eine bestimmte Grenze
-            static const __int64 SpaltenBreiteMax
-                = 0x00008000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer trotz des Flags SpaltenBreiteÄnderbar
-                              //! die Spaltenbreite nicht größer machen als eine
-                              //! bestimmte Grenze
-            static const __int64 ZeilenHeightMin
-                = 0x00010000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer trotz des Flags ZeilenHöheÄnderbar die
-                              //! Zeilenhöhe nicht kleiner machen als eine
-                              //! bestimmte Grenze
-            static const __int64 ZeilenHeightMax
-                = 0x00020000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer trotz des Flags ZeilenHöheÄnderbar die
-                              //! Zeilenhöhe nicht größer machen als eine
-                              //! bestimmte Grenze
-            static const __int64 SpaltenBeweglich
-                = 0x00040000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer die Reihenfolge der Spalten bestimmen,
-                              //! in dem er sie per Drag and Drop verschiebt
-            static const __int64 ZeilenBeweglich
-                = 0x00800000; //! Wenn dieser Flag gesetzt wird, so kann der
-                              //! Nutzer die Reihenfolge der Zeilen bestimmen,
-                              //! in dem er sie per Drag and Drop verschiebt
-            static const __int64 AuswahlRahmen
-                = 0x0080000; //! Wenn dieser Flag gesetzt ist, so bekommt das
-                             //! Feld, dass der Benutzer durch den Flag Erlaubt
-                             //! auswählen kann einen anderen Rahmen
-            static const __int64 AuswahlBuffer
-                = 0x00100000; //! Wenn dieser Flag gesetzt ist, so bekommt das
-                              //! Feld, dass der Benutzer durch den Flag Erlaubt
-                              //! auswählen kann ein anderes AlphaFeld
-            static const __int64 AuswahlMultistyled
-                = 0x00200000; //! Wenn dieser Flag gesetzt ist, so kann jedes
-                              //! Feld andere Rahmen und AlphaFelder beim
-                              //! Auswählen haben.
-            static const __int64 Raster
-                = 0x00400000; //! Wenn dieser Flag gesetzt ist, so werden
-                              //! zwischen den Feldern Linien gezeichnet
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Benutzer die Spalten mit der Maus vergrößern
+            //! und verkleinern
+            static const __int64 SpaltenBreiteChangeable = 0x00001000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Benutzer die Spalten mit der Maus vergrößern
+            //! und verkleinern
+            static const __int64 ZeilenHeightChangeable = 0x00002000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer trotz des Flags SpaltenBreiteÄnderbar
+            //! die Spaltenbreite nicht kleiner machen als
+            //! eine bestimmte Grenze
+            static const __int64 SpaltenBreiteMin = 0x00004000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer trotz des Flags SpaltenBreiteÄnderbar
+            //! die Spaltenbreite nicht größer machen als eine
+            //! bestimmte Grenze
+            static const __int64 SpaltenBreiteMax = 0x00008000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer trotz des Flags ZeilenHöheÄnderbar die
+            //! Zeilenhöhe nicht kleiner machen als eine
+            //! bestimmte Grenze
+            static const __int64 ZeilenHeightMin = 0x00010000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer trotz des Flags ZeilenHöheÄnderbar die
+            //! Zeilenhöhe nicht größer machen als eine
+            //! bestimmte Grenze
+            static const __int64 ZeilenHeightMax = 0x00020000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer die Reihenfolge der Spalten bestimmen,
+            //! in dem er sie per Drag and Drop verschiebt
+            static const __int64 SpaltenBeweglich = 0x00040000;
+            //! Wenn dieser Flag gesetzt wird, so kann der
+            //! Nutzer die Reihenfolge der Zeilen bestimmen,
+            //! in dem er sie per Drag and Drop verschiebt
+            static const __int64 ZeilenBeweglich = 0x00800000;
+            //! Wenn dieser Flag gesetzt ist, so bekommt das
+            //! Feld, dass der Benutzer durch den Flag Erlaubt
+            //! auswählen kann einen anderen Rahmen
+            static const __int64 AuswahlRahmen = 0x0080000;
+            //! Wenn dieser Flag gesetzt ist, so bekommt das
+            //! Feld, dass der Benutzer durch den Flag Erlaubt
+            //! auswählen kann ein anderes AlphaFeld
+            static const __int64 AuswahlBuffer = 0x00100000;
+            //! Wenn dieser Flag gesetzt ist, so kann jedes
+            //! Feld andere Rahmen und AlphaFelder beim
+            //! Auswählen haben.
+            static const __int64 AuswahlMultistyled = 0x00200000;
+            //! Wenn dieser Flag gesetzt ist, so werden
+            //! zwischen den Feldern Linien gezeichnet
+            static const __int64 Raster = 0x00400000;
 
-            static const __int64 beweglich
-                = SpaltenBreiteChangeable | ZeilenHeightChangeable
-                | SpaltenBeweglich
-                | ZeilenBeweglich; //! Vereint die Flags: SpaltenBreiteÄnderbar,
-                                   //! ZeilenHöheÄnderbar, SpaltenBeweglich,
-                                   //! ZeilenBeweglich
-            static const __int64 min_max
-                = SpaltenBreiteMax | SpaltenBreiteMin | ZeilenHeightMax
-                | ZeilenHeightMax; //! Vereint die Flags: SpaltenBreiteMax,
-                                   //! SpaltenBreiteMin, ZeilenHöheMax,
-                                   //! ZeilenHöheMax
-            static const __int64 scroll
-                = VScroll | HScroll; //! Vereint die Flags: VScroll, HScroll
+            //! Vereint die Flags: SpaltenBreiteÄnderbar,
+            //! ZeilenHöheÄnderbar, SpaltenBeweglich,
+            //! ZeilenBeweglich
+            static const __int64 beweglich = SpaltenBreiteChangeable
+                                           | ZeilenHeightChangeable
+                                           | SpaltenBeweglich | ZeilenBeweglich;
+            //! Vereint die Flags: SpaltenBreiteMax,
+            //! SpaltenBreiteMin, ZeilenHöheMax,
+            //! ZeilenHöheMax
+            static const __int64 min_max = SpaltenBreiteMax | SpaltenBreiteMin
+                                         | ZeilenHeightMax | ZeilenHeightMax;
+            //! Vereint die Flags: VScroll, HScroll
+            static const __int64 scroll = VScroll | HScroll;
+            //! Vereint die Flags: Rahmen, Erlaubt,
+            //! Sichtbar, SpaltenBeweglich,
+            //! AuswahlBuffer, AuswahlRahmen, Raster
             static const __int64 normal
                 = Rahmen | Erlaubt | Sichtbar | AuswahlBuffer | AuswahlRahmen
                 | Raster | MEIgnoreInside | MEIgnoreParentInside
-                | MEIgnoreSichtbar
-                | MEIgnoreVerarbeitet; //! Vereint die Flags: Rahmen, Erlaubt,
-                                       //! Sichtbar, SpaltenBeweglich,
-                                       //! AuswahlBuffer, AuswahlRahmen, Raster
+                | MEIgnoreSichtbar | MEIgnoreVerarbeitet;
         };
 
     private:

TextFeld.h

@@ -102,22 +102,22 @@ namespace Framework
             // wird dabei nicht verändert. Benötigt Style Mehrzeilig
             static const __int64 AutoLineBreak = 0x4000000;
 
-            static const __int64 Center
-                = HCenter | VCenter; //! Vereint die Flags HCenter und VCenter
+            //! Vereint die Flags HCenter und VCenter
+            static const __int64 Center = HCenter | VCenter;
+            //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
+            //! Buffered, VCenter
             static const __int64 TextFeld
-                = Sichtbar | Erlaubt | Rahmen | Buffered | VCenter
-                | Editierbar; //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
-                              //! Buffered, VCenter
-            static const __int64 Text = Sichtbar | Mehrzeilig
-                                      | Erlaubt; //! Vereint die Flags Sichtbar,
-                                                 //! Mehrfarbig, Mehrzeilig
-            static const __int64 TextGebiet
-                = Sichtbar | Erlaubt | Rahmen | Hintergrund | Editierbar
-                | Mehrzeilig
-                | VScroll; //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
-                           //! Hintergrund, Mehrzeilig, Mehrfarbig, VScroll
-            static const __int64 Scroll
-                = VScroll | HScroll; //! Vereint die Flags VScroll und HScroll
+                = Sichtbar | Erlaubt | Rahmen | Buffered | VCenter | Editierbar;
+            //! Vereint die Flags Sichtbar,
+            //! Mehrfarbig, Mehrzeilig
+            static const __int64 Text = Sichtbar | Mehrzeilig | Erlaubt;
+            //! Vereint die Flags Sichtbar, Erlaubt, Rahmen,
+            //! Hintergrund, Mehrzeilig, Mehrfarbig, VScroll
+            static const __int64 TextGebiet = Sichtbar | Erlaubt | Rahmen
+                                            | Hintergrund | Editierbar
+                                            | Mehrzeilig | VScroll;
+            //! Vereint die Flags VScroll und HScroll
+            static const __int64 Scroll = VScroll | HScroll;
         };
 
     private:

Zeichnung.cpp

@@ -829,12 +829,26 @@ void ZeichnungHintergrund::render(Bild& rObj)
                 0, 0, gr.x - rbr * 2, gr.y - rbr * 2, hintergrundFarbe);
         if (hatStyle(Style::HBild) && hintergrundBild)
         {
-            if (hatStyle(Style::HAlpha))
-                rObj.alphaBildSkall(
-                    0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+            if (hatStyle(Style::HBildScale))
+            {
+                if (hatStyle(Style::HAlpha))
+                    rObj.alphaBildSkall(
+                        0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+                else
+                    rObj.drawBildSkall(
+                        0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+            }
             else
-                rObj.drawBildSkall(
-                    0, 0, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+            {
+                int x = (gr.x - rbr * 2 - hintergrundBild->getSize().x) / 2;
+                int y = (gr.y - rbr * 2 - hintergrundBild->getSize().y) / 2;
+                if (hatStyle(Style::HAlpha))
+                    rObj.alphaBild(
+                        x, y, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+                else
+                    rObj.drawBild(
+                        x, y, gr.x - rbr * 2, gr.y - rbr * 2, *hintergrundBild);
+            }
         }
     }
     if (hatStyle(Style::Buffered) && hintergrundFeld)

Zeichnung.h

@@ -276,28 +276,28 @@ namespace Framework
         class Style : public Zeichnung::Style
         {
         public:
-            static const __int64 Rahmen
-                = 0x00010; //! Wenn dieser Flag gesetzt wird, bekommt die
-                           //! Zeichnugn einen Rahmen
-            static const __int64 Hintergrund
-                = 0x00020; //! Wenn dieser Flag gesetzt wird, bekommt die
-                           //! Zeichnung einen Hintergrund
-            static const __int64 HAlpha
-                = 0x00040; //! Wenn dieser Flag gesetzt wird, wird der
-                           //! Hintergrund durchsichtig. Benötigt Flag
-                           //! Hintergrund
-            static const __int64 HBild
-                = 0x00080; //! Wenn dieser Flag gesetzt wird, wird ein Bild als
-                           //! hintergrund verwendet. Benötigt Flag Hintergrund
-            static const __int64 Buffered
-                = 0x00100; //! Wenn dieser Flag gesetzt wird, Erscheint ein
-                           //! Farbübergang als Rahmen
-            static const __int64 VScroll
-                = 0x00200; //! Wenn dieser Flag gesetzt wird, erscheint eine
-                           //! Scrollbar am rechten Rand
-            static const __int64 HScroll
-                = 0x00400; //! Wenn dieser Flag gesetzt wird, erscheint eine
-                           //! Scrollbar am unteren Rand
+            // Wenn dieser Flag gesetzt wird, bekommt die Zeichnugn einen Rahmen
+            static const __int64 Rahmen = 0x00010;
+            // Wenn dieser Flag gesetzt wird, bekommt die Zeichnung einen
+            // Hintergrund
+            static const __int64 Hintergrund = 0x00020;
+            // Wenn dieser Flag gesetzt wird, wird der Hintergrund durchsichtig.
+            // Benötigt Flag Hintergrund
+            static const __int64 HAlpha = 0x00040;
+            // Wenn dieser Flag gesetzt wird, wird ein Bild als hintergrund
+            // verwendet. Benötigt Flag Hintergrund
+            static const __int64 HBild = 0x00080;
+            // Wenn dieser Flag gesetzt wird, Erscheint ein Farbübergang als
+            // Rahmen
+            static const __int64 Buffered = 0x00100;
+            // Wenn dieser Flag gesetzt wird, erscheint eine Scrollbar am
+            // rechten Rand
+            static const __int64 VScroll = 0x00200;
+            // Wenn dieser Flag gesetzt wird, erscheint eine Scrollbar am
+            // unteren Rand
+            static const __int64 HScroll = 0x00400;
+            // Wenn dieser Flag gesetzt wird, wird das Bild skaliert
+            static const __int64 HBildScale = 0x00800;
         };
 
     protected: