Browse Source

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

Kolja Strohm 1 year ago
parent
commit
dea4638394
14 changed files with 611 additions and 579 deletions
  1. 56 68
      AuswahlBox.h
  2. 242 199
      Bild.cpp
  3. 13 11
      Bild.h
  4. 26 27
      Diagramm.h
  5. 2 1
      Fenster.cpp
  6. 2 0
      Fenster.h
  7. 34 39
      Fortschritt.h
  8. 62 64
      Knopf.h
  9. 41 51
      Liste.h
  10. 9 9
      M2DVorschau.h
  11. 68 68
      Tabelle.h
  12. 15 15
      TextFeld.h
  13. 19 5
      Zeichnung.cpp
  14. 22 22
      Zeichnung.h

+ 56 - 68
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:

+ 242 - 199
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);
                 }
             }
         }

+ 13 - 11
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:

+ 26 - 27
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:

+ 2 - 1
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();
         }

+ 2 - 0
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ö,

+ 34 - 39
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:

+ 62 - 64
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:

+ 41 - 51
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:

+ 9 - 9
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:

+ 68 - 68
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:

+ 15 - 15
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:

+ 19 - 5
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)

+ 22 - 22
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: