fixing coding style

7 files changed, 665 insertions, 95 deletions

diff --git a/clang_format_diff b/clang_format_diff
new file mode 100644
index 000000000..3f4cbd8bc
--- /dev/null
+++ b/clang_format_diff
@@ -0,0 +1,576 @@
+--- src/live_effects/lpe-powerstroke.cpp	(before formatting)
++++ src/live_effects/lpe-powerstroke.cpp	(after formatting)
+@@ -208,36 +208,37 @@
+     offset_points.set_scale_width(scale_width);
+ }
+ 
+-void 
+-LPEPowerStroke::applyStyle(SPLPEItem *lpeitem)
+-{
+-    SPCSSAttr *css = sp_repr_css_attr_new ();
++void LPEPowerStroke::applyStyle(SPLPEItem *lpeitem)
++{
++    SPCSSAttr *css = sp_repr_css_attr_new();
+     if (lpeitem->style) {
+         if (lpeitem->style->stroke.isPaintserver()) {
+-            SPPaintServer * server = lpeitem->style->getStrokePaintServer();
++            SPPaintServer *server = lpeitem->style->getStrokePaintServer();
+             if (server) {
+                 Glib::ustring str;
+                 str += "url(#";
+                 str += server->getId();
+                 str += ")";
+-                sp_repr_css_set_property (css, "fill", str.c_str());
++                sp_repr_css_set_property(css, "fill", str.c_str());
+             }
+         } else if (lpeitem->style->stroke.isColor()) {
+             gchar c[64];
+-            sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+-            sp_repr_css_set_property (css, "fill", c);
++            sp_svg_write_color(
++                c, sizeof(c),
++                lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
++            sp_repr_css_set_property(css, "fill", c);
+         } else {
+-            sp_repr_css_set_property (css, "fill", "none");
++            sp_repr_css_set_property(css, "fill", "none");
+         }
+     } else {
+-        sp_repr_css_unset_property (css, "fill");
+-    }
+-
+-    sp_repr_css_set_property(css, "fill-rule", "nonzero");        
++        sp_repr_css_unset_property(css, "fill");
++    }
++
++    sp_repr_css_set_property(css, "fill-rule", "nonzero");
+     sp_repr_css_set_property(css, "stroke", "none");
+-    
++
+     sp_desktop_apply_css_recursive(lpeitem, css, true);
+-    sp_repr_css_attr_unref (css);
++    sp_repr_css_attr_unref(css);
+ }
+ 
+ void
+@@ -256,17 +257,17 @@
+             item->updateRepr();
+             if (pathv.empty()) {
+                 points.emplace_back(0.2,width );
+-                points.emplace_back(0.5,width );
+-                points.emplace_back(0.8,width );
++                points.emplace_back(0.5, width);
++                points.emplace_back(0.8, width);
+             } else {
+                 Geom::Path const &path = pathv.front();
+                 Geom::Path::size_type const size = path.size_default();
+                 if (!path.closed()) {
+-                    points.emplace_back(0.2,width );
+-                }
+-                points.emplace_back(0.5*size,width );
++                    points.emplace_back(0.2, width);
++                }
++                points.emplace_back(0.5 * size, width);
+                 if (!path.closed()) {
+-                    points.emplace_back(size - 0.2,width );
++                    points.emplace_back(size - 0.2, width);
+                 }
+             }
+             offset_points.param_set_and_write_new_value(points);
+@@ -765,7 +766,7 @@
+     }
+     if (path_out.empty()) {
+         return path_in;
+-        //doEffect_path (path_in);
++        // doEffect_path (path_in);
+     }
+     return path_out;
+ }
+--- src/ui/tools/freehand-base.cpp	(before formatting)
++++ src/ui/tools/freehand-base.cpp	(after formatting)
+@@ -31,15 +31,15 @@
+ #include "live_effects/lpe-simplify.h"
+ #include "live_effects/lpe-powerstroke.h"
+ 
++#include "svg/svg-color.h"
+ #include "svg/svg.h"
+-#include "svg/svg-color.h"
+-
++
++#include "id-clash.h"
+ #include "object/sp-item-group.h"
+ #include "object/sp-path.h"
+ #include "object/sp-rect.h"
+ #include "object/sp-use.h"
+ #include "style.h"
+-#include "id-clash.h"
+ 
+ #include "ui/clipboard.h"
+ #include "ui/control-manager.h"
+@@ -233,38 +233,40 @@
+     lpe->getRepr()->setAttribute("prop_scale", os.str().c_str());
+ }
+ 
+-void 
+-spdc_apply_style(SPObject *obj)
+-{
+-    SPCSSAttr *css = sp_repr_css_attr_new ();
++void spdc_apply_style(SPObject *obj)
++{
++    SPCSSAttr *css = sp_repr_css_attr_new();
+     if (obj->style) {
+         if (obj->style->stroke.isPaintserver()) {
+-            SPPaintServer * server = obj->style->getStrokePaintServer();
++            SPPaintServer *server = obj->style->getStrokePaintServer();
+             if (server) {
+                 Glib::ustring str;
+                 str += "url(#";
+                 str += server->getId();
+                 str += ")";
+-                sp_repr_css_set_property (css, "fill", str.c_str());
++                sp_repr_css_set_property(css, "fill", str.c_str());
+             }
+         } else if (obj->style->stroke.isColor()) {
+             gchar c[64];
+-            sp_svg_write_color (c, sizeof(c), obj->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(obj->style->stroke_opacity.value)));
+-            sp_repr_css_set_property (css, "fill", c);
++            sp_svg_write_color(
++                c, sizeof(c),
++                obj->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(obj->style->stroke_opacity.value)));
++            sp_repr_css_set_property(css, "fill", c);
+         } else {
+-            sp_repr_css_set_property (css, "fill", "none");
++            sp_repr_css_set_property(css, "fill", "none");
+         }
+     } else {
+-        sp_repr_css_unset_property (css, "fill");
+-    }
+-
+-    sp_repr_css_set_property(css, "fill-rule", "nonzero");        
++        sp_repr_css_unset_property(css, "fill");
++    }
++
++    sp_repr_css_set_property(css, "fill-rule", "nonzero");
+     sp_repr_css_set_property(css, "stroke", "none");
+-    
++
+     sp_desktop_apply_css_recursive(obj, css, true);
+-    sp_repr_css_attr_unref (css);
+-}
+-static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, FreehandBase *dc, SPItem *item, gint maxrecursion = 0)
++    sp_repr_css_attr_unref(css);
++}
++static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, FreehandBase *dc, SPItem *item,
++                                         gint maxrecursion = 0)
+ {
+     using namespace Inkscape::LivePathEffect;
+ 
+@@ -282,7 +284,8 @@
+                 if (SP_SHAPE(elemref)->getCurve() != pt->curvepressure) {
+                     elemref->getRepr()->setAttribute("style", nullptr);
+                     SPItem *successor = dynamic_cast<SPItem *>(elemref);
+-                    sp_desktop_apply_style_tool(desktop, successor->getRepr(), Glib::ustring("/tools/freehand/pencil").data(), false);
++                    sp_desktop_apply_style_tool(desktop, successor->getRepr(),
++                                                Glib::ustring("/tools/freehand/pencil").data(), false);
+                     spdc_apply_style(successor);
+                     item->deleteObject(true);
+                     item = successor;
+@@ -291,10 +294,10 @@
+                     rename_id(SP_OBJECT(item), "path-1");
+                 } else {
+                     using namespace Inkscape::LivePathEffect;
+-                    Effect* lpe = SP_LPE_ITEM(elemref)->getCurrentLPE();
++                    Effect *lpe = SP_LPE_ITEM(elemref)->getCurrentLPE();
+                     if (lpe) {
+                         SP_LPE_ITEM(elemref)->removeCurrentPathEffect(true);
+-                        LivePathEffectObject * lpeobj = lpe->getLPEObj();
++                        LivePathEffectObject *lpeobj = lpe->getLPEObj();
+                         if (lpeobj) {
+                             SP_OBJECT(lpeobj)->deleteObject(true);
+                             lpeobj = nullptr;
+@@ -302,14 +305,14 @@
+                     }
+                     elemref->deleteObject(true);
+                     elemref = nullptr;
+-                    maxrecursion ++;
++                    maxrecursion++;
+                     if (maxrecursion < 5) {
+                         pt->addPowerStrokePencil(true);
+                         spdc_apply_powerstroke_shape(points, dc, item, maxrecursion);
+                     }
+                 }
+             } else {
+-                maxrecursion ++;
++                maxrecursion++;
+                 if (maxrecursion < 5) {
+                     pt->addPowerStrokePencil(true);
+                     spdc_apply_powerstroke_shape(points, dc, item, maxrecursion);
+@@ -453,7 +456,7 @@
+                 previous_shape_type = NONE;
+             }
+         }
+-        
++
+ #define SHAPE_LENGTH 10
+ #define SHAPE_HEIGHT 10
+ 
+--- src/ui/tools/pencil-tool.cpp	(before formatting)
++++ src/ui/tools/pencil-tool.cpp	(after formatting)
+@@ -19,9 +19,9 @@
+ 
+ #include <gdk/gdkkeysyms.h>
+ 
++#include "ui/tools/pencil-tool.h"
++#include <2geom/bezier-utils.h>
+ #include <2geom/sbasis-to-bezier.h>
+-#include <2geom/bezier-utils.h>
+-#include "ui/tools/pencil-tool.h"
+ #include <2geom/svg-path-parser.h>
+ 
+ #include "desktop.h"
+@@ -42,8 +42,8 @@
+ #include "live_effects/lpe-powerstroke-interpolators.h"
+ #include "live_effects/lpe-powerstroke.h"
+ 
++#include "object/sp-lpe-item.h"
+ #include "object/sp-path.h"
+-#include "object/sp-lpe-item.h"
+ #include "style.h"
+ 
+ #include "ui/pixmaps/cursor-pencil.xpm"
+@@ -481,7 +481,7 @@
+                     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+                     tablet_enabled = prefs->getBool("/tools/freehand/pencil/pressure", false);
+                     if (tablet_enabled) {
+-                        gint prevmode  = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
++                        gint prevmode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+                         prefs->setInt("/tools/freehand/pencil/freehand-mode", 0);
+                         spdc_concat_colors_and_flush(this, FALSE);
+                         prefs->setInt("/tools/freehand/pencil/freehand-mode", prevmode);
+@@ -699,14 +699,9 @@
+     }
+ }
+ 
+-static inline double
+-square(double const x)
+-{
+-    return x * x;
+-}
+-
+-void 
+-PencilTool::addPowerStrokePencil(bool force) 
++static inline double square(double const x) { return x * x; }
++
++void PencilTool::addPowerStrokePencil(bool force)
+ {
+     static int pscounter = 11;
+     if (pscounter > 10 || force) {
+@@ -717,8 +712,8 @@
+     }
+     using namespace Inkscape::LivePathEffect;
+     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+-    double min  = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
+-    double max  = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
++    double min = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
++    double max = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
+     Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine();
+     if (min > max){
+         min = max;
+@@ -727,7 +722,7 @@
+     double last_pressure     = this->_wps.back();
+     double pressure_shrunk   = (last_pressure * (max - min)) + min;
+     //We need half width for power stroke
+-    double pressure_computed =  (pressure_shrunk * dezoomify_factor)/5.0;
++    double pressure_computed = (pressure_shrunk * dezoomify_factor) / 5.0;
+     this->_last_point        = this->ps.back();
+     this->_last_point       *= transform_coordinate.inverse();
+     this->_points_pressure.push_back(Geom::Point(0, pressure_computed));
+@@ -752,7 +747,7 @@
+         if (nofuture || status == std::future_status::ready) {
+             if (!stop && status == std::future_status::ready) { */
+ 
+-        SPDocument * document = SP_ACTIVE_DOCUMENT;
++        SPDocument *document = SP_ACTIVE_DOCUMENT;
+         if (!document) {
+             return;
+         }
+@@ -760,7 +755,7 @@
+         SPObject *toremove = document->getObjectById(id);
+         using namespace Inkscape::LivePathEffect;
+         if (toremove) {
+-            toremove->getRepr()->setAttribute("id","tmp_power_stroke_preview");
++            toremove->getRepr()->setAttribute("id", "tmp_power_stroke_preview");
+         }
+         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+         double tol = prefs->getDoubleLimited("/tools/freehand/pencil/base-simplify", 25.0, 1.0, 100.0) * 0.4;
+@@ -787,8 +782,8 @@
+         size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions());
+         //size /= sp_lpe_item->i2doc_affine().descrim();
+         pathliv->ConvertEvenLines(tol * size);
+-        pathliv->Simplify(tol * size); 
+-        
++        pathliv->Simplify(tol * size);
++
+         Geom::Path path = Geom::parse_svg_path(pathliv->svg_dump_path())[0];*/
+         if (!path.empty()) {
+             Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine().inverse();
+@@ -797,7 +792,7 @@
+             // points_preview.push_back(Geom::Point(path.size() - 1, points_preview[points_preview.size()-1][Geom::Y]));
+             // future = std::async(std::launch::async, [path, points_preview] {
+             using namespace Inkscape::LivePathEffect;
+-            SPDocument * document = SP_ACTIVE_DOCUMENT;
++            SPDocument *document = SP_ACTIVE_DOCUMENT;
+             if (!document) {
+                 return;
+                 // return true;
+@@ -806,14 +801,14 @@
+             Inkscape::XML::Node *pp = nullptr;
+             pp = xml_doc->createElement("svg:path");
+             pp->setAttribute("sodipodi:insensitive", "true");
+-            gchar * pvector_str = sp_svg_write_path(path);
++            gchar *pvector_str = sp_svg_write_path(path);
+             if (pvector_str) {
+-                pp->setAttribute("d" , pvector_str);
++                pp->setAttribute("d", pvector_str);
+                 g_free(pvector_str);
+             }
+             pp->setAttribute("id", "power_stroke_preview");
+             Inkscape::GC::release(pp);
+-            
++
+             SPShape *powerpreview = SP_SHAPE(SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->appendChildRepr(pp));
+             SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(powerpreview);
+             if (!lpeitem) {
+@@ -821,15 +816,15 @@
+                 // return true;
+             }
+             tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0);
+-            tol = tol/(100.0*(102.0-tol));
++            tol = tol / (100.0 * (102.0 - tol));
+             std::ostringstream threshold;
+             threshold << tol;
+             Effect::createAndApply(SIMPLIFY, desktop->doc(), SP_ITEM(lpeitem));
+-            Effect* lpe = lpeitem->getCurrentLPE();
++            Effect *lpe = lpeitem->getCurrentLPE();
+             if (lpe) {
+                 Glib::ustring pref_path = "/live_effects/simplify/smooth_angles";
+                 bool valid = prefs->getEntry(pref_path).isValid();
+-                if (!valid){
++                if (!valid) {
+                     lpe->getRepr()->setAttribute("smooth_angles", "360");
+                 }
+                 lpe->getRepr()->setAttribute("threshold", threshold.str());
+@@ -847,12 +842,12 @@
+             prefs->setBool(pref_path_pp, true);
+             Effect::createAndApply(POWERSTROKE, SP_ACTIVE_DESKTOP->doc(), lpeitem);
+             lpe = lpeitem->getCurrentLPE();
+-            Inkscape::LivePathEffect::LPEPowerStroke *pspreview = static_cast<LPEPowerStroke*>(lpe);
++            Inkscape::LivePathEffect::LPEPowerStroke *pspreview = static_cast<LPEPowerStroke *>(lpe);
+             sp_lpe_item_enable_path_effects(lpeitem, false);
+             if (pspreview) {
+                 Glib::ustring pref_path = "/live_effects/powerstroke/interpolator_type";
+                 bool valid = prefs->getEntry(pref_path).isValid();
+-                if (!valid){
++                if (!valid) {
+                     pspreview->getRepr()->setAttribute("interpolator_type", "CentripetalCatmullRom");
+                 }
+                 pspreview->getRepr()->setAttribute("sort_points", "true");
+@@ -860,17 +855,17 @@
+                 if (powerpreview->getCurve() != curvepressure) {
+                     pp->setAttribute("style", "fill:#888888;opacity:1;fill-rule:nonzero;stroke:none;");
+                 } else if (toremove) {
+-                    toremove->getRepr()->setAttribute("id","power_stroke_preview");
++                    toremove->getRepr()->setAttribute("id", "power_stroke_preview");
+                     toremove = powerpreview;
+                 }
+             }
+             sp_lpe_item_enable_path_effects(lpeitem, true);
+-            
++
+             if (toremove) {
+                 using namespace Inkscape::LivePathEffect;
+-                Effect* lpe = SP_LPE_ITEM(toremove)->getCurrentLPE();
++                Effect *lpe = SP_LPE_ITEM(toremove)->getCurrentLPE();
+                 SP_LPE_ITEM(toremove)->removeCurrentPathEffect(true);
+-                LivePathEffectObject * lpeobj = lpe->getLPEObj();
++                LivePathEffectObject *lpeobj = lpe->getLPEObj();
+                 if (lpeobj) {
+                     SP_OBJECT(lpeobj)->deleteObject(true);
+                     lpeobj = nullptr;
+@@ -896,7 +891,7 @@
+ void PencilTool::_addFreehandPoint(Geom::Point const &p, guint /*state*/) {
+     g_assert( this->_npoints > 0 );
+     g_return_if_fail(unsigned(this->_npoints) < G_N_ELEMENTS(this->p));
+-    
++
+     if ( ( p != this->p[ this->_npoints - 1 ] )
+          && in_svg_plane(p) )
+     {
+@@ -915,8 +910,8 @@
+     }
+ }
+ 
+-void
+-PencilTool::powerStrokeInterpolate(Geom::Path path) {
++void PencilTool::powerStrokeInterpolate(Geom::Path path)
++{
+     size_t ps_size = this->ps.size();
+     if ( ps_size <= 1 ) {
+         return;
+@@ -925,9 +920,9 @@
+     using Geom::Y;
+     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+     double step = prefs->getDoubleLimited("/tools/freehand/pencil/pressurestep", 5.0, 0.0, 100.0);
+-    double min  = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
+-    double max  = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
+-    if (min > max){
++    double min = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
++    double max = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
++    if (min > max) {
+         min = max;
+     }
+     step = (step * (max - min)) + min;
+@@ -937,14 +932,12 @@
+     std::vector<Geom::Point> tmp_points_pos;
+     Geom::Point prev = Geom::Point(Geom::infinity(), Geom::infinity());
+     size_t i = 0;
+-    for (auto pospoint: this->_points_pos) {
++    for (auto pospoint : this->_points_pos) {
+         Geom::Point pp = pospoint;
+-        pp[Geom::X] = (path.size()/(double)this->_points_pos.size()) * i;
++        pp[Geom::X] = (path.size() / (double)this->_points_pos.size()) * i;
+         pp[Geom::Y] = this->_points_pressure[i][Geom::Y];
+         if (this->_points_pos.size() - 1 == i ||
+-            (!Geom::are_near(prev[Geom::X], pp[Geom::X], 0.2) && 
+-             !Geom::are_near(prev[Geom::Y], pp[Geom::Y], step)))
+-        {
++            (!Geom::are_near(prev[Geom::X], pp[Geom::X], 0.2) && !Geom::are_near(prev[Geom::Y], pp[Geom::Y], step))) {
+             tmp_points.push_back(pp);
+             prev = pp;
+         }
+--- src/ui/toolbar/pencil-toolbar.cpp	(before formatting)
++++ src/ui/toolbar/pencil-toolbar.cpp	(after formatting)
+@@ -107,8 +107,7 @@
+     if (pencil_mode) {
+         /* Use pressure */
+         {
+-            _pressure_item = add_toggle_button(_("Use pressure input"),
+-                                               _("Use pressure input"));
++            _pressure_item = add_toggle_button(_("Use pressure input"), _("Use pressure input"));
+             _pressure_item->set_icon_name(INKSCAPE_ICON("draw-use-pressure"));
+             bool pressure = prefs->getBool(freehand_tool_name() + "/pressure", false);
+             if (oldPressureMode && pressure) {
+@@ -141,14 +140,16 @@
+         {
+             auto pressurestep_val = prefs->getDouble("/tools/freehand/pencil/pressurestep", 5);
+             _pressurestep_adj = Gtk::Adjustment::create(pressurestep_val, 0., 100, 1.0, 0.0);
+-            _pressurestep = Gtk::manage(new UI::Widget::SpinButtonToolItem("pencil-pressurestep", _("Knot gap:"), _pressurestep_adj, 0, 0));
++            _pressurestep = Gtk::manage(
++                new UI::Widget::SpinButtonToolItem("pencil-pressurestep", _("Knot gap:"), _pressurestep_adj, 0, 0));
+             _pressurestep->set_tooltip_text(_("Pressure steps for new knot"));
+             _pressurestep->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
+-            _pressurestep_adj->signal_value_changed().connect(sigc::mem_fun(*this, &PencilToolbar::pressurestep_value_changed));
++            _pressurestep_adj->signal_value_changed().connect(
++                sigc::mem_fun(*this, &PencilToolbar::pressurestep_value_changed));
+             add(*_pressurestep);
+         }
+ 
+-        
++
+ 
+         add(* Gtk::manage(new Gtk::SeparatorToolItem()));
+ 
+@@ -341,8 +342,7 @@
+     prefs->setDouble( "/tools/freehand/pencil/maxpressure", _maxpressure_adj->get_value());
+ }
+ 
+-void
+-PencilToolbar::pressurestep_value_changed()
++void PencilToolbar::pressurestep_value_changed()
+ {
+     // quit if run by the attr_changed listener
+     if (_freeze) {
+@@ -350,7 +350,7 @@
+     }
+ 
+     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+-    prefs->setDouble( "/tools/freehand/pencil/pressurestep", _pressurestep_adj->get_value());
++    prefs->setDouble("/tools/freehand/pencil/pressurestep", _pressurestep_adj->get_value());
+ }
+ 
+ void
+@@ -371,7 +371,7 @@
+         }
+     } else {
+         guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+-    
++
+         _minpressure->set_visible(false);
+         _maxpressure->set_visible(false);
+         _pressurestep->set_visible(false);
+--- src/ui/toolbar/pencil-toolbar.h	(before formatting)
++++ src/ui/toolbar/pencil-toolbar.h	(after formatting)
+@@ -54,7 +54,7 @@
+     UI::Widget::SpinButtonToolItem *_minpressure;
+     UI::Widget::SpinButtonToolItem *_maxpressure;
+     UI::Widget::SpinButtonToolItem *_pressurestep;
+-    
++
+     XML::Node *_repr;
+     Gtk::ToolButton *_flatten_spiro_bspline;
+     Gtk::ToolButton *_flatten_simplify;
+--- src/live_effects/effect.cpp	(before formatting)
++++ src/live_effects/effect.cpp	(after formatting)
+@@ -1098,22 +1098,25 @@
+ }
+ 
+ Effect::Effect(LivePathEffectObject *lpeobject)
+-    : apply_to_clippath_and_mask(false),
+-      _provides_knotholder_entities(false),
+-      oncanvasedit_it(0),
+-      is_visible(_("Is visible?"), _("If unchecked, the effect remains applied to the object but is temporarily disabled on canvas"), "is_visible", &wr, this, true),
+-      show_orig_path(false),
+-      keep_paths(false),
+-      is_load(true),
+-      lpeobj(lpeobject),
+-      concatenate_before_pwd2(false),
+-      sp_lpe_item(nullptr),
+-      current_zoom(1),
+-      upd_params(false),
+-      current_shape(nullptr),
+-      provides_own_flash_paths(true), // is automatically set to false if providesOwnFlashPaths() is not overridden
+-      defaultsopen(false),
+-      is_ready(false) 
++    : apply_to_clippath_and_mask(false)
++    , _provides_knotholder_entities(false)
++    , oncanvasedit_it(0)
++    , is_visible(_("Is visible?"),
++                 _("If unchecked, the effect remains applied to the object but is temporarily disabled on canvas"),
++                 "is_visible", &wr, this, true)
++    , show_orig_path(false)
++    , keep_paths(false)
++    , is_load(true)
++    , lpeobj(lpeobject)
++    , concatenate_before_pwd2(false)
++    , sp_lpe_item(nullptr)
++    , current_zoom(1)
++    , upd_params(false)
++    , current_shape(nullptr)
++    , provides_own_flash_paths(true)
++    , // is automatically set to false if providesOwnFlashPaths() is not overridden
++    defaultsopen(false)
++    , is_ready(false)
+ {
+     registerParameter( dynamic_cast<Parameter *>(&is_visible) );
+     is_visible.widget_is_visible = false;
+--- src/ui/tools/pencil-tool.h	(before formatting)
++++ src/ui/tools/pencil-tool.h	(after formatting)
+@@ -53,7 +53,7 @@
+     Geom::Piecewise<Geom::D2<Geom::SBasis> > sketch_interpolation; // the current proposal from the sketched paths
+     unsigned sketch_n; // number of sketches done
+     static const std::string prefsPath;
+-    SPCurve * curvepressure;
++    SPCurve *curvepressure;
+     const std::string& getPrefsPath() override;
+ 
+ protected:
diff --git a/src/live_effects/lpe-powerstroke.cpp b/src/live_effects/lpe-powerstroke.cpp
index 15fda42fc..e7700ba78 100644
--- a/src/live_effects/lpe-powerstroke.cpp
+++ b/src/live_effects/lpe-powerstroke.cpp
@@ -208,36 +208,37 @@ LPEPowerStroke::doBeforeEffect(SPLPEItem const *lpeItem)
     offset_points.set_scale_width(scale_width);
 }
 
-void 
-LPEPowerStroke::applyStyle(SPLPEItem *lpeitem)
+void LPEPowerStroke::applyStyle(SPLPEItem *lpeitem)
 {
-    SPCSSAttr *css = sp_repr_css_attr_new ();
+    SPCSSAttr *css = sp_repr_css_attr_new();
     if (lpeitem->style) {
         if (lpeitem->style->stroke.isPaintserver()) {
-            SPPaintServer * server = lpeitem->style->getStrokePaintServer();
+            SPPaintServer *server = lpeitem->style->getStrokePaintServer();
             if (server) {
                 Glib::ustring str;
                 str += "url(#";
                 str += server->getId();
                 str += ")";
-                sp_repr_css_set_property (css, "fill", str.c_str());
+                sp_repr_css_set_property(css, "fill", str.c_str());
             }
         } else if (lpeitem->style->stroke.isColor()) {
             gchar c[64];
-            sp_svg_write_color (c, sizeof(c), lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
-            sp_repr_css_set_property (css, "fill", c);
+            sp_svg_write_color(
+                c, sizeof(c),
+                lpeitem->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(lpeitem->style->stroke_opacity.value)));
+            sp_repr_css_set_property(css, "fill", c);
         } else {
-            sp_repr_css_set_property (css, "fill", "none");
+            sp_repr_css_set_property(css, "fill", "none");
         }
     } else {
-        sp_repr_css_unset_property (css, "fill");
+        sp_repr_css_unset_property(css, "fill");
     }
 
-    sp_repr_css_set_property(css, "fill-rule", "nonzero");        
+    sp_repr_css_set_property(css, "fill-rule", "nonzero");
     sp_repr_css_set_property(css, "stroke", "none");
-    
+
     sp_desktop_apply_css_recursive(lpeitem, css, true);
-    sp_repr_css_attr_unref (css);
+    sp_repr_css_attr_unref(css);
 }
 
 void
@@ -256,17 +257,17 @@ LPEPowerStroke::doOnApply(SPLPEItem const* lpeitem)
             item->updateRepr();
             if (pathv.empty()) {
                 points.emplace_back(0.2,width );
-                points.emplace_back(0.5,width );
-                points.emplace_back(0.8,width );
+                points.emplace_back(0.5, width);
+                points.emplace_back(0.8, width);
             } else {
                 Geom::Path const &path = pathv.front();
                 Geom::Path::size_type const size = path.size_default();
                 if (!path.closed()) {
-                    points.emplace_back(0.2,width );
+                    points.emplace_back(0.2, width);
                 }
-                points.emplace_back(0.5*size,width );
+                points.emplace_back(0.5 * size, width);
                 if (!path.closed()) {
-                    points.emplace_back(size - 0.2,width );
+                    points.emplace_back(size - 0.2, width);
                 }
             }
             offset_points.param_set_and_write_new_value(points);
@@ -765,7 +766,7 @@ LPEPowerStroke::doEffect_path (Geom::PathVector const & path_in)
     }
     if (path_out.empty()) {
         return path_in;
-        //doEffect_path (path_in);
+        // doEffect_path (path_in);
     }
     return path_out;
 }
diff --git a/src/ui/toolbar/pencil-toolbar.cpp b/src/ui/toolbar/pencil-toolbar.cpp
index 14dbed5a8..688524310 100644
--- a/src/ui/toolbar/pencil-toolbar.cpp
+++ b/src/ui/toolbar/pencil-toolbar.cpp
@@ -107,13 +107,9 @@ PencilToolbar::PencilToolbar(SPDesktop *desktop,
     if (pencil_mode) {
         /* Use pressure */
         {
-            _pressure_item = add_toggle_button(_("Use pressure input"),
-                                               _("Use pressure input"));
+            _pressure_item = add_toggle_button(_("Use pressure input"), _("Use pressure input"));
             _pressure_item->set_icon_name(INKSCAPE_ICON("draw-use-pressure"));
             bool pressure = prefs->getBool(freehand_tool_name() + "/pressure", false);
-            if (oldPressureMode && pressure) {
-                prefs->setBool(freehand_tool_name() + "/pressure", true);
-            }
             _pressure_item->set_active(pressure);
             _pressure_item->signal_toggled().connect(sigc::mem_fun(*this, &PencilToolbar::use_pencil_pressure));
         }
@@ -141,14 +137,16 @@ PencilToolbar::PencilToolbar(SPDesktop *desktop,
         {
             auto pressurestep_val = prefs->getDouble("/tools/freehand/pencil/pressurestep", 5);
             _pressurestep_adj = Gtk::Adjustment::create(pressurestep_val, 0., 100, 1.0, 0.0);
-            _pressurestep = Gtk::manage(new UI::Widget::SpinButtonToolItem("pencil-pressurestep", _("Knot gap:"), _pressurestep_adj, 0, 0));
+            _pressurestep = Gtk::manage(
+                new UI::Widget::SpinButtonToolItem("pencil-pressurestep", _("Knot gap:"), _pressurestep_adj, 0, 0));
             _pressurestep->set_tooltip_text(_("Pressure steps for new knot"));
             _pressurestep->set_focus_widget(Glib::wrap(GTK_WIDGET(desktop->canvas)));
-            _pressurestep_adj->signal_value_changed().connect(sigc::mem_fun(*this, &PencilToolbar::pressurestep_value_changed));
+            _pressurestep_adj->signal_value_changed().connect(
+                sigc::mem_fun(*this, &PencilToolbar::pressurestep_value_changed));
             add(*_pressurestep);
         }
 
-        
+
 
         add(* Gtk::manage(new Gtk::SeparatorToolItem()));
 
@@ -341,8 +339,7 @@ PencilToolbar::maxpressure_value_changed()
     prefs->setDouble( "/tools/freehand/pencil/maxpressure", _maxpressure_adj->get_value());
 }
 
-void
-PencilToolbar::pressurestep_value_changed()
+void PencilToolbar::pressurestep_value_changed()
 {
     // quit if run by the attr_changed listener
     if (_freeze) {
@@ -350,7 +347,7 @@ PencilToolbar::pressurestep_value_changed()
     }
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    prefs->setDouble( "/tools/freehand/pencil/pressurestep", _pressurestep_adj->get_value());
+    prefs->setDouble("/tools/freehand/pencil/pressurestep", _pressurestep_adj->get_value());
 }
 
 void
@@ -371,7 +368,7 @@ PencilToolbar::use_pencil_pressure() {
         }
     } else {
         guint freehandMode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
-    
+
         _minpressure->set_visible(false);
         _maxpressure->set_visible(false);
         _pressurestep->set_visible(false);
diff --git a/src/ui/toolbar/pencil-toolbar.h b/src/ui/toolbar/pencil-toolbar.h
index 81db52595..9022d32da 100644
--- a/src/ui/toolbar/pencil-toolbar.h
+++ b/src/ui/toolbar/pencil-toolbar.h
@@ -54,7 +54,7 @@ private:
     UI::Widget::SpinButtonToolItem *_minpressure;
     UI::Widget::SpinButtonToolItem *_maxpressure;
     UI::Widget::SpinButtonToolItem *_pressurestep;
-    
+
     XML::Node *_repr;
     Gtk::ToolButton *_flatten_spiro_bspline;
     Gtk::ToolButton *_flatten_simplify;
diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index bc092b79c..556ba9f2b 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -31,15 +31,15 @@
 #include "live_effects/lpe-simplify.h"
 #include "live_effects/lpe-powerstroke.h"
 
-#include "svg/svg.h"
 #include "svg/svg-color.h"
+#include "svg/svg.h"
 
+#include "id-clash.h"
 #include "object/sp-item-group.h"
 #include "object/sp-path.h"
 #include "object/sp-rect.h"
 #include "object/sp-use.h"
 #include "style.h"
-#include "id-clash.h"
 
 #include "ui/clipboard.h"
 #include "ui/control-manager.h"
@@ -233,38 +233,40 @@ static void spdc_paste_curve_as_freehand_shape(Geom::PathVector const &newpath,
     lpe->getRepr()->setAttribute("prop_scale", os.str().c_str());
 }
 
-void 
-spdc_apply_style(SPObject *obj)
+void spdc_apply_style(SPObject *obj)
 {
-    SPCSSAttr *css = sp_repr_css_attr_new ();
+    SPCSSAttr *css = sp_repr_css_attr_new();
     if (obj->style) {
         if (obj->style->stroke.isPaintserver()) {
-            SPPaintServer * server = obj->style->getStrokePaintServer();
+            SPPaintServer *server = obj->style->getStrokePaintServer();
             if (server) {
                 Glib::ustring str;
                 str += "url(#";
                 str += server->getId();
                 str += ")";
-                sp_repr_css_set_property (css, "fill", str.c_str());
+                sp_repr_css_set_property(css, "fill", str.c_str());
             }
         } else if (obj->style->stroke.isColor()) {
             gchar c[64];
-            sp_svg_write_color (c, sizeof(c), obj->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(obj->style->stroke_opacity.value)));
-            sp_repr_css_set_property (css, "fill", c);
+            sp_svg_write_color(
+                c, sizeof(c),
+                obj->style->stroke.value.color.toRGBA32(SP_SCALE24_TO_FLOAT(obj->style->stroke_opacity.value)));
+            sp_repr_css_set_property(css, "fill", c);
         } else {
-            sp_repr_css_set_property (css, "fill", "none");
+            sp_repr_css_set_property(css, "fill", "none");
         }
     } else {
-        sp_repr_css_unset_property (css, "fill");
+        sp_repr_css_unset_property(css, "fill");
     }
 
-    sp_repr_css_set_property(css, "fill-rule", "nonzero");        
+    sp_repr_css_set_property(css, "fill-rule", "nonzero");
     sp_repr_css_set_property(css, "stroke", "none");
-    
+
     sp_desktop_apply_css_recursive(obj, css, true);
-    sp_repr_css_attr_unref (css);
+    sp_repr_css_attr_unref(css);
 }
-static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, FreehandBase *dc, SPItem *item, gint maxrecursion = 0)
+static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, FreehandBase *dc, SPItem *item,
+                                         gint maxrecursion = 0)
 {
     using namespace Inkscape::LivePathEffect;
 
@@ -282,7 +284,8 @@ static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, Freeha
                 if (SP_SHAPE(elemref)->getCurve() != pt->curvepressure) {
                     elemref->getRepr()->setAttribute("style", nullptr);
                     SPItem *successor = dynamic_cast<SPItem *>(elemref);
-                    sp_desktop_apply_style_tool(desktop, successor->getRepr(), Glib::ustring("/tools/freehand/pencil").data(), false);
+                    sp_desktop_apply_style_tool(desktop, successor->getRepr(),
+                                                Glib::ustring("/tools/freehand/pencil").data(), false);
                     spdc_apply_style(successor);
                     item->deleteObject(true);
                     item = successor;
@@ -291,10 +294,10 @@ static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, Freeha
                     rename_id(SP_OBJECT(item), "path-1");
                 } else {
                     using namespace Inkscape::LivePathEffect;
-                    Effect* lpe = SP_LPE_ITEM(elemref)->getCurrentLPE();
+                    Effect *lpe = SP_LPE_ITEM(elemref)->getCurrentLPE();
                     if (lpe) {
                         SP_LPE_ITEM(elemref)->removeCurrentPathEffect(true);
-                        LivePathEffectObject * lpeobj = lpe->getLPEObj();
+                        LivePathEffectObject *lpeobj = lpe->getLPEObj();
                         if (lpeobj) {
                             SP_OBJECT(lpeobj)->deleteObject(true);
                             lpeobj = nullptr;
@@ -302,14 +305,14 @@ static void spdc_apply_powerstroke_shape(std::vector<Geom::Point> points, Freeha
                     }
                     elemref->deleteObject(true);
                     elemref = nullptr;
-                    maxrecursion ++;
+                    maxrecursion++;
                     if (maxrecursion < 5) {
                         pt->addPowerStrokePencil(true);
                         spdc_apply_powerstroke_shape(points, dc, item, maxrecursion);
                     }
                 }
             } else {
-                maxrecursion ++;
+                maxrecursion++;
                 if (maxrecursion < 5) {
                     pt->addPowerStrokePencil(true);
                     spdc_apply_powerstroke_shape(points, dc, item, maxrecursion);
@@ -453,7 +456,7 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
                 previous_shape_type = NONE;
             }
         }
-        
+
 #define SHAPE_LENGTH 10
 #define SHAPE_HEIGHT 10
 
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index a24e6a291..a0dc3201c 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -19,9 +19,9 @@
 
 #include <gdk/gdkkeysyms.h>
 
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/bezier-utils.h>
 #include "ui/tools/pencil-tool.h"
+#include <2geom/bezier-utils.h>
+#include <2geom/sbasis-to-bezier.h>
 #include <2geom/svg-path-parser.h>
 
 #include "desktop.h"
@@ -42,8 +42,8 @@
 #include "live_effects/lpe-powerstroke-interpolators.h"
 #include "live_effects/lpe-powerstroke.h"
 
-#include "object/sp-path.h"
 #include "object/sp-lpe-item.h"
+#include "object/sp-path.h"
 #include "style.h"
 
 #include "ui/pixmaps/cursor-pencil.xpm"
@@ -481,7 +481,7 @@ bool PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
                     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
                     tablet_enabled = prefs->getBool("/tools/freehand/pencil/pressure", false);
                     if (tablet_enabled) {
-                        gint prevmode  = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
+                        gint prevmode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
                         prefs->setInt("/tools/freehand/pencil/freehand-mode", 0);
                         spdc_concat_colors_and_flush(this, FALSE);
                         prefs->setInt("/tools/freehand/pencil/freehand-mode", prevmode);
@@ -699,14 +699,9 @@ void PencilTool::_finishEndpoint() {
     }
 }
 
-static inline double
-square(double const x)
-{
-    return x * x;
-}
+static inline double square(double const x) { return x * x; }
 
-void 
-PencilTool::addPowerStrokePencil(bool force) 
+void PencilTool::addPowerStrokePencil(bool force)
 {
     static int pscounter = 11;
     if (pscounter > 10 || force) {
@@ -717,8 +712,8 @@ PencilTool::addPowerStrokePencil(bool force)
     }
     using namespace Inkscape::LivePathEffect;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    double min  = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
-    double max  = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
+    double min = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
+    double max = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
     Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine();
     if (min > max){
         min = max;
@@ -727,7 +722,7 @@ PencilTool::addPowerStrokePencil(bool force)
     double last_pressure     = this->_wps.back();
     double pressure_shrunk   = (last_pressure * (max - min)) + min;
     //We need half width for power stroke
-    double pressure_computed =  (pressure_shrunk * dezoomify_factor)/5.0;
+    double pressure_computed = (pressure_shrunk * dezoomify_factor) / 5.0;
     this->_last_point        = this->ps.back();
     this->_last_point       *= transform_coordinate.inverse();
     this->_points_pressure.push_back(Geom::Point(0, pressure_computed));
@@ -752,7 +747,7 @@ PencilTool::addPowerStrokePencil(bool force)
         if (nofuture || status == std::future_status::ready) {
             if (!stop && status == std::future_status::ready) { */
 
-        SPDocument * document = SP_ACTIVE_DOCUMENT;
+        SPDocument *document = SP_ACTIVE_DOCUMENT;
         if (!document) {
             return;
         }
@@ -760,7 +755,7 @@ PencilTool::addPowerStrokePencil(bool force)
         SPObject *toremove = document->getObjectById(id);
         using namespace Inkscape::LivePathEffect;
         if (toremove) {
-            toremove->getRepr()->setAttribute("id","tmp_power_stroke_preview");
+            toremove->getRepr()->setAttribute("id", "tmp_power_stroke_preview");
         }
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         double tol = prefs->getDoubleLimited("/tools/freehand/pencil/base-simplify", 25.0, 1.0, 100.0) * 0.4;
@@ -787,8 +782,8 @@ PencilTool::addPowerStrokePencil(bool force)
         size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions());
         //size /= sp_lpe_item->i2doc_affine().descrim();
         pathliv->ConvertEvenLines(tol * size);
-        pathliv->Simplify(tol * size); 
-        
+        pathliv->Simplify(tol * size);
+
         Geom::Path path = Geom::parse_svg_path(pathliv->svg_dump_path())[0];*/
         if (!path.empty()) {
             Geom::Affine transform_coordinate = SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->i2dt_affine().inverse();
@@ -797,7 +792,7 @@ PencilTool::addPowerStrokePencil(bool force)
             // points_preview.push_back(Geom::Point(path.size() - 1, points_preview[points_preview.size()-1][Geom::Y]));
             // future = std::async(std::launch::async, [path, points_preview] {
             using namespace Inkscape::LivePathEffect;
-            SPDocument * document = SP_ACTIVE_DOCUMENT;
+            SPDocument *document = SP_ACTIVE_DOCUMENT;
             if (!document) {
                 return;
                 // return true;
@@ -806,14 +801,14 @@ PencilTool::addPowerStrokePencil(bool force)
             Inkscape::XML::Node *pp = nullptr;
             pp = xml_doc->createElement("svg:path");
             pp->setAttribute("sodipodi:insensitive", "true");
-            gchar * pvector_str = sp_svg_write_path(path);
+            gchar *pvector_str = sp_svg_write_path(path);
             if (pvector_str) {
-                pp->setAttribute("d" , pvector_str);
+                pp->setAttribute("d", pvector_str);
                 g_free(pvector_str);
             }
             pp->setAttribute("id", "power_stroke_preview");
             Inkscape::GC::release(pp);
-            
+
             SPShape *powerpreview = SP_SHAPE(SP_ITEM(SP_ACTIVE_DESKTOP->currentLayer())->appendChildRepr(pp));
             SPLPEItem *lpeitem = dynamic_cast<SPLPEItem *>(powerpreview);
             if (!lpeitem) {
@@ -821,15 +816,15 @@ PencilTool::addPowerStrokePencil(bool force)
                 // return true;
             }
             tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0);
-            tol = tol/(100.0*(102.0-tol));
+            tol = tol / (100.0 * (102.0 - tol));
             std::ostringstream threshold;
             threshold << tol;
             Effect::createAndApply(SIMPLIFY, desktop->doc(), SP_ITEM(lpeitem));
-            Effect* lpe = lpeitem->getCurrentLPE();
+            Effect *lpe = lpeitem->getCurrentLPE();
             if (lpe) {
                 Glib::ustring pref_path = "/live_effects/simplify/smooth_angles";
                 bool valid = prefs->getEntry(pref_path).isValid();
-                if (!valid){
+                if (!valid) {
                     lpe->getRepr()->setAttribute("smooth_angles", "360");
                 }
                 lpe->getRepr()->setAttribute("threshold", threshold.str());
@@ -847,12 +842,12 @@ PencilTool::addPowerStrokePencil(bool force)
             prefs->setBool(pref_path_pp, true);
             Effect::createAndApply(POWERSTROKE, SP_ACTIVE_DESKTOP->doc(), lpeitem);
             lpe = lpeitem->getCurrentLPE();
-            Inkscape::LivePathEffect::LPEPowerStroke *pspreview = static_cast<LPEPowerStroke*>(lpe);
+            Inkscape::LivePathEffect::LPEPowerStroke *pspreview = static_cast<LPEPowerStroke *>(lpe);
             sp_lpe_item_enable_path_effects(lpeitem, false);
             if (pspreview) {
                 Glib::ustring pref_path = "/live_effects/powerstroke/interpolator_type";
                 bool valid = prefs->getEntry(pref_path).isValid();
-                if (!valid){
+                if (!valid) {
                     pspreview->getRepr()->setAttribute("interpolator_type", "CentripetalCatmullRom");
                 }
                 pspreview->getRepr()->setAttribute("sort_points", "true");
@@ -860,17 +855,17 @@ PencilTool::addPowerStrokePencil(bool force)
                 if (powerpreview->getCurve() != curvepressure) {
                     pp->setAttribute("style", "fill:#888888;opacity:1;fill-rule:nonzero;stroke:none;");
                 } else if (toremove) {
-                    toremove->getRepr()->setAttribute("id","power_stroke_preview");
+                    toremove->getRepr()->setAttribute("id", "power_stroke_preview");
                     toremove = powerpreview;
                 }
             }
             sp_lpe_item_enable_path_effects(lpeitem, true);
-            
+
             if (toremove) {
                 using namespace Inkscape::LivePathEffect;
-                Effect* lpe = SP_LPE_ITEM(toremove)->getCurrentLPE();
+                Effect *lpe = SP_LPE_ITEM(toremove)->getCurrentLPE();
                 SP_LPE_ITEM(toremove)->removeCurrentPathEffect(true);
-                LivePathEffectObject * lpeobj = lpe->getLPEObj();
+                LivePathEffectObject *lpeobj = lpe->getLPEObj();
                 if (lpeobj) {
                     SP_OBJECT(lpeobj)->deleteObject(true);
                     lpeobj = nullptr;
@@ -896,7 +891,7 @@ PencilTool::addPowerStrokePencil(bool force)
 void PencilTool::_addFreehandPoint(Geom::Point const &p, guint /*state*/) {
     g_assert( this->_npoints > 0 );
     g_return_if_fail(unsigned(this->_npoints) < G_N_ELEMENTS(this->p));
-    
+
     if ( ( p != this->p[ this->_npoints - 1 ] )
          && in_svg_plane(p) )
     {
@@ -915,8 +910,8 @@ void PencilTool::_addFreehandPoint(Geom::Point const &p, guint /*state*/) {
     }
 }
 
-void
-PencilTool::powerStrokeInterpolate(Geom::Path path) {
+void PencilTool::powerStrokeInterpolate(Geom::Path path)
+{
     size_t ps_size = this->ps.size();
     if ( ps_size <= 1 ) {
         return;
@@ -925,9 +920,9 @@ PencilTool::powerStrokeInterpolate(Geom::Path path) {
     using Geom::Y;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double step = prefs->getDoubleLimited("/tools/freehand/pencil/pressurestep", 5.0, 0.0, 100.0);
-    double min  = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
-    double max  = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
-    if (min > max){
+    double min = prefs->getIntLimited("/tools/freehand/pencil/minpressure", 10, 1, 100) / 100.0;
+    double max = prefs->getIntLimited("/tools/freehand/pencil/maxpressure", 40, 1, 100) / 100.0;
+    if (min > max) {
         min = max;
     }
     step = (step * (max - min)) + min;
@@ -937,14 +932,12 @@ PencilTool::powerStrokeInterpolate(Geom::Path path) {
     std::vector<Geom::Point> tmp_points_pos;
     Geom::Point prev = Geom::Point(Geom::infinity(), Geom::infinity());
     size_t i = 0;
-    for (auto pospoint: this->_points_pos) {
+    for (auto pospoint : this->_points_pos) {
         Geom::Point pp = pospoint;
-        pp[Geom::X] = (path.size()/(double)this->_points_pos.size()) * i;
+        pp[Geom::X] = (path.size() / (double)this->_points_pos.size()) * i;
         pp[Geom::Y] = this->_points_pressure[i][Geom::Y];
         if (this->_points_pos.size() - 1 == i ||
-            (!Geom::are_near(prev[Geom::X], pp[Geom::X], 0.2) && 
-             !Geom::are_near(prev[Geom::Y], pp[Geom::Y], step)))
-        {
+            (!Geom::are_near(prev[Geom::X], pp[Geom::X], 0.2) && !Geom::are_near(prev[Geom::Y], pp[Geom::Y], step))) {
             tmp_points.push_back(pp);
             prev = pp;
         }
diff --git a/src/ui/tools/pencil-tool.h b/src/ui/tools/pencil-tool.h
index a4c9cbe39..211d21a1a 100644
--- a/src/ui/tools/pencil-tool.h
+++ b/src/ui/tools/pencil-tool.h
@@ -53,7 +53,7 @@ public:
     Geom::Piecewise<Geom::D2<Geom::SBasis> > sketch_interpolation; // the current proposal from the sketched paths
     unsigned sketch_n; // number of sketches done
     static const std::string prefsPath;
-    SPCurve * curvepressure;
+    SPCurve *curvepressure;
     const std::string& getPrefsPath() override;
 
 protected: