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 // constrainedSnap() will first project the point p onto the constraint line and then try to snap along that line.
114 // This way the constraint is already enforced, no need to worry about that later on
115 Inkscape::Snapper::SnapConstraint transformed_constraint = Inkscape::Snapper::SnapConstraint(constraint.getPoint() * i2d, (constraint.getPoint() + constraint.getDirection()) * i2d - constraint.getPoint() * i2d);
116 m.constrainedSnapReturnByRef(s, Inkscape::SNAPSOURCE_NODE_HANDLE, transformed_constraint);
117 m.unSetup();
119 return s * i2d.inverse();
120 }
123 /* Pattern manipulation */
125 /* 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. */
127 static gdouble sp_pattern_extract_theta(SPPattern *pat)
128 {
129 Geom::Matrix transf = pat->patternTransform;
130 return Geom::atan2(transf.xAxis());
131 }
133 static Geom::Point sp_pattern_extract_scale(SPPattern *pat)
134 {
135 Geom::Matrix transf = pat->patternTransform;
136 return Geom::Point( transf.expansionX(), transf.expansionY() );
137 }
139 static Geom::Point sp_pattern_extract_trans(SPPattern const *pat)
140 {
141 return Geom::Point(pat->patternTransform[4], pat->patternTransform[5]);
142 }
144 void
145 PatternKnotHolderEntityXY::knot_set(Geom::Point const &p, Geom::Point const &origin, guint state)
146 {
147 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
149 // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
150 Geom::Point p_snapped = snap_knot_position(p);
152 if ( state & GDK_CONTROL_MASK ) {
153 if (fabs((p - origin)[Geom::X]) > fabs((p - origin)[Geom::Y])) {
154 p_snapped[Geom::Y] = origin[Geom::Y];
155 } else {
156 p_snapped[Geom::X] = origin[Geom::X];
157 }
158 }
160 if (state) {
161 Geom::Point const q = p_snapped - sp_pattern_extract_trans(pat);
162 sp_item_adjust_pattern(item, Geom::Matrix(Geom::Translate(q)));
163 }
165 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
166 }
168 Geom::Point
169 PatternKnotHolderEntityXY::knot_get()
170 {
171 SPPattern const *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
172 return sp_pattern_extract_trans(pat);
173 }
175 Geom::Point
176 PatternKnotHolderEntityAngle::knot_get()
177 {
178 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
180 gdouble x = (pattern_width(pat));
181 gdouble y = 0;
182 Geom::Point delta = Geom::Point(x,y);
183 Geom::Point scale = sp_pattern_extract_scale(pat);
184 gdouble theta = sp_pattern_extract_theta(pat);
185 delta = delta * Geom::Matrix(Geom::Scale(scale))*Geom::Matrix(Geom::Rotate(theta));
186 delta = delta + sp_pattern_extract_trans(pat);
187 return delta;
188 }
190 void
191 PatternKnotHolderEntityAngle::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
192 {
193 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
194 int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
196 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
198 // get the angle from pattern 0,0 to the cursor pos
199 Geom::Point delta = p - sp_pattern_extract_trans(pat);
200 gdouble theta = atan2(delta);
202 if ( state & GDK_CONTROL_MASK ) {
203 theta = sp_round(theta, M_PI/snaps);
204 }
206 // get the scale from the current transform so we can keep it.
207 Geom::Point scl = sp_pattern_extract_scale(pat);
208 Geom::Matrix rot = Geom::Matrix(Geom::Scale(scl)) * Geom::Matrix(Geom::Rotate(theta));
209 Geom::Point const t = sp_pattern_extract_trans(pat);
210 rot[4] = t[Geom::X];
211 rot[5] = t[Geom::Y];
212 sp_item_adjust_pattern(item, rot, true);
213 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
214 }
216 void
217 PatternKnotHolderEntityScale::knot_set(Geom::Point const &p, Geom::Point const &/*origin*/, guint state)
218 {
219 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
221 // FIXME: this snapping should be done together with knowing whether control was pressed. If GDK_CONTROL_MASK, then constrained snapping should be used.
222 Geom::Point p_snapped = snap_knot_position(p);
224 // get angle from current transform
225 gdouble theta = sp_pattern_extract_theta(pat);
227 // Get the new scale from the position of the knotholder
228 Geom::Point d = p_snapped - sp_pattern_extract_trans(pat);
229 gdouble pat_x = pattern_width(pat);
230 gdouble pat_y = pattern_height(pat);
231 Geom::Scale scl(1);
232 if ( state & GDK_CONTROL_MASK ) {
233 // if ctrl is pressed: use 1:1 scaling
234 gdouble pat_h = hypot(pat_x, pat_y);
235 scl = Geom::Scale(d.length() / pat_h);
236 } else {
237 d *= Geom::Rotate(-theta);
238 scl = Geom::Scale(d[Geom::X] / pat_x, d[Geom::Y] / pat_y);
239 }
241 Geom::Matrix rot = (Geom::Matrix)scl * Geom::Rotate(theta);
243 Geom::Point const t = sp_pattern_extract_trans(pat);
244 rot[4] = t[Geom::X];
245 rot[5] = t[Geom::Y];
246 sp_item_adjust_pattern(item, rot, true);
247 item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
248 }
251 Geom::Point
252 PatternKnotHolderEntityScale::knot_get()
253 {
254 SPPattern *pat = SP_PATTERN(SP_STYLE_FILL_SERVER(SP_OBJECT(item)->style));
256 gdouble x = pattern_width(pat);
257 gdouble y = pattern_height(pat);
258 Geom::Point delta = Geom::Point(x,y);
259 Geom::Matrix a = pat->patternTransform;
260 a[4] = 0;
261 a[5] = 0;
262 delta = delta * a;
263 delta = delta + sp_pattern_extract_trans(pat);
264 return delta;
265 }
267 /*
268 Local Variables:
269 mode:c++
270 c-file-style:"stroustrup"
271 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
272 indent-tabs-mode:nil
273 fill-column:99
274 End:
275 */
276 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :