From a9469b254f4d9546f3619a688f845da53b065178 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 9 Apr 2015 21:38:17 +0200 Subject: Fix coding style issues in simplify LPE (bzr r14046) --- src/live_effects/lpe-simplify.cpp | 190 +++++++++++++++++++------------------- src/live_effects/lpe-simplify.h | 48 +++++----- 2 files changed, 119 insertions(+), 119 deletions(-) diff --git a/src/live_effects/lpe-simplify.cpp b/src/live_effects/lpe-simplify.cpp index 1fe18dd5e..7fc20ede1 100644 --- a/src/live_effects/lpe-simplify.cpp +++ b/src/live_effects/lpe-simplify.cpp @@ -27,39 +27,39 @@ namespace LivePathEffect { LPESimplify::LPESimplify(LivePathEffectObject *lpeobject) : Effect(lpeobject), - steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1), - threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003), - smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.), - helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5), - simplifyindividualpaths(_("Paths separately"), _("Simplifying paths (separately)"), "simplifyindividualpaths", &wr, this, false, - "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), - simplifyJustCoalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplifyJustCoalesce", &wr, this, false, - "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) - { - registerParameter(&steps); - registerParameter(&threshold); - registerParameter(&smooth_angles); - registerParameter(&helper_size); - registerParameter(&simplifyindividualpaths); - registerParameter(&simplifyJustCoalesce); + steps(_("Steps:"),_("Change number of simplify steps "), "steps", &wr, this,1), + threshold(_("Roughly threshold:"), _("Roughly threshold:"), "threshold", &wr, this, 0.003), + smooth_angles(_("Smooth angles:"), _("Max degree difference on handles to preform a smooth"), "smooth_angles", &wr, this, 20.), + helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 5), + simplify_individual_paths(_("Paths separately"), _("Simplifying paths (separately)"), "simplify_individual_paths", &wr, this, false, + "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + simplify_just_coalesce(_("Just coalesce"), _("Simplify just coalesce"), "simplify_just_coalesce", &wr, this, false, + "", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")) +{ + registerParameter(&steps); + registerParameter(&threshold); + registerParameter(&smooth_angles); + registerParameter(&helper_size); + registerParameter(&simplify_individual_paths); + registerParameter(&simplify_just_coalesce); - threshold.param_set_range(0.0001, Geom::infinity()); - threshold.param_set_increments(0.0001, 0.0001); - threshold.param_set_digits(6); + threshold.param_set_range(0.0001, Geom::infinity()); + threshold.param_set_increments(0.0001, 0.0001); + threshold.param_set_digits(6); - steps.param_set_range(0, 100); - steps.param_set_increments(1, 1); - steps.param_set_digits(0); + steps.param_set_range(0, 100); + steps.param_set_increments(1, 1); + steps.param_set_digits(0); - smooth_angles.param_set_range(0.0, 365.0); - smooth_angles.param_set_increments(10, 10); - smooth_angles.param_set_digits(2); + smooth_angles.param_set_range(0.0, 365.0); + smooth_angles.param_set_increments(10, 10); + smooth_angles.param_set_digits(2); - helper_size.param_set_range(0.0, 999.0); - helper_size.param_set_increments(5, 5); - helper_size.param_set_digits(2); + helper_size.param_set_range(0.0, 999.0); + helper_size.param_set_increments(5, 5); + helper_size.param_set_digits(2); - radiusHelperNodes = 6.0; + radius_helper_nodes = 6.0; } LPESimplify::~LPESimplify() {} @@ -67,12 +67,12 @@ LPESimplify::~LPESimplify() {} void LPESimplify::doBeforeEffect (SPLPEItem const* lpeitem) { - if(!hp.empty()){ + if(!hp.empty()) { hp.clear(); } bbox = SP_ITEM(lpeitem)->visualBounds(); SPLPEItem * item = const_cast(lpeitem); - radiusHelperNodes = helper_size; + radius_helper_nodes = helper_size; item->apply_to_clippath(item); item->apply_to_mask(item); } @@ -91,9 +91,8 @@ LPESimplify::newWidget() if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if (param->param_key == "simplifyindividualpaths" || - param->param_key == "simplifyJustCoalesce") - { + if (param->param_key == "simplify_individual_paths" || + param->param_key == "simplify_just_coalesce") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { buttons->pack_start(*widg, true, true, 2); @@ -104,13 +103,13 @@ LPESimplify::newWidget() widg->set_has_tooltip(false); } } - } else{ + } else { Glib::ustring * tip = param->param_getTooltip(); if (widg) { - Gtk::HBox * scalarParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = scalarParameter->get_children(); - Gtk::Entry* entryWidg = dynamic_cast(childList[1]); - entryWidg->set_width_chars(8); + Gtk::HBox * horizontal_box = dynamic_cast(widg); + std::vector< Gtk::Widget* > child_list = horizontal_box->get_children(); + Gtk::Entry* entry_widg = dynamic_cast(child_list[1]); + entry_widg->set_width_chars(8); vbox->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); @@ -128,28 +127,29 @@ LPESimplify::newWidget() return dynamic_cast(vbox); } -void -LPESimplify::doEffect(SPCurve *curve) { +void +LPESimplify::doEffect(SPCurve *curve) +{ Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector()); gdouble size = Geom::L2(bbox->dimensions()); //size /= Geom::Affine(0,0,0,0,0,0).descrim(); Path* pathliv = Path_for_pathvector(original_pathv); - if(simplifyindividualpaths){ + if(simplify_individual_paths) { size = Geom::L2(Geom::bounds_fast(original_pathv)->dimensions()); } - for (int unsigned i = 0; i < steps; i++){ - if ( simplifyJustCoalesce ) { - pathliv->Coalesce(threshold * size); - }else{ - pathliv->ConvertEvenLines(threshold * size); - pathliv->Simplify(threshold * size); + for (int unsigned i = 0; i < steps; i++) { + if ( simplify_just_coalesce ) { + pathliv->Coalesce(threshold * size); + } else { + pathliv->ConvertEvenLines(threshold * size); + pathliv->Simplify(threshold * size); } } Geom::PathVector result = Geom::parse_svg_path(pathliv->svg_dump_path()); generateHelperPathAndSmooth(result); curve->set_pathvector(result); SPDesktop* desktop = SP_ACTIVE_DESKTOP; - if(desktop && INK_IS_NODE_TOOL(desktop->event_context)){ + if(desktop && INK_IS_NODE_TOOL(desktop->event_context)) { Inkscape::UI::Tools::NodeTool *nt = static_cast(desktop->event_context); nt->update_helperpath(); } @@ -158,15 +158,15 @@ LPESimplify::doEffect(SPCurve *curve) { void LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) { - if(steps < 1){ + if(steps < 1) { return; } - Geom::PathVector tmpPath; + Geom::PathVector tmp_path; Geom::CubicBezier const *cubic = NULL; for (Geom::PathVector::iterator path_it = result.begin(); path_it != result.end(); ++path_it) { //Si está vacío... - if (path_it->empty()){ - continue; + if (path_it->empty()) { + continue; } //Itreadores Geom::Path::const_iterator curve_it1 = path_it->begin(); // incoming curve @@ -174,68 +174,68 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) Geom::Path::const_iterator curve_endit = path_it->end_default(); // this determines when the loop has to stop SPCurve *nCurve = new SPCurve(); if (path_it->closed()) { - // if the path is closed, maybe we have to stop a bit earlier because the - // closing line segment has zerolength. - const Geom::Curve &closingline = - path_it->back_closed(); // the closing line segment is always of type - // Geom::LineSegment. - if (are_near(closingline.initialPoint(), closingline.finalPoint())) { - // closingline.isDegenerate() did not work, because it only checks for - // *exact* zero length, which goes wrong for relative coordinates and - // rounding errors... - // the closing line segment has zero-length. So stop before that one! - curve_endit = path_it->end_open(); - } + // if the path is closed, maybe we have to stop a bit earlier because the + // closing line segment has zerolength. + const Geom::Curve &closingline = + path_it->back_closed(); // the closing line segment is always of type + // Geom::LineSegment. + if (are_near(closingline.initialPoint(), closingline.finalPoint())) { + // closingline.isDegenerate() did not work, because it only checks for + // *exact* zero length, which goes wrong for relative coordinates and + // rounding errors... + // the closing line segment has zero-length. So stop before that one! + curve_endit = path_it->end_open(); + } } - if(helper_size > 0){ + if(helper_size > 0) { drawNode(curve_it1->initialPoint()); } nCurve->moveto(curve_it1->initialPoint()); Geom::Point start = Geom::Point(0,0); while (curve_it1 != curve_endit) { cubic = dynamic_cast(&*curve_it1); - Geom::Point pointAt1 = curve_it1->initialPoint(); - Geom::Point pointAt2 = curve_it1->finalPoint(); - Geom::Point pointAt3 = curve_it1->finalPoint(); - Geom::Point pointAt4 = curve_it1->finalPoint(); + Geom::Point point_at1 = curve_it1->initialPoint(); + Geom::Point point_at2 = curve_it1->finalPoint(); + Geom::Point point_at3 = curve_it1->finalPoint(); + Geom::Point point_at4 = curve_it1->finalPoint(); if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; } - if(start == Geom::Point(0,0)){ - start = pointAt1; + if(start == Geom::Point(0,0)) { + start = point_at1; } - - if(path_it->closed() && curve_it2 == curve_endit){ - pointAt4 = start; + + if(path_it->closed() && curve_it2 == curve_endit) { + point_at4 = start; } - if(curve_it2 != curve_endit){ + if(curve_it2 != curve_endit) { cubic = dynamic_cast(&*curve_it2); if (cubic) { - pointAt4 = (*cubic)[1]; + point_at4 = (*cubic)[1]; } } - Geom::Ray ray1(pointAt2, pointAt3); - Geom::Ray ray2(pointAt3, pointAt4); + Geom::Ray ray1(point_at2, point_at3); + Geom::Ray ray2(point_at3, point_at4); double angle1 = Geom::rad_to_deg(ray1.angle()); double angle2 = Geom::rad_to_deg(ray2.angle()); - if((smooth_angles >= angle2 - angle1) && !are_near(pointAt4,pointAt3) && !are_near(pointAt2,pointAt3)){ - double dist = Geom::distance(pointAt2,pointAt3); + if((smooth_angles >= angle2 - angle1) && !are_near(point_at4,point_at3) && !are_near(point_at2,point_at3)) { + double dist = Geom::distance(point_at2,point_at3); Geom::Angle angleFixed = ray2.angle(); angleFixed -= Geom::Angle::from_degrees(180.0); - pointAt2 = Geom::Point::polar(angleFixed,dist) + pointAt3; + point_at2 = Geom::Point::polar(angleFixed,dist) + point_at3; } - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); + nCurve->curveto(point_at1, point_at2, curve_it1->finalPoint()); cubic = dynamic_cast(nCurve->last_segment()); if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; if(helper_size > 0) { - if(!are_near((*cubic)[0],(*cubic)[1])){ + if(!are_near((*cubic)[0],(*cubic)[1])) { drawHandle((*cubic)[1]); drawHandleLine((*cubic)[0],(*cubic)[1]); } - if(!are_near((*cubic)[3],(*cubic)[2])){ + if(!are_near((*cubic)[3],(*cubic)[2])) { drawHandle((*cubic)[2]); drawHandleLine((*cubic)[3],(*cubic)[2]); } @@ -250,17 +250,17 @@ LPESimplify::generateHelperPathAndSmooth(Geom::PathVector &result) if (path_it->closed()) { nCurve->closepath_current(); } - tmpPath.push_back(nCurve->get_pathvector()[0]); + tmp_path.push_back(nCurve->get_pathvector()[0]); nCurve->reset(); delete nCurve; } - result = tmpPath; + result = tmp_path; } -void +void LPESimplify::drawNode(Geom::Point p) { - double r = radiusHelperNodes; + double r = radius_helper_nodes; char const * svgd; svgd = "M 0.55,0.5 A 0.05,0.05 0 0 1 0.5,0.55 0.05,0.05 0 0 1 0.45,0.5 0.05,0.05 0 0 1 0.5,0.45 0.05,0.05 0 0 1 0.55,0.5 Z M 0,0 1,0 1,1 0,1 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); @@ -273,7 +273,7 @@ LPESimplify::drawNode(Geom::Point p) void LPESimplify::drawHandle(Geom::Point p) { - double r = radiusHelperNodes; + double r = radius_helper_nodes; char const * svgd; svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); @@ -288,8 +288,8 @@ LPESimplify::drawHandleLine(Geom::Point p,Geom::Point p2) { Geom::Path path; path.start( p ); - double diameter = radiusHelperNodes; - if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)){ + double diameter = radius_helper_nodes; + if(helper_size > 0 && Geom::distance(p,p2) > (diameter * 0.35)) { Geom::Ray ray2(p, p2); p2 = p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35)); } diff --git a/src/live_effects/lpe-simplify.h b/src/live_effects/lpe-simplify.h index c18c3ecdf..294d77b35 100644 --- a/src/live_effects/lpe-simplify.h +++ b/src/live_effects/lpe-simplify.h @@ -14,43 +14,43 @@ namespace Inkscape { namespace LivePathEffect { -class LPESimplify : public Effect , GroupBBoxEffect{ +class LPESimplify : public Effect , GroupBBoxEffect { public: - LPESimplify(LivePathEffectObject *lpeobject); - virtual ~LPESimplify(); + LPESimplify(LivePathEffectObject *lpeobject); + virtual ~LPESimplify(); - virtual void doEffect(SPCurve *curve); + virtual void doEffect(SPCurve *curve); - virtual void doBeforeEffect (SPLPEItem const* lpeitem); + virtual void doBeforeEffect (SPLPEItem const* lpeitem); - virtual void generateHelperPathAndSmooth(Geom::PathVector &result); + virtual void generateHelperPathAndSmooth(Geom::PathVector &result); - virtual Gtk::Widget * newWidget(); + virtual Gtk::Widget * newWidget(); - virtual void drawNode(Geom::Point p); - - virtual void drawHandle(Geom::Point p); + virtual void drawNode(Geom::Point p); - virtual void drawHandleLine(Geom::Point p,Geom::Point p2); + virtual void drawHandle(Geom::Point p); + + virtual void drawHandleLine(Geom::Point p,Geom::Point p2); protected: void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector &hp_vec); private: - ScalarParam steps; - ScalarParam threshold; - ScalarParam smooth_angles; - ScalarParam helper_size; - ToggleButtonParam simplifyindividualpaths; - ToggleButtonParam simplifyJustCoalesce; - - double radiusHelperNodes; - Geom::PathVector hp; - Geom::OptRect bbox; - - LPESimplify(const LPESimplify &); - LPESimplify &operator=(const LPESimplify &); + ScalarParam steps; + ScalarParam threshold; + ScalarParam smooth_angles; + ScalarParam helper_size; + ToggleButtonParam simplify_individual_paths; + ToggleButtonParam simplify_just_coalesce; + + double radius_helper_nodes; + Geom::PathVector hp; + Geom::OptRect bbox; + + LPESimplify(const LPESimplify &); + LPESimplify &operator=(const LPESimplify &); }; -- cgit v1.2.3 From 060edc50dba23acbbb05d6fdd98aa366956337f6 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 00:01:23 +0200 Subject: Fix coding style issues in lattice2 LPE (bzr r14047) --- src/live_effects/lpe-lattice2.cpp | 560 +++++++++++++++++++------------------- src/live_effects/lpe-lattice2.h | 63 ++--- 2 files changed, 310 insertions(+), 313 deletions(-) diff --git a/src/live_effects/lpe-lattice2.cpp b/src/live_effects/lpe-lattice2.cpp index 08bbbd504..abd6e7786 100644 --- a/src/live_effects/lpe-lattice2.cpp +++ b/src/live_effects/lpe-lattice2.cpp @@ -1,6 +1,6 @@ /** \file * LPE implementation - + */ /* * Authors: @@ -11,7 +11,7 @@ * ~suv * Jabiertxo Arraiza * -* Copyright (C) 2007-2008 Authors +* Copyright (C) 2007-2008 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -42,63 +42,63 @@ namespace LivePathEffect { LPELattice2::LPELattice2(LivePathEffectObject *lpeobject) : Effect(lpeobject), - horizontalMirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontalMirror", &wr, this, false), - verticalMirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "verticalMirror", &wr, this, false), - grid_point0(_("Control 0:"), _("Control 0 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint0", &wr, this), - grid_point1(_("Control 1:"), _("Control 1 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint1", &wr, this), - grid_point2(_("Control 2:"), _("Control 2 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint2", &wr, this), - grid_point3(_("Control 3:"), _("Control 3 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint3", &wr, this), - grid_point4(_("Control 4:"), _("Control 4 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint4", &wr, this), - grid_point5(_("Control 5:"), _("Control 5 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint5", &wr, this), - grid_point6(_("Control 6:"), _("Control 6 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint6", &wr, this), - grid_point7(_("Control 7:"), _("Control 7 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint7", &wr, this), - grid_point8x9(_("Control 8x9:"), _("Control 8x9 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint8x9", &wr, this), - grid_point10x11(_("Control 10x11:"), _("Control 10x11 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint10x11", &wr, this), - grid_point12(_("Control 12:"), _("Control 12 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint12", &wr, this), - grid_point13(_("Control 13:"), _("Control 13 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint13", &wr, this), - grid_point14(_("Control 14:"), _("Control 14 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint14", &wr, this), - grid_point15(_("Control 15:"), _("Control 15 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint15", &wr, this), - grid_point16(_("Control 16:"), _("Control 16 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint16", &wr, this), - grid_point17(_("Control 17:"), _("Control 17 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint17", &wr, this), - grid_point18(_("Control 18:"), _("Control 18 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint18", &wr, this), - grid_point19(_("Control 19:"), _("Control 19 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint19", &wr, this), - grid_point20x21(_("Control 20x21:"), _("Control 20x21 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint20x21", &wr, this), - grid_point22x23(_("Control 22x23:"), _("Control 22x23 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint22x23", &wr, this), - grid_point24x26(_("Control 24x26:"), _("Control 24x26 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint24x26", &wr, this), - grid_point25x27(_("Control 25x27:"), _("Control 25x27 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint25x27", &wr, this), - grid_point28x30(_("Control 28x30:"), _("Control 28x30 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint28x30", &wr, this), - grid_point29x31(_("Control 29x31:"), _("Control 29x31 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint29x31", &wr, this), - grid_point32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint32x33x34x35", &wr, this), + horizontal_mirror(_("Mirror movements in horizontal"), _("Mirror movements in horizontal"), "horizontal_mirror", &wr, this, false), + vertical_mirror(_("Mirror movements in vertical"), _("Mirror movements in vertical"), "vertical_mirror", &wr, this, false), + grid_point_0(_("Control 0:"), _("Control 0 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint0", &wr, this), + grid_point_1(_("Control 1:"), _("Control 1 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint1", &wr, this), + grid_point_2(_("Control 2:"), _("Control 2 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint2", &wr, this), + grid_point_3(_("Control 3:"), _("Control 3 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint3", &wr, this), + grid_point_4(_("Control 4:"), _("Control 4 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint4", &wr, this), + grid_point_5(_("Control 5:"), _("Control 5 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint5", &wr, this), + grid_point_6(_("Control 6:"), _("Control 6 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint6", &wr, this), + grid_point_7(_("Control 7:"), _("Control 7 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint7", &wr, this), + grid_point_8x9(_("Control 8x9:"), _("Control 8x9 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint8x9", &wr, this), + grid_point_10x11(_("Control 10x11:"), _("Control 10x11 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint10x11", &wr, this), + grid_point_12(_("Control 12:"), _("Control 12 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint12", &wr, this), + grid_point_13(_("Control 13:"), _("Control 13 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint13", &wr, this), + grid_point_14(_("Control 14:"), _("Control 14 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint14", &wr, this), + grid_point_15(_("Control 15:"), _("Control 15 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint15", &wr, this), + grid_point_16(_("Control 16:"), _("Control 16 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint16", &wr, this), + grid_point_17(_("Control 17:"), _("Control 17 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint17", &wr, this), + grid_point_18(_("Control 18:"), _("Control 18 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint18", &wr, this), + grid_point_19(_("Control 19:"), _("Control 19 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint19", &wr, this), + grid_point_20x21(_("Control 20x21:"), _("Control 20x21 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint20x21", &wr, this), + grid_point_22x23(_("Control 22x23:"), _("Control 22x23 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint22x23", &wr, this), + grid_point_24x26(_("Control 24x26:"), _("Control 24x26 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint24x26", &wr, this), + grid_point_25x27(_("Control 25x27:"), _("Control 25x27 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint25x27", &wr, this), + grid_point_28x30(_("Control 28x30:"), _("Control 28x30 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint28x30", &wr, this), + grid_point_29x31(_("Control 29x31:"), _("Control 29x31 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint29x31", &wr, this), + grid_point_32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "gridpoint32x33x34x35", &wr, this), expanded(false) { // register all your parameters here, so Inkscape knows which parameters this effect has: - registerParameter(&horizontalMirror); - registerParameter(&verticalMirror); - registerParameter(&grid_point0); - registerParameter(&grid_point1); - registerParameter(&grid_point2); - registerParameter(&grid_point3); - registerParameter(&grid_point4); - registerParameter(&grid_point5); - registerParameter(&grid_point6); - registerParameter(&grid_point7); - registerParameter(&grid_point8x9); - registerParameter(&grid_point10x11); - registerParameter(&grid_point12); - registerParameter(&grid_point13); - registerParameter(&grid_point14); - registerParameter(&grid_point15); - registerParameter(&grid_point16); - registerParameter(&grid_point17); - registerParameter(&grid_point18); - registerParameter(&grid_point19); - registerParameter(&grid_point20x21); - registerParameter(&grid_point22x23); - registerParameter(&grid_point24x26); - registerParameter(&grid_point25x27); - registerParameter(&grid_point28x30); - registerParameter(&grid_point29x31); - registerParameter(&grid_point32x33x34x35); + registerParameter(&horizontal_mirror); + registerParameter(&vertical_mirror); + registerParameter(&grid_point_0); + registerParameter(&grid_point_1); + registerParameter(&grid_point_2); + registerParameter(&grid_point_3); + registerParameter(&grid_point_4); + registerParameter(&grid_point_5); + registerParameter(&grid_point_6); + registerParameter(&grid_point_7); + registerParameter(&grid_point_8x9); + registerParameter(&grid_point_10x11); + registerParameter(&grid_point_12); + registerParameter(&grid_point_13); + registerParameter(&grid_point_14); + registerParameter(&grid_point_15); + registerParameter(&grid_point_16); + registerParameter(&grid_point_17); + registerParameter(&grid_point_18); + registerParameter(&grid_point_19); + registerParameter(&grid_point_20x21); + registerParameter(&grid_point_22x23); + registerParameter(&grid_point_24x26); + registerParameter(&grid_point_25x27); + registerParameter(&grid_point_28x30); + registerParameter(&grid_point_29x31); + registerParameter(&grid_point_32x33x34x35); } LPELattice2::~LPELattice2() @@ -113,7 +113,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd PathVector cubic = pathv_to_cubicbezier(pathv); Geom::Piecewise > const &pwd2_in_linear_and_cubic = paths_to_pw(cubic); D2 sb2; - + //Initialisation of the sb2 for(unsigned dim = 0; dim < 2; dim++) { sb2[dim].us = 3; @@ -125,46 +125,46 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd //Grouping the point params in a convenient vector std::vector handles(36); - - handles[0] = grid_point0; - handles[1] = grid_point1; - handles[2] = grid_point2; - handles[3] = grid_point3; - handles[4] = grid_point4; - handles[5] = grid_point5; - handles[6] = grid_point6; - handles[7] = grid_point7; - handles[8] = grid_point8x9; - handles[9] = grid_point8x9; - handles[10] = grid_point10x11; - handles[11] = grid_point10x11; - handles[12] = grid_point12; - handles[13] = grid_point13; - handles[14] = grid_point14; - handles[15] = grid_point15; - handles[16] = grid_point16; - handles[17] = grid_point17; - handles[18] = grid_point18; - handles[19] = grid_point19; - handles[20] = grid_point20x21; - handles[21] = grid_point20x21; - handles[22] = grid_point22x23; - handles[23] = grid_point22x23; - handles[24] = grid_point24x26; - handles[25] = grid_point25x27; - handles[26] = grid_point24x26; - handles[27] = grid_point25x27; - handles[28] = grid_point28x30; - handles[29] = grid_point29x31; - handles[30] = grid_point28x30; - handles[31] = grid_point29x31; - handles[32] = grid_point32x33x34x35; - handles[33] = grid_point32x33x34x35; - handles[34] = grid_point32x33x34x35; - handles[35] = grid_point32x33x34x35; + + handles[0] = grid_point_0; + handles[1] = grid_point_1; + handles[2] = grid_point_2; + handles[3] = grid_point_3; + handles[4] = grid_point_4; + handles[5] = grid_point_5; + handles[6] = grid_point_6; + handles[7] = grid_point_7; + handles[8] = grid_point_8x9; + handles[9] = grid_point_8x9; + handles[10] = grid_point_10x11; + handles[11] = grid_point_10x11; + handles[12] = grid_point_12; + handles[13] = grid_point_13; + handles[14] = grid_point_14; + handles[15] = grid_point_15; + handles[16] = grid_point_16; + handles[17] = grid_point_17; + handles[18] = grid_point_18; + handles[19] = grid_point_19; + handles[20] = grid_point_20x21; + handles[21] = grid_point_20x21; + handles[22] = grid_point_22x23; + handles[23] = grid_point_22x23; + handles[24] = grid_point_24x26; + handles[25] = grid_point_25x27; + handles[26] = grid_point_24x26; + handles[27] = grid_point_25x27; + handles[28] = grid_point_28x30; + handles[29] = grid_point_29x31; + handles[30] = grid_point_28x30; + handles[31] = grid_point_29x31; + handles[32] = grid_point_32x33x34x35; + handles[33] = grid_point_32x33x34x35; + handles[34] = grid_point_32x33x34x35; + handles[35] = grid_point_32x33x34x35; Geom::Point origin = Geom::Point(boundingbox_X.min(),boundingbox_Y.min()); - + double width = boundingbox_X.extent(); double height = boundingbox_Y.extent(); @@ -178,16 +178,16 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd for(unsigned iu = 0; iu < 2; iu++) { unsigned corner = iu + 2*iv; unsigned i = ui + vi*sb2[dim].us; - + //This is the offset from the Upperleft point Geom::Point base( (ui + iu*(4-2*ui))*width/4., (vi + iv*(4-2*vi))*height/4.); - + //Special action for corners if(vi == 0 && ui == 0) { base = Geom::Point(0,0); } - + // i = Upperleft corner of the considerated rectangle // corner = actual corner of the rectangle // origin = Upperleft point @@ -198,7 +198,7 @@ LPELattice2::doEffect_pwd2 (Geom::Piecewise > const & pwd } } } - + Piecewise > output; output.push_cut(0.); for(unsigned i = 0; i < pwd2_in_linear_and_cubic.size(); i++) { @@ -228,28 +228,28 @@ LPELattice2::newWidget() vbox->set_homogeneous(false); vbox->set_spacing(6); Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::VBox * vboxExpander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) ); - vboxExpander->set_border_width(0); - vboxExpander->set_spacing(2); - Gtk::Button * resetButton = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid")))); - resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid)); - resetButton->set_size_request(140,30); + Gtk::VBox * vbox_expander = Gtk::manage( new Gtk::VBox(Effect::newWidget()) ); + vbox_expander->set_border_width(0); + vbox_expander->set_spacing(2); + Gtk::Button * reset_button = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset grid")))); + reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPELattice2::resetGrid)); + reset_button->set_size_request(140,30); vbox->pack_start(*hbox, true,true,2); - hbox->pack_start(*resetButton, false, false,2); + hbox->pack_start(*reset_button, false, false,2); std::vector::iterator it = param_vector.begin(); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if(param->param_key == "grid"){ + if(param->param_key == "grid") { widg = NULL; } Glib::ustring * tip = param->param_getTooltip(); if (widg) { - if (param->param_key == "horizontalMirror" || param->param_key == "verticalMirror") { + if (param->param_key == "horizontal_mirror" || param->param_key == "vertical_mirror") { vbox->pack_start(*widg, true, true, 2); } else { - vboxExpander->pack_start(*widg, true, true, 2); + vbox_expander->pack_start(*widg, true, true, 2); } if (tip) { widg->set_tooltip_text(*tip); @@ -262,63 +262,65 @@ LPELattice2::newWidget() ++it; } - + expander = Gtk::manage(new Gtk::Expander(Glib::ustring(_("Show Points")))); - expander->add(*vboxExpander); + expander->add(*vbox_expander); expander->set_expanded(expanded); vbox->pack_start(*expander, true, true, 2); - expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::on_expander_changed) ); + expander->property_expanded().signal_changed().connect(sigc::mem_fun(*this, &LPELattice2::onExpanderChanged) ); return dynamic_cast(vbox); } void -LPELattice2::on_expander_changed() +LPELattice2::onExpanderChanged() { expanded = expander->get_expanded(); - if(expander->get_expanded()){ + if(expander->get_expanded()) { expander->set_label (Glib::ustring(_("Hide Points"))); } else { expander->set_label (Glib::ustring(_("Show Points"))); } } void -LPELattice2::vertical(PointParam ¶mA, PointParam ¶mB, Geom::Line vert){ - Geom::Point A = paramA; - Geom::Point B = paramB; +LPELattice2::vertical(PointParam ¶m_one, PointParam ¶m_two, Geom::Line vert) +{ + Geom::Point A = param_one; + Geom::Point B = param_two; double Y = (A[Geom::Y] + B[Geom::Y])/2; A[Geom::Y] = Y; B[Geom::Y] = Y; Geom::Point nearest = vert.pointAt(vert.nearestPoint(A)); - double distA = Geom::distance(A,nearest); - double distB = Geom::distance(B,nearest); - double distanceMed = (distA + distB)/2; - if(A[Geom::X] > B[Geom::X]){ - distanceMed *= -1; + double distance_one = Geom::distance(A,nearest); + double distance_two = Geom::distance(B,nearest); + double distance_middle = (distance_one + distance_two)/2; + if(A[Geom::X] > B[Geom::X]) { + distance_middle *= -1; } - A[Geom::X] = nearest[Geom::X] - distanceMed; - B[Geom::X] = nearest[Geom::X] + distanceMed; - paramA.param_setValue(A, true); - paramB.param_setValue(B, true); + A[Geom::X] = nearest[Geom::X] - distance_middle; + B[Geom::X] = nearest[Geom::X] + distance_middle; + param_one.param_setValue(A, true); + param_two.param_setValue(B, true); } void -LPELattice2::horizontal(PointParam ¶mA, PointParam ¶mB, Geom::Line horiz){ - Geom::Point A = paramA; - Geom::Point B = paramB; +LPELattice2::horizontal(PointParam ¶m_one, PointParam ¶m_two, Geom::Line horiz) +{ + Geom::Point A = param_one; + Geom::Point B = param_two; double X = (A[Geom::X] + B[Geom::X])/2; A[Geom::X] = X; B[Geom::X] = X; Geom::Point nearest = horiz.pointAt(horiz.nearestPoint(A)); - double distA = Geom::distance(A,nearest); - double distB = Geom::distance(B,nearest); - double distanceMed = (distA + distB)/2; - if(A[Geom::Y] > B[Geom::Y]){ - distanceMed *= -1; + double distance_one = Geom::distance(A,nearest); + double distance_two = Geom::distance(B,nearest); + double distance_middle = (distance_one + distance_two)/2; + if(A[Geom::Y] > B[Geom::Y]) { + distance_middle *= -1; } - A[Geom::Y] = nearest[Geom::Y] - distanceMed; - B[Geom::Y] = nearest[Geom::Y] + distanceMed; - paramA.param_setValue(A, true); - paramB.param_setValue(B, true); + A[Geom::Y] = nearest[Geom::Y] - distance_middle; + B[Geom::Y] = nearest[Geom::Y] + distance_middle; + param_one.param_setValue(A, true); + param_two.param_setValue(B, true); } void @@ -326,31 +328,31 @@ LPELattice2::doBeforeEffect (SPLPEItem const* lpeitem) { original_bbox(lpeitem); setDefaults(); - Geom::Line vert(grid_point8x9.param_get_default(),grid_point10x11.param_get_default()); - Geom::Line horiz(grid_point24x26.param_get_default(),grid_point25x27.param_get_default()); - if(verticalMirror){ - vertical(grid_point0, grid_point1,vert); - vertical(grid_point2, grid_point3,vert); - vertical(grid_point4, grid_point5,vert); - vertical(grid_point6, grid_point7,vert); - vertical(grid_point12, grid_point13,vert); - vertical(grid_point14, grid_point15,vert); - vertical(grid_point16, grid_point17,vert); - vertical(grid_point18, grid_point19,vert); - vertical(grid_point24x26, grid_point25x27,vert); - vertical(grid_point28x30, grid_point29x31,vert); + Geom::Line vert(grid_point_8x9.param_get_default(),grid_point_10x11.param_get_default()); + Geom::Line horiz(grid_point_24x26.param_get_default(),grid_point_25x27.param_get_default()); + if(vertical_mirror) { + vertical(grid_point_0, grid_point_1,vert); + vertical(grid_point_2, grid_point_3,vert); + vertical(grid_point_4, grid_point_5,vert); + vertical(grid_point_6, grid_point_7,vert); + vertical(grid_point_12, grid_point_13,vert); + vertical(grid_point_14, grid_point_15,vert); + vertical(grid_point_16, grid_point_17,vert); + vertical(grid_point_18, grid_point_19,vert); + vertical(grid_point_24x26, grid_point_25x27,vert); + vertical(grid_point_28x30, grid_point_29x31,vert); } - if(horizontalMirror){ - horizontal(grid_point0, grid_point2,horiz); - horizontal(grid_point1, grid_point3,horiz); - horizontal(grid_point4, grid_point6,horiz); - horizontal(grid_point5, grid_point7,horiz); - horizontal(grid_point8x9, grid_point10x11,horiz); - horizontal(grid_point12, grid_point14,horiz); - horizontal(grid_point13, grid_point15,horiz); - horizontal(grid_point16, grid_point18,horiz); - horizontal(grid_point17, grid_point19,horiz); - horizontal(grid_point20x21, grid_point22x23,horiz); + if(horizontal_mirror) { + horizontal(grid_point_0, grid_point_2,horiz); + horizontal(grid_point_1, grid_point_3,horiz); + horizontal(grid_point_4, grid_point_6,horiz); + horizontal(grid_point_5, grid_point_7,horiz); + horizontal(grid_point_8x9, grid_point_10x11,horiz); + horizontal(grid_point_12, grid_point_14,horiz); + horizontal(grid_point_13, grid_point_15,horiz); + horizontal(grid_point_16, grid_point_18,horiz); + horizontal(grid_point_17, grid_point_19,horiz); + horizontal(grid_point_20x21, grid_point_22x23,horiz); } SPLPEItem * item = const_cast(lpeitem); item->apply_to_clippath(item); @@ -385,111 +387,111 @@ LPELattice2::setDefaults() (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); Geom::Point gp8x9((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*0+boundingbox_Y.min()); Geom::Point gp10x11((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*4+boundingbox_Y.min()); Geom::Point gp12((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp13((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp14((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp15((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp16((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp17((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp18((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp19((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp20x21((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*1+boundingbox_Y.min()); Geom::Point gp22x23((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*3+boundingbox_Y.min()); Geom::Point gp24x26((boundingbox_X.max()-boundingbox_X.min())/4*0+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp25x27((boundingbox_X.max()-boundingbox_X.min())/4*4+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp28x30((boundingbox_X.max()-boundingbox_X.min())/4*1+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp29x31((boundingbox_X.max()-boundingbox_X.min())/4*3+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); Geom::Point gp32x33x34x35((boundingbox_X.max()-boundingbox_X.min())/4*2+boundingbox_X.min(), - (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); - - grid_point0.param_update_default(gp0); - grid_point1.param_update_default(gp1); - grid_point2.param_update_default(gp2); - grid_point3.param_update_default(gp3); - grid_point4.param_update_default(gp4); - grid_point5.param_update_default(gp5); - grid_point6.param_update_default(gp6); - grid_point7.param_update_default(gp7); - grid_point8x9.param_update_default(gp8x9); - grid_point10x11.param_update_default(gp10x11); - grid_point12.param_update_default(gp12); - grid_point13.param_update_default(gp13); - grid_point14.param_update_default(gp14); - grid_point15.param_update_default(gp15); - grid_point16.param_update_default(gp16); - grid_point17.param_update_default(gp17); - grid_point18.param_update_default(gp18); - grid_point19.param_update_default(gp19); - grid_point20x21.param_update_default(gp20x21); - grid_point22x23.param_update_default(gp22x23); - grid_point24x26.param_update_default(gp24x26); - grid_point25x27.param_update_default(gp25x27); - grid_point28x30.param_update_default(gp28x30); - grid_point29x31.param_update_default(gp29x31); - grid_point32x33x34x35.param_update_default(gp32x33x34x35); + (boundingbox_Y.max()-boundingbox_Y.min())/4*2+boundingbox_Y.min()); + + grid_point_0.param_update_default(gp0); + grid_point_1.param_update_default(gp1); + grid_point_2.param_update_default(gp2); + grid_point_3.param_update_default(gp3); + grid_point_4.param_update_default(gp4); + grid_point_5.param_update_default(gp5); + grid_point_6.param_update_default(gp6); + grid_point_7.param_update_default(gp7); + grid_point_8x9.param_update_default(gp8x9); + grid_point_10x11.param_update_default(gp10x11); + grid_point_12.param_update_default(gp12); + grid_point_13.param_update_default(gp13); + grid_point_14.param_update_default(gp14); + grid_point_15.param_update_default(gp15); + grid_point_16.param_update_default(gp16); + grid_point_17.param_update_default(gp17); + grid_point_18.param_update_default(gp18); + grid_point_19.param_update_default(gp19); + grid_point_20x21.param_update_default(gp20x21); + grid_point_22x23.param_update_default(gp22x23); + grid_point_24x26.param_update_default(gp24x26); + grid_point_25x27.param_update_default(gp25x27); + grid_point_28x30.param_update_default(gp28x30); + grid_point_29x31.param_update_default(gp29x31); + grid_point_32x33x34x35.param_update_default(gp32x33x34x35); } void LPELattice2::resetGrid() { - grid_point0.param_set_default(); - grid_point1.param_set_default(); - grid_point2.param_set_default(); - grid_point3.param_set_default(); - grid_point4.param_set_default(); - grid_point5.param_set_default(); - grid_point6.param_set_default(); - grid_point7.param_set_default(); - grid_point8x9.param_set_default(); - grid_point10x11.param_set_default(); - grid_point12.param_set_default(); - grid_point13.param_set_default(); - grid_point14.param_set_default(); - grid_point15.param_set_default(); - grid_point16.param_set_default(); - grid_point17.param_set_default(); - grid_point18.param_set_default(); - grid_point19.param_set_default(); - grid_point20x21.param_set_default(); - grid_point22x23.param_set_default(); - grid_point24x26.param_set_default(); - grid_point25x27.param_set_default(); - grid_point28x30.param_set_default(); - grid_point29x31.param_set_default(); - grid_point32x33x34x35.param_set_default(); + grid_point_0.param_set_default(); + grid_point_1.param_set_default(); + grid_point_2.param_set_default(); + grid_point_3.param_set_default(); + grid_point_4.param_set_default(); + grid_point_5.param_set_default(); + grid_point_6.param_set_default(); + grid_point_7.param_set_default(); + grid_point_8x9.param_set_default(); + grid_point_10x11.param_set_default(); + grid_point_12.param_set_default(); + grid_point_13.param_set_default(); + grid_point_14.param_set_default(); + grid_point_15.param_set_default(); + grid_point_16.param_set_default(); + grid_point_17.param_set_default(); + grid_point_18.param_set_default(); + grid_point_19.param_set_default(); + grid_point_20x21.param_set_default(); + grid_point_22x23.param_set_default(); + grid_point_24x26.param_set_default(); + grid_point_25x27.param_set_default(); + grid_point_28x30.param_set_default(); + grid_point_29x31.param_set_default(); + grid_point_32x33x34x35.param_set_default(); } void @@ -519,55 +521,55 @@ LPELattice2::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vectorget_pathvector()); } diff --git a/src/live_effects/lpe-lattice2.h b/src/live_effects/lpe-lattice2.h index 086bdab7e..ff2e75641 100644 --- a/src/live_effects/lpe-lattice2.h +++ b/src/live_effects/lpe-lattice2.h @@ -34,7 +34,7 @@ public: virtual ~LPELattice2(); virtual Geom::Piecewise > doEffect_pwd2 (Geom::Piecewise > const & pwd2_in); - + virtual void resetDefaults(SPItem const* item); virtual void doBeforeEffect(SPLPEItem const* lpeitem); @@ -49,46 +49,41 @@ public: virtual void setDefaults(); - virtual void on_expander_changed(); + virtual void onExpanderChanged(); virtual void resetGrid(); - //virtual void original_bbox(SPLPEItem const* lpeitem, bool absolute = false); - - //virtual void addCanvasIndicators(SPLPEItem const*/*lpeitem*/, std::vector &/*hp_vec*/); - - //virtual std::vector getHelperPaths(SPLPEItem const* lpeitem); protected: void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector &hp_vec); private: - BoolParam horizontalMirror; - BoolParam verticalMirror; - PointParam grid_point0; - PointParam grid_point1; - PointParam grid_point2; - PointParam grid_point3; - PointParam grid_point4; - PointParam grid_point5; - PointParam grid_point6; - PointParam grid_point7; - PointParam grid_point8x9; - PointParam grid_point10x11; - PointParam grid_point12; - PointParam grid_point13; - PointParam grid_point14; - PointParam grid_point15; - PointParam grid_point16; - PointParam grid_point17; - PointParam grid_point18; - PointParam grid_point19; - PointParam grid_point20x21; - PointParam grid_point22x23; - PointParam grid_point24x26; - PointParam grid_point25x27; - PointParam grid_point28x30; - PointParam grid_point29x31; - PointParam grid_point32x33x34x35; + BoolParam horizontal_mirror; + BoolParam vertical_mirror; + PointParam grid_point_0; + PointParam grid_point_1; + PointParam grid_point_2; + PointParam grid_point_3; + PointParam grid_point_4; + PointParam grid_point_5; + PointParam grid_point_6; + PointParam grid_point_7; + PointParam grid_point_8x9; + PointParam grid_point_10x11; + PointParam grid_point_12; + PointParam grid_point_13; + PointParam grid_point_14; + PointParam grid_point_15; + PointParam grid_point_16; + PointParam grid_point_17; + PointParam grid_point_18; + PointParam grid_point_19; + PointParam grid_point_20x21; + PointParam grid_point_22x23; + PointParam grid_point_24x26; + PointParam grid_point_25x27; + PointParam grid_point_28x30; + PointParam grid_point_29x31; + PointParam grid_point_32x33x34x35; bool expanded; Gtk::Expander * expander; -- cgit v1.2.3 From 857b0edbfff90b9271be66f0ab8b86ff214b8740 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 00:17:05 +0200 Subject: Fix coding style issues in roughen LPE (bzr r14048) --- src/live_effects/lpe-roughen.cpp | 206 +++++++++++++++++++-------------------- src/live_effects/lpe-roughen.h | 14 +-- 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(lpeitem); item->apply_to_clippath(item); @@ -99,37 +99,37 @@ Gtk::Widget *LPERoughen::newWidget() Parameter *param = *it; Gtk::Widget *widg = dynamic_cast(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(_("Roughen unit")), 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(_("Add nodes 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(_("Jitter nodes 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(_("Extra roughen 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(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(&*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(&*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 div = cubic->subdivide(t); std::vector 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(&*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 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 &); -- cgit v1.2.3 From 9c184a450842df13226e870e6e50c0515e53a659 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 16:51:16 +0200 Subject: Fixes bug #1409568: added possibility to use multiple pens (when using pen plotters, cutting plotters ignore it) via marking layers with pen information Fixed bugs: - https://launchpad.net/bugs/1409568 (bzr r14049) --- share/extensions/hpgl_encoder.py | 76 +++++++++++++++++++++++----------------- share/extensions/hpgl_output.py | 4 +-- share/extensions/plotter.py | 15 ++++---- 3 files changed, 53 insertions(+), 42 deletions(-) diff --git a/share/extensions/hpgl_encoder.py b/share/extensions/hpgl_encoder.py index a16561e97..75c5fa889 100644 --- a/share/extensions/hpgl_encoder.py +++ b/share/extensions/hpgl_encoder.py @@ -23,7 +23,6 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import math import re import string -#from StringIO import StringIO # local libraries import bezmisc import cspsubdiv @@ -66,6 +65,7 @@ class hpglEncoder: self.sizeY = 'False' self.dryRun = True self.lastPoint = [0, 0, 0] + self.lastPen = -1 self.offsetX = 0 self.offsetY = 0 self.scaleX = self.options.resolutionX / effect.unittouu("1.0in") # dots per inch to dots per user unit @@ -109,7 +109,7 @@ class hpglEncoder: # dryRun to find edges groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, 0.0], [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, 0.0]] groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')')) - self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]] + self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]] self.processGroups(self.doc, groupmat) if self.divergenceX == 'False' or self.divergenceY == 'False' or self.sizeX == 'False' or self.sizeY == 'False': raise Exception('NO_PATHS') @@ -156,11 +156,11 @@ class hpglEncoder: groupmat = [[self.mirrorX * self.scaleX * self.viewBoxTransformX, 0.0, -self.divergenceX + self.offsetX], [0.0, self.mirrorY * self.scaleY * self.viewBoxTransformY, -self.divergenceY + self.offsetY]] groupmat = simpletransform.composeTransform(groupmat, simpletransform.parseTransform('rotate(' + self.options.orientation + ')')) - self.vData = [['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0], ['', -1.0, -1.0]] + self.vData = [['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0], ['', 'False', 0, 0]] # add move to zero point and precut if self.toolOffset > 0.0 and self.options.precut: if self.options.center: - # position precut outside of drawing plus one times the tooloffset + # position precut outside of drawing plus one time the tooloffset if self.offsetX >= 0.0: precutX = self.offsetX + self.toolOffset else: @@ -169,17 +169,15 @@ class hpglEncoder: precutY = self.offsetY + self.toolOffset else: precutY = self.offsetY - self.toolOffset - self.processOffset('PU', precutX, precutY) - self.processOffset('PD', precutX, precutY + self.toolOffset * 8) + self.processOffset('PU', precutX, precutY, self.options.pen) + self.processOffset('PD', precutX, precutY + self.toolOffset * 8, self.options.pen) else: - self.processOffset('PU', 0, 0) - self.processOffset('PD', 0, self.toolOffset * 8) - else: - self.processOffset('PU', 0, 0) + self.processOffset('PU', 0, 0, self.options.pen) + self.processOffset('PD', 0, self.toolOffset * 8, self.options.pen) # start conversion self.processGroups(self.doc, groupmat) # shift an empty node in in order to process last node in cache - self.processOffset('PU', 0, 0) + self.processOffset('PU', 0, 0, 0) if self.options.debug: return self.hpgl, self else: @@ -190,7 +188,7 @@ class hpglEncoder: paths = [] for node in doc: if (node.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(node)) or node.tag == inkex.addNS('path', 'svg'): - paths.append([node.tag, node, self.mergeTransform(node, groupmat)]) + paths.append([node.tag, node, self.mergeTransform(node, groupmat), self.getPenNumber(node)]) doc = '' hasGroups = True while hasGroups: @@ -200,11 +198,19 @@ class hpglEncoder: hasGroups = True for path in paths[i][1]: if (path.tag == inkex.addNS('g', 'svg') and self.isGroupVisible(path)) or path.tag == inkex.addNS('path', 'svg'): - paths.append([path.tag, path, self.mergeTransform(path, paths[i][2])]) + paths.insert(i + 1, [path.tag, path, self.mergeTransform(path, paths[i][2]), paths[i][3]]) paths[i][0] = '' for node in paths: if node[0] == inkex.addNS('path', 'svg'): - self.processPath(node[1], node[2]) + self.processPath(node[1], node[2], node[3]) + + def getPenNumber(self, doc): + penNum = str(doc.get('{' + inkex.NSS['inkscape'] + '}label')).lower().strip(' \t\n\r') + if re.search(r'( |\A)pen *\d+( |\Z)', penNum): + penNum = re.sub(r'(.* |\A)pen *(\d+)( .*|\Z)', r'\2', penNum, 1) + return int(penNum) + else: + return self.options.pen def mergeTransform(self, doc, matrix): # get and merge two matrixes into one @@ -222,7 +228,7 @@ class hpglEncoder: return False return True - def processPath(self, node, mat): + def processPath(self, node, mat, pen): # process path path = node.get('d') if path: @@ -239,7 +245,7 @@ class hpglEncoder: posX, posY = singlePathPoint[1] # check if point is repeating, if so, ignore if int(round(posX)) != int(round(oldPosX)) or int(round(posY)) != int(round(oldPosY)): - self.processOffset(cmd, posX, posY) + self.processOffset(cmd, posX, posY, pen) cmd = 'PD' oldPosX = posX oldPosY = posY @@ -255,10 +261,10 @@ class hpglEncoder: overcutLength += self.getLength(oldPosX, oldPosY, posX, posY) if overcutLength >= self.overcut: newLength = self.changeLength(oldPosX, oldPosY, posX, posY, - (overcutLength - self.overcut)) - self.processOffset(cmd, newLength[0], newLength[1]) + self.processOffset(cmd, newLength[0], newLength[1], pen) break else: - self.processOffset(cmd, posX, posY) + self.processOffset(cmd, posX, posY, pen) oldPosX = posX oldPosY = posY @@ -277,34 +283,34 @@ class hpglEncoder: y = y2 + (y2 - y1) / self.getLength(x1, y1, x2, y2, False) * offset return [x, y] - def processOffset(self, cmd, posX, posY): + def processOffset(self, cmd, posX, posY, pen): # calculate offset correction (or dont) if self.toolOffset == 0.0 or self.dryRun: - self.storePoint(cmd, posX, posY) + self.storePoint(cmd, posX, posY, pen) else: # insert data into cache self.vData.pop(0) - self.vData.insert(3, [cmd, posX, posY]) + self.vData.insert(3, [cmd, posX, posY, pen]) # decide if enough data is availabe - if self.vData[2][1] != -1.0: - if self.vData[1][1] == -1.0: - self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2]) + if self.vData[2][1] != 'False': + if self.vData[1][1] == 'False': + self.storePoint(self.vData[2][0], self.vData[2][1], self.vData[2][2], self.vData[2][3]) else: # perform tool offset correction (It's a *tad* complicated, if you want to understand it draw the data as lines on paper) if self.vData[2][0] == 'PD': # If the 3rd entry in the cache is a pen down command make the line longer by the tool offset pointThree = self.changeLength(self.vData[1][1], self.vData[1][2], self.vData[2][1], self.vData[2][2], self.toolOffset) - self.storePoint('PD', pointThree[0], pointThree[1]) - elif self.vData[0][1] != -1.0: + self.storePoint('PD', pointThree[0], pointThree[1], self.vData[2][3]) + elif self.vData[0][1] != 'False': # Elif the 1st entry in the cache is filled with data and the 3rd entry is a pen up command shift # the 3rd entry by the current tool offset position according to the 2nd command pointThree = self.changeLength(self.vData[0][1], self.vData[0][2], self.vData[1][1], self.vData[1][2], self.toolOffset) pointThree[0] = self.vData[2][1] - (self.vData[1][1] - pointThree[0]) pointThree[1] = self.vData[2][2] - (self.vData[1][2] - pointThree[1]) - self.storePoint('PU', pointThree[0], pointThree[1]) + self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3]) else: # Else just write the 3rd entry pointThree = [self.vData[2][1], self.vData[2][2]] - self.storePoint('PU', pointThree[0], pointThree[1]) + self.storePoint('PU', pointThree[0], pointThree[1], self.vData[2][3]) if self.vData[3][0] == 'PD': # If the 4th entry in the cache is a pen down command guide tool to next line with a circle between the prolonged 3rd and 4th entry if self.getLength(self.vData[2][1], self.vData[2][2], self.vData[3][1], self.vData[3][2]) >= self.toolOffset: @@ -324,16 +330,16 @@ class hpglEncoder: if angleVector >= 0: angle = angleStart + self.toolOffsetFlat while angle < angleStart + angleVector: - self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset) + self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3]) angle += self.toolOffsetFlat else: angle = angleStart - self.toolOffsetFlat while angle > angleStart + angleVector: - self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset) + self.storePoint('PD', self.vData[2][1] + math.cos(angle) * self.toolOffset, self.vData[2][2] + math.sin(angle) * self.toolOffset, self.vData[2][3]) angle -= self.toolOffsetFlat - self.storePoint('PD', pointFour[0], pointFour[1]) + self.storePoint('PD', pointFour[0], pointFour[1], self.vData[3][3]) - def storePoint(self, command, x, y): + def storePoint(self, command, x, y, pen): x = int(round(x)) y = int(round(y)) # skip when no change in movement @@ -357,11 +363,15 @@ class hpglEncoder: x = 0 if y < 0: y = 0 + # select correct pen + if self.lastPen != pen: + self.hpgl += ';SP%d' % pen # do not repeat command - if command == 'PD' and self.lastPoint[0] == 'PD': + if command == 'PD' and self.lastPoint[0] == 'PD' and self.lastPen == pen: self.hpgl += ',%d,%d' % (x, y) else: self.hpgl += ';%s%d,%d' % (command, x, y) + self.lastPen = pen self.lastPoint = [command, x, y] # vim: expandtab shiftwidth=4 tabstop=8 softtabstop=4 fileencoding=utf-8 textwidth=99 \ No newline at end of file diff --git a/share/extensions/hpgl_output.py b/share/extensions/hpgl_output.py index c6713cb65..fc4f248af 100755 --- a/share/extensions/hpgl_output.py +++ b/share/extensions/hpgl_output.py @@ -62,12 +62,12 @@ class HpglOutput(inkex.Effect): type, value, traceback = sys.exc_info() raise ValueError, ("", type, value), traceback # convert raw HPGL to HPGL - hpglInit = 'IN;SP%d' % self.options.pen + hpglInit = 'IN' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN;' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; ' def output(self): # print to file diff --git a/share/extensions/plotter.py b/share/extensions/plotter.py index 7e24d0824..2e4fd5dd5 100644 --- a/share/extensions/plotter.py +++ b/share/extensions/plotter.py @@ -98,12 +98,12 @@ class Plot(inkex.Effect): def convertToHpgl(self): # convert raw HPGL to HPGL - hpglInit = 'IN;SP%d' % self.options.pen + hpglInit = 'IN' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;IN; ' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;IN; ' def convertToDmpl(self): # convert HPGL to DMPL @@ -119,22 +119,23 @@ class Plot(inkex.Effect): # Z = Reset plotter # n,n, = Coordinate pair self.hpgl = self.hpgl.replace(';', ',') + self.hpgl = self.hpgl.replace('SP', 'P') self.hpgl = self.hpgl.replace('PU', 'U') self.hpgl = self.hpgl.replace('PD', 'D') - dmplInit = ';:HAL0P%d' % self.options.pen + dmplInit = ';:HAL0' if self.options.speed > 0: dmplInit += 'V%d' % self.options.speed dmplInit += 'EC1' - self.hpgl = dmplInit + self.hpgl[1:] + ',U0,0,P0Z ' + self.hpgl = dmplInit + self.hpgl[1:] + ',P0,U0,0,Z ' def convertToKNK(self): # convert HPGL to KNK Plotter Language - hpglInit = 'ZG;SP%d' % self.options.pen + hpglInit = 'ZG' if self.options.force > 0: hpglInit += ';FS%d' % self.options.force if self.options.speed > 0: hpglInit += ';VS%d' % self.options.speed - self.hpgl = hpglInit + self.hpgl + ';PU0,0;SP0;@ ' + self.hpgl = hpglInit + self.hpgl + ';SP0;PU0,0;@ ' def sendHpglToSerial(self): # gracefully exit script when pySerial is missing @@ -223,7 +224,7 @@ class Plot(inkex.Effect): inkex.errormsg(' Flatness: ' + str(debugObject.flat) + ' plotter steps') inkex.errormsg(' Tool offset flatness: ' + str(debugObject.toolOffsetFlat) + ' plotter steps') inkex.errormsg("\n" + self.options.commandLanguage + " data:\n") - inkex.errormsg(self.hpgl) + inkex.errormsg(self.options.initCommands + self.hpgl) if __name__ == '__main__': # start extension -- cgit v1.2.3 From a729eeb50789ae7bc4e7f5a0c69f62c50212ab87 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 18:55:39 +0200 Subject: added option to set non-standard bytesize, stopbits and parity settings (bzr r14050) --- share/extensions/plotter.inx | 20 +++++++++- share/extensions/plotter.py | 91 +++++++++++++++++++++++++++++++------------- 2 files changed, 84 insertions(+), 27 deletions(-) diff --git a/share/extensions/plotter.inx b/share/extensions/plotter.inx index 5a6d8ce06..cc916fe08 100644 --- a/share/extensions/plotter.inx +++ b/share/extensions/plotter.inx @@ -27,7 +27,25 @@ 57600 115200 - + + 8 Bits + 7 Bits + 6 Bits + 5 Bits + + + 1 Bit + 1.5 Bits + 2 Bits + + + None + Even + Odd + Mark + Space + + <_item value="xonxoff">Software (XON/XOFF) <_item value="rtscts">Hardware (RTS/CTS) <_item value="dsrdtrrtscts">Hardware (DSR/DTR + RTS/CTS) diff --git a/share/extensions/plotter.py b/share/extensions/plotter.py index 2e4fd5dd5..c0f180f60 100644 --- a/share/extensions/plotter.py +++ b/share/extensions/plotter.py @@ -34,27 +34,30 @@ class Plot(inkex.Effect): def __init__(self): inkex.Effect.__init__(self) - self.OptionParser.add_option('--tab', action='store', type='string', dest='tab') - self.OptionParser.add_option('--serialPort', action='store', type='string', dest='serialPort', default='COM1', help='Serial port') - self.OptionParser.add_option('--serialBaudRate', action='store', type='string', dest='serialBaudRate', default='9600', help='Serial Baud rate') - self.OptionParser.add_option('--flowControl', action='store', type='string', dest='flowControl', default='0', help='Flow control') - self.OptionParser.add_option('--commandLanguage', action='store', type='string', dest='commandLanguage', default='hpgl', help='Command Language') - self.OptionParser.add_option('--initCommands', action='store', type='string', dest='initCommands', default='', help='Initialization commands') - self.OptionParser.add_option('--resolutionX', action='store', type='float', dest='resolutionX', default=1016.0, help='Resolution X (dpi)') - self.OptionParser.add_option('--resolutionY', action='store', type='float', dest='resolutionY', default=1016.0, help='Resolution Y (dpi)') - self.OptionParser.add_option('--pen', action='store', type='int', dest='pen', default=1, help='Pen number') - self.OptionParser.add_option('--force', action='store', type='int', dest='force', default=24, help='Pen force (g)') - self.OptionParser.add_option('--speed', action='store', type='int', dest='speed', default=20, help='Pen speed (cm/s)') - self.OptionParser.add_option('--orientation', action='store', type='string', dest='orientation', default='90', help='Rotation (Clockwise)') - self.OptionParser.add_option('--mirrorX', action='store', type='inkbool', dest='mirrorX', default='FALSE', help='Mirror X axis') - self.OptionParser.add_option('--mirrorY', action='store', type='inkbool', dest='mirrorY', default='FALSE', help='Mirror Y axis') - self.OptionParser.add_option('--center', action='store', type='inkbool', dest='center', default='FALSE', help='Center zero point') - self.OptionParser.add_option('--overcut', action='store', type='float', dest='overcut', default=1.0, help='Overcut (mm)') - self.OptionParser.add_option('--toolOffset', action='store', type='float', dest='toolOffset', default=0.25, help='Tool offset (mm)') - self.OptionParser.add_option('--precut', action='store', type='inkbool', dest='precut', default='TRUE', help='Use precut') - self.OptionParser.add_option('--flat', action='store', type='float', dest='flat', default=1.2, help='Curve flatness') - self.OptionParser.add_option('--autoAlign', action='store', type='inkbool', dest='autoAlign', default='TRUE', help='Auto align') - self.OptionParser.add_option('--debug', action='store', type='inkbool', dest='debug', default='FALSE', help='Show debug information') + self.OptionParser.add_option('--tab', action='store', type='string', dest='tab') + self.OptionParser.add_option('--serialPort', action='store', type='string', dest='serialPort', default='COM1', help='Serial port') + self.OptionParser.add_option('--serialBaudRate', action='store', type='string', dest='serialBaudRate', default='9600', help='Serial Baud rate') + self.OptionParser.add_option('--serialByteSize', action='store', type='string', dest='serialByteSize', default='eight', help='Serial byte size') + self.OptionParser.add_option('--serialStopBits', action='store', type='string', dest='serialStopBits', default='one', help='Serial stop bits') + self.OptionParser.add_option('--serialParity', action='store', type='string', dest='serialParity', default='none', help='Serial parity') + self.OptionParser.add_option('--serialFlowControl', action='store', type='string', dest='serialFlowControl', default='0', help='Flow control') + self.OptionParser.add_option('--commandLanguage', action='store', type='string', dest='commandLanguage', default='hpgl', help='Command Language') + self.OptionParser.add_option('--initCommands', action='store', type='string', dest='initCommands', default='', help='Initialization commands') + self.OptionParser.add_option('--resolutionX', action='store', type='float', dest='resolutionX', default=1016.0, help='Resolution X (dpi)') + self.OptionParser.add_option('--resolutionY', action='store', type='float', dest='resolutionY', default=1016.0, help='Resolution Y (dpi)') + self.OptionParser.add_option('--pen', action='store', type='int', dest='pen', default=1, help='Pen number') + self.OptionParser.add_option('--force', action='store', type='int', dest='force', default=24, help='Pen force (g)') + self.OptionParser.add_option('--speed', action='store', type='int', dest='speed', default=20, help='Pen speed (cm/s)') + self.OptionParser.add_option('--orientation', action='store', type='string', dest='orientation', default='90', help='Rotation (Clockwise)') + self.OptionParser.add_option('--mirrorX', action='store', type='inkbool', dest='mirrorX', default='FALSE', help='Mirror X axis') + self.OptionParser.add_option('--mirrorY', action='store', type='inkbool', dest='mirrorY', default='FALSE', help='Mirror Y axis') + self.OptionParser.add_option('--center', action='store', type='inkbool', dest='center', default='FALSE', help='Center zero point') + self.OptionParser.add_option('--overcut', action='store', type='float', dest='overcut', default=1.0, help='Overcut (mm)') + self.OptionParser.add_option('--toolOffset', action='store', type='float', dest='toolOffset', default=0.25, help='Tool offset (mm)') + self.OptionParser.add_option('--precut', action='store', type='inkbool', dest='precut', default='TRUE', help='Use precut') + self.OptionParser.add_option('--flat', action='store', type='float', dest='flat', default=1.2, help='Curve flatness') + self.OptionParser.add_option('--autoAlign', action='store', type='inkbool', dest='autoAlign', default='TRUE', help='Auto align') + self.OptionParser.add_option('--debug', action='store', type='inkbool', dest='debug', default='FALSE', help='Show debug information') def effect(self): # get hpgl data @@ -147,17 +150,49 @@ class Plot(inkex.Effect): + "\n2. Extract the \"serial\" subfolder from the zip to the following folder: C:\\[Program files]\\inkscape\\python\\Lib\\" + "\n3. Restart Inkscape.")) return - # send data to plotter + # init serial framework mySerial = serial.Serial() + # set serial port mySerial.port = self.options.serialPort + # set baudrate mySerial.baudrate = self.options.serialBaudRate + # set bytesize + if self.options.serialByteSize == 'five': + mySerial.bytesize = serial.FIVEBITS + if self.options.serialByteSize == 'six': + mySerial.bytesize = serial.SIXBITS + if self.options.serialByteSize == 'seven': + mySerial.bytesize = serial.SEVENBITS + if self.options.serialByteSize == 'eight': + mySerial.bytesize = serial.EIGHTBITS + # set stopbits + if self.options.serialStopBits == 'one': + mySerial.stopbits = serial.STOPBITS_ONE + if self.options.serialStopBits == 'onePointFive': + mySerial.stopbits = serial.STOPBITS_ONE_POINT_FIVE + if self.options.serialStopBits == 'two': + mySerial.stopbits = serial.STOPBITS_TWO + # set parity + if self.options.serialParity == 'none': + mySerial.parity = serial.PARITY_NONE + if self.options.serialParity == 'even': + mySerial.parity = serial.PARITY_EVEN + if self.options.serialParity == 'odd': + mySerial.parity = serial.PARITY_ODD + if self.options.serialParity == 'mark': + mySerial.parity = serial.PARITY_MARK + if self.options.serialParity == 'space': + mySerial.parity = serial.PARITY_SPACE + # set short timeout to avoid locked up interface mySerial.timeout = 0.1 - if self.options.flowControl == 'xonxoff': + # set flow control + if self.options.serialFlowControl == 'xonxoff': mySerial.xonxoff = True - if self.options.flowControl == 'rtscts' or self.options.flowControl == 'dsrdtrrtscts': + if self.options.serialFlowControl == 'rtscts' or self.options.serialFlowControl == 'dsrdtrrtscts': mySerial.rtscts = True - if self.options.flowControl == 'dsrdtrrtscts': + if self.options.serialFlowControl == 'dsrdtrrtscts': mySerial.dsrdtr = True + # try to establish connection try: mySerial.open() except Exception as inst: @@ -167,6 +202,7 @@ class Plot(inkex.Effect): else: type, value, traceback = sys.exc_info() raise ValueError, ('', type, value), traceback + # send data to plotter if self.options.initCommands != '': mySerial.write(self.options.initCommands.decode('string_escape')) mySerial.write(self.hpgl) @@ -178,7 +214,10 @@ class Plot(inkex.Effect): inkex.errormsg("---------------------------------\nDebug information\n---------------------------------\n\nSettings:\n") inkex.errormsg(' Serial Port: ' + self.options.serialPort) inkex.errormsg(' Serial baud rate: ' + self.options.serialBaudRate) - inkex.errormsg(' Flow control: ' + self.options.flowControl) + inkex.errormsg(' Serial byte size: ' + self.options.serialByteSize + ' Bits') + inkex.errormsg(' Serial stop bits: ' + self.options.serialStopBits + ' Bits') + inkex.errormsg(' Serial parity: ' + self.options.serialParity) + inkex.errormsg(' Serial Flow control: ' + self.options.serialFlowControl) inkex.errormsg(' Command language: ' + self.options.commandLanguage) inkex.errormsg(' Initialization commands: ' + self.options.initCommands) inkex.errormsg(' Resolution X (dpi): ' + str(self.options.resolutionX)) -- cgit v1.2.3 From fb014446df14a373bd1a4f8a9bb970ff730b024d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 19:11:00 +0200 Subject: fixed bug: when no tool offset is used uninitialize commands (SP0;PU0,0) are sent twice (bzr r14051) --- share/extensions/hpgl_encoder.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/share/extensions/hpgl_encoder.py b/share/extensions/hpgl_encoder.py index 75c5fa889..83b1b7297 100644 --- a/share/extensions/hpgl_encoder.py +++ b/share/extensions/hpgl_encoder.py @@ -177,7 +177,8 @@ class hpglEncoder: # start conversion self.processGroups(self.doc, groupmat) # shift an empty node in in order to process last node in cache - self.processOffset('PU', 0, 0, 0) + if self.toolOffset > 0.0 and not self.dryRun: + self.processOffset('PU', 0, 0, 0) if self.options.debug: return self.hpgl, self else: -- cgit v1.2.3 From cbbae063a9be5015fbc290b318aa9371e2f2a5ab Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 19:25:52 +0200 Subject: Fix coding style issues in perspective/envelope LPE (bzr r14052) --- src/live_effects/lpe-perspective-envelope.cpp | 273 +++++++++++++------------- src/live_effects/lpe-perspective-envelope.h | 18 +- 2 files changed, 147 insertions(+), 144 deletions(-) diff --git a/src/live_effects/lpe-perspective-envelope.cpp b/src/live_effects/lpe-perspective-envelope.cpp index b5885bdb3..4eac2d6eb 100644 --- a/src/live_effects/lpe-perspective-envelope.cpp +++ b/src/live_effects/lpe-perspective-envelope.cpp @@ -1,6 +1,6 @@ /** \file * LPE implementation - + */ /* * Authors: @@ -8,8 +8,8 @@ * Aaron Spike, aaron@ekips.org from envelope and perspective phyton code * Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math * Jose Hevia (freon) Transform algorithm from envelope - * - * Copyright (C) 2007-2014 Authors + * + * Copyright (C) 2007-2014 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -27,8 +27,8 @@ namespace Inkscape { namespace LivePathEffect { enum DeformationType { - DEFORMATION_PERSPECTIVE, - DEFORMATION_ENVELOPE + DEFORMATION_PERSPECTIVE, + DEFORMATION_ENVELOPE }; static const Util::EnumData DeformationTypeData[] = { @@ -42,52 +42,53 @@ LPEPerspectiveEnvelope::LPEPerspectiveEnvelope(LivePathEffectObject *lpeobject) Effect(lpeobject), // initialise your parameters here: deform_type(_("Type"), _("Select the type of deformation"), "deform_type", DeformationTypeConverter, &wr, this, DEFORMATION_PERSPECTIVE), - Up_Left_Point(_("Top Left"), _("Top Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Up_Left_Point", &wr, this), - Up_Right_Point(_("Top Right"), _("Top Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Up_Right_Point", &wr, this), - Down_Left_Point(_("Down Left"), _("Down Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Down_Left_Point", &wr, this), - Down_Right_Point(_("Down Right"), _("Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "Down_Right_Point", &wr, this) + up_left_point(_("Top Left"), _("Top Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "up_left_point", &wr, this), + up_right_point(_("Top Right"), _("Top Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "up_right_point", &wr, this), + down_left_point(_("Down Left"), _("Down Left - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "down_left_point", &wr, this), + down_right_point(_("Down Right"), _("Down Right - Ctrl+Alt+Click: reset, Ctrl: move along axes"), "down_right_point", &wr, this) { // register all your parameters here, so Inkscape knows which parameters this effect has: registerParameter(&deform_type); - registerParameter(&Up_Left_Point); - registerParameter(&Up_Right_Point); - registerParameter(&Down_Left_Point); - registerParameter(&Down_Right_Point); + registerParameter(&up_left_point); + registerParameter(&up_right_point); + registerParameter(&down_left_point); + registerParameter(&down_right_point); } LPEPerspectiveEnvelope::~LPEPerspectiveEnvelope() { } -void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { +void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) +{ using Geom::X; using Geom::Y; double projmatrix[3][3]; - if(deform_type == DEFORMATION_PERSPECTIVE){ + if(deform_type == DEFORMATION_PERSPECTIVE) { std::vector handles(4); - handles[0] = Down_Left_Point; - handles[1] = Up_Left_Point; - handles[2] = Up_Right_Point; - handles[3] = Down_Right_Point; - std::vector sourceHandles(4); - sourceHandles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max()); - sourceHandles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min()); - sourceHandles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min()); - sourceHandles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max()); + handles[0] = down_left_point; + handles[1] = up_left_point; + handles[2] = up_right_point; + handles[3] = down_right_point; + std::vector source_handles(4); + source_handles[0] = Geom::Point(boundingbox_X.min(), boundingbox_Y.max()); + source_handles[1] = Geom::Point(boundingbox_X.min(), boundingbox_Y.min()); + source_handles[2] = Geom::Point(boundingbox_X.max(), boundingbox_Y.min()); + source_handles[3] = Geom::Point(boundingbox_X.max(), boundingbox_Y.max()); double solmatrix[8][8] = {{0}}; double free_term[8] = {0}; double gslSolmatrix[64]; - for(unsigned int i = 0; i < 4; ++i){ - solmatrix[i][0] = sourceHandles[i][X]; - solmatrix[i][1] = sourceHandles[i][Y]; + for(unsigned int i = 0; i < 4; ++i) { + solmatrix[i][0] = source_handles[i][X]; + solmatrix[i][1] = source_handles[i][Y]; solmatrix[i][2] = 1; - solmatrix[i][6] = -handles[i][X] * sourceHandles[i][X]; - solmatrix[i][7] = -handles[i][X] * sourceHandles[i][Y]; - solmatrix[i+4][3] = sourceHandles[i][X]; - solmatrix[i+4][4] = sourceHandles[i][Y]; + solmatrix[i][6] = -handles[i][X] * source_handles[i][X]; + solmatrix[i][7] = -handles[i][X] * source_handles[i][Y]; + solmatrix[i+4][3] = source_handles[i][X]; + solmatrix[i+4][4] = source_handles[i][Y]; solmatrix[i+4][5] = 1; - solmatrix[i+4][6] = -handles[i][Y] * sourceHandles[i][X]; - solmatrix[i+4][7] = -handles[i][Y] * sourceHandles[i][Y]; + solmatrix[i+4][6] = -handles[i][Y] * source_handles[i][X]; + solmatrix[i+4][7] = -handles[i][Y] * source_handles[i][Y]; free_term[i] = handles[i][X]; free_term[i+4] = handles[i][Y]; } @@ -110,7 +111,7 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { h = 0; for( int i = 0; i < 3; i++ ) { for( int j = 0; j < 3; j++ ) { - if(h==8){ + if(h==8) { projmatrix[2][2] = 1.0; continue; } @@ -124,19 +125,19 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(curve->get_pathvector()); curve->reset(); Geom::CubicBezier const *cubic = NULL; - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point pointAt3(0, 0); + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point point_at3(0, 0); for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { //Si está vacío... if (path_it->empty()) - continue; + continue; //Itreadores SPCurve *nCurve = new SPCurve(); Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - + if (path_it->closed()) { const Geom::Curve &closingline = path_it->back_closed(); @@ -144,40 +145,40 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { curve_endit = path_it->end_open(); } } - if(deform_type == DEFORMATION_PERSPECTIVE){ - nCurve->moveto(project_point(curve_it1->initialPoint(),projmatrix)); - }else{ - nCurve->moveto(project_point(curve_it1->initialPoint())); + if(deform_type == DEFORMATION_PERSPECTIVE) { + nCurve->moveto(projectPoint(curve_it1->initialPoint(),projmatrix)); + } else { + nCurve->moveto(projectPoint(curve_it1->initialPoint())); } while (curve_it1 != curve_endit) { - cubic = dynamic_cast(&*curve_it1); - if (cubic) { - pointAt1 = (*cubic)[1]; - pointAt2 = (*cubic)[2]; - } else { - pointAt1 = curve_it1->initialPoint(); - pointAt2 = curve_it1->finalPoint(); - } - pointAt3 = curve_it1->finalPoint(); - if(deform_type == DEFORMATION_PERSPECTIVE){ - pointAt1 = project_point(pointAt1,projmatrix); - pointAt2 = project_point(pointAt2,projmatrix); - pointAt3 = project_point(pointAt3,projmatrix); - }else{ - pointAt1 = project_point(pointAt1); - pointAt2 = project_point(pointAt2); - pointAt3 = project_point(pointAt3); - } - nCurve->curveto(pointAt1, pointAt2, pointAt3); - ++curve_it1; - if(curve_it2 != curve_endit) { - ++curve_it2; - } + cubic = dynamic_cast(&*curve_it1); + if (cubic) { + point_at1 = (*cubic)[1]; + point_at2 = (*cubic)[2]; + } else { + point_at1 = curve_it1->initialPoint(); + point_at2 = curve_it1->finalPoint(); + } + point_at3 = curve_it1->finalPoint(); + if(deform_type == DEFORMATION_PERSPECTIVE) { + point_at1 = projectPoint(point_at1,projmatrix); + point_at2 = projectPoint(point_at2,projmatrix); + point_at3 = projectPoint(point_at3,projmatrix); + } else { + point_at1 = projectPoint(point_at1); + point_at2 = projectPoint(point_at2); + point_at3 = projectPoint(point_at3); + } + nCurve->curveto(point_at1, point_at2, point_at3); + ++curve_it1; + if(curve_it2 != curve_endit) { + ++curve_it2; + } } //y cerramos la curva if (path_it->closed()) { - nCurve->move_endpoints(pointAt3, pointAt3); - nCurve->closepath_current(); + nCurve->move_endpoints(point_at3, point_at3); + nCurve->closepath_current(); } curve->append(nCurve, false); nCurve->reset(); @@ -185,41 +186,44 @@ void LPEPerspectiveEnvelope::doEffect(SPCurve *curve) { } } -Geom::Point -LPEPerspectiveEnvelope::project_point(Geom::Point p){ +Geom::Point +LPEPerspectiveEnvelope::projectPoint(Geom::Point p) +{ double width = boundingbox_X.extent(); double height = boundingbox_Y.extent(); double delta_x = boundingbox_X.min() - p[X]; double delta_y = boundingbox_Y.max() - p[Y]; - Geom::Coord xratio = (delta_x * -1) / width; - Geom::Coord yratio = delta_y / height; + Geom::Coord x_ratio = (delta_x * -1) / width; + Geom::Coord y_ratio = delta_y / height; Geom::Line* horiz = new Geom::Line(); Geom::Line* vert = new Geom::Line(); - vert->setPoints (pointAtRatio(yratio,Down_Left_Point,Up_Left_Point),pointAtRatio(yratio,Down_Right_Point,Up_Right_Point)); - horiz->setPoints (pointAtRatio(xratio,Down_Left_Point,Down_Right_Point),pointAtRatio(xratio,Up_Left_Point,Up_Right_Point)); + vert->setPoints (pointAtRatio(y_ratio,down_left_point,up_left_point),pointAtRatio(y_ratio,down_right_point,up_right_point)); + horiz->setPoints (pointAtRatio(x_ratio,down_left_point,down_right_point),pointAtRatio(x_ratio,up_left_point,up_right_point)); OptCrossing crossPoint = intersection(*horiz,*vert); - if(crossPoint){ + if(crossPoint) { return horiz->pointAt(Geom::Coord(crossPoint->ta)); - }else{ + } else { return p; } } -Geom::Point -LPEPerspectiveEnvelope::project_point(Geom::Point p, double m[][3]){ +Geom::Point +LPEPerspectiveEnvelope::projectPoint(Geom::Point p, double m[][3]) +{ Geom::Coord x = p[0]; Geom::Coord y = p[1]; return Geom::Point( - Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])), - Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2]))); + Geom::Coord((x*m[0][0] + y*m[0][1] + m[0][2])/(x*m[2][0]+y*m[2][1]+m[2][2])), + Geom::Coord((x*m[1][0] + y*m[1][1] + m[1][2])/(x*m[2][0]+y*m[2][1]+m[2][2]))); } Geom::Point -LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B){ - Geom::Coord x = A[X] + (ratio * (B[X]-A[X])); - Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y])); - return Point(x, y); +LPEPerspectiveEnvelope::pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B) +{ + Geom::Coord x = A[X] + (ratio * (B[X]-A[X])); + Geom::Coord y = A[Y]+ (ratio * (B[Y]-A[Y])); + return Point(x, y); } @@ -233,36 +237,35 @@ LPEPerspectiveEnvelope::newWidget() vbox->set_homogeneous(false); vbox->set_spacing(6); std::vector::iterator it = param_vector.begin(); - Gtk::HBox * hboxUpHandles = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::HBox * hboxDownHandles = Gtk::manage(new Gtk::HBox(false,0)); + Gtk::HBox * hbox_up_handles = Gtk::manage(new Gtk::HBox(false,0)); + Gtk::HBox * hbox_down_handles = Gtk::manage(new Gtk::HBox(false,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter * param = *it; Gtk::Widget * widg = dynamic_cast(param->param_newWidget()); - if (param->param_key == "Up_Left_Point" || - param->param_key == "Up_Right_Point" || - param->param_key == "Down_Left_Point" || - param->param_key == "Down_Right_Point") - { - Gtk::HBox * pointParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = pointParameter->get_children(); - Gtk::HBox * pointParameterHBox = dynamic_cast(childList[0]); - std::vector< Gtk::Widget* > childList2 = pointParameterHBox->get_children(); - pointParameterHBox->remove(childList2[0][0]); + if (param->param_key == "up_left_point" || + param->param_key == "up_right_point" || + param->param_key == "down_left_point" || + param->param_key == "down_right_point") { + Gtk::HBox * point_hbox = dynamic_cast(widg); + std::vector< Gtk::Widget* > child_list = point_hbox->get_children(); + Gtk::HBox * point_hboxHBox = dynamic_cast(child_list[0]); + std::vector< Gtk::Widget* > child_list2 = point_hboxHBox->get_children(); + point_hboxHBox->remove(child_list2[0][0]); Glib::ustring * tip = param->param_getTooltip(); if (widg) { - if(param->param_key == "Up_Left_Point"){ + if(param->param_key == "up_left_point") { Gtk::Label* handles = Gtk::manage(new Gtk::Label(Glib::ustring(_("Handles:")),Gtk::ALIGN_START)); vbox->pack_start(*handles, false, false, 2); - hboxUpHandles->pack_start(*widg, true, true, 2); - hboxUpHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); - }else if(param->param_key == "Up_Right_Point"){ - hboxUpHandles->pack_start(*widg, true, true, 2); - }else if(param->param_key == "Down_Left_Point"){ - hboxDownHandles->pack_start(*widg, true, true, 2); - hboxDownHandles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); - }else{ - hboxDownHandles->pack_start(*widg, true, true, 2); + hbox_up_handles->pack_start(*widg, true, true, 2); + hbox_up_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); + } else if(param->param_key == "up_right_point") { + hbox_up_handles->pack_start(*widg, true, true, 2); + } else if(param->param_key == "down_left_point") { + hbox_down_handles->pack_start(*widg, true, true, 2); + hbox_down_handles->pack_start(*Gtk::manage(new Gtk::VSeparator()), Gtk::PACK_EXPAND_WIDGET); + } else { + hbox_down_handles->pack_start(*widg, true, true, 2); } if (tip) { widg->set_tooltip_text(*tip); @@ -271,7 +274,7 @@ LPEPerspectiveEnvelope::newWidget() widg->set_has_tooltip(false); } } - }else{ + } else { Glib::ustring * tip = param->param_getTooltip(); if (widg) { vbox->pack_start(*widg, true, true, 2); @@ -287,18 +290,18 @@ LPEPerspectiveEnvelope::newWidget() ++it; } - vbox->pack_start(*hboxUpHandles,true, true, 2); - Gtk::HBox * hboxMiddle = Gtk::manage(new Gtk::HBox(true,2)); - hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); - hboxMiddle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); - vbox->pack_start(*hboxMiddle, false, true, 2); - vbox->pack_start(*hboxDownHandles, true, true, 2); + vbox->pack_start(*hbox_up_handles,true, true, 2); + Gtk::HBox * hbox_middle = Gtk::manage(new Gtk::HBox(true,2)); + hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); + hbox_middle->pack_start(*Gtk::manage(new Gtk::HSeparator()), Gtk::PACK_EXPAND_WIDGET); + vbox->pack_start(*hbox_middle, false, true, 2); + vbox->pack_start(*hbox_down_handles, true, true, 2); Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false,0)); - Gtk::Button* resetButton = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR)); - resetButton->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid)); - resetButton->set_size_request(140,30); + Gtk::Button* reset_button = Gtk::manage(new Gtk::Button(Gtk::Stock::CLEAR)); + reset_button->signal_clicked().connect(sigc::mem_fun (*this,&LPEPerspectiveEnvelope::resetGrid)); + reset_button->set_size_request(140,30); vbox->pack_start(*hbox, true,true,2); - hbox->pack_start(*resetButton, false, false,2); + hbox->pack_start(*reset_button, false, false,2); return dynamic_cast(vbox); } @@ -315,24 +318,24 @@ LPEPerspectiveEnvelope::doBeforeEffect (SPLPEItem const* lpeitem) void LPEPerspectiveEnvelope::setDefaults() { - Geom::Point Up_Left(boundingbox_X.min(), boundingbox_Y.min()); - Geom::Point Up_Right(boundingbox_X.max(), boundingbox_Y.min()); - Geom::Point Down_Left(boundingbox_X.min(), boundingbox_Y.max()); - Geom::Point Down_Right(boundingbox_X.max(), boundingbox_Y.max()); - - Up_Left_Point.param_update_default(Up_Left); - Up_Right_Point.param_update_default(Up_Right); - Down_Right_Point.param_update_default(Down_Right); - Down_Left_Point.param_update_default(Down_Left); + Geom::Point up_left(boundingbox_X.min(), boundingbox_Y.min()); + Geom::Point up_right(boundingbox_X.max(), boundingbox_Y.min()); + Geom::Point down_left(boundingbox_X.min(), boundingbox_Y.max()); + Geom::Point down_right(boundingbox_X.max(), boundingbox_Y.max()); + + up_left_point.param_update_default(up_left); + up_right_point.param_update_default(up_right); + down_right_point.param_update_default(down_right); + down_left_point.param_update_default(down_left); } void LPEPerspectiveEnvelope::resetGrid() { - Up_Left_Point.param_set_default(); - Up_Right_Point.param_set_default(); - Down_Right_Point.param_set_default(); - Down_Left_Point.param_set_default(); + up_left_point.param_set_default(); + up_right_point.param_set_default(); + down_right_point.param_set_default(); + down_left_point.param_set_default(); } void @@ -351,11 +354,11 @@ LPEPerspectiveEnvelope::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::v SPCurve *c = new SPCurve(); c->reset(); - c->moveto(Up_Left_Point); - c->lineto(Up_Right_Point); - c->lineto(Down_Right_Point); - c->lineto(Down_Left_Point); - c->lineto(Up_Left_Point); + c->moveto(up_left_point); + c->lineto(up_right_point); + c->lineto(down_right_point); + c->lineto(down_left_point); + c->lineto(up_left_point); hp_vec.push_back(c->get_pathvector()); } diff --git a/src/live_effects/lpe-perspective-envelope.h b/src/live_effects/lpe-perspective-envelope.h index d3ff76445..e25f059a3 100644 --- a/src/live_effects/lpe-perspective-envelope.h +++ b/src/live_effects/lpe-perspective-envelope.h @@ -3,7 +3,7 @@ /** \file * LPE implementation , see lpe-perspective-envelope.cpp. - + */ /* * Authors: @@ -11,8 +11,8 @@ * Aaron Spike, aaron@ekips.org from envelope and perspective phyton code * Dmitry Platonov, shadowjack@mail.ru, 2006 perspective approach & math * Jose Hevia (freon) Transform algorithm from envelope - * - * Copyright (C) 2007-2014 Authors + * + * Copyright (C) 2007-2014 Authors * * Released under GNU GPL, read the file 'COPYING' for more information */ @@ -34,9 +34,9 @@ public: virtual void doEffect(SPCurve *curve); - virtual Geom::Point project_point(Geom::Point p); + virtual Geom::Point projectPoint(Geom::Point p); - virtual Geom::Point project_point(Geom::Point p, double m[][3]); + virtual Geom::Point projectPoint(Geom::Point p, double m[][3]); virtual Geom::Point pointAtRatio(Geom::Coord ratio,Geom::Point A, Geom::Point B); @@ -55,10 +55,10 @@ protected: private: EnumParam deform_type; - PointParam Up_Left_Point; - PointParam Up_Right_Point; - PointParam Down_Left_Point; - PointParam Down_Right_Point; + PointParam up_left_point; + PointParam up_right_point; + PointParam down_left_point; + PointParam down_right_point; LPEPerspectiveEnvelope(const LPEPerspectiveEnvelope&); LPEPerspectiveEnvelope& operator=(const LPEPerspectiveEnvelope&); -- cgit v1.2.3 From a4c5658e46ba9c792ab794d39b71e344bc95e3b6 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 19:38:28 +0200 Subject: Fix coding style issues in show/handles LPE (bzr r14053) --- src/live_effects/lpe-show_handles.cpp | 76 +++++++++++++++++------------------ src/live_effects/lpe-show_handles.h | 14 +++---- 2 files changed, 45 insertions(+), 45 deletions(-) diff --git a/src/live_effects/lpe-show_handles.cpp b/src/live_effects/lpe-show_handles.cpp index 2d8148730..2638f312e 100644 --- a/src/live_effects/lpe-show_handles.cpp +++ b/src/live_effects/lpe-show_handles.cpp @@ -24,25 +24,25 @@ LPEShowHandles::LPEShowHandles(LivePathEffectObject *lpeobject) : Effect(lpeobject), nodes(_("Show nodes"), _("Show nodes"), "nodes", &wr, this, true), handles(_("Show handles"), _("Show handles"), "handles", &wr, this, true), - originalPath(_("Show path"), _("Show path"), "originalPath", &wr, this, true), - scaleNodesAndHandles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scaleNodesAndHandles", &wr, this, 10), - rotateNodes(_("Rotate nodes"), _("Rotate nodes"), "rotateNodes", &wr, this, 0) + original_path(_("Show path"), _("Show path"), "original_path", &wr, this, true), + scale_nodes_and_handles(_("Scale nodes and handles"), _("Scale nodes and handles"), "scale_nodes_and_handles", &wr, this, 10), + rotate_nodes(_("Rotate nodes"), _("Rotate nodes"), "rotate_nodes", &wr, this, 0) { - registerParameter(dynamic_cast(&nodes)); - registerParameter(dynamic_cast(&handles)); - registerParameter(dynamic_cast(&originalPath)); - registerParameter(dynamic_cast(&scaleNodesAndHandles)); - registerParameter(dynamic_cast(&rotateNodes)); - scaleNodesAndHandles.param_set_range(0, 500.); - scaleNodesAndHandles.param_set_increments(1, 1); - scaleNodesAndHandles.param_set_digits(2); - rotateNodes.param_set_range(0, 365); - rotateNodes.param_set_increments(1, 1); - rotateNodes.param_set_digits(0); - strokeWidth = 1.0; + registerParameter(&nodes); + registerParameter(&handles); + registerParameter(&original_path); + registerParameter(&scale_nodes_and_handles); + registerParameter(&rotate_nodes); + scale_nodes_and_handles.param_set_range(0, 500.); + scale_nodes_and_handles.param_set_increments(1, 1); + scale_nodes_and_handles.param_set_digits(2); + rotate_nodes.param_set_range(0, 365); + rotate_nodes.param_set_increments(1, 1); + rotate_nodes.param_set_digits(0); + stroke_width = 1.0; } -bool LPEShowHandles::alertsOff = false; +bool LPEShowHandles::alerts_off = false; /** * Sets default styles to element @@ -51,11 +51,11 @@ bool LPEShowHandles::alertsOff = false; void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem) { - if(!alertsOff) { + if(!alerts_off) { char *msg = _("The \"show handles\" path effect will remove any custom style on the object you are applying it to. If this is not what you want, click Cancel."); Gtk::MessageDialog dialog(msg, false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_OK_CANCEL, true); gint response = dialog.run(); - alertsOff = true; + alerts_off = true; if(response == GTK_RESPONSE_CANCEL) { SPLPEItem* item = const_cast(lpeitem); item->removeCurrentPathEffect(false); @@ -76,24 +76,24 @@ void LPEShowHandles::doOnApply(SPLPEItem const* lpeitem) void LPEShowHandles::doBeforeEffect (SPLPEItem const* lpeitem) { SPItem const* item = SP_ITEM(lpeitem); - strokeWidth = item->style->stroke_width.computed; + stroke_width = item->style->stroke_width.computed; } std::vector LPEShowHandles::doEffect_path (std::vector const & path_in) { std::vector path_out; Geom::PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(path_in); - if(originalPath) { + if(original_path) { for (unsigned int i=0; i < path_in.size(); i++) { path_out.push_back(path_in[i]); } } - if(!outlinepath.empty()) { - outlinepath.clear(); + if(!outline_path.empty()) { + outline_path.clear(); } generateHelperPath(original_pathv); - for (unsigned int i=0; i < outlinepath.size(); i++) { - path_out.push_back(outlinepath[i]); + for (unsigned int i=0; i < outline_path.size(); i++) { + path_out.push_back(outline_path[i]); } return path_out; } @@ -136,11 +136,11 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) cubic = dynamic_cast(&*curve_it1); if (cubic) { if(handles) { - if(!are_near((*cubic)[0],(*cubic)[1])){ + if(!are_near((*cubic)[0],(*cubic)[1])) { drawHandle((*cubic)[1]); drawHandleLine((*cubic)[0],(*cubic)[1]); } - if(!are_near((*cubic)[3],(*cubic)[2])){ + if(!are_near((*cubic)[3],(*cubic)[2])) { drawHandle((*cubic)[2]); drawHandleLine((*cubic)[3],(*cubic)[2]); } @@ -150,7 +150,7 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) drawNode(curve_it1->finalPoint()); } ++curve_it1; - if(curve_it2 != curve_endit){ + if(curve_it2 != curve_endit) { ++curve_it2; } } @@ -160,30 +160,30 @@ LPEShowHandles::generateHelperPath(Geom::PathVector result) void LPEShowHandles::drawNode(Geom::Point p) { - if(strokeWidth * scaleNodesAndHandles > 0.0) { - double diameter = strokeWidth * scaleNodesAndHandles; + if(stroke_width * scale_nodes_and_handles > 0.0) { + double diameter = stroke_width * scale_nodes_and_handles; char const * svgd; svgd = "M 0.05,0 A 0.05,0.05 0 0 1 0,0.05 0.05,0.05 0 0 1 -0.05,0 0.05,0.05 0 0 1 0,-0.05 0.05,0.05 0 0 1 0.05,0 Z M -0.5,-0.5 0.5,-0.5 0.5,0.5 -0.5,0.5 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); - pathv *= Geom::Rotate::from_degrees(rotateNodes); + pathv *= Geom::Rotate::from_degrees(rotate_nodes); pathv *= Geom::Scale (diameter); pathv += p; - outlinepath.push_back(pathv[0]); - outlinepath.push_back(pathv[1]); + outline_path.push_back(pathv[0]); + outline_path.push_back(pathv[1]); } } void LPEShowHandles::drawHandle(Geom::Point p) { - if(strokeWidth * scaleNodesAndHandles > 0.0) { - double diameter = strokeWidth * scaleNodesAndHandles; + if(stroke_width * scale_nodes_and_handles > 0.0) { + double diameter = stroke_width * scale_nodes_and_handles; char const * svgd; svgd = "M 0.7,0.35 A 0.35,0.35 0 0 1 0.35,0.7 0.35,0.35 0 0 1 0,0.35 0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z"; Geom::PathVector pathv = sp_svg_read_pathv(svgd); pathv *= Geom::Scale (diameter); pathv += p-Geom::Point(diameter * 0.35,diameter * 0.35); - outlinepath.push_back(pathv[0]); + outline_path.push_back(pathv[0]); } } @@ -192,14 +192,14 @@ void LPEShowHandles::drawHandleLine(Geom::Point p,Geom::Point p2) { Geom::Path path; - double diameter = strokeWidth * scaleNodesAndHandles; - if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)){ + double diameter = stroke_width * scale_nodes_and_handles; + if(diameter > 0.0 && Geom::distance(p,p2) > (diameter * 0.35)) { Geom::Ray ray2(p, p2); p2 = p2 - Geom::Point::polar(ray2.angle(),(diameter * 0.35)); } path.start( p ); path.appendNew( p2 ); - outlinepath.push_back(path); + outline_path.push_back(path); } }; //namespace LivePathEffect diff --git a/src/live_effects/lpe-show_handles.h b/src/live_effects/lpe-show_handles.h index a405c26ee..77b28e77a 100644 --- a/src/live_effects/lpe-show_handles.h +++ b/src/live_effects/lpe-show_handles.h @@ -20,7 +20,7 @@ class LPEShowHandles : public Effect , GroupBBoxEffect { public: LPEShowHandles(LivePathEffectObject *lpeobject); - virtual ~LPEShowHandles(){} + virtual ~LPEShowHandles() {} virtual void doOnApply(SPLPEItem const* lpeitem); @@ -42,13 +42,13 @@ private: BoolParam nodes; BoolParam handles; - BoolParam originalPath; - ScalarParam scaleNodesAndHandles; - ScalarParam rotateNodes; - double strokeWidth; - static bool alertsOff; + BoolParam original_path; + ScalarParam scale_nodes_and_handles; + ScalarParam rotate_nodes; + double stroke_width; + static bool alerts_off; - Geom::PathVector outlinepath; + Geom::PathVector outline_path; LPEShowHandles(const LPEShowHandles &); LPEShowHandles &operator=(const LPEShowHandles &); -- cgit v1.2.3 From 79c874ab182858f6d400e41771981d8fe1c58921 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 10 Apr 2015 20:49:29 +0200 Subject: Fix coding style issues in bspline/spirolive code (bzr r14054) --- src/live_effects/lpe-bspline.cpp | 320 +++++++++++++++--------------- src/live_effects/lpe-bspline.h | 7 +- src/ui/tool/curve-drag-point.cpp | 4 +- src/ui/tool/node.cpp | 98 +++++----- src/ui/tool/path-manipulator.cpp | 122 ++++++------ src/ui/tool/path-manipulator.h | 12 +- src/ui/tools/freehand-base.cpp | 12 +- src/ui/tools/freehand-base.h | 2 +- src/ui/tools/pen-tool.cpp | 407 ++++++++++++++++++++------------------- src/ui/tools/pen-tool.h | 28 +-- src/ui/tools/pencil-tool.cpp | 22 +-- 11 files changed, 521 insertions(+), 513 deletions(-) diff --git a/src/live_effects/lpe-bspline.cpp b/src/live_effects/lpe-bspline.cpp index 5d5a6e616..ecbfef76a 100644 --- a/src/live_effects/lpe-bspline.cpp +++ b/src/live_effects/lpe-bspline.cpp @@ -15,26 +15,26 @@ namespace Inkscape { namespace LivePathEffect { -const double handleCubicGap = 0.01; -const double noPower = 0.0; -const double defaultStartPower = 0.3334; -const double defaultEndPower = 0.6667; +const double HANDLE_CUBIC_GAP = 0.01; +const double NO_POWER = 0.0; +const double DEFAULT_START_POWER = 0.3334; +const double DEFAULT_END_POWER = 0.6667; LPEBSpline::LPEBSpline(LivePathEffectObject *lpeobject) : Effect(lpeobject), steps(_("Steps with CTRL:"), _("Change number of steps with CTRL pressed"), "steps", &wr, this, 2), helper_size(_("Helper size:"), _("Helper size"), "helper_size", &wr, this, 0), - ignoreCusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignoreCusp", &wr, this, true), - onlySelected(_("Change only selected nodes"), _("Change only selected nodes"), "onlySelected", &wr, this, false), - weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, defaultStartPower) + ignore_cusp(_("Ignore cusp nodes"), _("Change ignoring cusp nodes"), "ignore_cusp", &wr, this, true), + only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false), + weight(_("Change weight:"), _("Change weight of the effect"), "weight", &wr, this, DEFAULT_START_POWER) { registerParameter(&weight); registerParameter(&steps); registerParameter(&helper_size); - registerParameter(&ignoreCusp); - registerParameter(&onlySelected); + registerParameter(&ignore_cusp); + registerParameter(&only_selected); - weight.param_set_range(noPower, 1); + weight.param_set_range(NO_POWER, 1); weight.param_set_increments(0.1, 0.1); weight.param_set_digits(4); @@ -51,7 +51,7 @@ LPEBSpline::~LPEBSpline() {} void LPEBSpline::doBeforeEffect (SPLPEItem const* /*lpeitem*/) { - if(!hp.empty()){ + if(!hp.empty()) { hp.clear(); } } @@ -69,7 +69,7 @@ void LPEBSpline::doOnApply(SPLPEItem const* lpeitem) void LPEBSpline::doEffect(SPCurve *curve) { - if (curve->get_segment_count() < 1){ + if (curve->get_segment_count() < 1) { return; } // Make copy of old path as it is changed during processing @@ -79,22 +79,22 @@ void LPEBSpline::doEffect(SPCurve *curve) for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - if (path_it->empty()){ + if (path_it->empty()) { continue; } hp.push_back(*path_it); Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); + SPCurve *curve_n = new SPCurve(); Geom::Point previousNode(0, 0); Geom::Point node(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point nextPointAt1(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; - Geom::D2 SBasisHelper; + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point next_point_at1(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; + Geom::D2 sbasis_helper; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { // if the path is closed, maybe we have to stop a bit earlier because the @@ -110,27 +110,27 @@ void LPEBSpline::doEffect(SPCurve *curve) curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); if (cubic) { - SBasisIn = in->first_segment()->toSBasis(); + sbasis_in = in->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - pointAt1 = SBasisIn.valueAt(defaultStartPower); + point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); + point_at1 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); } if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) { - pointAt2 = SBasisIn.valueAt(defaultEndPower); + point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER); } else { - pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); + point_at2 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } in->reset(); delete in; @@ -140,14 +140,14 @@ void LPEBSpline::doEffect(SPCurve *curve) out->lineto(curve_it2->finalPoint()); cubic = dynamic_cast(&*curve_it2); if (cubic) { - SBasisOut = out->first_segment()->toSBasis(); + sbasis_out = out->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - nextPointAt1 = SBasisIn.valueAt(defaultStartPower); + next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); + next_point_at1 = sbasis_out.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); } } else { - nextPointAt1 = out->first_segment()->initialPoint(); + next_point_at1 = out->first_segment()->initialPoint(); } out->reset(); delete out; @@ -156,14 +156,14 @@ void LPEBSpline::doEffect(SPCurve *curve) SPCurve *start = new SPCurve(); start->moveto(path_it->begin()->initialPoint()); start->lineto(path_it->begin()->finalPoint()); - Geom::D2 SBasisStart = start->first_segment()->toSBasis(); - SPCurve *lineHelper = new SPCurve(); + Geom::D2 sbasis_start = start->first_segment()->toSBasis(); + SPCurve *line_helper = new SPCurve(); cubic = dynamic_cast(&*path_it->begin()); if (cubic) { - lineHelper->moveto(SBasisStart.valueAt( + line_helper->moveto(sbasis_start.valueAt( Geom::nearest_point((*cubic)[1], *start->first_segment()))); } else { - lineHelper->moveto(start->first_segment()->initialPoint()); + line_helper->moveto(start->first_segment()->initialPoint()); } start->reset(); delete start; @@ -171,41 +171,41 @@ void LPEBSpline::doEffect(SPCurve *curve) SPCurve *end = new SPCurve(); end->moveto(curve_it1->initialPoint()); end->lineto(curve_it1->finalPoint()); - Geom::D2 SBasisEnd = end->first_segment()->toSBasis(); + Geom::D2 sbasis_end = end->first_segment()->toSBasis(); cubic = dynamic_cast(&*curve_it1); if (cubic) { - lineHelper->lineto(SBasisEnd.valueAt( + line_helper->lineto(sbasis_end.valueAt( Geom::nearest_point((*cubic)[2], *end->first_segment()))); } else { - lineHelper->lineto(end->first_segment()->finalPoint()); + line_helper->lineto(end->first_segment()->finalPoint()); } end->reset(); delete end; - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; - node = SBasisHelper.valueAt(0.5); - nCurve->curveto(pointAt1, pointAt2, node); - nCurve->move_endpoints(node, node); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; + node = sbasis_helper.valueAt(0.5); + curve_n->curveto(point_at1, point_at2, node); + curve_n->move_endpoints(node, node); } else if ( curve_it2 == curve_endit) { - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); - nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); + curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint()); + curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); } else { - SPCurve *lineHelper = new SPCurve(); - lineHelper->moveto(pointAt2); - lineHelper->lineto(nextPointAt1); - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; + SPCurve *line_helper = new SPCurve(); + line_helper->moveto(point_at2); + line_helper->lineto(next_point_at1); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; previousNode = node; - node = SBasisHelper.valueAt(0.5); + node = sbasis_helper.valueAt(0.5); Geom::CubicBezier const *cubic2 = dynamic_cast(&*curve_it1); if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) { node = curve_it1->finalPoint(); } - nCurve->curveto(pointAt1, pointAt2, node); + curve_n->curveto(point_at1, point_at2, node); } - if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0){ + if(!are_near(node,curve_it1->finalPoint()) && helper_size > 0.0) { drawHandle(node, helper_size); } ++curve_it1; @@ -213,15 +213,15 @@ void LPEBSpline::doEffect(SPCurve *curve) } //y cerramos la curva if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } - if(helper_size > 0.0){ + if(helper_size > 0.0) { Geom::PathVector const pathv = curve->get_pathvector(); - hp.push_back(pathv[0]); + hp.push_back(pathv[0]); } } @@ -256,40 +256,40 @@ Gtk::Widget *LPEBSpline::newWidget() Gtk::Widget *widg = dynamic_cast(param->param_newWidget()); if (param->param_key == "weight") { Gtk::HBox * buttons = Gtk::manage(new Gtk::HBox(true,0)); - Gtk::Button *defaultWeight = + Gtk::Button *default_weight = Gtk::manage(new Gtk::Button(Glib::ustring(_("Default weight")))); - defaultWeight->signal_clicked() + default_weight->signal_clicked() .connect(sigc::mem_fun(*this, &LPEBSpline::toDefaultWeight)); - buttons->pack_start(*defaultWeight, true, true, 2); - Gtk::Button *makeCusp = + buttons->pack_start(*default_weight, true, true, 2); + Gtk::Button *make_cusp = Gtk::manage(new Gtk::Button(Glib::ustring(_("Make cusp")))); - makeCusp->signal_clicked() + make_cusp->signal_clicked() .connect(sigc::mem_fun(*this, &LPEBSpline::toMakeCusp)); - buttons->pack_start(*makeCusp, true, true, 2); + buttons->pack_start(*make_cusp, true, true, 2); vbox->pack_start(*buttons, true, true, 2); } if (param->param_key == "weight" || param->param_key == "steps") { - Inkscape::UI::Widget::Scalar *widgRegistered = + Inkscape::UI::Widget::Scalar *widg_registered = Gtk::manage(dynamic_cast(widg)); - widgRegistered->signal_value_changed() + widg_registered->signal_value_changed() .connect(sigc::mem_fun(*this, &LPEBSpline::toWeight)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); if (widg) { - Gtk::HBox * scalarParameter = dynamic_cast(widg); - std::vector< Gtk::Widget* > childList = scalarParameter->get_children(); - Gtk::Entry* entryWidg = dynamic_cast(childList[1]); - entryWidg->set_width_chars(6); + Gtk::HBox * hbox_weight_steps = dynamic_cast(widg); + std::vector< Gtk::Widget* > childList = hbox_weight_steps->get_children(); + Gtk::Entry* entry_widget = dynamic_cast(childList[1]); + entry_widget->set_width_chars(6); } } - if (param->param_key == "onlySelected") { - Gtk::CheckButton *widgRegistered = + if (param->param_key == "only_selected") { + Gtk::CheckButton *widg_registered = Gtk::manage(dynamic_cast(widg)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); } - if (param->param_key == "ignoreCusp") { - Gtk::CheckButton *widgRegistered = + if (param->param_key == "ignore_cusp") { + Gtk::CheckButton *widg_registered = Gtk::manage(dynamic_cast(widg)); - widg = dynamic_cast(widgRegistered); + widg = dynamic_cast(widg_registered); } Glib::ustring *tip = param->param_getTooltip(); if (widg) { @@ -310,12 +310,12 @@ Gtk::Widget *LPEBSpline::newWidget() void LPEBSpline::toDefaultWeight() { - changeWeight(defaultStartPower); + changeWeight(DEFAULT_START_POWER); } void LPEBSpline::toMakeCusp() { - changeWeight(noPower); + changeWeight(NO_POWER); } void LPEBSpline::toWeight() @@ -323,22 +323,22 @@ void LPEBSpline::toWeight() changeWeight(weight); } -void LPEBSpline::changeWeight(double weightValue) +void LPEBSpline::changeWeight(double weight_ammount) { SPPath *path = dynamic_cast(sp_lpe_item); - if(path){ + if(path) { SPCurve *curve = path->get_curve_for_edit(); - LPEBSpline::doBSplineFromWidget(curve, weightValue); + doBSplineFromWidget(curve, weight_ammount); gchar *str = sp_svg_write_path(curve->get_pathvector()); path->getRepr()->setAttribute("inkscape:original-d", str); } } -void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) +void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weight_ammount) { using Geom::X; using Geom::Y; - + if (curve->get_segment_count() < 1) return; // Make copy of old path as it is changed during processing @@ -348,20 +348,20 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - if (path_it->empty()){ + if (path_it->empty()) { continue; } Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); - Geom::Point pointAt0(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point pointAt3(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; + SPCurve *curve_n = new SPCurve(); + Geom::Point point_at0(0, 0); + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point point_at3(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { // if the path is closed, maybe we have to stop a bit earlier because the @@ -377,120 +377,120 @@ void LPEBSpline::doBSplineFromWidget(SPCurve *curve, double weightValue) curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); - pointAt0 = in->first_segment()->initialPoint(); - pointAt3 = in->first_segment()->finalPoint(); - SBasisIn = in->first_segment()->toSBasis(); - if (!onlySelected) { + point_at0 = in->first_segment()->initialPoint(); + point_at3 = in->first_segment()->finalPoint(); + sbasis_in = in->first_segment()->toSBasis(); + if (!only_selected) { if (cubic) { - if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) { - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) { + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - if (!ignoreCusp && weightValue != noPower) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp && weight_ammount != NO_POWER) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } } } else { if (cubic) { - if (!ignoreCusp || !Geom::are_near((*cubic)[1], pointAt0)) { - if (isNodePointSelected(pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - if (weightValue != noPower) { - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[1], point_at0)) { + if (isNodePointSelected(point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + if (weight_ammount != NO_POWER) { + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt1 = (*cubic)[1]; + point_at1 = (*cubic)[1]; } } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (!ignoreCusp || !Geom::are_near((*cubic)[2], pointAt3)) { - if (isNodePointSelected(pointAt3)) { - pointAt2 = SBasisIn.valueAt(1 - weightValue); - if (weightValue != noPower) { - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (!ignore_cusp || !Geom::are_near((*cubic)[2], point_at3)) { + if (isNodePointSelected(point_at3)) { + point_at2 = sbasis_in.valueAt(1 - weight_ammount); + if (weight_ammount != NO_POWER) { + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } } else { - pointAt2 = (*cubic)[2]; + point_at2 = (*cubic)[2]; } } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - if (!ignoreCusp && weightValue != noPower) { - if (isNodePointSelected(pointAt0)) { - pointAt1 = SBasisIn.valueAt(weightValue); - pointAt1 = - Geom::Point(pointAt1[X] + handleCubicGap, pointAt1[Y] + handleCubicGap); + if (!ignore_cusp && weight_ammount != NO_POWER) { + if (isNodePointSelected(point_at0)) { + point_at1 = sbasis_in.valueAt(weight_ammount); + point_at1 = + Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP); } else { - pointAt1 = in->first_segment()->initialPoint(); + point_at1 = in->first_segment()->initialPoint(); } - if (isNodePointSelected(pointAt3)) { - pointAt2 = SBasisIn.valueAt(weightValue); - pointAt2 = - Geom::Point(pointAt2[X] + handleCubicGap, pointAt2[Y] + handleCubicGap); + if (isNodePointSelected(point_at3)) { + point_at2 = sbasis_in.valueAt(weight_ammount); + point_at2 = + Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP); } else { - pointAt2 = in->first_segment()->finalPoint(); + point_at2 = in->first_segment()->finalPoint(); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } } } in->reset(); delete in; - nCurve->curveto(pointAt1, pointAt2, pointAt3); + curve_n->curveto(point_at1, point_at2, point_at3); ++curve_it1; ++curve_it2; } if (path_it->closed()) { - nCurve->move_endpoints(path_it->begin()->initialPoint(), + curve_n->move_endpoints(path_it->begin()->initialPoint(), path_it->begin()->initialPoint()); } else { - nCurve->move_endpoints(path_it->begin()->initialPoint(), pointAt3); + curve_n->move_endpoints(path_it->begin()->initialPoint(), point_at3); } if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } } diff --git a/src/live_effects/lpe-bspline.h b/src/live_effects/lpe-bspline.h index 8017e39ef..fc0f66353 100644 --- a/src/live_effects/lpe-bspline.h +++ b/src/live_effects/lpe-bspline.h @@ -18,7 +18,8 @@ public: LPEBSpline(LivePathEffectObject *lpeobject); virtual ~LPEBSpline(); - virtual LPEPathFlashType pathFlashType() const { + virtual LPEPathFlashType pathFlashType() const + { return SUPPRESS_FLASH; } virtual void doOnApply(SPLPEItem const* lpeitem); @@ -38,8 +39,8 @@ public: private: ScalarParam helper_size; - BoolParam ignoreCusp; - BoolParam onlySelected; + BoolParam ignore_cusp; + BoolParam only_selected; ScalarParam weight; Geom::PathVector hp; diff --git a/src/ui/tool/curve-drag-point.cpp b/src/ui/tool/curve-drag-point.cpp index a90dfb155..23640456e 100644 --- a/src/ui/tool/curve-drag-point.cpp +++ b/src/ui/tool/curve-drag-point.cpp @@ -54,7 +54,7 @@ bool CurveDragPoint::grabbed(GdkEventMotion */*event*/) // delta is a vector equal 1/3 of distance from first to second Geom::Point delta = (second->position() - first->position()) / 3.0; // only update the nodes if the mode is bspline - if(!_pm.isBSpline()){ + if(!_pm._isBSpline()){ first->front()->move(first->front()->position() + delta); second->back()->move(second->back()->position() - delta); } @@ -91,7 +91,7 @@ void CurveDragPoint::dragged(Geom::Point &new_pos, GdkEventMotion *event) Geom::Point offset1 = (weight/(3*t*t*(1-t))) * delta; //modified so that, if the trace is bspline, it only acts if the SHIFT key is pressed - if(!_pm.isBSpline()){ + if(!_pm._isBSpline()){ first->front()->move(first->front()->position() + offset0); second->back()->move(second->back()->position() + offset1); }else if(weight>=0.8){ diff --git a/src/ui/tool/node.cpp b/src/ui/tool/node.cpp index 08cc6708d..aa5365265 100644 --- a/src/ui/tool/node.cpp +++ b/src/ui/tool/node.cpp @@ -175,9 +175,9 @@ void Handle::move(Geom::Point const &new_pos) setPosition(new_pos); //move the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } return; } @@ -192,9 +192,9 @@ void Handle::move(Geom::Point const &new_pos) setRelativePos(new_delta); //move the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } return; @@ -218,9 +218,9 @@ void Handle::move(Geom::Point const &new_pos) setPosition(new_pos); // moves the handler and its oposite the same proportion - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,this)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),this)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,this)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),this)); } } @@ -312,9 +312,9 @@ bool Handle::_eventHandler(Inkscape::UI::Tools::ToolBase *event_context, GdkEven //this function moves the handler and its oposite to the default proportion of defaultStartPower void Handle::handle_2button_press(){ - if(_pm().isBSpline()){ - setPosition(_pm().BSplineHandleReposition(this,defaultStartPower)); - this->other()->setPosition(_pm().BSplineHandleReposition(this->other(),defaultStartPower)); + if(_pm()._isBSpline()){ + setPosition(_pm()._bsplineHandleReposition(this,defaultStartPower)); + this->other()->setPosition(_pm()._bsplineHandleReposition(this->other(),defaultStartPower)); _pm().update(); } } @@ -372,16 +372,16 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) new_pos = result; // moves the handler and its oposite in X fixed positions depending on parameter "steps with control" // by default in live BSpline - if(_pm().isBSpline()){ + if(_pm()._isBSpline()){ setPosition(new_pos); - int steps = _pm().BSplineGetSteps(); - new_pos=_pm().BSplineHandleReposition(this,ceilf(_pm().BSplineHandlePosition(this,this)*steps)/steps); + int steps = _pm()._bsplineGetSteps(); + new_pos=_pm()._bsplineHandleReposition(this,ceilf(_pm()._bsplineHandlePosition(this,this)*steps)/steps); } } std::vector unselected; //if the snap adjustment is activated and it is not bspline - if (snap && !_pm().isBSpline()) { + if (snap && !_pm()._isBSpline()) { ControlPointSelection::Set &nodes = _parent->_selection.allPoints(); for (ControlPointSelection::Set::iterator i = nodes.begin(); i != nodes.end(); ++i) { Node *n = static_cast(*i); @@ -422,7 +422,7 @@ void Handle::dragged(Geom::Point &new_pos, GdkEventMotion *event) } } //if it is bspline but SHIFT or CONTROL are not pressed it fixes it in the original position - if(_pm().isBSpline() && !held_shift(*event) && !held_control(*event)){ + if(_pm()._isBSpline() && !held_shift(*event) && !held_control(*event)){ new_pos=_last_drag_origin(); } move(new_pos); // needed for correct update, even though it's redundant @@ -486,7 +486,7 @@ Glib::ustring Handle::_getTip(unsigned state) const // a trick to mark as bspline if the node has no strength, we are going to use it later // to show the appropiate messages. We cannot do it in any different way becasue the function is constant Handle *h = const_cast(this); - bool isBSpline = _pm().isBSpline(); + bool isBSpline = _pm()._isBSpline(); bool can_shift_rotate = _parent->type() == NODE_CUSP && !other()->isDegenerate(); if (can_shift_rotate && !isBSpline) { more = C_("Path handle tip", "more: Shift, Ctrl, Alt"); @@ -549,7 +549,7 @@ Glib::ustring Handle::_getTip(unsigned state) const "Auto node handle: drag to convert to smooth node (%s)"), more); }else{ return format_tip(C_("Path handle tip", - "BSpline node handle: Shift to drag, double click to reset (%s). %g power"),more,_pm().BSplineHandlePosition(h,NULL)); + "BSpline node handle: Shift to drag, double click to reset (%s). %g power"),more,_pm()._bsplineHandlePosition(h,NULL)); } } } @@ -633,15 +633,15 @@ void Node::move(Geom::Point const &new_pos) Node *n = this; Node * nextNode = n->nodeToward(n->front()); Node * prevNode = n->nodeToward(n->back()); - nodeWeight = fmax(_pm().BSplineHandlePosition(n->front()),_pm().BSplineHandlePosition(n->back())); + nodeWeight = fmax(_pm()._bsplineHandlePosition(n->front()),_pm()._bsplineHandlePosition(n->back())); if(prevNode){ if(prevNode->isEndNode()){ - prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front()); + prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front()); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back()); + nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back()); } } @@ -655,21 +655,21 @@ void Node::move(Geom::Point const &new_pos) _fixNeighbors(old_pos, new_pos); // move the affected handlers. First the node ones, later the adjoining ones. - if(_pm().isBSpline()){ - _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight)); + if(_pm()._isBSpline()){ + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight)); if(prevNode){ if(prevNode->isEndNode()){ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight)); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight)); }else{ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back())); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back())); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight)); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight)); }else{ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front())); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front())); } } } @@ -687,15 +687,15 @@ void Node::transform(Geom::Affine const &m) Node *n = this; Node * nextNode = n->nodeToward(n->front()); Node * prevNode = n->nodeToward(n->back()); - nodeWeight = _pm().BSplineHandlePosition(n->front()); + nodeWeight = _pm()._bsplineHandlePosition(n->front()); if(prevNode){ if(prevNode->isEndNode()){ - prevNodeWeight = _pm().BSplineHandlePosition(prevNode->front(),prevNode->front()); + prevNodeWeight = _pm()._bsplineHandlePosition(prevNode->front(),prevNode->front()); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNodeWeight = _pm().BSplineHandlePosition(nextNode->back(),nextNode->back()); + nextNodeWeight = _pm()._bsplineHandlePosition(nextNode->back(),nextNode->back()); } } @@ -708,21 +708,21 @@ void Node::transform(Geom::Affine const &m) _fixNeighbors(old_pos, position()); // move the involved handlers, first the node ones, later the adjoining ones - if(_pm().isBSpline()){ - _front.setPosition(_pm().BSplineHandleReposition(this->front(),nodeWeight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),nodeWeight)); + if(_pm()._isBSpline()){ + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),nodeWeight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),nodeWeight)); if(prevNode){ if(prevNode->isEndNode()){ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNodeWeight)); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNodeWeight)); }else{ - prevNode->front()->setPosition(_pm().BSplineHandleReposition(prevNode->front(),prevNode->back())); + prevNode->front()->setPosition(_pm()._bsplineHandleReposition(prevNode->front(),prevNode->back())); } } if(nextNode){ if(nextNode->isEndNode()){ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNodeWeight)); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNodeWeight)); }else{ - nextNode->back()->setPosition(_pm().BSplineHandleReposition(nextNode->back(),nextNode->front())); + nextNode->back()->setPosition(_pm()._bsplineHandleReposition(nextNode->back(),nextNode->front())); } } } @@ -915,13 +915,13 @@ void Node::setType(NodeType type, bool update_handles) } /* in node type changes, about bspline traces, we can mantain them with noPower power in border mode, or we give them the default power in curve mode */ - if(_pm().isBSpline()){ + if(_pm()._isBSpline()){ double weight = noPower; - if(_pm().BSplineHandlePosition(this->front()) != noPower ){ + if(_pm()._bsplineHandlePosition(this->front()) != noPower ){ weight = defaultStartPower; } - _front.setPosition(_pm().BSplineHandleReposition(this->front(),weight)); - _back.setPosition(_pm().BSplineHandleReposition(this->back(),weight)); + _front.setPosition(_pm()._bsplineHandleReposition(this->front(),weight)); + _back.setPosition(_pm()._bsplineHandleReposition(this->back(),weight)); } } _type = type; @@ -1171,9 +1171,9 @@ void Node::_setState(State state) mgr.setActive(_canvas_item, true); mgr.setPrelight(_canvas_item, false); //this shows the handlers when selecting the nodes - if(_pm().isBSpline()){ - this->front()->setPosition(_pm().BSplineHandleReposition(this->front())); - this->back()->setPosition(_pm().BSplineHandleReposition(this->back())); + if(_pm()._isBSpline()){ + this->front()->setPosition(_pm()._bsplineHandleReposition(this->front())); + this->back()->setPosition(_pm()._bsplineHandleReposition(this->back())); } break; } @@ -1433,7 +1433,7 @@ Node *Node::nodeAwayFrom(Handle *h) Glib::ustring Node::_getTip(unsigned state) const { - bool isBSpline = _pm().isBSpline(); + bool isBSpline = _pm()._isBSpline(); Handle *h = const_cast(&_front); Handle *h2 = const_cast(&_back); if (state_held_shift(state)) { @@ -1470,7 +1470,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype); }else if(_selection.size() == 1){ return format_tip(C_("Path node tip", - "BSpline node: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); + "BSpline node: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2)); } return format_tip(C_("Path node tip", "%s: drag to shape the path, click to toggle scale/rotation handles (more: Shift, Ctrl, Alt)"), nodetype); @@ -1480,7 +1480,7 @@ Glib::ustring Node::_getTip(unsigned state) const "%s: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype); }else{ return format_tip(C_("Path node tip", - "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2)); + "BSpline node: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2)); } } diff --git a/src/ui/tool/path-manipulator.cpp b/src/ui/tool/path-manipulator.cpp index dbae69f2c..6b0c95f68 100644 --- a/src/ui/tool/path-manipulator.cpp +++ b/src/ui/tool/path-manipulator.cpp @@ -56,8 +56,8 @@ enum PathChange { }; } // anonymous namespace -const double handleCubicGap = 0.01; -const double noPower = 0.0; +const double HANDLE_CUBIC_GAP = 0.01; +const double NO_POWER = 0.0; const double defaultStartPower = 0.3334; @@ -152,7 +152,7 @@ PathManipulator::PathManipulator(MultiPathManipulator &mpm, SPPath *path, _createControlPointsFromGeometry(); //Define if the path is BSpline on construction - recalculateIsBSpline(); + _recalculateIsBSpline(); } PathManipulator::~PathManipulator() @@ -671,12 +671,12 @@ unsigned PathManipulator::_deleteStretch(NodeList::iterator start, NodeList::ite start = next; } // if we are removing, we readjust the handlers - if(isBSpline()){ + if(_isBSpline()){ if(start.prev()){ - start.prev()->front()->setPosition(BSplineHandleReposition(start.prev()->front(),start.prev()->back())); + start.prev()->front()->setPosition(_bsplineHandleReposition(start.prev()->front(),start.prev()->back())); } if(end){ - end->back()->setPosition(BSplineHandleReposition(end->back(),end->front())); + end->back()->setPosition(_bsplineHandleReposition(end->back(),end->front())); } } @@ -1000,30 +1000,30 @@ NodeList::iterator PathManipulator::subdivideSegment(NodeList::iterator first, d // set new handle positions Node *n = new Node(_multi_path_manipulator._path_data.node_data, seg2[0]); - if(!isBSpline()){ + if(!_isBSpline()){ n->back()->setPosition(seg1[2]); n->front()->setPosition(seg2[1]); n->setType(NODE_SMOOTH, false); } else { - Geom::D2< Geom::SBasis > SBasisInsideNodes; - SPCurve *lineInsideNodes = new SPCurve(); + Geom::D2< Geom::SBasis > sbasis_inside_nodes; + SPCurve *line_inside_nodes = new SPCurve(); if(second->back()->isDegenerate()){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(second->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - Geom::Point next = SBasisInsideNodes.valueAt(defaultStartPower); - next = Geom::Point(next[Geom::X] + handleCubicGap,next[Geom::Y] + handleCubicGap); - lineInsideNodes->reset(); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(second->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + Geom::Point next = sbasis_inside_nodes.valueAt(defaultStartPower); + next = Geom::Point(next[Geom::X] + HANDLE_CUBIC_GAP,next[Geom::Y] + HANDLE_CUBIC_GAP); + line_inside_nodes->reset(); n->front()->setPosition(next); }else{ n->front()->setPosition(seg2[1]); } if(first->front()->isDegenerate()){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(first->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - Geom::Point previous = SBasisInsideNodes.valueAt(defaultStartPower); - previous = Geom::Point(previous[Geom::X] + handleCubicGap,previous[Geom::Y] + handleCubicGap); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(first->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + Geom::Point previous = sbasis_inside_nodes.valueAt(defaultStartPower); + previous = Geom::Point(previous[Geom::X] + HANDLE_CUBIC_GAP,previous[Geom::Y] + HANDLE_CUBIC_GAP); n->back()->setPosition(previous); }else{ n->back()->setPosition(seg1[2]); @@ -1218,16 +1218,16 @@ void PathManipulator::_createControlPointsFromGeometry() } //determines if the trace has a bspline effect and the number of steps that it takes -int PathManipulator::BSplineGetSteps() const { +int PathManipulator::_bsplineGetSteps() const { LivePathEffect::LPEBSpline const *lpe_bsp = NULL; SPLPEItem * path = dynamic_cast(_path); if (path){ if(path->hasPathEffect()){ - Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ - lpe_bsp = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + Inkscape::LivePathEffect::Effect const *this_effect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(this_effect){ + lpe_bsp = dynamic_cast(this_effect->getLPEObj()->get_lpe()); } } } @@ -1239,10 +1239,10 @@ int PathManipulator::BSplineGetSteps() const { } // determines if the trace has bspline effect -void PathManipulator::recalculateIsBSpline(){ +void PathManipulator::_recalculateIsBSpline(){ if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { - Inkscape::LivePathEffect::Effect const *thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); - if(thisEffect){ + Inkscape::LivePathEffect::Effect const *this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE); + if(this_effect){ _is_bspline = true; return; } @@ -1250,61 +1250,61 @@ void PathManipulator::recalculateIsBSpline(){ _is_bspline = false; } -bool PathManipulator::isBSpline() const { +bool PathManipulator::_isBSpline() const { return _is_bspline; } // returns the corresponding strength to the position of the handlers -double PathManipulator::BSplineHandlePosition(Handle *h, Handle *h2) +double PathManipulator::_bsplineHandlePosition(Handle *h, Handle *h2) { using Geom::X; using Geom::Y; if(h2){ h = h2; } - double pos = noPower; + double pos = NO_POWER; Node *n = h->parent(); - Node * nextNode = NULL; - nextNode = n->nodeToward(h); - if(nextNode){ - SPCurve *lineInsideNodes = new SPCurve(); - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(nextNode->position()); + Node * next_node = NULL; + next_node = n->nodeToward(h); + if(next_node){ + SPCurve *line_inside_nodes = new SPCurve(); + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(next_node->position()); if(!are_near(h->position(), n->position())){ - pos = Geom::nearest_point(Geom::Point(h->position()[X] - handleCubicGap, h->position()[Y] - handleCubicGap), *lineInsideNodes->first_segment()); + pos = Geom::nearest_point(Geom::Point(h->position()[X] - HANDLE_CUBIC_GAP, h->position()[Y] - HANDLE_CUBIC_GAP), *line_inside_nodes->first_segment()); } } - if (pos == noPower && !h2){ - return BSplineHandlePosition(h, h->other()); + if (pos == NO_POWER && !h2){ + return _bsplineHandlePosition(h, h->other()); } return pos; } // give the location for the handler in the corresponding position -Geom::Point PathManipulator::BSplineHandleReposition(Handle *h, Handle *h2) +Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h, Handle *h2) { - double pos = this->BSplineHandlePosition(h, h2); - return BSplineHandleReposition(h,pos); + double pos = this->_bsplineHandlePosition(h, h2); + return _bsplineHandleReposition(h,pos); } // give the location for the handler to the specified position -Geom::Point PathManipulator::BSplineHandleReposition(Handle *h,double pos){ +Geom::Point PathManipulator::_bsplineHandleReposition(Handle *h,double pos){ using Geom::X; using Geom::Y; Geom::Point ret = h->position(); Node *n = h->parent(); - Geom::D2< Geom::SBasis > SBasisInsideNodes; - SPCurve *lineInsideNodes = new SPCurve(); - Node * nextNode = NULL; - nextNode = n->nodeToward(h); - if(nextNode && pos != noPower){ - lineInsideNodes->moveto(n->position()); - lineInsideNodes->lineto(nextNode->position()); - SBasisInsideNodes = lineInsideNodes->first_segment()->toSBasis(); - ret = SBasisInsideNodes.valueAt(pos); - ret = Geom::Point(ret[X] + handleCubicGap,ret[Y] + handleCubicGap); + Geom::D2< Geom::SBasis > sbasis_inside_nodes; + SPCurve *line_inside_nodes = new SPCurve(); + Node * next_node = NULL; + next_node = n->nodeToward(h); + if(next_node && pos != NO_POWER){ + line_inside_nodes->moveto(n->position()); + line_inside_nodes->lineto(next_node->position()); + sbasis_inside_nodes = line_inside_nodes->first_segment()->toSBasis(); + ret = sbasis_inside_nodes.valueAt(pos); + ret = Geom::Point(ret[X] + HANDLE_CUBIC_GAP, ret[Y] + HANDLE_CUBIC_GAP); }else{ - if(pos == noPower){ + if(pos == NO_POWER){ ret = n->position(); } } @@ -1319,7 +1319,7 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) { Geom::PathBuilder builder; //Refresh if is bspline some times -think on path change selection, this value get lost - recalculateIsBSpline(); + _recalculateIsBSpline(); for (std::list::iterator spi = _subpaths.begin(); spi != _subpaths.end(); ) { SubpathPtr subpath = *spi; if (subpath->empty()) { @@ -1349,16 +1349,16 @@ void PathManipulator::_createGeometryFromControlPoints(bool alert_LPE) if (alert_LPE) { /// \todo note that _path can be an Inkscape::LivePathEffect::Effect* too, kind of confusing, rework member naming? if (SP_IS_LPE_ITEM(_path) && _path->hasPathEffect()) { - Inkscape::LivePathEffect::Effect* thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); - if(thisEffect){ - LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + Inkscape::LivePathEffect::Effect* this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE); + if(this_effect){ + LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast(this_effect->getLPEObj()->get_lpe()); if (lpe_pwr) { lpe_pwr->adjustForNewPath(pathv); } } - thisEffect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); - if(thisEffect){ - LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(thisEffect->getLPEObj()->get_lpe()); + this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER); + if(this_effect){ + LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast(this_effect->getLPEObj()->get_lpe()); if (lpe_fll) { lpe_fll->adjustForNewPath(pathv); } diff --git a/src/ui/tool/path-manipulator.h b/src/ui/tool/path-manipulator.h index 6dc1c9d09..2219af849 100644 --- a/src/ui/tool/path-manipulator.h +++ b/src/ui/tool/path-manipulator.h @@ -96,7 +96,7 @@ public: NodeList::iterator extremeNode(NodeList::iterator origin, bool search_selected, bool search_unselected, bool closest); - int BSplineGetSteps() const; + int _bsplineGetSteps() const; // this is necessary for Tab-selection in MultiPathManipulator SubpathList &subpathList() { return _subpaths; } @@ -107,11 +107,11 @@ private: void _createControlPointsFromGeometry(); - void recalculateIsBSpline(); - bool isBSpline() const; - double BSplineHandlePosition(Handle *h, Handle *h2 = NULL); - Geom::Point BSplineHandleReposition(Handle *h, Handle *h2 = NULL); - Geom::Point BSplineHandleReposition(Handle *h, double pos); + void _recalculateIsBSpline(); + bool _isBSpline() const; + double _bsplineHandlePosition(Handle *h, Handle *h2 = NULL); + Geom::Point _bsplineHandleReposition(Handle *h, Handle *h2 = NULL); + Geom::Point _bsplineHandleReposition(Handle *h, double pos); void _createGeometryFromControlPoints(bool alert_LPE = false); unsigned _deleteStretch(NodeList::iterator first, NodeList::iterator last, bool keep_shape); std::string _createTypeString(); diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp index 0f14d7534..e8cbfcdbf 100644 --- a/src/ui/tools/freehand-base.cpp +++ b/src/ui/tools/freehand-base.cpp @@ -92,7 +92,7 @@ FreehandBase::FreehandBase(gchar const *const *cursor_shape, gint hot_x, gint ho , white_item(NULL) , white_curves(NULL) , white_anchors(NULL) - , overwriteCurve(NULL) + , overwrite_curve(NULL) , sa(NULL) , ea(NULL) , waiting_LPE_type(Inkscape::LivePathEffect::INVALID_LPE) @@ -149,7 +149,7 @@ void FreehandBase::setup() { this->green_closed = FALSE; // Create start anchor alternative curve - this->overwriteCurve = new SPCurve(); + this->overwrite_curve = new SPCurve(); this->attach = TRUE; spdc_attach_selection(this, this->selection); @@ -575,12 +575,12 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed) } if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){ - dc->overwriteCurve->append_continuous(c, 0.0625); + dc->overwrite_curve->append_continuous(c, 0.0625); c->unref(); - dc->overwriteCurve->closepath_current(); + dc->overwrite_curve->closepath_current(); if(dc->sa){ dc->white_curves = g_slist_remove(dc->white_curves, dc->sa->curve); - dc->white_curves = g_slist_append(dc->white_curves, dc->overwriteCurve); + dc->white_curves = g_slist_append(dc->white_curves, dc->overwrite_curve); } }else{ dc->sa->curve->append_continuous(c, 0.0625); @@ -597,7 +597,7 @@ void spdc_concat_colors_and_flush(FreehandBase *dc, gboolean forceclosed) dc->white_curves = g_slist_remove(dc->white_curves, s); if(prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 1 || prefs->getInt(tool_name(dc) + "/freehand-mode", 0) == 2){ - s = dc->overwriteCurve; + s = dc->overwrite_curve; } if (dc->sa->start) { s = reverse_then_unref(s); diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h index 6b4265215..a3e7b42f9 100644 --- a/src/ui/tools/freehand-base.h +++ b/src/ui/tools/freehand-base.h @@ -78,7 +78,7 @@ public: //ALternative curve to use on continuing exisiting curve in case of bspline or spirolive //because usigh anchor curves give memory and random bugs, - and obscure code- in some plataform reported by su_v in mac - SPCurve *overwriteCurve; + SPCurve *overwrite_curve; // Start anchor SPDrawAnchor *sa; diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp index d5f501163..daffc7032 100644 --- a/src/ui/tools/pen-tool.cpp +++ b/src/ui/tools/pen-tool.cpp @@ -85,7 +85,7 @@ namespace Tools { static Geom::Point pen_drag_origin_w(0, 0); static bool pen_within_tolerance = false; static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical -const double handleCubicGap = 0.01; +const double HANDLE_CUBIC_GAP = 0.01; const std::string& PenTool::getPrefsPath() { return PenTool::prefsPath; @@ -165,17 +165,17 @@ void PenTool::setPolylineMode() { this->polylines_paraxial = (mode == 4); //we call the function which defines the Spiro modes and the BSpline //todo: merge to one function only - this->_pen_context_set_mode(mode); + this->_penContextSetMode(mode); } /* *.Set the mode of draw spiro, and bsplines */ -void PenTool::_pen_context_set_mode(guint mode) { +void PenTool::_penContextSetMode(guint mode) { // define the nodes this->spiro = (mode == 1); this->bspline = (mode == 2); - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); } /** @@ -429,7 +429,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) { // This is allowed, if we just canceled curve case PenTool::POINT: if (this->npoints == 0) { - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); Geom::Point p; if ((bevent.state & GDK_CONTROL_MASK) && (this->polylines_only || this->polylines_paraxial)) { p = event_dt; @@ -451,7 +451,7 @@ bool PenTool::_handleButtonPress(GdkEventButton const &bevent) { this->sa = anchor; if(anchor){ - this->_bspline_spiro_start_anchor(bevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroStartAnchor(bevent.state & GDK_SHIFT_MASK); } if (anchor && (!this->hasWaitingLPE()|| this->bspline || this->spiro)) { // Adjust point to anchor if needed; if we have a waiting LPE, we need @@ -700,10 +700,10 @@ bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) { } // calls the function "bspline_spiro_motion" when the mouse starts or stops moving if(this->bspline){ - this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK); }else{ if ( Geom::LInfty( event_w - pen_drag_origin_w ) > (tolerance/2) || mevent.time == 0) { - this->_bspline_spiro_motion(mevent.state & GDK_SHIFT_MASK); + this->_bsplineSpiroMotion(mevent.state & GDK_SHIFT_MASK); pen_drag_origin_w = event_w; } } @@ -742,7 +742,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) { case PenTool::POINT: if ( this->npoints == 0 ) { // Start new thread only with button release - this->_bspline_spiro_color(); + this->_bsplineSpiroColor(); if (anchor) { p = anchor->dp; } @@ -750,7 +750,7 @@ bool PenTool::_handleButtonRelease(GdkEventButton const &revent) { // continue the existing curve if (anchor) { if(this->bspline || this->spiro){ - this->_bspline_spiro_start_anchor(revent.state & GDK_SHIFT_MASK);; + this->_bsplineSpiroStartAnchor(revent.state & GDK_SHIFT_MASK);; } } this->_setInitialPoint(p); @@ -879,11 +879,11 @@ void PenTool::_redrawAll() { this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data); } // one canvas bpath for all of green_curve - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); } if (this->green_anchor) SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp); @@ -925,7 +925,7 @@ void PenTool::_redrawAll() { // simply redraw the spiro. because its a redrawing, we don't call the global function, // but we call the redrawing at the ending. - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); } void PenTool::_lastpointMove(gdouble x, gdouble y) { @@ -1001,7 +1001,7 @@ void PenTool::_lastpointToCurve() { } //if the last node is an union with another curve if (this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()) { - this->_bspline_spiro_start_anchor(false); + this->_bsplineSpiroStartAnchor(false); } } @@ -1048,7 +1048,7 @@ void PenTool::_lastpointToLine() { } // if the last node is an union with another curve if(this->green_curve->is_empty() && this->sa && !this->sa->curve->is_empty()){ - this->_bspline_spiro_start_anchor(true); + this->_bsplineSpiroStartAnchor(true); } } @@ -1312,7 +1312,7 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t } // this function changes the colors red, green and blue making them transparent or not, depending on if spiro is being used. -void PenTool::_bspline_spiro_color() +void PenTool::_bsplineSpiroColor() { static Inkscape::Preferences *prefs = Inkscape::Preferences::get(); if(this->spiro){ @@ -1346,25 +1346,25 @@ void PenTool::_bspline_spiro_color() this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data); } // one canvas bpath for all of green_curve - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), this->green_curve); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvas_shape), 0, SP_WIND_RULE_NONZERO); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); } sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(this->red_bpath), this->red_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); } -void PenTool::_bspline_spiro(bool shift) +void PenTool::_bsplineSpiro(bool shift) { if(!this->spiro && !this->bspline) return; - shift?this->_bspline_spiro_off():this->_bspline_spiro_on(); - this->_bspline_spiro_build(); + shift?this->_bsplineSpiroOff():this->_bsplineSpiroOn(); + this->_bsplineSpiroBuild(); } -void PenTool::_bspline_spiro_on() +void PenTool::_bsplineSpiroOn() { if(!this->red_curve->is_empty()){ using Geom::X; @@ -1373,11 +1373,11 @@ void PenTool::_bspline_spiro_on() this->p[0] = this->red_curve->first_segment()->initialPoint(); this->p[3] = this->red_curve->first_segment()->finalPoint(); this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); } } -void PenTool::_bspline_spiro_off() +void PenTool::_bsplineSpiroOff() { if(!this->red_curve->is_empty()){ this->npoints = 5; @@ -1387,7 +1387,7 @@ void PenTool::_bspline_spiro_off() } } -void PenTool::_bspline_spiro_start_anchor(bool shift) +void PenTool::_bsplineSpiroStartAnchor(bool shift) { if(this->sa->curve->is_empty()){ return; @@ -1423,73 +1423,73 @@ void PenTool::_bspline_spiro_start_anchor(bool shift) return; if(shift) - this->_bspline_spiro_start_anchor_off(); + this->_bsplineSpiroStartAnchorOff(); else - this->_bspline_spiro_start_anchor_on(); + this->_bsplineSpiroStartAnchorOn(); } -void PenTool::_bspline_spiro_start_anchor_on() +void PenTool::_bsplineSpiroStartAnchorOn() { using Geom::X; using Geom::Y; - SPCurve *tmpCurve = new SPCurve(); - tmpCurve = this->sa->curve->copy(); + SPCurve *tmp_curve = new SPCurve(); + tmp_curve = this->sa->curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); - SPCurve *lastSeg = new SPCurve(); - Geom::Point A = tmpCurve->last_segment()->initialPoint(); - Geom::Point D = tmpCurve->last_segment()->finalPoint(); - Geom::Point C = D + (1./3)*(A - D); - C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap); + tmp_curve = tmp_curve ->create_reverse(); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); + SPCurve *last_segment = new SPCurve(); + Geom::Point point_a = tmp_curve ->last_segment()->initialPoint(); + Geom::Point point_d = tmp_curve ->last_segment()->finalPoint(); + Geom::Point point_c = point_d + (1./3)*(point_a - point_d); + point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP); if(cubic){ - lastSeg->moveto(A); - lastSeg->curveto((*cubic)[1],C,D); + last_segment->moveto(point_a); + last_segment->curveto((*cubic)[1],point_c,point_d); }else{ - lastSeg->moveto(A); - lastSeg->curveto(A,C,D); + last_segment->moveto(point_a); + last_segment->curveto(point_a,point_c,point_d); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (this->sa->start) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - this->overwriteCurve = tmpCurve; + this->overwrite_curve = tmp_curve ; } -void PenTool::_bspline_spiro_start_anchor_off() +void PenTool::_bsplineSpiroStartAnchorOff() { - SPCurve *tmpCurve = new SPCurve(); - tmpCurve = this->sa->curve->copy(); + SPCurve *tmp_curve = new SPCurve(); + tmp_curve = this->sa->curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + tmp_curve = tmp_curve ->create_reverse(); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ - SPCurve *lastSeg = new SPCurve(); - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + SPCurve *last_segment = new SPCurve(); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } } if (this->sa->start) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - this->overwriteCurve = tmpCurve; + this->overwrite_curve = tmp_curve ; } -void PenTool::_bspline_spiro_motion(bool shift){ +void PenTool::_bsplineSpiroMotion(bool shift){ if(!this->spiro && !this->bspline) return; @@ -1497,40 +1497,40 @@ void PenTool::_bspline_spiro_motion(bool shift){ using Geom::Y; if(this->red_curve->is_empty()) return; this->npoints = 5; - SPCurve *tmpCurve = new SPCurve(); + SPCurve *tmp_curve = new SPCurve(); this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); if(this->green_curve->is_empty() && !this->sa){ this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]); - this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap); + this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP); if(shift){ this->p[2] = this->p[3]; } }else if(!this->green_curve->is_empty()){ - tmpCurve = this->green_curve->copy(); + tmp_curve = this->green_curve->copy(); }else{ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(this->sa->start) - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } - if(!tmpCurve->is_empty()){ - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + if(!tmp_curve ->is_empty()){ + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ if(this->bspline){ - SPCurve * WPower = new SPCurve(); - Geom::D2< Geom::SBasis > SBasisWPower; - WPower->moveto(tmpCurve->last_segment()->finalPoint()); - WPower->lineto(tmpCurve->last_segment()->initialPoint()); - float WP = Geom::nearest_point((*cubic)[2],*WPower->first_segment()); - WPower->reset(); - WPower->moveto(this->red_curve->last_segment()->initialPoint()); - WPower->lineto(this->red_curve->last_segment()->finalPoint()); - SBasisWPower = WPower->first_segment()->toSBasis(); - WPower->reset(); - this->p[1] = SBasisWPower.valueAt(WP); + SPCurve * weight_power = new SPCurve(); + Geom::D2< Geom::SBasis > SBasisweight_power; + weight_power->moveto(tmp_curve ->last_segment()->finalPoint()); + weight_power->lineto(tmp_curve ->last_segment()->initialPoint()); + float WP = Geom::nearest_point((*cubic)[2],*weight_power->first_segment()); + weight_power->reset(); + weight_power->moveto(this->red_curve->last_segment()->initialPoint()); + weight_power->lineto(this->red_curve->last_segment()->finalPoint()); + SBasisweight_power = weight_power->first_segment()->toSBasis(); + weight_power->reset(); + this->p[1] = SBasisweight_power.valueAt(WP); if(!Geom::are_near(this->p[1],this->p[0])){ - this->p[1] = Geom::Point(this->p[1][X] + handleCubicGap,this->p[1][Y] + handleCubicGap); + this->p[1] = Geom::Point(this->p[1][X] + HANDLE_CUBIC_GAP,this->p[1][Y] + HANDLE_CUBIC_GAP); } else { this->p[1] = this->p[0]; } @@ -1548,129 +1548,129 @@ void PenTool::_bspline_spiro_motion(bool shift){ if(this->anchor_statusbar && !this->red_curve->is_empty()){ if(shift){ - this->_bspline_spiro_end_anchor_off(); + this->_bsplineSpiroEndAnchorOff(); }else{ - this->_bspline_spiro_end_anchor_on(); + this->_bsplineSpiroEndAnchorOn(); } } - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); } -void PenTool::_bspline_spiro_end_anchor_on() +void PenTool::_bsplineSpiroEndAnchorOn() { using Geom::X; using Geom::Y; this->p[2] = this->p[3] + (1./3)*(this->p[0] - this->p[3]); - this->p[2] = Geom::Point(this->p[2][X] + handleCubicGap,this->p[2][Y] + handleCubicGap); - SPCurve *tmpCurve = new SPCurve(); - SPCurve *lastSeg = new SPCurve(); - Geom::Point C(0,0); + this->p[2] = Geom::Point(this->p[2][X] + HANDLE_CUBIC_GAP,this->p[2][Y] + HANDLE_CUBIC_GAP); + SPCurve *tmp_curve = new SPCurve(); + SPCurve *last_segment = new SPCurve(); + Geom::Point point_c(0,0); bool reverse = false; if( this->green_anchor && this->green_anchor->active ){ - tmpCurve = this->green_curve->create_reverse(); + tmp_curve = this->green_curve->create_reverse(); if(this->green_curve->get_segment_count()==0){ return; } reverse = true; } else if(this->sa){ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(!this->sa->start){ - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); reverse = true; } }else{ return; } - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(this->bspline){ - C = tmpCurve->last_segment()->finalPoint() + (1./3)*(tmpCurve->last_segment()->initialPoint() - tmpCurve->last_segment()->finalPoint()); - C = Geom::Point(C[X] + handleCubicGap,C[Y] + handleCubicGap); + point_c = tmp_curve ->last_segment()->finalPoint() + (1./3)*(tmp_curve ->last_segment()->initialPoint() - tmp_curve ->last_segment()->finalPoint()); + point_c = Geom::Point(point_c[X] + HANDLE_CUBIC_GAP, point_c[Y] + HANDLE_CUBIC_GAP); }else{ - C = this->p[3] + this->p[3] - this->p[2]; + point_c = this->p[3] + this->p[3] - this->p[2]; } if(cubic){ - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],C,(*cubic)[3]); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],point_c,(*cubic)[3]); }else{ - lastSeg->moveto(tmpCurve->last_segment()->initialPoint()); - lastSeg->lineto(tmpCurve->last_segment()->finalPoint()); + last_segment->moveto(tmp_curve ->last_segment()->initialPoint()); + last_segment->lineto(tmp_curve ->last_segment()->finalPoint()); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (reverse) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } if( this->green_anchor && this->green_anchor->active ) { this->green_curve->reset(); - this->green_curve = tmpCurve; + this->green_curve = tmp_curve ; }else{ - this->overwriteCurve->reset(); - this->overwriteCurve = tmpCurve; + this->overwrite_curve->reset(); + this->overwrite_curve = tmp_curve ; } } -void PenTool::_bspline_spiro_end_anchor_off() +void PenTool::_bsplineSpiroEndAnchorOff() { - SPCurve *tmpCurve = new SPCurve(); - SPCurve *lastSeg = new SPCurve(); + SPCurve *tmp_curve = new SPCurve(); + SPCurve *last_segment = new SPCurve(); bool reverse = false; this->p[2] = this->p[3]; if( this->green_anchor && this->green_anchor->active ){ - tmpCurve = this->green_curve->create_reverse(); + tmp_curve = this->green_curve->create_reverse(); if(this->green_curve->get_segment_count()==0){ return; } reverse = true; } else if(this->sa){ - tmpCurve = this->overwriteCurve->copy(); + tmp_curve = this->overwrite_curve->copy(); if(!this->sa->start){ - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); reverse = true; } }else{ return; } - Geom::CubicBezier const * cubic = dynamic_cast(&*tmpCurve->last_segment()); + Geom::CubicBezier const * cubic = dynamic_cast(&*tmp_curve ->last_segment()); if(cubic){ - lastSeg->moveto((*cubic)[0]); - lastSeg->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); + last_segment->moveto((*cubic)[0]); + last_segment->curveto((*cubic)[1],(*cubic)[3],(*cubic)[3]); }else{ - lastSeg->moveto(tmpCurve->last_segment()->initialPoint()); - lastSeg->lineto(tmpCurve->last_segment()->finalPoint()); + last_segment->moveto(tmp_curve ->last_segment()->initialPoint()); + last_segment->lineto(tmp_curve ->last_segment()->finalPoint()); } - if( tmpCurve->get_segment_count() == 1){ - tmpCurve = lastSeg; + if( tmp_curve ->get_segment_count() == 1){ + tmp_curve = last_segment; }else{ //we eliminate the last segment - tmpCurve->backspace(); + tmp_curve ->backspace(); //and we add it again with the recreation - tmpCurve->append_continuous(lastSeg, 0.0625); + tmp_curve ->append_continuous(last_segment, 0.0625); } if (reverse) { - tmpCurve = tmpCurve->create_reverse(); + tmp_curve = tmp_curve ->create_reverse(); } if( this->green_anchor && this->green_anchor->active ) { this->green_curve->reset(); - this->green_curve = tmpCurve; + this->green_curve = tmp_curve ; }else{ - this->overwriteCurve->reset(); - this->overwriteCurve = tmpCurve; + this->overwrite_curve->reset(); + this->overwrite_curve = tmp_curve ; } } //prepares the curves for its transformation into BSpline curve. -void PenTool::_bspline_spiro_build() +void PenTool::_bsplineSpiroBuild() { if(!this->spiro && !this->bspline){ return; @@ -1680,7 +1680,7 @@ void PenTool::_bspline_spiro_build() SPCurve *curve = new SPCurve(); //If we continuate the existing curve we add it at the start if(this->sa && !this->sa->curve->is_empty()){ - curve = this->overwriteCurve->copy(); + curve = this->overwrite_curve->copy(); if (this->sa->start) { curve = curve->create_reverse(); } @@ -1715,9 +1715,9 @@ void PenTool::_bspline_spiro_build() //Effect *spr = static_cast ( new LPEbspline(lpeobj) ); //spr->doEffect(curve); if(this->bspline){ - this->_bspline_doEffect(curve); + this->_bsplineDoEffect(curve); }else{ - this->_spiro_doEffect(curve); + this->_spiroDoEffect(curve); } sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), curve); @@ -1741,66 +1741,73 @@ void PenTool::_bspline_spiro_build() } } -void PenTool::_bspline_doEffect(SPCurve * curve) +//from LPE BSPLINE: +void PenTool::_bsplineDoEffect(SPCurve * curve) { - // commenting the function doEffect in src/live_effects/lpe-bspline.cpp - if (curve->get_segment_count() < 1){ + const double NO_POWER = 0.0; + const double DEFAULT_START_POWER = 0.3334; + const double DEFAULT_END_POWER = 0.6667; + if (curve->get_segment_count() < 1) { return; } // Make copy of old path as it is changed during processing Geom::PathVector const original_pathv = curve->get_pathvector(); + curve->reset(); - //Recorremos todos los paths a los que queremos aplicar el efecto, hasta el - //penúltimo for (Geom::PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) { - //Si está vacío... - if (path_it->empty()) + if (path_it->empty()) { continue; - //Itreadores - + } Geom::Path::const_iterator curve_it1 = path_it->begin(); Geom::Path::const_iterator curve_it2 = ++(path_it->begin()); - Geom::Path::const_iterator curve_endit = path_it->end_default(); - SPCurve *nCurve = new SPCurve(); + Geom::Path::const_iterator curve_endit = path_it->end_default(); + SPCurve *curve_n = new SPCurve(); Geom::Point previousNode(0, 0); Geom::Point node(0, 0); - Geom::Point pointAt1(0, 0); - Geom::Point pointAt2(0, 0); - Geom::Point nextPointAt1(0, 0); - Geom::D2 SBasisIn; - Geom::D2 SBasisOut; - Geom::D2 SBasisHelper; + Geom::Point point_at1(0, 0); + Geom::Point point_at2(0, 0); + Geom::Point next_point_at1(0, 0); + Geom::D2 sbasis_in; + Geom::D2 sbasis_out; + Geom::D2 sbasis_helper; Geom::CubicBezier const *cubic = NULL; if (path_it->closed()) { + // if the path is closed, maybe we have to stop a bit earlier because the + // closing line segment has zerolength. const Geom::Curve &closingline = path_it->back_closed(); // the closing line segment is always of type + // Geom::LineSegment. if (are_near(closingline.initialPoint(), closingline.finalPoint())) { + // closingline.isDegenerate() did not work, because it only checks for + // *exact* zero length, which goes wrong for relative coordinates and + // rounding errors... + // the closing line segment has zero-length. So stop before that one! curve_endit = path_it->end_open(); } } - nCurve->moveto(curve_it1->initialPoint()); + curve_n->moveto(curve_it1->initialPoint()); while (curve_it1 != curve_endit) { SPCurve *in = new SPCurve(); in->moveto(curve_it1->initialPoint()); in->lineto(curve_it1->finalPoint()); cubic = dynamic_cast(&*curve_it1); if (cubic) { - SBasisIn = in->first_segment()->toSBasis(); + sbasis_in = in->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - pointAt1 = SBasisIn.valueAt(0.3334); + point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - pointAt1 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); + point_at1 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[1], *in->first_segment())); } if(are_near((*cubic)[2],(*cubic)[3]) && !are_near((*cubic)[1],(*cubic)[0])) { - pointAt2 = SBasisIn.valueAt(0.6667); + point_at2 = sbasis_in.valueAt(DEFAULT_END_POWER); } else { - pointAt2 = SBasisIn.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); + point_at2 = sbasis_in.valueAt(Geom::nearest_point((*cubic)[2], *in->first_segment())); } } else { - pointAt1 = in->first_segment()->initialPoint(); - pointAt2 = in->first_segment()->finalPoint(); + point_at1 = in->first_segment()->initialPoint(); + point_at2 = in->first_segment()->finalPoint(); } in->reset(); delete in; @@ -1810,31 +1817,30 @@ void PenTool::_bspline_doEffect(SPCurve * curve) out->lineto(curve_it2->finalPoint()); cubic = dynamic_cast(&*curve_it2); if (cubic) { - SBasisOut = out->first_segment()->toSBasis(); + sbasis_out = out->first_segment()->toSBasis(); if(are_near((*cubic)[1],(*cubic)[0]) && !are_near((*cubic)[2],(*cubic)[3])) { - nextPointAt1 = SBasisIn.valueAt(0.3334); + next_point_at1 = sbasis_in.valueAt(DEFAULT_START_POWER); } else { - nextPointAt1 = SBasisOut.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); + next_point_at1 = sbasis_out.valueAt(Geom::nearest_point((*cubic)[1], *out->first_segment())); } } else { - nextPointAt1 = out->first_segment()->initialPoint(); + next_point_at1 = out->first_segment()->initialPoint(); } out->reset(); delete out; } - Geom::Point startNode = path_it->begin()->initialPoint(); if (path_it->closed() && curve_it2 == curve_endit) { SPCurve *start = new SPCurve(); start->moveto(path_it->begin()->initialPoint()); start->lineto(path_it->begin()->finalPoint()); - Geom::D2 SBasisStart = start->first_segment()->toSBasis(); - SPCurve *lineHelper = new SPCurve(); + Geom::D2 sbasis_start = start->first_segment()->toSBasis(); + SPCurve *line_helper = new SPCurve(); cubic = dynamic_cast(&*path_it->begin()); if (cubic) { - lineHelper->moveto(SBasisStart.valueAt( + line_helper->moveto(sbasis_start.valueAt( Geom::nearest_point((*cubic)[1], *start->first_segment()))); } else { - lineHelper->moveto(start->first_segment()->initialPoint()); + line_helper->moveto(start->first_segment()->initialPoint()); } start->reset(); delete start; @@ -1842,55 +1848,56 @@ void PenTool::_bspline_doEffect(SPCurve * curve) SPCurve *end = new SPCurve(); end->moveto(curve_it1->initialPoint()); end->lineto(curve_it1->finalPoint()); - Geom::D2 SBasisEnd = end->first_segment()->toSBasis(); + Geom::D2 sbasis_end = end->first_segment()->toSBasis(); cubic = dynamic_cast(&*curve_it1); if (cubic) { - lineHelper->lineto(SBasisEnd.valueAt( + line_helper->lineto(sbasis_end.valueAt( Geom::nearest_point((*cubic)[2], *end->first_segment()))); } else { - lineHelper->lineto(end->first_segment()->finalPoint()); + line_helper->lineto(end->first_segment()->finalPoint()); } end->reset(); delete end; - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; - startNode = SBasisHelper.valueAt(0.5); - nCurve->curveto(pointAt1, pointAt2, startNode); - nCurve->move_endpoints(startNode, startNode); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; + node = sbasis_helper.valueAt(0.5); + curve_n->curveto(point_at1, point_at2, node); + curve_n->move_endpoints(node, node); } else if ( curve_it2 == curve_endit) { - nCurve->curveto(pointAt1, pointAt2, curve_it1->finalPoint()); - nCurve->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); + curve_n->curveto(point_at1, point_at2, curve_it1->finalPoint()); + curve_n->move_endpoints(path_it->begin()->initialPoint(), curve_it1->finalPoint()); } else { - SPCurve *lineHelper = new SPCurve(); - lineHelper->moveto(pointAt2); - lineHelper->lineto(nextPointAt1); - SBasisHelper = lineHelper->first_segment()->toSBasis(); - lineHelper->reset(); - delete lineHelper; + SPCurve *line_helper = new SPCurve(); + line_helper->moveto(point_at2); + line_helper->lineto(next_point_at1); + sbasis_helper = line_helper->first_segment()->toSBasis(); + line_helper->reset(); + delete line_helper; previousNode = node; - node = SBasisHelper.valueAt(0.5); + node = sbasis_helper.valueAt(0.5); Geom::CubicBezier const *cubic2 = dynamic_cast(&*curve_it1); if((cubic && are_near((*cubic)[0],(*cubic)[1])) || (cubic2 && are_near((*cubic2)[2],(*cubic2)[3]))) { node = curve_it1->finalPoint(); } - nCurve->curveto(pointAt1, pointAt2, node); + curve_n->curveto(point_at1, point_at2, node); } ++curve_it1; ++curve_it2; } + //y cerramos la curva if (path_it->closed()) { - nCurve->closepath_current(); + curve_n->closepath_current(); } - curve->append(nCurve, false); - nCurve->reset(); - delete nCurve; + curve->append(curve_n, false); + curve_n->reset(); + delete curve_n; } } //Spiro function cloned from lpe-spiro.cpp // commenting the function "doEffect" from src/live_effects/lpe-spiro.cpp -void PenTool::_spiro_doEffect(SPCurve * curve) +void PenTool::_spiroDoEffect(SPCurve * curve) { using Geom::X; using Geom::Y; @@ -2087,16 +2094,16 @@ void PenTool::_finishSegment(Geom::Point const p, guint const state) { if (!this->red_curve->is_empty()) { - this->_bspline_spiro(state & GDK_SHIFT_MASK); + this->_bsplineSpiro(state & GDK_SHIFT_MASK); this->green_curve->append_continuous(this->red_curve, 0.0625); SPCurve *curve = this->red_curve->copy(); /// \todo fixme: - SPCanvasItem *cshape = sp_canvas_bpath_new(this->desktop->getSketch(), curve); + SPCanvasItem *canvas_shape = sp_canvas_bpath_new(this->desktop->getSketch(), curve); curve->unref(); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); + sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvas_shape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape); + this->green_bpaths = g_slist_prepend(this->green_bpaths, canvas_shape); this->p[0] = this->p[3]; this->p[1] = this->p[4]; @@ -2185,7 +2192,7 @@ bool PenTool::_undoLastPoint() { pen_last_paraxial_dir = !pen_last_paraxial_dir; //redraw - this->_bspline_spiro_build(); + this->_bsplineSpiroBuild(); ret = true; } @@ -2210,7 +2217,7 @@ void PenTool::_finish(gboolean const closed) { // cancelate line without a created segment this->red_curve->reset(); spdc_concat_colors_and_flush(this, closed); - this->overwriteCurve = NULL; + this->overwrite_curve = NULL; this->sa = NULL; this->ea = NULL; diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h index 2208005c5..0ae16caf0 100644 --- a/src/ui/tools/pen-tool.h +++ b/src/ui/tools/pen-tool.h @@ -89,33 +89,33 @@ private: bool _handle2ButtonPress(GdkEventButton const &bevent); bool _handleKeyPress(GdkEvent *event); //adds spiro & bspline modes - void _pen_context_set_mode(guint mode); + void _penContextSetMode(guint mode); //this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro - void _bspline_spiro_color(); + void _bsplineSpiroColor(); //creates a node in bspline or spiro modes - void _bspline_spiro(bool shift); + void _bsplineSpiro(bool shift); //creates a node in bspline or spiro modes - void _bspline_spiro_on(); + void _bsplineSpiroOn(); //creates a CUSP node - void _bspline_spiro_off(); + void _bsplineSpiroOff(); //continues the existing curve in bspline or spiro mode - void _bspline_spiro_start_anchor(bool shift); + void _bsplineSpiroStartAnchor(bool shift); //continues the existing curve with the union node in bspline or spiro modes - void _bspline_spiro_start_anchor_on(); + void _bsplineSpiroStartAnchorOn(); //continues an existing curve with the union node in CUSP mode - void _bspline_spiro_start_anchor_off(); + void _bsplineSpiroStartAnchorOff(); //modifies the "red_curve" when it detects movement - void _bspline_spiro_motion(bool shift); + void _bsplineSpiroMotion(bool shift); //closes the curve with the last node in bspline or spiro mode - void _bspline_spiro_end_anchor_on(); + void _bsplineSpiroEndAnchorOn(); //closes the curve with the last node in CUSP mode - void _bspline_spiro_end_anchor_off(); + void _bsplineSpiroEndAnchorOff(); //CHECK: join all the curves "in game" and we call doEffect function - void _bspline_spiro_build(); + void _bsplineSpiroBuild(); //function bspline cloned from lpe-bspline.cpp - void _bspline_doEffect(SPCurve * curve); + void _bsplineDoEffect(SPCurve * curve); //function spiro cloned from lpe-spiro.cpp - void _spiro_doEffect(SPCurve * curve); + void _spiroDoEffect(SPCurve * curve); void _setInitialPoint(Geom::Point const p); void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0); diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp index db24c7432..008804162 100644 --- a/src/ui/tools/pencil-tool.cpp +++ b/src/ui/tools/pencil-tool.cpp @@ -191,7 +191,7 @@ bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) { } if (anchor) { p = anchor->dp; - this->overwriteCurve = anchor->curve; + this->overwrite_curve = anchor->curve; desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Continuing selected path")); } else { m.setup(desktop); @@ -663,11 +663,11 @@ void PencilTool::_interpolate() { for (int c = 0; c < n_segs; c++) { // if we are in BSpline we modify the trace to create adhoc nodes if(mode == 2){ - Geom::Point BP = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]); - BP = Geom::Point(BP[X] + 0.0001,BP[Y] + 0.0001); - Geom::Point CP = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]); - CP = Geom::Point(CP[X] + 0.0001,CP[Y] + 0.0001); - this->green_curve->curveto(BP,CP,b[4*c+3]); + Geom::Point point_at1 = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]); + point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001); + Geom::Point point_at2 = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]); + point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001); + this->green_curve->curveto(point_at1,point_at2,b[4*c+3]); }else{ this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]); } @@ -810,11 +810,11 @@ void PencilTool::_fitAndSplit() { // if we are in BSpline we modify the trace to create adhoc nodes guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0); if(mode == 2){ - Geom::Point B = b[0] + (1./3)*(b[3] - b[0]); - B = Geom::Point(B[X] + 0.0001,B[Y] + 0.0001); - Geom::Point C = b[3] + (1./3)*(b[0] - b[3]); - C = Geom::Point(C[X] + 0.0001,C[Y] + 0.0001); - this->red_curve->curveto(B,C,b[3]); + Geom::Point point_at1 = b[0] + (1./3)*(b[3] - b[0]); + point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001); + Geom::Point point_at2 = b[3] + (1./3)*(b[0] - b[3]); + point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001); + this->red_curve->curveto(point_at1,point_at2,b[3]); }else{ this->red_curve->curveto(b[1], b[2], b[3]); } -- cgit v1.2.3 From d5f4e25e196928fdc80e076432ea486d89abf931 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20W=C3=BCst?= Date: Fri, 10 Apr 2015 20:52:44 +0200 Subject: added info about multiple pen feature in gui (bzr r14055) --- share/extensions/hpgl_output.inx | 14 ++++++++------ share/extensions/plotter.inx | 24 +++++++++++++----------- 2 files changed, 21 insertions(+), 17 deletions(-) diff --git a/share/extensions/hpgl_output.inx b/share/extensions/hpgl_output.inx index bfb3e3567..7fa900dc8 100644 --- a/share/extensions/hpgl_output.inx +++ b/share/extensions/hpgl_output.inx @@ -22,14 +22,16 @@ false false - false + false +   + <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above. - 1.00 - 0.25 - true - 1.2 - true + 1.00 + 0.25 + true + 1.2 + true <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter. diff --git a/share/extensions/plotter.inx b/share/extensions/plotter.inx index cc916fe08..17b2ff185 100644 --- a/share/extensions/plotter.inx +++ b/share/extensions/plotter.inx @@ -65,9 +65,9 @@ 1016.0 1016.0 - 1 - 0 - 0 + 1 + 0 + 0 0 90 @@ -76,16 +76,18 @@ false false - false + false +   + <_param name="multiplePensHelp" type="description">If you want to use multiple pens on your pen plotter create one layer for each pen, name the layers "Pen 1", "Pen 2", etc., and put your drawings in the corresponding layers. This overrules the pen number option above. - 1.00 - 0.25 - true - 1.2 - true -   - false + 1.00 + 0.25 + true + 1.2 + true +   + false <_param name="settingsHelp" type="description">All these settings depend on the plotter you use, for more information please consult the manual or homepage for your plotter. -- cgit v1.2.3