From e2d2279032ac0e7c1767551ac3d9bed7a94388bd Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Tue, 27 Jan 2015 23:09:47 +0100 Subject: Create a empty LPE (bzr r13879.1.1) --- src/live_effects/lpe-transform_2pts.cpp | 47 +++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 src/live_effects/lpe-transform_2pts.cpp (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp new file mode 100644 index 000000000..95555b80e --- /dev/null +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -0,0 +1,47 @@ +/** \file + * LPE "Transform through 2 points" implementation + */ + +/* + * Authors: + * + * + * + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#include "live_effects/lpe-transform_2pts.h" + +namespace Inkscape { +namespace LivePathEffect { + +LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : + Effect(lpeobject) +{ +} + +LPETransform2Pts::~LPETransform2Pts() +{ +} + +std::vector +LPETransform2Pts::doEffect_path (std::vector const & path_in) +{ + return path_in; +} + +/* ######################## */ + +} //namespace LivePathEffect +} /* namespace Inkscape */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : -- cgit v1.2.3 From c75f15ce27ce08091e85c1d23b0e3d9bbd9aa13c Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sun, 1 Feb 2015 20:37:22 +0100 Subject: adde parameter to select knot node position (bzr r13879.1.4) --- src/live_effects/lpe-transform_2pts.cpp | 108 +++++++++++++++++++++++++++++--- 1 file changed, 98 insertions(+), 10 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 142070578..bb126b2bb 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -33,11 +33,18 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), fromOriginalWidth(_("Use bounding box"), _("Use bounding box"), "fromOriginalWidth", &wr, this, false), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), - end(_("End"), _("End point"), "end", &wr, this, "End point") + end(_("End"), _("End point"), "end", &wr, this, "End point"), + firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1), + lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1) { - registerParameter(&fromOriginalWidth); registerParameter(&start); registerParameter(&end); + registerParameter(&firstKnot); + registerParameter(&lastKnot); + registerParameter(&fromOriginalWidth); + + firstKnot.param_make_integer(true); + lastKnot.param_make_integer(true); } LPETransform2Pts::~LPETransform2Pts() @@ -60,6 +67,8 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) if(!c->is_closed() && c->first_path() == c->last_path()){ A = *(c->first_point()); B = *(c->last_point()); + int nnodes = (int)c->nodes_in_path(); + lastKnot.param_set_value((int)c->nodes_in_path()); } } start.param_setValue(A); @@ -73,25 +82,93 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) original_bbox(lpeitem); SPLPEItem* item = const_cast(lpeitem); SPPath *path = dynamic_cast(item); - if(fromOriginalWidth || !path ){ - A = Point(boundingbox_X.min(), boundingbox_Y.middle()); - B = Point(boundingbox_X.max(), boundingbox_Y.middle()); - } + A = Point(boundingbox_X.min(), boundingbox_Y.middle()); + B = Point(boundingbox_X.max(), boundingbox_Y.middle()); if(path && !fromOriginalWidth){ SPCurve * c = NULL; c = path->get_original_curve(); - if(!c->is_closed()){ - A = *(c->first_point()); - B = *(c->last_point()); + if(!c->is_closed() && c->first_path() == c->last_path()){ + Geom::PathVector const originalPV = c->get_pathvector(); + A = originalPV[0][0].initialPoint(); + if((int)firstKnot > 1){ + A = originalPV[0][(int)firstKnot-2].finalPoint(); + } + B = originalPV[0][0].initialPoint(); + if((int)lastKnot > 1){ + B = originalPV[0][(int)lastKnot-2].finalPoint(); + } + int nnodes = (int)c->nodes_in_path(); + firstKnot.param_set_range(1, lastKnot-1); + lastKnot.param_set_range(firstKnot+1, nnodes); + } else { + firstKnot.param_set_value(1); + lastKnot.param_set_value(2); + firstKnot.param_set_range(1,1); + lastKnot.param_set_range(2,2); } + } else { + firstKnot.param_set_value(1); + lastKnot.param_set_value(2); + firstKnot.param_set_range(1,1); + lastKnot.param_set_range(2,2); } item->apply_to_clippath(item); item->apply_to_mask(item); } void -LPETransform2Pts::reset () +LPETransform2Pts::updateIndex() +{ + SPPath *path = dynamic_cast(sp_lpe_item); + if(path && !fromOriginalWidth){ + SPCurve * c = NULL; + c = path->get_original_curve(); + int nnodes = (int)c->nodes_in_path(); + if(!c->is_closed() && c->first_path() == c->last_path()){ + c->reset(); + c = path->getCurve(); + Geom::PathVector const originalPV = c->get_pathvector(); + Geom::Point C = originalPV[0][0].initialPoint(); + Geom::Point D = originalPV[0][0].initialPoint(); + if((int)firstKnot > 1){ + C = originalPV[0][(int)firstKnot-2].finalPoint(); + } + if((int)lastKnot > 1){ + D = originalPV[0][(int)lastKnot-2].finalPoint(); + } + start.param_update_default(C); + start.param_set_and_write_default(); + end.param_update_default(D); + end.param_set_and_write_default(); + start.param_update_default(A); + end.param_update_default(B); + start.param_set_and_write_default(); + end.param_set_and_write_default(); + SPDesktop * desktop = SP_ACTIVE_DESKTOP; + tools_switch(desktop, TOOLS_SELECT); + tools_switch(desktop, TOOLS_NODES); + } + } +} + +void +LPETransform2Pts::reset() { + SPPath *path = dynamic_cast(sp_lpe_item); + A = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); + B = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); + if(path && !fromOriginalWidth){ + SPCurve * c = NULL; + c = path->get_original_curve(); + int nnodes = (int)c->nodes_in_path(); + firstKnot.param_set_value(1); + lastKnot.param_set_value(nnodes); + A = *(c->first_point()); + B = *(c->last_point()); + } else { + firstKnot.param_set_value(1); + lastKnot.param_set_value(2); + } start.param_update_default(A); end.param_update_default(B); start.param_set_and_write_default(); @@ -118,6 +195,17 @@ Gtk::Widget *LPETransform2Pts::newWidget() Parameter *param = *it; Gtk::Widget *widg = dynamic_cast(param->param_newWidget()); Glib::ustring *tip = param->param_getTooltip(); + if (param->param_key == "firstKnot" || param->param_key == "lastKnot") { + Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast(widg)); + widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPETransform2Pts::updateIndex)); + widg = widgRegistered; + if (widg) { + Gtk::HBox *scalarParameter = dynamic_cast(widg); + std::vector childList = scalarParameter->get_children(); + Gtk::Entry *entryWidg = dynamic_cast(childList[1]); + entryWidg->set_width_chars(3); + } + } if (widg) { vbox->pack_start(*widg, true, true, 2); if (tip) { -- cgit v1.2.3 From d9e84828804bef871c833e6b749a826f29c0e153 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Mon, 2 Feb 2015 22:59:36 +0100 Subject: Fix some problems pointed by su_v (bzr r13879.1.7) --- src/live_effects/lpe-transform_2pts.cpp | 35 +++++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 8 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index bb126b2bb..049212302 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -23,7 +23,7 @@ #include <2geom/path.h> #include "sp-path.h" #include "ui/tools-switch.h" - +#include "ui/icon-names.h" #include "inkscape.h" namespace Inkscape { @@ -31,7 +31,7 @@ namespace LivePathEffect { LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), - fromOriginalWidth(_("Use bounding box"), _("Use bounding box"), "fromOriginalWidth", &wr, this, false), + fromOriginalWidth(_("From original width"), _("From original width"), "fromOriginalWidth", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1), @@ -68,7 +68,7 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) A = *(c->first_point()); B = *(c->last_point()); int nnodes = (int)c->nodes_in_path(); - lastKnot.param_set_value((int)c->nodes_in_path()); + lastKnot.param_set_value(nnodes); } } start.param_setValue(A); @@ -79,6 +79,10 @@ void LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) { using namespace Geom; + if(fromOriginalWidthToogler != fromOriginalWidth){ + fromOriginalWidthToogler = fromOriginalWidth; + reset(); + } original_bbox(lpeitem); SPLPEItem* item = const_cast(lpeitem); SPPath *path = dynamic_cast(item); @@ -100,17 +104,20 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) int nnodes = (int)c->nodes_in_path(); firstKnot.param_set_range(1, lastKnot-1); lastKnot.param_set_range(firstKnot+1, nnodes); + fromOriginalWidth.param_setValue(false); } else { firstKnot.param_set_value(1); lastKnot.param_set_value(2); firstKnot.param_set_range(1,1); lastKnot.param_set_range(2,2); + fromOriginalWidth.param_setValue(true); } } else { firstKnot.param_set_value(1); lastKnot.param_set_value(2); firstKnot.param_set_range(1,1); lastKnot.param_set_range(2,2); + fromOriginalWidth.param_setValue(true); } item->apply_to_clippath(item); item->apply_to_mask(item); @@ -123,7 +130,6 @@ LPETransform2Pts::updateIndex() if(path && !fromOriginalWidth){ SPCurve * c = NULL; c = path->get_original_curve(); - int nnodes = (int)c->nodes_in_path(); if(!c->is_closed() && c->first_path() == c->last_path()){ c->reset(); c = path->getCurve(); @@ -161,6 +167,8 @@ LPETransform2Pts::reset() SPCurve * c = NULL; c = path->get_original_curve(); int nnodes = (int)c->nodes_in_path(); + firstKnot.param_set_range(1, lastKnot-1); + lastKnot.param_set_range(firstKnot+1, nnodes); firstKnot.param_set_value(1); lastKnot.param_set_value(nnodes); A = *(c->first_point()); @@ -189,7 +197,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() vbox->set_spacing(6); std::vector::iterator it = param_vector.begin(); - + Gtk::HBox * button = Gtk::manage(new Gtk::HBox(true,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter *param = *it; @@ -206,6 +214,19 @@ Gtk::Widget *LPETransform2Pts::newWidget() entryWidg->set_width_chars(3); } } + if (param->param_key == "fromOriginalWidth") + { + Glib::ustring * tip = param->param_getTooltip(); + if (widg) { + button->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } + } + } if (widg) { vbox->pack_start(*widg, true, true, 2); if (tip) { @@ -219,11 +240,9 @@ Gtk::Widget *LPETransform2Pts::newWidget() ++it; } - Gtk::HBox * button = Gtk::manage(new Gtk::HBox(true,0)); Gtk::Button *reset = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset")))); reset->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::reset)); - reset->set_size_request(140,45); - button->pack_start(*reset, false, false, 2); + button->pack_start(*reset, true, true, 2); vbox->pack_start(*button, true, true, 2); return dynamic_cast(vbox); } -- cgit v1.2.3 From dd7b327403513170b6ab3fb4413dd90b61d91157 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 5 Feb 2015 00:00:49 +0100 Subject: fixing bugs on reset function (bzr r13879.1.8) --- src/live_effects/lpe-transform_2pts.cpp | 139 ++++++++++++++++++-------------- 1 file changed, 77 insertions(+), 62 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 049212302..cb5180f4d 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -10,14 +10,9 @@ * Released under GNU GPL, read the file 'COPYING' for more information */ -#ifdef HAVE_CONFIG_H -# include -#endif - #include #include "live_effects/lpe-transform_2pts.h" -#include #include "display/curve.h" #include <2geom/transforms.h> #include <2geom/path.h> @@ -26,6 +21,8 @@ #include "ui/icon-names.h" #include "inkscape.h" +#include + namespace Inkscape { namespace LivePathEffect { @@ -35,7 +32,10 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1), - lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1) + lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1), + fromOriginalWidthToogler(true), + A(Geom::Point(0,0)), + B(Geom::Point(0,0)) { registerParameter(&start); registerParameter(&end); @@ -59,38 +59,40 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) A = Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Point(boundingbox_X.max(), boundingbox_Y.middle()); - SPLPEItem* item = const_cast(lpeitem); - SPPath *path = dynamic_cast(item); + SPLPEItem * splpeitem = const_cast(lpeitem); + SPCurve * c = NULL; + SPPath *path = dynamic_cast(splpeitem); if (path) { - SPCurve * c = NULL; c = path->get_original_curve(); - if(!c->is_closed() && c->first_path() == c->last_path()){ - A = *(c->first_point()); - B = *(c->last_point()); - int nnodes = (int)c->nodes_in_path(); - lastKnot.param_set_value(nnodes); - } } - start.param_setValue(A); - end.param_setValue(B); + if(c && !c->is_closed() && c->first_path() == c->last_path()){ + A = *(c->first_point()); + B = *(c->last_point()); + int nnodes = (int)c->nodes_in_path(); + lastKnot.param_set_value(nnodes); + } + start.param_update_default(A); + start.param_set_and_write_default(); + end.param_update_default(B); + end.param_set_and_write_default(); } void LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) { using namespace Geom; - if(fromOriginalWidthToogler != fromOriginalWidth){ - fromOriginalWidthToogler = fromOriginalWidth; - reset(); - } + original_bbox(lpeitem); - SPLPEItem* item = const_cast(lpeitem); - SPPath *path = dynamic_cast(item); A = Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Point(boundingbox_X.max(), boundingbox_Y.middle()); - if(path && !fromOriginalWidth){ - SPCurve * c = NULL; + + SPLPEItem * splpeitem = const_cast(lpeitem); + SPCurve * c = NULL; + SPPath *path = dynamic_cast(splpeitem); + if (path) { c = path->get_original_curve(); + } + if(c && !fromOriginalWidth){ if(!c->is_closed() && c->first_path() == c->last_path()){ Geom::PathVector const originalPV = c->get_pathvector(); A = originalPV[0][0].initialPoint(); @@ -119,53 +121,62 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) lastKnot.param_set_range(2,2); fromOriginalWidth.param_setValue(true); } - item->apply_to_clippath(item); - item->apply_to_mask(item); + if(fromOriginalWidthToogler != fromOriginalWidth){ + fromOriginalWidthToogler = fromOriginalWidth; + reset(); + } + splpeitem->apply_to_clippath(splpeitem); + splpeitem->apply_to_mask(splpeitem); } void LPETransform2Pts::updateIndex() { - SPPath *path = dynamic_cast(sp_lpe_item); - if(path && !fromOriginalWidth){ - SPCurve * c = NULL; - c = path->get_original_curve(); - if(!c->is_closed() && c->first_path() == c->last_path()){ - c->reset(); - c = path->getCurve(); - Geom::PathVector const originalPV = c->get_pathvector(); - Geom::Point C = originalPV[0][0].initialPoint(); - Geom::Point D = originalPV[0][0].initialPoint(); - if((int)firstKnot > 1){ - C = originalPV[0][(int)firstKnot-2].finalPoint(); - } - if((int)lastKnot > 1){ - D = originalPV[0][(int)lastKnot-2].finalPoint(); - } - start.param_update_default(C); - start.param_set_and_write_default(); - end.param_update_default(D); - end.param_set_and_write_default(); - start.param_update_default(A); - end.param_update_default(B); - start.param_set_and_write_default(); - end.param_set_and_write_default(); - SPDesktop * desktop = SP_ACTIVE_DESKTOP; - tools_switch(desktop, TOOLS_SELECT); - tools_switch(desktop, TOOLS_NODES); + SPCurve * c = NULL; + SPCurve * c2 = NULL; + SPShape *shape = SP_SHAPE(sp_lpe_item); + if (shape) { + c = shape->getCurve(); + SPPath *path = dynamic_cast(shape); + if (path) { + c2 = path->get_original_curve(); + } + } + if(c && c2 && !fromOriginalWidth && !c2->is_closed() && c2->first_path() == c2->last_path()){ + Geom::PathVector const originalPV = c->get_pathvector(); + Geom::Point C = originalPV[0][0].initialPoint(); + Geom::Point D = originalPV[0][0].initialPoint(); + if((int)firstKnot > 1){ + C = originalPV[0][(int)firstKnot-2].finalPoint(); + } + if((int)lastKnot > 1){ + D = originalPV[0][(int)lastKnot-2].finalPoint(); } + start.param_update_default(C); + start.param_set_and_write_default(); + end.param_update_default(D); + end.param_set_and_write_default(); + start.param_update_default(A); + end.param_update_default(B); + start.param_set_and_write_default(); + end.param_set_and_write_default(); + SPDesktop * desktop = SP_ACTIVE_DESKTOP; + tools_switch(desktop, TOOLS_SELECT); + tools_switch(desktop, TOOLS_NODES); } } void LPETransform2Pts::reset() { - SPPath *path = dynamic_cast(sp_lpe_item); A = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); - if(path && !fromOriginalWidth){ - SPCurve * c = NULL; + SPCurve * c = NULL; + SPPath *path = dynamic_cast(sp_lpe_item); + if (path) { c = path->get_original_curve(); + } + if(c && !fromOriginalWidth){ int nnodes = (int)c->nodes_in_path(); firstKnot.param_set_range(1, lastKnot-1); lastKnot.param_set_range(firstKnot+1, nnodes); @@ -212,10 +223,15 @@ Gtk::Widget *LPETransform2Pts::newWidget() std::vector childList = scalarParameter->get_children(); Gtk::Entry *entryWidg = dynamic_cast(childList[1]); entryWidg->set_width_chars(3); + vbox->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } } - } - if (param->param_key == "fromOriginalWidth") - { + } else if (param->param_key == "fromOriginalWidth"){ Glib::ustring * tip = param->param_getTooltip(); if (widg) { button->pack_start(*widg, true, true, 2); @@ -226,8 +242,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } - if (widg) { + } else if (widg) { vbox->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); -- cgit v1.2.3 From 56acf863aae3ec2f54ef049698489e65f0356e22 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 5 Feb 2015 02:39:07 +0100 Subject: fixed bugs pointed by su_v (bzr r13879.1.9) --- src/live_effects/lpe-transform_2pts.cpp | 43 +++++++++++++++------------------ 1 file changed, 19 insertions(+), 24 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index cb5180f4d..5a7d1b16d 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -33,9 +33,11 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : end(_("End"), _("End point"), "end", &wr, this, "End point"), firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1), lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1), - fromOriginalWidthToogler(true), + fromOriginalWidthToogler(false), A(Geom::Point(0,0)), - B(Geom::Point(0,0)) + B(Geom::Point(0,0)), + c(NULL), + appandedPath(false) { registerParameter(&start); registerParameter(&end); @@ -60,7 +62,6 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) A = Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); - SPCurve * c = NULL; SPPath *path = dynamic_cast(splpeitem); if (path) { c = path->get_original_curve(); @@ -81,19 +82,22 @@ void LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) { using namespace Geom; - original_bbox(lpeitem); A = Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); - SPCurve * c = NULL; SPPath *path = dynamic_cast(splpeitem); if (path) { c = path->get_original_curve(); } + if(fromOriginalWidthToogler != fromOriginalWidth){ + fromOriginalWidthToogler = fromOriginalWidth; + reset(); + } if(c && !fromOriginalWidth){ if(!c->is_closed() && c->first_path() == c->last_path()){ + appandedPath = false; Geom::PathVector const originalPV = c->get_pathvector(); A = originalPV[0][0].initialPoint(); if((int)firstKnot > 1){ @@ -112,7 +116,11 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) lastKnot.param_set_value(2); firstKnot.param_set_range(1,1); lastKnot.param_set_range(2,2); - fromOriginalWidth.param_setValue(true); + if(appandedPath == false){ + appandedPath = true; + } else { + fromOriginalWidth.param_setValue(true); + } } } else { firstKnot.param_set_value(1); @@ -120,10 +128,7 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) firstKnot.param_set_range(1,1); lastKnot.param_set_range(2,2); fromOriginalWidth.param_setValue(true); - } - if(fromOriginalWidthToogler != fromOriginalWidth){ - fromOriginalWidthToogler = fromOriginalWidth; - reset(); + appandedPath = false; } splpeitem->apply_to_clippath(splpeitem); splpeitem->apply_to_mask(splpeitem); @@ -132,18 +137,13 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) void LPETransform2Pts::updateIndex() { - SPCurve * c = NULL; SPCurve * c2 = NULL; SPShape *shape = SP_SHAPE(sp_lpe_item); if (shape) { - c = shape->getCurve(); - SPPath *path = dynamic_cast(shape); - if (path) { - c2 = path->get_original_curve(); - } + c2 = shape->getCurve(); } - if(c && c2 && !fromOriginalWidth && !c2->is_closed() && c2->first_path() == c2->last_path()){ - Geom::PathVector const originalPV = c->get_pathvector(); + if(c2 && !fromOriginalWidth && !c->is_closed() && c->first_path() == c->last_path()){ + Geom::PathVector const originalPV = c2->get_pathvector(); Geom::Point C = originalPV[0][0].initialPoint(); Geom::Point D = originalPV[0][0].initialPoint(); if((int)firstKnot > 1){ @@ -171,12 +171,7 @@ LPETransform2Pts::reset() { A = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); B = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); - SPCurve * c = NULL; - SPPath *path = dynamic_cast(sp_lpe_item); - if (path) { - c = path->get_original_curve(); - } - if(c && !fromOriginalWidth){ + if(c && !c->is_closed() && c->first_path() == c->last_path() && !fromOriginalWidth){ int nnodes = (int)c->nodes_in_path(); firstKnot.param_set_range(1, lastKnot-1); lastKnot.param_set_range(firstKnot+1, nnodes); -- cgit v1.2.3 From 2b7ed651e29bd2f4f22830d8a0525609478a33ff Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 19 Mar 2015 13:07:13 +0100 Subject: Fixed compiling problems and removed ACTIVE DESKTOP from LPE (bzr r13879.1.13) --- src/live_effects/lpe-transform_2pts.cpp | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 5a7d1b16d..9b8c1879a 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -17,9 +17,7 @@ #include <2geom/transforms.h> #include <2geom/path.h> #include "sp-path.h" -#include "ui/tools-switch.h" #include "ui/icon-names.h" -#include "inkscape.h" #include @@ -73,9 +71,9 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) lastKnot.param_set_value(nnodes); } start.param_update_default(A); - start.param_set_and_write_default(); + start.param_set_default(); end.param_update_default(B); - end.param_set_and_write_default(); + end.param_set_default(); } void @@ -153,16 +151,13 @@ LPETransform2Pts::updateIndex() D = originalPV[0][(int)lastKnot-2].finalPoint(); } start.param_update_default(C); - start.param_set_and_write_default(); + start.param_set_default(); end.param_update_default(D); - end.param_set_and_write_default(); + end.param_set_default(); start.param_update_default(A); end.param_update_default(B); - start.param_set_and_write_default(); - end.param_set_and_write_default(); - SPDesktop * desktop = SP_ACTIVE_DESKTOP; - tools_switch(desktop, TOOLS_SELECT); - tools_switch(desktop, TOOLS_NODES); + start.param_set_default(); + end.param_set_default(); } } @@ -185,11 +180,8 @@ LPETransform2Pts::reset() } start.param_update_default(A); end.param_update_default(B); - start.param_set_and_write_default(); - end.param_set_and_write_default(); - SPDesktop * desktop = SP_ACTIVE_DESKTOP; - tools_switch(desktop, TOOLS_SELECT); - tools_switch(desktop, TOOLS_NODES); + start.param_set_default(); + end.param_set_default(); } Gtk::Widget *LPETransform2Pts::newWidget() -- cgit v1.2.3 From c956c7436fbb9a9ba3281882f7d388f249a050a4 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sat, 11 Apr 2015 00:54:25 +0200 Subject: Fix coding style issues in transform by two points LPE (bzr r13879.1.15) --- src/live_effects/lpe-transform_2pts.cpp | 194 ++++++++++++++++---------------- 1 file changed, 97 insertions(+), 97 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 9b8c1879a..4b0cbadbb 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -26,25 +26,25 @@ namespace LivePathEffect { LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), - fromOriginalWidth(_("From original width"), _("From original width"), "fromOriginalWidth", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), - firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1), - lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1), - fromOriginalWidthToogler(false), - A(Geom::Point(0,0)), - B(Geom::Point(0,0)), - c(NULL), - appandedPath(false) + first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), + last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), + from_original_width_toogler(false), + point_a(Geom::Point(0,0)), + point_b(Geom::Point(0,0)), + curve_c(NULL), + append_path(false) { registerParameter(&start); registerParameter(&end); - registerParameter(&firstKnot); - registerParameter(&lastKnot); - registerParameter(&fromOriginalWidth); - - firstKnot.param_make_integer(true); - lastKnot.param_make_integer(true); + registerParameter(&first_knot); + registerParameter(&last_knot); + registerParameter(&from_original_width); + + first_knot.param_make_integer(true); + last_knot.param_make_integer(true); } LPETransform2Pts::~LPETransform2Pts() @@ -57,22 +57,22 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) using namespace Geom; original_bbox(lpeitem); - A = Point(boundingbox_X.min(), boundingbox_Y.middle()); - B = Point(boundingbox_X.max(), boundingbox_Y.middle()); + point_a = Point(boundingbox_X.min(), boundingbox_Y.middle()); + point_b = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); SPPath *path = dynamic_cast(splpeitem); if (path) { - c = path->get_original_curve(); + curve_c = path->get_original_curve(); } - if(c && !c->is_closed() && c->first_path() == c->last_path()){ - A = *(c->first_point()); - B = *(c->last_point()); - int nnodes = (int)c->nodes_in_path(); - lastKnot.param_set_value(nnodes); + if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { + point_a = *(curve_c->first_point()); + point_b = *(curve_c->last_point()); + int nnodes = (int)curve_c->nodes_in_path(); + last_knot.param_set_value(nnodes); } - start.param_update_default(A); + start.param_update_default(point_a); start.param_set_default(); - end.param_update_default(B); + end.param_update_default(point_b); end.param_set_default(); } @@ -81,52 +81,52 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) { using namespace Geom; original_bbox(lpeitem); - A = Point(boundingbox_X.min(), boundingbox_Y.middle()); - B = Point(boundingbox_X.max(), boundingbox_Y.middle()); + point_a = Point(boundingbox_X.min(), boundingbox_Y.middle()); + point_b = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); SPPath *path = dynamic_cast(splpeitem); if (path) { - c = path->get_original_curve(); + curve_c = path->get_original_curve(); } - if(fromOriginalWidthToogler != fromOriginalWidth){ - fromOriginalWidthToogler = fromOriginalWidth; + if(from_original_width_toogler != from_original_width) { + from_original_width_toogler = from_original_width; reset(); } - if(c && !fromOriginalWidth){ - if(!c->is_closed() && c->first_path() == c->last_path()){ - appandedPath = false; - Geom::PathVector const originalPV = c->get_pathvector(); - A = originalPV[0][0].initialPoint(); - if((int)firstKnot > 1){ - A = originalPV[0][(int)firstKnot-2].finalPoint(); + if(curve_c && !from_original_width) { + if(!curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { + append_path = false; + Geom::PathVector const originalPV = curve_c->get_pathvector(); + point_a = originalPV[0][0].initialPoint(); + if((int)first_knot > 1) { + point_a = originalPV[0][(int)first_knot-2].finalPoint(); } - B = originalPV[0][0].initialPoint(); - if((int)lastKnot > 1){ - B = originalPV[0][(int)lastKnot-2].finalPoint(); + point_b = originalPV[0][0].initialPoint(); + if((int)last_knot > 1) { + point_b = originalPV[0][(int)last_knot-2].finalPoint(); } - int nnodes = (int)c->nodes_in_path(); - firstKnot.param_set_range(1, lastKnot-1); - lastKnot.param_set_range(firstKnot+1, nnodes); - fromOriginalWidth.param_setValue(false); + int nnodes = (int)curve_c->nodes_in_path(); + first_knot.param_set_range(1, last_knot-1); + last_knot.param_set_range(first_knot+1, nnodes); + from_original_width.param_setValue(false); } else { - firstKnot.param_set_value(1); - lastKnot.param_set_value(2); - firstKnot.param_set_range(1,1); - lastKnot.param_set_range(2,2); - if(appandedPath == false){ - appandedPath = true; + first_knot.param_set_value(1); + last_knot.param_set_value(2); + first_knot.param_set_range(1,1); + last_knot.param_set_range(2,2); + if(append_path == false) { + append_path = true; } else { - fromOriginalWidth.param_setValue(true); + from_original_width.param_setValue(true); } } } else { - firstKnot.param_set_value(1); - lastKnot.param_set_value(2); - firstKnot.param_set_range(1,1); - lastKnot.param_set_range(2,2); - fromOriginalWidth.param_setValue(true); - appandedPath = false; + first_knot.param_set_value(1); + last_knot.param_set_value(2); + first_knot.param_set_range(1,1); + last_knot.param_set_range(2,2); + from_original_width.param_setValue(true); + append_path = false; } splpeitem->apply_to_clippath(splpeitem); splpeitem->apply_to_mask(splpeitem); @@ -135,27 +135,27 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) void LPETransform2Pts::updateIndex() { - SPCurve * c2 = NULL; + SPCurve * curve2 = NULL; SPShape *shape = SP_SHAPE(sp_lpe_item); if (shape) { - c2 = shape->getCurve(); + curve2 = shape->getCurve(); } - if(c2 && !fromOriginalWidth && !c->is_closed() && c->first_path() == c->last_path()){ - Geom::PathVector const originalPV = c2->get_pathvector(); - Geom::Point C = originalPV[0][0].initialPoint(); - Geom::Point D = originalPV[0][0].initialPoint(); - if((int)firstKnot > 1){ - C = originalPV[0][(int)firstKnot-2].finalPoint(); + if(curve2 && !from_original_width && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { + Geom::PathVector const originalPV = curve2->get_pathvector(); + Geom::Point point_c = originalPV[0][0].initialPoint(); + Geom::Point point_d = originalPV[0][0].initialPoint(); + if((int)first_knot > 1) { + point_c = originalPV[0][(int)first_knot-2].finalPoint(); } - if((int)lastKnot > 1){ - D = originalPV[0][(int)lastKnot-2].finalPoint(); + if((int)last_knot > 1) { + point_d = originalPV[0][(int)last_knot-2].finalPoint(); } - start.param_update_default(C); + start.param_update_default(point_c); start.param_set_default(); - end.param_update_default(D); + end.param_update_default(point_d); end.param_set_default(); - start.param_update_default(A); - end.param_update_default(B); + start.param_update_default(point_a); + end.param_update_default(point_b); start.param_set_default(); end.param_set_default(); } @@ -164,22 +164,22 @@ LPETransform2Pts::updateIndex() void LPETransform2Pts::reset() { - A = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); - B = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); - if(c && !c->is_closed() && c->first_path() == c->last_path() && !fromOriginalWidth){ - int nnodes = (int)c->nodes_in_path(); - firstKnot.param_set_range(1, lastKnot-1); - lastKnot.param_set_range(firstKnot+1, nnodes); - firstKnot.param_set_value(1); - lastKnot.param_set_value(nnodes); - A = *(c->first_point()); - B = *(c->last_point()); + point_a = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); + point_b = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); + if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path() && !from_original_width) { + int nnodes = (int)curve_c->nodes_in_path(); + first_knot.param_set_range(1, last_knot-1); + last_knot.param_set_range(first_knot+1, nnodes); + first_knot.param_set_value(1); + last_knot.param_set_value(nnodes); + point_a = *(curve_c->first_point()); + point_b = *(curve_c->last_point()); } else { - firstKnot.param_set_value(1); - lastKnot.param_set_value(2); + first_knot.param_set_value(1); + last_knot.param_set_value(2); } - start.param_update_default(A); - end.param_update_default(B); + start.param_update_default(point_a); + end.param_update_default(point_b); start.param_set_default(); end.param_set_default(); } @@ -201,15 +201,15 @@ Gtk::Widget *LPETransform2Pts::newWidget() Parameter *param = *it; Gtk::Widget *widg = dynamic_cast(param->param_newWidget()); Glib::ustring *tip = param->param_getTooltip(); - if (param->param_key == "firstKnot" || param->param_key == "lastKnot") { - Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast(widg)); - widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPETransform2Pts::updateIndex)); - widg = widgRegistered; + if (param->param_key == "first_knot" || param->param_key == "last_knot") { + Inkscape::UI::Widget::Scalar *registered_widget = Gtk::manage(dynamic_cast(widg)); + registered_widget->signal_value_changed().connect(sigc::mem_fun(*this, &LPETransform2Pts::updateIndex)); + widg = registered_widget; if (widg) { - Gtk::HBox *scalarParameter = dynamic_cast(widg); - std::vector childList = scalarParameter->get_children(); - Gtk::Entry *entryWidg = dynamic_cast(childList[1]); - entryWidg->set_width_chars(3); + Gtk::HBox *hbox_scalar = dynamic_cast(widg); + std::vector child_list = hbox_scalar->get_children(); + Gtk::Entry *entry_widget = dynamic_cast(child_list[1]); + entry_widget->set_width_chars(3); vbox->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); @@ -218,7 +218,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } else if (param->param_key == "fromOriginalWidth"){ + } else if (param->param_key == "from_original_width") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { button->pack_start(*widg, true, true, 2); @@ -253,13 +253,13 @@ Geom::Piecewise > LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const & pwd2_in) { Geom::Piecewise > output; - double sca = Geom::distance((Geom::Point)start,(Geom::Point)end)/Geom::distance(A,B); - Geom::Ray original(A,B); + double sca = Geom::distance((Geom::Point)start,(Geom::Point)end)/Geom::distance(point_a,point_b); + Geom::Ray original(point_a,point_b); Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); double rot = transformed.angle() - original.angle(); Geom::Path helper; - helper.start(A); - helper.appendNew(B); + helper.start(point_a); + helper.appendNew(point_b); Geom::Affine m; m *= Geom::Scale(sca); m *= Geom::Rotate(rot); -- cgit v1.2.3 From 56e98c4508ce491ce5d8406914e6b192de72fe6f Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Fri, 31 Jul 2015 00:59:02 +0200 Subject: Fixed bugs in branch review and updated to new api (bzr r13879.1.20) --- src/live_effects/lpe-transform_2pts.cpp | 143 ++++++++++++++++++-------------- 1 file changed, 79 insertions(+), 64 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 4b0cbadbb..d2c2cfc0e 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -15,7 +15,7 @@ #include "live_effects/lpe-transform_2pts.h" #include "display/curve.h" #include <2geom/transforms.h> -#include <2geom/path.h> +#include <2geom/pathvector.h> #include "sp-path.h" #include "ui/icon-names.h" @@ -31,10 +31,10 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : end(_("End"), _("End point"), "end", &wr, this, "End point"), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), - from_original_width_toogler(false), - point_a(Geom::Point(0,0)), - point_b(Geom::Point(0,0)), - curve_c(NULL), + from_original_width_toggler(false), + point_a(Geom::Point()), + point_b(Geom::Point()), + pathvector(), append_path(false) { registerParameter(&start); @@ -60,14 +60,14 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) point_a = Point(boundingbox_X.min(), boundingbox_Y.middle()); point_b = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); - SPPath *path = dynamic_cast(splpeitem); - if (path) { - curve_c = path->get_original_curve(); + SPPath *sp_path = dynamic_cast(splpeitem); + if (sp_path) { + pathvector = sp_path->get_original_curve()->get_pathvector(); } - if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { - point_a = *(curve_c->first_point()); - point_b = *(curve_c->last_point()); - int nnodes = (int)curve_c->nodes_in_path(); + if(!pathvector.empty()) { + point_a = pathvector.initialPoint(); + point_b = pathvector.finalPoint(); + size_t nnodes = nodeCount(pathvector); last_knot.param_set_value(nnodes); } start.param_update_default(point_a); @@ -85,41 +85,22 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) point_b = Point(boundingbox_X.max(), boundingbox_Y.middle()); SPLPEItem * splpeitem = const_cast(lpeitem); - SPPath *path = dynamic_cast(splpeitem); - if (path) { - curve_c = path->get_original_curve(); + SPPath *sp_path = dynamic_cast(splpeitem); + if (sp_path) { + pathvector = sp_path->get_original_curve()->get_pathvector(); } - if(from_original_width_toogler != from_original_width) { - from_original_width_toogler = from_original_width; + if(from_original_width_toggler != from_original_width) { + from_original_width_toggler = from_original_width; reset(); } - if(curve_c && !from_original_width) { - if(!curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { - append_path = false; - Geom::PathVector const originalPV = curve_c->get_pathvector(); - point_a = originalPV[0][0].initialPoint(); - if((int)first_knot > 1) { - point_a = originalPV[0][(int)first_knot-2].finalPoint(); - } - point_b = originalPV[0][0].initialPoint(); - if((int)last_knot > 1) { - point_b = originalPV[0][(int)last_knot-2].finalPoint(); - } - int nnodes = (int)curve_c->nodes_in_path(); - first_knot.param_set_range(1, last_knot-1); - last_knot.param_set_range(first_knot+1, nnodes); - from_original_width.param_setValue(false); - } else { - first_knot.param_set_value(1); - last_knot.param_set_value(2); - first_knot.param_set_range(1,1); - last_knot.param_set_range(2,2); - if(append_path == false) { - append_path = true; - } else { - from_original_width.param_setValue(true); - } - } + if(!pathvector.empty() && !from_original_width) { + append_path = false; + point_a = pointAtNodeIndex(pathvector,(size_t)first_knot-1); + point_b = pointAtNodeIndex(pathvector,(size_t)last_knot-1); + size_t nnodes = nodeCount(pathvector); + first_knot.param_set_range(1, last_knot-1); + last_knot.param_set_range(first_knot+1, nnodes); + from_original_width.param_setValue(false); } else { first_knot.param_set_value(1); last_knot.param_set_value(2); @@ -135,24 +116,17 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) void LPETransform2Pts::updateIndex() { - SPCurve * curve2 = NULL; - SPShape *shape = SP_SHAPE(sp_lpe_item); - if (shape) { - curve2 = shape->getCurve(); + SPLPEItem * splpeitem = const_cast(sp_lpe_item); + SPPath *sp_path = dynamic_cast(splpeitem); + if (sp_path) { + pathvector = sp_path->get_original_curve()->get_pathvector(); } - if(curve2 && !from_original_width && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) { - Geom::PathVector const originalPV = curve2->get_pathvector(); - Geom::Point point_c = originalPV[0][0].initialPoint(); - Geom::Point point_d = originalPV[0][0].initialPoint(); - if((int)first_knot > 1) { - point_c = originalPV[0][(int)first_knot-2].finalPoint(); - } - if((int)last_knot > 1) { - point_d = originalPV[0][(int)last_knot-2].finalPoint(); - } - start.param_update_default(point_c); + if(!pathvector.empty() && !from_original_width) { + point_a = pointAtNodeIndex(pathvector,(size_t)first_knot-1); + point_b = pointAtNodeIndex(pathvector,(size_t)last_knot-1); + start.param_update_default(point_a); start.param_set_default(); - end.param_update_default(point_d); + end.param_update_default(point_b); end.param_set_default(); start.param_update_default(point_a); end.param_update_default(point_b); @@ -160,20 +134,61 @@ LPETransform2Pts::updateIndex() end.param_set_default(); } } +//todo migrate to PathVector class? +size_t +LPETransform2Pts::nodeCount(Geom::PathVector pathvector) const +{ + size_t n = 0; + for (Geom::PathVector::iterator it = pathvector.begin(); it != pathvector.end(); ++it) { + n += it->size_closed(); + } + return n; +} +//todo migrate to PathVector class? +Geom::Point +LPETransform2Pts::pointAtNodeIndex(Geom::PathVector pathvector, size_t index) const +{ + size_t n = 0; + for (Geom::PathVector::iterator pv_it = pathvector.begin(); pv_it != pathvector.end(); ++pv_it) { + for (Geom::Path::iterator curve_it = pv_it->begin(); curve_it != pv_it->end_closed(); ++curve_it) { + if(index == n){ + return curve_it->initialPoint(); + } + n++; + } + } + return Geom::Point(); +} +//todo migrate to PathVector class? Not used +Geom::Path +LPETransform2Pts::pathAtNodeIndex(Geom::PathVector pathvector, size_t index) const +{ + size_t n = 0; + for (Geom::PathVector::iterator pv_it = pathvector.begin(); pv_it != pathvector.end(); ++pv_it) { + for (Geom::Path::iterator curve_it = pv_it->begin(); curve_it != pv_it->end_closed(); ++curve_it) { + if(index == n){ + return *pv_it; + } + n++; + } + } + return Geom::Path(); +} + void LPETransform2Pts::reset() { point_a = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); point_b = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); - if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path() && !from_original_width) { - int nnodes = (int)curve_c->nodes_in_path(); + if(!pathvector.empty() && !from_original_width) { + size_t nnodes = nodeCount(pathvector); first_knot.param_set_range(1, last_knot-1); last_knot.param_set_range(first_knot+1, nnodes); first_knot.param_set_value(1); last_knot.param_set_value(nnodes); - point_a = *(curve_c->first_point()); - point_b = *(curve_c->last_point()); + point_a = pathvector.initialPoint(); + point_b = pathvector.finalPoint(); } else { first_knot.param_set_value(1); last_knot.param_set_value(2); -- cgit v1.2.3 From af121b63c22bde5929a2706285bbc3814fb0ed90 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Mon, 24 Aug 2015 23:21:51 +0200 Subject: Fix a big on apply on closed path Transform By two knots (bzr r14322) --- src/live_effects/lpe-transform_2pts.cpp | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index d2c2cfc0e..b70b68968 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -67,6 +67,9 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) if(!pathvector.empty()) { point_a = pathvector.initialPoint(); point_b = pathvector.finalPoint(); + if(are_near(point_a,point_b)){ + point_b = pathvector.back().finalCurve().initialPoint(); + } size_t nnodes = nodeCount(pathvector); last_knot.param_set_value(nnodes); } @@ -98,6 +101,7 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) point_a = pointAtNodeIndex(pathvector,(size_t)first_knot-1); point_b = pointAtNodeIndex(pathvector,(size_t)last_knot-1); size_t nnodes = nodeCount(pathvector); + std::cout << nnodes << "nnodes\n"; first_knot.param_set_range(1, last_knot-1); last_knot.param_set_range(first_knot+1, nnodes); from_original_width.param_setValue(false); -- cgit v1.2.3 From e540144050e6caf543adb6299e56f6cbee396e77 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 27 Aug 2015 01:34:34 +0200 Subject: Added fixed and elastic modes to transform by two knots (bzr r14325) --- src/live_effects/lpe-transform_2pts.cpp | 94 ++++++++++++++++++++++++++++++--- 1 file changed, 86 insertions(+), 8 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index b70b68968..1f1cccd89 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -18,6 +18,7 @@ #include <2geom/pathvector.h> #include "sp-path.h" #include "ui/icon-names.h" +#include "svg/svg.h" #include @@ -26,25 +27,42 @@ namespace LivePathEffect { LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), + elastic(_("Elastic"), _("Elastic transform mode"), "elastic", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + fixed(_("Fixed"), _("No scale, only move and rotate"), "fixed", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), + fixed_width(_("Fixed width"), _("Fixed width"), "fixed_width", &wr, this, 1), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), + helper_size(_("Helper size:"), _("Rotation helper size"), "helper_size", &wr, this, 10), from_original_width_toggler(false), point_a(Geom::Point()), point_b(Geom::Point()), pathvector(), - append_path(false) + append_path(false), + previous_angle(Geom::deg_to_rad(0)), + previous_start(Geom::Point()) { registerParameter(&start); registerParameter(&end); + registerParameter(&fixed_width); registerParameter(&first_knot); registerParameter(&last_knot); + registerParameter(&helper_size); + registerParameter(&elastic); + registerParameter(&fixed); registerParameter(&from_original_width); first_knot.param_make_integer(true); last_knot.param_make_integer(true); + helper_size.param_set_range(0, 999); + helper_size.param_set_increments(1, 1); + helper_size.param_set_digits(0); + + fixed_width.param_set_range(0.0, 99999.0); + fixed_width.param_set_increments(1, 1); + fixed_width.param_set_digits(4); } LPETransform2Pts::~LPETransform2Pts() @@ -73,6 +91,8 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) size_t nnodes = nodeCount(pathvector); last_knot.param_set_value(nnodes); } + + fixed_width.param_set_value(Geom::distance(point_a,point_b)); start.param_update_default(point_a); start.param_set_default(); end.param_update_default(point_b); @@ -101,7 +121,6 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) point_a = pointAtNodeIndex(pathvector,(size_t)first_knot-1); point_b = pointAtNodeIndex(pathvector,(size_t)last_knot-1); size_t nnodes = nodeCount(pathvector); - std::cout << nnodes << "nnodes\n"; first_knot.param_set_range(1, last_knot-1); last_knot.param_set_range(first_knot+1, nnodes); from_original_width.param_setValue(false); @@ -113,6 +132,15 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) from_original_width.param_setValue(true); append_path = false; } + if(fixed){ + Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); + if(previous_start == start || previous_angle == Geom::deg_to_rad(0)){ + previous_angle = transformed.angle(); + } + Geom::Point end_point = Geom::Point::polar(previous_angle, fixed_width) + (Geom::Point)start; + end.param_setValue(end_point); + } + previous_start = start; splpeitem->apply_to_clippath(splpeitem); splpeitem->apply_to_mask(splpeitem); } @@ -125,7 +153,10 @@ LPETransform2Pts::updateIndex() if (sp_path) { pathvector = sp_path->get_original_curve()->get_pathvector(); } - if(!pathvector.empty() && !from_original_width) { + if(pathvector.empty()){ + return; + } + if(!from_original_width) { point_a = pointAtNodeIndex(pathvector,(size_t)first_knot-1); point_b = pointAtNodeIndex(pathvector,(size_t)last_knot-1); start.param_update_default(point_a); @@ -136,7 +167,11 @@ LPETransform2Pts::updateIndex() end.param_update_default(point_b); start.param_set_default(); end.param_set_default(); + } else { + point_a = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); + point_b = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); } + fixed_width.param_set_value(Geom::distance(point_a,point_b)); } //todo migrate to PathVector class? size_t @@ -197,6 +232,7 @@ LPETransform2Pts::reset() first_knot.param_set_value(1); last_knot.param_set_value(2); } + fixed_width.param_set_value(Geom::distance(point_a,point_b)); start.param_update_default(point_a); end.param_update_default(point_b); start.param_set_default(); @@ -215,6 +251,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() std::vector::iterator it = param_vector.begin(); Gtk::HBox * button = Gtk::manage(new Gtk::HBox(true,0)); + Gtk::HBox * button2 = Gtk::manage(new Gtk::HBox(true,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter *param = *it; @@ -238,6 +275,28 @@ Gtk::Widget *LPETransform2Pts::newWidget() } } } else if (param->param_key == "from_original_width") { + Glib::ustring * tip = param->param_getTooltip(); + if (widg) { + button2->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } + } + } else if (param->param_key == "elastic") { + Glib::ustring * tip = param->param_getTooltip(); + if (widg) { + button->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } + } + } else if (param->param_key == "fixed") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { button->pack_start(*widg, true, true, 2); @@ -263,8 +322,9 @@ Gtk::Widget *LPETransform2Pts::newWidget() } Gtk::Button *reset = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset")))); reset->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::reset)); - button->pack_start(*reset, true, true, 2); + button2->pack_start(*reset, true, true, 2); vbox->pack_start(*button, true, true, 2); + vbox->pack_start(*button2, true, true, 2); return dynamic_cast(vbox); } @@ -280,10 +340,19 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const helper.start(point_a); helper.appendNew(point_b); Geom::Affine m; - m *= Geom::Scale(sca); - m *= Geom::Rotate(rot); - helper *= m; - m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); + if(elastic){ + Geom::Angle original_angle = original.angle(); + m *= Geom::Rotate(-original_angle); + m *= Geom::Scale(sca, 1.0); + m *= Geom::Rotate(transformed.angle()); + helper *= m; + m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); + } else { + m *= Geom::Scale(sca); + m *= Geom::Rotate(rot); + helper *= m; + m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); + } output.concat(pwd2_in * m); return output; @@ -299,6 +368,15 @@ LPETransform2Pts::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector< hp.appendNew((Geom::Point)end); Geom::PathVector pathv; pathv.push_back(hp); + if(fixed){ + double r = helper_size*.1; + char const * svgd; + svgd = "m 7.07,7.07 c -3.9,3.91 -10.24,3.91 -14.14,0 -3.91,-3.9 -3.91,-10.24 0,-14.14 3.9,-3.91 10.24,-3.91 14.14,0 l -2.83,-4.24 -0.7,2.12"; + PathVector pathv_turn = sp_svg_read_pathv(svgd); + pathv_turn *= Geom::Rotate(previous_angle); + pathv_turn *= Affine(r,0,0,r,0,0) * Translate(Geom::Point(start)); + hp_vec.push_back(pathv_turn); + } hp_vec.push_back(pathv); } -- cgit v1.2.3 From 45f0472b3761eb0d68d59c4fc52cc9ebc2d5acee Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 27 Aug 2015 09:05:40 +0200 Subject: Changed from fixed width to lock width, removed one widget to the transform by 2 pts (bzr r14326) --- src/live_effects/lpe-transform_2pts.cpp | 43 ++++++++++++++------------------- 1 file changed, 18 insertions(+), 25 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 1f1cccd89..2aa02039d 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -28,11 +28,10 @@ namespace LivePathEffect { LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), elastic(_("Elastic"), _("Elastic transform mode"), "elastic", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), - fixed(_("Fixed"), _("No scale, only move and rotate"), "fixed", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + lock_width(_("Lock width"), _("Lock width to current distance"), "lock_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), - fixed_width(_("Fixed width"), _("Fixed width"), "fixed_width", &wr, this, 1), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), helper_size(_("Helper size:"), _("Rotation helper size"), "helper_size", &wr, this, 10), @@ -42,16 +41,16 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : pathvector(), append_path(false), previous_angle(Geom::deg_to_rad(0)), - previous_start(Geom::Point()) + previous_start(Geom::Point()), + previous_width(-1) { registerParameter(&start); registerParameter(&end); - registerParameter(&fixed_width); registerParameter(&first_knot); registerParameter(&last_knot); registerParameter(&helper_size); registerParameter(&elastic); - registerParameter(&fixed); + registerParameter(&lock_width); registerParameter(&from_original_width); first_knot.param_make_integer(true); @@ -59,10 +58,6 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : helper_size.param_set_range(0, 999); helper_size.param_set_increments(1, 1); helper_size.param_set_digits(0); - - fixed_width.param_set_range(0.0, 99999.0); - fixed_width.param_set_increments(1, 1); - fixed_width.param_set_digits(4); } LPETransform2Pts::~LPETransform2Pts() @@ -85,14 +80,14 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) if(!pathvector.empty()) { point_a = pathvector.initialPoint(); point_b = pathvector.finalPoint(); - if(are_near(point_a,point_b)){ + if(are_near(point_a,point_b)) { point_b = pathvector.back().finalCurve().initialPoint(); } size_t nnodes = nodeCount(pathvector); last_knot.param_set_value(nnodes); } - fixed_width.param_set_value(Geom::distance(point_a,point_b)); + previous_width = Geom::distance(point_a,point_b); start.param_update_default(point_a); start.param_set_default(); end.param_update_default(point_b); @@ -132,13 +127,15 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) from_original_width.param_setValue(true); append_path = false; } - if(fixed){ + if(lock_width && previous_width != -1) { Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); - if(previous_start == start || previous_angle == Geom::deg_to_rad(0)){ + if(previous_start == start || previous_angle == Geom::deg_to_rad(0)) { previous_angle = transformed.angle(); } - Geom::Point end_point = Geom::Point::polar(previous_angle, fixed_width) + (Geom::Point)start; + Geom::Point end_point = Geom::Point::polar(previous_angle, previous_width) + (Geom::Point)start; end.param_setValue(end_point); + } else { + previous_width = Geom::distance(Geom::Point(start), Geom::Point(end)); } previous_start = start; splpeitem->apply_to_clippath(splpeitem); @@ -153,7 +150,7 @@ LPETransform2Pts::updateIndex() if (sp_path) { pathvector = sp_path->get_original_curve()->get_pathvector(); } - if(pathvector.empty()){ + if(pathvector.empty()) { return; } if(!from_original_width) { @@ -167,11 +164,7 @@ LPETransform2Pts::updateIndex() end.param_update_default(point_b); start.param_set_default(); end.param_set_default(); - } else { - point_a = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle()); - point_b = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle()); } - fixed_width.param_set_value(Geom::distance(point_a,point_b)); } //todo migrate to PathVector class? size_t @@ -190,7 +183,7 @@ LPETransform2Pts::pointAtNodeIndex(Geom::PathVector pathvector, size_t index) co size_t n = 0; for (Geom::PathVector::iterator pv_it = pathvector.begin(); pv_it != pathvector.end(); ++pv_it) { for (Geom::Path::iterator curve_it = pv_it->begin(); curve_it != pv_it->end_closed(); ++curve_it) { - if(index == n){ + if(index == n) { return curve_it->initialPoint(); } n++; @@ -205,7 +198,7 @@ LPETransform2Pts::pathAtNodeIndex(Geom::PathVector pathvector, size_t index) con size_t n = 0; for (Geom::PathVector::iterator pv_it = pathvector.begin(); pv_it != pathvector.end(); ++pv_it) { for (Geom::Path::iterator curve_it = pv_it->begin(); curve_it != pv_it->end_closed(); ++curve_it) { - if(index == n){ + if(index == n) { return *pv_it; } n++; @@ -232,7 +225,7 @@ LPETransform2Pts::reset() first_knot.param_set_value(1); last_knot.param_set_value(2); } - fixed_width.param_set_value(Geom::distance(point_a,point_b)); + previous_width = Geom::distance(point_a, point_b); start.param_update_default(point_a); end.param_update_default(point_b); start.param_set_default(); @@ -296,7 +289,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } else if (param->param_key == "fixed") { + } else if (param->param_key == "lock_width") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { button->pack_start(*widg, true, true, 2); @@ -340,7 +333,7 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const helper.start(point_a); helper.appendNew(point_b); Geom::Affine m; - if(elastic){ + if(elastic) { Geom::Angle original_angle = original.angle(); m *= Geom::Rotate(-original_angle); m *= Geom::Scale(sca, 1.0); @@ -368,7 +361,7 @@ LPETransform2Pts::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector< hp.appendNew((Geom::Point)end); Geom::PathVector pathv; pathv.push_back(hp); - if(fixed){ + if(lock_width) { double r = helper_size*.1; char const * svgd; svgd = "m 7.07,7.07 c -3.9,3.91 -10.24,3.91 -14.14,0 -3.91,-3.9 -3.91,-10.24 0,-14.14 3.9,-3.91 10.24,-3.91 14.14,0 l -2.83,-4.24 -0.7,2.12"; -- cgit v1.2.3 From f7e10f65e9df1bc9138e4fd625936098c4333fad Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Thu, 27 Aug 2015 22:03:17 +0200 Subject: Add lock angle to transform by two points LPE (bzr r14328) --- src/live_effects/lpe-transform_2pts.cpp | 73 +++++++++++++++++++-------------- 1 file changed, 42 insertions(+), 31 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 2aa02039d..83c24dc0c 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -28,13 +28,14 @@ namespace LivePathEffect { LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), elastic(_("Elastic"), _("Elastic transform mode"), "elastic", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), - lock_width(_("Lock width"), _("Lock width to current distance"), "lock_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + lock_lenght(_("Lock lenght"), _("Lock lenght to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + lock_angle(_("Lock angle"), _("Lock angle"), "lock_angle", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), - helper_size(_("Helper size:"), _("Rotation helper size"), "helper_size", &wr, this, 10), + helper_size(_("Helper size:"), _("Rotation helper size"), "helper_size", &wr, this, 3), from_original_width_toggler(false), point_a(Geom::Point()), point_b(Geom::Point()), @@ -42,7 +43,7 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : append_path(false), previous_angle(Geom::deg_to_rad(0)), previous_start(Geom::Point()), - previous_width(-1) + previous_lenght(-1) { registerParameter(&start); registerParameter(&end); @@ -50,8 +51,9 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : registerParameter(&last_knot); registerParameter(&helper_size); registerParameter(&elastic); - registerParameter(&lock_width); registerParameter(&from_original_width); + registerParameter(&lock_lenght); + registerParameter(&lock_angle); first_knot.param_make_integer(true); last_knot.param_make_integer(true); @@ -87,7 +89,9 @@ LPETransform2Pts::doOnApply(SPLPEItem const* lpeitem) last_knot.param_set_value(nnodes); } - previous_width = Geom::distance(point_a,point_b); + previous_lenght = Geom::distance(point_a,point_b); + Geom::Ray transformed(point_a,point_b); + previous_angle = transformed.angle(); start.param_update_default(point_a); start.param_set_default(); end.param_update_default(point_b); @@ -127,16 +131,23 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) from_original_width.param_setValue(true); append_path = false; } - if(lock_width && previous_width != -1) { + if(lock_lenght && !lock_angle && previous_lenght != -1) { Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); if(previous_start == start || previous_angle == Geom::deg_to_rad(0)) { previous_angle = transformed.angle(); } - Geom::Point end_point = Geom::Point::polar(previous_angle, previous_width) + (Geom::Point)start; + } else if(lock_angle && !lock_lenght && previous_angle != Geom::deg_to_rad(0)) { + if(previous_start == start){ + previous_lenght = Geom::distance((Geom::Point)start, (Geom::Point)end); + } + } + if(lock_lenght || lock_angle ) { + Geom::Point end_point = Geom::Point::polar(previous_angle, previous_lenght) + (Geom::Point)start; end.param_setValue(end_point); - } else { - previous_width = Geom::distance(Geom::Point(start), Geom::Point(end)); } + Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); + previous_angle = transformed.angle(); + previous_lenght = Geom::distance((Geom::Point)start, (Geom::Point)end); previous_start = start; splpeitem->apply_to_clippath(splpeitem); splpeitem->apply_to_mask(splpeitem); @@ -225,7 +236,9 @@ LPETransform2Pts::reset() first_knot.param_set_value(1); last_knot.param_set_value(2); } - previous_width = Geom::distance(point_a, point_b); + Geom::Ray transformed(point_a, point_b); + previous_angle = transformed.angle(); + previous_lenght = Geom::distance(point_a, point_b); start.param_update_default(point_a); end.param_update_default(point_b); start.param_set_default(); @@ -243,8 +256,9 @@ Gtk::Widget *LPETransform2Pts::newWidget() vbox->set_spacing(6); std::vector::iterator it = param_vector.begin(); - Gtk::HBox * button = Gtk::manage(new Gtk::HBox(true,0)); + Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0)); Gtk::HBox * button2 = Gtk::manage(new Gtk::HBox(true,0)); + Gtk::HBox * button3 = Gtk::manage(new Gtk::HBox(true,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter *param = *it; @@ -267,10 +281,10 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } else if (param->param_key == "from_original_width") { + } else if (param->param_key == "from_original_width" || param->param_key == "elastic") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { - button2->pack_start(*widg, true, true, 2); + button1->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); } else { @@ -278,21 +292,10 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } else if (param->param_key == "elastic") { + } else if (param->param_key == "lock_angle" || param->param_key == "lock_lenght") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { - button->pack_start(*widg, true, true, 2); - if (tip) { - widg->set_tooltip_text(*tip); - } else { - widg->set_tooltip_text(""); - widg->set_has_tooltip(false); - } - } - } else if (param->param_key == "lock_width") { - Glib::ustring * tip = param->param_getTooltip(); - if (widg) { - button->pack_start(*widg, true, true, 2); + button2->pack_start(*widg, true, true, 2); if (tip) { widg->set_tooltip_text(*tip); } else { @@ -315,9 +318,10 @@ Gtk::Widget *LPETransform2Pts::newWidget() } Gtk::Button *reset = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset")))); reset->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::reset)); - button2->pack_start(*reset, true, true, 2); - vbox->pack_start(*button, true, true, 2); + button3->pack_start(*reset, true, true, 2); + vbox->pack_start(*button1, true, true, 2); vbox->pack_start(*button2, true, true, 2); + vbox->pack_start(*button3, true, true, 2); return dynamic_cast(vbox); } @@ -361,13 +365,20 @@ LPETransform2Pts::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector< hp.appendNew((Geom::Point)end); Geom::PathVector pathv; pathv.push_back(hp); - if(lock_width) { - double r = helper_size*.1; + double r = helper_size*.1; + if(lock_lenght || lock_angle ) { + char const * svgd; + svgd = "M -5.39,8.78 -9.13,5.29 -10.38,10.28 Z M -7.22,7.07 -3.43,3.37 m -1.95,-12.16 -3.74,3.5 -1.26,-5 z m -1.83,1.71 3.78,3.7 M 5.24,8.78 8.98,5.29 10.24,10.28 Z M 7.07,7.07 3.29,3.37 M 5.24,-8.78 l 3.74,3.5 1.26,-5 z M 7.07,-7.07 3.29,-3.37"; + PathVector pathv_move = sp_svg_read_pathv(svgd); + pathv_move *= Affine(r,0,0,r,0,0) * Translate(Geom::Point(start)); + hp_vec.push_back(pathv_move); + } + if(!lock_angle && lock_lenght) { char const * svgd; svgd = "m 7.07,7.07 c -3.9,3.91 -10.24,3.91 -14.14,0 -3.91,-3.9 -3.91,-10.24 0,-14.14 3.9,-3.91 10.24,-3.91 14.14,0 l -2.83,-4.24 -0.7,2.12"; PathVector pathv_turn = sp_svg_read_pathv(svgd); pathv_turn *= Geom::Rotate(previous_angle); - pathv_turn *= Affine(r,0,0,r,0,0) * Translate(Geom::Point(start)); + pathv_turn *= Affine(r,0,0,r,0,0) * Translate(Geom::Point(end)); hp_vec.push_back(pathv_turn); } hp_vec.push_back(pathv); -- cgit v1.2.3 From 8ceb1ada94fa58656a3a40bef7c7d1b8232d5a09 Mon Sep 17 00:00:00 2001 From: jtx Date: Fri, 28 Aug 2015 12:32:00 +0200 Subject: Improve elastic mode in transform by two points LPE (bzr r14329) --- src/live_effects/lpe-transform_2pts.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 83c24dc0c..79ffd74de 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -340,7 +340,11 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const if(elastic) { Geom::Angle original_angle = original.angle(); m *= Geom::Rotate(-original_angle); - m *= Geom::Scale(sca, 1.0); + if(sca > 1){ + m *= Geom::Scale(sca, 1.0); + } else { + m *= Geom::Scale(sca, 1.0-((1.0-sca)/2.0)); + } m *= Geom::Rotate(transformed.angle()); helper *= m; m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); -- cgit v1.2.3 From 288eceeafde73ce1ad21a9f8c38d13072cb805be Mon Sep 17 00:00:00 2001 From: jtx Date: Thu, 17 Sep 2015 16:15:55 +0200 Subject: Improvements to transform by two knots pointed by Ivan Louette (bzr r14375) --- src/live_effects/lpe-transform_2pts.cpp | 76 ++++++++++++++++++++++++++++----- 1 file changed, 66 insertions(+), 10 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 79ffd74de..8326bd6f1 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -19,7 +19,8 @@ #include "sp-path.h" #include "ui/icon-names.h" #include "svg/svg.h" - +#include "verbs.h" +// TODO due to internal breakage in glibmm headers, this must be last: #include namespace Inkscape { @@ -31,8 +32,12 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), lock_lenght(_("Lock lenght"), _("Lock lenght to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), lock_angle(_("Lock angle"), _("Lock angle"), "lock_angle", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + flip_horizontal(_("Flip horizontal"), _("Flip horizontal"), "flip_horizontal", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + flip_vertical(_("Flip vertical"), _("Flip vertical"), "flip_vertical", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), + strech(_("Strech"), _("Strech the result"), "strech", &wr, this, 1), + offset(_("Offset"), _("Offset from knots"), "offset", &wr, this, 0), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), helper_size(_("Helper size:"), _("Rotation helper size"), "helper_size", &wr, this, 3), @@ -45,21 +50,34 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : previous_start(Geom::Point()), previous_lenght(-1) { - registerParameter(&start); - registerParameter(&end); + registerParameter(&first_knot); registerParameter(&last_knot); registerParameter(&helper_size); + registerParameter(&strech); + registerParameter(&offset); + registerParameter(&start); + registerParameter(&end); registerParameter(&elastic); registerParameter(&from_original_width); + registerParameter(&flip_vertical); + registerParameter(&flip_horizontal); registerParameter(&lock_lenght); registerParameter(&lock_angle); first_knot.param_make_integer(true); + first_knot.param_overwrite_widget(true); last_knot.param_make_integer(true); + last_knot.param_overwrite_widget(true); helper_size.param_set_range(0, 999); helper_size.param_set_increments(1, 1); helper_size.param_set_digits(0); + offset.param_set_range(-999999.0, 999999.0); + offset.param_set_increments(1, 1); + offset.param_set_digits(2); + strech.param_set_range(0, 999.0); + strech.param_set_increments(0.01, 0.01); + strech.param_set_digits(4); } LPETransform2Pts::~LPETransform2Pts() @@ -176,6 +194,7 @@ LPETransform2Pts::updateIndex() start.param_set_default(); end.param_set_default(); } + DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change index of knot")); } //todo migrate to PathVector class? size_t @@ -259,6 +278,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() Gtk::HBox * button1 = Gtk::manage(new Gtk::HBox(true,0)); Gtk::HBox * button2 = Gtk::manage(new Gtk::HBox(true,0)); Gtk::HBox * button3 = Gtk::manage(new Gtk::HBox(true,0)); + Gtk::HBox * button4 = Gtk::manage(new Gtk::HBox(true,0)); while (it != param_vector.end()) { if ((*it)->widget_is_visible) { Parameter *param = *it; @@ -292,7 +312,7 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } - } else if (param->param_key == "lock_angle" || param->param_key == "lock_lenght") { + } else if (param->param_key == "flip_horizontal" || param->param_key == "flip_vertical") { Glib::ustring * tip = param->param_getTooltip(); if (widg) { button2->pack_start(*widg, true, true, 2); @@ -303,6 +323,17 @@ Gtk::Widget *LPETransform2Pts::newWidget() widg->set_has_tooltip(false); } } + } else if (param->param_key == "lock_angle" || param->param_key == "lock_lenght") { + Glib::ustring * tip = param->param_getTooltip(); + if (widg) { + button3->pack_start(*widg, true, true, 2); + if (tip) { + widg->set_tooltip_text(*tip); + } else { + widg->set_tooltip_text(""); + widg->set_has_tooltip(false); + } + } } else if (widg) { vbox->pack_start(*widg, true, true, 2); if (tip) { @@ -318,10 +349,11 @@ Gtk::Widget *LPETransform2Pts::newWidget() } Gtk::Button *reset = Gtk::manage(new Gtk::Button(Glib::ustring(_("Reset")))); reset->signal_clicked().connect(sigc::mem_fun(*this, &LPETransform2Pts::reset)); - button3->pack_start(*reset, true, true, 2); + button4->pack_start(*reset, true, true, 2); vbox->pack_start(*button1, true, true, 2); vbox->pack_start(*button2, true, true, 2); vbox->pack_start(*button3, true, true, 2); + vbox->pack_start(*button4, true, true, 2); return dynamic_cast(vbox); } @@ -337,8 +369,26 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const helper.start(point_a); helper.appendNew(point_b); Geom::Affine m; + Geom::Angle original_angle = original.angle(); + if(flip_horizontal && flip_vertical){ + m *= Geom::Rotate(-original_angle); + m *= Geom::Scale(-1,-1); + m *= Geom::Rotate(original_angle); + } else if(flip_vertical){ + m *= Geom::Rotate(-original_angle); + m *= Geom::Scale(1,-1); + m *= Geom::Rotate(original_angle); + } else if(flip_horizontal){ + m *= Geom::Rotate(-original_angle); + m *= Geom::Scale(-1,1); + m *= Geom::Rotate(original_angle); + } + if(strech != 1){ + m *= Geom::Rotate(-original_angle); + m *= Geom::Scale(1,strech); + m *= Geom::Rotate(original_angle); + } if(elastic) { - Geom::Angle original_angle = original.angle(); m *= Geom::Rotate(-original_angle); if(sca > 1){ m *= Geom::Scale(sca, 1.0); @@ -346,14 +396,20 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const m *= Geom::Scale(sca, 1.0-((1.0-sca)/2.0)); } m *= Geom::Rotate(transformed.angle()); - helper *= m; - m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); } else { m *= Geom::Scale(sca); m *= Geom::Rotate(rot); - helper *= m; - m *= Geom::Translate((Geom::Point)start - helper.initialPoint()); } + helper *= m; + Geom::Point trans = (Geom::Point)start - helper.initialPoint(); + if(flip_horizontal){ + trans = (Geom::Point)end - helper.initialPoint(); + } + if(offset != 0){ + trans = Geom::Point::polar(transformed.angle() + Geom::deg_to_rad(-90),offset) + trans; + } + m *= Geom::Translate(trans); + output.concat(pwd2_in * m); return output; -- cgit v1.2.3 From e40c7e81cc683c8c937486c4a53f9758752bbbe6 Mon Sep 17 00:00:00 2001 From: Yuri Chornoivan <> Date: Sun, 1 Nov 2015 13:49:27 +0100 Subject: Typo fix (bzr r14439) --- src/live_effects/lpe-transform_2pts.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index 8326bd6f1..f2b756567 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -30,13 +30,13 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : Effect(lpeobject), elastic(_("Elastic"), _("Elastic transform mode"), "elastic", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), - lock_lenght(_("Lock lenght"), _("Lock lenght to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), + lock_lenght(_("Lock length"), _("Lock length to current distance"), "lock_lenght", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), lock_angle(_("Lock angle"), _("Lock angle"), "lock_angle", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), flip_horizontal(_("Flip horizontal"), _("Flip horizontal"), "flip_horizontal", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), flip_vertical(_("Flip vertical"), _("Flip vertical"), "flip_vertical", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")), start(_("Start"), _("Start point"), "start", &wr, this, "Start point"), end(_("End"), _("End point"), "end", &wr, this, "End point"), - strech(_("Strech"), _("Strech the result"), "strech", &wr, this, 1), + strech(_("Stretch"), _("Stretch the result"), "strech", &wr, this, 1), offset(_("Offset"), _("Offset from knots"), "offset", &wr, this, 0), first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1), last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1), -- cgit v1.2.3 From 0a2477feea6e1df586b926b8482afbf79e2355e1 Mon Sep 17 00:00:00 2001 From: Krzysztof Kosi??ski Date: Sun, 7 Feb 2016 23:32:51 -0800 Subject: Sync 2Geom to commit 5ee51c1c4f2066faa3e2c82021fc92671ad44ba4 (bzr r14639) --- src/live_effects/lpe-transform_2pts.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index f2b756567..dd1a29689 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -46,7 +46,7 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : point_b(Geom::Point()), pathvector(), append_path(false), - previous_angle(Geom::deg_to_rad(0)), + previous_angle(Geom::rad_from_deg(0)), previous_start(Geom::Point()), previous_lenght(-1) { @@ -151,10 +151,10 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) } if(lock_lenght && !lock_angle && previous_lenght != -1) { Geom::Ray transformed((Geom::Point)start,(Geom::Point)end); - if(previous_start == start || previous_angle == Geom::deg_to_rad(0)) { + if(previous_start == start || previous_angle == Geom::rad_from_deg(0)) { previous_angle = transformed.angle(); } - } else if(lock_angle && !lock_lenght && previous_angle != Geom::deg_to_rad(0)) { + } else if(lock_angle && !lock_lenght && previous_angle != Geom::rad_from_deg(0)) { if(previous_start == start){ previous_lenght = Geom::distance((Geom::Point)start, (Geom::Point)end); } @@ -406,7 +406,7 @@ LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise > const trans = (Geom::Point)end - helper.initialPoint(); } if(offset != 0){ - trans = Geom::Point::polar(transformed.angle() + Geom::deg_to_rad(-90),offset) + trans; + trans = Geom::Point::polar(transformed.angle() + Geom::rad_from_deg(-90),offset) + trans; } m *= Geom::Translate(trans); -- cgit v1.2.3 From 4aba6b92f30733f400891d2c3a6d77c1ae1d7a47 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Wed, 2 Mar 2016 20:34:31 +0100 Subject: Fix for bug 1540070 Fixed bugs: - https://launchpad.net/bugs/1540070 (bzr r14678) --- src/live_effects/lpe-transform_2pts.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'src/live_effects/lpe-transform_2pts.cpp') diff --git a/src/live_effects/lpe-transform_2pts.cpp b/src/live_effects/lpe-transform_2pts.cpp index dd1a29689..1cd59b7fa 100644 --- a/src/live_effects/lpe-transform_2pts.cpp +++ b/src/live_effects/lpe-transform_2pts.cpp @@ -78,6 +78,7 @@ LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) : strech.param_set_range(0, 999.0); strech.param_set_increments(0.01, 0.01); strech.param_set_digits(4); + apply_to_clippath_and_mask = true; } LPETransform2Pts::~LPETransform2Pts() @@ -167,8 +168,6 @@ LPETransform2Pts::doBeforeEffect (SPLPEItem const* lpeitem) previous_angle = transformed.angle(); previous_lenght = Geom::distance((Geom::Point)start, (Geom::Point)end); previous_start = start; - splpeitem->apply_to_clippath(splpeitem); - splpeitem->apply_to_mask(splpeitem); } void -- cgit v1.2.3