src/event-context.cpp

   1 #define __SP_EVENT_CONTEXT_C__
   2
   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  */
  16
  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  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include "event-context.h"
  31
  32 #include <string.h>
  33 #include <gdk/gdkkeysyms.h>
  34 #include <gtk/gtkmain.h>
  35 #include <gtk/gtkmenu.h>
  36 #include <glibmm/i18n.h>
  37 #include <cstring>
  38 #include <string>
  39
  40 #include "display/sp-canvas.h"
  41 #include "xml/node-event-vector.h"
  42 #include "sp-cursor.h"
  43 #include "shortcuts.h"
  44 #include "desktop.h"
  45 #include "desktop-handles.h"
  46 #include "selection.h"
  47 #include "file.h"
  48 #include "interface.h"
  49 #include "macros.h"
  50 #include "tools-switch.h"
  51 #include "prefs-utils.h"
  52 #include "message-context.h"
  53 #include "gradient-drag.h"
  54 #include "object-edit.h"
  55 #include "attributes.h"
  56 #include "rubberband.h"
  57 #include "selcue.h"
  58 #include "node-context.h"
  59 #include "lpe-tool-context.h"
  60
  61 static void sp_event_context_class_init(SPEventContextClass *klass);
  62 static void sp_event_context_init(SPEventContext *event_context);
  63 static void sp_event_context_dispose(GObject *object);
  64
  65 static void sp_event_context_private_setup(SPEventContext *ec);
  66 static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event);
  67 static gint sp_event_context_private_item_handler(SPEventContext *event_context, SPItem *item, GdkEvent *event);
  68
  69 static void set_event_location(SPDesktop * desktop, GdkEvent * event);
  70
  71 static GObjectClass *parent_class;
  72
  73 // globals for temporary switching to selector by space
  74 static bool selector_toggled = FALSE;
  75 static int switch_selector_to = 0;
  76
  77 // globals for temporary switching to dropper by 'D'
  78 static bool dropper_toggled = FALSE;
  79 static int switch_dropper_to = 0;
  80
  81 static gint xp = 0, yp = 0; // where drag started
  82 static gint tolerance = 0;
  83 static bool within_tolerance = false;
  84
  85 // globals for keeping track of keyboard scroll events in order to accelerate
  86 static guint32 scroll_event_time = 0;
  87 static gdouble scroll_multiply = 1;
  88 static guint scroll_keyval = 0;
  89
  90 /**
  91  * Registers the SPEventContext class with Glib and returns its type number.
  92  */
  93 GType
  94 sp_event_context_get_type(void)
  95 {
  96     static GType type = 0;
  97     if (!type) {
  98         GTypeInfo info = {
  99             sizeof(SPEventContextClass),
 100             NULL, NULL,
 101             (GClassInitFunc) sp_event_context_class_init,
 102             NULL, NULL,
 103             sizeof(SPEventContext),
 104             4,
 105             (GInstanceInitFunc) sp_event_context_init,
 106             NULL,    /* value_table */
 107         };
 108         type = g_type_register_static(G_TYPE_OBJECT, "SPEventContext", &info, (GTypeFlags)0);
 109     }
 110     return type;
 111 }
 112
 113 /**
 114  * Callback to set up the SPEventContext vtable.
 115  */
 116 static void
 117 sp_event_context_class_init(SPEventContextClass *klass)
 118 {
 119     GObjectClass *object_class;
 120
 121     object_class = (GObjectClass *) klass;
 122
 123     parent_class = (GObjectClass*)g_type_class_peek_parent(klass);
 124
 125     object_class->dispose = sp_event_context_dispose;
 126
 127     klass->setup = sp_event_context_private_setup;
 128     klass->root_handler = sp_event_context_private_root_handler;
 129     klass->item_handler = sp_event_context_private_item_handler;
 130 }
 131
 132 /**
 133  * Clears all SPEventContext object members.
 134  */
 135 static void
 136 sp_event_context_init(SPEventContext *event_context)
 137 {
 138     event_context->desktop = NULL;
 139     event_context->cursor = NULL;
 140     event_context->_message_context = NULL;
 141     event_context->_selcue = NULL;
 142     event_context->_grdrag = NULL;
 143     event_context->space_panning = false;
 144 }
 145
 146 /**
 147  * Callback to free and null member variables of SPEventContext object.
 148  */
 149 static void
 150 sp_event_context_dispose(GObject *object)
 151 {
 152     SPEventContext *ec;
 153
 154     ec = SP_EVENT_CONTEXT(object);
 155
 156     if (ec->_message_context) {
 157         delete ec->_message_context;
 158     }
 159
 160     if (ec->cursor != NULL) {
 161         gdk_cursor_unref(ec->cursor);
 162         ec->cursor = NULL;
 163     }
 164
 165     if (ec->desktop) {
 166         ec->desktop = NULL;
 167     }
 168
 169     if (ec->prefs_repr) {
 170         sp_repr_remove_listener_by_data(ec->prefs_repr, ec);
 171         Inkscape::GC::release(ec->prefs_repr);
 172         ec->prefs_repr = NULL;
 173     }
 174
 175     G_OBJECT_CLASS(parent_class)->dispose(object);
 176 }
 177
 178 /**
 179  * Recreates and draws cursor on desktop related to SPEventContext.
 180  */
 181 void
 182 sp_event_context_update_cursor(SPEventContext *ec)
 183 {
 184     GtkWidget *w = GTK_WIDGET(sp_desktop_canvas(ec->desktop));
 185     if (w->window) {
 186         /* fixme: */
 187         if (ec->cursor_shape) {
 188             GdkBitmap *bitmap = NULL;
 189             GdkBitmap *mask = NULL;
 190             sp_cursor_bitmap_and_mask_from_xpm(&bitmap, &mask, ec->cursor_shape);
 191             if ((bitmap != NULL) && (mask != NULL)) {
 192                 if (ec->cursor)
 193                     gdk_cursor_unref (ec->cursor);
 194                 ec->cursor = gdk_cursor_new_from_pixmap(bitmap, mask,
 195                                                         &w->style->black,
 196                                                         &w->style->white,
 197                                                         ec->hot_x, ec->hot_y);
 198                 g_object_unref (bitmap);
 199                 g_object_unref (mask);
 200             }
 201         }
 202         gdk_window_set_cursor(w->window, ec->cursor);
 203         gdk_flush();
 204     }
 205     ec->desktop->waiting_cursor = false;
 206 }
 207
 208 /**
 209  * Callback that gets called on initialization of SPEventContext object.
 210  * Redraws mouse cursor, at the moment.
 211  */
 212 static void
 213 sp_event_context_private_setup(SPEventContext *ec)
 214 {
 215     sp_event_context_update_cursor(ec);
 216 }
 217
 218 /**
 219  * \brief   Gobbles next key events on the queue with the same keyval and mask. Returns the number of events consumed.
 220  */
 221 gint gobble_key_events(guint keyval, gint mask)
 222 {
 223     GdkEvent *event_next;
 224     gint i = 0;
 225
 226     event_next = gdk_event_get();
 227     // while the next event is also a key notify with the same keyval and mask,
 228     while (event_next && (event_next->type == GDK_KEY_PRESS || event_next->type == GDK_KEY_RELEASE)
 229            && event_next->key.keyval == keyval
 230            && (!mask || (event_next->key.state & mask))) {
 231         if (event_next->type == GDK_KEY_PRESS)
 232             i ++;
 233         // kill it
 234         gdk_event_free(event_next);
 235         // get next
 236         event_next = gdk_event_get();
 237     }
 238     // otherwise, put it back onto the queue
 239     if (event_next) gdk_event_put(event_next);
 240
 241     return i;
 242 }
 243
 244 /**
 245  * \brief   Gobbles next motion notify events on the queue with the same mask. Returns the number of events consumed.
 246 */
 247 gint gobble_motion_events(gint mask)
 248 {
 249     GdkEvent *event_next;
 250     gint i = 0;
 251
 252     event_next = gdk_event_get();
 253     // while the next event is also a key notify with the same keyval and mask,
 254     while (event_next && event_next->type == GDK_MOTION_NOTIFY
 255            && (event_next->motion.state & mask)) {
 256         // kill it
 257         gdk_event_free(event_next);
 258         // get next
 259         event_next = gdk_event_get();
 260         i ++;
 261     }
 262     // otherwise, put it back onto the queue
 263     if (event_next) gdk_event_put(event_next);
 264
 265     return i;
 266 }
 267
 268 /**
 269  * Toggles current tool between active tool and selector tool.
 270  * Subroutine of sp_event_context_private_root_handler().
 271  */
 272 static void
 273 sp_toggle_selector(SPDesktop *dt)
 274 {
 275     if (!dt->event_context) return;
 276
 277     if (tools_isactive(dt, TOOLS_SELECT)) {
 278         if (selector_toggled) {
 279             if (switch_selector_to) tools_switch (dt, switch_selector_to);
 280             selector_toggled = FALSE;
 281         } else return;
 282     } else {
 283         selector_toggled = TRUE;
 284         switch_selector_to = tools_active(dt);
 285         tools_switch (dt, TOOLS_SELECT);
 286     }
 287 }
 288
 289 /**
 290  * Toggles current tool between active tool and dropper tool.
 291  * Subroutine of sp_event_context_private_root_handler().
 292  */
 293 static void
 294 sp_toggle_dropper(SPDesktop *dt)
 295 {
 296     if (!dt->event_context) return;
 297
 298     if (tools_isactive(dt, TOOLS_DROPPER)) {
 299         if (dropper_toggled) {
 300             if (switch_dropper_to) tools_switch (dt, switch_dropper_to);
 301             dropper_toggled = FALSE;
 302         } else return;
 303     } else {
 304         dropper_toggled = TRUE;
 305         switch_dropper_to = tools_active(dt);
 306         tools_switch (dt, TOOLS_DROPPER);
 307     }
 308 }
 309
 310 /**
 311  * Calculates and keeps track of scroll acceleration.
 312  * Subroutine of sp_event_context_private_root_handler().
 313  */
 314 static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration, SPCanvas */*canvas*/)
 315 {
 316     guint32 time_diff = ((GdkEventKey *) event)->time - scroll_event_time;
 317
 318     /* key pressed within 500ms ? (1/2 second) */
 319     if (time_diff > 500 || event->key.keyval != scroll_keyval) {
 320         scroll_multiply = 1; // abort acceleration
 321     } else {
 322         scroll_multiply += acceleration; // continue acceleration
 323     }
 324
 325     scroll_event_time = ((GdkEventKey *) event)->time;
 326     scroll_keyval = event->key.keyval;
 327
 328     return scroll_multiply;
 329 }
 330
 331 /**
 332  * Main event dispatch, gets called from Gdk.
 333  */
 334 static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event)
 335 {
 336     static Geom::Point button_w;
 337     static unsigned int panning = 0;
 338     static unsigned int zoom_rb = 0;
 339
 340     SPDesktop *desktop = event_context->desktop;
 341
 342     tolerance = prefs_get_int_attribute_limited(
 343             "options.dragtolerance","value", 0, 0, 100);
 344     double const zoom_inc = prefs_get_double_attribute_limited(
 345             "options.zoomincrement", "value", M_SQRT2, 1.01, 10);
 346     double const acceleration = prefs_get_double_attribute_limited(
 347             "options.scrollingacceleration", "value", 0, 0, 6);
 348     int const key_scroll = prefs_get_int_attribute_limited(
 349             "options.keyscroll", "value", 10, 0, 1000);
 350     int const wheel_scroll = prefs_get_int_attribute_limited(
 351             "options.wheelscroll", "value", 40, 0, 1000);
 352
 353     gint ret = FALSE;
 354
 355     switch (event->type) {
 356         case GDK_2BUTTON_PRESS:
 357             if (panning) {
 358                 panning = 0;
 359                 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
 360                         event->button.time);
 361                 ret = TRUE;
 362             } else {
 363                 /* sp_desktop_dialog(); */
 364             }
 365             break;
 366         case GDK_BUTTON_PRESS:
 367
 368             // save drag origin
 369             xp = (gint) event->button.x;
 370             yp = (gint) event->button.y;
 371             within_tolerance = true;
 372
 373             button_w = Geom::Point(event->button.x, event->button.y);
 374
 375             switch (event->button.button) {
 376                 case 1:
 377                     if (event_context->space_panning) {
 378                         panning = 1;
 379                         sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
 380                             GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
 381                             NULL, event->button.time-1);
 382                         ret = TRUE;
 383                     }
 384                     break;
 385                 case 2:
 386                     if (event->button.state == GDK_SHIFT_MASK) {
 387                         zoom_rb = 2;
 388                     } else {
 389                         panning = 2;
 390                         sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
 391                             GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
 392                             NULL, event->button.time-1);
 393                     }
 394                     ret = TRUE;
 395                     break;
 396                 case 3:
 397                     if (event->button.state & GDK_SHIFT_MASK
 398                             || event->button.state & GDK_CONTROL_MASK) {
 399                         panning = 3;
 400                         sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
 401                                 GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK,
 402                                 NULL, event->button.time);
 403                         ret = TRUE;
 404                     } else {
 405                         sp_event_root_menu_popup(desktop, NULL, event);
 406                     }
 407                     break;
 408                 default:
 409                     break;
 410             }
 411             break;
 412         case GDK_MOTION_NOTIFY:
 413             if (panning) {
 414                 if ((panning == 2 && !(event->motion.state & GDK_BUTTON2_MASK))
 415                         || (panning == 1 && !(event->motion.state & GDK_BUTTON1_MASK))
 416                         || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK))
 417                    ) {
 418                     /* Gdk seems to lose button release for us sometimes :-( */
 419                     panning = 0;
 420                     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
 421                             event->button.time);
 422                     ret = TRUE;
 423                 } else {
 424                     if ( within_tolerance
 425                          && ( abs( (gint) event->motion.x - xp ) < tolerance )
 426                          && ( abs( (gint) event->motion.y - yp ) < tolerance ))
 427                     {
 428                         // do not drag if we're within tolerance from origin
 429                         break;
 430                     }
 431                     // Once the user has moved farther than tolerance from
 432                     // the original location (indicating they intend to move
 433                     // the object, not click), then always process the motion
 434                     // notify coordinates as given (no snapping back to origin)
 435                     within_tolerance = false;
 436
 437                     // gobble subsequent motion events to prevent "sticking"
 438                     // when scrolling is slow
 439                     gobble_motion_events(panning == 2 ?
 440                                          GDK_BUTTON2_MASK :
 441                                          (panning == 1 ? GDK_BUTTON1_MASK : GDK_BUTTON3_MASK));
 442
 443                     Geom::Point const motion_w(event->motion.x, event->motion.y);
 444                     Geom::Point const moved_w( motion_w - button_w );
 445                     event_context->desktop->scroll_world(moved_w, true); // we're still scrolling, do not redraw
 446                     ret = TRUE;
 447                 }
 448             } else if (zoom_rb) {
 449                 Geom::Point const motion_w(event->motion.x, event->motion.y);
 450                 Geom::Point const motion_dt(desktop->w2d(motion_w));
 451
 452                 if ( within_tolerance
 453                      && ( abs( (gint) event->motion.x - xp ) < tolerance )
 454                      && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) {
 455                     break; // do not drag if we're within tolerance from origin
 456                 }
 457                 // Once the user has moved farther than tolerance from the original location
 458                 // (indicating they intend to move the object, not click), then always process the
 459                 // motion notify coordinates as given (no snapping back to origin)
 460                 within_tolerance = false;
 461
 462                 if (Inkscape::Rubberband::get(desktop)->is_started()) {
 463                     Inkscape::Rubberband::get(desktop)->move(motion_dt);
 464                 } else {
 465                     Inkscape::Rubberband::get(desktop)->start(desktop, motion_dt);
 466                 }
 467                 if (zoom_rb == 2)
 468                     gobble_motion_events(GDK_BUTTON2_MASK);
 469             }
 470             break;
 471         case GDK_BUTTON_RELEASE:
 472             xp = yp = 0;
 473             if (within_tolerance && (panning || zoom_rb)) {
 474                 zoom_rb = 0;
 475                 if (panning) {
 476                     panning = 0;
 477                     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
 478                                       event->button.time);
 479                 }
 480                 Geom::Point const event_w(event->button.x, event->button.y);
 481                 Geom::Point const event_dt(desktop->w2d(event_w));
 482                 desktop->zoom_relative_keep_point(event_dt,
 483                           (event->button.state & GDK_SHIFT_MASK) ? 1/zoom_inc : zoom_inc);
 484                 desktop->updateNow();
 485                 ret = TRUE;
 486             } else if (panning == event->button.button) {
 487                 panning = 0;
 488                 sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
 489                                       event->button.time);
 490
 491                 // in slow complex drawings, some of the motion events are lost;
 492                 // to make up for this, we scroll it once again to the button-up event coordinates
 493                 // (i.e. canvas will always get scrolled all the way to the mouse release point,
 494                 // even if few intermediate steps were visible)
 495                 Geom::Point const motion_w(event->button.x, event->button.y);
 496                 Geom::Point const moved_w( motion_w - button_w );
 497                 event_context->desktop->scroll_world(moved_w);
 498                 desktop->updateNow();
 499                 ret = TRUE;
 500             } else if (zoom_rb == event->button.button) {
 501                 zoom_rb = 0;
 502                 boost::optional<NR::Rect> const b = Inkscape::Rubberband::get(desktop)->getRectangle();
 503                 Inkscape::Rubberband::get(desktop)->stop();
 504                 if (b && !within_tolerance) {
 505                     desktop->set_display_area(*b, 10);
 506                 }
 507                 ret = TRUE;
 508             }
 509             break;
 510         case GDK_KEY_PRESS:
 511             switch (get_group0_keyval(&event->key)) {
 512                 // GDK insists on stealing these keys (F1 for no idea what, tab for cycling widgets
 513                 // in the editing window). So we resteal them back and run our regular shortcut
 514                 // invoker on them.
 515                 unsigned int shortcut;
 516                 case GDK_Tab:
 517                 case GDK_ISO_Left_Tab:
 518                 case GDK_F1:
 519                     shortcut = get_group0_keyval(&event->key);
 520                     if (event->key.state & GDK_SHIFT_MASK)
 521                         shortcut |= SP_SHORTCUT_SHIFT_MASK;
 522                     if (event->key.state & GDK_CONTROL_MASK)
 523                         shortcut |= SP_SHORTCUT_CONTROL_MASK;
 524                     if (event->key.state & GDK_MOD1_MASK)
 525                         shortcut |= SP_SHORTCUT_ALT_MASK;
 526                     ret = sp_shortcut_invoke(shortcut, desktop);
 527                     break;
 528
 529                 case GDK_D:
 530                 case GDK_d:
 531                     if (!MOD__SHIFT && !MOD__CTRL && !MOD__ALT) {
 532                         sp_toggle_dropper(desktop);
 533                         ret = TRUE;
 534                     }
 535                     break;
 536                 case GDK_W:
 537                 case GDK_w:
 538                 case GDK_F4:
 539                     /* Close view */
 540                     if (MOD__CTRL_ONLY) {
 541                         sp_ui_close_view(NULL);
 542                         ret = TRUE;
 543                     }
 544                     break;
 545                 case GDK_Left: // Ctrl Left
 546                 case GDK_KP_Left:
 547                 case GDK_KP_4:
 548                     if (MOD__CTRL_ONLY) {
 549                         int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop)));
 550                         gobble_key_events(get_group0_keyval(&event->key),
 551                                 GDK_CONTROL_MASK);
 552                         event_context->desktop->scroll_world(i, 0);
 553                         ret = TRUE;
 554                     }
 555                     break;
 556                 case GDK_Up: // Ctrl Up
 557                 case GDK_KP_Up:
 558                 case GDK_KP_8:
 559                     if (MOD__CTRL_ONLY) {
 560                         int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop)));
 561                         gobble_key_events(get_group0_keyval(&event->key),
 562                                 GDK_CONTROL_MASK);
 563                         event_context->desktop->scroll_world(0, i);
 564                         ret = TRUE;
 565                     }
 566                     break;
 567                 case GDK_Right: // Ctrl Right
 568                 case GDK_KP_Right:
 569                 case GDK_KP_6:
 570                     if (MOD__CTRL_ONLY) {
 571                         int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop)));
 572                         gobble_key_events(get_group0_keyval(&event->key),
 573                                 GDK_CONTROL_MASK);
 574                         event_context->desktop->scroll_world(-i, 0);
 575                         ret = TRUE;
 576                     }
 577                     break;
 578                 case GDK_Down: // Ctrl Down
 579                 case GDK_KP_Down:
 580                 case GDK_KP_2:
 581                     if (MOD__CTRL_ONLY) {
 582                         int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop)));
 583                         gobble_key_events(get_group0_keyval(&event->key),
 584                                 GDK_CONTROL_MASK);
 585                         event_context->desktop->scroll_world(0, -i);
 586                         ret = TRUE;
 587                     }
 588                     break;
 589                 case GDK_F10:
 590                     if (MOD__SHIFT_ONLY) {
 591                         sp_event_root_menu_popup(desktop, NULL, event);
 592                         ret= TRUE;
 593                     }
 594                     break;
 595                 case GDK_space:
 596                     if (prefs_get_int_attribute("options.spacepans","value", 0) == 1) {
 597                         event_context->space_panning = true;
 598                         event_context->_message_context->set(Inkscape::INFORMATION_MESSAGE, _("<b>Space+mouse drag</b> to pan canvas"));
 599                         ret= TRUE;
 600                     } else {
 601                         sp_toggle_selector(desktop);
 602                         ret= TRUE;
 603                     }
 604                     break;
 605                 case GDK_z:
 606                 case GDK_Z:
 607                     if (MOD__ALT_ONLY) {
 608                         desktop->zoom_grab_focus();
 609                         ret = TRUE;
 610                     }
 611                     break;
 612                 default:
 613                     break;
 614             }
 615             break;
 616         case GDK_KEY_RELEASE:
 617             switch (get_group0_keyval(&event->key)) {
 618                 case GDK_space:
 619                     if (event_context->space_panning) {
 620                         event_context->space_panning = false;
 621                         event_context->_message_context->clear();
 622                         if (panning == 1) {
 623                             panning = 0;
 624                             sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
 625                                   event->key.time);
 626                             desktop->updateNow();
 627                         }
 628                         ret= TRUE;
 629                     }
 630                     break;
 631                 default:
 632                     break;
 633             }
 634             break;
 635         case GDK_SCROLL:
 636         {
 637             bool ctrl = (event->scroll.state & GDK_CONTROL_MASK);
 638             bool wheelzooms = (prefs_get_int_attribute("options.wheelzooms","value", 0) == 1);
 639             /* shift + wheel, pan left--right */
 640             if (event->scroll.state & GDK_SHIFT_MASK) {
 641                 switch (event->scroll.direction) {
 642                     case GDK_SCROLL_UP:
 643                         desktop->scroll_world(wheel_scroll, 0);
 644                         break;
 645                     case GDK_SCROLL_DOWN:
 646                         desktop->scroll_world(-wheel_scroll, 0);
 647                         break;
 648                     default:
 649                         break;
 650                 }
 651
 652                 /* ctrl + wheel, zoom in--out */
 653             } else if ((ctrl && !wheelzooms) || (!ctrl && wheelzooms)) {
 654                 double rel_zoom;
 655                 switch (event->scroll.direction) {
 656                     case GDK_SCROLL_UP:
 657                         rel_zoom = zoom_inc;
 658                         break;
 659                     case GDK_SCROLL_DOWN:
 660                         rel_zoom = 1 / zoom_inc;
 661                         break;
 662                     default:
 663                         rel_zoom = 0.0;
 664                         break;
 665                 }
 666                 if (rel_zoom != 0.0) {
 667                     Geom::Point const scroll_dt = desktop->point();
 668                     desktop->zoom_relative_keep_point(scroll_dt, rel_zoom);
 669                 }
 670
 671                 /* no modifier, pan up--down (left--right on multiwheel mice?) */
 672             } else {
 673                 switch (event->scroll.direction) {
 674                     case GDK_SCROLL_UP:
 675                         desktop->scroll_world(0, wheel_scroll);
 676                         break;
 677                     case GDK_SCROLL_DOWN:
 678                         desktop->scroll_world(0, -wheel_scroll);
 679                         break;
 680                     case GDK_SCROLL_LEFT:
 681                         desktop->scroll_world(wheel_scroll, 0);
 682                         break;
 683                     case GDK_SCROLL_RIGHT:
 684                         desktop->scroll_world(-wheel_scroll, 0);
 685                         break;
 686                 }
 687             }
 688             break;
 689         }
 690         default:
 691             break;
 692     }
 693
 694     return ret;
 695 }
 696
 697 /**
 698  * Handles item specific events. Gets called from Gdk.
 699  *
 700  * Only reacts to right mouse button at the moment.
 701  * \todo Fixme: do context sensitive popup menu on items.
 702  */
 703 gint
 704 sp_event_context_private_item_handler(SPEventContext *ec, SPItem *item, GdkEvent *event)
 705 {
 706     int ret = FALSE;
 707
 708     switch (event->type) {
 709         case GDK_BUTTON_PRESS:
 710             if ((event->button.button == 3)
 711                     && !(event->button.state & GDK_SHIFT_MASK || event->button.state & GDK_CONTROL_MASK)) {
 712                 sp_event_root_menu_popup(ec->desktop, item, event);
 713                 ret = TRUE;
 714             }
 715             break;
 716         default:
 717             break;
 718     }
 719
 720     return ret;
 721 }
 722
 723 /**
 724  * Gets called when attribute changes value.
 725  */
 726 static void
 727 sp_ec_repr_attr_changed(Inkscape::XML::Node */*prefs_repr*/, gchar const *key, gchar const */*oldval*/, gchar const *newval,
 728                         bool /*is_interactive*/, gpointer data)
 729 {
 730     SPEventContext *ec;
 731
 732     ec = SP_EVENT_CONTEXT(data);
 733
 734     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) {
 735         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, newval);
 736     }
 737 }
 738
 739 Inkscape::XML::NodeEventVector sp_ec_event_vector = {
 740     NULL, /* Child added */
 741     NULL, /* Child removed */
 742     sp_ec_repr_attr_changed,
 743     NULL, /* Content changed */
 744     NULL /* Order changed */
 745 };
 746
 747 /**
 748  * Creates new SPEventContext object and calls its virtual setup() function.
 749  */
 750 SPEventContext *
 751 sp_event_context_new(GType type, SPDesktop *desktop, Inkscape::XML::Node *prefs_repr, unsigned int key)
 752 {
 753     g_return_val_if_fail(g_type_is_a(type, SP_TYPE_EVENT_CONTEXT), NULL);
 754     g_return_val_if_fail(desktop != NULL, NULL);
 755
 756     SPEventContext *const ec = (SPEventContext*)g_object_new(type, NULL);
 757
 758     ec->desktop = desktop;
 759     ec->_message_context = new Inkscape::MessageContext(desktop->messageStack());
 760     ec->key = key;
 761     ec->prefs_repr = prefs_repr;
 762     if (ec->prefs_repr) {
 763         Inkscape::GC::anchor(ec->prefs_repr);
 764         sp_repr_add_listener(ec->prefs_repr, &sp_ec_event_vector, ec);
 765     }
 766
 767     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup)
 768         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup(ec);
 769
 770     return ec;
 771 }
 772
 773 /**
 774  * Finishes SPEventContext.
 775  */
 776 void
 777 sp_event_context_finish(SPEventContext *ec)
 778 {
 779     g_return_if_fail(ec != NULL);
 780     g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
 781
 782     ec->enableSelectionCue(false);
 783
 784     if (ec->next) {
 785         g_warning("Finishing event context with active link\n");
 786     }
 787
 788     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish)
 789         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish(ec);
 790 }
 791
 792 //-------------------------------member functions
 793
 794 /**
 795  * Enables/disables the SPEventContext's SelCue.
 796  */
 797 void SPEventContext::enableSelectionCue(bool enable) {
 798     if (enable) {
 799         if (!_selcue) {
 800             _selcue = new Inkscape::SelCue(desktop);
 801         }
 802     } else {
 803         delete _selcue;
 804         _selcue = NULL;
 805     }
 806 }
 807
 808 /**
 809  * Enables/disables the SPEventContext's GrDrag.
 810  */
 811 void SPEventContext::enableGrDrag(bool enable) {
 812     if (enable) {
 813         if (!_grdrag) {
 814             _grdrag = new GrDrag(desktop);
 815         }
 816     } else {
 817         if (_grdrag) {
 818             delete _grdrag;
 819             _grdrag = NULL;
 820         }
 821     }
 822 }
 823
 824 /**
 825  * Calls virtual set() function of SPEventContext.
 826  */
 827 void
 828 sp_event_context_read(SPEventContext *ec, gchar const *key)
 829 {
 830     g_return_if_fail(ec != NULL);
 831     g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
 832     g_return_if_fail(key != NULL);
 833
 834     if (ec->prefs_repr) {
 835         gchar const *val = ec->prefs_repr->attribute(key);
 836         if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set)
 837             ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, val);
 838     }
 839 }
 840
 841 /**
 842  * Calls virtual activate() function of SPEventContext.
 843  */
 844 void
 845 sp_event_context_activate(SPEventContext *ec)
 846 {
 847     g_return_if_fail(ec != NULL);
 848     g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
 849
 850     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
 851         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
 852 }
 853
 854 /**
 855  * Calls virtual deactivate() function of SPEventContext.
 856  */
 857 void
 858 sp_event_context_deactivate(SPEventContext *ec)
 859 {
 860     g_return_if_fail(ec != NULL);
 861     g_return_if_fail(SP_IS_EVENT_CONTEXT(ec));
 862
 863     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->deactivate)
 864         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->deactivate(ec);
 865 }
 866
 867 /**
 868  * Calls virtual root_handler(), the main event handling function.
 869  */
 870 gint
 871 sp_event_context_root_handler(SPEventContext * event_context, GdkEvent * event)
 872 {
 873     gint ret;
 874
 875     ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event);
 876
 877     set_event_location(event_context->desktop, event);
 878
 879     return ret;
 880 }
 881
 882 /**
 883  * Calls virtual item_handler(), the item event handling function.
 884  */
 885 gint
 886 sp_event_context_item_handler(SPEventContext * event_context, SPItem * item, GdkEvent * event)
 887 {
 888     gint ret;
 889
 890     ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event);
 891
 892     if (! ret) {
 893         ret = sp_event_context_root_handler(event_context, event);
 894     } else {
 895         set_event_location(event_context->desktop, event);
 896     }
 897
 898     return ret;
 899 }
 900
 901 /**
 902  * Emits 'position_set' signal on desktop and shows coordinates on status bar.
 903  */
 904 static void set_event_location(SPDesktop *desktop, GdkEvent *event)
 905 {
 906     if (event->type != GDK_MOTION_NOTIFY) {
 907         return;
 908     }
 909
 910     Geom::Point const button_w(event->button.x, event->button.y);
 911     Geom::Point const button_dt(desktop->w2d(button_w));
 912     desktop-> setPosition (button_dt);
 913     desktop->set_coordinate_status(button_dt);
 914 }
 915
 916 //-------------------------------------------------------------------
 917 /**
 918  * Create popup menu and tell Gtk to show it.
 919  */
 920 void
 921 sp_event_root_menu_popup(SPDesktop *desktop, SPItem *item, GdkEvent *event)
 922 {
 923     GtkWidget *menu;
 924
 925     /* fixme: This is not what I want but works for now (Lauris) */
 926     if (event->type == GDK_KEY_PRESS) {
 927         item = sp_desktop_selection(desktop)->singleItem();
 928     }
 929     menu = sp_ui_context_menu(desktop, item);
 930     gtk_widget_show(menu);
 931
 932     switch (event->type) {
 933         case GDK_BUTTON_PRESS:
 934             gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, event->button.button, event->button.time);
 935             break;
 936         case GDK_KEY_PRESS:
 937             gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 0, NULL, 0, event->key.time);
 938             break;
 939         default:
 940             break;
 941     }
 942 }
 943
 944 /**
 945  * Show tool context specific modifier tip.
 946  */
 947 void
 948 sp_event_show_modifier_tip(Inkscape::MessageContext *message_context,
 949         GdkEvent *event, gchar const *ctrl_tip, gchar const *shift_tip,
 950         gchar const *alt_tip)
 951 {
 952     guint keyval = get_group0_keyval(&event->key);
 953
 954     bool ctrl = ctrl_tip && (MOD__CTRL
 955             || (keyval == GDK_Control_L)
 956             || (keyval == GDK_Control_R));
 957     bool shift = shift_tip
 958         && (MOD__SHIFT || (keyval == GDK_Shift_L) || (keyval == GDK_Shift_R));
 959     bool alt = alt_tip
 960         && (MOD__ALT
 961                 || (keyval == GDK_Alt_L)
 962                 || (keyval == GDK_Alt_R)
 963                 || (keyval == GDK_Meta_L)
 964                 || (keyval == GDK_Meta_R));
 965
 966     gchar *tip = g_strdup_printf("%s%s%s%s%s",
 967                                  ( ctrl ? ctrl_tip : "" ),
 968                                  ( ctrl && (shift || alt) ? "; " : "" ),
 969                                  ( shift ? shift_tip : "" ),
 970                                  ( (ctrl || shift) && alt ? "; " : "" ),
 971                                  ( alt ? alt_tip : "" ));
 972
 973     if (strlen(tip) > 0) {
 974         message_context->flash(Inkscape::INFORMATION_MESSAGE, tip);
 975     }
 976
 977     g_free(tip);
 978 }
 979
 980 /**
 981  * Return the keyval corresponding to the key event in group 0, i.e.,
 982  * in the main (English) layout.
 983  *
 984  * Use this instead of simply event->keyval, so that your keyboard shortcuts
 985  * work regardless of layouts (e.g., in Cyrillic).
 986  */
 987 guint
 988 get_group0_keyval(GdkEventKey *event)
 989 {
 990     guint keyval = 0;
 991     gdk_keymap_translate_keyboard_state(
 992             gdk_keymap_get_for_display(gdk_display_get_default()),
 993             event->hardware_keycode,
 994             (GdkModifierType) event->state,
 995             0   /*event->key.group*/,
 996             &keyval, NULL, NULL, NULL);
 997     return keyval;
 998 }
 999
1000 /**
1001  * Returns item at point p in desktop.
1002  *
1003  * If state includes alt key mask, cyclically selects under; honors
1004  * into_groups.
1005  */
1006 SPItem *
1007 sp_event_context_find_item (SPDesktop *desktop, Geom::Point const &p,
1008         bool select_under, bool into_groups)
1009 {
1010     SPItem *item;
1011
1012     if (select_under) {
1013         SPItem *selected_at_point =
1014             desktop->item_from_list_at_point_bottom (desktop->selection->itemList(), p);
1015         item = desktop->item_at_point(p, into_groups, selected_at_point);
1016         if (item == NULL) { // we may have reached bottom, flip over to the top
1017             item = desktop->item_at_point(p, into_groups, NULL);
1018         }
1019     } else
1020         item = desktop->item_at_point(p, into_groups, NULL);
1021
1022     return item;
1023 }
1024
1025 /**
1026  * Returns item if it is under point p in desktop, at any depth; otherwise returns NULL.
1027  *
1028  * Honors into_groups.
1029  */
1030 SPItem *
1031 sp_event_context_over_item (SPDesktop *desktop, SPItem *item, Geom::Point const &p)
1032 {
1033     GSList *temp = NULL;
1034     temp = g_slist_prepend (temp, item);
1035     SPItem *item_at_point = desktop->item_from_list_at_point_bottom (temp, p);
1036     g_slist_free (temp);
1037
1038     return item_at_point;
1039 }
1040
1041 ShapeEditor *
1042 sp_event_context_get_shape_editor (SPEventContext *ec)
1043 {
1044     if (SP_IS_NODE_CONTEXT(ec)) {
1045         return SP_NODE_CONTEXT(ec)->shape_editor;
1046     } else if (SP_IS_LPETOOL_CONTEXT(ec)) {
1047         return SP_LPETOOL_CONTEXT(ec)->shape_editor;
1048     } else {
1049         g_warning("ShapeEditor only exists in Node and Geometric Tool.");
1050         return NULL;
1051     }
1052 }
1053
1054 /**
1055  * Called when SPEventContext subclass node attribute changed.
1056  */
1057 void
1058 ec_shape_event_attr_changed(Inkscape::XML::Node */*shape_repr*/, gchar const *name,
1059                             gchar const */*old_value*/, gchar const */*new_value*/,
1060                             bool const /*is_interactive*/, gpointer const data)
1061 {
1062     if (!name
1063             || !strcmp(name, "style")
1064             || SP_ATTRIBUTE_IS_CSS(sp_attribute_lookup(name))) {
1065         // no need to regenrate knotholder if only style changed
1066         return;
1067     }
1068
1069     SPEventContext *ec = SP_EVENT_CONTEXT(data);
1070
1071     if (ec->shape_knot_holder) {
1072         delete ec->shape_knot_holder;
1073     }
1074     ec->shape_knot_holder = NULL;
1075
1076     SPDesktop *desktop = ec->desktop;
1077
1078     SPItem *item = sp_desktop_selection(desktop)->singleItem();
1079
1080     if (item) {
1081         ec->shape_knot_holder = sp_item_knot_holder(item, desktop);
1082     }
1083 }
1084
1085
1086 void
1087 event_context_print_event_info(GdkEvent *event, bool print_return) {
1088     switch (event->type) {
1089         case GDK_BUTTON_PRESS:
1090             g_print ("GDK_BUTTON_PRESS");
1091             break;
1092         case GDK_2BUTTON_PRESS:
1093             g_print ("GDK_2BUTTON_PRESS");
1094             break;
1095         case GDK_3BUTTON_PRESS:
1096             g_print ("GDK_3BUTTON_PRESS");
1097             break;
1098
1099         case GDK_MOTION_NOTIFY:
1100             g_print ("GDK_MOTION_NOTIFY");
1101             break;
1102         case GDK_ENTER_NOTIFY:
1103             g_print ("GDK_ENTER_NOTIFY");
1104             break;
1105
1106         case GDK_LEAVE_NOTIFY:
1107             g_print ("GDK_LEAVE_NOTIFY");
1108             break;
1109         case GDK_BUTTON_RELEASE:
1110             g_print ("GDK_BUTTON_RELEASE");
1111             break;
1112
1113         case GDK_KEY_PRESS:
1114             g_print ("GDK_KEY_PRESS: %d", get_group0_keyval(&event->key));
1115             break;
1116         case GDK_KEY_RELEASE:
1117             g_print ("GDK_KEY_RELEASE: %d", get_group0_keyval(&event->key));
1118             break;
1119         default:
1120             //g_print ("even type not recognized");
1121             break;
1122     }
1123
1124     if (print_return) {
1125         g_print ("\n");
1126     }
1127 }
1128
1129 /*
1130   Local Variables:
1131   mode:c++
1132   c-file-style:"stroustrup"
1133   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1134   indent-tabs-mode:nil
1135   fill-column:99
1136   End:
1137 */
1138 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :