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 | \
35 GDK_POINTER_MOTION_HINT_MASK | \
36 GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)
38 static bool nograb = false;
40 static bool grabbed = FALSE;
41 static bool moved = FALSE;
43 static gint xp = 0, yp = 0; // where drag started
44 static gint tolerance = 0;
45 static bool within_tolerance = false;
47 static bool transform_escaped = false; // true iff resize or rotate was cancelled by esc.
49 enum {
50 EVENT,
51 CLICKED,
52 DOUBLECLICKED,
53 GRABBED,
54 UNGRABBED,
55 MOVED,
56 REQUEST,
57 DISTANCE,
58 LAST_SIGNAL
59 };
61 static void sp_knot_class_init(SPKnotClass *klass);
62 static void sp_knot_init(SPKnot *knot);
63 static void sp_knot_dispose(GObject *object);
65 static int sp_knot_handler(SPCanvasItem *item, GdkEvent *event, SPKnot *knot);
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;
199 knot->pressure = 0;
201 knot->fill[SP_KNOT_STATE_NORMAL] = 0xffffff00;
202 knot->fill[SP_KNOT_STATE_MOUSEOVER] = 0xff0000ff;
203 knot->fill[SP_KNOT_STATE_DRAGGING] = 0x0000ffff;
205 knot->stroke[SP_KNOT_STATE_NORMAL] = 0x01000000;
206 knot->stroke[SP_KNOT_STATE_MOUSEOVER] = 0x01000000;
207 knot->stroke[SP_KNOT_STATE_DRAGGING] = 0x01000000;
209 knot->image[SP_KNOT_STATE_NORMAL] = NULL;
210 knot->image[SP_KNOT_STATE_MOUSEOVER] = NULL;
211 knot->image[SP_KNOT_STATE_DRAGGING] = NULL;
213 knot->cursor[SP_KNOT_STATE_NORMAL] = NULL;
214 knot->cursor[SP_KNOT_STATE_MOUSEOVER] = NULL;
215 knot->cursor[SP_KNOT_STATE_DRAGGING] = NULL;
217 knot->saved_cursor = NULL;
218 knot->pixbuf = NULL;
219 }
221 /**
222 * Called before SPKnot destruction.
223 */
224 static void sp_knot_dispose(GObject *object)
225 {
226 SPKnot *knot = (SPKnot *) object;
228 if ((knot->flags & SP_KNOT_GRABBED) && gdk_pointer_is_grabbed ()) {
229 // This happens e.g. when deleting a node in node tool while dragging it
230 gdk_pointer_ungrab (GDK_CURRENT_TIME);
231 }
233 if (knot->_event_handler_id > 0)
234 {
235 g_signal_handler_disconnect(G_OBJECT (knot->item), knot->_event_handler_id);
236 knot->_event_handler_id = 0;
237 }
239 if (knot->item) {
240 gtk_object_destroy (GTK_OBJECT (knot->item));
241 knot->item = NULL;
242 }
244 for (gint i = 0; i < SP_KNOT_VISIBLE_STATES; i++) {
245 if (knot->cursor[i]) {
246 gdk_cursor_unref(knot->cursor[i]);
247 knot->cursor[i] = NULL;
248 }
249 }
251 if (knot->tip) {
252 g_free(knot->tip);
253 knot->tip = NULL;
254 }
256 if (parent_class->dispose) {
257 (*parent_class->dispose) (object);
258 }
259 }
261 /**
262 * Update knot for dragging and tell canvas an item was grabbed.
263 */
264 void sp_knot_start_dragging(SPKnot *knot, NR::Point p, gint x, gint y, guint32 etime)
265 {
266 // save drag origin
267 xp = x;
268 yp = y;
269 within_tolerance = true;
271 knot->grabbed_rel_pos = p - knot->pos;
272 knot->drag_origin = knot->pos;
273 if (!nograb) {
274 sp_canvas_item_grab(knot->item,
275 KNOT_EVENT_MASK,
276 knot->cursor[SP_KNOT_STATE_DRAGGING],
277 etime);
278 }
279 sp_knot_set_flag(knot, SP_KNOT_GRABBED, TRUE);
280 grabbed = TRUE;
281 }
283 /**
284 * Called to handle events on knots.
285 */
286 static int sp_knot_handler(SPCanvasItem */*item*/, GdkEvent *event, SPKnot *knot)
287 {
288 g_assert(knot != NULL);
289 g_assert(SP_IS_KNOT(knot));
291 /* Run client universal event handler, if present */
293 gboolean consumed = FALSE;
295 g_signal_emit(knot, knot_signals[EVENT], 0, event, &consumed);
297 if (consumed) {
298 return TRUE;
299 }
301 g_object_ref(knot);
302 tolerance = prefs_get_int_attribute_limited("options.dragtolerance", "value", 0, 0, 100);
304 switch (event->type) {
305 case GDK_2BUTTON_PRESS:
306 if (event->button.button == 1) {
307 g_signal_emit(knot, knot_signals[DOUBLECLICKED], 0, event->button.state);
309 grabbed = FALSE;
310 moved = FALSE;
311 consumed = TRUE;
312 }
313 break;
314 case GDK_BUTTON_PRESS:
315 if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
316 NR::Point const p = knot->desktop->w2d(NR::Point(event->button.x, event->button.y));
317 sp_knot_start_dragging(knot, p, (gint) event->button.x, (gint) event->button.y, event->button.time);
318 consumed = TRUE;
319 }
320 break;
321 case GDK_BUTTON_RELEASE:
322 if (event->button.button == 1 && !knot->desktop->event_context->space_panning) {
323 knot->pressure = 0;
324 if (transform_escaped) {
325 transform_escaped = false;
326 consumed = TRUE;
327 } else {
328 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
329 if (!nograb) {
330 sp_canvas_item_ungrab(knot->item, event->button.time);
331 }
332 if (moved) {
333 sp_knot_set_flag(knot,
334 SP_KNOT_DRAGGING,
335 FALSE);
336 g_signal_emit(knot,
337 knot_signals[UNGRABBED], 0,
338 event->button.state);
339 knot->_ungrabbed_signal.emit(knot);
340 } else {
341 g_signal_emit(knot,
342 knot_signals[CLICKED], 0,
343 event->button.state);
344 knot->_click_signal.emit(knot, event->button.state);
345 }
346 grabbed = FALSE;
347 moved = FALSE;
348 consumed = TRUE;
349 }
350 }
351 break;
352 case GDK_MOTION_NOTIFY:
353 if (grabbed && !knot->desktop->event_context->space_panning) {
354 consumed = TRUE;
356 if ( within_tolerance
357 && ( abs( (gint) event->motion.x - xp ) < tolerance )
358 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
359 break; // do not drag if we're within tolerance from origin
360 }
362 // Once the user has moved farther than tolerance from the original location
363 // (indicating they intend to move the object, not click), then always process the
364 // motion notify coordinates as given (no snapping back to origin)
365 within_tolerance = false;
367 if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &knot->pressure))
368 knot->pressure = CLAMP (knot->pressure, 0, 1);
369 else
370 knot->pressure = 0.5;
372 if (!moved) {
373 g_signal_emit(knot,
374 knot_signals[GRABBED], 0,
375 event->motion.state);
376 sp_knot_set_flag(knot,
377 SP_KNOT_DRAGGING,
378 TRUE);
379 }
380 NR::Point const motion_w(event->motion.x, event->motion.y);
381 NR::Point const motion_dt = knot->desktop->w2d(motion_w);
382 NR::Point p = motion_dt - knot->grabbed_rel_pos;
383 sp_knot_request_position (knot, &p, event->motion.state);
384 knot->desktop->scroll_to_point (&motion_dt);
385 knot->desktop->set_coordinate_status(knot->pos); // display the coordinate of knot, not cursor - they may be different!
386 if (event->motion.state & GDK_BUTTON1_MASK)
387 gobble_motion_events(GDK_BUTTON1_MASK);
388 moved = TRUE;
389 }
390 break;
391 case GDK_ENTER_NOTIFY:
392 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, TRUE);
393 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
395 if (knot->tip) {
396 knot->desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, knot->tip);
397 }
399 grabbed = FALSE;
400 moved = FALSE;
401 consumed = TRUE;
402 break;
403 case GDK_LEAVE_NOTIFY:
404 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, FALSE);
405 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
407 if (knot->tip) {
408 knot->desktop->event_context->defaultMessageContext()->clear();
409 }
411 grabbed = FALSE;
412 moved = FALSE;
414 consumed = TRUE;
415 break;
416 case GDK_KEY_PRESS: // keybindings for knot
417 switch (get_group0_keyval(&event->key)) {
418 case GDK_Escape:
419 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
420 if (!nograb) {
421 sp_canvas_item_ungrab(knot->item, event->button.time);
422 }
423 if (moved) {
424 sp_knot_set_flag(knot,
425 SP_KNOT_DRAGGING,
426 FALSE);
427 g_signal_emit(knot,
428 knot_signals[UNGRABBED], 0,
429 event->button.state);
430 sp_document_undo(sp_desktop_document(knot->desktop));
431 knot->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Node or handle drag canceled."));
432 transform_escaped = true;
433 consumed = TRUE;
434 }
435 grabbed = FALSE;
436 moved = FALSE;
437 break;
438 default:
439 consumed = FALSE;
440 break;
441 }
442 break;
443 default:
444 break;
445 }
447 g_object_unref(knot);
449 return consumed;
450 }
452 /**
453 * Return new knot object.
454 */
455 SPKnot *sp_knot_new(SPDesktop *desktop, const gchar *tip)
456 {
457 g_return_val_if_fail(desktop != NULL, NULL);
459 SPKnot * knot = (SPKnot*) g_object_new(SP_TYPE_KNOT, 0);
461 knot->desktop = desktop;
462 knot->flags = SP_KNOT_VISIBLE;
463 if (tip) {
464 knot->tip = g_strdup (tip);
465 }
467 knot->item = sp_canvas_item_new(sp_desktop_controls (desktop),
468 SP_TYPE_CTRL,
469 "anchor", GTK_ANCHOR_CENTER,
470 "size", 8.0,
471 "filled", TRUE,
472 "fill_color", 0xffffff00,
473 "stroked", TRUE,
474 "stroke_color", 0x01000000,
475 "mode", SP_KNOT_MODE_XOR,
476 NULL);
478 knot->_event_handler_id = gtk_signal_connect(GTK_OBJECT(knot->item), "event",
479 GTK_SIGNAL_FUNC(sp_knot_handler), knot);
481 return knot;
482 }
484 /**
485 * Show knot on its canvas.
486 */
487 void sp_knot_show(SPKnot *knot)
488 {
489 g_return_if_fail(knot != NULL);
490 g_return_if_fail(SP_IS_KNOT (knot));
492 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, TRUE);
493 }
495 /**
496 * Hide knot on its canvas.
497 */
498 void sp_knot_hide(SPKnot *knot)
499 {
500 g_return_if_fail(knot != NULL);
501 g_return_if_fail(SP_IS_KNOT(knot));
503 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, FALSE);
504 }
506 /**
507 * Request or set new position for knot.
508 */
509 void sp_knot_request_position(SPKnot *knot, NR::Point *p, guint state)
510 {
511 g_return_if_fail(knot != NULL);
512 g_return_if_fail(SP_IS_KNOT(knot));
514 gboolean done = FALSE;
516 g_signal_emit(knot,
517 knot_signals[REQUEST], 0,
518 p,
519 state,
520 &done);
522 /* If user did not complete, we simply move knot to new position */
524 if (!done) {
525 sp_knot_set_position (knot, p, state);
526 }
527 }
529 /**
530 * Return distance of point to knot's position; unused.
531 */
532 gdouble sp_knot_distance(SPKnot * knot, NR::Point *p, guint state)
533 {
534 g_return_val_if_fail(knot != NULL, 1e18);
535 g_return_val_if_fail(SP_IS_KNOT(knot), 1e18);
537 gdouble distance = NR::L2(*p - knot->pos);
539 g_signal_emit(knot,
540 knot_signals[DISTANCE], 0,
541 p,
542 state,
543 &distance);
545 return distance;
546 }
548 /**
549 * Move knot to new position.
550 */
551 void sp_knot_set_position(SPKnot *knot, NR::Point *p, guint state)
552 {
553 g_return_if_fail(knot != NULL);
554 g_return_if_fail(SP_IS_KNOT (knot));
556 knot->pos = *p;
558 if (knot->item) {
559 SP_CTRL(knot->item)->moveto (*p);
560 }
562 g_signal_emit(knot,
563 knot_signals[MOVED], 0,
564 p,
565 state);
566 knot->_moved_signal.emit(knot, p, state);
567 }
569 /**
570 * Move knot to new position, without emitting a MOVED signal.
571 */
572 void sp_knot_moveto(SPKnot *knot, NR::Point *p)
573 {
574 g_return_if_fail(knot != NULL);
575 g_return_if_fail(SP_IS_KNOT(knot));
577 knot->pos = *p;
579 if (knot->item) {
580 SP_CTRL(knot->item)->moveto (*p);
581 }
582 }
584 /**
585 * Returns position of knot.
586 */
587 NR::Point sp_knot_position(SPKnot const *knot)
588 {
589 g_assert(knot != NULL);
590 g_assert(SP_IS_KNOT (knot));
592 return knot->pos;
593 }
595 /**
596 * Set flag in knot, with side effects.
597 */
598 void sp_knot_set_flag(SPKnot *knot, guint flag, bool set)
599 {
600 g_assert(knot != NULL);
601 g_assert(SP_IS_KNOT(knot));
603 if (set) {
604 knot->flags |= flag;
605 } else {
606 knot->flags &= ~flag;
607 }
609 switch (flag) {
610 case SP_KNOT_VISIBLE:
611 if (set) {
612 sp_canvas_item_show(knot->item);
613 } else {
614 sp_canvas_item_hide(knot->item);
615 }
616 break;
617 case SP_KNOT_MOUSEOVER:
618 case SP_KNOT_DRAGGING:
619 sp_knot_set_ctrl_state(knot);
620 break;
621 case SP_KNOT_GRABBED:
622 break;
623 default:
624 g_assert_not_reached();
625 break;
626 }
627 }
629 /**
630 * Update knot's pixbuf and set its control state.
631 */
632 void sp_knot_update_ctrl(SPKnot *knot)
633 {
634 if (!knot->item) {
635 return;
636 }
638 gtk_object_set(GTK_OBJECT(knot->item), "shape", knot->shape, NULL);
639 gtk_object_set(GTK_OBJECT(knot->item), "mode", knot->mode, NULL);
640 gtk_object_set(GTK_OBJECT(knot->item), "size", (gdouble) knot->size, NULL);
641 gtk_object_set(GTK_OBJECT(knot->item), "anchor", knot->anchor, NULL);
642 if (knot->pixbuf) {
643 gtk_object_set(GTK_OBJECT (knot->item), "pixbuf", knot->pixbuf, NULL);
644 }
646 sp_knot_set_ctrl_state(knot);
647 }
649 /**
650 * Set knot control state (dragging/mouseover/normal).
651 */
652 static void sp_knot_set_ctrl_state(SPKnot *knot)
653 {
654 if (knot->flags & SP_KNOT_DRAGGING) {
655 gtk_object_set(GTK_OBJECT (knot->item),
656 "fill_color",
657 knot->fill[SP_KNOT_STATE_DRAGGING],
658 NULL);
659 gtk_object_set(GTK_OBJECT (knot->item),
660 "stroke_color",
661 knot->stroke[SP_KNOT_STATE_DRAGGING],
662 NULL);
663 } else if (knot->flags & SP_KNOT_MOUSEOVER) {
664 gtk_object_set(GTK_OBJECT(knot->item),
665 "fill_color",
666 knot->fill[SP_KNOT_STATE_MOUSEOVER],
667 NULL);
668 gtk_object_set(GTK_OBJECT(knot->item),
669 "stroke_color",
670 knot->stroke[SP_KNOT_STATE_MOUSEOVER],
671 NULL);
672 } else {
673 gtk_object_set(GTK_OBJECT(knot->item),
674 "fill_color",
675 knot->fill[SP_KNOT_STATE_NORMAL],
676 NULL);
677 gtk_object_set(GTK_OBJECT(knot->item),
678 "stroke_color",
679 knot->stroke[SP_KNOT_STATE_NORMAL],
680 NULL);
681 }
682 }
686 /*
687 Local Variables:
688 mode:c++
689 c-file-style:"stroustrup"
690 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
691 indent-tabs-mode:nil
692 fill-column:99
693 End:
694 */
695 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :