1
=== modified file 'po/POTFILES.in'
2
--- po/POTFILES.in	2016-12-27 15:49:22 +0000
3
+++ po/POTFILES.in	2017-05-06 17:46:29 +0000
4
@@ -153,7 +153,7 @@
5
153
src/live_effects/lpe-vonkoch.cpp
153
src/live_effects/lpe-vonkoch.cpp
6
154
src/live_effects/parameter/bool.cpp
154
src/live_effects/parameter/bool.cpp
7
155
src/live_effects/parameter/enum.h
155
src/live_effects/parameter/enum.h
9
156
src/live_effects/parameter/filletchamferpointarray.cpp
156
src/live_effects/parameter/satellitearray.cpp
10
157
src/live_effects/parameter/fontbutton.cpp
157
src/live_effects/parameter/fontbutton.cpp
11
158
src/live_effects/parameter/originalpath.cpp
158
src/live_effects/parameter/originalpath.cpp
12
159
src/live_effects/parameter/originalpatharray.cpp
159
src/live_effects/parameter/originalpatharray.cpp
13
160
160
14
=== modified file 'src/helper/CMakeLists.txt'
15
--- src/helper/CMakeLists.txt	2015-03-19 01:41:26 +0000
16
+++ src/helper/CMakeLists.txt	2017-05-06 17:46:29 +0000
17
@@ -14,6 +14,8 @@
18
14
	geom.cpp
14
	geom.cpp
19
15
	geom-nodetype.cpp
15
	geom-nodetype.cpp
20
16
	geom-pathstroke.cpp
16
	geom-pathstroke.cpp
21
17
	geom-pathvectorsatellites.cpp
22
18
	geom-satellite.cpp
23
17
	gnome-utils.cpp
19
	gnome-utils.cpp
24
18
	pixbuf-ops.cpp
20
	pixbuf-ops.cpp
25
19
	png-write.cpp
21
	png-write.cpp
26
@@ -32,6 +34,8 @@
27
32
	geom-curves.h
34
	geom-curves.h
28
33
	geom-nodetype.h
35
	geom-nodetype.h
29
34
	geom-pathstroke.h
36
	geom-pathstroke.h
30
37
	geom-pathvectorsatellites.h
31
38
	geom-satellite.h
32
35
	geom.h
39
	geom.h
33
36
	gnome-utils.h
40
	gnome-utils.h
34
37
	mathfns.h
41
	mathfns.h
35
38
42
36
=== added file 'src/helper/geom-pathvectorsatellites.cpp'
37
--- src/helper/geom-pathvectorsatellites.cpp	1970-01-01 00:00:00 +0000
38
+++ src/helper/geom-pathvectorsatellites.cpp	2017-05-06 17:46:29 +0000
39
@@ -0,0 +1,244 @@
40
1
/**
41
2
 * \file
42
3
 * \brief PathVectorSatellites a class to manage satellites -per node extra data- in a pathvector
43
4
 */ /*
44
5
    * Authors:
45
6
    * Jabiertxof
46
7
    * Nathan Hurst
47
8
    * Johan Engelen
48
9
    * Josh Andler
49
10
    * suv
50
11
    * Mc-
51
12
    * Liam P. White
52
13
    * Krzysztof Kosiński
53
14
    * This code is in public domain
54
15
    */
55
16
56
17
#include <helper/geom-pathvectorsatellites.h>
57
18
#include "util/units.h"
58
19
59
20
Geom::PathVector PathVectorSatellites::getPathVector() const
60
21
{
61
22
    return _pathvector;
62
23
}
63
24
64
25
void PathVectorSatellites::setPathVector(Geom::PathVector pathv)
65
26
{
66
27
    _pathvector = pathv;
67
28
}
68
29
69
30
Satellites PathVectorSatellites::getSatellites()
70
31
{
71
32
    return _satellites;
72
33
}
73
34
74
35
void PathVectorSatellites::setSatellites(Satellites satellites)
75
36
{
76
37
    _satellites = satellites;
77
38
}
78
39
79
40
size_t PathVectorSatellites::getTotalSatellites()
80
41
{
81
42
    size_t counter = 0;
82
43
    for (size_t i = 0; i < _satellites.size(); ++i) {
83
44
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
84
45
            counter++;
85
46
        }
86
47
    }
87
48
    return counter;
88
49
}
89
50
90
51
std::pair<size_t, size_t> PathVectorSatellites::getIndexData(size_t index)
91
52
{
92
53
    size_t counter = 0;
93
54
    for (size_t i = 0; i < _satellites.size(); ++i) {
94
55
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
95
56
            if (index == counter) {
96
57
                return std::make_pair(i,j);
97
58
            }
98
59
            counter++;
99
60
        }
100
61
    }
101
62
    return std::make_pair(0,0);
102
63
}
103
64
104
65
void PathVectorSatellites::setSelected(std::vector<size_t> selected)
105
66
{
106
67
    size_t counter = 0;
107
68
    for (size_t i = 0; i < _satellites.size(); ++i) {
108
69
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
109
70
            if (find (selected.begin(), selected.end(), counter) != selected.end()) {
110
71
                _satellites[i][j].setSelected(true);
111
72
            } else {
112
73
                _satellites[i][j].setSelected(false);
113
74
            }
114
75
            counter++;
115
76
        }
116
77
    }
117
78
}
118
79
119
80
void PathVectorSatellites::updateSteps(size_t steps, bool apply_no_radius, bool apply_with_radius, bool only_selected)
120
81
{
121
82
    for (size_t i = 0; i < _satellites.size(); ++i) {
122
83
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
123
84
            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
124
85
                (!apply_with_radius && _satellites[i][j].amount != 0)) 
125
86
            {
126
87
                continue;
127
88
            }
128
89
            if (only_selected) {
129
90
                if (_satellites[i][j].selected) {
130
91
                    _satellites[i][j].steps = steps;
131
92
                }
132
93
            } else {
133
94
                _satellites[i][j].steps = steps;
134
95
            }
135
96
        }
136
97
    }
137
98
}
138
99
139
100
void PathVectorSatellites::updateAmount(double radius, bool apply_no_radius, bool apply_with_radius, bool only_selected, 
140
101
                                         bool use_knot_distance, bool flexible)
141
102
{
142
103
    double power = 0;
143
104
    if (!flexible) {
144
105
        power = radius;
145
106
    } else {
146
107
        power = radius / 100;
147
108
    }
148
109
    for (size_t i = 0; i < _satellites.size(); ++i) {
149
110
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
150
111
            boost::optional<size_t> previous_index = boost::none;
151
112
            if (j == 0 && _pathvector[i].closed()) {
152
113
                previous_index = _pathvector[i].size() - 1;
153
114
            } else if (!_pathvector[i].closed() || j != 0) {
154
115
                previous_index = j - 1;
155
116
            }
156
117
            if (!_pathvector[i].closed() && j == 0) {
157
118
                _satellites[i][j].amount = 0;
158
119
                continue;
159
120
            }
160
121
            if (_pathvector[i].size() == j) {
161
122
                continue;
162
123
            }
163
124
            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
164
125
                (!apply_with_radius && _satellites[i][j].amount != 0)) 
165
126
            {
166
127
                continue;
167
128
            }
168
129
            
169
130
            Geom::Point satellite_point = _pathvector[i].pointAt(j);
170
131
            if (_satellites[i][j].selected || !only_selected) {
171
132
                if (!use_knot_distance && !flexible) {
172
133
                    if (previous_index) {
173
134
                        _satellites[i][j].amount = _satellites[i][j].radToLen(power, _pathvector[i][*previous_index], _pathvector[i][j]);
174
135
                        if (power && !_satellites[i][j].amount) {
175
136
                            g_warning("Seems a too high radius value");
176
137
                        }
177
138
                    } else {
178
139
                        _satellites[i][j].amount = 0.0;
179
140
                    }
180
141
                } else {
181
142
                    _satellites[i][j].amount = power;
182
143
                }
183
144
            }
184
145
        }
185
146
    }
186
147
}
187
148
188
149
void PathVectorSatellites::convertUnit(Glib::ustring in, Glib::ustring to, bool apply_no_radius, bool apply_with_radius)
189
150
{
190
151
    for (size_t i = 0; i < _satellites.size(); ++i) {
191
152
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
192
153
            if (!_pathvector[i].closed() && j == 0) {
193
154
                _satellites[i][j].amount = 0;
194
155
                continue;
195
156
            }
196
157
            if (_pathvector[i].size() == j) {
197
158
                continue;
198
159
            }
199
160
            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
200
161
                (!apply_with_radius && _satellites[i][j].amount != 0)) 
201
162
            {
202
163
                continue;
203
164
            }
204
165
            _satellites[i][j].amount = Inkscape::Util::Quantity::convert(_satellites[i][j].amount, in.c_str(), to.c_str());
205
166
        }
206
167
    }
207
168
}
208
169
209
170
void PathVectorSatellites::updateSatelliteType(SatelliteType satellitetype, bool apply_no_radius, bool apply_with_radius,
210
171
                                               bool only_selected)
211
172
{
212
173
    for (size_t i = 0; i < _satellites.size(); ++i) {
213
174
        for (size_t j = 0; j < _satellites[i].size(); ++j) {
214
175
            if ((!apply_no_radius && _satellites[i][j].amount == 0) ||
215
176
                (!apply_with_radius && _satellites[i][j].amount != 0)) 
216
177
            {
217
178
                continue;
218
179
            }
219
180
            if (_pathvector[i].size() == j) {
220
181
                if (!only_selected) {
221
182
                    _satellites[i][j].satellite_type = satellitetype;
222
183
                }
223
184
                continue;
224
185
            }
225
186
            if (only_selected) {
226
187
                Geom::Point satellite_point = _pathvector[i].pointAt(j);
227
188
                if (_satellites[i][j].selected) {
228
189
                    _satellites[i][j].satellite_type = satellitetype;
229
190
                }
230
191
            } else {
231
192
                _satellites[i][j].satellite_type = satellitetype;
232
193
            }
233
194
        }
234
195
    }
235
196
}
236
197
237
198
void PathVectorSatellites::recalculateForNewPathVector(Geom::PathVector const pathv, Satellite const S)
238
199
{
239
200
    Satellites satellites;
240
201
    bool found = false;
241
202
    //TODO evaluate fix on nodes at same position
242
203
    size_t number_nodes = pathv.nodes().size();
243
204
    size_t previous_number_nodes = _pathvector.nodes().size();
244
205
    for (size_t i = 0; i < pathv.size(); i++) {
245
206
        std::vector<Satellite> path_satellites;
246
207
        for (size_t j = 0; j < pathv[i].size_closed(); j++) {
247
208
            found = false;
248
209
            for (size_t k = 0; k < _pathvector.size(); k++) {
249
210
                for (size_t l = 0; l < _pathvector[k].size_closed(); l++) {
250
211
                    if (Geom::are_near(_pathvector[k][l].initialPoint(),  pathv[i][j].initialPoint()))
251
212
                    {
252
213
                        path_satellites.push_back(_satellites[k][l]);
253
214
                        found = true;
254
215
                        break;
255
216
                    }
256
217
                }
257
218
                if (found) {
258
219
                    break;
259
220
                }
260
221
            }
261
222
            
262
223
            if (!found && previous_number_nodes < number_nodes) {
263
224
                path_satellites.push_back(S);
264
225
            }
265
226
        }
266
227
        satellites.push_back(path_satellites);
267
228
    }
268
229
    setPathVector(pathv);
269
230
    setSatellites(satellites);
270
231
}
271
232
272
233
/*
273
234
  Local Variables:
274
235
  mode:c++
275
236
  c-file-style:"stroustrup"
276
237
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
277
238
  indent-tabs-mode:nil
278
239
  fill-column:99
279
240
  End:
280
241
*/
281
242
// vim:
282
243
// filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99
283
244
// :
284
0
245
285
=== added file 'src/helper/geom-pathvectorsatellites.h'
286
--- src/helper/geom-pathvectorsatellites.h	1970-01-01 00:00:00 +0000
287
+++ src/helper/geom-pathvectorsatellites.h	2017-05-06 17:46:29 +0000
288
@@ -0,0 +1,58 @@
289
1
/**
290
2
 * \file
291
3
 * \brief PathVectorSatellites a class to manage satellites -per node extra data- in a pathvector
292
4
 */ /*
293
5
    * Authors:
294
6
    * Jabiertxof
295
7
    * Nathan Hurst
296
8
    * Johan Engelen
297
9
    * Josh Andler
298
10
    * suv
299
11
    * Mc-
300
12
    * Liam P. White
301
13
    * Krzysztof Kosiński
302
14
    * This code is in public domain
303
15
    */
304
16
305
17
#ifndef SEEN_PATHVECTORSATELLITES_H
306
18
#define SEEN_PATHVECTORSATELLITES_H
307
19
308
20
#include <helper/geom-satellite.h>
309
21
#include <2geom/path.h>
310
22
#include <2geom/pathvector.h>
311
23
312
24
typedef std::vector<std::vector<Satellite> > Satellites;
313
25
///@brief PathVectorSatellites a class to manage satellites in a pathvector
314
26
class PathVectorSatellites {
315
27
public:
316
28
    Geom::PathVector getPathVector() const;
317
29
    void setPathVector(Geom::PathVector pathv);
318
30
    Satellites getSatellites();
319
31
    void setSatellites(Satellites satellites);
320
32
    size_t getTotalSatellites();
321
33
    void setSelected(std::vector<size_t> selected);
322
34
    void updateSteps(size_t steps, bool apply_no_radius, bool apply_with_radius, bool only_selected);
323
35
    void updateAmount(double radius, bool apply_no_radius, bool apply_with_radius, bool only_selected, 
324
36
                      bool use_knot_distance, bool flexible);
325
37
    void convertUnit(Glib::ustring in, Glib::ustring to, bool apply_no_radius, bool apply_with_radius);
326
38
    void updateSatelliteType(SatelliteType satellitetype, bool apply_no_radius, bool apply_with_radius, bool only_selected);
327
39
    std::pair<size_t, size_t> getIndexData(size_t index);
328
40
    void recalculateForNewPathVector(Geom::PathVector const pathv, Satellite const S);
329
41
private:
330
42
    Geom::PathVector _pathvector;
331
43
    Satellites _satellites;
332
44
};
333
45
334
46
#endif //SEEN_PATHVECTORSATELLITES_H
335
47
/*
336
48
  Local Variables:
337
49
  mode:c++
338
50
  c-file-style:"stroustrup"
339
51
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
340
52
  indent-tabs-mode:nil
341
53
  fill-column:99
342
54
  End:
343
55
*/
344
56
// vim:
345
57
// filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99
346
58
// :
347
0
59
348
=== added file 'src/helper/geom-satellite.cpp'
349
--- src/helper/geom-satellite.cpp	1970-01-01 00:00:00 +0000
350
+++ src/helper/geom-satellite.cpp	2017-05-06 17:46:29 +0000
351
@@ -0,0 +1,245 @@
352
1
/**
353
2
 * \file
354
3
 * \brief Satellite a per node holder of data.
355
4
 */ /*
356
5
    * Authors:
357
6
    * 2015 Jabier Arraiza Cenoz<jabier.arraiza@marker.es>
358
7
    *
359
8
    * This code is in public domain
360
9
    */
361
10
362
11
#include <helper/geom-satellite.h>
363
12
#include <2geom/curve.h>
364
13
#include <2geom/nearest-time.h>
365
14
#include <2geom/path-intersection.h>
366
15
#include <2geom/sbasis-to-bezier.h>
367
16
#include <2geom/ray.h>
368
17
#include <boost/optional.hpp>
369
18
//log cache
370
19
#ifdef _WIN32
371
20
#include <Windows.h>
372
21
#else
373
22
#include <sys/time.h>
374
23
#include <ctime>
375
24
#endif
376
25
377
26
///@brief Satellite a per node holder of data.
378
27
Satellite::Satellite() {}
379
28
380
29
381
30
Satellite::Satellite(SatelliteType satellite_type)
382
31
    : satellite_type(satellite_type),
383
32
      is_time(false),
384
33
      selected(false),
385
34
      has_mirror(false),
386
35
      hidden(true),
387
36
      amount(0.0),
388
37
      angle(0.0),
389
38
      steps(0)
390
39
{}
391
40
392
41
Satellite::~Satellite() {}
393
42
394
43
///Calculate the time in curve_in with a size of A
395
44
//TODO: find a better place to it
396
45
double timeAtArcLength(double const A, Geom::Curve const &curve_in)
397
46
{
398
47
    if ( A == 0 || curve_in.isDegenerate()) {
399
48
        return 0;
400
49
    }
401
50
402
51
    Geom::D2<Geom::SBasis> d2_in = curve_in.toSBasis();
403
52
    double t = 0;
404
53
    double length_part = curve_in.length();
405
54
    if (A >= length_part || curve_in.isLineSegment()) {
406
55
        if (length_part != 0) {
407
56
            t = A / length_part;
408
57
        }
409
58
    } else if (!curve_in.isLineSegment()) {
410
59
        std::vector<double> t_roots = roots(Geom::arcLengthSb(d2_in) - A);
411
60
        if (!t_roots.empty()) {
412
61
            t = t_roots[0];
413
62
        }
414
63
    }
415
64
    return t;
416
65
}
417
66
418
67
///Calculate the size in curve_in with a point at A
419
68
//TODO: find a better place to it
420
69
double arcLengthAt(double const A, Geom::Curve const &curve_in)
421
70
{
422
71
    if ( A == 0 || curve_in.isDegenerate()) {
423
72
        return 0;
424
73
    }
425
74
426
75
    double s = 0;
427
76
    double length_part = curve_in.length();
428
77
    if (A > length_part || curve_in.isLineSegment()) {
429
78
        s = (A * length_part);
430
79
    } else if (!curve_in.isLineSegment()) {
431
80
        Geom::Curve *curve = curve_in.portion(0.0, A);
432
81
        s = curve->length();
433
82
        delete curve;
434
83
    }
435
84
    return s;
436
85
}
437
86
438
87
///Convert a arc radius of a fillet/chamfer to his satellite length -point position where fillet/chamfer knot be on original curve
439
88
double Satellite::radToLen(
440
89
    double const A, Geom::Curve const &curve_in,
441
90
    Geom::Curve const &curve_out) const
442
91
{
443
92
    double len = 0;
444
93
    Geom::D2<Geom::SBasis> d2_in = curve_in.toSBasis();
445
94
    Geom::D2<Geom::SBasis> d2_out = curve_out.toSBasis();
446
95
    Geom::Piecewise<Geom::D2<Geom::SBasis> > offset_curve0 = 
447
96
        Geom::Piecewise<Geom::D2<Geom::SBasis> >(d2_in) +
448
97
        rot90(unitVector(derivative(d2_in))) * (A);
449
98
    Geom::Piecewise<Geom::D2<Geom::SBasis> > offset_curve1 =
450
99
        Geom::Piecewise<Geom::D2<Geom::SBasis> >(d2_out) +
451
100
        rot90(unitVector(derivative(d2_out))) * (A);
452
101
    Geom::Path p0 = path_from_piecewise(offset_curve0, 0.1)[0];
453
102
    Geom::Path p1 = path_from_piecewise(offset_curve1, 0.1)[0];
454
103
    Geom::Crossings cs = Geom::crossings(p0, p1);
455
104
    if (cs.size() > 0) {
456
105
        Geom::Point cp = p0(cs[0].ta);
457
106
        double p0pt = nearest_time(cp, curve_out);
458
107
        len = arcLengthAt(p0pt, curve_out);
459
108
    } else {
460
109
        if (A > 0) {
461
110
            len = radToLen(A * -1, curve_in, curve_out);
462
111
        }
463
112
    }
464
113
    return len;
465
114
}
466
115
467
116
///Convert a satelite length -point position where fillet/chamfer knot be on original curve- to a arc radius of fillet/chamfer
468
117
double Satellite::lenToRad(
469
118
    double const A, Geom::Curve const &curve_in,
470
119
    Geom::Curve const &curve_out,
471
120
    Satellite const previousSatellite) const
472
121
{
473
122
    double time_in = (previousSatellite).time(A, true, curve_in);
474
123
    double time_out = timeAtArcLength(A, curve_out);
475
124
    Geom::Point start_arc_point = curve_in.pointAt(time_in);
476
125
    Geom::Point end_arc_point = curve_out.pointAt(time_out);
477
126
    Geom::Curve *knot_curve1 = curve_in.portion(0, time_in);
478
127
    Geom::Curve *knot_curve2 = curve_out.portion(time_out, 1);
479
128
    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve1);
480
129
    Geom::Ray ray1(start_arc_point, curve_in.pointAt(1));
481
130
    if (cubic1) {
482
131
        ray1.setPoints((*cubic1)[2], start_arc_point);
483
132
    }
484
133
    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve2);
485
134
    Geom::Ray ray2(curve_out.pointAt(0), end_arc_point);
486
135
    if (cubic2) {
487
136
        ray2.setPoints(end_arc_point, (*cubic2)[1]);
488
137
    }
489
138
    bool ccw_toggle = cross(curve_in.pointAt(1) - start_arc_point,
490
139
                           end_arc_point - start_arc_point) < 0;
491
140
    double distance_arc =
492
141
        Geom::distance(start_arc_point, middle_point(start_arc_point, end_arc_point));
493
142
    double angle = angle_between(ray1, ray2, ccw_toggle);
494
143
    double divisor = std::sin(angle / 2.0);
495
144
    if (divisor > 0) {
496
145
        return distance_arc / divisor;
497
146
    }
498
147
    return 0;
499
148
}
500
149
501
150
///Get the time position of the satellite in curve_in
502
151
double Satellite::time(Geom::Curve const &curve_in, bool inverse) const
503
152
{
504
153
    double t = amount;
505
154
    if (!is_time) {
506
155
        t = time(t, inverse, curve_in);
507
156
    } else if (inverse) {
508
157
        t = 1-t;
509
158
    }
510
159
    if (t > 1) {
511
160
        t = 1;
512
161
    }
513
162
    return t;
514
163
}
515
164
516
165
///Get the time from a length A in other curve, a bolean inverse gived to reverse time
517
166
double Satellite::time(double A, bool inverse,
518
167
                       Geom::Curve const &curve_in) const
519
168
{
520
169
    if (A == 0 && inverse) {
521
170
        return 1;
522
171
    }
523
172
    if (A == 0 && !inverse) {
524
173
        return 0;
525
174
    }
526
175
    if (!inverse) {
527
176
        return timeAtArcLength(A, curve_in);
528
177
    }
529
178
    double length_part = curve_in.length();
530
179
    A = length_part - A;
531
180
    return timeAtArcLength(A, curve_in);
532
181
}
533
182
534
183
///Get the length of the satellite in curve_in
535
184
double Satellite::arcDistance(Geom::Curve const &curve_in) const
536
185
{
537
186
    double s = amount;
538
187
    if (is_time) {
539
188
        s = arcLengthAt(s, curve_in);
540
189
    }
541
190
    return s;
542
191
}
543
192
544
193
///Get the point position of the satellite
545
194
Geom::Point Satellite::getPosition(Geom::Curve const &curve_in, bool inverse) const
546
195
{
547
196
    double t = time(curve_in, inverse);
548
197
    return curve_in.pointAt(t);
549
198
}
550
199
551
200
///Set the position of the satellite from a gived point P
552
201
void Satellite::setPosition(Geom::Point const p, Geom::Curve const &curve_in, bool inverse)
553
202
{
554
203
    Geom::Curve * curve = const_cast<Geom::Curve *>(&curve_in);
555
204
    if (inverse) {
556
205
        curve = curve->reverse();
557
206
    }
558
207
    double A = Geom::nearest_time(p, *curve);
559
208
    if (!is_time) {
560
209
        A = arcLengthAt(A, *curve);
561
210
    }
562
211
    amount = A;
563
212
}
564
213
565
214
566
215
///Map a satellite type with gchar
567
216
void Satellite::setSatelliteType(gchar const *A)
568
217
{
569
218
    std::map<std::string, SatelliteType> gchar_map_to_satellite_type =
570
219
        boost::assign::map_list_of("F", FILLET)("IF", INVERSE_FILLET)("C", CHAMFER)("IC", INVERSE_CHAMFER)("KO", INVALID_SATELLITE);
571
220
    std::map<std::string, SatelliteType>::iterator it = gchar_map_to_satellite_type.find(std::string(A));
572
221
    if (it != gchar_map_to_satellite_type.end()) {
573
222
        satellite_type = it->second;
574
223
    }
575
224
}
576
225
577
226
///Map a gchar with satelliteType
578
227
gchar const *Satellite::getSatelliteTypeGchar() const
579
228
{
580
229
    std::map<SatelliteType, gchar const *> satellite_type_to_gchar_map =
581
230
        boost::assign::map_list_of(FILLET, "F")(INVERSE_FILLET, "IF")(CHAMFER, "C")(INVERSE_CHAMFER, "IC")(INVALID_SATELLITE, "KO");
582
231
    return satellite_type_to_gchar_map.at(satellite_type);
583
232
}
584
233
585
234
/*
586
235
  Local Variables:
587
236
  mode:c++
588
237
  c-file-style:"stroustrup"
589
238
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
590
239
  indent-tabs-mode:nil
591
240
  fill-column:99
592
241
  End:
593
242
*/
594
243
// vim:
595
244
// filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99
596
245
// :
597
0
246
598
=== added file 'src/helper/geom-satellite.h'
599
--- src/helper/geom-satellite.h	1970-01-01 00:00:00 +0000
600
+++ src/helper/geom-satellite.h	2017-05-06 17:46:29 +0000
601
@@ -0,0 +1,110 @@
602
1
/**
603
2
 * \file
604
3
 * \brief Satellite a per node holder of data.
605
4
 */ /*
606
5
    * Authors:
607
6
    * 2015 Jabier Arraiza Cenoz<jabier.arraiza@marker.es>
608
7
    *
609
8
    * This code is in public domain
610
9
    */
611
10
612
11
#ifndef SEEN_SATELLITE_H
613
12
#define SEEN_SATELLITE_H
614
13
615
14
#include <map>
616
15
#include <boost/assign.hpp>
617
16
#include <2geom/sbasis-geometric.h>
618
17
#include "util/enums.h"
619
18
620
19
621
20
enum SatelliteType {
622
21
    FILLET = 0, //Fillet
623
22
    INVERSE_FILLET,    //Inverse Fillet
624
23
    CHAMFER,     //Chamfer
625
24
    INVERSE_CHAMFER,    //Inverse Chamfer
626
25
    INVALID_SATELLITE     // Invalid Satellite
627
26
};
628
27
/**
629
28
 * @brief Satellite a per node holder of data.
630
29
 */
631
30
632
31
class Satellite {
633
32
public:
634
33
635
34
    Satellite();
636
35
    Satellite(SatelliteType satellite_type);
637
36
638
37
    virtual ~Satellite();
639
38
    void setIsTime(bool set_is_time)
640
39
    {
641
40
        is_time = set_is_time;
642
41
    }
643
42
    void setSelected(bool set_selected)
644
43
    {
645
44
        selected = set_selected;
646
45
    }
647
46
    void setHasMirror(bool set_has_mirror)
648
47
    {
649
48
        has_mirror = set_has_mirror;
650
49
    }
651
50
    void setHidden(bool set_hidden)
652
51
    {
653
52
        hidden = set_hidden;
654
53
    }
655
54
    void setAmount(bool set_amount)
656
55
    {
657
56
        amount = set_amount;
658
57
    }
659
58
    void setAngle(bool set_angle)
660
59
    {
661
60
        angle = set_angle;
662
61
    }
663
62
    void setSteps(bool set_steps)
664
63
    {
665
64
        steps = set_steps;
666
65
    }
667
66
    double lenToRad(double const A, Geom::Curve const &curve_in,
668
67
                    Geom::Curve const &curve_out,
669
68
                    Satellite const previousSatellite) const;
670
69
    double radToLen(double const A, Geom::Curve const &curve_in,
671
70
                    Geom::Curve const &curve_out) const;
672
71
673
72
    double time(Geom::Curve const &curve_in, bool inverse = false) const;
674
73
    double time(double A, bool inverse, Geom::Curve const &curve_in) const;
675
74
    double arcDistance(Geom::Curve const &curve_in) const;
676
75
677
76
    void setPosition(Geom::Point const p, Geom::Curve const &curve_in, bool inverse = false);
678
77
    Geom::Point getPosition(Geom::Curve const &curve_in, bool inverse = false) const;
679
78
680
79
    void setSatelliteType(gchar const *A);
681
80
    gchar const *getSatelliteTypeGchar() const;
682
81
    SatelliteType satellite_type;
683
82
    //The value stored could be a time value of the satellite in the curve or a lenght of distance to the node from the satellite
684
83
    //"is_time" tell is if is a time or lenght value
685
84
    bool is_time;
686
85
    bool selected;
687
86
    bool has_mirror;
688
87
    bool hidden;
689
88
    //in "amount" we store the time or distance used in the satellite
690
89
    double amount;
691
90
    double angle;
692
91
    size_t steps;
693
92
};
694
93
695
94
double timeAtArcLength(double const A, Geom::Curve const &curve_in);
696
95
double arcLengthAt(double const A, Geom::Curve const &curve_in);
697
96
698
97
#endif // SEEN_SATELLITE_H
699
98
700
99
/*
701
100
  Local Variables:
702
101
  mode:c++
703
102
  c-file-style:"stroustrup"
704
103
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
705
104
  indent-tabs-mode:nil
706
105
  fill-column:99
707
106
  End:
708
107
*/
709
108
// vim:
710
109
// filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99
711
110
// :
712
0
111
713
=== modified file 'src/knotholder.h'
714
--- src/knotholder.h	2016-07-30 17:04:34 +0000
715
+++ src/knotholder.h	2017-05-06 17:46:29 +0000
716
@@ -30,7 +30,8 @@
717
30
}
30
}
718
31
namespace LivePathEffect {
31
namespace LivePathEffect {
719
32
class PowerStrokePointArrayParamKnotHolderEntity;
32
class PowerStrokePointArrayParamKnotHolderEntity;
721
33
class FilletPointArrayParamKnotHolderEntity;
33
class SatellitesArrayParam;
722
34
class FilletChamferKnotHolderEntity;
723
34
}
35
}
724
35
}
36
}
725
36
37
726
@@ -63,7 +64,7 @@
727
63
64
728
64
    friend class Inkscape::UI::ShapeEditor; // FIXME why?
65
    friend class Inkscape::UI::ShapeEditor; // FIXME why?
729
65
    friend class Inkscape::LivePathEffect::PowerStrokePointArrayParamKnotHolderEntity; // why?
66
    friend class Inkscape::LivePathEffect::PowerStrokePointArrayParamKnotHolderEntity; // why?
731
66
    friend class Inkscape::LivePathEffect::FilletPointArrayParamKnotHolderEntity; // why?
67
    friend class Inkscape::LivePathEffect::FilletChamferKnotHolderEntity; // why?
732
67
68
733
68
protected:
69
protected:
734
69
70
735
70
71
736
=== modified file 'src/live_effects/CMakeLists.txt'
737
--- src/live_effects/CMakeLists.txt	2017-01-24 09:44:10 +0000
738
+++ src/live_effects/CMakeLists.txt	2017-05-06 17:46:29 +0000
739
@@ -59,7 +59,6 @@
740
59
59
741
60
	parameter/array.cpp
60
	parameter/array.cpp
742
61
	parameter/bool.cpp
61
	parameter/bool.cpp
743
62
	parameter/filletchamferpointarray.cpp
744
63
	parameter/item-reference.cpp
62
	parameter/item-reference.cpp
745
64
	parameter/item.cpp
63
	parameter/item.cpp
746
65
	parameter/originalitem.cpp
64
	parameter/originalitem.cpp
747
@@ -70,6 +69,7 @@
748
70
	parameter/path.cpp
69
	parameter/path.cpp
749
71
	parameter/point.cpp
70
	parameter/point.cpp
750
72
	parameter/powerstrokepointarray.cpp
71
	parameter/powerstrokepointarray.cpp
751
72
	parameter/satellitesarray.cpp
752
73
	parameter/random.cpp
73
	parameter/random.cpp
753
74
	parameter/text.cpp
74
	parameter/text.cpp
754
75
	parameter/fontbutton.cpp
75
	parameter/fontbutton.cpp
755
@@ -144,7 +144,6 @@
756
144
	parameter/array.h
144
	parameter/array.h
757
145
	parameter/bool.h
145
	parameter/bool.h
758
146
	parameter/enum.h
146
	parameter/enum.h
759
147
	parameter/filletchamferpointarray.h
760
148
	parameter/item.h
147
	parameter/item.h
761
149
	parameter/item-reference.h
148
	parameter/item-reference.h
762
150
	parameter/originalitem.h
149
	parameter/originalitem.h
763
@@ -155,6 +154,7 @@
764
155
	parameter/path.h
154
	parameter/path.h
765
156
	parameter/point.h
155
	parameter/point.h
766
157
	parameter/powerstrokepointarray.h
156
	parameter/powerstrokepointarray.h
767
157
	parameter/satellitesarray.h
768
158
	parameter/random.h
158
	parameter/random.h
769
159
	parameter/text.h
159
	parameter/text.h
770
160
	parameter/fontbutton.h
160
	parameter/fontbutton.h
771
161
161
772
=== modified file 'src/live_effects/effect.cpp'
773
--- src/live_effects/effect.cpp	2017-05-05 14:45:16 +0000
774
+++ src/live_effects/effect.cpp	2017-05-06 17:46:29 +0000
775
@@ -101,7 +101,6 @@
776
101
    {RECURSIVE_SKELETON,    N_("Recursive skeleton"),              "recursive_skeleton"},
101
    {RECURSIVE_SKELETON,    N_("Recursive skeleton"),              "recursive_skeleton"},
777
102
    {TANGENT_TO_CURVE,      N_("Tangent to curve"),                "tangent_to_curve"},
102
    {TANGENT_TO_CURVE,      N_("Tangent to curve"),                "tangent_to_curve"},
778
103
    {TEXT_LABEL,            N_("Text label"),                      "text_label"},
103
    {TEXT_LABEL,            N_("Text label"),                      "text_label"},
779
104
    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
780
105
#endif
104
#endif
781
106
/* 0.46 */
105
/* 0.46 */
782
107
    {BEND_PATH,             N_("Bend"),                            "bend_path"},
106
    {BEND_PATH,             N_("Bend"),                            "bend_path"},
783
@@ -142,6 +141,7 @@
784
142
    {BOUNDING_BOX,          N_("Bounding Box"),                    "bounding_box"},
141
    {BOUNDING_BOX,          N_("Bounding Box"),                    "bounding_box"},
785
143
/* 9.93 */
142
/* 9.93 */
786
144
    {MEASURE_LINE,          N_("Measure Line"),                    "measure_line"},
143
    {MEASURE_LINE,          N_("Measure Line"),                    "measure_line"},
787
144
    {FILLET_CHAMFER,        N_("Fillet/Chamfer"),                  "fillet_chamfer"},
788
145
};
145
};
789
146
const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
146
const Util::EnumDataConverter<EffectType> LPETypeConverter(LPETypeData, sizeof(LPETypeData)/sizeof(*LPETypeData));
790
147
147
791
148
148
792
=== modified file 'src/live_effects/lpe-fillet-chamfer.cpp'
793
--- src/live_effects/lpe-fillet-chamfer.cpp	2017-04-28 19:42:36 +0000
794
+++ src/live_effects/lpe-fillet-chamfer.cpp	2017-05-06 17:46:29 +0000
795
@@ -4,86 +4,131 @@
796
4
 *
4
 *
797
5
 * Copyright (C) 2014 Author(s)
5
 * Copyright (C) 2014 Author(s)
798
6
 *
6
 *
799
7
 * Special thanks to Johan Engelen for the base of the effect -powerstroke-
800
8
 * Also to ScislaC for point me to the idea
801
9
 * Also su_v for his construvtive feedback and time
802
10
 * Also to Mc- (IRC nick) for his important contribution to find real time
803
11
 * values based on
804
12
 * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
805
13
 *
7
 *
806
14
 * Released under GNU GPL, read the file 'COPYING' for more information
8
 * Released under GNU GPL, read the file 'COPYING' for more information
807
15
 */
9
 */
808
10
809
16
#include "live_effects/lpe-fillet-chamfer.h"
11
#include "live_effects/lpe-fillet-chamfer.h"
814
17
 
12
#include "helper/geom.h"
811
18
#include <2geom/sbasis-to-bezier.h>
812
19
#include <2geom/elliptical-arc.h>
813
20
815
21
#include "display/curve.h"
13
#include "display/curve.h"
816
22
#include "helper/geom-nodetype.h"
817
23
#include "helper/geom-curves.h"
14
#include "helper/geom-curves.h"
819
24
#include "helper/geom.h"
15
#include "helper/geom-satellite.h"
820
16
#include <2geom/elliptical-arc.h>
821
17
#include "knotholder.h"
822
18
#include <boost/optional.hpp>
823
25
19
824
26
// for programmatically updating knots
825
27
#include "ui/tools-switch.h"
826
28
// TODO due to internal breakage in glibmm headers, this must be last:
20
// TODO due to internal breakage in glibmm headers, this must be last:
827
29
#include <glibmm/i18n.h>
21
#include <glibmm/i18n.h>
828
30
22
829
31
using namespace Geom;
830
32
namespace Inkscape {
23
namespace Inkscape {
831
33
namespace LivePathEffect {
24
namespace LivePathEffect {
832
34
25
835
35
static const Util::EnumData<FilletMethod> FilletMethodData[FM_END] = {
26
static const Util::EnumData<Filletmethod> FilletmethodData[] = {
836
36
    { FM_AUTO, N_("Auto"), "auto" },
27
    { FM_AUTO, N_("Auto"), "auto" }, 
837
37
    { FM_ARC, N_("Force arc"), "arc" },
28
    { FM_ARC, N_("Force arc"), "arc" },
838
38
    { FM_BEZIER, N_("Force bezier"), "bezier" }
29
    { FM_BEZIER, N_("Force bezier"), "bezier" }
839
39
};
30
};
859
40
static const Util::EnumDataConverter<FilletMethod>
31
static const Util::EnumDataConverter<Filletmethod> FMConverter(FilletmethodData, FM_END);
860
41
FMConverter(FilletMethodData, FM_END);
32
861
42
33
LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject)
862
43
const double tolerance = 0.001;
34
    : Effect(lpeobject),
863
44
const double gapHelper = 0.00001;
35
      unit(_("Unit"), _("Unit"), "unit", &wr, this, "px"),
864
45
36
      satellites_param("Satellites_param", "Satellites_param",
865
46
LPEFilletChamfer::LPEFilletChamfer(LivePathEffectObject *lpeobject) :
37
                       "satellites_param", &wr, this),
866
47
    Effect(lpeobject),
38
      method(_("Method:"), _("Methods to calculate the fillet or chamfer"),
867
48
    fillet_chamfer_values(_("Fillet point"), _("Fillet point"), "fillet_chamfer_values", &wr, this),
39
             "method", FMConverter, &wr, this, FM_AUTO),
868
49
    hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this, false),
40
      radius(_("Radius (unit or %):"), _("Radius, in unit or %"), "radius", &wr,
869
50
    ignore_radius_0(_("Ignore 0 radius knots"), _("Ignore 0 radius knots"), "ignore_radius_0", &wr, this, false),
41
             this, 0.0),
870
51
    only_selected(_("Change only selected nodes"), _("Change only selected nodes"), "only_selected", &wr, this, false),
42
      chamfer_steps(_("Chamfer steps:"), _("Chamfer steps"), "chamfer_steps",
871
52
    flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"), "flexible", &wr, this, false),
43
                    &wr, this, 1),
872
53
    use_knot_distance(_("Use knots distance instead radius"), _("Use knots distance instead radius"), "use_knot_distance", &wr, this, false),
44
      flexible(_("Flexible radius size (%)"), _("Flexible radius size (%)"),
873
54
    method(_("Method:"), _("Fillets methods"), "method", FMConverter, &wr, this, FM_AUTO),
45
               "flexible", &wr, this, false),
874
55
    radius(_("Radius (unit or %):"), _("Radius, in unit or %"), "radius", &wr, this, 0.),
46
      mirror_knots(_("Mirror Knots"), _("Mirror Knots"), "mirror_knots", &wr,
875
56
    chamfer_steps(_("Chamfer steps:"), _("Chamfer steps"), "chamfer_steps", &wr, this, 0),
47
                   this, true),
876
57
    
48
      only_selected(_("Change only selected nodes"),
877
58
    helper_size(_("Helper size with direction:"), _("Helper size with direction"), "helper_size", &wr, this, 0)
49
                    _("Change only selected nodes"), "only_selected", &wr, this,
878
50
                    false),
879
51
      use_knot_distance(_("Use knots distance instead radius"),
880
52
                        _("Use knots distance instead radius"),
881
53
                        "use_knot_distance", &wr, this, false),
882
54
      hide_knots(_("Hide knots"), _("Hide knots"), "hide_knots", &wr, this,
883
55
                 false),
884
56
      apply_no_radius(_("Apply changes if radius = 0"), _("Apply changes if radius = 0"), "apply_no_radius", &wr, this, true),
885
57
      apply_with_radius(_("Apply changes if radius > 0"), _("Apply changes if radius > 0"), "apply_with_radius", &wr, this, true),
886
58
      helper_size(_("Helper path size with direction to node:"),
887
59
                  _("Helper path size with direction to node"), "helper_size", &wr, this, 0),
888
60
      _pathvector_satellites(NULL),
889
61
      _degenerate_hide(false)
890
59
{
62
{
892
60
    registerParameter(&fillet_chamfer_values);
63
    registerParameter(&satellites_param);
893
64
    registerParameter(&unit);
894
61
    registerParameter(&method);
65
    registerParameter(&method);
895
62
    registerParameter(&radius);
66
    registerParameter(&radius);
896
63
    registerParameter(&chamfer_steps);
67
    registerParameter(&chamfer_steps);
897
64
    registerParameter(&helper_size);
68
    registerParameter(&helper_size);
898
65
    registerParameter(&flexible);
69
    registerParameter(&flexible);
899
66
    registerParameter(&use_knot_distance);
70
    registerParameter(&use_knot_distance);
901
67
    registerParameter(&ignore_radius_0);
71
    registerParameter(&mirror_knots);
902
72
    registerParameter(&apply_no_radius);
903
73
    registerParameter(&apply_with_radius);
904
68
    registerParameter(&only_selected);
74
    registerParameter(&only_selected);
905
69
    registerParameter(&hide_knots);
75
    registerParameter(&hide_knots);
906
70
76
908
71
    radius.param_set_range(0., infinity());
77
    radius.param_set_range(0.0, Geom::infinity());
909
72
    radius.param_set_increments(1, 1);
78
    radius.param_set_increments(1, 1);
910
73
    radius.param_set_digits(4);
79
    radius.param_set_digits(4);
911
74
    radius.param_overwrite_widget(true);
80
    radius.param_overwrite_widget(true);
912
75
    chamfer_steps.param_set_range(1, 999);
81
    chamfer_steps.param_set_range(1, 999);
913
76
    chamfer_steps.param_set_increments(1, 1);
82
    chamfer_steps.param_set_increments(1, 1);
914
77
    chamfer_steps.param_set_digits(0);
83
    chamfer_steps.param_set_digits(0);
917
78
    chamfer_steps.param_overwrite_widget(true);
84
    helper_size.param_set_range(0, 999);
916
79
    helper_size.param_set_range(0, infinity());
918
80
    helper_size.param_set_increments(5, 5);
85
    helper_size.param_set_increments(5, 5);
919
81
    helper_size.param_set_digits(0);
86
    helper_size.param_set_digits(0);
922
82
    helper_size.param_overwrite_widget(true);
87
    _provides_knotholder_entities = true;
921
83
    fillet_chamfer_values.set_chamfer_steps(3);
923
84
}
88
}
924
85
89
926
86
LPEFilletChamfer::~LPEFilletChamfer() {}
90
void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
927
91
{
928
92
    SPLPEItem *splpeitem = const_cast<SPLPEItem *>(lpeItem);
929
93
    SPShape *shape = dynamic_cast<SPShape *>(splpeitem);
930
94
    if (shape) {
931
95
        Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(shape->getCurve()->get_pathvector());
932
96
        Satellites satellites;
933
97
        for (Geom::PathVector::const_iterator path_it = pathv.begin(); path_it !=  pathv.end(); ++path_it) {
934
98
            if (path_it->empty()) {
935
99
                continue;
936
100
            }
937
101
            std::vector<Satellite> subpath_satellites;
938
102
            for (Geom::Path::const_iterator curve_it = path_it->begin(); curve_it !=  path_it->end(); ++curve_it) {
939
103
                //Maybe we want this satellites...
940
104
                //if (curve_it->isDegenerate()) {
941
105
                //  continue 
942
106
                //}
943
107
                Satellite satellite(FILLET);
944
108
                satellite.setSteps(chamfer_steps);
945
109
                subpath_satellites.push_back(satellite);
946
110
            }
947
111
            //we add the last satellite on open path because _pathvector_satellites is related to nodes, not curves
948
112
            //so maybe in the future we can need this last satellite in other effects
949
113
            //dont remove for this effect because _pathvector_satellites class has methods when the path is modiffied
950
114
            //and we want one method for all uses
951
115
            if (!path_it->closed()) {
952
116
                Satellite satellite(FILLET);
953
117
                satellite.setSteps(chamfer_steps);
954
118
                subpath_satellites.push_back(satellite);
955
119
            }
956
120
            satellites.push_back(subpath_satellites);
957
121
        }
958
122
        _pathvector_satellites = new PathVectorSatellites();
959
123
        _pathvector_satellites->setPathVector(pathv);
960
124
        _pathvector_satellites->setSatellites(satellites);
961
125
        satellites_param.setPathVectorSatellites(_pathvector_satellites);
962
126
    } else {
963
127
        g_warning("LPE Fillet/Chamfer can only be applied to shapes (not groups).");
964
128
        SPLPEItem *item = const_cast<SPLPEItem *>(lpeItem);
965
129
        item->removeCurrentPathEffect(false);
966
130
    }
967
131
}
968
87
132
969
88
Gtk::Widget *LPEFilletChamfer::newWidget()
133
Gtk::Widget *LPEFilletChamfer::newWidget()
970
89
{
134
{
971
@@ -94,54 +139,50 @@
972
94
    vbox->set_border_width(5);
139
    vbox->set_border_width(5);
973
95
    vbox->set_homogeneous(false);
140
    vbox->set_homogeneous(false);
974
96
    vbox->set_spacing(2);
141
    vbox->set_spacing(2);
975
97
    Gtk::HBox *advertaising = Gtk::manage(new Gtk::HBox(true, 0));
976
98
    Gtk::Button *advert = Gtk::manage(new Gtk::Button(Glib::ustring(_("IMPORTANT! New version soon..."))));
977
99
    advertaising->pack_start(*advert, true, true, 2);
978
100
    vbox->pack_start(*advertaising, true, true, 2);
979
101
    Gtk::HBox *advertaising2 = Gtk::manage(new Gtk::HBox(true, 0));
980
102
    Gtk::Button *advert2 = Gtk::manage(new Gtk::Button(Glib::ustring(_("Not compatible. Convert to path after."))));
981
103
    advertaising2->pack_start(*advert2, true, true, 2);
982
104
    vbox->pack_start(*advertaising2, true, true, 2);
983
105
    std::vector<Parameter *>::iterator it = param_vector.begin();
142
    std::vector<Parameter *>::iterator it = param_vector.begin();
984
106
    while (it != param_vector.end()) {
143
    while (it != param_vector.end()) {
985
107
        if ((*it)->widget_is_visible) {
144
        if ((*it)->widget_is_visible) {
986
108
            Parameter *param = *it;
145
            Parameter *param = *it;
987
109
            Gtk::Widget *widg = param->param_newWidget();
146
            Gtk::Widget *widg = param->param_newWidget();
988
110
            if (param->param_key == "radius") {
147
            if (param->param_key == "radius") {
992
111
                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
148
                Inkscape::UI::Widget::Scalar *widg_registered =
993
112
                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::updateFillet));
149
                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
994
113
                widg = widgRegistered;
150
                widg_registered->signal_value_changed().connect(
995
151
                    sigc::mem_fun(*this, &LPEFilletChamfer::updateAmount));
996
152
                widg = widg_registered;
997
114
                if (widg) {
153
                if (widg) {
1002
115
                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
154
                    Gtk::HBox *scalar_parameter = dynamic_cast<Gtk::HBox *>(widg);
1003
116
                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
155
                    std::vector<Gtk::Widget *> childList = scalar_parameter->get_children();
1004
117
                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
156
                    Gtk::Entry *entry_widget = dynamic_cast<Gtk::Entry *>(childList[1]);
1005
118
                    entryWidg->set_width_chars(6);
157
                    entry_widget->set_width_chars(6);
1006
119
                }
158
                }
1007
159
//            } else if (param->param_key == "unit") {
1008
160
//                Inkscape::UI::Widget::RegisteredUnitMenu* widg_registered = 
1009
161
//                    Gtk::manage(dynamic_cast< Inkscape::UI::Widget::RegisteredUnitMenu *>(widg));
1010
162
//                widg_registered->setUnit(unit.get_abbreviation());
1011
163
//                widg_registered->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change unit parameter"));
1012
164
//                widg_registered->getUnitMenu()->signal_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::convertUnit));
1013
165
//                widg = widg_registered;
1014
120
            } else if (param->param_key == "chamfer_steps") {
166
            } else if (param->param_key == "chamfer_steps") {
1018
121
                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
167
                Inkscape::UI::Widget::Scalar *widg_registered =
1019
122
                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamferSubdivisions));
168
                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
1020
123
                widg = widgRegistered;
169
                widg_registered->signal_value_changed().connect(
1021
170
                    sigc::mem_fun(*this, &LPEFilletChamfer::updateChamferSteps));
1022
171
                widg = widg_registered;
1023
124
                if (widg) {
172
                if (widg) {
1028
125
                    Gtk::HBox *scalarParameter = dynamic_cast<Gtk::HBox *>(widg);
173
                    Gtk::HBox *scalar_parameter = dynamic_cast<Gtk::HBox *>(widg);
1029
126
                    std::vector<Gtk::Widget *> childList = scalarParameter->get_children();
174
                    std::vector<Gtk::Widget *> childList = scalar_parameter->get_children();
1030
127
                    Gtk::Entry *entryWidg = dynamic_cast<Gtk::Entry *>(childList[1]);
175
                    Gtk::Entry *entry_widget = dynamic_cast<Gtk::Entry *>(childList[1]);
1031
128
                    entryWidg->set_width_chars(3);
176
                    entry_widget->set_width_chars(3);
1032
129
                }
177
                }
1033
130
            } else if (param->param_key == "flexible") {
1034
131
                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
1035
132
                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleFlexFixed));
1036
133
            } else if (param->param_key == "helper_size") {
178
            } else if (param->param_key == "helper_size") {
1042
134
                Inkscape::UI::Widget::Scalar *widgRegistered = Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
179
                Inkscape::UI::Widget::Scalar *widg_registered =
1043
135
                widgRegistered->signal_value_changed().connect(sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
180
                    Gtk::manage(dynamic_cast<Inkscape::UI::Widget::Scalar *>(widg));
1044
136
            } else if (param->param_key == "hide_knots") {
181
                widg_registered->signal_value_changed().connect(
1045
137
                Gtk::CheckButton *widgRegistered = Gtk::manage(dynamic_cast<Gtk::CheckButton *>(widg));
182
                    sigc::mem_fun(*this, &LPEFilletChamfer::refreshKnots));
1041
138
                widgRegistered->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::toggleHide));
1046
139
            } else if (param->param_key == "only_selected") {
183
            } else if (param->param_key == "only_selected") {
1047
140
                Gtk::manage(widg);
184
                Gtk::manage(widg);
1048
141
            } else if (param->param_key == "ignore_radius_0") {
1049
142
                Gtk::manage(widg);
1050
143
            }
185
            }
1051
144
1052
145
            Glib::ustring *tip = param->param_getTooltip();
186
            Glib::ustring *tip = param->param_getTooltip();
1053
146
            if (widg) {
187
            if (widg) {
1054
147
                vbox->pack_start(*widg, true, true, 2);
188
                vbox->pack_start(*widg, true, true, 2);
1055
@@ -153,504 +194,386 @@
1056
153
                }
194
                }
1057
154
            }
195
            }
1058
155
        }
196
        }
1059
156
1060
157
        ++it;
197
        ++it;
1061
158
    }
198
    }
1072
159
    Gtk::HBox *filletContainer = Gtk::manage(new Gtk::HBox(true, 0));
199
1073
160
    Gtk::Button *fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
200
    Gtk::HBox *fillet_container = Gtk::manage(new Gtk::HBox(true, 0));
1074
161
    fillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::fillet));
201
    Gtk::Button *fillet =  Gtk::manage(new Gtk::Button(Glib::ustring(_("Fillet"))));
1075
162
202
    fillet->signal_clicked()
1076
163
    filletContainer->pack_start(*fillet, true, true, 2);
203
    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),FILLET));
1077
164
    Gtk::Button *inverseFillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
204
1078
165
    inverseFillet->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseFillet));
205
    fillet_container->pack_start(*fillet, true, true, 2);
1079
166
    filletContainer->pack_start(*inverseFillet, true, true, 2);
206
    Gtk::Button *inverse_fillet = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse fillet"))));
1080
167
    
207
    inverse_fillet->signal_clicked()
1081
168
    Gtk::HBox *chamferContainer = Gtk::manage(new Gtk::HBox(true, 0));
208
    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),INVERSE_FILLET));
1082
209
    fillet_container->pack_start(*inverse_fillet, true, true, 2);
1083
210
1084
211
    Gtk::HBox *chamfer_container = Gtk::manage(new Gtk::HBox(true, 0));
1085
169
    Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
212
    Gtk::Button *chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Chamfer"))));
1095
170
    chamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::chamfer));
213
    chamfer->signal_clicked()
1096
171
214
    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),CHAMFER));
1097
172
    chamferContainer->pack_start(*chamfer, true, true, 2);
215
1098
173
    Gtk::Button *inverseChamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse chamfer"))));
216
    chamfer_container->pack_start(*chamfer, true, true, 2);
1099
174
    inverseChamfer->signal_clicked().connect(sigc::mem_fun(*this, &LPEFilletChamfer::inverseChamfer));
217
    Gtk::Button *inverse_chamfer = Gtk::manage(new Gtk::Button(Glib::ustring(_("Inverse chamfer"))));
1100
175
    chamferContainer->pack_start(*inverseChamfer, true, true, 2);
218
    inverse_chamfer->signal_clicked()
1101
176
219
    .connect(sigc::bind<SatelliteType>(sigc::mem_fun(*this, &LPEFilletChamfer::updateSatelliteType),INVERSE_CHAMFER));
1102
177
    vbox->pack_start(*filletContainer, true, true, 2);
220
    chamfer_container->pack_start(*inverse_chamfer, true, true, 2);
1103
178
    vbox->pack_start(*chamferContainer, true, true, 2);
221
1104
222
    vbox->pack_start(*fillet_container, true, true, 2);
1105
223
    vbox->pack_start(*chamfer_container, true, true, 2);
1106
179
224
1107
180
    return vbox;
225
    return vbox;
1108
181
}
226
}
1109
182
227
1155
183
void LPEFilletChamfer::toggleHide()
228
void LPEFilletChamfer::refreshKnots()
1156
184
{
229
{
1157
185
    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
230
    if (satellites_param._knoth) {
1158
186
    std::vector<Geom::Point> result;
231
        satellites_param._knoth->update_knots();
1159
187
    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
232
    }
1160
188
            point_it != filletChamferData.end(); ++point_it) {
233
}
1161
189
        if (hide_knots) {
234
1162
190
            result.push_back(Point((*point_it)[X], std::abs((*point_it)[Y]) * -1));
235
void LPEFilletChamfer::updateAmount()
1163
191
        } else {
236
{
1164
192
            result.push_back(Point((*point_it)[X], std::abs((*point_it)[Y])));
237
    setSelected(_pathvector_satellites);
1165
193
        }
238
    double power = radius;
1121
194
    }
1122
195
    fillet_chamfer_values.param_set_and_write_new_value(result);
1123
196
    refreshKnots();
1124
197
}
1125
198
1126
199
void LPEFilletChamfer::toggleFlexFixed()
1127
200
{
1128
201
    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
1129
202
    std::vector<Geom::Point> result;
1130
203
    unsigned int i = 0;
1131
204
    for (std::vector<Point>::const_iterator point_it = filletChamferData.begin();
1132
205
            point_it != filletChamferData.end(); ++point_it) {
1133
206
        if (flexible) {
1134
207
            result.push_back(Point(fillet_chamfer_values.to_time(i, (*point_it)[X]),
1135
208
                                   (*point_it)[Y]));
1136
209
        } else {
1137
210
            result.push_back(Point(fillet_chamfer_values.to_len(i, (*point_it)[X]),
1138
211
                                   (*point_it)[Y]));
1139
212
        }
1140
213
        i++;
1141
214
    }
1142
215
    if (flexible) {
1143
216
        radius.param_set_range(0., 100);
1144
217
        radius.param_set_value(0);
1145
218
    } else {
1146
219
        radius.param_set_range(0., infinity());
1147
220
        radius.param_set_value(0);
1148
221
    }
1149
222
    fillet_chamfer_values.param_set_and_write_new_value(result);
1150
223
}
1151
224
1152
225
void LPEFilletChamfer::updateFillet()
1153
226
{
1154
227
    double power = 0;
1166
228
    if (!flexible) {
239
    if (!flexible) {
1311
229
        power = radius * -1;
240
        SPDocument * document = SP_ACTIVE_DOCUMENT;
1312
230
    } else {
241
        SPNamedView *nv = sp_document_namedview(document, NULL);
1313
231
        power = radius;
242
        Glib::ustring display_unit = nv->display_units->abbr;
1314
232
    }
243
        power = Inkscape::Util::Quantity::convert(power, unit.get_abbreviation(), display_unit.c_str());
1315
233
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
244
    }
1316
234
    doUpdateFillet(path_from_piecewise(pwd2, tolerance), power);
245
    _pathvector_satellites->updateAmount(power, apply_no_radius, apply_with_radius, only_selected, 
1317
235
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
246
                                         use_knot_distance, flexible);
1318
236
}
247
    satellites_param.setPathVectorSatellites(_pathvector_satellites);
1319
237
248
}
1320
238
void LPEFilletChamfer::fillet()
249
1321
239
{
250
//void LPEFilletChamfer::convertUnit()
1322
240
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
251
//{
1323
241
    doChangeType(path_from_piecewise(pwd2, tolerance), 1);
252
//    SPDocument * document = SP_ACTIVE_DOCUMENT;
1324
242
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to fillet"));
253
//    SPNamedView *nv = sp_document_namedview(document, NULL);
1325
243
}
254
//    Glib::ustring display_unit = nv->display_units->abbr;
1326
244
255
//    _pathvector_satellites->convertUnit(unit.get_abbreviation(), display_unit, apply_no_radius, apply_with_radius);
1327
245
void LPEFilletChamfer::inverseFillet()
256
//    satellites_param.setPathVectorSatellites(_pathvector_satellites);
1328
246
{
257
//}
1329
247
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
258
1330
248
    doChangeType(path_from_piecewise(pwd2, tolerance), 2);
259
void LPEFilletChamfer::updateChamferSteps()
1331
249
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to inverse fillet"));
260
{
1332
250
}
261
    setSelected(_pathvector_satellites);
1333
251
262
    _pathvector_satellites->updateSteps(chamfer_steps, apply_no_radius, apply_with_radius, only_selected);
1334
252
void LPEFilletChamfer::chamferSubdivisions()
263
    satellites_param.setPathVectorSatellites(_pathvector_satellites);
1335
253
{
264
}
1336
254
    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
265
1337
255
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
266
void LPEFilletChamfer::updateSatelliteType(SatelliteType satellitetype)
1338
256
    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 5000);
267
{
1339
257
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Change scalar parameter"));
268
    setSelected(_pathvector_satellites);
1340
258
}
269
    _pathvector_satellites->updateSatelliteType(satellitetype, apply_no_radius, apply_with_radius, only_selected);
1341
259
270
    satellites_param.setPathVectorSatellites(_pathvector_satellites);
1342
260
void LPEFilletChamfer::chamfer()
271
}
1343
261
{
272
1344
262
    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
273
void LPEFilletChamfer::setSelected(PathVectorSatellites *_pathvector_satellites){
1345
263
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
274
    Geom::PathVector const pathv = _pathvector_satellites->getPathVector();
1346
264
    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 3000);
275
    Satellites satellites = _pathvector_satellites->getSatellites();
1347
265
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to chamfer"));
276
    for (size_t i = 0; i < satellites.size(); ++i) {
1348
266
}
277
        for (size_t j = 0; j < satellites[i].size(); ++j) {
1349
267
278
            Geom::Curve const &curve_in = pathv[i][j];
1350
268
void LPEFilletChamfer::inverseChamfer()
279
            if (only_selected && isNodePointSelected(curve_in.initialPoint()) ){
1351
269
{
280
                satellites[i][j].setSelected(true);
1208
270
    fillet_chamfer_values.set_chamfer_steps(chamfer_steps);
1209
271
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
1210
272
    doChangeType(path_from_piecewise(pwd2, tolerance), chamfer_steps + 4000);
1211
273
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Convert to inverse fillet"));
1212
274
}
1213
275
1214
276
void LPEFilletChamfer::refreshKnots()
1215
277
{
1216
278
    Piecewise<D2<SBasis> > const &pwd2 = fillet_chamfer_values.get_pwd2();
1217
279
    fillet_chamfer_values.recalculate_knots(pwd2);
1218
280
    SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1219
281
    if (tools_isactive(desktop, TOOLS_NODES)) {
1220
282
        tools_switch(desktop, TOOLS_SELECT);
1221
283
        tools_switch(desktop, TOOLS_NODES);
1222
284
    }
1223
285
    DocumentUndo::done(getSPDoc(), SP_VERB_DIALOG_LIVE_PATH_EFFECT, _("Knots and helper paths refreshed"));
1224
286
}
1225
287
1226
288
void LPEFilletChamfer::doUpdateFillet(Geom::PathVector const &original_pathv, double power)
1227
289
{
1228
290
    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
1229
291
    std::vector<Geom::Point> result;
1230
292
    Geom::PathVector original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
1231
293
    int counter = 0;
1232
294
    for (PathVector::const_iterator path_it = original_pathv_processed.begin();
1233
295
            path_it != original_pathv_processed.end(); ++path_it) {
1234
296
        if (path_it->empty())
1235
297
            continue;
1236
298
1237
299
        Geom::Path::const_iterator curve_it1 = path_it->begin();
1238
300
        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
1239
301
        Geom::Path::const_iterator curve_endit = path_it->end_default();
1240
302
        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
1241
303
            const Curve &closingline = path_it->back_closed();
1242
304
            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
1243
305
                curve_endit = path_it->end_open();
1244
306
            }
1245
307
        }
1246
308
        double powerend = 0;
1247
309
        while (curve_it1 != curve_endit) {
1248
310
            powerend = power;
1249
311
            if (power < 0 && !use_knot_distance) {
1250
312
                powerend = fillet_chamfer_values.rad_to_len(counter,powerend);
1251
313
            }
1252
314
            if (power > 0) {
1253
315
                powerend = counter + (power / 100);
1254
316
            }
1255
317
            if (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
1256
318
                                    filletChamferData[counter][X] == counter)) {
1257
319
                powerend = filletChamferData[counter][X];
1258
320
            }
1259
321
            if (filletChamferData[counter][Y] == 0) {
1260
322
                powerend = filletChamferData[counter][X];
1261
323
            }
1262
324
            if (only_selected && !isNodePointSelected(curve_it1->initialPoint())) {
1263
325
                powerend = filletChamferData[counter][X];
1264
326
            }
1265
327
            result.push_back(Point(powerend, filletChamferData[counter][Y]));
1266
328
            ++curve_it1;
1267
329
            ++curve_it2;
1268
330
            counter++;
1269
331
        }
1270
332
    }
1271
333
    fillet_chamfer_values.param_set_and_write_new_value(result);
1272
334
}
1273
335
1274
336
void LPEFilletChamfer::doChangeType(Geom::PathVector const &original_pathv, int type)
1275
337
{
1276
338
    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
1277
339
    std::vector<Geom::Point> result;
1278
340
    Geom::PathVector original_pathv_processed = pathv_to_linear_and_cubic_beziers(original_pathv);
1279
341
    int counter = 0;
1280
342
    for (PathVector::const_iterator path_it = original_pathv_processed.begin(); path_it != original_pathv_processed.end(); ++path_it) {
1281
343
        int pathCounter = 0;
1282
344
        if (path_it->empty())
1283
345
            continue;
1284
346
1285
347
        Geom::Path::const_iterator curve_it1 = path_it->begin();
1286
348
        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
1287
349
        Geom::Path::const_iterator curve_endit = path_it->end_default();
1288
350
        if (path_it->closed() && path_it->back_closed().isDegenerate()) {
1289
351
            const Curve &closingline = path_it->back_closed();
1290
352
            if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
1291
353
                curve_endit = path_it->end_open();
1292
354
            }
1293
355
        }
1294
356
        while (curve_it1 != curve_endit) {
1295
357
            bool toggle = true;
1296
358
            if (filletChamferData[counter][Y] == 0 ||
1297
359
                    (ignore_radius_0 && (filletChamferData[counter][X] == 0 ||
1298
360
                    filletChamferData[counter][X] == counter)) ||
1299
361
                    (only_selected && !isNodePointSelected(curve_it1->initialPoint()))) {
1300
362
                toggle = false;
1301
363
            }
1302
364
            if (toggle) {
1303
365
                if(type >= 5000){
1304
366
                    if(filletChamferData[counter][Y] >= 3000 && filletChamferData[counter][Y] < 4000){
1305
367
                        type = type - 2000;
1306
368
                    } else if (filletChamferData[counter][Y] >= 4000 && filletChamferData[counter][Y] < 5000){
1307
369
                        type = type - 1000;
1308
370
                    }
1309
371
                }
1310
372
                result.push_back(Point(filletChamferData[counter][X], type));
1352
373
            } else {
281
            } else {
1426
374
                result.push_back(filletChamferData[counter]);
282
                satellites[i][j].setSelected(false);
1427
375
            }
283
            }
1428
376
            ++curve_it1;
284
        }
1429
377
            if (curve_it2 != curve_endit) {
285
    }
1430
378
                ++curve_it2;
286
    _pathvector_satellites->setSatellites(satellites);
1358
379
            }
1359
380
            counter++;
1360
381
            pathCounter++;
1361
382
        }
1362
383
    }
1363
384
    fillet_chamfer_values.param_set_and_write_new_value(result);
1364
385
}
1365
386
1366
387
void LPEFilletChamfer::doOnApply(SPLPEItem const *lpeItem)
1367
388
{
1368
389
    if (SP_IS_SHAPE(lpeItem)) {
1369
390
        std::vector<Point> point;
1370
391
        PathVector const &original_pathv = pathv_to_linear_and_cubic_beziers(SP_SHAPE(lpeItem)->_curve->get_pathvector());
1371
392
        Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
1372
393
        for (PathVector::const_iterator path_it = original_pathv.begin(); path_it != original_pathv.end(); ++path_it) {
1373
394
            if (path_it->empty())
1374
395
                continue;
1375
396
1376
397
            Geom::Path::const_iterator curve_it1 = path_it->begin();
1377
398
            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
1378
399
            Geom::Path::const_iterator curve_endit = path_it->end_default();
1379
400
            if (path_it->closed()) {
1380
401
              const Geom::Curve &closingline = path_it->back_closed(); 
1381
402
              // the closing line segment is always of type 
1382
403
              // Geom::LineSegment.
1383
404
              if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
1384
405
                // closingline.isDegenerate() did not work, because it only checks for
1385
406
                // *exact* zero length, which goes wrong for relative coordinates and
1386
407
                // rounding errors...
1387
408
                // the closing line segment has zero-length. So stop before that one!
1388
409
                curve_endit = path_it->end_open();
1389
410
              }
1390
411
            }
1391
412
            int counter = 0;
1392
413
            while (curve_it1 != curve_endit) {
1393
414
                std::pair<std::size_t, std::size_t> positions = fillet_chamfer_values.get_positions(counter, original_pathv);
1394
415
                Geom::NodeType nodetype;
1395
416
                if (positions.second == 0) {
1396
417
                    if (path_it->closed()) {
1397
418
                        Piecewise<D2<SBasis> > u;
1398
419
                        u.push_cut(0);          
1399
420
                        u.push(pwd2_in[fillet_chamfer_values.last_index(counter, original_pathv)], 1);
1400
421
                        Geom::Curve const * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
1401
422
                        nodetype = get_nodetype(*A, *curve_it1);
1402
423
                    } else {
1403
424
                        nodetype = NODE_NONE;
1404
425
                    }
1405
426
                } else {
1406
427
                    nodetype = get_nodetype((*path_it)[counter - 1], *curve_it1);
1407
428
                }
1408
429
                if (nodetype == NODE_CUSP) {
1409
430
                    point.push_back(Point(0, 1));
1410
431
                } else {
1411
432
                    point.push_back(Point(0, 0));
1412
433
                }
1413
434
                ++curve_it1;
1414
435
                if (curve_it2 != curve_endit) {
1415
436
                    ++curve_it2;
1416
437
                }
1417
438
                counter++;
1418
439
            }
1419
440
        }
1420
441
        fillet_chamfer_values.param_set_and_write_new_value(point);
1421
442
    } else {
1422
443
        g_warning("LPE Fillet can only be applied to shapes (not groups).");
1423
444
        SPLPEItem * item = const_cast<SPLPEItem*>(lpeItem);
1424
445
        item->removeCurrentPathEffect(false);
1425
446
    }
1431
447
}
287
}
1432
448
288
1433
449
void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
289
void LPEFilletChamfer::doBeforeEffect(SPLPEItem const *lpeItem)
1434
450
{
290
{
1452
451
    if (SP_IS_SHAPE(lpeItem)) {
291
    if (sp_curve) {
1453
452
        if(hide_knots){
292
        //fillet chamfer specific calls
1454
453
            fillet_chamfer_values.set_helper_size(0);
293
        satellites_param.setUseDistance(use_knot_distance);
1455
454
        } else {
294
        satellites_param.setCurrentZoom(current_zoom);
1456
455
            fillet_chamfer_values.set_helper_size(helper_size);
295
        //mandatory call
1457
456
        }
296
        satellites_param.setEffectType(effectType());
1458
457
        fillet_chamfer_values.set_use_distance(use_knot_distance);
297
        Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(sp_curve->get_pathvector());
1459
458
        SPCurve *c = SP_IS_PATH(lpeItem) ? static_cast<SPPath const *>(lpeItem)
298
        //if are diferent sizes call to recalculate
1460
459
                     ->get_original_curve()
299
        //TODO: Update the satellite data in paths modified,
1461
460
                     : SP_SHAPE(lpeItem)->getCurve();
300
        Satellites satellites = satellites_param.data();
1462
461
        std::vector<Point> filletChamferData = fillet_chamfer_values.data();
301
        if (satellites.empty()) {
1463
462
        if (!filletChamferData.empty() && getKnotsNumber(c) != (int)
302
            doOnApply(lpeItem);
1464
463
                filletChamferData.size()) {
303
            satellites = satellites_param.data();
1465
464
            PathVector const original_pathv = pathv_to_linear_and_cubic_beziers(c->get_pathvector());
304
        }
1466
465
            Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(original_pathv);
305
        if (_pathvector_satellites) {
1467
466
            fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pwd2_in);
306
            size_t number_nodes = pathv.nodes().size();
1468
467
        }
307
            size_t previous_number_nodes = _pathvector_satellites->getTotalSatellites();
1469
308
            if (number_nodes != previous_number_nodes) {
1470
309
                Satellite satellite(FILLET);
1471
310
                satellite.setIsTime(flexible);
1472
311
                satellite.setHasMirror(mirror_knots);
1473
312
                satellite.setHidden(hide_knots);
1474
313
                _pathvector_satellites->recalculateForNewPathVector(pathv, satellite);
1475
314
                satellites = _pathvector_satellites->getSatellites();
1476
315
            }
1477
316
        }
1478
317
        if (_degenerate_hide) {
1479
318
            satellites_param.setGlobalKnotHide(true);
1480
319
        } else {
1481
320
            satellites_param.setGlobalKnotHide(false);
1482
321
        }
1483
322
        if (hide_knots) {
1484
323
            satellites_param.setHelperSize(0);
1485
324
        } else {
1486
325
            satellites_param.setHelperSize(helper_size);
1487
326
        }
1488
327
        for (size_t i = 0; i < satellites.size(); ++i) {
1489
328
            for (size_t j = 0; j < satellites[i].size(); ++j) {
1490
329
                Geom::Curve const &curve_in = pathv[i][j];
1491
330
                if (satellites[i][j].is_time != flexible) {
1492
331
                    satellites[i][j].is_time = flexible;
1493
332
                    double amount = satellites[i][j].amount;
1494
333
                    if (pathv[i].size() == j) {
1495
334
                        continue;
1496
335
                    }
1497
336
                    if (satellites[i][j].is_time) {
1498
337
                        double time = timeAtArcLength(amount, curve_in);
1499
338
                        satellites[i][j].amount = time;
1500
339
                    } else {
1501
340
                        double size = arcLengthAt(amount, curve_in);
1502
341
                        satellites[i][j].amount = size;
1503
342
                    }
1504
343
                }
1505
344
                if (satellites[i][j].has_mirror != mirror_knots) {
1506
345
                    satellites[i][j].has_mirror = mirror_knots;
1507
346
                }
1508
347
                satellites[i][j].hidden = hide_knots;
1509
348
                if (only_selected && isNodePointSelected(curve_in.initialPoint()) ){
1510
349
                    satellites[i][j].setSelected(true);
1511
350
                }
1512
351
            }
1513
352
        }
1514
353
        if (!_pathvector_satellites) {
1515
354
            _pathvector_satellites = new PathVectorSatellites();
1516
355
        }
1517
356
        _pathvector_satellites->setPathVector(pathv);
1518
357
        _pathvector_satellites->setSatellites(satellites);
1519
358
        satellites_param.setPathVectorSatellites(_pathvector_satellites, false);
1520
359
        refreshKnots();
1521
468
    } else {
360
    } else {
1522
469
        g_warning("LPE Fillet can only be applied to shapes (not groups).");
361
        g_warning("LPE Fillet can only be applied to shapes (not groups).");
1523
470
    }
362
    }
1524
471
}
363
}
1525
472
364
1527
473
int LPEFilletChamfer::getKnotsNumber(SPCurve const *c)
365
void
1528
366
LPEFilletChamfer::addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
1529
474
{
367
{
1539
475
    int nKnots = c->nodes_in_path();
368
    hp_vec.push_back(_hp);
1531
476
    PathVector const pv =    pathv_to_linear_and_cubic_beziers(c->get_pathvector());
1532
477
    for (Geom::PathVector::const_iterator path_it = pv.begin();
1533
478
            path_it != pv.end(); ++path_it) {
1534
479
        if (!(*path_it).closed()) {
1535
480
            nKnots--;
1536
481
        }
1537
482
    }
1538
483
    return nKnots;
1540
484
}
369
}
1541
485
370
1542
486
void
371
void
1544
487
LPEFilletChamfer::adjustForNewPath(Geom::PathVector const &path_in)
372
LPEFilletChamfer::addChamferSteps(Geom::Path &tmp_path, Geom::Path path_chamfer, Geom::Point end_arc_point, size_t steps)
1545
488
{
373
{
1548
489
    if (!path_in.empty()) {
374
    setSelected(_pathvector_satellites);
1549
490
        fillet_chamfer_values.recalculate_controlpoints_for_new_pwd2(pathv_to_linear_and_cubic_beziers(path_in)[0].toPwSb());
375
    double path_subdivision = 1.0 / steps;
1550
376
    for (size_t i = 1; i < steps; i++) {
1551
377
        Geom::Point chamfer_step = path_chamfer.pointAt(path_subdivision * i);
1552
378
        tmp_path.appendNew<Geom::LineSegment>(chamfer_step);
1553
491
    }
379
    }
1554
380
    tmp_path.appendNew<Geom::LineSegment>(end_arc_point);
1555
492
}
381
}
1556
493
382
1557
494
Geom::PathVector
383
Geom::PathVector
1558
495
LPEFilletChamfer::doEffect_path(Geom::PathVector const &path_in)
384
LPEFilletChamfer::doEffect_path(Geom::PathVector const &path_in)
1559
496
{
385
{
1568
497
    Geom::PathVector pathvector_out;
386
    const double GAP_HELPER = 0.00001;
1569
498
    Piecewise<D2<SBasis> > pwd2_in = paths_to_pw(pathv_to_linear_and_cubic_beziers(path_in));
387
    Geom::PathVector path_out;
1570
499
    pwd2_in = remove_short_cuts(pwd2_in, .01);
388
    size_t path = 0;
1563
500
    Piecewise<D2<SBasis> > der = derivative(pwd2_in);
1564
501
    Piecewise<D2<SBasis> > n = rot90(unitVector(der));
1565
502
    fillet_chamfer_values.set_pwd2(pwd2_in, n);
1566
503
    std::vector<Point> filletChamferData = fillet_chamfer_values.data();
1567
504
    unsigned int counter = 0;
1571
505
    const double K = (4.0 / 3.0) * (sqrt(2.0) - 1.0);
389
    const double K = (4.0 / 3.0) * (sqrt(2.0) - 1.0);
1581
506
    Geom::PathVector path_in_processed = pathv_to_linear_and_cubic_beziers(path_in);
390
    _degenerate_hide = false;
1582
507
    for (PathVector::const_iterator path_it = path_in_processed.begin();
391
    Geom::PathVector const pathv = pathv_to_linear_and_cubic_beziers(path_in);
1583
508
            path_it != path_in_processed.end(); ++path_it) {
392
    Satellites satellites = _pathvector_satellites->getSatellites();
1584
509
        if (path_it->empty())
393
    for (Geom::PathVector::const_iterator path_it = pathv.begin(); path_it != pathv.end(); ++path_it) {
1585
510
            continue;
394
        if (path_it->empty()) {
1586
511
        Geom::Path path_out;
395
            continue;
1587
512
        Geom::Path::const_iterator curve_it1 = path_it->begin();
396
        }
1588
513
        Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
397
        Geom::Path tmp_path;
1589
514
        Geom::Path::const_iterator curve_endit = path_it->end_default();
398
        if (path_it->size() == 1) {
1590
399
            path++;
1591
400
            tmp_path.start(path_it[0].pointAt(0));
1592
401
            tmp_path.append(path_it[0]);
1593
402
            path_out.push_back(tmp_path);
1594
403
            continue;
1595
404
        }
1596
405
        double time0 = 0;
1597
406
        size_t curve = 0;
1598
407
        for (Geom::Path::const_iterator curve_it1 = path_it->begin(); curve_it1 !=  path_it->end(); ++curve_it1) {
1599
408
            size_t next_index = curve + 1;
1600
409
            if (curve == pathv[path].size() - 1 && pathv[path].closed()) {
1601
410
                next_index = 0;
1602
411
            }
1603
412
            //append last extreme of paths on open paths
1604
413
            if (curve == pathv[path].size() -1 && !pathv[path].closed()) { //the path is open and we are at end of path
1605
414
                if (time0 != 1) { //Previous satellite not at 100% amount
1606
415
                    Geom::Curve *last_curve = curve_it1->portion(time0, 1);
1607
416
                    last_curve->setInitial(tmp_path.finalPoint());
1608
417
                    tmp_path.append(*last_curve);
1609
418
                }
1610
419
                continue;
1611
420
            }
1612
421
            Geom::Curve const &curve_it2 = pathv[path][next_index];
1613
422
            Satellite satellite = satellites[path][next_index];
1614
423
            if (Geom::are_near((*curve_it1).initialPoint(), (*curve_it1).finalPoint())) {
1615
424
                _degenerate_hide = true;
1616
425
                g_warning("Knots hidded if consecutive nodes has the same position.");
1617
426
                return path_in;
1618
427
            }
1619
428
            if (!curve) { //curve == 0 
1620
429
                if (!path_it->closed()) {
1621
430
                    time0 = 0;
1622
431
                } else {
1623
432
                    time0 = satellites[path][0].time(*curve_it1);
1624
433
                }
1625
434
            }
1626
435
            double s = satellite.arcDistance(curve_it2);
1627
436
            double time1 = satellite.time(s, true, (*curve_it1));
1628
437
            double time2 = satellite.time(curve_it2);
1629
438
            if (time1 <= time0) {
1630
439
                time1 = time0;
1631
440
            }
1632
441
            if (time2 > 1) {
1633
442
                time2 = 1;
1634
443
            }
1635
444
            Geom::Curve *knot_curve_1 = curve_it1->portion(time0, time1);
1636
445
            Geom::Curve *knot_curve_2 = curve_it2.portion(time2, 1);
1637
446
            if (curve > 0) {
1638
447
                knot_curve_1->setInitial(tmp_path.finalPoint());
1639
448
            } else {
1640
449
                tmp_path.start((*curve_it1).pointAt(time0));
1641
450
            }
1642
451
1643
452
            Geom::Point start_arc_point = knot_curve_1->finalPoint();
1644
453
            Geom::Point end_arc_point = curve_it2.pointAt(time2);
1645
454
            //add a gap helper
1646
455
            if (time2 == 1) {
1647
456
                end_arc_point = curve_it2.pointAt(time2 - GAP_HELPER);
1648
457
            }
1649
458
            if (time1 == time0) {
1650
459
                start_arc_point = curve_it1->pointAt(time1 + GAP_HELPER);
1651
460
            }
1652
461
1653
462
            double k1 = distance(start_arc_point, curve_it1->finalPoint()) * K;
1654
463
            double k2 = distance(curve_it2.initialPoint(), end_arc_point) * K;
1655
464
            Geom::CubicBezier const *cubic_1 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve_1);
1656
465
            Geom::CubicBezier const *cubic_2 = dynamic_cast<Geom::CubicBezier const *>(&*knot_curve_2);
1657
466
            Geom::Ray ray_1(start_arc_point, curve_it1->finalPoint());
1658
467
            Geom::Ray ray_2(curve_it2.initialPoint(), end_arc_point);
1659
468
            if (cubic_1) {
1660
469
                ray_1.setPoints((*cubic_1)[2], start_arc_point);
1661
470
            }
1662
471
            if (cubic_2) {
1663
472
                ray_2.setPoints(end_arc_point, (*cubic_2)[1]);
1664
473
            }
1665
474
            bool ccw_toggle = cross(curve_it1->finalPoint() - start_arc_point, end_arc_point - start_arc_point) < 0;
1666
475
            double angle = angle_between(ray_1, ray_2, ccw_toggle);
1667
476
            double handle_angle_1 = ray_1.angle() - angle;
1668
477
            double handle_angle_2 = ray_2.angle() + angle;
1669
478
            if (ccw_toggle) {
1670
479
                handle_angle_1 = ray_1.angle() + angle;
1671
480
                handle_angle_2 = ray_2.angle() - angle;
1672
481
            }
1673
482
            Geom::Point handle_1 = Geom::Point::polar(ray_1.angle(), k1) + start_arc_point;
1674
483
            Geom::Point handle_2 = end_arc_point - Geom::Point::polar(ray_2.angle(), k2);
1675
484
            Geom::Point inverse_handle_1 = Geom::Point::polar(handle_angle_1, k1) + start_arc_point;
1676
485
            Geom::Point inverse_handle_2 = end_arc_point - Geom::Point::polar(handle_angle_2, k2);
1677
486
            if (time0 == 1) {
1678
487
                handle_1 = start_arc_point;
1679
488
                inverse_handle_1 = start_arc_point;
1680
489
            }
1681
490
            //remove gap helper
1682
491
            if (time2 == 1) {
1683
492
                end_arc_point = curve_it2.pointAt(time2);
1684
493
            }
1685
494
            if (time1 == time0) {
1686
495
                start_arc_point = curve_it1->pointAt(time0);
1687
496
            }
1688
497
            if (time1 != 1) {
1689
498
                if (time1 != time0 || (time1 == 1 && time0 == 1)) {
1690
499
                    if (!knot_curve_1->isDegenerate()) {
1691
500
                        tmp_path.append(*knot_curve_1);
1692
501
                    }
1693
502
                }
1694
503
                SatelliteType type = satellite.satellite_type;
1695
504
                size_t steps = satellite.steps;
1696
505
                if (!steps) steps = 1;
1697
506
                Geom::Line const x_line(Geom::Point(0, 0), Geom::Point(1, 0));
1698
507
                Geom::Line const angled_line(start_arc_point, end_arc_point);
1699
508
                double arc_angle = Geom::angle_between(x_line, angled_line);
1700
509
                double radius = Geom::distance(start_arc_point, middle_point(start_arc_point, end_arc_point)) /
1701
510
                                               sin(angle / 2.0);
1702
511
                Geom::Coord rx = radius;
1703
512
                Geom::Coord ry = rx;
1704
513
                bool eliptical = (is_straight_curve(*curve_it1) &&
1705
514
                                  is_straight_curve(curve_it2) && method != FM_BEZIER) ||
1706
515
                                  method == FM_ARC;
1707
516
                switch (type) {
1708
517
                case CHAMFER:
1709
518
                    {
1710
519
                        Geom::Path path_chamfer;
1711
520
                        path_chamfer.start(tmp_path.finalPoint());
1712
521
                        if (eliptical) {
1713
522
                            ccw_toggle = ccw_toggle ? 0 : 1;
1714
523
                            path_chamfer.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
1715
524
                        } else {
1716
525
                            path_chamfer.appendNew<Geom::CubicBezier>(handle_1, handle_2, end_arc_point);
1717
526
                        }
1718
527
                        addChamferSteps(tmp_path, path_chamfer, end_arc_point, steps);
1719
528
                    }
1720
529
                    break;
1721
530
                case INVERSE_CHAMFER:
1722
531
                    {
1723
532
                        Geom::Path path_chamfer;
1724
533
                        path_chamfer.start(tmp_path.finalPoint());
1725
534
                        if (eliptical) {
1726
535
                            path_chamfer.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
1727
536
                        } else {
1728
537
                            path_chamfer.appendNew<Geom::CubicBezier>(inverse_handle_1, inverse_handle_2, end_arc_point);
1729
538
                        }
1730
539
                        addChamferSteps(tmp_path, path_chamfer, end_arc_point, steps);
1731
540
                    }
1732
541
                    break;
1733
542
                case INVERSE_FILLET:
1734
543
                    {
1735
544
                        if (eliptical) {
1736
545
                            tmp_path.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
1737
546
                        } else {
1738
547
                            tmp_path.appendNew<Geom::CubicBezier>(inverse_handle_1, inverse_handle_2, end_arc_point);
1739
548
                        }
1740
549
                    }
1741
550
                    break;
1742
551
                default: //fillet
1743
552
                    {
1744
553
                        if (eliptical) {
1745
554
                            ccw_toggle = ccw_toggle ? 0 : 1;
1746
555
                            tmp_path.appendNew<Geom::EllipticalArc>(rx, ry, arc_angle, 0, ccw_toggle, end_arc_point);
1747
556
                        } else {
1748
557
                            tmp_path.appendNew<Geom::CubicBezier>(handle_1, handle_2, end_arc_point);
1749
558
                        }
1750
559
                    }
1751
560
                    break;
1752
561
                }
1753
562
            } else {
1754
563
                if (!knot_curve_1->isDegenerate()) {
1755
564
                    tmp_path.append(*knot_curve_1);
1756
565
                }
1757
566
            }
1758
567
            curve++;
1759
568
            time0 = time2;
1760
569
        }
1761
515
        if (path_it->closed()) {
570
        if (path_it->closed()) {
1898
516
          const Geom::Curve &closingline = path_it->back_closed(); 
571
            tmp_path.close();
1899
517
          // the closing line segment is always of type 
572
        }
1900
518
          // Geom::LineSegment.
573
        path++;
1901
519
          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
574
        path_out.push_back(tmp_path);
1766
520
            // closingline.isDegenerate() did not work, because it only checks for
1767
521
            // *exact* zero length, which goes wrong for relative coordinates and
1768
522
            // rounding errors...
1769
523
            // the closing line segment has zero-length. So stop before that one!
1770
524
            curve_endit = path_it->end_open();
1771
525
          }
1772
526
        }
1773
527
        unsigned int counterCurves = 0;
1774
528
        while (curve_it1 != curve_endit) {
1775
529
            Curve *curve_it2Fixed = (*path_it->begin()).duplicate();
1776
530
            if(!path_it->closed() || curve_it2 != curve_endit){
1777
531
                curve_it2Fixed = (*curve_it2).duplicate();
1778
532
            }
1779
533
            bool last = curve_it2 == curve_endit;
1780
534
            std::vector<double> times = fillet_chamfer_values.get_times(counter, path_in, last);
1781
535
            Curve *knotCurve1 = curve_it1->portion(times[0], times[1]);
1782
536
            if (counterCurves > 0) {
1783
537
                knotCurve1->setInitial(path_out.finalPoint());
1784
538
            } else {
1785
539
                path_out.start((*curve_it1).pointAt(times[0]));
1786
540
            }
1787
541
            Curve *knotCurve2 = curve_it2Fixed->portion(times[2], 1);
1788
542
            Point startArcPoint = knotCurve1->finalPoint();
1789
543
            Point endArcPoint = curve_it2Fixed->pointAt(times[2]);
1790
544
            double k1 = distance(startArcPoint, curve_it1->finalPoint()) * K;
1791
545
            double k2 = distance(endArcPoint, curve_it1->finalPoint()) * K;
1792
546
            Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(&*knotCurve1);
1793
547
            Ray ray1(startArcPoint, curve_it1->finalPoint());
1794
548
            if (cubic1) {
1795
549
                ray1.setPoints((*cubic1)[2], startArcPoint);
1796
550
            }
1797
551
            Point handle1 =  Point::polar(ray1.angle(),k1) + startArcPoint;
1798
552
            Geom::CubicBezier const *cubic2 =
1799
553
                dynamic_cast<Geom::CubicBezier const *>(&*knotCurve2);
1800
554
            Ray ray2(curve_it1->finalPoint(), endArcPoint);
1801
555
            if (cubic2) {
1802
556
                ray2.setPoints(endArcPoint, (*cubic2)[1]);
1803
557
            }
1804
558
            Point handle2 = endArcPoint - Point::polar(ray2.angle(),k2);
1805
559
            bool ccwToggle = cross(curve_it1->finalPoint() - startArcPoint, endArcPoint - startArcPoint) > 0;
1806
560
            double angle = angle_between(ray1, ray2, ccwToggle);
1807
561
            double handleAngle = ray1.angle() - angle;
1808
562
            if (ccwToggle) {
1809
563
                handleAngle = ray1.angle() + angle;
1810
564
            }
1811
565
            Point inverseHandle1 = Point::polar(handleAngle,k1) + startArcPoint;
1812
566
            handleAngle = ray2.angle() + angle;
1813
567
            if (ccwToggle) {
1814
568
                handleAngle = ray2.angle() - angle;
1815
569
            }
1816
570
            Point inverseHandle2 = endArcPoint - Point::polar(handleAngle,k2);
1817
571
            //straigth lines arc based
1818
572
            Line const x_line(Geom::Point(0,0),Geom::Point(1,0));
1819
573
            Line const angled_line(startArcPoint,endArcPoint);
1820
574
            double angleArc = Geom::angle_between( x_line,angled_line);
1821
575
            double radius = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint))/sin(angle/2.0);
1822
576
            Coord rx = radius;
1823
577
            Coord ry = rx;
1824
578
            
1825
579
            if (times[1] != 1) {
1826
580
                if (times[1] != gapHelper && times[1] != times[0] + gapHelper) {
1827
581
                    path_out.append(*knotCurve1);
1828
582
                }
1829
583
                int type = 0;
1830
584
                if(path_it->closed() && last){
1831
585
                    type = std::abs(filletChamferData[counter - counterCurves][Y]);
1832
586
                } else if (!path_it->closed() && last){
1833
587
                    //0
1834
588
                } else {
1835
589
                    type = std::abs(filletChamferData[counter + 1][Y]);
1836
590
                }
1837
591
                if(are_near(middle_point(startArcPoint,endArcPoint),curve_it1->finalPoint(), 0.0001)){
1838
592
                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
1839
593
                } else if (type >= 3000 && type < 4000) {
1840
594
                    unsigned int chamferSubs = type-3000;
1841
595
                    Geom::Path path_chamfer;
1842
596
                    path_chamfer.start(path_out.finalPoint());
1843
597
                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
1844
598
                        path_chamfer.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
1845
599
                    } else {
1846
600
                        path_chamfer.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
1847
601
                    }
1848
602
                    double chamfer_stepsTime = 1.0/chamferSubs;
1849
603
                    for(unsigned int i = 1; i < chamferSubs; i++){
1850
604
                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
1851
605
                        path_out.appendNew<Geom::LineSegment>(chamferStep);
1852
606
                    }
1853
607
                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
1854
608
                } else if (type >= 4000 && type < 5000) {
1855
609
                    unsigned int chamferSubs = type-4000;
1856
610
                    Geom::Path path_chamfer;
1857
611
                    path_chamfer.start(path_out.finalPoint());
1858
612
                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
1859
613
                        ccwToggle = ccwToggle?0:1;
1860
614
                        path_chamfer.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
1861
615
                    }else{
1862
616
                        path_chamfer.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
1863
617
                    }
1864
618
                    double chamfer_stepsTime = 1.0/chamferSubs;
1865
619
                    for(unsigned int i = 1; i < chamferSubs; i++){
1866
620
                        Geom::Point chamferStep = path_chamfer.pointAt(chamfer_stepsTime * i);
1867
621
                        path_out.appendNew<Geom::LineSegment>(chamferStep);
1868
622
                    }
1869
623
                    path_out.appendNew<Geom::LineSegment>(endArcPoint);
1870
624
                } else if (type == 2) {
1871
625
                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
1872
626
                        ccwToggle = ccwToggle?0:1;
1873
627
                        path_out.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
1874
628
                    }else{
1875
629
                        path_out.appendNew<Geom::CubicBezier>(inverseHandle1, inverseHandle2, endArcPoint);
1876
630
                    }
1877
631
                } else if (type == 1){
1878
632
                    if((is_straight_curve(*curve_it1) && is_straight_curve(*curve_it2Fixed) && method != FM_BEZIER )|| method == FM_ARC){ 
1879
633
                        path_out.appendNew<EllipticalArc>(rx, ry, angleArc, 0, ccwToggle, endArcPoint);
1880
634
                    } else {
1881
635
                        path_out.appendNew<Geom::CubicBezier>(handle1, handle2, endArcPoint);
1882
636
                    }
1883
637
                }
1884
638
            } else {
1885
639
                path_out.append(*knotCurve1);
1886
640
            }
1887
641
            if (path_it->closed() && last) {
1888
642
                path_out.close();
1889
643
            }
1890
644
            ++curve_it1;
1891
645
            if (curve_it2 != curve_endit) {
1892
646
                ++curve_it2;
1893
647
            }
1894
648
            counter++;
1895
649
            counterCurves++;
1896
650
        }
1897
651
        pathvector_out.push_back(path_out);
1902
652
    }
575
    }
1904
653
    return pathvector_out;
576
    return path_out;
1905
654
}
577
}
1906
655
578
1907
656
}; //namespace LivePathEffect
579
}; //namespace LivePathEffect
1908
657
580
1909
=== modified file 'src/live_effects/lpe-fillet-chamfer.h'
1910
--- src/live_effects/lpe-fillet-chamfer.h	2015-07-24 18:50:50 +0000
1911
+++ src/live_effects/lpe-fillet-chamfer.h	2017-05-06 17:46:29 +0000
1912
@@ -7,25 +7,22 @@
1913
7
 *
7
 *
1914
8
 * Copyright (C) 2014 Author(s)
8
 * Copyright (C) 2014 Author(s)
1915
9
 *
9
 *
1920
10
 * Special thanks to Johan Engelen for the base of the effect -powerstroke-
10
 * Jabiertxof:Thanks to all people help me
1917
11
 * Also to ScislaC for point me to the idea
1918
12
 * Also su_v for his construvtive feedback and time
1919
13
 * and finaly to Liam P. White for his big help on coding, that save me a lot of hours
1921
14
 *
11
 *
1922
15
 * Released under GNU GPL, read the file 'COPYING' for more information
12
 * Released under GNU GPL, read the file 'COPYING' for more information
1923
16
 */
13
 */
1924
17
14
1925
18
#include "live_effects/parameter/enum.h"
15
#include "live_effects/parameter/enum.h"
1927
19
#include "live_effects/parameter/bool.h"
16
#include "live_effects/parameter/satellitesarray.h"
1928
17
#include "live_effects/effect.h"
1929
20
#include "live_effects/parameter/unit.h"
18
#include "live_effects/parameter/unit.h"
1933
21
19
#include "helper/geom-pathvectorsatellites.h"
1934
22
#include "live_effects/parameter/filletchamferpointarray.h"
20
#include "helper/geom-satellite.h"
1932
23
#include "live_effects/effect.h"
1935
24
21
1936
25
namespace Inkscape {
22
namespace Inkscape {
1937
26
namespace LivePathEffect {
23
namespace LivePathEffect {
1938
27
24
1940
28
enum FilletMethod {
25
enum Filletmethod {
1941
29
    FM_AUTO,
26
    FM_AUTO,
1942
30
    FM_ARC,
27
    FM_ARC,
1943
31
    FM_BEZIER,
28
    FM_BEZIER,
1944
@@ -35,41 +32,38 @@
1945
35
class LPEFilletChamfer : public Effect {
32
class LPEFilletChamfer : public Effect {
1946
36
public:
33
public:
1947
37
    LPEFilletChamfer(LivePathEffectObject *lpeobject);
34
    LPEFilletChamfer(LivePathEffectObject *lpeobject);
1950
38
    virtual ~LPEFilletChamfer();
35
    virtual void doBeforeEffect(SPLPEItem const *lpeItem);
1949
39
1951
40
    virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
36
    virtual Geom::PathVector doEffect_path(Geom::PathVector const &path_in);
1952
41
1953
42
    virtual void doOnApply(SPLPEItem const *lpeItem);
37
    virtual void doOnApply(SPLPEItem const *lpeItem);
1969
43
    virtual void doBeforeEffect(SPLPEItem const *lpeItem);
38
    virtual Gtk::Widget *newWidget();
1970
44
    virtual void adjustForNewPath(Geom::PathVector const &path_in);
39
    Geom::Ray getRay(Geom::Point start, Geom::Point end, Geom::Curve *curve, bool reverse);
1971
45
    virtual Gtk::Widget* newWidget();
40
    void addChamferSteps(Geom::Path &tmp_path, Geom::Path path_chamfer, Geom::Point end_arc_point, size_t steps);
1972
46
41
    void addCanvasIndicators(SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec);
1973
47
    int getKnotsNumber(SPCurve const *c);
42
    void updateSatelliteType(SatelliteType satellitetype);
1974
48
    void toggleHide();
43
    void setSelected(PathVectorSatellites *_pathvector_satellites);
1975
49
    void toggleFlexFixed();
44
    //void convertUnit();
1976
50
    void chamfer();
45
    void updateChamferSteps();
1977
51
    void chamferSubdivisions();
46
    void updateAmount();
1963
52
    void inverseChamfer();
1964
53
    void fillet();
1965
54
    void inverseFillet();
1966
55
    void updateFillet();
1967
56
    void doUpdateFillet(Geom::PathVector const& original_pathv, double power);
1968
57
    void doChangeType(Geom::PathVector const& original_pathv, int type);
1978
58
    void refreshKnots();
47
    void refreshKnots();
1979
59
48
1981
60
    FilletChamferPointArrayParam fillet_chamfer_values;
49
    SatellitesArrayParam satellites_param;
1982
61
50
1983
62
private:
51
private:
1987
63
52
    UnitParam unit;
1988
64
    BoolParam hide_knots;
53
    EnumParam<Filletmethod> method;
1989
65
    BoolParam ignore_radius_0;
54
    ScalarParam radius;
1990
55
    ScalarParam chamfer_steps;
1991
56
    BoolParam flexible;
1992
57
    BoolParam mirror_knots;
1993
66
    BoolParam only_selected;
58
    BoolParam only_selected;
1994
67
    BoolParam flexible;
1995
68
    BoolParam use_knot_distance;
59
    BoolParam use_knot_distance;
1999
69
    EnumParam<FilletMethod> method;
60
    BoolParam hide_knots;
2000
70
    ScalarParam radius;
61
    BoolParam apply_no_radius;
2001
71
    ScalarParam chamfer_steps;
62
    BoolParam apply_with_radius;
2002
72
    ScalarParam helper_size;
63
    ScalarParam helper_size;
2003
64
    bool _degenerate_hide;
2004
65
    PathVectorSatellites *_pathvector_satellites;
2005
66
    Geom::PathVector _hp;
2006
73
67
2007
74
    LPEFilletChamfer(const LPEFilletChamfer &);
68
    LPEFilletChamfer(const LPEFilletChamfer &);
2008
75
    LPEFilletChamfer &operator=(const LPEFilletChamfer &);
69
    LPEFilletChamfer &operator=(const LPEFilletChamfer &);
2009
76
70
2010
=== modified file 'src/live_effects/parameter/array.cpp'
2011
--- src/live_effects/parameter/array.cpp	2014-03-27 01:33:44 +0000
2012
+++ src/live_effects/parameter/array.cpp	2017-05-06 17:46:29 +0000
2013
@@ -5,10 +5,7 @@
2014
5
 */
5
 */
2015
6
6
2016
7
#include "live_effects/parameter/array.h"
7
#include "live_effects/parameter/array.h"
2021
8
8
#include "helper-fns.h"
2018
9
#include "svg/svg.h"
2019
10
#include "svg/stringstream.h"
2020
11
2022
12
#include <2geom/coord.h>
9
#include <2geom/coord.h>
2023
13
#include <2geom/point.h>
10
#include <2geom/point.h>
2024
14
11
2025
@@ -49,6 +46,45 @@
2026
49
    return Geom::Point(Geom::infinity(),Geom::infinity());
46
    return Geom::Point(Geom::infinity(),Geom::infinity());
2027
50
}
47
}
2028
51
48
2029
49
2030
50
template <>
2031
51
std::vector<Satellite>
2032
52
ArrayParam<std::vector<Satellite > >::readsvg(const gchar * str)
2033
53
{
2034
54
    std::vector<Satellite> subpath_satellites;
2035
55
    if (!str) {
2036
56
        return subpath_satellites;
2037
57
    }
2038
58
    gchar ** strarray = g_strsplit(str, "@", 0);
2039
59
    gchar ** iter = strarray;
2040
60
    while (*iter != NULL) {
2041
61
        gchar ** strsubarray = g_strsplit(*iter, ",", 8);
2042
62
        if (*strsubarray[7]) {//steps always > 0
2043
63
            Satellite *satellite = new Satellite();
2044
64
            satellite->setSatelliteType(g_strstrip(strsubarray[0]));
2045
65
            satellite->is_time = strncmp(strsubarray[1],"1",1) == 0;
2046
66
            satellite->selected = strncmp(strsubarray[2],"1",1) == 0;
2047
67
            satellite->has_mirror = strncmp(strsubarray[3],"1",1) == 0;
2048
68
            satellite->hidden = strncmp(strsubarray[4],"1",1) == 0;
2049
69
            double amount,angle;
2050
70
            float stepsTmp;
2051
71
            sp_svg_number_read_d(strsubarray[5], &amount);
2052
72
            sp_svg_number_read_d(strsubarray[6], &angle);
2053
73
            sp_svg_number_read_f(g_strstrip(strsubarray[7]), &stepsTmp);
2054
74
            unsigned int steps = (unsigned int)stepsTmp;
2055
75
            satellite->amount = amount;
2056
76
            satellite->angle = angle;
2057
77
            satellite->steps = steps;
2058
78
            subpath_satellites.push_back(*satellite);
2059
79
        }
2060
80
        g_strfreev (strsubarray);
2061
81
        iter++;
2062
82
    }
2063
83
    g_strfreev (strarray);
2064
84
    return subpath_satellites;
2065
85
}
2066
86
2067
87
2068
52
} /* namespace LivePathEffect */
88
} /* namespace LivePathEffect */
2069
53
89
2070
54
} /* namespace Inkscape */
90
} /* namespace Inkscape */
2071
55
91
2072
=== modified file 'src/live_effects/parameter/array.h'
2073
--- src/live_effects/parameter/array.h	2017-04-29 00:01:22 +0000
2074
+++ src/live_effects/parameter/array.h	2017-05-06 17:46:29 +0000
2075
@@ -15,6 +15,7 @@
2076
15
15
2077
16
#include "live_effects/parameter/parameter.h"
16
#include "live_effects/parameter/parameter.h"
2078
17
17
2079
18
#include "helper/geom-satellite.h"
2080
18
#include "svg/svg.h"
19
#include "svg/svg.h"
2081
19
#include "svg/stringstream.h"
20
#include "svg/stringstream.h"
2082
20
21
2083
@@ -93,7 +94,43 @@
2084
93
                // separate items with pipe symbol
94
                // separate items with pipe symbol
2085
94
                str << " | ";
95
                str << " | ";
2086
95
            }
96
            }
2088
96
            str << vector[i];
97
            writesvgData(str,vector[i]);
2089
98
        }
2090
99
    }
2091
100
    
2092
101
    void writesvgData(SVGOStringStream &str, float const &vector_data) const {
2093
102
        str << vector_data;
2094
103
    }
2095
104
2096
105
    void writesvgData(SVGOStringStream &str, double const &vector_data) const {
2097
106
        str << vector_data;
2098
107
    }
2099
108
2100
109
    void writesvgData(SVGOStringStream &str, Geom::Point const &vector_data) const {
2101
110
        str << vector_data;
2102
111
    }
2103
112
2104
113
    void writesvgData(SVGOStringStream &str, std::vector<Satellite> const &vector_data) const {
2105
114
        for (size_t i = 0; i < vector_data.size(); ++i) {
2106
115
            if (i != 0) {
2107
116
                // separate items with @ symbol ¿Any other?
2108
117
                str << " @ ";
2109
118
            }
2110
119
            str << vector_data[i].getSatelliteTypeGchar();
2111
120
            str << ",";
2112
121
            str << vector_data[i].is_time;
2113
122
            str << ",";
2114
123
            str << vector_data[i].selected;
2115
124
            str << ",";
2116
125
            str << vector_data[i].has_mirror;
2117
126
            str << ",";
2118
127
            str << vector_data[i].hidden;
2119
128
            str << ",";
2120
129
            str << vector_data[i].amount;
2121
130
            str << ",";
2122
131
            str << vector_data[i].angle;
2123
132
            str << ",";
2124
133
            str << vector_data[i].steps;
2125
97
        }
134
        }
2126
98
    }
135
    }
2127
99
136
2128
100
137
2129
=== removed file 'src/live_effects/parameter/filletchamferpointarray.cpp'
2130
--- src/live_effects/parameter/filletchamferpointarray.cpp	2016-12-19 20:54:42 +0000
2131
+++ src/live_effects/parameter/filletchamferpointarray.cpp	1970-01-01 00:00:00 +0000
2132
@@ -1,873 +0,0 @@
2133
1
/*
2134
2
 * Copyright (C) Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
2135
3
 * Special thanks to Johan Engelen for the base of the effect -powerstroke-
2136
4
 * Also to ScislaC for point me to the idea
2137
5
 * Also su_v for his construvtive feedback and time
2138
6
 * and finaly to Liam P. White for his big help on coding, that save me a lot of
2139
7
 * hours
2140
8
 * Released under GNU GPL, read the file 'COPYING' for more information
2141
9
 */
2142
10
2143
11
#include <2geom/piecewise.h>
2144
12
#include <2geom/sbasis-to-bezier.h>
2145
13
#include <2geom/sbasis-geometric.h>
2146
14
#include <2geom/line.h>
2147
15
#include <2geom/path-intersection.h>
2148
16
2149
17
#include "ui/dialog/lpe-fillet-chamfer-properties.h"
2150
18
#include "live_effects/parameter/filletchamferpointarray.h"
2151
19
#include "live_effects/effect.h"
2152
20
#include "svg/svg.h"
2153
21
#include "svg/stringstream.h"
2154
22
#include "knotholder.h"
2155
23
#include "sp-lpe-item.h"
2156
24
#include "selection.h"
2157
25
2158
26
// needed for on-canvas editting:
2159
27
#include "live_effects/lpeobject.h"
2160
28
#include "helper/geom-nodetype.h"
2161
29
#include "helper/geom-curves.h"
2162
30
#include "ui/tools/node-tool.h"
2163
31
2164
32
// TODO due to internal breakage in glibmm headers,
2165
33
// this has to be included last.
2166
34
#include <glibmm/i18n.h>
2167
35
2168
36
2169
37
using namespace Geom;
2170
38
2171
39
namespace Inkscape {
2172
40
2173
41
namespace LivePathEffect {
2174
42
2175
43
FilletChamferPointArrayParam::FilletChamferPointArrayParam(
2176
44
    const Glib::ustring &label, const Glib::ustring &tip,
2177
45
    const Glib::ustring &key, Inkscape::UI::Widget::Registry *wr,
2178
46
    Effect *effect)
2179
47
    : ArrayParam<Point>(label, tip, key, wr, effect, 0)
2180
48
{
2181
49
    knot_shape = SP_KNOT_SHAPE_DIAMOND;
2182
50
    knot_mode = SP_KNOT_MODE_XOR;
2183
51
    knot_color = 0x00ff0000;
2184
52
}
2185
53
2186
54
FilletChamferPointArrayParam::~FilletChamferPointArrayParam() {}
2187
55
2188
56
Gtk::Widget *FilletChamferPointArrayParam::param_newWidget()
2189
57
{
2190
58
    return NULL;
2191
59
    /*
2192
60
          Inkscape::UI::Widget::RegisteredTransformedPoint * pointwdg =
2193
61
        Gtk::manage(
2194
62
              new Inkscape::UI::Widget::RegisteredTransformedPoint(
2195
63
        param_label,
2196
64
                                                                    param_tooltip,
2197
65
                                                                    param_key,
2198
66
                                                                    *param_wr,
2199
67
                                                                    param_effect->getRepr(),
2200
68
                                                                    param_effect->getSPDoc()
2201
69
        ) );
2202
70
          // TODO: fix to get correct desktop (don't use SP_ACTIVE_DESKTOP)
2203
71
          SPDesktop *desktop = SP_ACTIVE_DESKTOP;
2204
72
          Affine transf = desktop->doc2dt();
2205
73
          pointwdg->setTransform(transf);
2206
74
          pointwdg->setValue( *this );
2207
75
          pointwdg->clearProgrammatically();
2208
76
          pointwdg->set_undo_parameters(SP_VERB_DIALOG_LIVE_PATH_EFFECT,
2209
77
        _("Change point parameter"));
2210
78
2211
79
          Gtk::HBox * hbox = Gtk::manage( new Gtk::HBox() );
2212
80
          static_cast<Gtk::HBox*>(hbox)->pack_start(*pointwdg, true, true);
2213
81
          static_cast<Gtk::HBox*>(hbox)->show_all_children();
2214
82
2215
83
          return dynamic_cast<Gtk::Widget *> (hbox);
2216
84
      */
2217
85
}
2218
86
2219
87
void
2220
88
FilletChamferPointArrayParam::param_transform_multiply(Affine const &postmul,
2221
89
        bool /*set*/)
2222
90
{
2223
91
    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
2224
92
2225
93
    if (prefs->getBool("/options/transform/rectcorners", true) &&
2226
94
            _vector[1][X] <= 0) {
2227
95
        std::vector<Geom::Point> result;
2228
96
        for (std::vector<Point>::const_iterator point_it = _vector.begin();
2229
97
                point_it != _vector.end(); ++point_it) {
2230
98
            Coord A =
2231
99
                (*point_it)[X] * ((postmul.expansionX() + postmul.expansionY()) / 2);
2232
100
            result.push_back(Point(A, (*point_it)[Y]));
2233
101
        }
2234
102
        param_set_and_write_new_value(result);
2235
103
    }
2236
104
2237
105
    //    param_set_and_write_new_value( (*this) * postmul );
2238
106
}
2239
107
2240
108
/** call this method to recalculate the controlpoints such that they stay at the
2241
109
 * same location relative to the new path. Useful after adding/deleting nodes to
2242
110
 * the path.*/
2243
111
void FilletChamferPointArrayParam::recalculate_controlpoints_for_new_pwd2(
2244
112
    Piecewise<D2<SBasis> > const &pwd2_in)
2245
113
{
2246
114
    if (!last_pwd2.empty()) {
2247
115
        PathVector const pathv =
2248
116
            path_from_piecewise(remove_short_cuts(pwd2_in, 0.1), 0.001);
2249
117
        PathVector last_pathv =
2250
118
            path_from_piecewise(remove_short_cuts(last_pwd2, 0.1), 0.001);
2251
119
        std::vector<Point> result;
2252
120
        unsigned long counter = 0;
2253
121
        unsigned long counterPaths = 0;
2254
122
        unsigned long counterCurves = 0;
2255
123
        long offset = 0;
2256
124
        long offsetPaths = 0;
2257
125
        Geom::NodeType nodetype;
2258
126
        for (PathVector::const_iterator path_it = pathv.begin();
2259
127
                path_it != pathv.end(); ++path_it) {
2260
128
            if (path_it->empty()) {
2261
129
                counterPaths++;
2262
130
                counter++;
2263
131
                continue;
2264
132
            }
2265
133
            Geom::Path::const_iterator curve_it1 = path_it->begin();
2266
134
            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
2267
135
            Geom::Path::const_iterator curve_endit = path_it->end_default();
2268
136
            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
2269
137
                const Curve &closingline = path_it->back_closed();
2270
138
                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
2271
139
                    curve_endit = path_it->end_open();
2272
140
                }
2273
141
            }
2274
142
            counterCurves = 0;
2275
143
            while (curve_it1 != curve_endit) {
2276
144
                //if start a path get node type
2277
145
                if (counterCurves == 0) {
2278
146
                    if (path_it->closed()) {
2279
147
                        if (path_it->back_closed().isDegenerate()) {
2280
148
                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
2281
149
                        } else {
2282
150
                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
2283
151
                        }
2284
152
                    } else {
2285
153
                        nodetype = NODE_NONE;
2286
154
                    }
2287
155
                } else {
2288
156
                    //check node type also whith straight lines because get_nodetype
2289
157
                    //return non cusp node in a node inserted inside a straight line
2290
158
                    //todo: if the path remove some nodes whith the result of a straight
2291
159
                    //line but with handles, the node inserted into dont fire the knot
2292
160
                    // because is not handle as cusp node by  get_nodetype function
2293
161
                    bool next_is_line = is_straight_curve(*curve_it1);
2294
162
                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
2295
163
                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
2296
164
                    if (this_is_line || next_is_line) {
2297
165
                        nodetype = NODE_CUSP;
2298
166
                    }
2299
167
                }
2300
168
                if (last_pathv.size() > pathv.size() ||
2301
169
                        (last_pathv.size() > counterPaths && 
2302
170
                        last_pathv[counterPaths].size() > counter - offset &&
2303
171
                         !are_near(curve_it1->initialPoint(),
2304
172
                                   last_pathv[counterPaths][counter - offset].initialPoint(),
2305
173
                                   0.1))) {
2306
174
                    if ( curve_it2 == curve_endit) {
2307
175
                        if (last_pathv[counterPaths].size() != pathv[counterPaths].size()) {
2308
176
                            offset = (last_pathv[counterPaths].size() - pathv[counterPaths].size()) * -1;
2309
177
                        } else {
2310
178
                            offset = 0;
2311
179
                        }
2312
180
                        offsetPaths += offset;
2313
181
                        offset = offsetPaths;
2314
182
                    } else if (counterCurves == 0 && last_pathv.size() <= pathv.size() &&
2315
183
                            counter - offset <= last_pathv[counterPaths].size() &&
2316
184
                            are_near(curve_it1->initialPoint(),
2317
185
                                     last_pathv[counterPaths].finalPoint(), 0.1) &&
2318
186
                                     !last_pathv[counterPaths].closed()) {
2319
187
                        long e = counter - offset + 1;
2320
188
                        std::vector<Point> tmp = _vector;
2321
189
                        for (unsigned long i =
2322
190
                                     last_pathv[counterPaths].size() + counter - offset;
2323
191
                                i > counterCurves - offset + 1; i--) {
2324
192
2325
193
                            if (tmp[i - 1][X] > 0) {
2326
194
                                double fractpart, intpart;
2327
195
                                fractpart = modf(tmp[i - 1][X], &intpart);
2328
196
                                _vector[e] = Point(e + fractpart, tmp[i - 1][Y]);
2329
197
                            } else {
2330
198
                                _vector[e] = Point(tmp[i - 1][X], tmp[i - 1][Y]);
2331
199
                            }
2332
200
                            e++;
2333
201
                        }
2334
202
                        //delete temp vector
2335
203
                        std::vector<Point>().swap(tmp);
2336
204
                        if (last_pathv.size() > counterPaths) {
2337
205
                            last_pathv[counterPaths] = last_pathv[counterPaths].reversed();
2338
206
                        }
2339
207
                    } else {
2340
208
                        if (last_pathv.size() > counterPaths) {
2341
209
                            if (last_pathv[counterPaths].size() <
2342
210
                                    pathv[counterPaths].size()) {
2343
211
                                offset++;
2344
212
                            } else if (last_pathv[counterPaths].size() >
2345
213
                                       pathv[counterPaths].size()) {
2346
214
                                offset--;
2347
215
                                continue;
2348
216
                            }
2349
217
                        } else {
2350
218
                            offset++;
2351
219
                        }
2352
220
                    }
2353
221
                    double xPos = 0;
2354
222
                    if (_vector[1][X] > 0) {
2355
223
                        xPos = nearest_time(curve_it1->initialPoint(), pwd2_in);
2356
224
                    }
2357
225
                    if (nodetype == NODE_CUSP) {
2358
226
                        result.push_back(Point(xPos, 1));
2359
227
                    } else {
2360
228
                        result.push_back(Point(xPos, 0));
2361
229
                    }
2362
230
                } else {
2363
231
                    double xPos = _vector[counter - offset][X];
2364
232
                    if (_vector.size() <= (unsigned)(counter - offset)) {
2365
233
                        if (_vector[1][X] > 0) {
2366
234
                            xPos = nearest_time(curve_it1->initialPoint(), pwd2_in);
2367
235
                        } else {
2368
236
                            xPos = 0;
2369
237
                        }
2370
238
                    }
2371
239
                    if (nodetype == NODE_CUSP) {
2372
240
                        double vectorY = _vector[counter - offset][Y];
2373
241
                        if (_vector.size() <= (unsigned)(counter - offset) || vectorY == 0) {
2374
242
                            vectorY = 1;
2375
243
                        }
2376
244
                        result.push_back(Point(xPos, vectorY));
2377
245
                    } else {
2378
246
                        if (_vector[1][X] < 0) {
2379
247
                            xPos = 0;
2380
248
                        }
2381
249
                        result.push_back(Point(floor(xPos), 0));
2382
250
                    }
2383
251
                }
2384
252
                ++curve_it1;
2385
253
                if (curve_it2 != curve_endit) {
2386
254
                    ++curve_it2;
2387
255
                }
2388
256
                counter++;
2389
257
                counterCurves++;
2390
258
            }
2391
259
            counterPaths++;
2392
260
        }
2393
261
        _vector = result;
2394
262
        write_to_SVG();
2395
263
    }
2396
264
}
2397
265
2398
266
void FilletChamferPointArrayParam::recalculate_knots(
2399
267
    Piecewise<D2<SBasis> > const &pwd2_in)
2400
268
{
2401
269
    bool change = false;
2402
270
    if(_vector.size() == 0){
2403
271
        return;
2404
272
    }
2405
273
    PathVector pathv = path_from_piecewise(pwd2_in, 0.001);
2406
274
    if (!pathv.empty()) {
2407
275
        std::vector<Point> result;
2408
276
        int counter = 0;
2409
277
        int counterCurves = 0;
2410
278
        Geom::NodeType nodetype;
2411
279
        for (PathVector::const_iterator path_it = pathv.begin();
2412
280
                path_it != pathv.end(); ++path_it) {
2413
281
            if (path_it->empty()) {
2414
282
                counter++;
2415
283
                continue;
2416
284
            }
2417
285
            Geom::Path::const_iterator curve_it1 = path_it->begin();
2418
286
            Geom::Path::const_iterator curve_it2 = ++(path_it->begin());
2419
287
            Geom::Path::const_iterator curve_endit = path_it->end_default();
2420
288
            if (path_it->closed() && path_it->back_closed().isDegenerate()) {
2421
289
                const Curve &closingline = path_it->back_closed();
2422
290
                if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
2423
291
                    curve_endit = path_it->end_open();
2424
292
                }
2425
293
            }
2426
294
            counterCurves = 0;
2427
295
            while (curve_it1 != curve_endit) {
2428
296
                //if start a path get node type
2429
297
                if (counterCurves == 0) {
2430
298
                    if (path_it->closed()) {
2431
299
                        if (path_it->back_closed().isDegenerate()) {
2432
300
                            nodetype = get_nodetype(path_it->back_open(), *curve_it1);
2433
301
                        } else {
2434
302
                            nodetype = get_nodetype(path_it->back_closed(), *curve_it1);
2435
303
                        }
2436
304
                    } else {
2437
305
                        nodetype = NODE_NONE;
2438
306
                    }
2439
307
                } else {
2440
308
                    bool next_is_line = is_straight_curve(*curve_it1);
2441
309
                    bool this_is_line = is_straight_curve((*path_it)[counterCurves - 1]);
2442
310
                    nodetype = get_nodetype((*path_it)[counterCurves - 1], *curve_it1);
2443
311
                    if (this_is_line || next_is_line) {
2444
312
                        nodetype = NODE_CUSP;
2445
313
                    }
2446
314
                }
2447
315
                if (nodetype == NODE_CUSP) {
2448
316
                    double vectorY = _vector[counter][Y];
2449
317
                    if (vectorY == 0) {
2450
318
                        vectorY = 1;
2451
319
                        change = true;
2452
320
                    }
2453
321
                    result.push_back(Point(_vector[counter][X], vectorY));
2454
322
                } else {
2455
323
                    double xPos = floor(_vector[counter][X]);
2456
324
                    if (_vector[1][X] < 0) {
2457
325
                        xPos = 0;
2458
326
                    }
2459
327
                    double vectorY = _vector[counter][Y];
2460
328
                    if (vectorY != 0) {
2461
329
                        change = true;
2462
330
                    }
2463
331
                    result.push_back(Point(xPos, 0));
2464
332
                }
2465
333
                ++curve_it1;
2466
334
                counter++;
2467
335
                if (curve_it2 != curve_endit) {
2468
336
                    ++curve_it2;
2469
337
                }
2470
338
                counterCurves++;
2471
339
            }
2472
340
        }
2473
341
        if (change) {
2474
342
            _vector = result;
2475
343
            write_to_SVG();
2476
344
        }
2477
345
    }
2478
346
}
2479
347
2480
348
void FilletChamferPointArrayParam::set_pwd2(
2481
349
    Piecewise<D2<SBasis> > const &pwd2_in,
2482
350
    Piecewise<D2<SBasis> > const &pwd2_normal_in)
2483
351
{
2484
352
    last_pwd2 = pwd2_in;
2485
353
    last_pwd2_normal = pwd2_normal_in;
2486
354
}
2487
355
2488
356
void FilletChamferPointArrayParam::set_helper_size(int hs)
2489
357
{
2490
358
    helper_size = hs;
2491
359
}
2492
360
2493
361
void FilletChamferPointArrayParam::set_chamfer_steps(int value_chamfer_steps)
2494
362
{
2495
363
    chamfer_steps = value_chamfer_steps;
2496
364
}
2497
365
2498
366
void FilletChamferPointArrayParam::set_use_distance(bool use_knot_distance )
2499
367
{
2500
368
    use_distance = use_knot_distance;
2501
369
}
2502
370
2503
371
void FilletChamferPointArrayParam::updateCanvasIndicators()
2504
372
{
2505
373
    std::vector<Point> ts = data();
2506
374
    hp.clear();
2507
375
    unsigned int i = 0;
2508
376
    for (std::vector<Point>::const_iterator point_it = ts.begin();
2509
377
            point_it != ts.end(); ++point_it) {
2510
378
        double Xvalue = to_time(i, (*point_it)[X]) -i;
2511
379
        if (Xvalue == 0) {
2512
380
            i++;
2513
381
            continue;
2514
382
        }
2515
383
        Geom::Point ptA = last_pwd2[i].valueAt(Xvalue);
2516
384
        Geom::Point derivA = unit_vector(derivative(last_pwd2[i]).valueAt(Xvalue));
2517
385
        Geom::Rotate rot(Geom::Rotate::from_degrees(-90));
2518
386
        derivA = derivA * rot;
2519
387
        Geom::Point C = ptA - derivA * helper_size;
2520
388
        Geom::Point D = ptA + derivA * helper_size;
2521
389
        Geom::Ray ray1(C, D);
2522
390
        char const * svgd = "M 1,0.25 0.5,0 1,-0.25 M 1,0.5 0,0 1,-0.5";
2523
391
        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
2524
392
        Geom::Affine aff = Geom::Affine();
2525
393
        aff *= Geom::Scale(helper_size);
2526
394
        aff *= Geom::Rotate(ray1.angle() - rad_from_deg(270));
2527
395
        aff *= Geom::Translate(last_pwd2[i].valueAt(Xvalue));
2528
396
        pathv *= aff;
2529
397
        hp.push_back(pathv[0]);
2530
398
        hp.push_back(pathv[1]);
2531
399
        i++;
2532
400
    }
2533
401
}
2534
402
2535
403
void FilletChamferPointArrayParam::addCanvasIndicators(
2536
404
    SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
2537
405
{
2538
406
    hp_vec.push_back(hp);
2539
407
}
2540
408
2541
409
double FilletChamferPointArrayParam::rad_to_len(int index, double rad)
2542
410
{
2543
411
    double len = 0;
2544
412
    Geom::PathVector subpaths = path_from_piecewise(last_pwd2, 0.1);
2545
413
    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
2546
414
    D2<SBasis> A = last_pwd2[last_index(index, subpaths)];
2547
415
    if(positions.second != 0){
2548
416
        A = last_pwd2[index-1];
2549
417
    }else{
2550
418
        if(!subpaths[positions.first].closed()){
2551
419
            return len;
2552
420
        }
2553
421
    }
2554
422
    D2<SBasis> B = last_pwd2[index];
2555
423
    Piecewise<D2<SBasis> > offset_curve0 = Piecewise<D2<SBasis> >(A)+rot90(unitVector(derivative(A)))*(rad);
2556
424
    Piecewise<D2<SBasis> > offset_curve1 = Piecewise<D2<SBasis> >(B)+rot90(unitVector(derivative(B)))*(rad);
2557
425
    Geom::Path p0 = path_from_piecewise(offset_curve0, 0.1)[0];
2558
426
    Geom::Path p1 = path_from_piecewise(offset_curve1, 0.1)[0];
2559
427
    Geom::Crossings cs = Geom::crossings(p0, p1);
2560
428
    if(cs.size() > 0){
2561
429
        Point cp =p0(cs[0].ta);
2562
430
        double p0pt = nearest_time(cp, B);
2563
431
        len = time_to_len(index,p0pt);
2564
432
    } else {
2565
433
        if(rad < 0){
2566
434
            len = rad_to_len(index, rad * -1);
2567
435
        }
2568
436
    }
2569
437
    return len;
2570
438
}
2571
439
2572
440
double FilletChamferPointArrayParam::len_to_rad(int index, double len)
2573
441
{
2574
442
    double rad = 0;
2575
443
    double tmp_len = _vector[index][X];
2576
444
    _vector[index] = Geom::Point(len,_vector[index][Y]);
2577
445
    Geom::PathVector subpaths = path_from_piecewise(last_pwd2, 0.1);
2578
446
    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
2579
447
    Piecewise<D2<SBasis> > u;
2580
448
    u.push_cut(0);          
2581
449
    u.push(last_pwd2[last_index(index, subpaths)], 1);
2582
450
    Geom::Curve * A = path_from_piecewise(u, 0.1)[0][0].duplicate();
2583
451
    Geom::Curve * B = subpaths[positions.first][positions.second].duplicate();
2584
452
    std::vector<double> times;
2585
453
    if(positions.second != 0){
2586
454
        A = subpaths[positions.first][positions.second-1].duplicate();
2587
455
        times = get_times(index-1, subpaths, false);
2588
456
    }else{
2589
457
        if(!subpaths[positions.first].closed()){
2590
458
            return rad;
2591
459
        }
2592
460
        times = get_times(last_index(index, subpaths), subpaths, true);
2593
461
    }
2594
462
    _vector[index] = Geom::Point(tmp_len,_vector[index][Y]);
2595
463
    Geom::Point startArcPoint = A->toSBasis().valueAt(times[1]);
2596
464
    Geom::Point endArcPoint = B->toSBasis().valueAt(times[2]);
2597
465
    Curve *knotCurve1 = A->portion(times[0], times[1]);
2598
466
    Curve *knotCurve2 = B->portion(times[2], 1);
2599
467
    Geom::CubicBezier const *cubic1 = dynamic_cast<Geom::CubicBezier const *>(knotCurve1);
2600
468
    Ray ray1(startArcPoint, A->finalPoint());
2601
469
    if (cubic1) {
2602
470
        ray1.setPoints((*cubic1)[2], startArcPoint);
2603
471
    }
2604
472
    Geom::CubicBezier const *cubic2 = dynamic_cast<Geom::CubicBezier const *>(knotCurve2);
2605
473
    Ray ray2(B->initialPoint(), endArcPoint);
2606
474
    if (cubic2) {
2607
475
        ray2.setPoints(endArcPoint, (*cubic2)[1]);
2608
476
    }
2609
477
    bool ccwToggle = cross(A->finalPoint() - startArcPoint, endArcPoint - startArcPoint) > 0;
2610
478
    double distanceArc = Geom::distance(startArcPoint,middle_point(startArcPoint,endArcPoint));
2611
479
    double angleBetween = angle_between(ray1, ray2, ccwToggle);
2612
480
    rad = distanceArc/sin(angleBetween/2.0);
2613
481
    return rad * -1;
2614
482
}
2615
483
2616
484
std::vector<double> FilletChamferPointArrayParam::get_times(int index, Geom::PathVector subpaths, bool last)
2617
485
{
2618
486
    const double tolerance = 0.001;
2619
487
    const double gapHelper = 0.00001;
2620
488
    std::pair<std::size_t, std::size_t> positions = get_positions(index, subpaths);
2621
489
    Curve *curve_it1;
2622
490
    curve_it1 = subpaths[positions.first][positions.second].duplicate();
2623
491
    Coord it1_length = (*curve_it1).length(tolerance);
2624
492
    double time_it1, time_it2, time_it1_B, intpart;
2625
493
    if (static_cast<int>(_vector.size()) <= index){
2626
494
        std::vector<double> out;
2627
495
        out.push_back(0);
2628
496
        out.push_back(1);
2629
497
        out.push_back(0);
2630
498
        return out;
2631
499
    }
2632
500
    time_it1 = modf(to_time(index, _vector[index][X]), &intpart);
2633
501
    if (_vector[index][Y] == 0) {
2634
502
        time_it1 = 0;
2635
503
    }
2636
504
    double resultLenght = 0;
2637
505
    if (subpaths[positions.first].closed() && last) {
2638
506
        time_it2 = modf(to_time(index - positions.second , _vector[index - positions.second ][X]), &intpart);
2639
507
        resultLenght = it1_length + to_len(index - positions.second, _vector[index - positions.second ][X]);
2640
508
    } else if (!subpaths[positions.first].closed() && last){
2641
509
        time_it2 = 0;
2642
510
        resultLenght = 0;
2643
511
    } else {
2644
512
        time_it2 = modf(to_time(index + 1, _vector[index + 1][X]), &intpart);
2645
513
        resultLenght = it1_length + to_len( index + 1, _vector[index + 1][X]);
2646
514
    }
2647
515
    if (resultLenght > 0 && time_it2 != 0) {
2648
516
        time_it1_B = modf(to_time(index, -resultLenght), &intpart);
2649
517
    } else {
2650
518
        if (time_it2 == 0) {
2651
519
            time_it1_B = 1;
2652
520
        } else {
2653
521
            time_it1_B = gapHelper;
2654
522
        }
2655
523
    }
2656
524
2657
525
    if ((subpaths[positions.first].closed() && last && _vector[index - positions.second][Y] == 0) || (subpaths[positions.first].size() > positions.second + 1 && _vector[index + 1][Y] == 0)) {
2658
526
        time_it1_B = 1;
2659
527
        time_it2 = 0;
2660
528
    }
2661
529
    if (time_it1_B < time_it1) {
2662
530
        time_it1_B = time_it1 + gapHelper;
2663
531
    }
2664
532
    std::vector<double> out;
2665
533
    out.push_back(time_it1);
2666
534
    out.push_back(time_it1_B);
2667
535
    out.push_back(time_it2);
2668
536
    return out;
2669
537
}
2670
538
2671
539
std::pair<std::size_t, std::size_t> FilletChamferPointArrayParam::get_positions(int index, Geom::PathVector subpaths)
2672
540
{
2673
541
    int counter = -1;
2674
542
    std::size_t first = 0;
2675
543
    std::size_t second = 0;
2676
544
    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
2677
545
        if (path_it->empty())
2678
546
            continue;
2679
547
        Geom::Path::const_iterator curve_it1 = path_it->begin();
2680
548
        Geom::Path::const_iterator curve_endit = path_it->end_default();
2681
549
        if (path_it->closed()) {
2682
550
          const Geom::Curve &closingline = path_it->back_closed(); 
2683
551
          // the closing line segment is always of type 
2684
552
          // Geom::LineSegment.
2685
553
          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
2686
554
            // closingline.isDegenerate() did not work, because it only checks for
2687
555
            // *exact* zero length, which goes wrong for relative coordinates and
2688
556
            // rounding errors...
2689
557
            // the closing line segment has zero-length. So stop before that one!
2690
558
            curve_endit = path_it->end_open();
2691
559
          }
2692
560
        }
2693
561
        first++;
2694
562
        second = 0;
2695
563
        while (curve_it1 != curve_endit) {
2696
564
            counter++;
2697
565
            second++;
2698
566
            if(counter == index){
2699
567
                break;
2700
568
            }
2701
569
            ++curve_it1;
2702
570
        }
2703
571
        if(counter == index){
2704
572
            break;
2705
573
        }
2706
574
    }
2707
575
    first--;
2708
576
    second--;
2709
577
    std::pair<std::size_t, std::size_t> out(first, second);
2710
578
    return out;
2711
579
}
2712
580
2713
581
int FilletChamferPointArrayParam::last_index(int index, Geom::PathVector subpaths)
2714
582
{
2715
583
    int counter = -1;
2716
584
    bool inSubpath = false;
2717
585
    for (PathVector::const_iterator path_it = subpaths.begin(); path_it != subpaths.end(); ++path_it) {
2718
586
        if (path_it->empty())
2719
587
            continue;
2720
588
        Geom::Path::const_iterator curve_it1 = path_it->begin();
2721
589
        Geom::Path::const_iterator curve_endit = path_it->end_default();
2722
590
        if (path_it->closed()) {
2723
591
          const Geom::Curve &closingline = path_it->back_closed(); 
2724
592
          if (are_near(closingline.initialPoint(), closingline.finalPoint())) {
2725
593
            curve_endit = path_it->end_open();
2726
594
          }
2727
595
        }
2728
596
        while (curve_it1 != curve_endit) {
2729
597
            counter++;
2730
598
            if(counter == index){
2731
599
                inSubpath = true;
2732
600
            }
2733
601
            ++curve_it1;
2734
602
        }
2735
603
        if(inSubpath){
2736
604
            break;
2737
605
        }
2738
606
    }
2739
607
    if(!inSubpath){
2740
608
        counter = -1;
2741
609
    }
2742
610
    return counter;
2743
611
}
2744
612
2745
613
2746
614
double FilletChamferPointArrayParam::len_to_time(int index, double len)
2747
615
{
2748
616
    double t = 0;
2749
617
    if (last_pwd2.size() > (unsigned) index) {
2750
618
        if (len != 0) {
2751
619
            if (last_pwd2[index][0].degreesOfFreedom() != 2) {
2752
620
                Piecewise<D2<SBasis> > u;
2753
621
                u.push_cut(0);          
2754
622
                u.push(last_pwd2[index], 1);
2755
623
                std::vector<double> t_roots = roots(arcLengthSb(u) - std::abs(len));
2756
624
                if (t_roots.size() > 0) {
2757
625
                    t = t_roots[0];
2758
626
                }
2759
627
            } else {
2760
628
                double lenghtPart = 0;
2761
629
                if (last_pwd2.size() > (unsigned) index) {
2762
630
                    lenghtPart = length(last_pwd2[index], EPSILON);
2763
631
                }
2764
632
                if (std::abs(len) < lenghtPart && lenghtPart != 0) {
2765
633
                    t = std::abs(len) / lenghtPart;
2766
634
                }
2767
635
            }
2768
636
        }
2769
637
        t = double(index) + t;
2770
638
    } else {
2771
639
        t = double(last_pwd2.size() - 1);
2772
640
    }
2773
641
2774
642
    return t;
2775
643
}
2776
644
2777
645
double FilletChamferPointArrayParam::time_to_len(int index, double time)
2778
646
{
2779
647
    double intpart;
2780
648
    double len = 0;
2781
649
    time = modf(time, &intpart);
2782
650
    double lenghtPart = 0;
2783
651
    if (last_pwd2.size() <= (unsigned) index || time == 0) {
2784
652
        return len;
2785
653
    }
2786
654
    if (last_pwd2[index][0].degreesOfFreedom() != 2) {
2787
655
        Piecewise<D2<SBasis> > u;
2788
656
        u.push_cut(0);
2789
657
        u.push(last_pwd2[index], 1);
2790
658
        u = portion(u, 0, time);
2791
659
        return length(u, 0.001) * -1;
2792
660
    }
2793
661
    lenghtPart = length(last_pwd2[index], EPSILON);
2794
662
    return (time * lenghtPart) * -1;
2795
663
}
2796
664
2797
665
double FilletChamferPointArrayParam::to_time(int index, double A)
2798
666
{
2799
667
    if (A > 0) {
2800
668
        return A;
2801
669
    } else {
2802
670
        return len_to_time(index, A);
2803
671
    }
2804
672
}
2805
673
2806
674
double FilletChamferPointArrayParam::to_len(int index, double A)
2807
675
{
2808
676
    if (A > 0) {
2809
677
        return time_to_len(index, A);
2810
678
    } else {
2811
679
        return A;
2812
680
    }
2813
681
}
2814
682
2815
683
void FilletChamferPointArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
2816
684
        SPKnotModeType mode,
2817
685
        guint32 color)
2818
686
{
2819
687
    knot_shape = shape;
2820
688
    knot_mode = mode;
2821
689
    knot_color = color;
2822
690
}
2823
691
2824
692
FilletChamferPointArrayParamKnotHolderEntity::
2825
693
FilletChamferPointArrayParamKnotHolderEntity(
2826
694
    FilletChamferPointArrayParam *p, unsigned int index)
2827
695
    : _pparam(p), _index(index) {}
2828
696
2829
697
void FilletChamferPointArrayParamKnotHolderEntity::knot_set(Point const &p,
2830
698
                                                            Point const &/*origin*/,
2831
699
                                                            guint state)
2832
700
{
2833
701
    using namespace Geom;
2834
702
2835
703
    if (!valid_index(_index)) {
2836
704
        return;
2837
705
    }
2838
706
    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
2839
707
    double t = nearest_time(p, pwd2[_index]);
2840
708
    Geom::Point const s = snap_knot_position(pwd2[_index].valueAt(t), state);
2841
709
    t = nearest_time(s, pwd2[_index]);
2842
710
    if (t == 1) {
2843
711
        t = 0.9999;
2844
712
    }
2845
713
    t += _index;
2846
714
2847
715
    if (_pparam->_vector.at(_index)[X] <= 0) {
2848
716
        _pparam->_vector.at(_index) =
2849
717
            Point(_pparam->time_to_len(_index, t), _pparam->_vector.at(_index)[Y]);
2850
718
    } else {
2851
719
        _pparam->_vector.at(_index) = Point(t, _pparam->_vector.at(_index)[Y]);
2852
720
    }
2853
721
    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
2854
722
}
2855
723
2856
724
Point FilletChamferPointArrayParamKnotHolderEntity::knot_get() const
2857
725
{
2858
726
    using namespace Geom;
2859
727
2860
728
    if (!valid_index(_index)) {
2861
729
        return Point(infinity(), infinity());
2862
730
    }
2863
731
2864
732
    Piecewise<D2<SBasis> > const &pwd2 = _pparam->get_pwd2();
2865
733
2866
734
    double time_it = _pparam->to_time(_index, _pparam->_vector.at(_index)[X]);
2867
735
    Point canvas_point = pwd2.valueAt(time_it);
2868
736
2869
737
    _pparam->updateCanvasIndicators();
2870
738
    return canvas_point;
2871
739
2872
740
}
2873
741
2874
742
void FilletChamferPointArrayParamKnotHolderEntity::knot_click(guint state)
2875
743
{
2876
744
    if (state & GDK_CONTROL_MASK) {
2877
745
        if (state & GDK_MOD1_MASK) {
2878
746
            _pparam->_vector.at(_index) = Point(_index, _pparam->_vector.at(_index)[Y]);
2879
747
            _pparam->param_set_and_write_new_value(_pparam->_vector);
2880
748
            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
2881
749
        }else{
2882
750
            using namespace Geom;
2883
751
            int type = (int)_pparam->_vector.at(_index)[Y];
2884
752
            if (type >=3000 && type < 4000){
2885
753
                type = 3;
2886
754
            }
2887
755
            if (type >=4000 && type < 5000){
2888
756
                type = 4;
2889
757
            }
2890
758
            switch(type){
2891
759
                case 1:
2892
760
                    type = 2;
2893
761
                    break;
2894
762
                case 2:
2895
763
                    type =  _pparam->chamfer_steps + 3000;
2896
764
                    break;
2897
765
                case 3:
2898
766
                    type =  _pparam->chamfer_steps + 4000;
2899
767
                    break;
2900
768
                default:
2901
769
                    type = 1;
2902
770
                    break;
2903
771
            }
2904
772
            _pparam->_vector.at(_index) = Point(_pparam->_vector.at(_index)[X], (double)type);
2905
773
            _pparam->param_set_and_write_new_value(_pparam->_vector);
2906
774
            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
2907
775
            const gchar *tip;
2908
776
            if (type >=3000 && type < 4000){
2909
777
                 tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
2910
778
                        "<b>Shift+Click</b> open dialog, "
2911
779
                        "<b>Ctrl+Alt+Click</b> reset");
2912
780
            } else if (type >=4000 && type < 5000) {
2913
781
                tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
2914
782
                        "<b>Shift+Click</b> open dialog, "
2915
783
                        "<b>Ctrl+Alt+Click</b> reset");
2916
784
            } else if (type == 2) {
2917
785
                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
2918
786
                        "<b>Shift+Click</b> open dialog, "
2919
787
                        "<b>Ctrl+Alt+Click</b> reset");
2920
788
            } else {
2921
789
                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
2922
790
                        "<b>Shift+Click</b> open dialog, "
2923
791
                        "<b>Ctrl+Alt+Click</b> reset");
2924
792
            }
2925
793
            this->knot->tip = g_strdup(tip);
2926
794
            this->knot->show();
2927
795
        }
2928
796
    } else if (state & GDK_SHIFT_MASK) {
2929
797
        double xModified = _pparam->_vector.at(_index).x(); 
2930
798
        if(xModified < 0 && !_pparam->use_distance){
2931
799
             xModified = _pparam->len_to_rad(_index, _pparam->_vector.at(_index).x());
2932
800
        }
2933
801
        Geom::PathVector subpaths = path_from_piecewise(_pparam->last_pwd2, 0.1);
2934
802
        std::pair<std::size_t, std::size_t> positions = _pparam->get_positions(_index, subpaths);
2935
803
        D2<SBasis> A = _pparam->last_pwd2[_pparam->last_index(_index, subpaths)];
2936
804
        if(positions.second != 0){
2937
805
            A = _pparam->last_pwd2[_index-1];
2938
806
        }
2939
807
        D2<SBasis> B = _pparam->last_pwd2[_index];
2940
808
        bool aprox = (A[0].degreesOfFreedom() != 2 || B[0].degreesOfFreedom() != 2) && !_pparam->use_distance?true:false;
2941
809
        Geom::Point offset = Geom::Point(xModified, _pparam->_vector.at(_index).y());
2942
810
        Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
2943
811
            this->desktop, offset, this, _pparam->use_distance, aprox);
2944
812
    }
2945
813
2946
814
}
2947
815
2948
816
void FilletChamferPointArrayParamKnotHolderEntity::knot_set_offset(
2949
817
    Geom::Point offset)
2950
818
{
2951
819
    double xModified = offset.x(); 
2952
820
    if(xModified < 0 && !_pparam->use_distance){
2953
821
         xModified = _pparam->rad_to_len(_index, offset.x());
2954
822
    }
2955
823
    _pparam->_vector.at(_index) = Geom::Point(xModified, offset.y());
2956
824
    this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
2957
825
}
2958
826
2959
827
void FilletChamferPointArrayParam::addKnotHolderEntities(KnotHolder *knotholder, SPItem *item) {
2960
828
    recalculate_knots(get_pwd2());
2961
829
    for (unsigned int i = 0; i < _vector.size(); ++i) {
2962
830
        if (_vector[i][Y] <= 0) {
2963
831
            continue;
2964
832
        }
2965
833
        const gchar *tip;
2966
834
        if (_vector[i][Y] >=3000 && _vector[i][Y] < 4000){
2967
835
             tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
2968
836
                    "<b>Shift+Click</b> open dialog, "
2969
837
                    "<b>Ctrl+Alt+Click</b> reset");
2970
838
        } else if (_vector[i][Y] >=4000 && _vector[i][Y] < 5000) {
2971
839
            tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggle type, "
2972
840
                    "<b>Shift+Click</b> open dialog, "
2973
841
                    "<b>Ctrl+Alt+Click</b> reset");
2974
842
        } else if (_vector[i][Y] == 2) {
2975
843
            tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggle type, "
2976
844
                    "<b>Shift+Click</b> open dialog, "
2977
845
                    "<b>Ctrl+Alt+Click</b> reset");
2978
846
        } else {
2979
847
            tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggle type, "
2980
848
                    "<b>Shift+Click</b> open dialog, "
2981
849
                    "<b>Ctrl+Alt+Click</b> reset");
2982
850
        }
2983
851
        FilletChamferPointArrayParamKnotHolderEntity *e =
2984
852
            new FilletChamferPointArrayParamKnotHolderEntity(this, i);
2985
853
        e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),
2986
854
                  knot_shape, knot_mode, knot_color);
2987
855
        knotholder->add(e);
2988
856
    }
2989
857
    updateCanvasIndicators();
2990
858
}
2991
859
2992
860
} /* namespace LivePathEffect */
2993
861
2994
862
} /* namespace Inkscape */
2995
863
2996
864
/*
2997
865
  Local Variables:
2998
866
  mode:c++
2999
867
  c-file-style:"stroustrup"
3000
868
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
3001
869
  indent-tabs-mode:nil
3002
870
  fill-column:99
3003
871
  End:
3004
872
*/
3005
873
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
3006
874
0
3007
=== removed file 'src/live_effects/parameter/filletchamferpointarray.h'
3008
--- src/live_effects/parameter/filletchamferpointarray.h	2017-04-29 00:01:22 +0000
3009
+++ src/live_effects/parameter/filletchamferpointarray.h	1970-01-01 00:00:00 +0000
3010
@@ -1,123 +0,0 @@
3011
1
#ifndef INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
3012
2
#define INKSCAPE_LIVEPATHEFFECT_FILLET_CHAMFER_POINT_ARRAY_H
3013
3
3014
4
/*
3015
5
 * Inkscape::LivePathEffectParameters
3016
6
 * Copyright (C) Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
3017
7
 * Special thanks to Johan Engelen for the base of the effect -powerstroke-
3018
8
 * Also to ScislaC for point me to the idea
3019
9
 * Also su_v for his construvtive feedback and time
3020
10
 * and finaly to Liam P. White for his big help on coding, that save me a lot of
3021
11
 * hours
3022
12
 * Released under GNU GPL, read the file 'COPYING' for more information
3023
13
 */
3024
14
3025
15
#include <glib.h>
3026
16
#include <2geom/point.h>
3027
17
3028
18
#include "live_effects/parameter/array.h"
3029
19
3030
20
#include "knot-holder-entity.h"
3031
21
3032
22
namespace Inkscape {
3033
23
3034
24
namespace LivePathEffect {
3035
25
3036
26
class FilletChamferPointArrayParamKnotHolderEntity;
3037
27
3038
28
class FilletChamferPointArrayParam : public ArrayParam<Geom::Point> {
3039
29
public:
3040
30
    FilletChamferPointArrayParam(const Glib::ustring &label,
3041
31
                                 const Glib::ustring &tip,
3042
32
                                 const Glib::ustring &key,
3043
33
                                 Inkscape::UI::Widget::Registry *wr,
3044
34
                                 Effect *effect);
3045
35
    virtual ~FilletChamferPointArrayParam();
3046
36
3047
37
    virtual Gtk::Widget *param_newWidget();
3048
38
3049
39
    virtual void param_transform_multiply(Geom::Affine const &postmul,
3050
40
                                          bool /*set*/);
3051
41
3052
42
    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode,
3053
43
                            guint32 color);
3054
44
    virtual double to_time(int index, double A);
3055
45
    virtual double to_len(int index, double A);
3056
46
    virtual double rad_to_len(int index, double rad);
3057
47
    virtual double len_to_rad(int index, double len);
3058
48
    virtual double len_to_time(int index, double len);
3059
49
    virtual double time_to_len(int index, double time);
3060
50
    virtual std::pair<std::size_t, std::size_t> get_positions(int index, Geom::PathVector subpaths);
3061
51
    virtual int last_index(int index, Geom::PathVector subpaths);
3062
52
    std::vector<double> get_times(int index, Geom::PathVector subpaths, bool last);
3063
53
    virtual void set_helper_size(int hs);
3064
54
    virtual void set_use_distance(bool use_knot_distance);
3065
55
    virtual void set_chamfer_steps(int value_chamfer_steps);
3066
56
    virtual void addCanvasIndicators(SPLPEItem const *lpeitem,
3067
57
                                     std::vector<Geom::PathVector> &hp_vec);
3068
58
    virtual void param_update_default(const gchar * default_value){};
3069
59
    virtual bool providesKnotHolderEntities() const {
3070
60
        return true;
3071
61
    }
3072
62
    virtual void updateCanvasIndicators();
3073
63
    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
3074
64
3075
65
    void set_pwd2(Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in,
3076
66
                  Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_normal_in);
3077
67
    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2() const {
3078
68
        return last_pwd2;
3079
69
    }
3080
70
    Geom::Piecewise<Geom::D2<Geom::SBasis> > const &get_pwd2_normal() const {
3081
71
        return last_pwd2_normal;
3082
72
    }
3083
73
3084
74
    void recalculate_controlpoints_for_new_pwd2(
3085
75
        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
3086
76
    void recalculate_knots(
3087
77
        Geom::Piecewise<Geom::D2<Geom::SBasis> > const &pwd2_in);
3088
78
    friend class FilletChamferPointArrayParamKnotHolderEntity;
3089
79
3090
80
private:
3091
81
    FilletChamferPointArrayParam(const FilletChamferPointArrayParam &);
3092
82
    FilletChamferPointArrayParam &operator=(const FilletChamferPointArrayParam &);
3093
83
3094
84
    SPKnotShapeType knot_shape;
3095
85
    SPKnotModeType knot_mode;
3096
86
    guint32 knot_color;
3097
87
    int helper_size;
3098
88
    int chamfer_steps;
3099
89
    bool use_distance;
3100
90
    Geom::PathVector hp;
3101
91
3102
92
    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2;
3103
93
    Geom::Piecewise<Geom::D2<Geom::SBasis> > last_pwd2_normal;
3104
94
};
3105
95
3106
96
class FilletChamferPointArrayParamKnotHolderEntity : public KnotHolderEntity {
3107
97
public:
3108
98
    FilletChamferPointArrayParamKnotHolderEntity(FilletChamferPointArrayParam *p,
3109
99
            unsigned int index);
3110
100
    virtual ~FilletChamferPointArrayParamKnotHolderEntity() {}
3111
101
3112
102
    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin,
3113
103
                          guint state);
3114
104
    virtual Geom::Point knot_get() const;
3115
105
    virtual void knot_click(guint state);
3116
106
    virtual void knot_set_offset(Geom::Point offset);
3117
107
3118
108
    /*Checks whether the index falls within the size of the parameter's vector*/
3119
109
    bool valid_index(unsigned int index) const {
3120
110
        return (_pparam->_vector.size() > index);
3121
111
    }
3122
112
    ;
3123
113
3124
114
private:
3125
115
    FilletChamferPointArrayParam *_pparam;
3126
116
    unsigned int _index;
3127
117
};
3128
118
3129
119
} //namespace LivePathEffect
3130
120
3131
121
} //namespace Inkscape
3132
122
3133
123
#endif
3134
124
0
3135
=== added file 'src/live_effects/parameter/satellitesarray.cpp'
3136
--- src/live_effects/parameter/satellitesarray.cpp	1970-01-01 00:00:00 +0000
3137
+++ src/live_effects/parameter/satellitesarray.cpp	2017-05-06 17:46:29 +0000
3138
@@ -0,0 +1,583 @@
3139
1
/*
3140
2
 * Author(s):
3141
3
 *   Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
3142
4
 *
3143
5
 * Copyright (C) 2014 Author(s)
3144
6
 * Released under GNU GPL, read the file 'COPYING' for more information
3145
7
 */
