Adjustable blurring level #369

Source/Core/Images/Utils.cpp

@@ -173,7 +173,7 @@ std::unique_ptr<Gdiplus::Bitmap> IconToBitmap(HICON ico)
     return image;
 }
 
-void ApplyGaussianBlur(Gdiplus::Bitmap* bm, int x,int y, int w, int h, int radius, Gdiplus::Rect exclude) {
+void ApplyGaussianBlur(Gdiplus::Bitmap* bm, int x,int y, int w, int h, float radius, Gdiplus::Rect exclude) {
     using namespace Gdiplus;
     Rect rc(x, y, w, h);
 

Source/Core/Images/Utils.h

@@ -35,7 +35,7 @@ std::unique_ptr<Gdiplus::Bitmap> BitmapFromResource(HINSTANCE hInstance, LPCTSTR
 void PrintRichEdit(HWND hwnd, Gdiplus::Graphics* graphics, Gdiplus::Bitmap* background, Gdiplus::Rect layoutArea);
 void DrawRoundedRectangle(Gdiplus::Graphics* gr, Gdiplus::Rect r, int d, Gdiplus::Pen* p, Gdiplus::Brush* br);
 std::unique_ptr<Gdiplus::Bitmap> IconToBitmap(HICON ico);
-void ApplyGaussianBlur(Gdiplus::Bitmap* bm, int x, int y, int w, int h, int radius, Gdiplus::Rect exclude = {});
+void ApplyGaussianBlur(Gdiplus::Bitmap* bm, int x, int y, int w, int h, float radius, Gdiplus::Rect exclude = {});
 void ApplyPixelateEffect(Gdiplus::Bitmap* bm, int xPos, int yPos, int w, int h, int blockSize, Gdiplus::Rect exclude = {});
 std::unique_ptr<Gdiplus::Bitmap> LoadImageFromFileWithoutLocking(const WCHAR* fileName, bool* isAnimated);
 Gdiplus::Color StringToColor(const std::string& str);

Source/Core/Settings/WtlGuiSettings.cpp

@@ -525,6 +525,7 @@ WtlGuiSettings::WtlGuiSettings() :
     ImageEditorSettings.StepForegroundColor = Gdiplus::Color(255, 255, 255);
     ImageEditorSettings.PenSize = 12;
     ImageEditorSettings.RoundingRadius = ImageEditorSettings.PenSize;
+    ImageEditorSettings.BlurRadius = 4.0f;
     ImageEditorSettings.AllowAltTab = true;
     ImageEditorSettings.AllowEditingInFullscreen = false;
     ImageEditorSettings.SearchEngine = SearchByImage::SearchEngine::seYandex;
@@ -817,6 +818,7 @@ void WtlGuiSettings::BindToManager() {
     imageEditor.nm_bind(ImageEditorSettings, StepBackgroundColor);
     imageEditor.nm_bind(ImageEditorSettings, PenSize);
     imageEditor.nm_bind(ImageEditorSettings, RoundingRadius);
+    imageEditor.nm_bind(ImageEditorSettings, BlurRadius);
     imageEditor.nm_bind(ImageEditorSettings, ArrowType);
     imageEditor.nm_bind(ImageEditorSettings, Font);
     imageEditor.nm_bind(ImageEditorSettings, FillTextBackground);

Source/Core/Settings/WtlGuiSettings.h

@@ -28,6 +28,7 @@ struct ImageEditorSettingsStruct {
     Gdiplus::Color ForegroundColor, BackgroundColor, StepForegroundColor, StepBackgroundColor;
     int PenSize;
     int RoundingRadius;
+    float BlurRadius;
     LOGFONT Font;
     bool AllowAltTab;
     bool AllowEditingInFullscreen;

Source/Func/ImageEditorConfigurationProvider.cpp

@@ -12,6 +12,7 @@ ImageEditorConfigurationProvider::ImageEditorConfigurationProvider()
     stepBackgroundColor_ = settings->ImageEditorSettings.StepBackgroundColor;
     font_ =  settings->ImageEditorSettings.Font;
     roundingRadius_ = settings->ImageEditorSettings.RoundingRadius;
+    blurRadius_ = settings->ImageEditorSettings.BlurRadius;
     allowAltTab_ = settings->ImageEditorSettings.AllowAltTab;
     searchEngine_ = settings->ImageEditorSettings.SearchEngine;
     fillTextBackground_ = settings->ImageEditorSettings.FillTextBackground;
@@ -27,6 +28,7 @@ void ImageEditorConfigurationProvider::saveConfiguration()
     settings->ImageEditorSettings.BackgroundColor = backgroundColor_;
     settings->ImageEditorSettings.Font = font_;
     settings->ImageEditorSettings.RoundingRadius = roundingRadius_;
+    settings->ImageEditorSettings.BlurRadius = blurRadius_;
     settings->ImageEditorSettings.AllowAltTab = allowAltTab_;
     settings->ImageEditorSettings.SearchEngine = searchEngine_;
     settings->ImageEditorSettings.FillTextBackground = fillTextBackground_;

Source/Gui/Dialogs/WizardDlg.cpp

@@ -64,7 +64,7 @@
 #include "Core/ScreenCapture/MonitorEnumerator.h"
 #include "Core/Network/NetworkClientFactory.h"
 #include "Gui/Components/NewStyleFolderDialog.h"
-#include "statusdlg.h"
+#include "StatusDlg.h"
 #include "3rdpart/wintoastlib.h"
 #include "Gui/Components/WinToastHandler.h"
 #include "ServerListTool/ServersCheckerDlg.h"

Source/ImageEditor/Canvas.cpp

@@ -59,11 +59,11 @@ Canvas::Canvas( HWND parent ) {
     originalPenSize_ = 0;
     roundingRadius_ = 12;
     originalRoundingRadius_ = 0;
+    originalBlurRadius_ = 0;
     selection_ = nullptr;
     canvasChanged_ = true;
     fullRender_ = true;
-    blurRadius_ = 5;
-    pixelateBlockSize_ = 12;
+    blurRadius_ = 1.0f;
     blurRectanglesCount_ = 0;
     currentDrawingTool_ = nullptr;
     isDocumentModified_ = false;
@@ -400,7 +400,7 @@ void Canvas::endRoundingRadiusChanging(int radius) {
     if ( updatedElementsCount ) {
         addUndoHistoryItem(uhi);
     }
-    originalPenSize_= 0;
+    originalRoundingRadius_ = 0;
 }
 
 void Canvas::setForegroundColor(Gdiplus::Color color)
@@ -748,15 +748,48 @@ void Canvas::setBlurRadius(float radius)
     blurRadius_ = radius;
 }
 
+void Canvas::beginBlurRadiusChanging() {
+    if (!originalBlurRadius_) {
+        originalBlurRadius_ = blurRadius_;
+    }
+}
+
+void Canvas::endBlurRadiusChanging(float radius) {
+    blurRadius_ = radius;
+    if (fabs(originalBlurRadius_) < 0.0001 || fabs(originalBlurRadius_ - blurRadius_) < 0.0001) {
+        return;
+    }
+    int updatedElementsCount = 0;
+    UndoHistoryItem uhi;
+    uhi.type = UndoHistoryItemType::uitBlurRadiusChanged;
+    for (size_t i = 0; i < elementsOnCanvas_.size(); i++) {
+        if (elementsOnCanvas_[i]->isSelected() && (elementsOnCanvas_[i]->getType() == ElementType::etBlurringRectangle || elementsOnCanvas_[i]->getType() == ElementType::etPixelateRectangle)) {
+            auto el = dynamic_cast<BlurringRectangle*>(elementsOnCanvas_[i]);
+            if (el) {
+                UndoHistoryItemElement uhie;
+                uhie.floatVal = originalBlurRadius_;
+                RECT paintRect = elementsOnCanvas_[i]->getPaintBoundingRect();
+                uhie.movableElement = elementsOnCanvas_[i];
+                el->setBlurRadius(radius);
+                RECT newPaintRect = elementsOnCanvas_[i]->getPaintBoundingRect();
+                uhi.elements.push_back(uhie);
+                UnionRect(&paintRect, &paintRect, &newPaintRect);
+                updatedElementsCount++;
+                updateView(paintRect);
+            }
+        }
+    }
+    if (updatedElementsCount) {
+        addUndoHistoryItem(uhi);
+    }
+    originalBlurRadius_ = 0;
+}
+
 bool Canvas::hasBlurRectangles() const
 {
     return blurRectanglesCount_!=0;
 }
 
-int Canvas::getPixelateBlockSize() const {
-    return pixelateBlockSize_;
-}
-
 void Canvas::showOverlay(bool show)
 {
     if ( !overlay_ ) {
@@ -1130,6 +1163,14 @@ bool Canvas::undo() {
             }
         }
         result = true;
+    } else if (item.type == UndoHistoryItemType::uitBlurRadiusChanged) {
+        int itemCount = item.elements.size();
+        for (int i = itemCount - 1; i >= 0; i--) {
+            if (item.elements[i].movableElement->getType() == ElementType::etBlurringRectangle || item.elements[i].movableElement->getType() == ElementType::etPixelateRectangle) {
+                dynamic_cast<BlurringRectangle*>(item.elements[i].movableElement)->setBlurRadius(item.elements[i].floatVal);
+            }
+        }
+        result = true;
     } else if ( item.type == UndoHistoryItemType::uitElementPositionChanged ) {
         int itemCount = item.elements.size();
         // Insert elements in their initial positions

Source/ImageEditor/Canvas.h

@@ -41,17 +41,20 @@ class Canvas {
         enum class UndoHistoryItemType { uitDocumentChanged, uitElementAdded, uitElementRemoved, 
             uitElementPositionChanged, uitElementForegroundColorChanged, uitElementBackgroundColorChanged,
             uitPenSizeChanged, uitFontChanged, uitTextChanged, uitRoundingRadiusChanged, uitFillBackgroundChanged,
-            uitCropApplied, uitInvertSelectionChanged
+            uitCropApplied, uitInvertSelectionChanged, uitBlurRadiusChanged
         };
-        enum { kMaxPenSize = 50, kMaxRoundingRadius = 50, kDefaultStepFontSize = 14 };
+        enum { kMaxPenSize = 50, kMaxRoundingRadius = 50, kMaxBlurRadius = 10, kDefaultStepFontSize = 14 };
 
         struct UndoHistoryItemElement {
             MovableElement* movableElement;
             int pos;
             POINT startPoint{};
             POINT endPoint{};
             Gdiplus::Color color;
-            int penSize; // pen size or rounding radius or fill background
+            union {
+                int penSize; // pen size or rounding radius or fill background
+                float floatVal;
+            };
             std::string rawText;
 
             UndoHistoryItemElement() {
@@ -142,8 +145,9 @@ class Canvas {
         int deleteSelectedElements();
         float getBlurRadius() const;
         void setBlurRadius(float radius);
+        void beginBlurRadiusChanging();
+        void endBlurRadiusChanging(float radius);
         bool hasBlurRectangles() const;
-        int getPixelateBlockSize() const;
         void showOverlay(bool show);
         void selectionChanged();
         Gdiplus::Rect currentRenderingRect() const;
@@ -212,7 +216,6 @@ class Canvas {
         Document* doc_;
         std::unique_ptr<Gdiplus::Graphics> bufferedGr_;
         float blurRadius_;
-        int pixelateBlockSize_;
         int canvasWidth_, canvasHeight_;
         POINT oldPoint_;
         POINT leftMouseDownPoint_;
@@ -239,6 +242,7 @@ class Canvas {
         int originalPenSize_;
         int roundingRadius_;
         int originalRoundingRadius_;
+        float originalBlurRadius_;
         bool canvasChanged_;
         bool fullRender_;
         int blurRectanglesCount_;

Source/ImageEditor/DrawingTools/MoveAndResizeTool.cpp

@@ -349,7 +349,7 @@ void MoveAndResizeTool::createElement() {
             currentElement_ = new FilledEllipse(canvas_);
             break;
         case ElementType::etPixelateRectangle:
-            currentElement_ = new PixelateRectangle(canvas_, float(canvas_->getPixelateBlockSize()), startPoint_.x, startPoint_.y, endPoint_.x, endPoint_.y, canvas_->getInvertSelection());
+            currentElement_ = new PixelateRectangle(canvas_, /*float(canvas_->getPixelateBlockSize())*/canvas_->getBlurRadius(), startPoint_.x, startPoint_.y, endPoint_.x, endPoint_.y, canvas_->getInvertSelection());
             break;
         case ElementType::etBlurringRectangle:
             currentElement_ = new BlurringRectangle(canvas_, canvas_->getBlurRadius(), startPoint_.x,startPoint_.y, endPoint_.x, endPoint_.y, false, canvas_->getInvertSelection());

Source/ImageEditor/Gui/ImageEditorWindow.cpp

@@ -52,6 +52,7 @@ void ImageEditorWindow::init()
     showAddToWizardButton_ = true;
     prevPenSize_ = 0;
     prevRoundingRadius_ = 0;
+    prevBlurRadius_ = 0;
     imageQuality_ = 85;
     searchEngine_ = SearchByImage::SearchEngine::seGoogle;
     currentDrawingTool_ = DrawingToolType::dtNone;
@@ -467,6 +468,7 @@ ImageEditorWindow::DialogResult ImageEditorWindow::DoModal(HWND parent, HMONITOR
         canvas_->setBackgroundColor(configurationProvider_->backgroundColor());
         canvas_->setFont(configurationProvider_->font());
         canvas_->setRoundingRadius(configurationProvider_->roundingRadius());
+        canvas_->setBlurRadius(configurationProvider_->blurRadius());
         canvas_->setFillTextBackground(configurationProvider_->fillTextBackground());
         canvas_->setInvertSelection(configurationProvider_->invertSelection());
         canvas_->setStepColors(configurationProvider_->stepForegroundColor(), configurationProvider_->stepBackgroundColor());
@@ -930,6 +932,7 @@ void ImageEditorWindow::createToolbars()
     }
     horizontalToolbar_.penSizeSlider_.SetPos(canvas_->getPenSize());
     horizontalToolbar_.roundRadiusSlider_.SetPos(canvas_->getRoundingRadius());
+    horizontalToolbar_.blurRadiusSlider_.SetPos(round(canvas_->getBlurRadius()*BLUR_RADIUS_PRECISION));
     horizontalToolbar_.setStepFontSize(canvas_->getStepFontSize());
     horizontalToolbar_.setStepInitialValue(1);
     horizontalToolbar_.setArrowType(static_cast<int>(canvas_->getArrowMode()));
@@ -1104,10 +1107,16 @@ void ImageEditorWindow::updateRoundingRadiusSlider()
     horizontalToolbar_.roundRadiusLabel_.ShowWindow( showRoundingRadiusSlider ? SW_SHOW: SW_HIDE );
     horizontalToolbar_.roundRadiusSlider_.ShowWindow( showRoundingRadiusSlider ? SW_SHOW: SW_HIDE );
 
+    bool showBlurRadiusSlider = currentDrawingTool_ == DrawingToolType::dtBlurringRectangle
+        || currentDrawingTool_ == DrawingToolType::dtPixelateRectangle;
+
+    horizontalToolbar_.blurRadiusSlider_.ShowWindow(showBlurRadiusSlider ? SW_SHOW : SW_HIDE);
+    horizontalToolbar_.blurRadiusLabel_.ShowWindow(showBlurRadiusSlider ? SW_SHOW : SW_HIDE);
+    horizontalToolbar_.showInvertSelectionCheckbox(showBlurRadiusSlider);
+
     bool showFillBackgound = currentDrawingTool_ == DrawingToolType::dtText;
     horizontalToolbar_.showFillBackgroundCheckbox(showFillBackgound);
-    horizontalToolbar_.showInvertSelectionCheckbox(currentDrawingTool_ == DrawingToolType::dtBlurringRectangle
-        || currentDrawingTool_ == DrawingToolType::dtPixelateRectangle);
+
 
     horizontalToolbar_.showArrowTypeCombo(currentDrawingTool_ == DrawingToolType::dtArrow);
 
@@ -1331,6 +1340,8 @@ void ImageEditorWindow::updatePixelLabels()
 {
     horizontalToolbar_.pixelLabel_.SetWindowText(WinUtils::IntToStr(canvas_->getPenSize()) + L" px");
     horizontalToolbar_.roundRadiusLabel_.SetWindowText(WinUtils::IntToStr(canvas_->getRoundingRadius()) + L" px");
+    std::string s = str(boost::format("%0.2f") % canvas_->getBlurRadius());
+    horizontalToolbar_.blurRadiusLabel_.SetWindowText(IuCoreUtils::Utf8ToWstring(s).c_str());
 }
 
 bool ImageEditorWindow::OnSaveAs()
@@ -1373,6 +1384,7 @@ void ImageEditorWindow::saveSettings()
         configurationProvider_->setBackgroundColor(canvas_->getBackgroundColor());
         configurationProvider_->setFont(canvas_->getFont());
         configurationProvider_->setRoundingRadius(canvas_->getRoundingRadius());
+        configurationProvider_->setBlurRadius(canvas_->getBlurRadius());
         configurationProvider_->setSearchEngine(searchEngine_);
         configurationProvider_->setFillTextBackground(canvas_->getFillTextBackground());
         configurationProvider_->setInvertSelection(canvas_->getInvertSelection());
@@ -1492,6 +1504,33 @@ LRESULT ImageEditorWindow::OnHScroll(UINT uMsg, WPARAM wParam, LPARAM lParam, BO
             break;
         }
     }
+    else if (hwndSender == horizontalToolbar_.blurRadiusSlider_.m_hWnd) {
+        float blurRadius = HIWORD(wParam)/ BLUR_RADIUS_PRECISION;
+        switch (LOWORD(wParam)) {
+        case TB_ENDTRACK:
+            blurRadius = horizontalToolbar_.blurRadiusSlider_.GetPos()/ BLUR_RADIUS_PRECISION;
+        case TB_THUMBPOSITION:
+            canvas_->endBlurRadiusChanging(blurRadius);
+            updatePixelLabels();
+            prevBlurRadius_ = 0;
+            break;
+        case TB_PAGEDOWN:
+        case TB_PAGEUP:
+        case TB_TOP:
+        case TB_LINEDOWN:
+        case TB_LINEUP:
+        case TB_BOTTOM:
+            blurRadius = horizontalToolbar_.blurRadiusSlider_.GetPos()/ BLUR_RADIUS_PRECISION;
+        case TB_THUMBTRACK:
+            if (!prevRoundingRadius_) {
+                prevBlurRadius_ = canvas_->getBlurRadius();
+                canvas_->beginBlurRadiusChanging();
+            }
+            canvas_->setBlurRadius(blurRadius);
+            updatePixelLabels();
+            break;
+        }
+    }
 
     return 0;
 }

Source/ImageEditor/Gui/ImageEditorWindow.h

@@ -198,6 +198,7 @@ class ImageEditorWindow : public CWindowImpl<ImageEditorWindow>, CMessageFilter
         CString serverName_;
         int prevPenSize_;
         int prevRoundingRadius_;
+        float prevBlurRadius_;
         CIcon icon_;
         CIcon iconSmall_;
         std::unique_ptr<ColorsDelegate> colorsDelegate_;
@@ -261,6 +262,7 @@ class ConfigurationProvider {
         fillTextBackground_ = false;
         arrowMode_ = 0;
         invertSelection_ = false;
+        blurRadius_ = 1.0f;
     }
     virtual ~ConfigurationProvider() = default;
     virtual void saveConfiguration() {}
@@ -278,6 +280,9 @@ class ConfigurationProvider {
     int penSize() const { return penSize_;}
     void setRoundingRadius(int radius) { roundingRadius_ = radius; }
     int roundingRadius() const { return roundingRadius_;}
+    void setBlurRadius(float radius) { blurRadius_ = radius; }
+    float blurRadius() const { return blurRadius_; }
+
     bool allowAltTab() const  {  return allowAltTab_; } 
     void setFont(const LOGFONT& font) { font_ = font; }
     LOGFONT font() const { return font_; }
@@ -311,6 +316,7 @@ class ConfigurationProvider {
         stepForegroundColor_, stepBackgroundColor_;
     int penSize_;
     int roundingRadius_;
+    float blurRadius_;
     int arrowMode_;
     LOGFONT font_;
     bool allowAltTab_;