Ticket #8699: blur.patch

gui/themes/modern.ini

@@ -162 +162 @@
 shadow_right_width=4
 shadow_top_height=2
 shadow_bottom_height=4
-inactive_dialog_shading=kShadingDim
+inactive_dialog_shading=kShadingBlur
 shading_dim_percent=50
+shading_blur_rad=5
 fontfile_normal="helvr12-l1.bdf"
 fontfile_fixed_normal="courr12-l1.bdf"
 cursor_hotspot_x=0

gui/ThemeModern.cpp

@@ -195 +195 @@
                 _dialog->screen.create(_screen.w, _screen.h, sizeof(OverlayColor));
         }
         
-        if (_dialogShadingCallback && topDialog) {
-                OverlayColor *col = (OverlayColor*)_screen.pixels;
-                for (int y = 0; y < _screen.h; ++y) {
-                        for (int x = 0; x < _screen.w; ++x) {
-                                col[x] = (this->*(_dialogShadingCallback))(col[x]);
-                        }
-                        col += _screen.w;
-                }
-        }
+        if (_dialogShadingCallback && topDialog)
+                (this->*(_dialogShadingCallback))();
         
         memcpy(_dialog->screen.pixels, _screen.pixels, _screen.pitch*_screen.h);
         
@@ -1096 +1089 @@
 
 #define NO_EFFECT(x) ((x) & rowColor)
 #define ALPHA_EFFECT(x) (getColorAlpha((x) & rowColor, *dst, alpha))
-#define DARKEN_EFFECT(x) (calcDimColor((x) & rowColor))
+#define DARKEN_EFFECT(x) (calcDimPixel((x) & rowColor))
 
 #define LEFT_RIGHT_OFFSET(x) (drawWidth-x-1)
 #define NORMAL_OFFSET(x) (x)
@@ -1443 +1436 @@
                 }
                 break;
 
+        case kShadingBlur:
+                _blurRadValue = _evaluator->getVar("shading_blur_rad", -1);
+
+                if (_blurRadValue < 0) {
+                        _blurRadValue = 0;
+                } else if (_blurRadValue > 100) {
+                        _blurRadValue = 100;
+                }
+                if (_blurRadValue != 0) {
+                        _dialogShadingCallback = &ThemeModern::calcBlurColor;
+                }
+                break;
+
         default:
                         warning("no valid 'inactive_dialog_shading' specified");
         }
@@ -1460 +1466 @@
 
 #pragma mark -
 
-OverlayColor ThemeModern::calcLuminance(OverlayColor col) {
+void ThemeModern::calcLuminance() {
+        OverlayColor *col = (OverlayColor*)_screen.pixels;
         uint8 r, g, b;
-        _system->colorToRGB(col, r, g, b);
 
-        // A better (but slower) formula to calculate the luminance would be:
-        //uint lum = (byte)((0.299 * r + 0.587 * g + 0.114 * b) + 0.5);
-        // Note that the approximation below will only produce values between
-        // (and including) 0 and 221.
-        uint lum = (r >> 2) + (g >> 1) + (b >> 3);
-        
-        return _system->RGBToColor(lum, lum, lum);
+        for (int y = 0; y < _screen.h; ++y) {
+                for (int x = 0; x < _screen.w; ++x) {
+                        _system->colorToRGB(col[x], r, g, b);
+
+                        // A better (but slower) formula to calculate the luminance would be:
+                        //uint lum = (byte)((0.299 * r + 0.587 * g + 0.114 * b) + 0.5);
+                        // Note that the approximation below will only produce values between
+                        // (and including) 0 and 221.
+                        uint lum = (r >> 2) + (g >> 1) + (b >> 3);
+
+                        col[x] = _system->RGBToColor(lum, lum, lum);
+                }
+                col += _screen.w;
+        }
 }
 
-OverlayColor ThemeModern::calcDimColor(OverlayColor col) {
+void ThemeModern::calcDimColor() {
+        OverlayColor *col = (OverlayColor*)_screen.pixels;
+        for (int y = 0; y < _screen.h; ++y) {
+                for (int x = 0; x < _screen.w; ++x) {
+                        col[x] = calcDimPixel(col[x]);
+                }
+                col += _screen.w;
+        }
+}
+
+OverlayColor ThemeModern::calcDimPixel(OverlayColor col) {
         uint8 r, g, b;
         _system->colorToRGB(col, r, g, b);
         
@@ -1484 +1507 @@
         return _system->RGBToColor(r, g, b);
 }
 
+void ThemeModern::calcBlurColor() {
+        int rad = _blurRadValue;
+
+        OverlayColor *col = (OverlayColor*)_screen.pixels;
+        int32 acum_r, acum_g, acum_b;
+        int count = 0;
+
+        // Convert the whole overlay to RGB (is there a more efficient way?)
+#define pixel(x,y) (rgb + (((x) + (y) * _screen.w) * 4))
+        uint8 *rgb = new uint8[_screen.w * _screen.h * 4];
+        for (int y = 0; y < _screen.h; y++) {
+                for (int x = 0; x < _screen.w; x++) {
+                        uint8 r, g, b;
+                        _system->colorToRGB(col[x + y * _screen.w], r, g, b);
+
+                        pixel(x,y)[0] = r;
+                        pixel(x,y)[1] = g;
+                        pixel(x,y)[2] = b;
+                }
+        }
+
+
+        // Horizontal blur in place (using original_row for substractions)
+        uint8 *original_row = new uint8[_screen.w * 4];
+        for (int y = 0; y < _screen.h; y++) {
+                acum_r = acum_g = acum_b = 0;
+                count = 0;
+
+                memcpy(original_row, rgb + y * _screen.w * 4, _screen.w * 4);
+
+                // Blur one line
+                for (int x = -rad; x < _screen.w; x++) {
+                        if (x + rad < _screen.w) {
+                                count++;
+                                acum_r += pixel(x + rad, y)[0];
+                                acum_g += pixel(x + rad, y)[1];
+                                acum_b += pixel(x + rad, y)[2];
+                        }
+                        if (x >= 0 && x < _screen.pitch) {
+                                pixel(x,y)[0] = acum_r / count;
+                                pixel(x,y)[1] = acum_g / count;
+                                pixel(x,y)[2] = acum_b / count;
+                        }
+                        if (x - rad >= 0) {
+                                count--;
+                                // We take it from the original row (current row is half blurred)
+                                acum_r -= original_row[(x - rad) * 4 + 0];
+                                acum_g -= original_row[(x - rad) * 4 + 1];
+                                acum_b -= original_row[(x - rad) * 4 + 2];
+                        }
+                }
+        }
+        delete [] original_row;
+
+        // Vertical blur with result to the overlay
+        for (int x = 0; x < _screen.w; x++) {
+                acum_r = acum_g = acum_b = 0;
+                count = 0;
+
+                // Blur one column
+                for (int y = -rad; y <= _screen.h + rad; y++) {
+                        if (y + rad < _screen.h) {
+                                count++;
+                                acum_r += pixel(x, y + rad)[0];
+                                acum_g += pixel(x, y + rad)[1];
+                                acum_b += pixel(x, y + rad)[2];
+                        }
+                        if (y >= 0 && y < _screen.h) {
+                                col[x + y * _screen.w] = _system->RGBToColor(acum_r / count, acum_g / count, acum_b / count);
+                        }
+                        if (y - rad >= 0) {
+                                count--;
+                                acum_r -= pixel(x, y - rad)[0];
+                                acum_g -= pixel(x, y - rad)[1];
+                                acum_b -= pixel(x, y - rad)[2];
+                        }
+                }
+        }
+
+        delete [] rgb;
+
+#undef pixel
+}
+
 #pragma mark -
 
 void ThemeModern::setUpCursor() {

gui/theme.h

@@ -120 +120 @@
         enum ShadingStyle {
                 kShadingNone,
                 kShadingDim,
-                kShadingLuminance
+                kShadingLuminance,
+                kShadingBlur
         };
 
         virtual bool init() = 0;

gui/eval.cpp

@@ -282 +282 @@
         {"kShadingNone", Theme::kShadingNone},
         {"kShadingDim", Theme::kShadingDim},
         {"kShadingLuminance", Theme::kShadingLuminance},
+        {"kShadingBlur", Theme::kShadingBlur},
 
         {"false", 0},
         {"true", 1},

gui/ThemeModern.h

@@ -211 +211 @@
 
 private:
         int _dimPercentValue;
-        typedef OverlayColor (ThemeModern::*InactiveDialogCallback)(OverlayColor col);  
+        int _blurRadValue;
+        typedef void (ThemeModern::*InactiveDialogCallback)();
         InactiveDialogCallback _dialogShadingCallback;
         
-        OverlayColor calcLuminance(OverlayColor col);
-        OverlayColor calcDimColor(OverlayColor col);
+        void calcLuminance();
+        void calcDimColor();
+        void calcBlurColor();
 
+        OverlayColor calcDimPixel(OverlayColor col);
+
         bool _useCursor;
         void setUpCursor();
         void createCursor();