1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
// SPDX-License-Identifier: GPL-2.0-or-later
#ifndef INKSCAPE_LIVEPATHEFFECT_H
#define INKSCAPE_LIVEPATHEFFECT_H
/*
* Copyright (C) Johan Engelen 2007-2012 <j.b.c.engelen@alumnus.utwente.nl>
*
* Released under GNU GPL v2+, read the file 'COPYING' for more information.
*/
#include "effect-enum.h"
#include "parameter/bool.h"
#include "parameter/hidden.h"
#include "ui/widget/registry.h"
#include <2geom/forward.h>
#include <glibmm/ustring.h>
#include <gtkmm/eventbox.h>
#include <gtkmm/expander.h>
#define LPE_CONVERSION_TOLERANCE 0.01 // FIXME: find good solution for this.
class SPDocument;
class SPDesktop;
class SPItem;
class LivePathEffectObject;
class SPLPEItem;
class KnotHolder;
class KnotHolderEntity;
class SPPath;
class SPCurve;
namespace Gtk {
class Widget;
}
namespace Inkscape {
namespace XML {
class Node;
}
namespace LivePathEffect {
enum LPEPathFlashType {
SUPPRESS_FLASH,
// PERMANENT_FLASH,
DEFAULT
};
enum LPEAction {
LPE_ERASE = 0,
LPE_TO_OBJECTS,
LPE_VISIBILITY
};
class Effect {
public:
static Effect* New(EffectType lpenr, LivePathEffectObject *lpeobj);
static void createAndApply(const char* name, SPDocument *doc, SPItem *item);
static void createAndApply(EffectType type, SPDocument *doc, SPItem *item);
virtual ~Effect();
Effect(const Effect&) = delete;
Effect& operator=(const Effect&) = delete;
EffectType effectType() const;
//basically, to get this method called before the derived classes, a bit
//of indirection is needed. We first call these methods, then the below.
void doAfterEffect_impl(SPLPEItem const *lpeitem);
void doOnApply_impl(SPLPEItem const* lpeitem);
void doBeforeEffect_impl(SPLPEItem const* lpeitem);
void setCurrentZoom(double cZ);
void setSelectedNodePoints(std::vector<Geom::Point> sNP);
bool isNodePointSelected(Geom::Point const &nodePoint) const;
virtual void doOnApply (SPLPEItem const* lpeitem);
virtual void doBeforeEffect (SPLPEItem const* lpeitem);
virtual void transform_multiply(Geom::Affine const &postmul, bool set);
virtual void doAfterEffect (SPLPEItem const* lpeitem);
virtual void doOnException(SPLPEItem const *lpeitem);
virtual void doOnRemove (SPLPEItem const* lpeitem);
virtual void doOnVisibilityToggled(SPLPEItem const* lpeitem);
void writeParamsToSVG();
virtual void acceptParamPath (SPPath const* param_path);
static int acceptsNumClicks(EffectType type);
int acceptsNumClicks() const { return acceptsNumClicks(effectType()); }
void doAcceptPathPreparations(SPLPEItem *lpeitem);
SPShape * getCurrentShape() const { return current_shape; };
void setCurrentShape(SPShape * shape) { current_shape = shape; }
void processObjects(LPEAction lpe_action);
/*
* isReady() indicates whether all preparations which are necessary to apply the LPE are done,
* e.g., waiting for a parameter path either before the effect is created or when it needs a
* path as argument. This is set in SPLPEItem::addPathEffect().
*/
inline bool isReady() const { return is_ready; }
inline void setReady(bool ready = true) { is_ready = ready; }
virtual void doEffect (SPCurve * curve);
virtual Gtk::Widget * newWidget();
virtual Gtk::Widget * defaultParamSet();
/**
* Sets all parameters to their default values and writes them to SVG.
*/
virtual void resetDefaults(SPItem const* item);
// /TODO: providesKnotholder() is currently used as an indicator of whether a nodepath is
// created for an item or not. When we allow both at the same time, this needs rethinking!
bool providesKnotholder() const;
// /TODO: in view of providesOwnFlashPaths() below, this is somewhat redundant
// (but spiro lpe still needs it!)
virtual LPEPathFlashType pathFlashType() const { return DEFAULT; }
void addHandles(KnotHolder *knotholder, SPItem *item);
std::vector<Geom::PathVector> getCanvasIndicators(SPLPEItem const* lpeitem);
void update_helperpath();
bool has_exception;
inline bool providesOwnFlashPaths() const {
return provides_own_flash_paths || show_orig_path;
}
inline bool showOrigPath() const { return show_orig_path; }
Glib::ustring getName() const;
Inkscape::XML::Node * getRepr();
SPDocument * getSPDoc();
LivePathEffectObject * getLPEObj() {return lpeobj;};
LivePathEffectObject const * getLPEObj() const {return lpeobj;};
Parameter * getParameter(const char * key);
void readallParameters(Inkscape::XML::Node const* repr);
void setParameter(const gchar * key, const gchar * new_value);
inline bool isVisible() const { return is_visible; }
void editNextParamOncanvas(SPItem * item, SPDesktop * desktop);
bool apply_to_clippath_and_mask;
bool keep_paths; // set this to false allow retain extra generated objects, see measure line LPE
bool is_load;
bool refresh_widgets;
BoolParam is_visible;
HiddenParam lpeversion;
Geom::PathVector pathvector_before_effect;
Geom::PathVector pathvector_after_effect;
SPLPEItem *sp_lpe_item; // these get stored in doBeforeEffect_impl, and derived classes may do as they please with
// them.
SPShape *current_shape; // these get stored in performPathEffects.
protected:
Effect(LivePathEffectObject *lpeobject);
// provide a set of doEffect functions so the developer has a choice
// of what kind of input/output parameters he desires.
// the order in which they appear is the order in which they are
// called by this base class. (i.e. doEffect(SPCurve * curve) defaults to calling
// doEffect(Geom::PathVector )
virtual Geom::PathVector
doEffect_path (Geom::PathVector const & path_in);
virtual Geom::Piecewise<Geom::D2<Geom::SBasis> >
doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in);
void registerParameter(Parameter * param);
Parameter * getNextOncanvasEditableParam();
virtual void addKnotHolderEntities(KnotHolder * /*knotholder*/, SPItem * /*item*/) {};
virtual void addCanvasIndicators(SPLPEItem const* lpeitem, std::vector<Geom::PathVector> &hp_vec);
std::vector<Parameter *> param_vector;
bool _provides_knotholder_entities;
int oncanvasedit_it;
bool is_applied;
bool show_orig_path; // set this to true in derived effects to automatically have the original
// path displayed as helperpath
Inkscape::UI::Widget::Registry wr;
LivePathEffectObject *lpeobj;
// this boolean defaults to false, it concatenates the input path to one pwd2,
// instead of normally 'splitting' the path into continuous pwd2 paths and calling doEffect_pwd2 for each.
bool concatenate_before_pwd2;
std::vector<Glib::ustring> items;
double current_zoom;
std::vector<Geom::Point> selectedNodesPoints;
private:
void onDefaultsExpanderChanged(Gtk::Expander * expander);
void setDefaultParam(Glib::ustring pref_path, Glib::ustring tooltip, Parameter *param, Gtk::Image *info,
Gtk::Button *set, Gtk::Button *unset);
void unsetDefaultParam(Glib::ustring pref_path, Glib::ustring tooltip, Parameter *param, Gtk::Image *info,
Gtk::Button *set, Gtk::Button *unset);
bool provides_own_flash_paths; // if true, the standard flash path is suppressed
bool is_ready;
bool defaultsopen;
};
} //namespace LivePathEffect
} //namespace Inkscape
#endif
/*
Local Variables:
mode:c++
c-file-style:"stroustrup"
c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
indent-tabs-mode:nil
fill-column:99
End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
|