3146
8
3147
9
#include "knotholder.h"
3148
10
#include "ui/dialog/lpe-fillet-chamfer-properties.h"
3149
11
#include "live_effects/parameter/satellitesarray.h"
3150
12
#include "live_effects/effect.h"
3151
13
#include "sp-lpe-item.h"
3152
14
#include "inkscape.h"
3153
15
#include <preferences.h>
3154
16
// TODO due to internal breakage in glibmm headers,
3155
17
// this has to be included last.
3156
18
#include <glibmm/i18n.h>
3157
19
3158
20
namespace Inkscape {
3159
21
3160
22
namespace LivePathEffect {
3161
23
3162
24
SatellitesArrayParam::SatellitesArrayParam(const Glib::ustring &label,
3163
25
        const Glib::ustring &tip,
3164
26
        const Glib::ustring &key,
3165
27
        Inkscape::UI::Widget::Registry *wr,
3166
28
        Effect *effect)
3167
29
    : ArrayParam<std::vector<Satellite> >(label, tip, key, wr, effect, 0), _knoth(NULL)
3168
30
{
3169
31
    _knot_shape = SP_KNOT_SHAPE_DIAMOND;
3170
32
    _knot_mode = SP_KNOT_MODE_XOR;
3171
33
    _knot_color = 0xAAFF8800;
3172
34
    _helper_size = 0;
3173
35
    _use_distance = false;
3174
36
    _global_knot_hide = false;
3175
37
    _current_zoom = 0;
3176
38
    _effectType = FILLET_CHAMFER;
3177
39
    _last_pathvector_satellites = NULL;
3178
40
}
3179
41
3180
42
3181
43
void SatellitesArrayParam::set_oncanvas_looks(SPKnotShapeType shape,
3182
44
        SPKnotModeType mode,
3183
45
        guint32 color)
3184
46
{
3185
47
    _knot_shape = shape;
3186
48
    _knot_mode = mode;
3187
49
    _knot_color = color;
3188
50
}
3189
51
3190
52
void SatellitesArrayParam::setPathVectorSatellites(PathVectorSatellites *pathVectorSatellites, bool write)
3191
53
{
3192
54
    _last_pathvector_satellites = pathVectorSatellites;
3193
55
    if (write) {
3194
56
        param_set_and_write_new_value(_last_pathvector_satellites->getSatellites());
3195
57
    } else {
3196
58
        param_setValue(_last_pathvector_satellites->getSatellites());
3197
59
    }
3198
60
}
3199
61
3200
62
void SatellitesArrayParam::setUseDistance(bool use_knot_distance)
3201
63
{
3202
64
    _use_distance = use_knot_distance;
3203
65
}
3204
66
3205
67
void SatellitesArrayParam::setCurrentZoom(double current_zoom)
3206
68
{
3207
69
    _current_zoom = current_zoom;
3208
70
}
3209
71
3210
72
void SatellitesArrayParam::setGlobalKnotHide(bool global_knot_hide)
3211
73
{
3212
74
    _global_knot_hide = global_knot_hide;
3213
75
}
3214
76
void SatellitesArrayParam::setEffectType(EffectType et)
3215
77
{
3216
78
    _effectType = et;
3217
79
}
3218
80
3219
81
void SatellitesArrayParam::setHelperSize(int hs)
3220
82
{
3221
83
    _helper_size = hs;
3222
84
    updateCanvasIndicators();
3223
85
}
3224
86
3225
87
void SatellitesArrayParam::updateCanvasIndicators(bool mirror)
3226
88
{
3227
89
    if (!_last_pathvector_satellites) {
3228
90
        return;
3229
91
    }
3230
92
3231
93
    if (!_hp.empty()) {
3232
94
        _hp.clear();
3233
95
    }
3234
96
    Geom::PathVector pathv = _last_pathvector_satellites->getPathVector();
3235
97
    if (pathv.empty()) {
3236
98
        return;
3237
99
    }
3238
100
    if (mirror == true) {
3239
101
        _hp.clear();
3240
102
    }
3241
103
    if (_effectType == FILLET_CHAMFER) {
3242
104
        for (size_t i = 0; i < _vector.size(); ++i) {
3243
105
            for (size_t j = 0; j < _vector[i].size(); ++j) {
3244
106
                if (_vector[i][j].hidden || //Ignore if hidden
3245
107
                    (!_vector[i][j].has_mirror && mirror == true) || //Ignore if not have mirror and we are in mirror loop
3246
108
                    _vector[i][j].amount == 0 || //no helper in 0 value
3247
109
                    pathv[i].size() == j || //ignore last satellite in open paths with fillet chamfer effect
3248
110
                    (!pathv[i].closed() && j == 0))  //ignore first satellites on open paths
3249
111
                {
3250
112
                    continue;
3251
113
                }
3252
114
                Geom::Curve *curve_in = pathv[i][j].duplicate();
3253
115
                double pos = 0;
3254
116
                bool overflow = false;
3255
117
                double size_out = _vector[i][j].arcDistance(*curve_in);
3256
118
                double lenght_out = curve_in->length();
3257
119
                gint previous_index = j - 1; //Always are previous index because we skip first satellite on open paths
3258
120
                if (j == 0 && pathv[i].closed()) {
3259
121
                    previous_index = pathv[i].size() - 1;
3260
122
                }
3261
123
                if ( previous_index < 0 ) {
3262
124
                    return;
3263
125
                }
3264
126
                double lenght_in = pathv.curveAt(previous_index).length();
3265
127
                if (mirror) {
3266
128
                    curve_in = const_cast<Geom::Curve *>(&pathv.curveAt(previous_index));
3267
129
                    pos = _vector[i][j].time(size_out, true, *curve_in);
3268
130
                    if (lenght_out < size_out) {
3269
131
                        overflow = true;
3270
132
                    }
3271
133
                } else {
3272
134
                    pos = _vector[i][j].time(*curve_in);
3273
135
                    if (lenght_in < size_out) {
3274
136
                        overflow = true;
3275
137
                    }
3276
138
                }
3277
139
                if (pos <= 0 || pos >= 1) {
3278
140
                    continue;
3279
141
                }
3280
142
                Geom::Point point_a = curve_in->pointAt(pos);
3281
143
                Geom::Point deriv_a = unit_vector(derivative(curve_in->toSBasis()).pointAt(pos));
3282
144
                Geom::Rotate rot(Geom::Rotate::from_degrees(-90));
3283
145
                deriv_a = deriv_a * rot;
3284
146
                Geom::Point point_c = point_a - deriv_a * _helper_size;
3285
147
                Geom::Point point_d = point_a + deriv_a * _helper_size;
3286
148
                Geom::Ray ray_1(point_c, point_d);
3287
149
                char const *svgd = "M 1,0.25 0.5,0 1,-0.25 M 1,0.5 0,0 1,-0.5";
3288
150
                Geom::PathVector pathv = sp_svg_read_pathv(svgd);
3289
151
                Geom::Affine aff = Geom::Affine();
3290
152
                aff *= Geom::Scale(_helper_size);
3291
153
                if (mirror) {
3292
154
                    aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(90));
3293
155
                } else {
3294
156
                    aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(270));
3295
157
                }
3296
158
                aff *= Geom::Translate(curve_in->pointAt(pos));
3297
159
                pathv *= aff;
3298
160
                _hp.push_back(pathv[0]);
3299
161
                _hp.push_back(pathv[1]);
3300
162
                if (overflow) {
3301
163
                    double diameter = _helper_size;
3302
164
                    if (_helper_size == 0) {
3303
165
                        diameter = 15;
3304
166
                        char const *svgd;
3305
167
                        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 "
3306
168
                               "0.35,0.35 0 0 1 0.35,0 0.35,0.35 0 0 1 0.7,0.35 Z";
3307
169
                        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
3308
170
                        aff = Geom::Affine();
3309
171
                        aff *= Geom::Scale(diameter);
3310
172
                        aff *= Geom::Translate(point_a - Geom::Point(diameter * 0.35, diameter * 0.35));
3311
173
                        pathv *= aff;
3312
174
                        _hp.push_back(pathv[0]);
3313
175
                    } else {
3314
176
                        char const *svgd;
3315
177
                        svgd = "M 0 -1.32 A 1.32 1.32 0 0 0 -1.32 0 A 1.32 1.32 0 0 0 0 1.32 A "
3316
178
                               "1.32 1.32 0 0 0 1.18 0.59 L 0 0 L 1.18 -0.59 A 1.32 1.32 0 0 0 "
3317
179
                               "0 -1.32 z";
3318
180
                        Geom::PathVector pathv = sp_svg_read_pathv(svgd);
3319
181
                        aff = Geom::Affine();
3320
182
                        aff *= Geom::Scale(_helper_size / 2.0);
3321
183
                        if (mirror) {
3322
184
                            aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(90));
3323
185
                        } else {
3324
186
                            aff *= Geom::Rotate(ray_1.angle() - Geom::rad_from_deg(270));
3325
187
                        }
3326
188
                        aff *= Geom::Translate(curve_in->pointAt(pos));
3327
189
                        pathv *= aff;
3328
190
                        _hp.push_back(pathv[0]);
3329
191
                    }
3330
192
                }
3331
193
            }
3332
194
        }
3333
195
    }
3334
196
    if (!_knot_reset_helper.empty()) {
3335
197
        _hp.insert(_hp.end(), _knot_reset_helper.begin(), _knot_reset_helper.end() );
3336
198
    }
3337
199
    if (mirror) {
3338
200
        updateCanvasIndicators(false);
3339
201
    }
3340
202
}
3341
203
void SatellitesArrayParam::updateCanvasIndicators()
3342
204
{
3343
205
    updateCanvasIndicators(true);
3344
206
}
3345
207
3346
208
void SatellitesArrayParam::addCanvasIndicators(
3347
209
    SPLPEItem const */*lpeitem*/, std::vector<Geom::PathVector> &hp_vec)
3348
210
{
3349
211
    hp_vec.push_back(_hp);
3350
212
}
3351
213
3352
214
void SatellitesArrayParam::param_transform_multiply(Geom::Affine const &postmul, bool /*set*/)
3353
215
{
3354
216
    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
3355
217
3356
218
    if (prefs->getBool("/options/transform/rectcorners", true)) {
3357
219
        for (size_t i = 0; i < _vector.size(); ++i) {
3358
220
            for (size_t j = 0; j < _vector[i].size(); ++j) {
3359
221
                if (!_vector[i][j].is_time && _vector[i][j].amount > 0) {
3360
222
                    _vector[i][j].amount = _vector[i][j].amount * ((postmul.expansionX() + postmul.expansionY()) / 2);
3361
223
                }
3362
224
            }
3363
225
        }
3364
226
        param_set_and_write_new_value(_vector);
3365
227
    }
3366
228
}
3367
229
3368
230
void SatellitesArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
3369
231
                                                 SPItem *item,
3370
232
                                                 bool mirror)
3371
233
{
3372
234
    if (!_last_pathvector_satellites) {
3373
235
        return;
3374
236
    }
3375
237
    Geom::PathVector pathv = _last_pathvector_satellites->getPathVector();
3376
238
    size_t index = 0;
3377
239
    for (size_t i = 0; i < _vector.size(); ++i) {
3378
240
        for (size_t j = 0; j < _vector[i].size(); ++j) {
3379
241
            if (!_vector[i][j].has_mirror && mirror) {
3380
242
                continue;
3381
243
            }
3382
244
            SatelliteType type = _vector[i][j].satellite_type;
3383
245
            if (mirror && i == 0 && j == 0) {
3384
246
                index = index + _last_pathvector_satellites->getTotalSatellites();
3385
247
            }
3386
248
            using namespace Geom;
3387
249
            //If is for filletChamfer effect...
3388
250
            if (_effectType == FILLET_CHAMFER) {
3389
251
                const gchar *tip;
3390
252
                if (type == CHAMFER) {
3391
253
                    tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
3392
254
                            "<b>Shift+Click</b> open dialog, "
3393
255
                            "<b>Ctrl+Alt+Click</b> reset");
3394
256
                } else if (type == INVERSE_CHAMFER) {
3395
257
                    tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
3396
258
                            "<b>Shift+Click</b> open dialog, "
3397
259
                            "<b>Ctrl+Alt+Click</b> reset");
3398
260
                } else if (type == INVERSE_FILLET) {
3399
261
                    tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggles type, "
3400
262
                            "<b>Shift+Click</b> open dialog, "
3401
263
                            "<b>Ctrl+Alt+Click</b> reset");
3402
264
                } else {
3403
265
                    tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggles type, "
3404
266
                            "<b>Shift+Click</b> open dialog, "
3405
267
                            "<b>Ctrl+Alt+Click</b> reset");
3406
268
                }
3407
269
                FilletChamferKnotHolderEntity *e = new FilletChamferKnotHolderEntity(this, index);
3408
270
                e->create(NULL, item, knotholder, Inkscape::CTRL_TYPE_UNKNOWN, _(tip),_knot_shape, _knot_mode, _knot_color);
3409
271
                knotholder->add(e);
3410
272
            }
3411
273
            index++;
3412
274
        }
3413
275
    }
3414
276
    if (mirror) {
3415
277
        addKnotHolderEntities(knotholder, item, false);
3416
278
    }
3417
279
}
3418
280
3419
281
void SatellitesArrayParam::addKnotHolderEntities(KnotHolder *knotholder,
3420
282
        SPItem *item)
3421
283
{
3422
284
    _knoth = knotholder;
3423
285
    addKnotHolderEntities(knotholder, item, true);
3424
286
}
3425
287
3426
288
FilletChamferKnotHolderEntity::FilletChamferKnotHolderEntity(
3427
289
    SatellitesArrayParam *p, size_t index)
3428
290
    : _pparam(p), _index(index) {}
3429
291
3430
292
void FilletChamferKnotHolderEntity::knot_set(Geom::Point const &p,
3431
293
        Geom::Point const &/*origin*/,
3432
294
        guint state)
