← Back to branch summary

~inkscape.dev/inkscape/transform_by_two_points

« back to all changes in this revision

Viewing changes to src/live_effects/lpe-transform_2pts.cpp

  • Committer: Jabiertxof
  • Date: 2015-04-10 22:54:25 UTC
  • Revision ID: jtx@jtx.marker.es-20150410225425-7f9dmx3nuuroeglk
Fix coding style issues in transform by two points LPE

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/live_effects/lpe-transform_2pts.cpp
26
26
 
27
27
LPETransform2Pts::LPETransform2Pts(LivePathEffectObject *lpeobject) :
28
28
    Effect(lpeobject),
29
 
    fromOriginalWidth(_("From original width"), _("From original width"), "fromOriginalWidth", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
 
29
    from_original_width(_("From original width"), _("From original width"), "from_original_width", &wr, this, false,"", INKSCAPE_ICON("on"), INKSCAPE_ICON("off")),
30
30
    start(_("Start"), _("Start point"), "start", &wr, this, "Start point"),
31
31
    end(_("End"), _("End point"), "end", &wr, this, "End point"),
32
 
    firstKnot(_("First Knot"), _("First Knot"), "firstKnot", &wr, this, 1),
33
 
    lastKnot(_("Last Knot"), _("Last Knot"), "lastKnot", &wr, this, 1),
34
 
    fromOriginalWidthToogler(false),
35
 
    A(Geom::Point(0,0)),
36
 
    B(Geom::Point(0,0)),
37
 
    c(NULL),
38
 
    appandedPath(false)
 
32
    first_knot(_("First Knot"), _("First Knot"), "first_knot", &wr, this, 1),
 
33
    last_knot(_("Last Knot"), _("Last Knot"), "last_knot", &wr, this, 1),
 
34
    from_original_width_toogler(false),
 
35
    point_a(Geom::Point(0,0)),
 
36
    point_b(Geom::Point(0,0)),
 
37
    curve_c(NULL),
 
38
    append_path(false)
39
39
{
40
40
    registerParameter(&start);
41
41
    registerParameter(&end);
42
 
    registerParameter(&firstKnot);
43
 
    registerParameter(&lastKnot);
44
 
    registerParameter(&fromOriginalWidth);
45
 
    
46
 
    firstKnot.param_make_integer(true);
47
 
    lastKnot.param_make_integer(true);
 
42
    registerParameter(&first_knot);
 
43
    registerParameter(&last_knot);
 
44
    registerParameter(&from_original_width);
 
45
 
 
46
    first_knot.param_make_integer(true);
 
47
    last_knot.param_make_integer(true);
48
48
}
49
49
 
50
50
LPETransform2Pts::~LPETransform2Pts()
57
57
    using namespace Geom;
58
58
    original_bbox(lpeitem);
59
59
 
60
 
    A = Point(boundingbox_X.min(), boundingbox_Y.middle());
61
 
    B = Point(boundingbox_X.max(), boundingbox_Y.middle());
 
60
    point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
 
61
    point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
62
62
    SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
63
63
    SPPath *path = dynamic_cast<SPPath *>(splpeitem);
64
64
    if (path) {
65
 
        c = path->get_original_curve();
66
 
    }
67
 
    if(c && !c->is_closed() && c->first_path() == c->last_path()){
68
 
        A = *(c->first_point());
69
 
        B = *(c->last_point());
70
 
        int nnodes = (int)c->nodes_in_path();
71
 
        lastKnot.param_set_value(nnodes);
72
 
    }
73
 
    start.param_update_default(A);
 
65
        curve_c = path->get_original_curve();
 
66
    }
 
67
    if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) {
 
68
        point_a = *(curve_c->first_point());
 
69
        point_b = *(curve_c->last_point());
 
70
        int nnodes = (int)curve_c->nodes_in_path();
 
71
        last_knot.param_set_value(nnodes);
 
72
    }
 
73
    start.param_update_default(point_a);
74
74
    start.param_set_default();
75
 
    end.param_update_default(B);
 
75
    end.param_update_default(point_b);
76
76
    end.param_set_default();
77
77
}
78
78
 
81
81
{
82
82
    using namespace Geom;
83
83
    original_bbox(lpeitem);
84
 
    A = Point(boundingbox_X.min(), boundingbox_Y.middle());
85
 
    B = Point(boundingbox_X.max(), boundingbox_Y.middle());
 
84
    point_a = Point(boundingbox_X.min(), boundingbox_Y.middle());
 
85
    point_b = Point(boundingbox_X.max(), boundingbox_Y.middle());
86
86
 
87
87
    SPLPEItem * splpeitem = const_cast<SPLPEItem *>(lpeitem);
88
88
    SPPath *path = dynamic_cast<SPPath *>(splpeitem);
89
89
    if (path) {
90
 
        c = path->get_original_curve();
 
90
        curve_c = path->get_original_curve();
91
91
    }
92
 
    if(fromOriginalWidthToogler != fromOriginalWidth){
93
 
        fromOriginalWidthToogler = fromOriginalWidth;
 
92
    if(from_original_width_toogler != from_original_width) {
 
93
        from_original_width_toogler = from_original_width;
94
94
        reset();
95
95
    }
96
 
    if(c && !fromOriginalWidth){
97
 
        if(!c->is_closed() && c->first_path() == c->last_path()){
98
 
            appandedPath = false;
99
 
            Geom::PathVector const originalPV = c->get_pathvector();
100
 
            A = originalPV[0][0].initialPoint();
101
 
            if((int)firstKnot > 1){
102
 
                A = originalPV[0][(int)firstKnot-2].finalPoint();
103
 
            }
104
 
            B = originalPV[0][0].initialPoint();
105
 
            if((int)lastKnot > 1){
106
 
                B = originalPV[0][(int)lastKnot-2].finalPoint();
107
 
            }
108
 
            int nnodes = (int)c->nodes_in_path();
109
 
            firstKnot.param_set_range(1, lastKnot-1);
110
 
            lastKnot.param_set_range(firstKnot+1, nnodes);
111
 
            fromOriginalWidth.param_setValue(false);
 
96
    if(curve_c && !from_original_width) {
 
97
        if(!curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) {
 
98
            append_path = false;
 
99
            Geom::PathVector const originalPV = curve_c->get_pathvector();
 
100
            point_a = originalPV[0][0].initialPoint();
 
101
            if((int)first_knot > 1) {
 
102
                point_a = originalPV[0][(int)first_knot-2].finalPoint();
 
103
            }
 
104
            point_b = originalPV[0][0].initialPoint();
 
105
            if((int)last_knot > 1) {
 
106
                point_b = originalPV[0][(int)last_knot-2].finalPoint();
 
107
            }
 
108
            int nnodes = (int)curve_c->nodes_in_path();
 
109
            first_knot.param_set_range(1, last_knot-1);
 
110
            last_knot.param_set_range(first_knot+1, nnodes);
 
111
            from_original_width.param_setValue(false);
112
112
        } else {
113
 
            firstKnot.param_set_value(1);
114
 
            lastKnot.param_set_value(2);
115
 
            firstKnot.param_set_range(1,1);
116
 
            lastKnot.param_set_range(2,2);
117
 
            if(appandedPath == false){
118
 
                appandedPath = true;
 
113
            first_knot.param_set_value(1);
 
114
            last_knot.param_set_value(2);
 
115
            first_knot.param_set_range(1,1);
 
116
            last_knot.param_set_range(2,2);
 
117
            if(append_path == false) {
 
118
                append_path = true;
119
119
            } else {
120
 
                fromOriginalWidth.param_setValue(true);
 
120
                from_original_width.param_setValue(true);
121
121
            }
122
122
        }
123
123
    } else {
124
 
        firstKnot.param_set_value(1);
125
 
        lastKnot.param_set_value(2);
126
 
        firstKnot.param_set_range(1,1);
127
 
        lastKnot.param_set_range(2,2);
128
 
        fromOriginalWidth.param_setValue(true);
129
 
        appandedPath = false;
 
124
        first_knot.param_set_value(1);
 
125
        last_knot.param_set_value(2);
 
126
        first_knot.param_set_range(1,1);
 
127
        last_knot.param_set_range(2,2);
 
128
        from_original_width.param_setValue(true);
 
129
        append_path = false;
130
130
    }
131
131
    splpeitem->apply_to_clippath(splpeitem);
132
132
    splpeitem->apply_to_mask(splpeitem);
135
135
void
136
136
LPETransform2Pts::updateIndex()
137
137
{
138
 
    SPCurve * c2 = NULL;
 
138
    SPCurve * curve2 = NULL;
139
139
    SPShape *shape = SP_SHAPE(sp_lpe_item);
140
140
    if (shape) {
141
 
        c2 = shape->getCurve();
 
141
        curve2 = shape->getCurve();
142
142
    }
143
 
    if(c2 && !fromOriginalWidth && !c->is_closed() && c->first_path() == c->last_path()){
144
 
        Geom::PathVector const originalPV = c2->get_pathvector();
145
 
        Geom::Point C = originalPV[0][0].initialPoint();
146
 
        Geom::Point D = originalPV[0][0].initialPoint();
147
 
        if((int)firstKnot > 1){
148
 
            C = originalPV[0][(int)firstKnot-2].finalPoint();
149
 
        }
150
 
        if((int)lastKnot > 1){
151
 
            D = originalPV[0][(int)lastKnot-2].finalPoint();
152
 
        }
153
 
        start.param_update_default(C);
 
143
    if(curve2 && !from_original_width && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path()) {
 
144
        Geom::PathVector const originalPV = curve2->get_pathvector();
 
145
        Geom::Point point_c = originalPV[0][0].initialPoint();
 
146
        Geom::Point point_d = originalPV[0][0].initialPoint();
 
147
        if((int)first_knot > 1) {
 
148
            point_c = originalPV[0][(int)first_knot-2].finalPoint();
 
149
        }
 
150
        if((int)last_knot > 1) {
 
151
            point_d = originalPV[0][(int)last_knot-2].finalPoint();
 
152
        }
 
153
        start.param_update_default(point_c);
154
154
        start.param_set_default();
155
 
        end.param_update_default(D);
 
155
        end.param_update_default(point_d);
156
156
        end.param_set_default();
157
 
        start.param_update_default(A);
158
 
        end.param_update_default(B);
 
157
        start.param_update_default(point_a);
 
158
        end.param_update_default(point_b);
159
159
        start.param_set_default();
160
160
        end.param_set_default();
161
161
    }
164
164
void
165
165
LPETransform2Pts::reset()
166
166
{
167
 
    A = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle());
168
 
    B = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle());
169
 
    if(c && !c->is_closed() && c->first_path() == c->last_path() && !fromOriginalWidth){
170
 
        int nnodes = (int)c->nodes_in_path();
171
 
        firstKnot.param_set_range(1, lastKnot-1);
172
 
        lastKnot.param_set_range(firstKnot+1, nnodes);
173
 
        firstKnot.param_set_value(1);
174
 
        lastKnot.param_set_value(nnodes);
175
 
        A = *(c->first_point());
176
 
        B = *(c->last_point());
 
167
    point_a = Geom::Point(boundingbox_X.min(), boundingbox_Y.middle());
 
168
    point_b = Geom::Point(boundingbox_X.max(), boundingbox_Y.middle());
 
169
    if(curve_c && !curve_c->is_closed() && curve_c->first_path() == curve_c->last_path() && !from_original_width) {
 
170
        int nnodes = (int)curve_c->nodes_in_path();
 
171
        first_knot.param_set_range(1, last_knot-1);
 
172
        last_knot.param_set_range(first_knot+1, nnodes);
 
173
        first_knot.param_set_value(1);
 
174
        last_knot.param_set_value(nnodes);
 
175
        point_a = *(curve_c->first_point());
 
176
        point_b = *(curve_c->last_point());
177
177
    } else {
178
 
        firstKnot.param_set_value(1);
179
 
        lastKnot.param_set_value(2);
 
178
        first_knot.param_set_value(1);
 
179
        last_knot.param_set_value(2);
180
180
    }
181
 
    start.param_update_default(A);
182
 
    end.param_update_default(B);
 
181
    start.param_update_default(point_a);
 
182
    end.param_update_default(point_b);
183
183
    start.param_set_default();
184
184
    end.param_set_default();
185
185
}
201
201
            Parameter *param = *it;
202
202
            Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(param->param_newWidget());
203
203
            Glib::ustring *tip = param->param_getTooltip();
204
 
            if (param->param_key == "firstKnot" || param->param_key == "lastKnot") {
205
 
                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
206
 
                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPETransform2Pts::updateIndex));
207
 
                widg = widgRegistered;
 
204
            if (param->param_key == "first_knot" || param->param_key == "last_knot") {
 
205
                Inkscape::UI::Widget::Scalar *registered_widget = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
 
206
                registered_widget->signal_value_changed().connect(sigc::mem_fun(*this, &LPETransform2Pts::updateIndex));
 
207
                widg = registered_widget;
208
208
                if (widg) {
209
 
                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
210
 
                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
211
 
                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
212
 
                    entryWidg->set_width_chars(3);
 
209
                    Gtk::HBox *hbox_scalar = dynamic_cast<Gtk::HBox *>(widg);
 
210
                    std::vector<Gtk::Widget *> child_list = hbox_scalar->get_children();
 
211
                    Gtk::Entry *entry_widget = dynamic_cast<Gtk::Entry *>(child_list[1]);
 
212
                    entry_widget->set_width_chars(3);
213
213
                    vbox->pack_start(*widg, true, true, 2);
214
214
                    if (tip) {
215
215
                        widg->set_tooltip_text(*tip);
218
218
                        widg->set_has_tooltip(false);
219
219
                    }
220
220
                }
221
 
            } else if (param->param_key == "fromOriginalWidth"){
 
221
            } else if (param->param_key == "from_original_width") {
222
222
                Glib::ustring * tip = param->param_getTooltip();
223
223
                if (widg) {
224
224
                    button->pack_start(*widg, true, true, 2);
253
253
LPETransform2Pts::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
254
254
{
255
255
    Geom::Piecewise<Geom::D2<Geom::SBasis> > output;
256
 
    double sca = Geom::distance((Geom::Point)start,(Geom::Point)end)/Geom::distance(A,B);
257
 
    Geom::Ray original(A,B);
 
256
    double sca = Geom::distance((Geom::Point)start,(Geom::Point)end)/Geom::distance(point_a,point_b);
 
257
    Geom::Ray original(point_a,point_b);
258
258
    Geom::Ray transformed((Geom::Point)start,(Geom::Point)end);
259
259
    double rot = transformed.angle() - original.angle();
260
260
    Geom::Path helper;
261
 
    helper.start(A);
262
 
    helper.appendNew<Geom::LineSegment>(B);
 
261
    helper.start(point_a);
 
262
    helper.appendNew<Geom::LineSegment>(point_b);
263
263
    Geom::Affine m;
264
264
    m *= Geom::Scale(sca);
265
265
    m *= Geom::Rotate(rot);