1 #define __SP_KNOT_C__
3 /** \file
4 * SPKnot implementation
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * bulia byak <buliabyak@users.sf.net>
9 *
10 * Copyright (C) 1999-2005 authors
11 * Copyright (C) 2001-2002 Ximian, Inc.
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #ifdef HAVE_CONFIG_H
17 # include <config.h>
18 #endif
19 #include <gdk/gdkkeysyms.h>
20 #include <glibmm/i18n.h>
21 #include "helper/sp-marshal.h"
22 #include "display/sodipodi-ctrl.h"
23 #include "desktop.h"
24 #include "desktop-handles.h"
25 #include "knot.h"
26 #include "document.h"
27 #include "prefs-utils.h"
28 #include "message-stack.h"
29 #include "message-context.h"
30 #include "event-context.h"
33 #define KNOT_EVENT_MASK (GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | \
34 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | \
35 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)
37 static bool nograb = false;
39 static bool grabbed = FALSE;
40 static bool moved = FALSE;
42 static gint xp = 0, yp = 0; // where drag started
43 static gint tolerance = 0;
44 static bool within_tolerance = false;
46 static bool transform_escaped = false; // true iff resize or rotate was cancelled by esc.
48 enum {
49 EVENT,
50 CLICKED,
51 DOUBLECLICKED,
52 GRABBED,
53 UNGRABBED,
54 MOVED,
55 REQUEST,
56 DISTANCE,
57 LAST_SIGNAL
58 };
60 static void sp_knot_class_init(SPKnotClass *klass);
61 static void sp_knot_init(SPKnot *knot);
62 static void sp_knot_dispose(GObject *object);
64 static int sp_knot_handler(SPCanvasItem *item, GdkEvent *event, SPKnot *knot);
65 static void sp_knot_set_flag(SPKnot *knot, guint flag, bool set);
66 static void sp_knot_set_ctrl_state(SPKnot *knot);
68 static GObjectClass *parent_class;
69 static guint knot_signals[LAST_SIGNAL] = { 0 };
71 /**
72 * Registers SPKnot class and returns its type number.
73 */
74 GType sp_knot_get_type()
75 {
76 static GType type = 0;
77 if (!type) {
78 GTypeInfo info = {
79 sizeof(SPKnotClass),
80 NULL, /* base_init */
81 NULL, /* base_finalize */
82 (GClassInitFunc) sp_knot_class_init,
83 NULL, /* class_finalize */
84 NULL, /* class_data */
85 sizeof (SPKnot),
86 16, /* n_preallocs */
87 (GInstanceInitFunc) sp_knot_init,
88 NULL
89 };
90 type = g_type_register_static (G_TYPE_OBJECT, "SPKnot", &info, (GTypeFlags) 0);
91 }
92 return type;
93 }
95 /**
96 * SPKnot vtable initialization.
97 */
98 static void sp_knot_class_init(SPKnotClass *klass)
99 {
100 GObjectClass *object_class = (GObjectClass*)klass;
102 parent_class = (GObjectClass*) g_type_class_peek_parent(klass);
104 object_class->dispose = sp_knot_dispose;
106 knot_signals[EVENT] = g_signal_new("event",
107 G_TYPE_FROM_CLASS(klass),
108 G_SIGNAL_RUN_LAST,
109 G_STRUCT_OFFSET(SPKnotClass, event),
110 NULL, NULL,
111 sp_marshal_BOOLEAN__POINTER,
112 G_TYPE_BOOLEAN, 1,
113 GDK_TYPE_EVENT);
115 knot_signals[CLICKED] = g_signal_new("clicked",
116 G_TYPE_FROM_CLASS(klass),
117 G_SIGNAL_RUN_FIRST,
118 G_STRUCT_OFFSET(SPKnotClass, clicked),
119 NULL, NULL,
120 sp_marshal_NONE__UINT,
121 G_TYPE_NONE, 1,
122 G_TYPE_UINT);
124 knot_signals[DOUBLECLICKED] = g_signal_new("doubleclicked",
125 G_TYPE_FROM_CLASS(klass),
126 G_SIGNAL_RUN_FIRST,
127 G_STRUCT_OFFSET(SPKnotClass, doubleclicked),
128 NULL, NULL,
129 sp_marshal_NONE__UINT,
130 G_TYPE_NONE, 1,
131 G_TYPE_UINT);
133 knot_signals[GRABBED] = g_signal_new("grabbed",
134 G_TYPE_FROM_CLASS(klass),
135 G_SIGNAL_RUN_FIRST,
136 G_STRUCT_OFFSET(SPKnotClass, grabbed),
137 NULL, NULL,
138 sp_marshal_NONE__UINT,
139 G_TYPE_NONE, 1,
140 G_TYPE_UINT);
142 knot_signals[UNGRABBED] = g_signal_new("ungrabbed",
143 G_TYPE_FROM_CLASS(klass),
144 G_SIGNAL_RUN_FIRST,
145 G_STRUCT_OFFSET(SPKnotClass, ungrabbed),
146 NULL, NULL,
147 sp_marshal_NONE__UINT,
148 G_TYPE_NONE, 1,
149 G_TYPE_UINT);
151 knot_signals[MOVED] = g_signal_new("moved",
152 G_TYPE_FROM_CLASS(klass),
153 G_SIGNAL_RUN_FIRST,
154 G_STRUCT_OFFSET(SPKnotClass, moved),
155 NULL, NULL,
156 sp_marshal_NONE__POINTER_UINT,
157 G_TYPE_NONE, 2,
158 G_TYPE_POINTER, G_TYPE_UINT);
160 knot_signals[REQUEST] = g_signal_new("request",
161 G_TYPE_FROM_CLASS(klass),
162 G_SIGNAL_RUN_LAST,
163 G_STRUCT_OFFSET(SPKnotClass, request),
164 NULL, NULL,
165 sp_marshal_BOOLEAN__POINTER_UINT,
166 G_TYPE_BOOLEAN, 2,
167 G_TYPE_POINTER, G_TYPE_UINT);
169 knot_signals[DISTANCE] = g_signal_new("distance",
170 G_TYPE_FROM_CLASS(klass),
171 G_SIGNAL_RUN_LAST,
172 G_STRUCT_OFFSET(SPKnotClass, distance),
173 NULL, NULL,
174 sp_marshal_DOUBLE__POINTER_UINT,
175 G_TYPE_DOUBLE, 2,
176 G_TYPE_POINTER, G_TYPE_UINT);
178 const gchar *nograbenv = getenv("INKSCAPE_NO_GRAB");
179 nograb = (nograbenv && *nograbenv && (*nograbenv != '0'));
180 }
182 /**
183 * Callback for SPKnot initialization.
184 */
185 static void sp_knot_init(SPKnot *knot)
186 {
187 knot->desktop = NULL;
188 knot->item = NULL;
189 knot->flags = 0;
191 knot->size = 8;
192 knot->pos = NR::Point(0, 0);
193 knot->grabbed_rel_pos = NR::Point(0, 0);
194 knot->anchor = GTK_ANCHOR_CENTER;
195 knot->shape = SP_KNOT_SHAPE_SQUARE;
196 knot->mode = SP_KNOT_MODE_XOR;
197 knot->tip = NULL;
198 knot->_event_handler_id = 0;
200 knot->fill[SP_KNOT_STATE_NORMAL] = 0xffffff00;
201 knot->fill[SP_KNOT_STATE_MOUSEOVER] = 0xff0000ff;
202 knot->fill[SP_KNOT_STATE_DRAGGING] = 0x0000ffff;
204 knot->stroke[SP_KNOT_STATE_NORMAL] = 0x01000000;
205 knot->stroke[SP_KNOT_STATE_MOUSEOVER] = 0x01000000;
206 knot->stroke[SP_KNOT_STATE_DRAGGING] = 0x01000000;
208 knot->image[SP_KNOT_STATE_NORMAL] = NULL;
209 knot->image[SP_KNOT_STATE_MOUSEOVER] = NULL;
210 knot->image[SP_KNOT_STATE_DRAGGING] = NULL;
212 knot->cursor[SP_KNOT_STATE_NORMAL] = NULL;
213 knot->cursor[SP_KNOT_STATE_MOUSEOVER] = NULL;
214 knot->cursor[SP_KNOT_STATE_DRAGGING] = NULL;
216 knot->saved_cursor = NULL;
217 knot->pixbuf = NULL;
218 }
220 /**
221 * Called before SPKnot destruction.
222 */
223 static void sp_knot_dispose(GObject *object)
224 {
225 SPKnot *knot = (SPKnot *) object;
227 if ((knot->flags & SP_KNOT_GRABBED) && gdk_pointer_is_grabbed ()) {
228 // This happens e.g. when deleting a node in node tool while dragging it
229 gdk_pointer_ungrab (GDK_CURRENT_TIME);
230 }
232 if (knot->_event_handler_id > 0)
233 {
234 g_signal_handler_disconnect(G_OBJECT (knot->item), knot->_event_handler_id);
235 knot->_event_handler_id = 0;
236 }
238 if (knot->item) {
239 gtk_object_destroy (GTK_OBJECT (knot->item));
240 knot->item = NULL;
241 }
243 for (gint i = 0; i < SP_KNOT_VISIBLE_STATES; i++) {
244 if (knot->cursor[i]) {
245 gdk_cursor_unref(knot->cursor[i]);
246 knot->cursor[i] = NULL;
247 }
248 }
250 if (knot->tip) {
251 g_free(knot->tip);
252 knot->tip = NULL;
253 }
255 if (parent_class->dispose) {
256 (*parent_class->dispose) (object);
257 }
258 }
260 /**
261 * Update knot for dragging and tell canvas an item was grabbed.
262 */
263 void sp_knot_start_dragging(SPKnot *knot, NR::Point p, gint x, gint y, guint32 etime)
264 {
265 // save drag origin
266 xp = x;
267 yp = y;
268 within_tolerance = true;
270 knot->grabbed_rel_pos = p - knot->pos;
271 knot->drag_origin = knot->pos;
272 if (!nograb) {
273 sp_canvas_item_grab(knot->item,
274 KNOT_EVENT_MASK,
275 knot->cursor[SP_KNOT_STATE_DRAGGING],
276 etime);
277 }
278 sp_knot_set_flag(knot, SP_KNOT_GRABBED, TRUE);
279 grabbed = TRUE;
280 }
282 /**
283 * Called to handle events on knots.
284 */
285 static int sp_knot_handler(SPCanvasItem *item, GdkEvent *event, SPKnot *knot)
286 {
287 g_assert(knot != NULL);
288 g_assert(SP_IS_KNOT(knot));
290 g_object_ref(knot);
291 tolerance = prefs_get_int_attribute_limited("options.dragtolerance", "value", 0, 0, 100);
293 gboolean consumed = FALSE;
295 /* Run client universal event handler, if present */
297 g_signal_emit(knot, knot_signals[EVENT], 0, event, &consumed);
299 if (consumed) {
300 return TRUE;
301 }
303 switch (event->type) {
304 case GDK_2BUTTON_PRESS:
305 if (event->button.button == 1) {
306 g_signal_emit(knot, knot_signals[DOUBLECLICKED], 0, event->button.state);
308 grabbed = FALSE;
309 moved = FALSE;
310 consumed = TRUE;
311 }
312 break;
313 case GDK_BUTTON_PRESS:
314 if (event->button.button == 1) {
315 NR::Point const p = knot->desktop->w2d(NR::Point(event->button.x, event->button.y));
316 sp_knot_start_dragging(knot, p, (gint) event->button.x, (gint) event->button.y, event->button.time);
317 consumed = TRUE;
318 }
319 break;
320 case GDK_BUTTON_RELEASE:
321 if (event->button.button == 1) {
322 if (transform_escaped) {
323 transform_escaped = false;
324 consumed = TRUE;
325 } else {
326 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
327 if (!nograb) {
328 sp_canvas_item_ungrab(knot->item, event->button.time);
329 }
330 if (moved) {
331 sp_knot_set_flag(knot,
332 SP_KNOT_DRAGGING,
333 FALSE);
334 g_signal_emit(knot,
335 knot_signals[UNGRABBED], 0,
336 event->button.state);
337 } else {
338 g_signal_emit(knot,
339 knot_signals[CLICKED], 0,
340 event->button.state);
341 }
342 grabbed = FALSE;
343 moved = FALSE;
344 consumed = TRUE;
345 }
346 }
347 break;
348 case GDK_MOTION_NOTIFY:
349 if (grabbed) {
350 consumed = TRUE;
352 if ( within_tolerance
353 && ( abs( (gint) event->motion.x - xp ) < tolerance )
354 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
355 break; // do not drag if we're within tolerance from origin
356 }
358 // Once the user has moved farther than tolerance from the original location
359 // (indicating they intend to move the object, not click), then always process the
360 // motion notify coordinates as given (no snapping back to origin)
361 within_tolerance = false;
363 if (!moved) {
364 g_signal_emit(knot,
365 knot_signals[GRABBED], 0,
366 event->motion.state);
367 sp_knot_set_flag(knot,
368 SP_KNOT_DRAGGING,
369 TRUE);
370 }
371 NR::Point const motion_w(event->motion.x, event->motion.y);
372 NR::Point const motion_dt = knot->desktop->w2d(motion_w);
373 NR::Point p = motion_dt - knot->grabbed_rel_pos;
374 sp_knot_request_position (knot, &p, event->motion.state);
375 knot->desktop->scroll_to_point (&motion_dt);
376 moved = TRUE;
377 }
378 break;
379 case GDK_ENTER_NOTIFY:
380 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, TRUE);
381 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
383 if (knot->tip) {
384 knot->desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, knot->tip);
385 }
387 grabbed = FALSE;
388 moved = FALSE;
389 consumed = TRUE;
390 break;
391 case GDK_LEAVE_NOTIFY:
392 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, FALSE);
393 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
395 if (knot->tip) {
396 knot->desktop->event_context->defaultMessageContext()->clear();
397 }
399 grabbed = FALSE;
400 moved = FALSE;
402 consumed = TRUE;
403 break;
404 case GDK_KEY_PRESS: // keybindings for knot
405 switch (get_group0_keyval(&event->key)) {
406 case GDK_Escape:
407 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
408 if (!nograb) {
409 sp_canvas_item_ungrab(knot->item, event->button.time);
410 }
411 if (moved) {
412 sp_knot_set_flag(knot,
413 SP_KNOT_DRAGGING,
414 FALSE);
415 g_signal_emit(knot,
416 knot_signals[UNGRABBED], 0,
417 event->button.state);
418 sp_document_undo(SP_DT_DOCUMENT(knot->desktop));
419 knot->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Node or handle drag canceled."));
420 transform_escaped = true;
421 consumed = TRUE;
422 }
423 grabbed = FALSE;
424 moved = FALSE;
425 break;
426 default:
427 consumed = FALSE;
428 break;
429 }
430 break;
431 default:
432 break;
433 }
435 g_object_unref(knot);
437 return consumed;
438 }
440 /**
441 * Return new knot object.
442 */
443 SPKnot *sp_knot_new(SPDesktop *desktop, const gchar *tip)
444 {
445 g_return_val_if_fail(desktop != NULL, NULL);
447 SPKnot * knot = (SPKnot*) g_object_new(SP_TYPE_KNOT, 0);
449 knot->desktop = desktop;
450 knot->flags = SP_KNOT_VISIBLE;
451 if (tip) {
452 knot->tip = g_strdup (tip);
453 }
455 knot->item = sp_canvas_item_new(SP_DT_CONTROLS (desktop),
456 SP_TYPE_CTRL,
457 "anchor", GTK_ANCHOR_CENTER,
458 "size", 8.0,
459 "filled", TRUE,
460 "fill_color", 0xffffff00,
461 "stroked", TRUE,
462 "stroke_color", 0x01000000,
463 "mode", SP_KNOT_MODE_XOR,
464 NULL);
466 knot->_event_handler_id = gtk_signal_connect(GTK_OBJECT(knot->item), "event",
467 GTK_SIGNAL_FUNC(sp_knot_handler), knot);
469 return knot;
470 }
472 /**
473 * Show knot on its canvas.
474 */
475 void sp_knot_show(SPKnot *knot)
476 {
477 g_return_if_fail(knot != NULL);
478 g_return_if_fail(SP_IS_KNOT (knot));
480 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, TRUE);
481 }
483 /**
484 * Hide knot on its canvas.
485 */
486 void sp_knot_hide(SPKnot *knot)
487 {
488 g_return_if_fail(knot != NULL);
489 g_return_if_fail(SP_IS_KNOT(knot));
491 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, FALSE);
492 }
494 /**
495 * Request or set new position for knot.
496 */
497 void sp_knot_request_position(SPKnot *knot, NR::Point *p, guint state)
498 {
499 g_return_if_fail(knot != NULL);
500 g_return_if_fail(SP_IS_KNOT(knot));
502 gboolean done = FALSE;
504 g_signal_emit(knot,
505 knot_signals[REQUEST], 0,
506 p,
507 state,
508 &done);
510 /* If user did not complete, we simply move knot to new position */
512 if (!done) {
513 sp_knot_set_position (knot, p, state);
514 }
515 }
517 /**
518 * Return distance of point to knot's position; unused.
519 */
520 gdouble sp_knot_distance(SPKnot * knot, NR::Point *p, guint state)
521 {
522 g_return_val_if_fail(knot != NULL, 1e18);
523 g_return_val_if_fail(SP_IS_KNOT(knot), 1e18);
525 gdouble distance = NR::L2(*p - knot->pos);
527 g_signal_emit(knot,
528 knot_signals[DISTANCE], 0,
529 p,
530 state,
531 &distance);
533 return distance;
534 }
536 /**
537 * Move knot to new position.
538 */
539 void sp_knot_set_position(SPKnot *knot, NR::Point *p, guint state)
540 {
541 g_return_if_fail(knot != NULL);
542 g_return_if_fail(SP_IS_KNOT (knot));
544 knot->pos = *p;
546 if (knot->item) {
547 SP_CTRL(knot->item)->moveto (*p);
548 }
550 g_signal_emit(knot,
551 knot_signals[MOVED], 0,
552 p,
553 state);
554 }
556 /**
557 * Move knot to new position, without emitting a MOVED signal.
558 */
559 void sp_knot_moveto(SPKnot *knot, NR::Point *p)
560 {
561 g_return_if_fail(knot != NULL);
562 g_return_if_fail(SP_IS_KNOT(knot));
564 knot->pos = *p;
566 if (knot->item) {
567 SP_CTRL(knot->item)->moveto (*p);
568 }
569 }
571 /**
572 * Returns position of knot.
573 */
574 NR::Point sp_knot_position(SPKnot const *knot)
575 {
576 g_assert(knot != NULL);
577 g_assert(SP_IS_KNOT (knot));
579 return knot->pos;
580 }
582 /**
583 * Set flag in knot, with side effects.
584 */
585 static void sp_knot_set_flag(SPKnot *knot, guint flag, bool set)
586 {
587 g_assert(knot != NULL);
588 g_assert(SP_IS_KNOT(knot));
590 if (set) {
591 knot->flags |= flag;
592 } else {
593 knot->flags &= ~flag;
594 }
596 switch (flag) {
597 case SP_KNOT_VISIBLE:
598 if (set) {
599 sp_canvas_item_show(knot->item);
600 } else {
601 sp_canvas_item_hide(knot->item);
602 }
603 break;
604 case SP_KNOT_MOUSEOVER:
605 case SP_KNOT_DRAGGING:
606 sp_knot_set_ctrl_state(knot);
607 break;
608 case SP_KNOT_GRABBED:
609 break;
610 default:
611 g_assert_not_reached();
612 break;
613 }
614 }
616 /**
617 * Update knot's pixbuf and set its control state.
618 */
619 void sp_knot_update_ctrl(SPKnot *knot)
620 {
621 if (!knot->item) {
622 return;
623 }
625 gtk_object_set(GTK_OBJECT(knot->item), "shape", knot->shape, NULL);
626 gtk_object_set(GTK_OBJECT(knot->item), "mode", knot->mode, NULL);
627 gtk_object_set(GTK_OBJECT(knot->item), "size", (gdouble) knot->size, NULL);
628 gtk_object_set(GTK_OBJECT(knot->item), "anchor", knot->anchor, NULL);
629 if (knot->pixbuf) {
630 gtk_object_set(GTK_OBJECT (knot->item), "pixbuf", knot->pixbuf, NULL);
631 }
633 sp_knot_set_ctrl_state(knot);
634 }
636 /**
637 * Set knot control state (dragging/mouseover/normal).
638 */
639 static void sp_knot_set_ctrl_state(SPKnot *knot)
640 {
641 if (knot->flags & SP_KNOT_DRAGGING) {
642 gtk_object_set(GTK_OBJECT (knot->item),
643 "fill_color",
644 knot->fill[SP_KNOT_STATE_DRAGGING],
645 NULL);
646 gtk_object_set(GTK_OBJECT (knot->item),
647 "stroke_color",
648 knot->stroke[SP_KNOT_STATE_DRAGGING],
649 NULL);
650 } else if (knot->flags & SP_KNOT_MOUSEOVER) {
651 gtk_object_set(GTK_OBJECT(knot->item),
652 "fill_color",
653 knot->fill[SP_KNOT_STATE_MOUSEOVER],
654 NULL);
655 gtk_object_set(GTK_OBJECT(knot->item),
656 "stroke_color",
657 knot->stroke[SP_KNOT_STATE_MOUSEOVER],
658 NULL);
659 } else {
660 gtk_object_set(GTK_OBJECT(knot->item),
661 "fill_color",
662 knot->fill[SP_KNOT_STATE_NORMAL],
663 NULL);
664 gtk_object_set(GTK_OBJECT(knot->item),
665 "stroke_color",
666 knot->stroke[SP_KNOT_STATE_NORMAL],
667 NULL);
668 }
669 }
673 /*
674 Local Variables:
675 mode:c++
676 c-file-style:"stroustrup"
677 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
678 indent-tabs-mode:nil
679 fill-column:99
680 End:
681 */
682 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :