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_DT_CANVAS(ec->desktop));
174 if (w->window) {
175 /* fixme: */
176 if (ec->cursor_shape) {
177 GdkBitmap *bitmap = NULL;
178 GdkBitmap *mask = NULL;
179 sp_cursor_bitmap_and_mask_from_xpm(&bitmap, &mask, ec->cursor_shape);
180 if ((bitmap != NULL) && (mask != NULL)) {
181 if (ec->cursor)
182 gdk_cursor_unref (ec->cursor);
183 ec->cursor = gdk_cursor_new_from_pixmap(bitmap, mask,
184 &w->style->black,
185 &w->style->white,
186 ec->hot_x, ec->hot_y);
187 g_object_unref (bitmap);
188 g_object_unref (mask);
189 }
190 }
191 gdk_window_set_cursor(w->window, ec->cursor);
192 }
193 }
195 /**
196 * Callback that gets called on initialization of SPEventContext object.
197 * Redraws mouse cursor, at the moment.
198 */
199 static void
200 sp_event_context_private_setup(SPEventContext *ec)
201 {
202 sp_event_context_update_cursor(ec);
203 }
205 /**
206 * \brief Gobbles next key events on the queue with the same keyval and mask. Returns the number of events consumed.
207 */
208 gint gobble_key_events(guint keyval, gint mask)
209 {
210 GdkEvent *event_next;
211 gint i = 0;
213 event_next = gdk_event_get();
214 // while the next event is also a key notify with the same keyval and mask,
215 while (event_next && event_next->type == GDK_KEY_PRESS
216 && event_next->key.keyval == keyval
217 && (event_next->key.state & mask)) {
218 // kill it
219 gdk_event_free(event_next);
220 // get next
221 event_next = gdk_event_get();
222 i ++;
223 }
224 // otherwise, put it back onto the queue
225 if (event_next) gdk_event_put(event_next);
227 return i;
228 }
230 /**
231 * \brief Gobbles next motion notify events on the queue with the same mask. Returns the number of events consumed.
232 */
233 gint gobble_motion_events(gint mask)
234 {
235 GdkEvent *event_next;
236 gint i = 0;
238 event_next = gdk_event_get();
239 // while the next event is also a key notify with the same keyval and mask,
240 while (event_next && event_next->type == GDK_MOTION_NOTIFY
241 && (event_next->motion.state & mask)) {
242 // kill it
243 gdk_event_free(event_next);
244 // get next
245 event_next = gdk_event_get();
246 i ++;
247 }
248 // otherwise, put it back onto the queue
249 if (event_next) gdk_event_put(event_next);
251 return i;
252 }
254 /**
255 * Toggles current tool between active tool and selector tool.
256 * Subroutine of sp_event_context_private_root_handler().
257 */
258 static void
259 sp_toggle_selector(SPDesktop *dt)
260 {
261 if (!dt->event_context) return;
263 if (tools_isactive(dt, TOOLS_SELECT)) {
264 if (selector_toggled) {
265 if (switch_selector_to) tools_switch (dt, switch_selector_to);
266 selector_toggled = FALSE;
267 } else return;
268 } else {
269 selector_toggled = TRUE;
270 switch_selector_to = tools_active(dt);
271 tools_switch (dt, TOOLS_SELECT);
272 }
273 }
275 /**
276 * Calculates and keeps track of scroll acceleration.
277 * Subroutine of sp_event_context_private_root_handler().
278 */
279 static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration)
280 {
281 guint32 time_diff = ((GdkEventKey *) event)->time - scroll_event_time;
283 /* key pressed within 500ms ? (1/2 second) */
284 if (time_diff > 500 || event->key.keyval != scroll_keyval) {
285 scroll_multiply = 1;
286 } else {
287 scroll_multiply += acceleration;
288 }
290 scroll_event_time = ((GdkEventKey *) event)->time;
291 scroll_keyval = event->key.keyval;
293 return scroll_multiply;
294 }
296 // This is a hack that is necessary because when middle-clicking too fast,
297 // button_press events come for all clicks but there's button_release only
298 // for the first one. So after a release, we must prohibit the next grab for
299 // some time, or the grab will be stuck. Perhaps this is caused by some
300 // wrong handling of events among contexts and not by a GDK bug;
301 // if someone can fix this properly this would be great.
302 static gint dontgrab = 0;
303 static bool
304 grab_allow_again()
305 {
306 dontgrab--;
307 if (dontgrab < 0) dontgrab = 0;
308 return FALSE; // so that it is only called once
309 }
311 /**
312 * Main event dispatch, gets called from Gdk.
313 */
314 static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event)
315 {
316 static NR::Point button_w;
317 static unsigned int panning = 0;
318 static unsigned int zoom_rb = 0;
320 SPDesktop *desktop = event_context->desktop;
322 tolerance = prefs_get_int_attribute_limited(
323 "options.dragtolerance","value", 0, 0, 100);
324 double const zoom_inc = prefs_get_double_attribute_limited(
325 "options.zoomincrement", "value", M_SQRT2, 1.01, 10);
326 double const acceleration = prefs_get_double_attribute_limited(
327 "options.scrollingacceleration", "value", 0, 0, 6);
328 int const key_scroll = prefs_get_int_attribute_limited(
329 "options.keyscroll", "value", 10, 0, 1000);
330 int const wheel_scroll = prefs_get_int_attribute_limited(
331 "options.wheelscroll", "value", 40, 0, 1000);
333 gint ret = FALSE;
335 switch (event->type) {
336 case GDK_2BUTTON_PRESS:
337 if (panning) {
338 panning = 0;
339 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
340 event->button.time);
341 ret = TRUE;
342 } else {
343 /* sp_desktop_dialog(); */
344 }
345 break;
346 case GDK_BUTTON_PRESS:
348 // save drag origin
349 xp = (gint) event->button.x;
350 yp = (gint) event->button.y;
351 within_tolerance = true;
353 switch (event->button.button) {
354 case 2:
356 if (dontgrab)
357 // double-click, still not permitted to grab;
358 // increase the counter to guard against triple click
359 {
360 dontgrab ++;
361 gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL);
362 break;
363 }
365 button_w = NR::Point(event->button.x,
366 event->button.y);
367 if (event->button.state == GDK_SHIFT_MASK) {
368 zoom_rb = 2;
369 } else {
370 panning = 2;
371 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
372 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
373 NULL, event->button.time-1);
374 }
375 ret = TRUE;
376 break;
377 case 3:
378 if (event->button.state & GDK_SHIFT_MASK
379 || event->button.state & GDK_CONTROL_MASK) {
380 button_w = NR::Point(event->button.x,
381 event->button.y);
382 panning = 3;
383 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
384 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
385 NULL, event->button.time);
386 ret = TRUE;
387 } else {
388 sp_event_root_menu_popup(desktop, NULL, event);
389 }
390 break;
391 default:
392 break;
393 }
394 break;
395 case GDK_MOTION_NOTIFY:
396 if (panning) {
397 if ((panning == 2 && !(event->motion.state & GDK_BUTTON2_MASK))
398 || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK))) {
399 /* Gdk seems to lose button release for us sometimes :-( */
400 panning = 0;
401 dontgrab = 0;
402 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
403 event->button.time);
404 ret = TRUE;
405 } else {
406 if ( within_tolerance
407 && ( abs( (gint) event->motion.x - xp ) < tolerance )
408 && ( abs( (gint) event->motion.y - yp ) < tolerance ))
409 {
410 // do not drag if we're within tolerance from origin
411 break;
412 }
413 // Once the user has moved farther than tolerance from
414 // the original location (indicating they intend to move
415 // the object, not click), then always process the motion
416 // notify coordinates as given (no snapping back to origin)
417 within_tolerance = false;
419 // gobble subsequent motion events to prevent "sticking"
420 // when scrolling is slow
421 gobble_motion_events(panning == 2 ?
422 GDK_BUTTON2_MASK : GDK_BUTTON3_MASK);
424 NR::Point const motion_w(event->motion.x,
425 event->motion.y);
426 NR::Point const moved_w( motion_w - button_w );
427 event_context->desktop->scroll_world(moved_w);
428 ret = TRUE;
429 }
430 } else if (zoom_rb) {
431 NR::Point const motion_w(event->motion.x, event->motion.y);
432 NR::Point const motion_dt(desktop->w2d(motion_w));
434 if ( within_tolerance
435 && ( abs( (gint) event->motion.x - xp ) < tolerance )
436 && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
437 break; // do not drag if we're within tolerance from origin
438 }
440 if (within_tolerance) {
441 Inkscape::Rubberband::get()->start(desktop, motion_dt);
442 } else {
443 Inkscape::Rubberband::get()->move(motion_dt);
444 }
446 // Once the user has moved farther than tolerance from the original location
447 // (indicating they intend to move the object, not click), then always process the
448 // motion notify coordinates as given (no snapping back to origin)
449 within_tolerance = false;
450 }
451 break;
452 case GDK_BUTTON_RELEASE:
453 if (within_tolerance && (panning || zoom_rb)) {
454 dontgrab ++;
455 NR::Point const event_w(event->button.x, event->button.y);
456 NR::Point const event_dt(desktop->w2d(event_w));
457 double const zoom_power = ( (event->button.state & GDK_SHIFT_MASK)
458 ? -dontgrab : dontgrab );
459 desktop->zoom_relative_keep_point(event_dt,
460 pow(zoom_inc, zoom_power));
461 gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL);
462 }
463 if (panning == event->button.button) {
464 panning = 0;
465 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
466 event->button.time);
467 ret = TRUE;
468 } else if (zoom_rb == event->button.button) {
469 zoom_rb = 0;
470 NR::Maybe<NR::Rect> const b = Inkscape::Rubberband::get()->getRectangle();
471 if (b != NR::Nothing() && !within_tolerance) {
472 desktop->set_display_area(b.assume(), 10);
473 }
474 Inkscape::Rubberband::get()->stop();
475 }
476 xp = yp = 0;
477 break;
478 case GDK_KEY_PRESS:
479 switch (get_group0_keyval(&event->key)) {
480 unsigned int shortcut;
481 case GDK_F1:
482 /* Grab it away from Gtk */
483 shortcut = get_group0_keyval(&event->key);
484 if (event->key.state & GDK_SHIFT_MASK)
485 shortcut |= SP_SHORTCUT_SHIFT_MASK;
486 if (event->key.state & GDK_CONTROL_MASK)
487 shortcut |= SP_SHORTCUT_CONTROL_MASK;
488 if (event->key.state & GDK_MOD1_MASK)
489 shortcut |= SP_SHORTCUT_ALT_MASK;
490 ret = sp_shortcut_invoke(shortcut, desktop);
491 break;
493 case GDK_Tab: // disable tab/shift-tab which cycle widget focus
494 case GDK_ISO_Left_Tab: // they will get different functions
495 if (!(MOD__CTRL_ONLY || (MOD__CTRL && MOD__SHIFT))) {
496 ret = TRUE;
497 } else {
498 /* Grab it away from Gtk */
499 shortcut = get_group0_keyval(&event->key);
500 if (event->key.state & GDK_SHIFT_MASK)
501 shortcut |= SP_SHORTCUT_SHIFT_MASK;
502 if (event->key.state & GDK_CONTROL_MASK)
503 shortcut |= SP_SHORTCUT_CONTROL_MASK;
504 if (event->key.state & GDK_MOD1_MASK)
505 shortcut |= SP_SHORTCUT_ALT_MASK;
506 ret = sp_shortcut_invoke(shortcut, desktop);
507 }
508 break;
509 case GDK_W:
510 case GDK_w:
511 case GDK_F4:
512 /* Close view */
513 if (MOD__CTRL_ONLY) {
514 sp_ui_close_view(NULL);
515 ret = TRUE;
516 }
517 break;
518 // FIXME: make import a verb
519 case GDK_i: // Ctrl i - import file
520 if (MOD__CTRL_ONLY) {
521 sp_file_import(NULL);
522 ret = TRUE;
523 }
524 break;
525 case GDK_Left: // Ctrl Left
526 case GDK_KP_Left:
527 case GDK_KP_4:
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(i, 0);
533 ret = TRUE;
534 }
535 break;
536 case GDK_Up: // Ctrl Up
537 case GDK_KP_Up:
538 case GDK_KP_8:
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(0, i);
544 ret = TRUE;
545 }
546 break;
547 case GDK_Right: // Ctrl Right
548 case GDK_KP_Right:
549 case GDK_KP_6:
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(-i, 0);
555 ret = TRUE;
556 }
557 break;
558 case GDK_Down: // Ctrl Down
559 case GDK_KP_Down:
560 case GDK_KP_2:
561 if (MOD__CTRL_ONLY) {
562 int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration));
563 gobble_key_events(get_group0_keyval(&event->key),
564 GDK_CONTROL_MASK);
565 event_context->desktop->scroll_world(0, -i);
566 ret = TRUE;
567 }
568 break;
569 case GDK_F10:
570 if (MOD__SHIFT_ONLY) {
571 sp_event_root_menu_popup(desktop, NULL, event);
572 ret= TRUE;
573 }
574 break;
575 case GDK_space:
576 sp_toggle_selector(desktop);
577 ret= TRUE;
578 break;
579 case GDK_z:
580 case GDK_Z:
581 if (MOD__ALT_ONLY) {
582 desktop->zoom_grab_focus();
583 ret = TRUE;
584 }
585 break;
586 default:
587 break;
588 }
589 break;
590 case GDK_SCROLL:
591 /* shift + wheel, pan left--right */
592 if (event->scroll.state & GDK_SHIFT_MASK) {
593 switch (event->scroll.direction) {
594 case GDK_SCROLL_UP:
595 desktop->scroll_world(wheel_scroll, 0);
596 break;
597 case GDK_SCROLL_DOWN:
598 desktop->scroll_world(-wheel_scroll, 0);
599 break;
600 default:
601 break;
602 }
604 /* ctrl + wheel, zoom in--out */
605 } else if (event->scroll.state & GDK_CONTROL_MASK) {
606 double rel_zoom;
607 switch (event->scroll.direction) {
608 case GDK_SCROLL_UP:
609 rel_zoom = zoom_inc;
610 break;
611 case GDK_SCROLL_DOWN:
612 rel_zoom = 1 / zoom_inc;
613 break;
614 default:
615 rel_zoom = 0.0;
616 break;
617 }
618 if (rel_zoom != 0.0) {
619 NR::Point const scroll_dt = desktop->point();
620 desktop->zoom_relative_keep_point(scroll_dt, rel_zoom);
621 }
623 /* no modifier, pan up--down (left--right on multiwheel mice?) */
624 } else {
625 switch (event->scroll.direction) {
626 case GDK_SCROLL_UP:
627 desktop->scroll_world(0, wheel_scroll);
628 break;
629 case GDK_SCROLL_DOWN:
630 desktop->scroll_world(0, -wheel_scroll);
631 break;
632 case GDK_SCROLL_LEFT:
633 desktop->scroll_world(wheel_scroll, 0);
634 break;
635 case GDK_SCROLL_RIGHT:
636 desktop->scroll_world(-wheel_scroll, 0);
637 break;
638 }
639 }
640 break;
641 default:
642 break;
643 }
645 return ret;
646 }
648 /**
649 * Handles item specific events. Gets called from Gdk.
650 *
651 * Only reacts to right mouse button at the moment.
652 * \todo Fixme: do context sensitive popup menu on items.
653 */
654 gint
655 sp_event_context_private_item_handler(SPEventContext *ec, SPItem *item, GdkEvent *event)
656 {
657 int ret = FALSE;
659 switch (event->type) {
660 case GDK_BUTTON_PRESS:
661 if ((event->button.button == 3)
662 && !(event->button.state & GDK_SHIFT_MASK || event->button.state & GDK_CONTROL_MASK)) {
663 sp_event_root_menu_popup(ec->desktop, item, event);
664 ret = TRUE;
665 }
666 break;
667 default:
668 break;
669 }
671 return ret;
672 }
674 /**
675 * Gets called when attribute changes value.
676 */
677 static void
678 sp_ec_repr_attr_changed(Inkscape::XML::Node *prefs_repr, gchar const *key, gchar const *oldval, gchar const *newval,
679 bool is_interactive, gpointer data)
680 {
681 SPEventContext *ec;
683 ec = SP_EVENT_CONTEXT(data);
685 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) {
686 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, newval);
687 }
688 }
690 Inkscape::XML::NodeEventVector sp_ec_event_vector = {
691 NULL, /* Child added */
692 NULL, /* Child removed */
693 sp_ec_repr_attr_changed,
694 NULL, /* Content changed */
695 NULL /* Order changed */
696 };
698 /**
699 * Creates new SPEventContext object and calls its virtual setup() function.
700 */
701 SPEventContext *
702 sp_event_context_new(GType type, SPDesktop *desktop, Inkscape::XML::Node *prefs_repr, unsigned int key)
703 {
704 g_return_val_if_fail(g_type_is_a(type, SP_TYPE_EVENT_CONTEXT), NULL);
705 g_return_val_if_fail(desktop != NULL, NULL);
707 SPEventContext *const ec = (SPEventContext*)g_object_new(type, NULL);
709 ec->desktop = desktop;
710 ec->_message_context = new Inkscape::MessageContext(desktop->messageStack());
711 ec->key = key;
712 ec->prefs_repr = prefs_repr;
713 if (ec->prefs_repr) {
714 Inkscape::GC::anchor(ec->prefs_repr);
715 sp_repr_add_listener(ec->prefs_repr, &sp_ec_event_vector, ec);
716 }
718 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup)
719 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup(ec);
721 return ec;
722 }
724 /**
725 * Finishes SPEventContext.
726 */
727 void
728 sp_event_context_finish(SPEventContext *ec)
729 {
730 g_return_if_fail(ec != NULL);
731 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
733 ec->enableSelectionCue(false);
735 if (ec->next) {
736 g_warning("Finishing event context with active link\n");
737 }
739 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish)
740 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish(ec);
741 }
743 //-------------------------------member functions
745 /**
746 * Enables/disables the SPEventContext's SelCue.
747 */
748 void SPEventContext::enableSelectionCue(bool enable) {
749 if (enable) {
750 if (!_selcue) {
751 _selcue = new Inkscape::SelCue(desktop);
752 }
753 } else {
754 delete _selcue;
755 _selcue = NULL;
756 }
757 }
759 /**
760 * Enables/disables the SPEventContext's GrDrag.
761 */
762 void SPEventContext::enableGrDrag(bool enable) {
763 if (enable) {
764 if (!_grdrag) {
765 _grdrag = new GrDrag(desktop);
766 }
767 } else {
768 if (_grdrag) {
769 delete _grdrag;
770 _grdrag = NULL;
771 }
772 }
773 }
775 /**
776 * Calls virtual set() function of SPEventContext.
777 */
778 void
779 sp_event_context_read(SPEventContext *ec, gchar const *key)
780 {
781 g_return_if_fail(ec != NULL);
782 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
783 g_return_if_fail(key != NULL);
785 if (ec->prefs_repr) {
786 gchar const *val = ec->prefs_repr->attribute(key);
787 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set)
788 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, val);
789 }
790 }
792 /**
793 * Calls virtual activate() function of SPEventContext.
794 */
795 void
796 sp_event_context_activate(SPEventContext *ec)
797 {
798 g_return_if_fail(ec != NULL);
799 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
801 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
802 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
803 }
805 /**
806 * Calls virtual deactivate() function of SPEventContext.
807 */
808 void
809 sp_event_context_deactivate(SPEventContext *ec)
810 {
811 g_return_if_fail(ec != NULL);
812 g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
814 if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
815 ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
816 }
818 /**
819 * Calls virtual root_handler(), the main event handling function.
820 */
821 gint
822 sp_event_context_root_handler(SPEventContext * event_context, GdkEvent * event)
823 {
824 gint ret;
826 ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event);
828 set_event_location(event_context->desktop, event);
830 return ret;
831 }
833 /**
834 * Calls virtual item_handler(), the item event handling function.
835 */
836 gint
837 sp_event_context_item_handler(SPEventContext * event_context, SPItem * item, GdkEvent * event)
838 {
839 gint ret;
841 ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event);
843 if (! ret) {
844 ret = sp_event_context_root_handler(event_context, event);
845 } else {
846 set_event_location(event_context->desktop, event);
847 }
849 return ret;
850 }
852 /**
853 * Emits 'position_set' signal on desktop and shows coordinates on status bar.
854 */
855 static void set_event_location(SPDesktop *desktop, GdkEvent *event)
856 {
857 if (event->type != GDK_MOTION_NOTIFY) {
858 return;
859 }
861 NR::Point const button_w(event->button.x, event->button.y);
862 NR::Point const button_dt(desktop->w2d(button_w));
863 desktop-> setPosition (button_dt);
864 desktop->set_coordinate_status(button_dt);
865 }
867 //-------------------------------------------------------------------
868 /**
869 * Create popup menu and tell Gtk to show it.
870 */
871 void
872 sp_event_root_menu_popup(SPDesktop *desktop, SPItem *item, GdkEvent *event)
873 {
874 GtkWidget *menu;
876 /* fixme: This is not what I want but works for now (Lauris) */
877 if (event->type == GDK_KEY_PRESS) {
878 item = SP_DT_SELECTION(desktop)->singleItem();
879 }
880 menu = sp_ui_context_menu(desktop, item);
881 gtk_widget_show(menu);
883 switch (event->type) {
884 case GDK_BUTTON_PRESS:
885 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, event->button.button, event->button.time);
886 break;
887 case GDK_KEY_PRESS:
888 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, 0, event->key.time);
889 break;
890 default:
891 break;
892 }
893 }
895 /**
896 * Show tool context specific modifier tip.
897 */
898 void
899 sp_event_show_modifier_tip(Inkscape::MessageContext *message_context,
900 GdkEvent *event, gchar const *ctrl_tip, gchar const *shift_tip,
901 gchar const *alt_tip)
902 {
903 guint keyval = get_group0_keyval(&event->key);
905 bool ctrl = ctrl_tip && (MOD__CTRL
906 || (keyval == GDK_Control_L)
907 || (keyval == GDK_Control_R));
908 bool shift = shift_tip
909 && (MOD__SHIFT || (keyval == GDK_Shift_L) || (keyval == GDK_Shift_R));
910 bool alt = alt_tip
911 && (MOD__ALT
912 || (keyval == GDK_Alt_L)
913 || (keyval == GDK_Alt_R)
914 || (keyval == GDK_Meta_L)
915 || (keyval == GDK_Meta_R));
917 gchar *tip = g_strdup_printf("%s%s%s%s%s",
918 ( ctrl ? ctrl_tip : "" ),
919 ( ctrl && (shift || alt) ? "; " : "" ),
920 ( shift ? shift_tip : "" ),
921 ( (ctrl || shift) && alt ? "; " : "" ),
922 ( alt ? alt_tip : "" ));
924 if (strlen(tip) > 0) {
925 message_context->flash(Inkscape::INFORMATION_MESSAGE, tip);
926 }
928 g_free(tip);
929 }
931 /**
932 * Return the keyval corresponding to the key event in group 0, i.e.,
933 * in the main (English) layout.
934 *
935 * Use this instead of simply event->keyval, so that your keyboard shortcuts
936 * work regardless of layouts (e.g., in Cyrillic).
937 */
938 guint
939 get_group0_keyval(GdkEventKey *event)
940 {
941 guint keyval = 0;
942 gdk_keymap_translate_keyboard_state(
943 gdk_keymap_get_for_display(gdk_display_get_default()),
944 event->hardware_keycode,
945 (GdkModifierType) event->state,
946 0 /*event->key.group*/,
947 &keyval, NULL, NULL, NULL);
948 return keyval;
949 }
951 /**
952 * Returns item at point p in desktop.
953 *
954 * If state includes alt key mask, cyclically selects under; honors
955 * into_groups.
956 */
957 SPItem *
958 sp_event_context_find_item (SPDesktop *desktop, NR::Point const p,
959 bool select_under, bool into_groups)
960 {
961 SPItem *item;
963 if (select_under) {
964 SPItem *selected_at_point =
965 desktop->item_from_list_at_point_bottom (desktop->selection->itemList(), p);
966 item = desktop->item_at_point(p, into_groups, selected_at_point);
967 if (item == NULL) { // we may have reached bottom, flip over to the top
968 item = desktop->item_at_point(p, into_groups, NULL);
969 }
970 } else
971 item = desktop->item_at_point(p, into_groups, NULL);
973 return item;
974 }
976 /**
977 * Returns item if it is under point p in desktop, at any depth; otherwise returns NULL.
978 *
979 * Honors into_groups.
980 */
981 SPItem *
982 sp_event_context_over_item (SPDesktop *desktop, SPItem *item, NR::Point const p)
983 {
984 GSList *temp = NULL;
985 temp = g_slist_prepend (temp, item);
986 SPItem *item_at_point = desktop->item_from_list_at_point_bottom (temp, p);
987 g_slist_free (temp);
989 return item_at_point;
990 }
992 /**
993 * Called when SPEventContext subclass node attribute changed.
994 */
995 void
996 ec_shape_event_attr_changed(Inkscape::XML::Node *shape_repr, gchar const *name,
997 gchar const *old_value, gchar const *new_value,
998 bool const is_interactive, gpointer const data)
999 {
1000 if (!name
1001 || !strcmp(name, "style")
1002 || SP_ATTRIBUTE_IS_CSS(sp_attribute_lookup(name))) {
1003 // no need to regenrate knotholder if only style changed
1004 return;
1005 }
1007 SPEventContext *ec = SP_EVENT_CONTEXT(data);
1009 if (ec->shape_knot_holder) {
1010 sp_knot_holder_destroy(ec->shape_knot_holder);
1011 }
1012 ec->shape_knot_holder = NULL;
1014 SPDesktop *desktop = ec->desktop;
1016 SPItem *item = SP_DT_SELECTION(desktop)->singleItem();
1018 if (item) {
1019 ec->shape_knot_holder = sp_item_knot_holder(item, desktop);
1020 }
1021 }
1024 /*
1025 Local Variables:
1026 mode:c++
1027 c-file-style:"stroustrup"
1028 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1029 indent-tabs-mode:nil
1030 fill-column:99
1031 End:
1032 */
1033 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :