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_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_ctrl_state(SPKnot *knot);
67 static GObjectClass *parent_class;
68 static guint knot_signals[LAST_SIGNAL] = { 0 };
70 /**
71 * Registers SPKnot class and returns its type number.
72 */
73 GType sp_knot_get_type()
74 {
75 static GType type = 0;
76 if (!type) {
77 GTypeInfo info = {
78 sizeof(SPKnotClass),
79 NULL, /* base_init */
80 NULL, /* base_finalize */
81 (GClassInitFunc) sp_knot_class_init,
82 NULL, /* class_finalize */
83 NULL, /* class_data */
84 sizeof (SPKnot),
85 16, /* n_preallocs */
86 (GInstanceInitFunc) sp_knot_init,
87 NULL
88 };
89 type = g_type_register_static (G_TYPE_OBJECT, "SPKnot", &info, (GTypeFlags) 0);
90 }
91 return type;
92 }
94 /**
95 * SPKnot vtable initialization.
96 */
97 static void sp_knot_class_init(SPKnotClass *klass)
98 {
99 GObjectClass *object_class = (GObjectClass*)klass;
101 parent_class = (GObjectClass*) g_type_class_peek_parent(klass);
103 object_class->dispose = sp_knot_dispose;
105 knot_signals[EVENT] = g_signal_new("event",
106 G_TYPE_FROM_CLASS(klass),
107 G_SIGNAL_RUN_LAST,
108 G_STRUCT_OFFSET(SPKnotClass, event),
109 NULL, NULL,
110 sp_marshal_BOOLEAN__POINTER,
111 G_TYPE_BOOLEAN, 1,
112 GDK_TYPE_EVENT);
114 knot_signals[CLICKED] = g_signal_new("clicked",
115 G_TYPE_FROM_CLASS(klass),
116 G_SIGNAL_RUN_FIRST,
117 G_STRUCT_OFFSET(SPKnotClass, clicked),
118 NULL, NULL,
119 sp_marshal_NONE__UINT,
120 G_TYPE_NONE, 1,
121 G_TYPE_UINT);
123 knot_signals[DOUBLECLICKED] = g_signal_new("doubleclicked",
124 G_TYPE_FROM_CLASS(klass),
125 G_SIGNAL_RUN_FIRST,
126 G_STRUCT_OFFSET(SPKnotClass, doubleclicked),
127 NULL, NULL,
128 sp_marshal_NONE__UINT,
129 G_TYPE_NONE, 1,
130 G_TYPE_UINT);
132 knot_signals[GRABBED] = g_signal_new("grabbed",
133 G_TYPE_FROM_CLASS(klass),
134 G_SIGNAL_RUN_FIRST,
135 G_STRUCT_OFFSET(SPKnotClass, grabbed),
136 NULL, NULL,
137 sp_marshal_NONE__UINT,
138 G_TYPE_NONE, 1,
139 G_TYPE_UINT);
141 knot_signals[UNGRABBED] = g_signal_new("ungrabbed",
142 G_TYPE_FROM_CLASS(klass),
143 G_SIGNAL_RUN_FIRST,
144 G_STRUCT_OFFSET(SPKnotClass, ungrabbed),
145 NULL, NULL,
146 sp_marshal_NONE__UINT,
147 G_TYPE_NONE, 1,
148 G_TYPE_UINT);
150 knot_signals[MOVED] = g_signal_new("moved",
151 G_TYPE_FROM_CLASS(klass),
152 G_SIGNAL_RUN_FIRST,
153 G_STRUCT_OFFSET(SPKnotClass, moved),
154 NULL, NULL,
155 sp_marshal_NONE__POINTER_UINT,
156 G_TYPE_NONE, 2,
157 G_TYPE_POINTER, G_TYPE_UINT);
159 knot_signals[REQUEST] = g_signal_new("request",
160 G_TYPE_FROM_CLASS(klass),
161 G_SIGNAL_RUN_LAST,
162 G_STRUCT_OFFSET(SPKnotClass, request),
163 NULL, NULL,
164 sp_marshal_BOOLEAN__POINTER_UINT,
165 G_TYPE_BOOLEAN, 2,
166 G_TYPE_POINTER, G_TYPE_UINT);
168 knot_signals[DISTANCE] = g_signal_new("distance",
169 G_TYPE_FROM_CLASS(klass),
170 G_SIGNAL_RUN_LAST,
171 G_STRUCT_OFFSET(SPKnotClass, distance),
172 NULL, NULL,
173 sp_marshal_DOUBLE__POINTER_UINT,
174 G_TYPE_DOUBLE, 2,
175 G_TYPE_POINTER, G_TYPE_UINT);
177 const gchar *nograbenv = getenv("INKSCAPE_NO_GRAB");
178 nograb = (nograbenv && *nograbenv && (*nograbenv != '0'));
179 }
181 /**
182 * Callback for SPKnot initialization.
183 */
184 static void sp_knot_init(SPKnot *knot)
185 {
186 knot->desktop = NULL;
187 knot->item = NULL;
188 knot->flags = 0;
190 knot->size = 8;
191 knot->pos = NR::Point(0, 0);
192 knot->grabbed_rel_pos = NR::Point(0, 0);
193 knot->anchor = GTK_ANCHOR_CENTER;
194 knot->shape = SP_KNOT_SHAPE_SQUARE;
195 knot->mode = SP_KNOT_MODE_XOR;
196 knot->tip = NULL;
197 knot->_event_handler_id = 0;
198 knot->pressure = 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 /* Run client universal event handler, if present */
292 gboolean consumed = FALSE;
294 g_signal_emit(knot, knot_signals[EVENT], 0, event, &consumed);
296 if (consumed) {
297 return TRUE;
298 }
300 g_object_ref(knot);
301 tolerance = prefs_get_int_attribute_limited("options.dragtolerance", "value", 0, 0, 100);
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 && !knot->desktop->event_context->space_panning) {
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 && !knot->desktop->event_context->space_panning) {
322 knot->pressure = 0;
323 if (transform_escaped) {
324 transform_escaped = false;
325 consumed = TRUE;
326 } else {
327 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
328 if (!nograb) {
329 sp_canvas_item_ungrab(knot->item, event->button.time);
330 }
331 if (moved) {
332 sp_knot_set_flag(knot,
333 SP_KNOT_DRAGGING,
334 FALSE);
335 g_signal_emit(knot,
336 knot_signals[UNGRABBED], 0,
337 event->button.state);
338 } else {
339 g_signal_emit(knot,
340 knot_signals[CLICKED], 0,
341 event->button.state);
342 }
343 grabbed = FALSE;
344 moved = FALSE;
345 consumed = TRUE;
346 }
347 }
348 break;
349 case GDK_MOTION_NOTIFY:
350 if (grabbed && !knot->desktop->event_context->space_panning) {
351 consumed = TRUE;
353 if ( within_tolerance
354 && ( abs( (gint) event->motion.x - xp ) < tolerance )
355 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
356 break; // do not drag if we're within tolerance from origin
357 }
359 // Once the user has moved farther than tolerance from the original location
360 // (indicating they intend to move the object, not click), then always process the
361 // motion notify coordinates as given (no snapping back to origin)
362 within_tolerance = false;
364 if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &knot->pressure))
365 knot->pressure = CLAMP (knot->pressure, 0, 1);
366 else
367 knot->pressure = 0.5;
369 if (!moved) {
370 g_signal_emit(knot,
371 knot_signals[GRABBED], 0,
372 event->motion.state);
373 sp_knot_set_flag(knot,
374 SP_KNOT_DRAGGING,
375 TRUE);
376 }
377 NR::Point const motion_w(event->motion.x, event->motion.y);
378 NR::Point const motion_dt = knot->desktop->w2d(motion_w);
379 NR::Point p = motion_dt - knot->grabbed_rel_pos;
380 sp_knot_request_position (knot, &p, event->motion.state);
381 knot->desktop->scroll_to_point (&motion_dt);
382 knot->desktop->set_coordinate_status(knot->pos); // display the coordinate of knot, not cursor - they may be different!
383 if (event->motion.state & GDK_BUTTON1_MASK)
384 gobble_motion_events(GDK_BUTTON1_MASK);
385 moved = TRUE;
386 }
387 break;
388 case GDK_ENTER_NOTIFY:
389 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, TRUE);
390 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
392 if (knot->tip) {
393 knot->desktop->event_context->defaultMessageContext()->set(Inkscape::NORMAL_MESSAGE, knot->tip);
394 }
396 grabbed = FALSE;
397 moved = FALSE;
398 consumed = TRUE;
399 break;
400 case GDK_LEAVE_NOTIFY:
401 sp_knot_set_flag(knot, SP_KNOT_MOUSEOVER, FALSE);
402 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
404 if (knot->tip) {
405 knot->desktop->event_context->defaultMessageContext()->clear();
406 }
408 grabbed = FALSE;
409 moved = FALSE;
411 consumed = TRUE;
412 break;
413 case GDK_KEY_PRESS: // keybindings for knot
414 switch (get_group0_keyval(&event->key)) {
415 case GDK_Escape:
416 sp_knot_set_flag(knot, SP_KNOT_GRABBED, FALSE);
417 if (!nograb) {
418 sp_canvas_item_ungrab(knot->item, event->button.time);
419 }
420 if (moved) {
421 sp_knot_set_flag(knot,
422 SP_KNOT_DRAGGING,
423 FALSE);
424 g_signal_emit(knot,
425 knot_signals[UNGRABBED], 0,
426 event->button.state);
427 sp_document_undo(sp_desktop_document(knot->desktop));
428 knot->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Node or handle drag canceled."));
429 transform_escaped = true;
430 consumed = TRUE;
431 }
432 grabbed = FALSE;
433 moved = FALSE;
434 break;
435 default:
436 consumed = FALSE;
437 break;
438 }
439 break;
440 default:
441 break;
442 }
444 g_object_unref(knot);
446 return consumed;
447 }
449 /**
450 * Return new knot object.
451 */
452 SPKnot *sp_knot_new(SPDesktop *desktop, const gchar *tip)
453 {
454 g_return_val_if_fail(desktop != NULL, NULL);
456 SPKnot * knot = (SPKnot*) g_object_new(SP_TYPE_KNOT, 0);
458 knot->desktop = desktop;
459 knot->flags = SP_KNOT_VISIBLE;
460 if (tip) {
461 knot->tip = g_strdup (tip);
462 }
464 knot->item = sp_canvas_item_new(sp_desktop_controls (desktop),
465 SP_TYPE_CTRL,
466 "anchor", GTK_ANCHOR_CENTER,
467 "size", 8.0,
468 "filled", TRUE,
469 "fill_color", 0xffffff00,
470 "stroked", TRUE,
471 "stroke_color", 0x01000000,
472 "mode", SP_KNOT_MODE_XOR,
473 NULL);
475 knot->_event_handler_id = gtk_signal_connect(GTK_OBJECT(knot->item), "event",
476 GTK_SIGNAL_FUNC(sp_knot_handler), knot);
478 return knot;
479 }
481 /**
482 * Show knot on its canvas.
483 */
484 void sp_knot_show(SPKnot *knot)
485 {
486 g_return_if_fail(knot != NULL);
487 g_return_if_fail(SP_IS_KNOT (knot));
489 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, TRUE);
490 }
492 /**
493 * Hide knot on its canvas.
494 */
495 void sp_knot_hide(SPKnot *knot)
496 {
497 g_return_if_fail(knot != NULL);
498 g_return_if_fail(SP_IS_KNOT(knot));
500 sp_knot_set_flag(knot, SP_KNOT_VISIBLE, FALSE);
501 }
503 /**
504 * Request or set new position for knot.
505 */
506 void sp_knot_request_position(SPKnot *knot, NR::Point *p, guint state)
507 {
508 g_return_if_fail(knot != NULL);
509 g_return_if_fail(SP_IS_KNOT(knot));
511 gboolean done = FALSE;
513 g_signal_emit(knot,
514 knot_signals[REQUEST], 0,
515 p,
516 state,
517 &done);
519 /* If user did not complete, we simply move knot to new position */
521 if (!done) {
522 sp_knot_set_position (knot, p, state);
523 }
524 }
526 /**
527 * Return distance of point to knot's position; unused.
528 */
529 gdouble sp_knot_distance(SPKnot * knot, NR::Point *p, guint state)
530 {
531 g_return_val_if_fail(knot != NULL, 1e18);
532 g_return_val_if_fail(SP_IS_KNOT(knot), 1e18);
534 gdouble distance = NR::L2(*p - knot->pos);
536 g_signal_emit(knot,
537 knot_signals[DISTANCE], 0,
538 p,
539 state,
540 &distance);
542 return distance;
543 }
545 /**
546 * Move knot to new position.
547 */
548 void sp_knot_set_position(SPKnot *knot, NR::Point *p, guint state)
549 {
550 g_return_if_fail(knot != NULL);
551 g_return_if_fail(SP_IS_KNOT (knot));
553 knot->pos = *p;
555 if (knot->item) {
556 SP_CTRL(knot->item)->moveto (*p);
557 }
559 g_signal_emit(knot,
560 knot_signals[MOVED], 0,
561 p,
562 state);
563 }
565 /**
566 * Move knot to new position, without emitting a MOVED signal.
567 */
568 void sp_knot_moveto(SPKnot *knot, NR::Point *p)
569 {
570 g_return_if_fail(knot != NULL);
571 g_return_if_fail(SP_IS_KNOT(knot));
573 knot->pos = *p;
575 if (knot->item) {
576 SP_CTRL(knot->item)->moveto (*p);
577 }
578 }
580 /**
581 * Returns position of knot.
582 */
583 NR::Point sp_knot_position(SPKnot const *knot)
584 {
585 g_assert(knot != NULL);
586 g_assert(SP_IS_KNOT (knot));
588 return knot->pos;
589 }
591 /**
592 * Set flag in knot, with side effects.
593 */
594 void sp_knot_set_flag(SPKnot *knot, guint flag, bool set)
595 {
596 g_assert(knot != NULL);
597 g_assert(SP_IS_KNOT(knot));
599 if (set) {
600 knot->flags |= flag;
601 } else {
602 knot->flags &= ~flag;
603 }
605 switch (flag) {
606 case SP_KNOT_VISIBLE:
607 if (set) {
608 sp_canvas_item_show(knot->item);
609 } else {
610 sp_canvas_item_hide(knot->item);
611 }
612 break;
613 case SP_KNOT_MOUSEOVER:
614 case SP_KNOT_DRAGGING:
615 sp_knot_set_ctrl_state(knot);
616 break;
617 case SP_KNOT_GRABBED:
618 break;
619 default:
620 g_assert_not_reached();
621 break;
622 }
623 }
625 /**
626 * Update knot's pixbuf and set its control state.
627 */
628 void sp_knot_update_ctrl(SPKnot *knot)
629 {
630 if (!knot->item) {
631 return;
632 }
634 gtk_object_set(GTK_OBJECT(knot->item), "shape", knot->shape, NULL);
635 gtk_object_set(GTK_OBJECT(knot->item), "mode", knot->mode, NULL);
636 gtk_object_set(GTK_OBJECT(knot->item), "size", (gdouble) knot->size, NULL);
637 gtk_object_set(GTK_OBJECT(knot->item), "anchor", knot->anchor, NULL);
638 if (knot->pixbuf) {
639 gtk_object_set(GTK_OBJECT (knot->item), "pixbuf", knot->pixbuf, NULL);
640 }
642 sp_knot_set_ctrl_state(knot);
643 }
645 /**
646 * Set knot control state (dragging/mouseover/normal).
647 */
648 static void sp_knot_set_ctrl_state(SPKnot *knot)
649 {
650 if (knot->flags & SP_KNOT_DRAGGING) {
651 gtk_object_set(GTK_OBJECT (knot->item),
652 "fill_color",
653 knot->fill[SP_KNOT_STATE_DRAGGING],
654 NULL);
655 gtk_object_set(GTK_OBJECT (knot->item),
656 "stroke_color",
657 knot->stroke[SP_KNOT_STATE_DRAGGING],
658 NULL);
659 } else if (knot->flags & SP_KNOT_MOUSEOVER) {
660 gtk_object_set(GTK_OBJECT(knot->item),
661 "fill_color",
662 knot->fill[SP_KNOT_STATE_MOUSEOVER],
663 NULL);
664 gtk_object_set(GTK_OBJECT(knot->item),
665 "stroke_color",
666 knot->stroke[SP_KNOT_STATE_MOUSEOVER],
667 NULL);
668 } else {
669 gtk_object_set(GTK_OBJECT(knot->item),
670 "fill_color",
671 knot->fill[SP_KNOT_STATE_NORMAL],
672 NULL);
673 gtk_object_set(GTK_OBJECT(knot->item),
674 "stroke_color",
675 knot->stroke[SP_KNOT_STATE_NORMAL],
676 NULL);
677 }
678 }
682 /*
683 Local Variables:
684 mode:c++
685 c-file-style:"stroustrup"
686 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
687 indent-tabs-mode:nil
688 fill-column:99
689 End:
690 */
691 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :