Fix coding style issues in roughen LPE

(bzr r14048)

2 files changed, 110 insertions, 110 deletions

diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index 8cef9a3a3..9d1c3152b 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -39,36 +39,36 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
       unit(_("Unit"), _("Unit"), "unit", &wr, this),
       method(_("Method"), _("Division method"), "method", DMConverter, &wr,
              this, DM_SEGMENTS),
-      maxSegmentSize(_("Max. segment size"), _("Max. segment size"),
-                     "maxSegmentSize", &wr, this, 10.),
+      max_segment_size(_("Max. segment size"), _("Max. segment size"),
+                     "max_segment_size", &wr, this, 10.),
       segments(_("Number of segments"), _("Number of segments"), "segments",
                &wr, this, 2),
-      displaceX(_("Max. displacement in X"), _("Max. displacement in X"),
-                "displaceX", &wr, this, 10.),
-      displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"),
-                "displaceY", &wr, this, 10.),
-      globalRandomize(_("Global randomize"), _("Global randomize"),
-                     "globalRandomize", &wr, this, 1.),
-      shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this,
+      displace_x(_("Max. displacement in X"), _("Max. displacement in X"),
+                "displace_x", &wr, this, 10.),
+      displace_y(_("Max. displacement in Y"), _("Max. displacement in Y"),
+                "displace_y", &wr, this, 10.),
+      global_randomize(_("Global randomize"), _("Global randomize"),
+                      "global_randomize", &wr, this, 1.),
+      shift_nodes(_("Shift nodes"), _("Shift nodes"), "shift_nodes", &wr, this,
                  true),
-      shiftNodeHandles(_("Shift node handles"), _("Shift node handles"),
-                       "shiftNodeHandles", &wr, this, true)
+      shift_node_handles(_("Shift node handles"), _("Shift node handles"),
+                       "shift_node_handles", &wr, this, true)
 {
     registerParameter(&unit);
     registerParameter(&method);
-    registerParameter(&maxSegmentSize);
+    registerParameter(&max_segment_size);
     registerParameter(&segments);
-    registerParameter(&displaceX);
-    registerParameter(&displaceY);
-    registerParameter(&globalRandomize);
-    registerParameter(&shiftNodes);
-    registerParameter(&shiftNodeHandles);
-    displaceX.param_set_range(0., Geom::infinity());
-    displaceY.param_set_range(0., Geom::infinity());
-    globalRandomize.param_set_range(0., Geom::infinity());
-    maxSegmentSize.param_set_range(0., Geom::infinity());
-    maxSegmentSize.param_set_increments(1, 1);
-    maxSegmentSize.param_set_digits(1);
+    registerParameter(&displace_x);
+    registerParameter(&displace_y);
+    registerParameter(&global_randomize);
+    registerParameter(&shift_nodes);
+    registerParameter(&shift_node_handles);
+    displace_x.param_set_range(0., Geom::infinity());
+    displace_y.param_set_range(0., Geom::infinity());
+    global_randomize.param_set_range(0., Geom::infinity());
+    max_segment_size.param_set_range(0., Geom::infinity());
+    max_segment_size.param_set_increments(1, 1);
+    max_segment_size.param_set_digits(1);
     segments.param_set_range(1, Geom::infinity());
     segments.param_set_increments(1, 1);
     segments.param_set_digits(0);
@@ -78,9 +78,9 @@ LPERoughen::~LPERoughen() {}
 
 void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem)
 {
-    displaceX.resetRandomizer();
-    displaceY.resetRandomizer();
-    globalRandomize.resetRandomizer();
+    displace_x.resetRandomizer();
+    displace_y.resetRandomizer();
+    global_randomize.resetRandomizer();
     srand(1);
     SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
     item->apply_to_clippath(item);
@@ -99,37 +99,37 @@ Gtk::Widget *LPERoughen::newWidget()
             Parameter *param = *it;
             Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
             if (param->param_key == "unit") {
-                Gtk::Label *unitLabel = Gtk::manage(new Gtk::Label(
+                Gtk::Label *unit_label = Gtk::manage(new Gtk::Label(
                                                         Glib::ustring(_("<b>Roughen unit</b>")), Gtk::ALIGN_START));
-                unitLabel->set_use_markup(true);
-                vbox->pack_start(*unitLabel, false, false, 2);
+                unit_label->set_use_markup(true);
+                vbox->pack_start(*unit_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
             if (param->param_key == "method") {
-                Gtk::Label *methodLabel = Gtk::manage(new Gtk::Label(
+                Gtk::Label *method_label = Gtk::manage(new Gtk::Label(
                         Glib::ustring(_("<b>Add nodes</b> Subdivide each segment")),
                         Gtk::ALIGN_START));
-                methodLabel->set_use_markup(true);
-                vbox->pack_start(*methodLabel, false, false, 2);
+                method_label->set_use_markup(true);
+                vbox->pack_start(*method_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
-            if (param->param_key == "displaceX") {
-                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+            if (param->param_key == "displace_x") {
+                Gtk::Label *displace_x_label = Gtk::manage(new Gtk::Label(
                                                  Glib::ustring(_("<b>Jitter nodes</b> Move nodes/handles")),
                                                  Gtk::ALIGN_START));
-                displaceXLabel->set_use_markup(true);
-                vbox->pack_start(*displaceXLabel, false, false, 2);
+                displace_x_label->set_use_markup(true);
+                vbox->pack_start(*displace_x_label, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
-            if (param->param_key == "globalRandomize") {
-                Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+            if (param->param_key == "global_randomize") {
+                Gtk::Label *global_rand = Gtk::manage(new Gtk::Label(
                                                  Glib::ustring(_("<b>Extra roughen</b> Add a extra layer of rough")),
                                                  Gtk::ALIGN_START));
-                displaceXLabel->set_use_markup(true);
-                vbox->pack_start(*displaceXLabel, false, false, 2);
+                global_rand->set_use_markup(true);
+                vbox->pack_start(*global_rand, false, false, 2);
                 vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
                                  Gtk::PACK_EXPAND_WIDGET);
             }
@@ -150,23 +150,23 @@ Gtk::Widget *LPERoughen::newWidget()
     return dynamic_cast<Gtk::Widget *>(vbox);
 }
 
-double LPERoughen::sign(double randNumber)
+double LPERoughen::sign(double random_number)
 {
     if (rand() % 100 < 49) {
-        randNumber *= -1.;
+        random_number *= -1.;
     }
-    return randNumber;
+    return random_number;
 }
 
 Geom::Point LPERoughen::randomize()
 {
     Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units;
-    double displaceXParsed = Inkscape::Util::Quantity::convert(
-                                 displaceX * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
-    double displaceYParsed = Inkscape::Util::Quantity::convert(
-                                 displaceY * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
+    double displace_x_parsed = Inkscape::Util::Quantity::convert(
+                                 displace_x * global_randomize, unit.get_abbreviation(), svg_units->abbr);
+    double displace_y_parsed = Inkscape::Util::Quantity::convert(
+                                 displace_y * global_randomize, unit.get_abbreviation(), svg_units->abbr);
 
-    Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed));
+    Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed));
     return output;
 }
 
@@ -193,32 +193,32 @@ void LPERoughen::doEffect(SPCurve *curve)
             }
         }
         Geom::Point initialMove(0, 0);
-        if (shiftNodes) {
+        if (shift_nodes) {
             initialMove = randomize();
         }
         Geom::Point initialPoint = curve_it1->initialPoint() + initialMove;
         nCurve->moveto(initialPoint);
-        Geom::Point A0(0, 0);
-        Geom::Point A1(0, 0);
-        Geom::Point A2(0, 0);
-        Geom::Point A3(0, 0);
+        Geom::Point point0(0, 0);
+        Geom::Point point1(0, 0);
+        Geom::Point point2(0, 0);
+        Geom::Point point3(0, 0);
         bool first = true;
         while (curve_it1 != curve_endit) {
             Geom::CubicBezier const *cubic = NULL;
-            A0 = curve_it1->initialPoint();
-            A1 = curve_it1->initialPoint();
-            A2 = curve_it1->finalPoint();
-            A3 = curve_it1->finalPoint();
+            point0 = curve_it1->initialPoint();
+            point1 = curve_it1->initialPoint();
+            point2 = curve_it1->finalPoint();
+            point3 = curve_it1->finalPoint();
             cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
             if (cubic) {
-                A1 = (*cubic)[1];
-                if (shiftNodes && first) {
-                    A1 = (*cubic)[1] + initialMove;
+                point1 = (*cubic)[1];
+                if (shift_nodes && first) {
+                    point1 = (*cubic)[1] + initialMove;
                 }
-                A2 = (*cubic)[2];
-                nCurve->curveto(A1, A2, A3);
+                point2 = (*cubic)[2];
+                nCurve->curveto(point1, point2, point3);
             } else {
-                nCurve->lineto(A3);
+                nCurve->lineto(point3);
             }
             double length = Inkscape::Util::Quantity::convert(
                                 curve_it1->length(0.001), svg_units->abbr, unit.get_abbreviation());
@@ -226,7 +226,7 @@ void LPERoughen::doEffect(SPCurve *curve)
             if (method == DM_SEGMENTS) {
                 splits = segments;
             } else {
-                splits = ceil(length / maxSegmentSize);
+                splits = ceil(length / max_segment_size);
             }
             for (unsigned int t = splits; t >= 1; t--) {
                 if (t == 1 && splits != 1) {
@@ -265,42 +265,42 @@ SPCurve *LPERoughen::addNodesAndJitter(const Geom::Curve *A, double t)
 {
     SPCurve *out = new SPCurve();
     Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
-    Geom::Point A1(0, 0);
-    Geom::Point A2(0, 0);
-    Geom::Point A3(0, 0);
-    Geom::Point B1(0, 0);
-    Geom::Point B2(0, 0);
-    Geom::Point B3(0, 0);
-    if (shiftNodes) {
-        A3 = randomize();
-        B3 = randomize();
+    Geom::Point point1(0, 0);
+    Geom::Point point2(0, 0);
+    Geom::Point point3(0, 0);
+    Geom::Point point_b1(0, 0);
+    Geom::Point point_b2(0, 0);
+    Geom::Point point_b3(0, 0);
+    if (shift_nodes) {
+        point3 = randomize();
+        point_b3 = randomize();
     }
-    if (shiftNodeHandles) {
-        A1 = randomize();
-        A2 = randomize();
-        B1 = randomize();
-        B2 = randomize();
+    if (shift_node_handles) {
+        point1 = randomize();
+        point2 = randomize();
+        point_b1 = randomize();
+        point_b2 = randomize();
     } else {
-        A2 = A3;
-        B1 = A3;
-        B2 = B3;
+        point2 = point3;
+        point_b1 = point3;
+        point_b2 = point_b3;
     }
     if (cubic) {
         std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
         std::vector<Geom::Point> seg1 = div.first.points(),
                                  seg2 = div.second.points();
         out->moveto(seg1[0]);
-        out->curveto(seg1[1] + A1, seg1[2] + A2, seg1[3] + A3);
-        out->curveto(seg2[1] + B1, seg2[2], seg2[3]);
-    } else if (shiftNodeHandles) {
+        out->curveto(seg1[1] + point1, seg1[2] + point2, seg1[3] + point3);
+        out->curveto(seg2[1] + point_b1, seg2[2], seg2[3]);
+    } else if (shift_node_handles) {
         out->moveto(A->initialPoint());
-        out->curveto(A->pointAt(t / 3) + A1, A->pointAt((t / 3) * 2) + A2,
-                     A->pointAt(t) + A3);
-        out->curveto(A->pointAt(t + (t / 3)) + B1, A->pointAt(t + ((t / 3) * 2)),
+        out->curveto(A->pointAt(t / 3) + point1, A->pointAt((t / 3) * 2) + point2,
+                     A->pointAt(t) + point3);
+        out->curveto(A->pointAt(t + (t / 3)) + point_b1, A->pointAt(t + ((t / 3) * 2)),
                      A->finalPoint());
     } else {
         out->moveto(A->initialPoint());
-        out->lineto(A->pointAt(t) + A3);
+        out->lineto(A->pointAt(t) + point3);
         out->lineto(A->finalPoint());
     }
     return out;
@@ -310,33 +310,33 @@ SPCurve *LPERoughen::jitter(const Geom::Curve *A)
 {
     SPCurve *out = new SPCurve();
     Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
-    Geom::Point A1(0, 0);
-    Geom::Point A2(0, 0);
-    Geom::Point A3(0, 0);
-    if (shiftNodes) {
-        A3 = randomize();
+    Geom::Point point1(0, 0);
+    Geom::Point point2(0, 0);
+    Geom::Point point3(0, 0);
+    if (shift_nodes) {
+        point3 = randomize();
     }
-    if (shiftNodeHandles) {
-        A1 = randomize();
-        A2 = randomize();
+    if (shift_node_handles) {
+        point1 = randomize();
+        point2 = randomize();
     } else {
-        A2 = A3;
+        point2 = point3;
     }
     if (cubic) {
         out->moveto((*cubic)[0]);
-        out->curveto((*cubic)[1] + A1, (*cubic)[2] + A2, (*cubic)[3] + A3);
-    } else if (shiftNodeHandles) {
+        out->curveto((*cubic)[1] + point1, (*cubic)[2] + point2, (*cubic)[3] + point3);
+    } else if (shift_node_handles) {
         out->moveto(A->initialPoint());
-        out->curveto(A->pointAt(0.3333) + A1, A->pointAt(0.6666) + A2,
-                     A->finalPoint() + A3);
+        out->curveto(A->pointAt(0.3333) + point1, A->pointAt(0.6666) + point2,
+                     A->finalPoint() + point3);
     } else {
         out->moveto(A->initialPoint());
-        out->lineto(A->finalPoint() + A3);
+        out->lineto(A->finalPoint() + point3);
     }
     return out;
 }
 
-Geom::Point LPERoughen::tpoint(Geom::Point A, Geom::Point B, double t)
+Geom::Point LPERoughen::tPoint(Geom::Point A, Geom::Point B, double t)
 {
     using Geom::X;
     using Geom::Y;
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index 74331f1ef..ed9f06cf7 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -41,19 +41,19 @@ public:
     virtual void doBeforeEffect(SPLPEItem const * lpeitem);
     virtual SPCurve *addNodesAndJitter(const Geom::Curve *A, double t);
     virtual SPCurve *jitter(const Geom::Curve *A);
-    virtual Geom::Point tpoint(Geom::Point A, Geom::Point B, double t = 0.5);
+    virtual Geom::Point tPoint(Geom::Point A, Geom::Point B, double t = 0.5);
     virtual Gtk::Widget *newWidget();
 
 private:
     UnitParam unit;
     EnumParam<DivisionMethod> method;
-    ScalarParam maxSegmentSize;
+    ScalarParam max_segment_size;
     ScalarParam segments;
-    RandomParam displaceX;
-    RandomParam displaceY;
-    RandomParam globalRandomize;
-    BoolParam shiftNodes;
-    BoolParam shiftNodeHandles;
+    RandomParam displace_x;
+    RandomParam displace_y;
+    RandomParam global_randomize;
+    BoolParam shift_nodes;
+    BoolParam shift_node_handles;
 
     LPERoughen(const LPERoughen &);
     LPERoughen &operator=(const LPERoughen &);