3433
295
{
3434
296
    if (!_pparam->_last_pathvector_satellites) {
3435
297
        return;
3436
298
    }
3437
299
    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
3438
300
    bool is_mirror = false;
3439
301
    size_t index = _index;
3440
302
    if (_index >= total_satellites) {
3441
303
        index = _index - total_satellites;
3442
304
        is_mirror = true;
3443
305
    }
3444
306
    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
3445
307
    size_t path_index = index_data.first;
3446
308
    size_t curve_index = index_data.second;
3447
309
    
3448
310
    Geom::Point s = snap_knot_position(p, state);
3449
311
    if (!valid_index(path_index, curve_index)) {
3450
312
        return;
3451
313
    }
3452
314
    Satellite satellite = _pparam->_vector[path_index][curve_index];
3453
315
    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
3454
316
    if (satellite.hidden ||
3455
317
        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
3456
318
        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
3457
319
    {
3458
320
        return;
3459
321
    }
3460
322
    gint previous_index = curve_index - 1;
3461
323
    if (curve_index == 0 && pathv[path_index].closed()) {
3462
324
        previous_index = pathv[path_index].size() - 1;
3463
325
    }
3464
326
    if ( previous_index < 0 ) {
3465
327
        return;
3466
328
    }
3467
329
    Geom::Curve const &curve_in = pathv[path_index][previous_index];
3468
330
    double mirror_time = Geom::nearest_time(s, curve_in);
3469
331
    Geom::Point mirror = curve_in.pointAt(mirror_time);
3470
332
    double normal_time = Geom::nearest_time(s, pathv[path_index][curve_index]);
3471
333
    Geom::Point normal = pathv[path_index][curve_index].pointAt(normal_time);
3472
334
    double distance_mirror = Geom::distance(mirror,s);
3473
335
    double distance_normal = Geom::distance(normal,s);
3474
336
    if (Geom::are_near(s, pathv[path_index][curve_index].initialPoint(), 1.5 / _pparam->_current_zoom)) {
3475
337
        satellite.amount = 0;
3476
338
    } else if (distance_mirror < distance_normal) {
3477
339
        double time_start = 0;
3478
340
        Satellites satellites = _pparam->_last_pathvector_satellites->getSatellites();
3479
341
        time_start = satellites[path_index][previous_index].time(curve_in);
3480
342
        if (time_start > mirror_time) {
3481
343
            mirror_time = time_start;
3482
344
        }
3483
345
        double size = arcLengthAt(mirror_time, curve_in);
3484
346
        double amount = curve_in.length() - size;
3485
347
        if (satellite.is_time) {
3486
348
            amount = timeAtArcLength(amount, pathv[path_index][curve_index]);
3487
349
        }
3488
350
        satellite.amount = amount;
3489
351
    } else {
3490
352
        satellite.setPosition(s, pathv[path_index][curve_index]);
3491
353
    }
3492
354
    _pparam->_knot_reset_helper.clear();
3493
355
    if (satellite.amount == 0) {
3494
356
        char const *svgd;
3495
357
        svgd = "M -5.39,8.78 -9.13,5.29 -10.38,10.28 Z M -7.22,7.07 -3.43,3.37 m -1.95,-12.16 -3.74,3.5 -1.26,-5 z "
3496
358
               "m -1.83,1.71 3.78,3.7 M 5.24,8.78 8.98,5.29 10.24,10.28 Z "
3497
359
               "M 7.07,7.07 3.29,3.37 M 5.24,-8.78 l 3.74,3.5 1.26,-5 z M 7.07,-7.07 3.29,-3.37";
3498
360
        _pparam->_knot_reset_helper = sp_svg_read_pathv(svgd);
3499
361
        _pparam->_knot_reset_helper *= Geom::Affine(_pparam->_helper_size * 0.1,0,0,_pparam->_helper_size * 0.1,0,0) * Geom::Translate(pathv[path_index][curve_index].initialPoint());
3500
362
    }
3501
363
    _pparam->_vector[path_index][curve_index] = satellite;
3502
364
    sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
3503
365
}
3504
366
3505
367
Geom::Point FilletChamferKnotHolderEntity::knot_get() const
3506
368
{
3507
369
    if (!_pparam->_last_pathvector_satellites || _pparam->_global_knot_hide) {
3508
370
        return Geom::Point(Geom::infinity(), Geom::infinity());
3509
371
    }
3510
372
    Geom::Point tmp_point;
3511
373
    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
3512
374
    bool is_mirror = false;
3513
375
    size_t index = _index;
3514
376
    if (_index >= total_satellites) {
3515
377
        index = _index - total_satellites;
3516
378
        is_mirror = true;
3517
379
    }
3518
380
    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
3519
381
    size_t path_index = index_data.first;
3520
382
    size_t curve_index = index_data.second;
3521
383
    if (!valid_index(path_index, curve_index)) {
3522
384
        return Geom::Point(Geom::infinity(), Geom::infinity());
3523
385
    }
3524
386
    Satellite satellite = _pparam->_vector[path_index][curve_index];
3525
387
    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
3526
388
    if (satellite.hidden ||
3527
389
        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
3528
390
        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
3529
391
    {
3530
392
        return Geom::Point(Geom::infinity(), Geom::infinity());
3531
393
    }
3532
394
    this->knot->show();
3533
395
    if (is_mirror) {
3534
396
        gint previous_index = curve_index - 1;
3535
397
        if (curve_index == 0 && pathv[path_index].closed()) {
3536
398
            previous_index = pathv[path_index].size() - 1;
3537
399
        }
3538
400
        if ( previous_index < 0 ) {
3539
401
            return Geom::Point(Geom::infinity(), Geom::infinity());
3540
402
        }
3541
403
        Geom::Curve const &curve_in = pathv[path_index][previous_index];
3542
404
        double s = satellite.arcDistance(pathv[path_index][curve_index]);
3543
405
        double t = satellite.time(s, true, curve_in);
3544
406
        if (t > 1) {
3545
407
            t = 1;
3546
408
        }
3547
409
        if (t < 0) {
3548
410
            t = 0;
3549
411
        }
3550
412
        double time_start = 0;
3551
413
        time_start = _pparam->_last_pathvector_satellites->getSatellites()[path_index][previous_index].time(curve_in);
3552
414
        if (time_start > t) {
3553
415
            t = time_start;
3554
416
        }
3555
417
        tmp_point = (curve_in).pointAt(t);
3556
418
    } else {
3557
419
        tmp_point = satellite.getPosition(pathv[path_index][curve_index]);
3558
420
    }
3559
421
    Geom::Point const canvas_point = tmp_point;
3560
422
    _pparam->updateCanvasIndicators();
3561
423
    return canvas_point;
3562
424
}
3563
425
3564
426
void FilletChamferKnotHolderEntity::knot_click(guint state)
3565
427
{
3566
428
    if (!_pparam->_last_pathvector_satellites) {
3567
429
        return;
3568
430
    }
3569
431
    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
3570
432
    bool is_mirror = false;
3571
433
    size_t index = _index;
3572
434
    if (_index >= total_satellites) {
3573
435
        index = _index - total_satellites;
3574
436
        is_mirror = true;
3575
437
    }
3576
438
    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
3577
439
    size_t path_index = index_data.first;
3578
440
    size_t curve_index = index_data.second;
3579
441
    if (!valid_index(path_index, curve_index)) {
3580
442
        return;
3581
443
    }
3582
444
    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
3583
445
    if ((!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
3584
446
        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
3585
447
    {
3586
448
        return;
3587
449
    }
3588
450
    if (state & GDK_CONTROL_MASK) {
3589
451
        if (state & GDK_MOD1_MASK) {
3590
452
            _pparam->_vector[path_index][curve_index].amount = 0.0;
3591
453
            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
3592
454
        } else {
3593
455
            using namespace Geom;
3594
456
            SatelliteType type = _pparam->_vector[path_index][curve_index].satellite_type;
3595
457
            switch (type) {
3596
458
            case FILLET:
3597
459
                type = INVERSE_FILLET;
3598
460
                break;
3599
461
            case INVERSE_FILLET:
3600
462
                type = CHAMFER;
3601
463
                break;
3602
464
            case CHAMFER:
3603
465
                type = INVERSE_CHAMFER;
3604
466
                break;
3605
467
            default:
3606
468
                type = FILLET;
3607
469
                break;
3608
470
            }
3609
471
            _pparam->_vector[path_index][curve_index].satellite_type = type;
3610
472
            sp_lpe_item_update_patheffect(SP_LPE_ITEM(item), false, false);
3611
473
            const gchar *tip;
3612
474
            if (type == CHAMFER) {
3613
475
                tip = _("<b>Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
3614
476
                        "<b>Shift+Click</b> open dialog, "
3615
477
                        "<b>Ctrl+Alt+Click</b> resets");
3616
478
            } else if (type == INVERSE_CHAMFER) {
3617
479
                tip = _("<b>Inverse Chamfer</b>: <b>Ctrl+Click</b> toggles type, "
3618
480
                        "<b>Shift+Click</b> open dialog, "
3619
481
                        "<b>Ctrl+Alt+Click</b> resets");
3620
482
            } else if (type == INVERSE_FILLET) {
3621
483
                tip = _("<b>Inverse Fillet</b>: <b>Ctrl+Click</b> toggles type, "
3622
484
                        "<b>Shift+Click</b> open dialog, "
3623
485
                        "<b>Ctrl+Alt+Click</b> resets");
3624
486
            } else {
3625
487
                tip = _("<b>Fillet</b>: <b>Ctrl+Click</b> toggles type, "
3626
488
                        "<b>Shift+Click</b> open dialog, "
3627
489
                        "<b>Ctrl+Alt+Click</b> resets");
3628
490
            }
3629
491
            this->knot->tip = g_strdup(tip);
3630
492
            this->knot->show();
3631
493
        }
3632
494
    } else if (state & GDK_SHIFT_MASK) {
3633
495
        double amount = _pparam->_vector[path_index][curve_index].amount;
3634
496
        gint previous_index =  curve_index - 1;
3635
497
        if (curve_index == 0 && pathv[path_index].closed()) {
3636
498
            previous_index = pathv[path_index].size() - 1;
3637
499
        }
3638
500
        if ( previous_index < 0 ) {
3639
501
            return;
3640
502
        }
3641
503
        if (!_pparam->_use_distance && !_pparam->_vector[path_index][curve_index].is_time) {
3642
504
            amount = _pparam->_vector[path_index][curve_index].lenToRad(amount, pathv[path_index][previous_index], pathv[path_index][curve_index], _pparam->_vector[path_index][previous_index]);
3643
505
        }
3644
506
        bool aprox = false;
3645
507
        Geom::D2<Geom::SBasis> d2_out = pathv[path_index][curve_index].toSBasis();
3646
508
        Geom::D2<Geom::SBasis> d2_in = pathv[path_index][previous_index].toSBasis();
3647
509
        aprox = ((d2_in)[0].degreesOfFreedom() != 2 ||
3648
510
                 d2_out[0].degreesOfFreedom() != 2) &&
3649
511
                !_pparam->_use_distance
3650
512
                ? true
3651
513
                : false;
3652
514
        Inkscape::UI::Dialogs::FilletChamferPropertiesDialog::showDialog(
3653
515
            this->desktop, amount, this, _pparam->_use_distance,
3654
516
            aprox, _pparam->_vector[path_index][curve_index]);
3655
517
3656
518
    }
3657
519
}
3658
520
3659
521
void FilletChamferKnotHolderEntity::knot_set_offset(Satellite satellite)
3660
522
{
3661
523
    if (!_pparam->_last_pathvector_satellites) {
3662
524
        return;
3663
525
    }
3664
526
    size_t total_satellites = _pparam->_last_pathvector_satellites->getTotalSatellites();
3665
527
    bool is_mirror = false;
3666
528
    size_t index = _index;
3667
529
    if (_index >= total_satellites) {
3668
530
        index = _index - total_satellites;
3669
531
        is_mirror = true;
3670
532
    }
3671
533
    std::pair<size_t, size_t> index_data = _pparam->_last_pathvector_satellites->getIndexData(index);
3672
534
    size_t path_index = index_data.first;
3673
535
    size_t curve_index = index_data.second;
3674
536
    if (!valid_index(path_index, curve_index)) {
3675
537
        return;
3676
538
    }
3677
539
    Geom::PathVector pathv = _pparam->_last_pathvector_satellites->getPathVector();
3678
540
    if (satellite.hidden ||
3679
541
        (!pathv[path_index].closed() && curve_index == 0) ||//ignore first satellites on open paths
3680
542
        pathv[path_index].size() == curve_index) //ignore last satellite in open paths with fillet chamfer effect
3681
543
    {
3682
544
        return;
3683
545
    }
3684
546
    double amount = satellite.amount;
3685
547
    double max_amount = amount;
3686
548
    if (!_pparam->_use_distance && !satellite.is_time) {
3687
549
        gint previous_index = curve_index - 1;
3688
550
        if (curve_index == 0 && pathv[path_index].closed()) {
3689
551
            previous_index = pathv[path_index].size() - 1;
3690
552
        }
3691
553
        if ( previous_index < 0 ) {
3692
554
            return;
3693
555
        }
3694
556
        amount = _pparam->_vector[path_index][curve_index].radToLen(amount, pathv[path_index][previous_index], pathv[path_index][curve_index]);
3695
557
        if (max_amount > 0 && amount == 0) {
3696
558
            amount = _pparam->_vector[path_index][curve_index].amount;
3697
559
        }
3698
560
    }
3699
561
    satellite.amount = amount;
3700
562
    _pparam->_vector[path_index][curve_index] = satellite;
3701
563
    this->parent_holder->knot_ungrabbed_handler(this->knot, 0);
3702
564
    SPLPEItem *splpeitem = dynamic_cast<SPLPEItem *>(item);
3703
565
    if (splpeitem) {
3704
566
        sp_lpe_item_update_patheffect(splpeitem, false, false);
3705
567
    }
3706
568
}
3707
569
3708
570
} /* namespace LivePathEffect */
3709
571
3710
572
} /* namespace Inkscape */
3711
573
3712
574
/*
3713
575
  Local Variables:
3714
576
  mode:c++
3715
577
  c-file-style:"stroustrup"
3716
578
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
3717
579
  indent-tabs-mode:nil
3718
580
  fill-column:99
3719
581
  End:
3720
582
*/
3721
583
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
3722
0
584
3723
=== added file 'src/live_effects/parameter/satellitesarray.h'
3724
--- src/live_effects/parameter/satellitesarray.h	1970-01-01 00:00:00 +0000
3725
+++ src/live_effects/parameter/satellitesarray.h	2017-05-06 17:46:29 +0000
3726
@@ -0,0 +1,114 @@
3727
1
#ifndef INKSCAPE_LIVEPATHEFFECT_SATELLITES_ARRAY_H
3728
2
#define INKSCAPE_LIVEPATHEFFECT_SATELLITES_ARRAY_H
3729
3
3730
4
/*
3731
5
 * Inkscape::LivePathEffectParameters
3732
6
 * Copyright (C) Jabiertxo Arraiza Cenoz <jabier.arraiza@marker.es>
3733
7
 * Special thanks to Johan Engelen for the base of the effect -powerstroke-
3734
8
 * Also to ScislaC for point me to the idea
3735
9
 * Also su_v for his construvtive feedback and time
3736
10
 * To Nathan Hurst for his review and help on refactor
3737
11
 * and finaly to Liam P. White for his big help on coding, that save me a lot of
3738
12
 * hours
3739
13
 *
3740
14
 *
3741
15
 * This parameter act as bridge from pathVectorSatellites class to serialize it as a LPE
3742
16
 * parameter
3743
17
 *
3744
18
 * Released under GNU GPL, read the file 'COPYING' for more information
3745
19
 */
3746
20
3747
21
#include "live_effects/parameter/array.h"
3748
22
#include "live_effects/effect-enum.h"
3749
23
#include "helper/geom-pathvectorsatellites.h"
3750
24
#include "knot-holder-entity.h"
3751
25
#include <glib.h>
3752
26
3753
27
namespace Inkscape {
3754
28
3755
29
namespace LivePathEffect {
3756
30
3757
31
class FilletChamferKnotHolderEntity;
3758
32
3759
33
class SatellitesArrayParam : public ArrayParam<std::vector<Satellite> > {
3760
34
public:
3761
35
    SatellitesArrayParam(const Glib::ustring &label, const Glib::ustring &tip,
3762
36
                        const Glib::ustring &key,
3763
37
                        Inkscape::UI::Widget::Registry *wr, Effect *effect);
3764
38
3765
39
    virtual Gtk::Widget *param_newWidget()
3766
40
    {
3767
41
        return NULL;
3768
42
    }
3769
43
    virtual void setHelperSize(int hs);
3770
44
    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item);
3771
45
    virtual void addKnotHolderEntities(KnotHolder *knotholder, SPItem *item, bool mirror);
3772
46
    virtual void addCanvasIndicators(SPLPEItem const *lpeitem, std::vector<Geom::PathVector> &hp_vec);
3773
47
    virtual void updateCanvasIndicators();
3774
48
    virtual void updateCanvasIndicators(bool mirror);
3775
49
    virtual bool providesKnotHolderEntities() const
3776
50
    {
3777
51
        return true;
3778
52
    }
3779
53
    void param_transform_multiply(Geom::Affine const &postmul, bool /*set*/);
3780
54
    void setUseDistance(bool use_knot_distance);
3781
55
    void setCurrentZoom(double current_zoom);
3782
56
    void setGlobalKnotHide(bool global_knot_hide);
3783
57
    void setEffectType(EffectType et);
3784
58
    void setPathVectorSatellites(PathVectorSatellites *pathVectorSatellites, bool write = true);
3785
59
    void set_oncanvas_looks(SPKnotShapeType shape, SPKnotModeType mode, guint32 color);
3786
60
3787
61
    friend class FilletChamferKnotHolderEntity;
3788
62
    friend class LPEFilletChamfer;
3789
63
3790
64
protected:
3791
65
    KnotHolder *_knoth;
3792
66
3793
67
private:
3794
68
    SatellitesArrayParam(const SatellitesArrayParam &);
3795
69
    SatellitesArrayParam &operator=(const SatellitesArrayParam &);
3796
70
3797
71
    SPKnotShapeType _knot_shape;
3798
72
    SPKnotModeType _knot_mode;
3799
73
    guint32 _knot_color;
3800
74
    Geom::PathVector _hp;
3801
75
    Geom::PathVector _knot_reset_helper;
3802
76
    int _helper_size;
3803
77
    bool _use_distance;
3804
78
    bool _global_knot_hide;
3805
79
    double _current_zoom;
3806
80
    EffectType _effectType;
3807
81
    PathVectorSatellites *_last_pathvector_satellites;
3808
82
3809
83
};
3810
84
3811
85
class FilletChamferKnotHolderEntity : public KnotHolderEntity {
3812
86
public:
3813
87
    FilletChamferKnotHolderEntity(SatellitesArrayParam *p, size_t index);
3814
88
    virtual ~FilletChamferKnotHolderEntity()
3815
89
    {
3816
90
        _pparam->_knoth = NULL;
3817
91
    }
3818
92
3819
93
    virtual void knot_set(Geom::Point const &p, Geom::Point const &origin,
3820
94
                          guint state);
3821
95
    virtual Geom::Point knot_get() const;
3822
96
    virtual void knot_click(guint state);
3823
97
    void knot_set_offset(Satellite);
3824
98
    /** Checks whether the index falls within the size of the parameter's vector
3825
99
     */
3826
100
    bool valid_index(size_t index,size_t subindex) const
3827
101
    {
3828
102
        return (_pparam->_vector.size() > index && _pparam->_vector[index].size() > subindex);
3829
103
    };
3830
104
3831
105
private:
3832
106
    SatellitesArrayParam *_pparam;
3833
107
    size_t _index;
3834
108
};
3835
109
3836
110
} //namespace LivePathEffect
3837
111
3838
112
} //namespace Inkscape
3839
113
3840
114
#endif
3841
0
115
3842
=== modified file 'src/ui/dialog/lpe-fillet-chamfer-properties.cpp'
3843
--- src/ui/dialog/lpe-fillet-chamfer-properties.cpp	2017-03-12 13:45:15 +0000
3844
+++ src/ui/dialog/lpe-fillet-chamfer-properties.cpp	2017-05-06 17:46:29 +0000
3845
@@ -43,7 +43,6 @@
3846
43
    //todo: get tha max aloable infinity freeze the widget
43
    //todo: get tha max aloable infinity freeze the widget
3847
44
    _fillet_chamfer_position_numeric.set_range(0., SCALARPARAM_G_MAXDOUBLE);
44
    _fillet_chamfer_position_numeric.set_range(0., SCALARPARAM_G_MAXDOUBLE);
3848
45
    _fillet_chamfer_position_numeric.set_hexpand();
45
    _fillet_chamfer_position_numeric.set_hexpand();
3849
46
    
3850
47
    _fillet_chamfer_position_label.set_label(_("Radius (pixels):"));
46
    _fillet_chamfer_position_label.set_label(_("Radius (pixels):"));
3851
48
    _fillet_chamfer_position_label.set_alignment(1.0, 0.5);
47
    _fillet_chamfer_position_label.set_alignment(1.0, 0.5);
3852
49
48
3853
@@ -54,7 +53,6 @@
3854
54
    //todo: get tha max aloable infinity freeze the widget
53
    //todo: get tha max aloable infinity freeze the widget
3855
55
    _fillet_chamfer_chamfer_subdivisions.set_range(0, SCALARPARAM_G_MAXDOUBLE);
54
    _fillet_chamfer_chamfer_subdivisions.set_range(0, SCALARPARAM_G_MAXDOUBLE);
3856
56
    _fillet_chamfer_chamfer_subdivisions.set_hexpand();
55
    _fillet_chamfer_chamfer_subdivisions.set_hexpand();
3857
57
    
3858
58
    _fillet_chamfer_chamfer_subdivisions_label.set_label(_("Chamfer subdivisions:"));
56
    _fillet_chamfer_chamfer_subdivisions_label.set_label(_("Chamfer subdivisions:"));
3859
59
    _fillet_chamfer_chamfer_subdivisions_label.set_alignment(1.0, 0.5);
57
    _fillet_chamfer_chamfer_subdivisions_label.set_alignment(1.0, 0.5);
3860
60
58
3861
@@ -104,23 +102,26 @@
3862
104
FilletChamferPropertiesDialog::~FilletChamferPropertiesDialog()
102
FilletChamferPropertiesDialog::~FilletChamferPropertiesDialog()
3863
105
{
103
{
3864
106
104
3866
107
    _set_desktop(NULL);
105
    _setDesktop(NULL);
3867
108
}
106
}
3868
109
107
3869
110
void FilletChamferPropertiesDialog::showDialog(
108
void FilletChamferPropertiesDialog::showDialog(
3871
111
    SPDesktop *desktop, Geom::Point knotpoint,
109
    SPDesktop *desktop, 
3872
110
    double _amount,
3873
112
    const Inkscape::LivePathEffect::
111
    const Inkscape::LivePathEffect::
3877
113
    FilletChamferPointArrayParamKnotHolderEntity *pt,
112
    FilletChamferKnotHolderEntity *pt,
3878
114
    bool use_distance,
113
    bool _use_distance,
3879
115
    bool aprox_radius)
114
    bool _aprox_radius,
3880
115
    Satellite _satellite)
3881
116
{
116
{
3882
117
    FilletChamferPropertiesDialog *dialog = new FilletChamferPropertiesDialog();
117
    FilletChamferPropertiesDialog *dialog = new FilletChamferPropertiesDialog();
3883
118
118
3889
119
    dialog->_set_desktop(desktop);
119
    dialog->_setDesktop(desktop);
3890
120
    dialog->_set_use_distance(use_distance);
120
    dialog->_setUseDistance(_use_distance);
3891
121
    dialog->_set_aprox(aprox_radius);
121
    dialog->_setAprox(_aprox_radius);
3892
122
    dialog->_set_knot_point(knotpoint);
122
    dialog->_setAmount(_amount);
3893
123
    dialog->_set_pt(pt);
123
    dialog->_setSatellite(_satellite);
3894
124
    dialog->_setPt(pt);
3895
124
125
3896
125
    dialog->set_title(_("Modify Fillet-Chamfer"));
126
    dialog->set_title(_("Modify Fillet-Chamfer"));
3897
126
    dialog->_apply_button.set_label(_("_Modify"));
127
    dialog->_apply_button.set_label(_("_Modify"));
3898
@@ -135,34 +136,38 @@
3899
135
136
3900
136
void FilletChamferPropertiesDialog::_apply()
137
void FilletChamferPropertiesDialog::_apply()
3901
137
{
138
{
3903
138
    double d_width;
139
3904
139
    double d_pos =  _fillet_chamfer_position_numeric.get_value();
140
    double d_pos =  _fillet_chamfer_position_numeric.get_value();
3906
140
    if (d_pos) {
141
    if (d_pos >= 0) {
3907
141
        if (_fillet_chamfer_type_fillet.get_active() == true) {
142
        if (_fillet_chamfer_type_fillet.get_active() == true) {
3909
142
            d_width = 1;
143
            _satellite.satellite_type = FILLET;
3910
143
        } else if (_fillet_chamfer_type_inverse_fillet.get_active() == true) {
144
        } else if (_fillet_chamfer_type_inverse_fillet.get_active() == true) {
3912
144
            d_width = 2;
145
            _satellite.satellite_type = INVERSE_FILLET;
3913
145
        } else if (_fillet_chamfer_type_inverse_chamfer.get_active() == true) {
146
        } else if (_fillet_chamfer_type_inverse_chamfer.get_active() == true) {
3915
146
            d_width = _fillet_chamfer_chamfer_subdivisions.get_value() + 4000;
147
            _satellite.satellite_type = INVERSE_CHAMFER;
3916
147
        } else {
148
        } else {
3918
148
            d_width = _fillet_chamfer_chamfer_subdivisions.get_value() + 3000;
149
            _satellite.satellite_type = CHAMFER;
3919
149
        }
150
        }
3920
150
        if (_flexible) {
151
        if (_flexible) {
3921
151
            if (d_pos > 99.99999 || d_pos < 0) {
152
            if (d_pos > 99.99999 || d_pos < 0) {
3922
152
                d_pos = 0;
153
                d_pos = 0;
3923
153
            }
154
            }
3929
154
            d_pos = _index + (d_pos / 100);
155
            d_pos = d_pos / 100;
3930
155
        } else {
156
        }
3931
156
            d_pos = d_pos * -1;
157
        _satellite.amount = d_pos;
3932
157
        }
158
        size_t steps = (size_t)_fillet_chamfer_chamfer_subdivisions.get_value();
3933
158
        _knotpoint->knot_set_offset(Geom::Point(d_pos, d_width));
159
        if (steps < 1) {
3934
160
            steps = 1;
3935
161
        }
3936
162
        _satellite.steps = steps;
3937
163
        _knotpoint->knot_set_offset(_satellite);
3938
159
    }
164
    }
3939
160
    _close();
165
    _close();
3940
161
}
166
}
3941
162
167
3942
163
void FilletChamferPropertiesDialog::_close()
168
void FilletChamferPropertiesDialog::_close()
3943
164
{
169
{
3945
165
    _set_desktop(NULL);
170
    _setDesktop(NULL);
3946
166
    destroy_();
171
    destroy_();
3947
167
    Glib::signal_idle().connect(
172
    Glib::signal_idle().connect(
3948
168
        sigc::bind_return(
173
        sigc::bind_return(
3949
@@ -184,62 +189,68 @@
3950
184
    }
189
    }
3951
185
}
190
}
3952
186
191
3954
187
void FilletChamferPropertiesDialog::_set_knot_point(Geom::Point knotpoint)
192
void FilletChamferPropertiesDialog::_setSatellite(Satellite satellite)
3955
188
{
193
{
3956
189
    double position;
194
    double position;
3957
190
    std::string distance_or_radius = std::string(_("Radius"));
195
    std::string distance_or_radius = std::string(_("Radius"));
3959
191
    if(aprox){
196
    if (_aprox) {
3960
192
        distance_or_radius = std::string(_("Radius approximated"));
197
        distance_or_radius = std::string(_("Radius approximated"));
3961
193
    }
198
    }
3963
194
    if(use_distance){
199
    if (_use_distance) {
3964
195
        distance_or_radius = std::string(_("Knot distance"));
200
        distance_or_radius = std::string(_("Knot distance"));
3965
196
    }
201
    }
3969
197
    if (knotpoint.x() > 0) {
202
    if (satellite.is_time) {
3970
198
        double intpart;
203
        position = _amount * 100;
3968
199
        position = modf(knotpoint[Geom::X], &intpart) * 100;
3971
200
        _flexible = true;
204
        _flexible = true;
3972
201
        _index = intpart;
3973
202
        _fillet_chamfer_position_label.set_label(_("Position (%):"));
205
        _fillet_chamfer_position_label.set_label(_("Position (%):"));
3974
203
    } else {
206
    } else {
3975
204
        _flexible = false;
207
        _flexible = false;
3976
205
        std::string posConcat = Glib::ustring::compose (_("%1:"), distance_or_radius);
208
        std::string posConcat = Glib::ustring::compose (_("%1:"), distance_or_radius);
3977
206
        _fillet_chamfer_position_label.set_label(_(posConcat.c_str()));
209
        _fillet_chamfer_position_label.set_label(_(posConcat.c_str()));
3979
207
        position = knotpoint[Geom::X] * -1;
210
        position = _amount;
3980
208
    }
211
    }
3981
209
    _fillet_chamfer_position_numeric.set_value(position);
212
    _fillet_chamfer_position_numeric.set_value(position);
3983
210
    if (knotpoint.y() == 1) {
213
    _fillet_chamfer_chamfer_subdivisions.set_value(satellite.steps);
3984
214
    if (satellite.satellite_type == FILLET) {
3985
211
        _fillet_chamfer_type_fillet.set_active(true);
215
        _fillet_chamfer_type_fillet.set_active(true);
3987
212
    } else if (knotpoint.y() == 2) {
216
    } else if (satellite.satellite_type == INVERSE_FILLET) {
3988
213
        _fillet_chamfer_type_inverse_fillet.set_active(true);
217
        _fillet_chamfer_type_inverse_fillet.set_active(true);
3991
214
    } else if (knotpoint.y() >= 3000 && knotpoint.y() < 4000) {
218
    } else if (satellite.satellite_type == CHAMFER) {
3990
215
        _fillet_chamfer_chamfer_subdivisions.set_value(knotpoint.y() - 3000);
3992
216
        _fillet_chamfer_type_chamfer.set_active(true);
219
        _fillet_chamfer_type_chamfer.set_active(true);
3995
217
    } else if (knotpoint.y() >= 4000 && knotpoint.y() < 5000) {
220
    } else if (satellite.satellite_type == INVERSE_CHAMFER) {
3994
218
        _fillet_chamfer_chamfer_subdivisions.set_value(knotpoint.y() - 4000);
3996
219
        _fillet_chamfer_type_inverse_chamfer.set_active(true);
221
        _fillet_chamfer_type_inverse_chamfer.set_active(true);
3997
220
    }
222
    }
3998
223
    _satellite = satellite;
3999
221
}
224
}
4000
222
225
4002
223
void FilletChamferPropertiesDialog::_set_pt(
226
void FilletChamferPropertiesDialog::_setPt(
4003
224
    const Inkscape::LivePathEffect::
227
    const Inkscape::LivePathEffect::
4005
225
    FilletChamferPointArrayParamKnotHolderEntity *pt)
228
    FilletChamferKnotHolderEntity *pt)
4006
226
{
229
{
4007
227
    _knotpoint = const_cast<
230
    _knotpoint = const_cast<
4009
228
                 Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *>(
231
                 Inkscape::LivePathEffect::FilletChamferKnotHolderEntity *>(
4010
229
                     pt);
232
                     pt);
4011
230
}
233
}
4012
231
234
4024
232
void FilletChamferPropertiesDialog::_set_use_distance(bool use_knot_distance)
235
4025
233
{
236
void FilletChamferPropertiesDialog::_setAmount(double amount)
4026
234
    use_distance = use_knot_distance;
237
{
4027
235
}
238
    _amount = amount;
4028
236
239
}
4029
237
void FilletChamferPropertiesDialog::_set_aprox(bool aprox_radius)
240
4030
238
{
241
4031
239
    aprox = aprox_radius;
242
4032
240
}
243
void FilletChamferPropertiesDialog::_setUseDistance(bool use_knot_distance)
4033
241
244
{
4034
242
void FilletChamferPropertiesDialog::_set_desktop(SPDesktop *desktop)
245
    _use_distance = use_knot_distance;
4035
246
}
4036
247
4037
248
void FilletChamferPropertiesDialog::_setAprox(bool _aprox_radius)
4038
249
{
4039
250
    _aprox = _aprox_radius;
4040
251
}
4041
252
4042
253
void FilletChamferPropertiesDialog::_setDesktop(SPDesktop *desktop)
4043
243
{
254
{
4044
244
    if (desktop) {
255
    if (desktop) {
4045
245
        Inkscape::GC::anchor(desktop);
256
        Inkscape::GC::anchor(desktop);
4046
246
257
4047
=== modified file 'src/ui/dialog/lpe-fillet-chamfer-properties.h'
4048
--- src/ui/dialog/lpe-fillet-chamfer-properties.h	2017-03-12 13:37:33 +0000
4049
+++ src/ui/dialog/lpe-fillet-chamfer-properties.h	2017-05-06 17:46:29 +0000
4050
@@ -10,7 +10,7 @@
4051
10
10
4052
11
#include <2geom/point.h>
11
#include <2geom/point.h>
4053
12
#include <gtkmm.h>
12
#include <gtkmm.h>
4055
13
#include "live_effects/parameter/filletchamferpointarray.h"
13
#include "live_effects/parameter/satellitesarray.h"
4056
14
14
4057
15
class SPDesktop;
15
class SPDesktop;
4058
16
16
4059
@@ -23,20 +23,22 @@
4060
23
    FilletChamferPropertiesDialog();
23
    FilletChamferPropertiesDialog();
4061
24
    virtual ~FilletChamferPropertiesDialog();
24
    virtual ~FilletChamferPropertiesDialog();
4062
25
25
4064
26
    Glib::ustring getName() const {
26
    Glib::ustring getName() const
4065
27
    {
4066
27
        return "LayerPropertiesDialog";
28
        return "LayerPropertiesDialog";
4067
28
    }
29
    }
4068
29
30
4070
30
    static void showDialog(SPDesktop *desktop, Geom::Point knotpoint,
31
    static void showDialog(SPDesktop *desktop, double _amount,
4071
31
                           const Inkscape::LivePathEffect::
32
                           const Inkscape::LivePathEffect::
4075
32
                           FilletChamferPointArrayParamKnotHolderEntity *pt,
33
                           FilletChamferKnotHolderEntity *pt,
4076
33
                           bool use_distance,
34
                           bool _use_distance,
4077
34
                           bool aprox_radius);
35
                           bool _aprox_radius,
4078
36
                           Satellite _satellite);
4079
35
37
4080
36
protected:
38
protected:
4081
37
39
4082
38
    SPDesktop *_desktop;
40
    SPDesktop *_desktop;
4084
39
    Inkscape::LivePathEffect::FilletChamferPointArrayParamKnotHolderEntity *
41
    Inkscape::LivePathEffect::FilletChamferKnotHolderEntity *
4085
40
    _knotpoint;
42
    _knotpoint;
4086
41
43
4087
42
    Gtk::Label _fillet_chamfer_position_label;
44
    Gtk::Label _fillet_chamfer_position_label;
4088
@@ -51,36 +53,40 @@
4089
51
53
4090
52
    Gtk::Grid _layout_table;
54
    Gtk::Grid _layout_table;
4091
53
    bool _position_visible;
55
    bool _position_visible;
4092
54
    double _index;
4093
55
56
4094
56
    Gtk::Button _close_button;
57
    Gtk::Button _close_button;
4095
57
    Gtk::Button _apply_button;
58
    Gtk::Button _apply_button;
4096
58
59
4097
59
    sigc::connection _destroy_connection;
60
    sigc::connection _destroy_connection;
4098
60
61
4100
61
    static FilletChamferPropertiesDialog &_instance() {
62
    static FilletChamferPropertiesDialog &_instance()
4101
63
    {
4102
62
        static FilletChamferPropertiesDialog instance;
64
        static FilletChamferPropertiesDialog instance;
4103
63
        return instance;
65
        return instance;
4104
64
    }
66
    }
4105
65
67
4111
66
    void _set_desktop(SPDesktop *desktop);
68
    void _setDesktop(SPDesktop *desktop);
4112
67
    void _set_pt(const Inkscape::LivePathEffect::
69
    void _setPt(const Inkscape::LivePathEffect::
4113
68
                FilletChamferPointArrayParamKnotHolderEntity *pt);
70
                FilletChamferKnotHolderEntity *pt);
4114
69
    void _set_use_distance(bool use_knot_distance);
71
    void _setUseDistance(bool use_knot_distance);
4115
70
    void _set_aprox(bool aprox_radius);
72
    void _setAprox(bool aprox_radius);
4116
73
    void _setAmount(double amount);
4117
74
    void _setSatellite(Satellite satellite);
4118
75
    void _prepareLabelRenderer(Gtk::TreeModel::const_iterator const &row);
4119
76
4120
77
    bool _handleKeyEvent(GdkEventKey *event);
4121
78
    void _handleButtonEvent(GdkEventButton *event);
4122
79
4123
71
    void _apply();
80
    void _apply();
4124
72
    void _close();
81
    void _close();
4125
73
    bool _flexible;
82
    bool _flexible;
4133
74
    bool use_distance;
83
    Satellite _satellite;
4134
75
    bool aprox;
84
    bool _use_distance;
4135
76
    void _set_knot_point(Geom::Point knotpoint);
85
    double _amount;
4136
77
    void _prepareLabelRenderer(Gtk::TreeModel::const_iterator const &row);
86
    bool _aprox;
4130
78
4131
79
    bool _handleKeyEvent(GdkEventKey *event);
4132
80
    void _handleButtonEvent(GdkEventButton *event);
4137
81
87
4138
82
    friend class Inkscape::LivePathEffect::
88
    friend class Inkscape::LivePathEffect::
4140
83
            FilletChamferPointArrayParamKnotHolderEntity;
89
        FilletChamferKnotHolderEntity;
4141
84
90
4142
85
private:
91
private:
4143
86
    FilletChamferPropertiesDialog(
92
    FilletChamferPropertiesDialog(
4144
87
93
4145
=== modified file 'src/ui/tool/path-manipulator.cpp'
4146
--- src/ui/tool/path-manipulator.cpp	2016-12-06 21:22:02 +0000
4147
+++ src/ui/tool/path-manipulator.cpp	2017-05-06 17:46:29 +0000
4148
@@ -12,7 +12,6 @@
4149
12
12
4150
13
#include "live_effects/lpe-powerstroke.h"
13
#include "live_effects/lpe-powerstroke.h"
4151
14
#include "live_effects/lpe-bspline.h"
14
#include "live_effects/lpe-bspline.h"
4152
15
#include "live_effects/lpe-fillet-chamfer.h"
4153
16
#include <2geom/bezier-utils.h>
15
#include <2geom/bezier-utils.h>
4154
17
#include <2geom/path-sink.h>
16
#include <2geom/path-sink.h>
4155
18
#include "ui/tool/path-manipulator.h"
17
#include "ui/tool/path-manipulator.h"
4156
@@ -1364,13 +1363,6 @@
4157
1364
                    lpe_pwr->adjustForNewPath(pathv);
1363
                    lpe_pwr->adjustForNewPath(pathv);
4158
1365
                }
1364
                }
4159
1366
            }
1365
            }
4160
1367
            this_effect = _path->getPathEffectOfType(Inkscape::LivePathEffect::FILLET_CHAMFER);
4161
1368
            if(this_effect){
4162
1369
                LivePathEffect::LPEFilletChamfer *lpe_fll = dynamic_cast<LivePathEffect::LPEFilletChamfer*>(this_effect->getLPEObj()->get_lpe());
4163
1370
                if (lpe_fll) {
4164
1371
                    lpe_fll->adjustForNewPath(pathv);
4165
1372
                }
4166
1373
            }
4167
1374
        }
1366
        }
4168
1375
    }
1367
    }
4169
1376
1368
Status:	Merged
Merged at revision:	15666
Proposed branch:	lp:~inkscape.dev/inkscape/pathVectorSatellites
Merge into:	lp:~inkscape.dev/inkscape/trunk
Diff against target:	4168 lines (+2029/-1667) 20 files modified po/POTFILES.in (+1/-1) src/helper/CMakeLists.txt (+4/-0) src/helper/geom-pathvectorsatellites.cpp (+244/-0) src/helper/geom-pathvectorsatellites.h (+58/-0) src/helper/geom-satellite.cpp (+245/-0) src/helper/geom-satellite.h (+110/-0) src/knotholder.h (+3/-2) src/live_effects/CMakeLists.txt (+2/-2) src/live_effects/effect.cpp (+1/-1) src/live_effects/lpe-fillet-chamfer.cpp (+466/-543) src/live_effects/lpe-fillet-chamfer.h (+29/-35) src/live_effects/parameter/array.cpp (+40/-4) src/live_effects/parameter/array.h (+38/-1) src/live_effects/parameter/filletchamferpointarray.cpp (+0/-873) src/live_effects/parameter/filletchamferpointarray.h (+0/-123) src/live_effects/parameter/satellitesarray.cpp (+583/-0) src/live_effects/parameter/satellitesarray.h (+114/-0) src/ui/dialog/lpe-fillet-chamfer-properties.cpp (+63/-52) src/ui/dialog/lpe-fillet-chamfer-properties.h (+28/-22) src/ui/tool/path-manipulator.cpp (+0/-8)
To merge this branch:	bzr merge lp:~inkscape.dev/inkscape/pathVectorSatellites
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Jabiertxof		Needs Resubmitting on 2017-03-16
Krzysztof Kosinski	2015-03-31	Needs Fixing on 2016-05-08
Review via email: mp+254724@code.launchpad.net