0a449771e9e95b395045392049b37eb58845560a
1 #define __KNOT_HOLDER_ENTITY_C__
3 /** \file
4 * KnotHolderEntity definition.
5 *
6 * Authors:
7 * Mitsuru Oka <oka326@parkcity.ne.jp>
8 * Maximilian Albert <maximilian.albert@gmail.com>
9 *
10 * Copyright (C) 1999-2001 Lauris Kaplinski
11 * Copyright (C) 2000-2001 Ximian, Inc.
12 * Copyright (C) 2001 Mitsuru Oka
13 * Copyright (C) 2004 Monash University
14 * Copyright (C) 2008 Maximilian Albert
15 *
16 * Released under GNU GPL
17 */
19 #include "knotholder.h"
20 #include "sp-item.h"
21 #include "style.h"
22 #include "preferences.h"
23 #include "macros.h"
24 #include <libnr/nr-matrix-ops.h>
25 #include "sp-pattern.h"
26 #include "snap.h"
27 #include "desktop.h"
28 #include "sp-namedview.h"
29 #include <2geom/matrix.h>
30 #include <2geom/transforms.h>
32 int KnotHolderEntity::counter = 0;
34 void
35 KnotHolderEntity::create(SPDesktop *desktop, SPItem *item, KnotHolder *parent, const gchar *tip,
36 SPKnotShapeType shape, SPKnotModeType mode, guint32 color)
37 {
38 knot = sp_knot_new(desktop, tip);
40 this->parent_holder = parent;
41 this->item = item; // TODO: remove the item either from here or from knotholder.cpp
42 this->desktop = desktop;
44 my_counter = KnotHolderEntity::counter++;
46 g_object_set(G_OBJECT (knot->item), "shape", shape, NULL);
47 g_object_set(G_OBJECT (knot->item), "mode", mode, NULL);
49 knot->fill [SP_KNOT_STATE_NORMAL] = color;
50 g_object_set (G_OBJECT (knot->item), "fill_color", color, NULL);
52 update_knot();
53 sp_knot_show(knot);
55 _moved_connection = knot->_moved_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_moved_handler));
56 _click_connection = knot->_click_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_clicked_handler));
57 _ungrabbed_connection = knot->_ungrabbed_signal.connect(sigc::mem_fun(*parent_holder, &KnotHolder::knot_ungrabbed_handler));
58 }
61 KnotHolderEntity::~KnotHolderEntity()
62 {
63 _moved_connection.disconnect();
64 _click_connection.disconnect();
65 _ungrabbed_connection.disconnect();
67 /* unref should call destroy */
68 if (knot) {
69 g_object_unref(knot);
70 } else {
71 // FIXME: This shouldn't occur. Perhaps it is caused by LPE PointParams being knotholder entities, too
72 // If so, it will likely be fixed with upcoming refactoring efforts.
73 g_return_if_fail(knot);
74 }
75 }
77 void
78 KnotHolderEntity::update_knot()
79 {
80 Geom::Matrix const i2d(sp_item_i2d_affine(item));
82 Geom::Point dp(knot_get() * i2d);
84 _moved_connection.block();
85 sp_knot_set_position(knot, dp, SP_KNOT_STATE_NORMAL);
86 _moved_connection.unblock();
87 }
89 Geom::Point
90 KnotHolderEntity::snap_knot_position(Geom::Point const &p)
91 {
92 Geom::Matrix const i2d (sp_item_i2d_affine(item));
93 Geom::Point s = p * i2d;
95 SnapManager &m = desktop->namedview->snap_manager;
96 m.setup(desktop, true, item);
97 m.freeSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE);
98 m.unSetup();
100 return s * i2d.inverse();
101 }
103 Geom::Point
104 KnotHolderEntity::snap_knot_position_constrained(Geom::Point const &p, Inkscape::Snapper::SnapConstraint const &constraint)
105 {
106 Geom::Matrix const i2d (sp_item_i2d_affine(item));
107 Geom::Point s = p * i2d;
109 SnapManager &m = desktop->namedview->snap_manager;
110 m.setup(desktop, true, item);
112 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
113 if ((prefs->getBool("/options/snapmousepointer/value", false))) { // legacy behavior (pre v0.47)
114 // Snapping the mouse pointer instead of the constrained position of the knot allows to snap to
115 // things which don't intersect with the constraint line. This should be handled by the
116 // smart dynamic guides which are yet to be implemented, making this behavior more clean and
117 // transparent. With the current implementation it leads to unexpected results, and it doesn't
118 // allow accurately controlling what is being snapped to.
120 // freeSnap() will try snapping point p. This will not take into account the constraint, which
121 // is therefore to be enforced after snap_knot_position_constrained() has finished
122 m.freeSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE);
123 } else {
124 // constrainedSnap() will first project the point p onto the constraint line and then try to snap along that line.
125 // This way the constraint is already enforced, no need to worry about that later on
126 Inkscape::Snapper::SnapConstraint transformed_constraint = Inkscape::Snapper::SnapConstraint(constraint.getPoint() * i2d, (constraint.getPoint() + constraint.getDirection()) * i2d - constraint.getPoint() * i2d);
127 m.constrainedSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE, transformed_constraint);
128 }
129 m.unSetup();
131 return s * i2d.inverse();
132 }
135 /* Pattern manipulation */
137 /* TODO: this pattern manipulation is not able to handle general transformation matrices. Only matrices that are the result of a pure scale times a pure rotation. */
139 static gdouble sp_pattern_extract_theta(SPPattern *pat)
140 {
141 Geom::Matrix transf = pat->patternTransform;
142 return Geom::atan2(transf.xAxis());
143 }
145 static Geom::Point sp_pattern_extract_scale(SPPattern *pat)
146 {
147 Geom::Matrix transf = pat->patternTransform;
148 return Geom::Point( transf.expansionX(), transf.expansionY() );
149 }
151 static Geom::Point sp_pattern_extract_trans(SPPattern const *pat)
152 {
153 return Geom::Point(pat->patternTransform[4], pat->patternTransform[5]);
154 }
156 void
157 PatternKnotHolderEntityXY::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
158 {
159 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
161 // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
162 Geom::Point p_snapped = snap_knot_position(p);
164 if ( state & GDK_CONTROL_MASK ) {
165 if (fabs((p - origin)[Geom::X]) > fabs((p - origin)[Geom::Y])) {
166 p_snapped[Geom::Y] = origin[Geom::Y];
167 } else {
168 p_snapped[Geom::X] = origin[Geom::X];
169 }
170 }
172 if (state) {
173 Geom::Point const q = p_snapped - sp_pattern_extract_trans(pat);
174 sp_item_adjust_pattern(item, Geom::Matrix(Geom::Translate(q)));
175 }
177 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
178 }
180 Geom::Point
181 PatternKnotHolderEntityXY::knot_get()
182 {
183 SPPattern const *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
184 return sp_pattern_extract_trans(pat);
185 }
187 Geom::Point
188 PatternKnotHolderEntityAngle::knot_get()
189 {
190 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
192 gdouble x = (pattern_width(pat));
193 gdouble y = 0;
194 Geom::Point delta = Geom::Point(x,y);
195 Geom::Point scale = sp_pattern_extract_scale(pat);
196 gdouble theta = sp_pattern_extract_theta(pat);
197 delta = delta * Geom::Matrix(Geom::Scale(scale))*Geom::Matrix(Geom::Rotate(theta));
198 delta = delta + sp_pattern_extract_trans(pat);
199 return delta;
200 }
202 void
203 PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
204 {
205 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
206 int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
208 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
210 // get the angle from pattern 0,0 to the cursor pos
211 Geom::Point delta = p - sp_pattern_extract_trans(pat);
212 gdouble theta = atan2(delta);
214 if ( state & GDK_CONTROL_MASK ) {
215 theta = sp_round(theta, M_PI/snaps);
216 }
218 // get the scale from the current transform so we can keep it.
219 Geom::Point scl = sp_pattern_extract_scale(pat);
220 Geom::Matrix rot = Geom::Matrix(Geom::Scale(scl)) * Geom::Matrix(Geom::Rotate(theta));
221 Geom::Point const t = sp_pattern_extract_trans(pat);
222 rot[4] = t[Geom::X];
223 rot[5] = t[Geom::Y];
224 sp_item_adjust_pattern(item, rot, true);
225 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
226 }
228 void
229 PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
230 {
231 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
233 // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
234 Geom::Point p_snapped = snap_knot_position(p);
236 // get angle from current transform
237 gdouble theta = sp_pattern_extract_theta(pat);
239 // Get the new scale from the position of the knotholder
240 Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
241 gdouble pat_x = pattern_width(pat);
242 gdouble pat_y = pattern_height(pat);
243 Geom::Scale scl(1);
244 if ( state & GDK_CONTROL_MASK ) {
245 // if ctrl is pressed: use 1:1 scaling
246 gdouble pat_h = hypot(pat_x, pat_y);
247 scl = Geom::Scale(d.length() / pat_h);
248 } else {
249 d *= Geom::Rotate(-theta);
250 scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
251 }
253 Geom::Matrix rot = (Geom::Matrix)scl * Geom::Rotate(theta);
255 Geom::Point const t = sp_pattern_extract_trans(pat);
256 rot[4] = t[Geom::X];
257 rot[5] = t[Geom::Y];
258 sp_item_adjust_pattern(item, rot, true);
259 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
260 }
263 Geom::Point
264 PatternKnotHolderEntityScale::knot_get()
265 {
266 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
268 gdouble x = pattern_width(pat);
269 gdouble y = pattern_height(pat);
270 Geom::Point delta = Geom::Point(x,y);
271 Geom::Matrix a = pat->patternTransform;
272 a[4] = 0;
273 a[5] = 0;
274 delta = delta * a;
275 delta = delta + sp_pattern_extract_trans(pat);
276 return delta;
277 }
279 /*
280 Local Variables:
281 mode:c++
282 c-file-style:"stroustrup"
283 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
284 indent-tabs-mode:nil
285 fill-column:99
286 End:
287 */
288 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :