92dc711cf0f1c897181ace9a6339379690fa1cf3
1 #define __SP_EVENT_CONTEXT_C__
3 /** \file
4 * Main event handling, and related helper functions.
5 *
6 * Authors:
7 * Lauris Kaplinski <lauris@kaplinski.com>
8 * Frank Felfe <innerspace@iname.com>
9 * bulia byak <buliabyak@users.sf.net>
10 *
11 * Copyright (C) 1999-2005 authors
12 * Copyright (C) 2001-2002 Ximian, Inc.
13 *
14 * Released under GNU GPL, read the file 'COPYING' for more information
15 */
17 /** \class SPEventContext
18 * SPEventContext is an abstract base class of all tools. As the name
19 * indicates, event context implementations process UI events (mouse
20 * movements and keypresses) and take actions (like creating or modifying
21 * objects). There is one event context implementation for each tool,
22 * plus few abstract base classes. Writing a new tool involves
23 * subclassing SPEventContext.
24 */
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
30 #include <gdk/gdkkeysyms.h>
31 #include <gtk/gtkmain.h>
32 #include <gtk/gtkmenu.h>
34 #include "display/sp-canvas.h"
35 #include "xml/node-event-vector.h"
36 #include "sp-cursor.h"
37 #include "shortcuts.h"
38 #include "desktop.h"
39 #include "desktop-handles.h"
40 #include "selection.h"
41 #include "file.h"
42 #include "interface.h"
43 #include "macros.h"
44 #include "tools-switch.h"
45 #include "prefs-utils.h"
46 #include "message-context.h"
47 #include "gradient-drag.h"
48 #include "object-edit.h"
49 #include "attributes.h"
50 #include "rubberband.h"
51 #include "selcue.h"
53 #include "event-context.h"
55 static void sp_event_context_class_init(SPEventContextClass *klass);
56 static void sp_event_context_init(SPEventContext *event_context);
57 static void sp_event_context_dispose(GObject *object);
59 static void sp_event_context_private_setup(SPEventContext *ec);
60 static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event);
61 static gint sp_event_context_private_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);
63 static void set_event_location(SPDesktop * desktop, GdkEvent * event);
65 static GObjectClass *parent_class;
67 // globals for temporary switching to selector by space
68 static bool selector_toggled = FALSE;
69 static int switch_selector_to = 0;
71 static gint xp = 0, yp = 0; // where drag started
72 static gint tolerance = 0;
73 static bool within_tolerance = false;
75 // globals for keeping track of keyboard scroll events in order to accelerate
76 static guint32 scroll_event_time = 0;
77 static gdouble scroll_multiply = 1;
78 static guint scroll_keyval = 0;
80 /**
81 * Registers the SPEventContext class with Glib and returns its type number.
82 */
83 GType
84 sp_event_context_get_type(void)
85 {
86 static GType type = 0;
87 if (!type) {
88 GTypeInfo info = {
89 sizeof(SPEventContextClass),
90 NULL, NULL,
91 (GClassInitFunc) sp_event_context_class_init,
92 NULL, NULL,
93 sizeof(SPEventContext),
94 4,
95 (GInstanceInitFunc) sp_event_context_init,
96 NULL, /* value_table */
97 };
98 type = g_type_register_static(G_TYPE_OBJECT, "SPEventContext", &info, (GTypeFlags)0);
99 }
100 return type;
101 }
103 /**
104 * Callback to set up the SPEventContext vtable.
105 */
106 static void
107 sp_event_context_class_init(SPEventContextClass *klass)
108 {
109 GObjectClass *object_class;
111 object_class = (GObjectClass *) klass;
113 parent_class = (GObjectClass*)g_type_class_peek_parent(klass);
115 object_class->dispose = sp_event_context_dispose;
117 klass->setup = sp_event_context_private_setup;
118 klass->root_handler = sp_event_context_private_root_handler;
119 klass->item_handler = sp_event_context_private_item_handler;
120 }
122 /**
123 * Clears all SPEventContext object members.
124 */
125 static void
126 sp_event_context_init(SPEventContext *event_context)
127 {
128 event_context->desktop = NULL;
129 event_context->cursor = NULL;
130 event_context->_message_context = NULL;
131 event_context->_selcue = NULL;
132 event_context->_grdrag = NULL;
133 }
135 /**
136 * Callback to free and null member variables of SPEventContext object.
137 */
138 static void
139 sp_event_context_dispose(GObject *object)
140 {
141 SPEventContext *ec;
143 ec = SP_EVENT_CONTEXT(object);
145 if (ec->_message_context) {
146 delete ec->_message_context;
147 }
149 if (ec->cursor != NULL) {
150 gdk_cursor_unref(ec->cursor);
151 ec->cursor = NULL;
152 }
154 if (ec->desktop) {
155 ec->desktop = NULL;
156 }
158 if (ec->prefs_repr) {
159 sp_repr_remove_listener_by_data(ec->prefs_repr, ec);
160 Inkscape::GC::release(ec->prefs_repr);
161 ec->prefs_repr = NULL;
162 }
164 G_OBJECT_CLASS(parent_class)->dispose(object);
165 }
167 /**
168 * Recreates and draws cursor on desktop related to SPEventContext.
169 */
170 void
171 sp_event_context_update_cursor(SPEventContext *ec)
172 {
173 GtkWidget *w = GTK_WIDGET(sp_desktop_canvas(ec->desktop));
174 if (w->window) {
175 GdkDisplay *display=gdk_display_get_default();
177 if (ec->cursor)
178 gdk_cursor_unref(ec->cursor);
180 ec->cursor=sp_cursor_new(
181 display,
182 ec->cursor_pixbuf,
183 ec->cursor_shape,
184 ec->hot_x,
185 ec->hot_y);
186 gdk_window_set_cursor(w->window, ec->cursor);
187 }
188 }
190 /**
191 * Callback that gets called on initialization of SPEventContext object.
192 * Redraws mouse cursor, at the moment.
193 */
194 static void
195 sp_event_context_private_setup(SPEventContext *ec)
196 {
197 sp_event_context_update_cursor(ec);
198 }
200 /**
201 * \brief Gobbles next key events on the queue with the same keyval and mask. Returns the number of events consumed.
202 */
203 gint gobble_key_events(guint keyval, gint mask)
204 {
205 GdkEvent *event_next;
206 gint i = 0;
208 event_next = gdk_event_get();
209 // while the next event is also a key notify with the same keyval and mask,
210 while (event_next && event_next->type == GDK_KEY_PRESS
211 && event_next->key.keyval == keyval
212 && (event_next->key.state & mask)) {
213 // kill it
214 gdk_event_free(event_next);
215 // get next
216 event_next = gdk_event_get();
217 i ++;
218 }
219 // otherwise, put it back onto the queue
220 if (event_next) gdk_event_put(event_next);
222 return i;
223 }
225 /**
226 * \brief Gobbles next motion notify events on the queue with the same mask. Returns the number of events consumed.
227 */
228 gint gobble_motion_events(gint mask)
229 {
230 GdkEvent *event_next;
231 gint i = 0;
233 event_next = gdk_event_get();
234 // while the next event is also a key notify with the same keyval and mask,
235 while (event_next && event_next->type == GDK_MOTION_NOTIFY
236 && (event_next->motion.state & mask)) {
237 // kill it
238 gdk_event_free(event_next);
239 // get next
240 event_next = gdk_event_get();
241 i ++;
242 }
243 // otherwise, put it back onto the queue
244 if (event_next) gdk_event_put(event_next);
246 return i;
247 }
249 /**
250 * Toggles current tool between active tool and selector tool.
251 * Subroutine of sp_event_context_private_root_handler().
252 */
253 static void
254 sp_toggle_selector(SPDesktop *dt)
255 {
256 if (!dt->event_context) return;
258 if (tools_isactive(dt, TOOLS_SELECT)) {
259 if (selector_toggled) {
260 if (switch_selector_to) tools_switch (dt, switch_selector_to);
261 selector_toggled = FALSE;
262 } else return;
263 } else {
264 selector_toggled = TRUE;
265 switch_selector_to = tools_active(dt);
266 tools_switch (dt, TOOLS_SELECT);
267 }
268 }
270 /**
271 * Calculates and keeps track of scroll acceleration.
272 * Subroutine of sp_event_context_private_root_handler().
273 */
274 static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration)
275 {
276 guint32 time_diff = ((GdkEventKey *) event)->time - scroll_event_time;
278 /* key pressed within 500ms ? (1/2 second) */
279 if (time_diff > 500 || event->key.keyval != scroll_keyval) {
280 scroll_multiply = 1;
281 } else {
282 scroll_multiply += acceleration;
283 }
285 scroll_event_time = ((GdkEventKey *) event)->time;
286 scroll_keyval = event->key.keyval;
288 return scroll_multiply;
289 }
291 // This is a hack that is necessary because when middle-clicking too fast,
292 // button_press events come for all clicks but there's button_release only
293 // for the first one. So after a release, we must prohibit the next grab for
294 // some time, or the grab will be stuck. Perhaps this is caused by some
295 // wrong handling of events among contexts and not by a GDK bug;
296 // if someone can fix this properly this would be great.
297 static gint dontgrab = 0;
298 static bool
299 grab_allow_again()
300 {
301 dontgrab--;
302 if (dontgrab < 0) dontgrab = 0;
303 return FALSE; // so that it is only called once
304 }
306 /**
307 * Main event dispatch, gets called from Gdk.
308 */
309 static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event)
310 {
311 static NR::Point button_w;
312 static unsigned int panning = 0;
313 static unsigned int zoom_rb = 0;
315 SPDesktop *desktop = event_context->desktop;
317 tolerance = prefs_get_int_attribute_limited(
318 "options.dragtolerance","value", 0, 0, 100);
319 double const zoom_inc = prefs_get_double_attribute_limited(
320 "options.zoomincrement", "value", M_SQRT2, 1.01, 10);
321 double const acceleration = prefs_get_double_attribute_limited(
322 "options.scrollingacceleration", "value", 0, 0, 6);
323 int const key_scroll = prefs_get_int_attribute_limited(
324 "options.keyscroll", "value", 10, 0, 1000);
325 int const wheel_scroll = prefs_get_int_attribute_limited(
326 "options.wheelscroll", "value", 40, 0, 1000);
328 gint ret = FALSE;
330 switch (event->type) {
331 case GDK_2BUTTON_PRESS:
332 if (panning) {
333 panning = 0;
334 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
335 event->button.time);
336 ret = TRUE;
337 } else {
338 /* sp_desktop_dialog(); */
339 }
340 break;
341 case GDK_BUTTON_PRESS:
343 // save drag origin
344 xp = (gint) event->button.x;
345 yp = (gint) event->button.y;
346 within_tolerance = true;
348 switch (event->button.button) {
349 case 2:
351 if (dontgrab)
352 // double-click, still not permitted to grab;
353 // increase the counter to guard against triple click
354 {
355 dontgrab ++;
356 gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL);
357 break;
358 }
360 button_w = NR::Point(event->button.x,
361 event->button.y);
362 if (event->button.state == GDK_SHIFT_MASK) {
363 zoom_rb = 2;
364 } else {
365 panning = 2;
366 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
367 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
368 NULL, event->button.time-1);
369 }
370 ret = TRUE;
371 break;
372 case 3:
373 if (event->button.state & GDK_SHIFT_MASK
374 || event->button.state & GDK_CONTROL_MASK) {
375 button_w = NR::Point(event->button.x,
376 event->button.y);
377 panning = 3;
378 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
379 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
380 NULL, event->button.time);
381 ret = TRUE;
382 } else {
383 sp_event_root_menu_popup(desktop, NULL, event);
384 }
385 break;
386 default:
387 break;
388 }
389 break;
390 case GDK_MOTION_NOTIFY:
391 if (panning) {
392 if ((panning == 2 && !(event->motion.state & GDK_BUTTON2_MASK))
393 || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK))) {
394 /* Gdk seems to lose button release for us sometimes :-( */
395 panning = 0;
396 dontgrab = 0;
397 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
398 event->button.time);
399 ret = TRUE;
400 } else {
401 if ( within_tolerance
402 && ( abs( (gint) event->motion.x - xp ) < tolerance )
403 && ( abs( (gint) event->motion.y - yp ) < tolerance ))
404 {
405 // do not drag if we're within tolerance from origin
406 break;
407 }
408 // Once the user has moved farther than tolerance from
409 // the original location (indicating they intend to move
410 // the object, not click), then always process the motion
411 // notify coordinates as given (no snapping back to origin)
412 within_tolerance = false;
414 // gobble subsequent motion events to prevent "sticking"
415 // when scrolling is slow
416 gobble_motion_events(panning == 2 ?
417 GDK_BUTTON2_MASK : GDK_BUTTON3_MASK);
419 NR::Point const motion_w(event->motion.x,
420 event->motion.y);
421 NR::Point const moved_w( motion_w - button_w );
422 event_context->desktop->scroll_world(moved_w);
423 ret = TRUE;
424 }
425 } else if (zoom_rb) {
426 NR::Point const motion_w(event->motion.x, event->motion.y);
427 NR::Point const motion_dt(desktop->w2d(motion_w));
429 if ( within_tolerance
430 && ( abs( (gint) event->motion.x - xp ) < tolerance )
431 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
432 break; // do not drag if we're within tolerance from origin
433 }
435 if (within_tolerance) {
436 Inkscape::Rubberband::get()->start(desktop, motion_dt);
437 } else {
438 Inkscape::Rubberband::get()->move(motion_dt);
439 }
441 // Once the user has moved farther than tolerance from the original location
442 // (indicating they intend to move the object, not click), then always process the
443 // motion notify coordinates as given (no snapping back to origin)
444 within_tolerance = false;
445 }
446 break;
447 case GDK_BUTTON_RELEASE:
448 if (within_tolerance && (panning || zoom_rb)) {
449 dontgrab ++;
450 NR::Point const event_w(event->button.x, event->button.y);
451 NR::Point const event_dt(desktop->w2d(event_w));
452 double const zoom_power = ( (event->button.state & GDK_SHIFT_MASK)
453 ? -dontgrab : dontgrab );
454 desktop->zoom_relative_keep_point(event_dt,
455 pow(zoom_inc, zoom_power));
456 gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL);
457 desktop->updateNow();
458 }
459 if (panning == event->button.button) {
460 panning = 0;
461 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
462 event->button.time);
463 ret = TRUE;
464 } else if (zoom_rb == event->button.button) {
465 zoom_rb = 0;
466 NR::Maybe<NR::Rect> const b = Inkscape::Rubberband::get()->getRectangle();
467 if (b != NR::Nothing() && !within_tolerance) {
468 desktop->set_display_area(b.assume(), 10);
469 }
470 Inkscape::Rubberband::get()->stop();
471 }
472 xp = yp = 0;
473 break;
474 case GDK_KEY_PRESS:
475 switch (get_group0_keyval(&event->key)) {
476 unsigned int shortcut;
477 case GDK_F1:
478 /* Grab it away from Gtk */
479 shortcut = get_group0_keyval(&event->key);
480 if (event->key.state & GDK_SHIFT_MASK)
481 shortcut |= SP_SHORTCUT_SHIFT_MASK;
482 if (event->key.state & GDK_CONTROL_MASK)
483 shortcut |= SP_SHORTCUT_CONTROL_MASK;
484 if (event->key.state & GDK_MOD1_MASK)
485 shortcut |= SP_SHORTCUT_ALT_MASK;
486 ret = sp_shortcut_invoke(shortcut, desktop);
487 break;
489 case GDK_Tab: // disable tab/shift-tab which cycle widget focus
490 case GDK_ISO_Left_Tab: // they will get different functions
491 if (!(MOD__CTRL_ONLY || (MOD__CTRL && MOD__SHIFT))) {
492 ret = TRUE;
493 } else {
494 /* Grab it away from Gtk */
495 shortcut = get_group0_keyval(&event->key);
496 if (event->key.state & GDK_SHIFT_MASK)
497 shortcut |= SP_SHORTCUT_SHIFT_MASK;
498 if (event->key.state & GDK_CONTROL_MASK)
499 shortcut |= SP_SHORTCUT_CONTROL_MASK;
500 if (event->key.state & GDK_MOD1_MASK)
501 shortcut |= SP_SHORTCUT_ALT_MASK;
502 ret = sp_shortcut_invoke(shortcut, desktop);
503 }
504 break;
505 case GDK_W:
506 case GDK_w:
507 case GDK_F4:
508 /* Close view */
509 if (MOD__CTRL_ONLY) {
510 sp_ui_close_view(NULL);
511 ret = TRUE;
512 }
513 break;
514 case GDK_Left: // Ctrl Left
515 case GDK_KP_Left:
516 case GDK_KP_4:
517 if (MOD__CTRL_ONLY) {
518 int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration));
519 gobble_key_events(get_group0_keyval(&event->key),
520 GDK_CONTROL_MASK);
521 event_context->desktop->scroll_world(i, 0);
522 ret = TRUE;
523 }
524 break;
525 case GDK_Up: // Ctrl Up
526 case GDK_KP_Up:
527 case GDK_KP_8:
528 if (MOD__CTRL_ONLY) {
529 int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration));
530 gobble_key_events(get_group0_keyval(&event->key),
531 GDK_CONTROL_MASK);
532 event_context->desktop->scroll_world(0, i);
533 ret = TRUE;
534 }
535 break;
536 case GDK_Right: // Ctrl Right
537 case GDK_KP_Right:
538 case GDK_KP_6:
539 if (MOD__CTRL_ONLY) {
540 int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration));
541 gobble_key_events(get_group0_keyval(&event->key),
542 GDK_CONTROL_MASK);
543 event_context->desktop->scroll_world(-i, 0);
544 ret = TRUE;
545 }
546 break;
547 case GDK_Down: // Ctrl Down
548 case GDK_KP_Down:
549 case GDK_KP_2:
550 if (MOD__CTRL_ONLY) {
551 int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration));
552 gobble_key_events(get_group0_keyval(&event->key),
553 GDK_CONTROL_MASK);
554 event_context->desktop->scroll_world(0, -i);
555 ret = TRUE;
556 }
557 break;
558 case GDK_F10:
559 if (MOD__SHIFT_ONLY) {
560 sp_event_root_menu_popup(desktop, NULL, event);
561 ret= TRUE;
562 }
563 break;
564 case GDK_space:
565 sp_toggle_selector(desktop);
566 ret= TRUE;
567 break;
568 case GDK_z:
569 case GDK_Z:
570 if (MOD__ALT_ONLY) {
571 desktop->zoom_grab_focus();
572 ret = TRUE;
573 }
574 break;
575 default:
576 break;
577 }
578 break;
579 case GDK_SCROLL:
580 /* shift + wheel, pan left--right */
581 if (event->scroll.state & GDK_SHIFT_MASK) {
582 switch (event->scroll.direction) {
583 case GDK_SCROLL_UP:
584 desktop->scroll_world(wheel_scroll, 0);
585 break;
586 case GDK_SCROLL_DOWN:
587 desktop->scroll_world(-wheel_scroll, 0);
588 break;
589 default:
590 break;
591 }
593 /* ctrl + wheel, zoom in--out */
594 } else if (event->scroll.state & GDK_CONTROL_MASK) {
595 double rel_zoom;
596 switch (event->scroll.direction) {
597 case GDK_SCROLL_UP:
598 rel_zoom = zoom_inc;
599 break;
600 case GDK_SCROLL_DOWN:
601 rel_zoom = 1 / zoom_inc;
602 break;
603 default:
604 rel_zoom = 0.0;
605 break;
606 }
607 if (rel_zoom != 0.0) {
608 NR::Point const scroll_dt = desktop->point();
609 desktop->zoom_relative_keep_point(scroll_dt, rel_zoom);
610 }
612 /* no modifier, pan up--down (left--right on multiwheel mice?) */
613 } else {
614 switch (event->scroll.direction) {
615 case GDK_SCROLL_UP:
616 desktop->scroll_world(0, wheel_scroll);
617 break;
618 case GDK_SCROLL_DOWN:
619 desktop->scroll_world(0, -wheel_scroll);
620 break;
621 case GDK_SCROLL_LEFT:
622 desktop->scroll_world(wheel_scroll, 0);
623 break;
624 case GDK_SCROLL_RIGHT:
625 desktop->scroll_world(-wheel_scroll, 0);
626 break;
627 }
628 }
629 break;
630 default:
631 break;
632 }
634 return ret;
635 }
637 /**
638 * Handles item specific events. Gets called from Gdk.
639 *
640 * Only reacts to right mouse button at the moment.
641 * \todo Fixme: do context sensitive popup menu on items.
642 */
643 gint
644 sp_event_context_private_item_handler(SPEventContext *ec, SPItem *item, GdkEvent *event)
645 {
646 int ret = FALSE;
648 switch (event->type) {
649 case GDK_BUTTON_PRESS:
650 if ((event->button.button == 3)
651 && !(event->button.state & GDK_SHIFT_MASK || event->button.state & GDK_CONTROL_MASK)) {
652 sp_event_root_menu_popup(ec->desktop, item, event);
653 ret = TRUE;
654 }
655 break;
656 default:
657 break;
658 }
660 return ret;
661 }
663 /**
664 * Gets called when attribute changes value.
665 */
666 static void
667 sp_ec_repr_attr_changed(Inkscape::XML::Node *prefs_repr, gchar const *key, gchar const *oldval, gchar const *newval,
668 bool is_interactive, gpointer data)
669 {
670 SPEventContext *ec;
672 ec = SP_EVENT_CONTEXT(data);
674 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) {
675 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, newval);
676 }
677 }
679 Inkscape::XML::NodeEventVector sp_ec_event_vector = {
680 NULL, /* Child added */
681 NULL, /* Child removed */
682 sp_ec_repr_attr_changed,
683 NULL, /* Content changed */
684 NULL /* Order changed */
685 };
687 /**
688 * Creates new SPEventContext object and calls its virtual setup() function.
689 */
690 SPEventContext *
691 sp_event_context_new(GType type, SPDesktop *desktop, Inkscape::XML::Node *prefs_repr, unsigned int key)
692 {
693 g_return_val_if_fail(g_type_is_a(type, SP_TYPE_EVENT_CONTEXT), NULL);
694 g_return_val_if_fail(desktop != NULL, NULL);
696 SPEventContext *const ec = (SPEventContext*)g_object_new(type, NULL);
698 ec->desktop = desktop;
699 ec->_message_context = new Inkscape::MessageContext(desktop->messageStack());
700 ec->key = key;
701 ec->prefs_repr = prefs_repr;
702 if (ec->prefs_repr) {
703 Inkscape::GC::anchor(ec->prefs_repr);
704 sp_repr_add_listener(ec->prefs_repr, &sp_ec_event_vector, ec);
705 }
707 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup)
708 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup(ec);
710 return ec;
711 }
713 /**
714 * Finishes SPEventContext.
715 */
716 void
717 sp_event_context_finish(SPEventContext *ec)
718 {
719 g_return_if_fail(ec != NULL);
720 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
722 ec->enableSelectionCue(false);
724 if (ec->next) {
725 g_warning("Finishing event context with active link\n");
726 }
728 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish)
729 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish(ec);
730 }
732 //-------------------------------member functions
734 /**
735 * Enables/disables the SPEventContext's SelCue.
736 */
737 void SPEventContext::enableSelectionCue(bool enable) {
738 if (enable) {
739 if (!_selcue) {
740 _selcue = new Inkscape::SelCue(desktop);
741 }
742 } else {
743 delete _selcue;
744 _selcue = NULL;
745 }
746 }
748 /**
749 * Enables/disables the SPEventContext's GrDrag.
750 */
751 void SPEventContext::enableGrDrag(bool enable) {
752 if (enable) {
753 if (!_grdrag) {
754 _grdrag = new GrDrag(desktop);
755 }
756 } else {
757 if (_grdrag) {
758 delete _grdrag;
759 _grdrag = NULL;
760 }
761 }
762 }
764 /**
765 * Calls virtual set() function of SPEventContext.
766 */
767 void
768 sp_event_context_read(SPEventContext *ec, gchar const *key)
769 {
770 g_return_if_fail(ec != NULL);
771 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
772 g_return_if_fail(key != NULL);
774 if (ec->prefs_repr) {
775 gchar const *val = ec->prefs_repr->attribute(key);
776 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set)
777 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, val);
778 }
779 }
781 /**
782 * Calls virtual activate() function of SPEventContext.
783 */
784 void
785 sp_event_context_activate(SPEventContext *ec)
786 {
787 g_return_if_fail(ec != NULL);
788 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
790 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
791 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
792 }
794 /**
795 * Calls virtual deactivate() function of SPEventContext.
796 */
797 void
798 sp_event_context_deactivate(SPEventContext *ec)
799 {
800 g_return_if_fail(ec != NULL);
801 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
803 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
804 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
805 }
807 /**
808 * Calls virtual root_handler(), the main event handling function.
809 */
810 gint
811 sp_event_context_root_handler(SPEventContext * event_context, GdkEvent * event)
812 {
813 gint ret;
815 ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event);
817 set_event_location(event_context->desktop, event);
819 return ret;
820 }
822 /**
823 * Calls virtual item_handler(), the item event handling function.
824 */
825 gint
826 sp_event_context_item_handler(SPEventContext * event_context, SPItem * item, GdkEvent * event)
827 {
828 gint ret;
830 ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event);
832 if (! ret) {
833 ret = sp_event_context_root_handler(event_context, event);
834 } else {
835 set_event_location(event_context->desktop, event);
836 }
838 return ret;
839 }
841 /**
842 * Emits 'position_set' signal on desktop and shows coordinates on status bar.
843 */
844 static void set_event_location(SPDesktop *desktop, GdkEvent *event)
845 {
846 if (event->type != GDK_MOTION_NOTIFY) {
847 return;
848 }
850 NR::Point const button_w(event->button.x, event->button.y);
851 NR::Point const button_dt(desktop->w2d(button_w));
852 desktop-> setPosition (button_dt);
853 desktop->set_coordinate_status(button_dt);
854 }
856 //-------------------------------------------------------------------
857 /**
858 * Create popup menu and tell Gtk to show it.
859 */
860 void
861 sp_event_root_menu_popup(SPDesktop *desktop, SPItem *item, GdkEvent *event)
862 {
863 GtkWidget *menu;
865 /* fixme: This is not what I want but works for now (Lauris) */
866 if (event->type == GDK_KEY_PRESS) {
867 item = sp_desktop_selection(desktop)->singleItem();
868 }
869 menu = sp_ui_context_menu(desktop, item);
870 gtk_widget_show(menu);
872 switch (event->type) {
873 case GDK_BUTTON_PRESS:
874 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, event->button.button, event->button.time);
875 break;
876 case GDK_KEY_PRESS:
877 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, 0, event->key.time);
878 break;
879 default:
880 break;
881 }
882 }
884 /**
885 * Show tool context specific modifier tip.
886 */
887 void
888 sp_event_show_modifier_tip(Inkscape::MessageContext *message_context,
889 GdkEvent *event, gchar const *ctrl_tip, gchar const *shift_tip,
890 gchar const *alt_tip)
891 {
892 guint keyval = get_group0_keyval(&event->key);
894 bool ctrl = ctrl_tip && (MOD__CTRL
895 || (keyval == GDK_Control_L)
896 || (keyval == GDK_Control_R));
897 bool shift = shift_tip
898 && (MOD__SHIFT || (keyval == GDK_Shift_L) || (keyval == GDK_Shift_R));
899 bool alt = alt_tip
900 && (MOD__ALT
901 || (keyval == GDK_Alt_L)
902 || (keyval == GDK_Alt_R)
903 || (keyval == GDK_Meta_L)
904 || (keyval == GDK_Meta_R));
906 gchar *tip = g_strdup_printf("%s%s%s%s%s",
907 ( ctrl ? ctrl_tip : "" ),
908 ( ctrl && (shift || alt) ? "; " : "" ),
909 ( shift ? shift_tip : "" ),
910 ( (ctrl || shift) && alt ? "; " : "" ),
911 ( alt ? alt_tip : "" ));
913 if (strlen(tip) > 0) {
914 message_context->flash(Inkscape::INFORMATION_MESSAGE, tip);
915 }
917 g_free(tip);
918 }
920 /**
921 * Return the keyval corresponding to the key event in group 0, i.e.,
922 * in the main (English) layout.
923 *
924 * Use this instead of simply event->keyval, so that your keyboard shortcuts
925 * work regardless of layouts (e.g., in Cyrillic).
926 */
927 guint
928 get_group0_keyval(GdkEventKey *event)
929 {
930 guint keyval = 0;
931 gdk_keymap_translate_keyboard_state(
932 gdk_keymap_get_for_display(gdk_display_get_default()),
933 event->hardware_keycode,
934 (GdkModifierType) event->state,
935 0 /*event->key.group*/,
936 &keyval, NULL, NULL, NULL);
937 return keyval;
938 }
940 /**
941 * Returns item at point p in desktop.
942 *
943 * If state includes alt key mask, cyclically selects under; honors
944 * into_groups.
945 */
946 SPItem *
947 sp_event_context_find_item (SPDesktop *desktop, NR::Point const p,
948 bool select_under, bool into_groups)
949 {
950 SPItem *item;
952 if (select_under) {
953 SPItem *selected_at_point =
954 desktop->item_from_list_at_point_bottom (desktop->selection->itemList(), p);
955 item = desktop->item_at_point(p, into_groups, selected_at_point);
956 if (item == NULL) { // we may have reached bottom, flip over to the top
957 item = desktop->item_at_point(p, into_groups, NULL);
958 }
959 } else
960 item = desktop->item_at_point(p, into_groups, NULL);
962 return item;
963 }
965 /**
966 * Returns item if it is under point p in desktop, at any depth; otherwise returns NULL.
967 *
968 * Honors into_groups.
969 */
970 SPItem *
971 sp_event_context_over_item (SPDesktop *desktop, SPItem *item, NR::Point const p)
972 {
973 GSList *temp = NULL;
974 temp = g_slist_prepend (temp, item);
975 SPItem *item_at_point = desktop->item_from_list_at_point_bottom (temp, p);
976 g_slist_free (temp);
978 return item_at_point;
979 }
981 /**
982 * Called when SPEventContext subclass node attribute changed.
983 */
984 void
985 ec_shape_event_attr_changed(Inkscape::XML::Node *shape_repr, gchar const *name,
986 gchar const *old_value, gchar const *new_value,
987 bool const is_interactive, gpointer const data)
988 {
989 if (!name
990 || !strcmp(name, "style")
991 || SP_ATTRIBUTE_IS_CSS(sp_attribute_lookup(name))) {
992 // no need to regenrate knotholder if only style changed
993 return;
994 }
996 SPEventContext *ec = SP_EVENT_CONTEXT(data);
998 if (ec->shape_knot_holder) {
999 sp_knot_holder_destroy(ec->shape_knot_holder);
1000 }
1001 ec->shape_knot_holder = NULL;
1003 SPDesktop *desktop = ec->desktop;
1005 SPItem *item = sp_desktop_selection(desktop)->singleItem();
1007 if (item) {
1008 ec->shape_knot_holder = sp_item_knot_holder(item, desktop);
1009 }
1010 }
1013 /*
1014 Local Variables:
1015 mode:c++
1016 c-file-style:"stroustrup"
1017 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1018 indent-tabs-mode:nil
1019 fill-column:99
1020 End:
1021 */
1022 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :