summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/live_effects/lpe-bspline.cpp320
-rw-r--r--src/live_effects/lpe-bspline.h7
-rw-r--r--src/live_effects/lpe-lattice2.cpp560
-rw-r--r--src/live_effects/lpe-lattice2.h63
-rw-r--r--src/live_effects/lpe-perspective-envelope.cpp273
-rw-r--r--src/live_effects/lpe-perspective-envelope.h18
-rw-r--r--src/live_effects/lpe-roughen.cpp206
-rw-r--r--src/live_effects/lpe-roughen.h14
-rw-r--r--src/live_effects/lpe-show_handles.cpp76
-rw-r--r--src/live_effects/lpe-show_handles.h14
-rw-r--r--src/live_effects/lpe-simplify.cpp190
-rw-r--r--src/live_effects/lpe-simplify.h48
-rw-r--r--src/ui/tool/curve-drag-point.cpp4
-rw-r--r--src/ui/tool/node.cpp98
-rw-r--r--src/ui/tool/path-manipulator.cpp122
-rw-r--r--src/ui/tool/path-manipulator.h12
-rw-r--r--src/ui/tools/freehand-base.cpp12
-rw-r--r--src/ui/tools/freehand-base.h2
-rw-r--r--src/ui/tools/pen-tool.cpp407
-rw-r--r--src/ui/tools/pen-tool.h28
-rw-r--r--src/ui/tools/pencil-tool.cpp22
21 files changed, 1252 insertions, 1244 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<Geom::SBasis> SBasisIn;
- Geom::D2<Geom::SBasis> SBasisOut;
- Geom::D2<Geom::SBasis> SBasisHelper;
+ Geom::Point point_at1(0, 0);
+ Geom::Point point_at2(0, 0);
+ Geom::Point next_point_at1(0, 0);
+ Geom::D2<Geom::SBasis> sbasis_in;
+ Geom::D2<Geom::SBasis> sbasis_out;
+ Geom::D2<Geom::SBasis> 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<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
- SPCurve *lineHelper = new SPCurve();
+ Geom::D2<Geom::SBasis> sbasis_start = start->first_segment()->toSBasis();
+ SPCurve *line_helper = new SPCurve();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*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<Geom::SBasis> SBasisEnd = end->first_segment()->toSBasis();
+ Geom::D2<Geom::SBasis> sbasis_end = end->first_segment()->toSBasis();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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<Gtk::Widget *>(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<Inkscape::UI::Widget::Scalar *>(widg));
- widgRegistered->signal_value_changed()
+ widg_registered->signal_value_changed()
.connect(sigc::mem_fun(*this, &LPEBSpline::toWeight));
- widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+ widg = dynamic_cast<Gtk::Widget *>(widg_registered);
if (widg) {
- Gtk::HBox * scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
- std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
- Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
- entryWidg->set_width_chars(6);
+ Gtk::HBox * hbox_weight_steps = dynamic_cast<Gtk::HBox *>(widg);
+ std::vector< Gtk::Widget* > childList = hbox_weight_steps->get_children();
+ Gtk::Entry* entry_widget = dynamic_cast<Gtk::Entry *>(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<Gtk::CheckButton *>(widg));
- widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+ widg = dynamic_cast<Gtk::Widget *>(widg_registered);
}
- if (param->param_key == "ignoreCusp") {
- Gtk::CheckButton *widgRegistered =
+ if (param->param_key == "ignore_cusp") {
+ Gtk::CheckButton *widg_registered =
Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
- widg = dynamic_cast<Gtk::Widget *>(widgRegistered);
+ widg = dynamic_cast<Gtk::Widget *>(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<SPPath *>(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<Geom::SBasis> SBasisIn;
- Geom::D2<Geom::SBasis> 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<Geom::SBasis> sbasis_in;
+ Geom::D2<Geom::SBasis> 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<Geom::CubicBezier const *>(&*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/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 <lattice2> 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 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint0", &wr, this),
- grid_point1(_("Control 1:"), _("Control 1 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint1", &wr, this),
- grid_point2(_("Control 2:"), _("Control 2 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint2", &wr, this),
- grid_point3(_("Control 3:"), _("Control 3 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint3", &wr, this),
- grid_point4(_("Control 4:"), _("Control 4 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint4", &wr, this),
- grid_point5(_("Control 5:"), _("Control 5 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint5", &wr, this),
- grid_point6(_("Control 6:"), _("Control 6 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint6", &wr, this),
- grid_point7(_("Control 7:"), _("Control 7 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint7", &wr, this),
- grid_point8x9(_("Control 8x9:"), _("Control 8x9 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint8x9", &wr, this),
- grid_point10x11(_("Control 10x11:"), _("Control 10x11 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint10x11", &wr, this),
- grid_point12(_("Control 12:"), _("Control 12 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint12", &wr, this),
- grid_point13(_("Control 13:"), _("Control 13 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint13", &wr, this),
- grid_point14(_("Control 14:"), _("Control 14 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint14", &wr, this),
- grid_point15(_("Control 15:"), _("Control 15 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint15", &wr, this),
- grid_point16(_("Control 16:"), _("Control 16 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint16", &wr, this),
- grid_point17(_("Control 17:"), _("Control 17 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint17", &wr, this),
- grid_point18(_("Control 18:"), _("Control 18 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint18", &wr, this),
- grid_point19(_("Control 19:"), _("Control 19 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint19", &wr, this),
- grid_point20x21(_("Control 20x21:"), _("Control 20x21 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint20x21", &wr, this),
- grid_point22x23(_("Control 22x23:"), _("Control 22x23 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint22x23", &wr, this),
- grid_point24x26(_("Control 24x26:"), _("Control 24x26 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint24x26", &wr, this),
- grid_point25x27(_("Control 25x27:"), _("Control 25x27 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint25x27", &wr, this),
- grid_point28x30(_("Control 28x30:"), _("Control 28x30 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint28x30", &wr, this),
- grid_point29x31(_("Control 29x31:"), _("Control 29x31 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint29x31", &wr, this),
- grid_point32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: 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 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint0", &wr, this),
+ grid_point_1(_("Control 1:"), _("Control 1 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint1", &wr, this),
+ grid_point_2(_("Control 2:"), _("Control 2 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint2", &wr, this),
+ grid_point_3(_("Control 3:"), _("Control 3 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint3", &wr, this),
+ grid_point_4(_("Control 4:"), _("Control 4 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint4", &wr, this),
+ grid_point_5(_("Control 5:"), _("Control 5 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint5", &wr, this),
+ grid_point_6(_("Control 6:"), _("Control 6 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint6", &wr, this),
+ grid_point_7(_("Control 7:"), _("Control 7 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint7", &wr, this),
+ grid_point_8x9(_("Control 8x9:"), _("Control 8x9 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint8x9", &wr, this),
+ grid_point_10x11(_("Control 10x11:"), _("Control 10x11 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint10x11", &wr, this),
+ grid_point_12(_("Control 12:"), _("Control 12 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint12", &wr, this),
+ grid_point_13(_("Control 13:"), _("Control 13 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint13", &wr, this),
+ grid_point_14(_("Control 14:"), _("Control 14 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint14", &wr, this),
+ grid_point_15(_("Control 15:"), _("Control 15 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint15", &wr, this),
+ grid_point_16(_("Control 16:"), _("Control 16 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint16", &wr, this),
+ grid_point_17(_("Control 17:"), _("Control 17 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint17", &wr, this),
+ grid_point_18(_("Control 18:"), _("Control 18 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint18", &wr, this),
+ grid_point_19(_("Control 19:"), _("Control 19 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint19", &wr, this),
+ grid_point_20x21(_("Control 20x21:"), _("Control 20x21 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint20x21", &wr, this),
+ grid_point_22x23(_("Control 22x23:"), _("Control 22x23 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint22x23", &wr, this),
+ grid_point_24x26(_("Control 24x26:"), _("Control 24x26 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint24x26", &wr, this),
+ grid_point_25x27(_("Control 25x27:"), _("Control 25x27 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint25x27", &wr, this),
+ grid_point_28x30(_("Control 28x30:"), _("Control 28x30 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint28x30", &wr, this),
+ grid_point_29x31(_("Control 29x31:"), _("Control 29x31 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "gridpoint29x31", &wr, this),
+ grid_point_32x33x34x35(_("Control 32x33x34x35:"), _("Control 32x33x34x35 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: 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<Geom::D2<Geom::SBasis> > const & pwd
PathVector cubic = pathv_to_cubicbezier(pathv);
Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in_linear_and_cubic = paths_to_pw(cubic);
D2<SBasis2d> 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<Geom::D2<Geom::SBasis> > const & pwd
//Grouping the point params in a convenient vector
std::vector<Geom::Point > 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<Geom::D2<Geom::SBasis> > 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<Geom::D2<Geom::SBasis> > const & pwd
}
}
}
-
+
Piecewise<D2<SBasis> > 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<Parameter *>::iterator it = param_vector.begin();
while (it != param_vector.end()) {
if ((*it)->widget_is_visible) {
Parameter * param = *it;
Gtk::Widget * widg = dynamic_cast<Gtk::Widget *>(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<Gtk::Widget *>(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 &paramA, PointParam &paramB, Geom::Line vert){
- Geom::Point A = paramA;
- Geom::Point B = paramB;
+LPELattice2::vertical(PointParam &param_one, PointParam &param_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 &paramA, PointParam &paramB, Geom::Line horiz){
- Geom::Point A = paramA;
- Geom::Point B = paramB;
+LPELattice2::horizontal(PointParam &param_one, PointParam &param_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<SPLPEItem*>(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::vector<Geom:
hp_vec.clear();
SPCurve *c = new SPCurve();
- calculateCurve(grid_point0,grid_point4, c,true, true);
- calculateCurve(grid_point4,grid_point8x9, c,true, false);
- calculateCurve(grid_point8x9,grid_point5, c,true, false);
- calculateCurve(grid_point5,grid_point1, c,true, false);
-
- calculateCurve(grid_point12,grid_point16, c,true, true);
- calculateCurve(grid_point16,grid_point20x21, c,true, false);
- calculateCurve(grid_point20x21,grid_point17, c,true, false);
- calculateCurve(grid_point17,grid_point13, c,true, false);
-
- calculateCurve(grid_point24x26,grid_point28x30, c,true, true);
- calculateCurve(grid_point28x30,grid_point32x33x34x35, c,true, false);
- calculateCurve(grid_point32x33x34x35,grid_point29x31, c,true, false);
- calculateCurve(grid_point29x31,grid_point25x27, c,true, false);
-
- calculateCurve(grid_point14,grid_point18, c,true, true);
- calculateCurve(grid_point18,grid_point22x23, c,true, false);
- calculateCurve(grid_point22x23,grid_point19, c,true, false);
- calculateCurve(grid_point19,grid_point15, c,true, false);
-
- calculateCurve(grid_point2,grid_point6, c,true, true);
- calculateCurve(grid_point6,grid_point10x11, c,true, false);
- calculateCurve(grid_point10x11,grid_point7, c,true, false);
- calculateCurve(grid_point7,grid_point3, c,true, false);
-
- calculateCurve(grid_point0,grid_point12, c,false, true);
- calculateCurve(grid_point12,grid_point24x26, c,false, false);
- calculateCurve(grid_point24x26,grid_point14, c,false, false);
- calculateCurve(grid_point14,grid_point2, c,false, false);
-
- calculateCurve(grid_point4,grid_point16, c,false, true);
- calculateCurve(grid_point16,grid_point28x30, c,false, false);
- calculateCurve(grid_point28x30,grid_point18, c,false, false);
- calculateCurve(grid_point18,grid_point6, c,false, false);
-
- calculateCurve(grid_point8x9,grid_point20x21, c,false, true);
- calculateCurve(grid_point20x21,grid_point32x33x34x35, c,false, false);
- calculateCurve(grid_point32x33x34x35,grid_point22x23, c,false, false);
- calculateCurve(grid_point22x23,grid_point10x11, c,false, false);
-
- calculateCurve(grid_point5,grid_point17, c, false, true);
- calculateCurve(grid_point17,grid_point29x31, c,false, false);
- calculateCurve(grid_point29x31,grid_point19, c,false, false);
- calculateCurve(grid_point19,grid_point7, c,false, false);
-
- calculateCurve(grid_point1,grid_point13, c, false, true);
- calculateCurve(grid_point13,grid_point25x27, c,false, false);
- calculateCurve(grid_point25x27,grid_point15, c,false, false);
- calculateCurve(grid_point15,grid_point3, c, false, false);
+ calculateCurve(grid_point_0,grid_point_4, c,true, true);
+ calculateCurve(grid_point_4,grid_point_8x9, c,true, false);
+ calculateCurve(grid_point_8x9,grid_point_5, c,true, false);
+ calculateCurve(grid_point_5,grid_point_1, c,true, false);
+
+ calculateCurve(grid_point_12,grid_point_16, c,true, true);
+ calculateCurve(grid_point_16,grid_point_20x21, c,true, false);
+ calculateCurve(grid_point_20x21,grid_point_17, c,true, false);
+ calculateCurve(grid_point_17,grid_point_13, c,true, false);
+
+ calculateCurve(grid_point_24x26,grid_point_28x30, c,true, true);
+ calculateCurve(grid_point_28x30,grid_point_32x33x34x35, c,true, false);
+ calculateCurve(grid_point_32x33x34x35,grid_point_29x31, c,true, false);
+ calculateCurve(grid_point_29x31,grid_point_25x27, c,true, false);
+
+ calculateCurve(grid_point_14,grid_point_18, c,true, true);
+ calculateCurve(grid_point_18,grid_point_22x23, c,true, false);
+ calculateCurve(grid_point_22x23,grid_point_19, c,true, false);
+ calculateCurve(grid_point_19,grid_point_15, c,true, false);
+
+ calculateCurve(grid_point_2,grid_point_6, c,true, true);
+ calculateCurve(grid_point_6,grid_point_10x11, c,true, false);
+ calculateCurve(grid_point_10x11,grid_point_7, c,true, false);
+ calculateCurve(grid_point_7,grid_point_3, c,true, false);
+
+ calculateCurve(grid_point_0,grid_point_12, c,false, true);
+ calculateCurve(grid_point_12,grid_point_24x26, c,false, false);
+ calculateCurve(grid_point_24x26,grid_point_14, c,false, false);
+ calculateCurve(grid_point_14,grid_point_2, c,false, false);
+
+ calculateCurve(grid_point_4,grid_point_16, c,false, true);
+ calculateCurve(grid_point_16,grid_point_28x30, c,false, false);
+ calculateCurve(grid_point_28x30,grid_point_18, c,false, false);
+ calculateCurve(grid_point_18,grid_point_6, c,false, false);
+
+ calculateCurve(grid_point_8x9,grid_point_20x21, c,false, true);
+ calculateCurve(grid_point_20x21,grid_point_32x33x34x35, c,false, false);
+ calculateCurve(grid_point_32x33x34x35,grid_point_22x23, c,false, false);
+ calculateCurve(grid_point_22x23,grid_point_10x11, c,false, false);
+
+ calculateCurve(grid_point_5,grid_point_17, c, false, true);
+ calculateCurve(grid_point_17,grid_point_29x31, c,false, false);
+ calculateCurve(grid_point_29x31,grid_point_19, c,false, false);
+ calculateCurve(grid_point_19,grid_point_7, c,false, false);
+
+ calculateCurve(grid_point_1,grid_point_13, c, false, true);
+ calculateCurve(grid_point_13,grid_point_25x27, c,false, false);
+ calculateCurve(grid_point_25x27,grid_point_15, c,false, false);
+ calculateCurve(grid_point_15,grid_point_3, c, false, false);
hp_vec.push_back(c->get_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<Geom::D2<Geom::SBasis> > doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > 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<Geom::PathVector> &/*hp_vec*/);
-
- //virtual std::vector<Geom::PathVector> getHelperPaths(SPLPEItem const* lpeitem);
protected:
void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &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;
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 <perspective-envelope> 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<unsigned> 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 - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Up_Left_Point", &wr, this),
- Up_Right_Point(_("Top Right"), _("Top Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Up_Right_Point", &wr, this),
- Down_Left_Point(_("Down Left"), _("Down Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Down_Left_Point", &wr, this),
- Down_Right_Point(_("Down Right"), _("Down Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "Down_Right_Point", &wr, this)
+ up_left_point(_("Top Left"), _("Top Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "up_left_point", &wr, this),
+ up_right_point(_("Top Right"), _("Top Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "up_right_point", &wr, this),
+ down_left_point(_("Down Left"), _("Down Left - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: move along axes"), "down_left_point", &wr, this),
+ down_right_point(_("Down Right"), _("Down Right - <b>Ctrl+Alt+Click</b>: reset, <b>Ctrl</b>: 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<Geom::Point> handles(4);
- handles[0] = Down_Left_Point;
- handles[1] = Up_Left_Point;
- handles[2] = Up_Right_Point;
- handles[3] = Down_Right_Point;
- std::vector<Geom::Point> 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<Geom::Point> 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<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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<Parameter *>::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<Gtk::Widget *>(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<Gtk::HBox *>(widg);
- std::vector< Gtk::Widget* > childList = pointParameter->get_children();
- Gtk::HBox * pointParameterHBox = dynamic_cast<Gtk::HBox *>(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<Gtk::HBox *>(widg);
+ std::vector< Gtk::Widget* > child_list = point_hbox->get_children();
+ Gtk::HBox * point_hboxHBox = dynamic_cast<Gtk::HBox *>(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<Gtk::Widget *>(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 <perspective-envelope> 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<unsigned> 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&);
diff --git a/src/live_effects/lpe-roughen.cpp b/src/live_effects/lpe-roughen.cpp
index 8cef9a3a3..9d1c3152b 100644
--- a/src/live_effects/lpe-roughen.cpp
+++ b/src/live_effects/lpe-roughen.cpp
@@ -39,36 +39,36 @@ LPERoughen::LPERoughen(LivePathEffectObject *lpeobject)
unit(_("Unit"), _("Unit"), "unit", &wr, this),
method(_("Method"), _("Division method"), "method", DMConverter, &wr,
this, DM_SEGMENTS),
- maxSegmentSize(_("Max. segment size"), _("Max. segment size"),
- "maxSegmentSize", &wr, this, 10.),
+ max_segment_size(_("Max. segment size"), _("Max. segment size"),
+ "max_segment_size", &wr, this, 10.),
segments(_("Number of segments"), _("Number of segments"), "segments",
&wr, this, 2),
- displaceX(_("Max. displacement in X"), _("Max. displacement in X"),
- "displaceX", &wr, this, 10.),
- displaceY(_("Max. displacement in Y"), _("Max. displacement in Y"),
- "displaceY", &wr, this, 10.),
- globalRandomize(_("Global randomize"), _("Global randomize"),
- "globalRandomize", &wr, this, 1.),
- shiftNodes(_("Shift nodes"), _("Shift nodes"), "shiftNodes", &wr, this,
+ displace_x(_("Max. displacement in X"), _("Max. displacement in X"),
+ "displace_x", &wr, this, 10.),
+ displace_y(_("Max. displacement in Y"), _("Max. displacement in Y"),
+ "displace_y", &wr, this, 10.),
+ global_randomize(_("Global randomize"), _("Global randomize"),
+ "global_randomize", &wr, this, 1.),
+ shift_nodes(_("Shift nodes"), _("Shift nodes"), "shift_nodes", &wr, this,
true),
- shiftNodeHandles(_("Shift node handles"), _("Shift node handles"),
- "shiftNodeHandles", &wr, this, true)
+ shift_node_handles(_("Shift node handles"), _("Shift node handles"),
+ "shift_node_handles", &wr, this, true)
{
registerParameter(&unit);
registerParameter(&method);
- registerParameter(&maxSegmentSize);
+ registerParameter(&max_segment_size);
registerParameter(&segments);
- registerParameter(&displaceX);
- registerParameter(&displaceY);
- registerParameter(&globalRandomize);
- registerParameter(&shiftNodes);
- registerParameter(&shiftNodeHandles);
- displaceX.param_set_range(0., Geom::infinity());
- displaceY.param_set_range(0., Geom::infinity());
- globalRandomize.param_set_range(0., Geom::infinity());
- maxSegmentSize.param_set_range(0., Geom::infinity());
- maxSegmentSize.param_set_increments(1, 1);
- maxSegmentSize.param_set_digits(1);
+ registerParameter(&displace_x);
+ registerParameter(&displace_y);
+ registerParameter(&global_randomize);
+ registerParameter(&shift_nodes);
+ registerParameter(&shift_node_handles);
+ displace_x.param_set_range(0., Geom::infinity());
+ displace_y.param_set_range(0., Geom::infinity());
+ global_randomize.param_set_range(0., Geom::infinity());
+ max_segment_size.param_set_range(0., Geom::infinity());
+ max_segment_size.param_set_increments(1, 1);
+ max_segment_size.param_set_digits(1);
segments.param_set_range(1, Geom::infinity());
segments.param_set_increments(1, 1);
segments.param_set_digits(0);
@@ -78,9 +78,9 @@ LPERoughen::~LPERoughen() {}
void LPERoughen::doBeforeEffect(SPLPEItem const *lpeitem)
{
- displaceX.resetRandomizer();
- displaceY.resetRandomizer();
- globalRandomize.resetRandomizer();
+ displace_x.resetRandomizer();
+ displace_y.resetRandomizer();
+ global_randomize.resetRandomizer();
srand(1);
SPLPEItem * item = const_cast<SPLPEItem*>(lpeitem);
item->apply_to_clippath(item);
@@ -99,37 +99,37 @@ Gtk::Widget *LPERoughen::newWidget()
Parameter *param = *it;
Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
if (param->param_key == "unit") {
- Gtk::Label *unitLabel = Gtk::manage(new Gtk::Label(
+ Gtk::Label *unit_label = Gtk::manage(new Gtk::Label(
Glib::ustring(_("<b>Roughen unit</b>")), Gtk::ALIGN_START));
- unitLabel->set_use_markup(true);
- vbox->pack_start(*unitLabel, false, false, 2);
+ unit_label->set_use_markup(true);
+ vbox->pack_start(*unit_label, false, false, 2);
vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
Gtk::PACK_EXPAND_WIDGET);
}
if (param->param_key == "method") {
- Gtk::Label *methodLabel = Gtk::manage(new Gtk::Label(
+ Gtk::Label *method_label = Gtk::manage(new Gtk::Label(
Glib::ustring(_("<b>Add nodes</b> Subdivide each segment")),
Gtk::ALIGN_START));
- methodLabel->set_use_markup(true);
- vbox->pack_start(*methodLabel, false, false, 2);
+ method_label->set_use_markup(true);
+ vbox->pack_start(*method_label, false, false, 2);
vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
Gtk::PACK_EXPAND_WIDGET);
}
- if (param->param_key == "displaceX") {
- Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+ if (param->param_key == "displace_x") {
+ Gtk::Label *displace_x_label = Gtk::manage(new Gtk::Label(
Glib::ustring(_("<b>Jitter nodes</b> Move nodes/handles")),
Gtk::ALIGN_START));
- displaceXLabel->set_use_markup(true);
- vbox->pack_start(*displaceXLabel, false, false, 2);
+ displace_x_label->set_use_markup(true);
+ vbox->pack_start(*displace_x_label, false, false, 2);
vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
Gtk::PACK_EXPAND_WIDGET);
}
- if (param->param_key == "globalRandomize") {
- Gtk::Label *displaceXLabel = Gtk::manage(new Gtk::Label(
+ if (param->param_key == "global_randomize") {
+ Gtk::Label *global_rand = Gtk::manage(new Gtk::Label(
Glib::ustring(_("<b>Extra roughen</b> Add a extra layer of rough")),
Gtk::ALIGN_START));
- displaceXLabel->set_use_markup(true);
- vbox->pack_start(*displaceXLabel, false, false, 2);
+ global_rand->set_use_markup(true);
+ vbox->pack_start(*global_rand, false, false, 2);
vbox->pack_start(*Gtk::manage(new Gtk::HSeparator()),
Gtk::PACK_EXPAND_WIDGET);
}
@@ -150,23 +150,23 @@ Gtk::Widget *LPERoughen::newWidget()
return dynamic_cast<Gtk::Widget *>(vbox);
}
-double LPERoughen::sign(double randNumber)
+double LPERoughen::sign(double random_number)
{
if (rand() % 100 < 49) {
- randNumber *= -1.;
+ random_number *= -1.;
}
- return randNumber;
+ return random_number;
}
Geom::Point LPERoughen::randomize()
{
Inkscape::Util::Unit const *svg_units = SP_ACTIVE_DESKTOP->namedview->svg_units;
- double displaceXParsed = Inkscape::Util::Quantity::convert(
- displaceX * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
- double displaceYParsed = Inkscape::Util::Quantity::convert(
- displaceY * globalRandomize, unit.get_abbreviation(), svg_units->abbr);
+ double displace_x_parsed = Inkscape::Util::Quantity::convert(
+ displace_x * global_randomize, unit.get_abbreviation(), svg_units->abbr);
+ double displace_y_parsed = Inkscape::Util::Quantity::convert(
+ displace_y * global_randomize, unit.get_abbreviation(), svg_units->abbr);
- Geom::Point output = Geom::Point(sign(displaceXParsed), sign(displaceYParsed));
+ Geom::Point output = Geom::Point(sign(displace_x_parsed), sign(displace_y_parsed));
return output;
}
@@ -193,32 +193,32 @@ void LPERoughen::doEffect(SPCurve *curve)
}
}
Geom::Point initialMove(0, 0);
- if (shiftNodes) {
+ if (shift_nodes) {
initialMove = randomize();
}
Geom::Point initialPoint = curve_it1->initialPoint() + initialMove;
nCurve->moveto(initialPoint);
- Geom::Point A0(0, 0);
- Geom::Point A1(0, 0);
- Geom::Point A2(0, 0);
- Geom::Point A3(0, 0);
+ Geom::Point point0(0, 0);
+ Geom::Point point1(0, 0);
+ Geom::Point point2(0, 0);
+ Geom::Point point3(0, 0);
bool first = true;
while (curve_it1 != curve_endit) {
Geom::CubicBezier const *cubic = NULL;
- A0 = curve_it1->initialPoint();
- A1 = curve_it1->initialPoint();
- A2 = curve_it1->finalPoint();
- A3 = curve_it1->finalPoint();
+ point0 = curve_it1->initialPoint();
+ point1 = curve_it1->initialPoint();
+ point2 = curve_it1->finalPoint();
+ point3 = curve_it1->finalPoint();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*curve_it1);
if (cubic) {
- A1 = (*cubic)[1];
- if (shiftNodes && first) {
- A1 = (*cubic)[1] + initialMove;
+ point1 = (*cubic)[1];
+ if (shift_nodes && first) {
+ point1 = (*cubic)[1] + initialMove;
}
- A2 = (*cubic)[2];
- nCurve->curveto(A1, A2, A3);
+ point2 = (*cubic)[2];
+ nCurve->curveto(point1, point2, point3);
} else {
- nCurve->lineto(A3);
+ nCurve->lineto(point3);
}
double length = Inkscape::Util::Quantity::convert(
curve_it1->length(0.001), svg_units->abbr, unit.get_abbreviation());
@@ -226,7 +226,7 @@ void LPERoughen::doEffect(SPCurve *curve)
if (method == DM_SEGMENTS) {
splits = segments;
} else {
- splits = ceil(length / maxSegmentSize);
+ splits = ceil(length / max_segment_size);
}
for (unsigned int t = splits; t >= 1; t--) {
if (t == 1 && splits != 1) {
@@ -265,42 +265,42 @@ SPCurve *LPERoughen::addNodesAndJitter(const Geom::Curve *A, double t)
{
SPCurve *out = new SPCurve();
Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
- Geom::Point A1(0, 0);
- Geom::Point A2(0, 0);
- Geom::Point A3(0, 0);
- Geom::Point B1(0, 0);
- Geom::Point B2(0, 0);
- Geom::Point B3(0, 0);
- if (shiftNodes) {
- A3 = randomize();
- B3 = randomize();
+ Geom::Point point1(0, 0);
+ Geom::Point point2(0, 0);
+ Geom::Point point3(0, 0);
+ Geom::Point point_b1(0, 0);
+ Geom::Point point_b2(0, 0);
+ Geom::Point point_b3(0, 0);
+ if (shift_nodes) {
+ point3 = randomize();
+ point_b3 = randomize();
}
- if (shiftNodeHandles) {
- A1 = randomize();
- A2 = randomize();
- B1 = randomize();
- B2 = randomize();
+ if (shift_node_handles) {
+ point1 = randomize();
+ point2 = randomize();
+ point_b1 = randomize();
+ point_b2 = randomize();
} else {
- A2 = A3;
- B1 = A3;
- B2 = B3;
+ point2 = point3;
+ point_b1 = point3;
+ point_b2 = point_b3;
}
if (cubic) {
std::pair<Geom::CubicBezier, Geom::CubicBezier> div = cubic->subdivide(t);
std::vector<Geom::Point> seg1 = div.first.points(),
seg2 = div.second.points();
out->moveto(seg1[0]);
- out->curveto(seg1[1] + A1, seg1[2] + A2, seg1[3] + A3);
- out->curveto(seg2[1] + B1, seg2[2], seg2[3]);
- } else if (shiftNodeHandles) {
+ out->curveto(seg1[1] + point1, seg1[2] + point2, seg1[3] + point3);
+ out->curveto(seg2[1] + point_b1, seg2[2], seg2[3]);
+ } else if (shift_node_handles) {
out->moveto(A->initialPoint());
- out->curveto(A->pointAt(t / 3) + A1, A->pointAt((t / 3) * 2) + A2,
- A->pointAt(t) + A3);
- out->curveto(A->pointAt(t + (t / 3)) + B1, A->pointAt(t + ((t / 3) * 2)),
+ out->curveto(A->pointAt(t / 3) + point1, A->pointAt((t / 3) * 2) + point2,
+ A->pointAt(t) + point3);
+ out->curveto(A->pointAt(t + (t / 3)) + point_b1, A->pointAt(t + ((t / 3) * 2)),
A->finalPoint());
} else {
out->moveto(A->initialPoint());
- out->lineto(A->pointAt(t) + A3);
+ out->lineto(A->pointAt(t) + point3);
out->lineto(A->finalPoint());
}
return out;
@@ -310,33 +310,33 @@ SPCurve *LPERoughen::jitter(const Geom::Curve *A)
{
SPCurve *out = new SPCurve();
Geom::CubicBezier const *cubic = dynamic_cast<Geom::CubicBezier const *>(&*A);
- Geom::Point A1(0, 0);
- Geom::Point A2(0, 0);
- Geom::Point A3(0, 0);
- if (shiftNodes) {
- A3 = randomize();
+ Geom::Point point1(0, 0);
+ Geom::Point point2(0, 0);
+ Geom::Point point3(0, 0);
+ if (shift_nodes) {
+ point3 = randomize();
}
- if (shiftNodeHandles) {
- A1 = randomize();
- A2 = randomize();
+ if (shift_node_handles) {
+ point1 = randomize();
+ point2 = randomize();
} else {
- A2 = A3;
+ point2 = point3;
}
if (cubic) {
out->moveto((*cubic)[0]);
- out->curveto((*cubic)[1] + A1, (*cubic)[2] + A2, (*cubic)[3] + A3);
- } else if (shiftNodeHandles) {
+ out->curveto((*cubic)[1] + point1, (*cubic)[2] + point2, (*cubic)[3] + point3);
+ } else if (shift_node_handles) {
out->moveto(A->initialPoint());
- out->curveto(A->pointAt(0.3333) + A1, A->pointAt(0.6666) + A2,
- A->finalPoint() + A3);
+ out->curveto(A->pointAt(0.3333) + point1, A->pointAt(0.6666) + point2,
+ A->finalPoint() + point3);
} else {
out->moveto(A->initialPoint());
- out->lineto(A->finalPoint() + A3);
+ out->lineto(A->finalPoint() + point3);
}
return out;
}
-Geom::Point LPERoughen::tpoint(Geom::Point A, Geom::Point B, double t)
+Geom::Point LPERoughen::tPoint(Geom::Point A, Geom::Point B, double t)
{
using Geom::X;
using Geom::Y;
diff --git a/src/live_effects/lpe-roughen.h b/src/live_effects/lpe-roughen.h
index 74331f1ef..ed9f06cf7 100644
--- a/src/live_effects/lpe-roughen.h
+++ b/src/live_effects/lpe-roughen.h
@@ -41,19 +41,19 @@ public:
virtual void doBeforeEffect(SPLPEItem const * lpeitem);
virtual SPCurve *addNodesAndJitter(const Geom::Curve *A, double t);
virtual SPCurve *jitter(const Geom::Curve *A);
- virtual Geom::Point tpoint(Geom::Point A, Geom::Point B, double t = 0.5);
+ virtual Geom::Point tPoint(Geom::Point A, Geom::Point B, double t = 0.5);
virtual Gtk::Widget *newWidget();
private:
UnitParam unit;
EnumParam<DivisionMethod> method;
- ScalarParam maxSegmentSize;
+ ScalarParam max_segment_size;
ScalarParam segments;
- RandomParam displaceX;
- RandomParam displaceY;
- RandomParam globalRandomize;
- BoolParam shiftNodes;
- BoolParam shiftNodeHandles;
+ RandomParam displace_x;
+ RandomParam displace_y;
+ RandomParam global_randomize;
+ BoolParam shift_nodes;
+ BoolParam shift_node_handles;
LPERoughen(const LPERoughen &);
LPERoughen &operator=(const LPERoughen &);
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<Parameter *>(&nodes));
- registerParameter(dynamic_cast<Parameter *>(&handles));
- registerParameter(dynamic_cast<Parameter *>(&originalPath));
- registerParameter(dynamic_cast<Parameter *>(&scaleNodesAndHandles));
- registerParameter(dynamic_cast<Parameter *>(&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<SPLPEItem*>(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<Geom::Path> LPEShowHandles::doEffect_path (std::vector<Geom::Path> const & path_in)
{
std::vector<Geom::Path> 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<Geom::CubicBezier const *>(&*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<Geom::LineSegment>( 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 &);
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<SPLPEItem*>(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<Gtk::Widget *>(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<Gtk::HBox *>(widg);
- std::vector< Gtk::Widget* > childList = scalarParameter->get_children();
- Gtk::Entry* entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
- entryWidg->set_width_chars(8);
+ Gtk::HBox * horizontal_box = dynamic_cast<Gtk::HBox *>(widg);
+ std::vector< Gtk::Widget* > child_list = horizontal_box->get_children();
+ Gtk::Entry* entry_widg = dynamic_cast<Gtk::Entry *>(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<Gtk::Widget *>(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<Inkscape::UI::Tools::NodeTool*>(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<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(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<Geom::PathVector> &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 &);
};
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<Inkscape::SnapCandidatePoint> 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<Node*>(*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<Handle *>(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
"<b>Auto node handle</b>: drag to convert to smooth node (%s)"), more);
}else{
return format_tip(C_("Path handle tip",
- "<b>BSpline node handle</b>: Shift to drag, double click to reset (%s). %g power"),more,_pm().BSplineHandlePosition(h,NULL));
+ "<b>BSpline node handle</b>: 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<Handle *>(&_front);
Handle *h2 = const_cast<Handle *>(&_back);
if (state_held_shift(state)) {
@@ -1470,7 +1470,7 @@ Glib::ustring Node::_getTip(unsigned state) const
"<b>%s</b>: drag to shape the path (more: Shift, Ctrl, Alt)"), nodetype);
}else if(_selection.size() == 1){
return format_tip(C_("Path node tip",
- "<b>BSpline node</b>: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2));
+ "<b>BSpline node</b>: drag to shape the path (more: Shift, Ctrl, Alt). %g power"),_pm()._bsplineHandlePosition(h,h2));
}
return format_tip(C_("Path node tip",
"<b>%s</b>: 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
"<b>%s</b>: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt)"), nodetype);
}else{
return format_tip(C_("Path node tip",
- "<b>BSpline node</b>: drag to shape the path, click to select only this node (more: Shift, Ctrl, Alt). %g power"),_pm().BSplineHandlePosition(h,h2));
+ "<b>BSpline node</b>: 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<SPLPEItem *>(_path);
if (path){
if(path->hasPathEffect()){
- Inkscape::LivePathEffect::Effect const *thisEffect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
- if(thisEffect){
- lpe_bsp = dynamic_cast<LivePathEffect::LPEBSpline const*>(thisEffect->getLPEObj()->get_lpe());
+ Inkscape::LivePathEffect::Effect const *this_effect = path->getPathEffectOfType(Inkscape::LivePathEffect::BSPLINE);
+ if(this_effect){
+ lpe_bsp = dynamic_cast<LivePathEffect::LPEBSpline const*>(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<SubpathPtr>::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<LivePathEffect::LPEPowerStroke*>(thisEffect->getLPEObj()->get_lpe());
+ Inkscape::LivePathEffect::Effect* this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::POWERSTROKE);
+ if(this_effect){
+ LivePathEffect::LPEPowerStroke *lpe_pwr = dynamic_cast<LivePathEffect::LPEPowerStroke*>(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<LivePathEffect::LPEFilletChamfer*>(thisEffect->getLPEObj()->get_lpe());
+ this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
+ if(this_effect){
+ LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(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 096957be0..9aa6c9589 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -93,7 +93,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)
@@ -150,7 +150,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);
@@ -632,12 +632,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);
@@ -654,7 +654,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<Geom::CubicBezier const*>(&*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<Geom::CubicBezier const*>(&*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<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ tmp_curve = tmp_curve ->create_reverse();
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*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<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ if(!tmp_curve ->is_empty()){
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*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<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*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<Geom::CubicBezier const*>(&*tmpCurve->last_segment());
+ Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const*>(&*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<Effect*> ( 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<Geom::SBasis> SBasisIn;
- Geom::D2<Geom::SBasis> SBasisOut;
- Geom::D2<Geom::SBasis> SBasisHelper;
+ Geom::Point point_at1(0, 0);
+ Geom::Point point_at2(0, 0);
+ Geom::Point next_point_at1(0, 0);
+ Geom::D2<Geom::SBasis> sbasis_in;
+ Geom::D2<Geom::SBasis> sbasis_out;
+ Geom::D2<Geom::SBasis> 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<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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<Geom::SBasis> SBasisStart = start->first_segment()->toSBasis();
- SPCurve *lineHelper = new SPCurve();
+ Geom::D2<Geom::SBasis> sbasis_start = start->first_segment()->toSBasis();
+ SPCurve *line_helper = new SPCurve();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*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<Geom::SBasis> SBasisEnd = end->first_segment()->toSBasis();
+ Geom::D2<Geom::SBasis> sbasis_end = end->first_segment()->toSBasis();
cubic = dynamic_cast<Geom::CubicBezier const *>(&*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<Geom::CubicBezier const *>(&*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]);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-19 22:12:47 +0000