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 <gdk/gdkkeysyms.h>
  31 #include <gtk/gtkmain.h>
  32 #include <gtk/gtkmenu.h>
  33
  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"
  52
  53 #include "event-context.h"
  54
  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);
  58
  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);
  62
  63 static void set_event_location(SPDesktop * desktop, GdkEvent * event);
  64
  65 static GObjectClass *parent_class;
  66
  67 // globals for temporary switching to selector by space
  68 static bool selector_toggled = FALSE;
  69 static int switch_selector_to = 0;
  70
  71 static gint xp = 0, yp = 0; // where drag started
  72 static gint tolerance = 0;
  73 static bool within_tolerance = false;
  74
  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;
  79
  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 }
 102
 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;
 110
 111     object_class = (GObjectClass *) klass;
 112
 113     parent_class = (GObjectClass*)g_type_class_peek_parent(klass);
 114
 115     object_class->dispose = sp_event_context_dispose;
 116
 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 }
 121
 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 }
 134
 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;
 142
 143     ec = SP_EVENT_CONTEXT(object);
 144
 145     if (ec->_message_context) {
 146         delete ec->_message_context;
 147     }
 148
 149     if (ec->cursor != NULL) {
 150         gdk_cursor_unref(ec->cursor);
 151         ec->cursor = NULL;
 152     }
 153
 154     if (ec->desktop) {
 155         ec->desktop = NULL;
 156     }
 157
 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     }
 163
 164     G_OBJECT_CLASS(parent_class)->dispose(object);
 165 }
 166
 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();
 176
 177          if (ec->cursor)
 178              gdk_cursor_unref(ec->cursor);
 179
 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 }
 189
 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 }
 199
 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;
 207
 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);
 221
 222     return i;
 223 }
 224
 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;
 232
 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);
 245
 246     return i;
 247 }
 248
 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;
 257
 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 }
 269
 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;
 277
 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     }
 284
 285     scroll_event_time = ((GdkEventKey *) event)->time;
 286     scroll_keyval = event->key.keyval;
 287
 288     return scroll_multiply;
 289 }
 290
 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 }
 305
 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;
 314
 315     SPDesktop *desktop = event_context->desktop;
 316
 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);
 327
 328     gint ret = FALSE;
 329
 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:
 342
 343             // save drag origin
 344             xp = (gint) event->button.x;
 345             yp = (gint) event->button.y;
 346             within_tolerance = true;
 347
 348             switch (event->button.button) {
 349                 case 2:
 350
 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                     }
 359
 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;
 413
 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);
 418
 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));
 428
 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                 }
 434
 435                 if (within_tolerance) {
 436                     Inkscape::Rubberband::get()->start(desktop, motion_dt);
 437                 } else {
 438                     Inkscape::Rubberband::get()->move(motion_dt);
 439                 }
 440
 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;
 488
 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                 }
 592
 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                 }
 611
 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     }
 633
 634     return ret;
 635 }
 636
 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;
 647
 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     }
 659
 660     return ret;
 661 }
 662
 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;
 671
 672     ec = SP_EVENT_CONTEXT(data);
 673
 674     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) {
 675         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, newval);
 676     }
 677 }
 678
 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 };
 686
 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);
 695
 696     SPEventContext *const ec = (SPEventContext*)g_object_new(type, NULL);
 697
 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     }
 706
 707     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup)
 708         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup(ec);
 709
 710     return ec;
 711 }
 712
 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));
 721
 722     ec->enableSelectionCue(false);
 723
 724     if (ec->next) {
 725         g_warning("Finishing event context with active link\n");
 726     }
 727
 728     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish)
 729         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->finish(ec);
 730 }
 731
 732 //-------------------------------member functions
 733
 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 }
 747
 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 }
 763
 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);
 773
 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 }
 780
 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));
 789
 790     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
 791         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
 792 }
 793
 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));
 802
 803     if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate)
 804         ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec);
 805 }
 806
 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;
 814
 815     ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event);
 816
 817     set_event_location(event_context->desktop, event);
 818
 819     return ret;
 820 }
 821
 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;
 829
 830     ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event);
 831
 832     if (! ret) {
 833         ret = sp_event_context_root_handler(event_context, event);
 834     } else {
 835         set_event_location(event_context->desktop, event);
 836     }
 837
 838     return ret;
 839 }
 840
 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     }
 849
 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 }
 855
 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;
 864
 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);
 871
 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 }
 883
 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);
 893
 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));
 905
 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 : "" ));
 912
 913     if (strlen(tip) > 0) {
 914         message_context->flash(Inkscape::INFORMATION_MESSAGE, tip);
 915     }
 916
 917     g_free(tip);
 918 }
 919
 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 }
 939
 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;
 951
 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);
 961
 962     return item;
 963 }
 964
 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);
 977
 978     return item_at_point;
 979 }
 980
 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     }
 995
 996     SPEventContext *ec = SP_EVENT_CONTEXT(data);
 997
 998     if (ec->shape_knot_holder) {
 999         sp_knot_holder_destroy(ec->shape_knot_holder);
1000     }
1001     ec->shape_knot_holder = NULL;
1002
1003     SPDesktop *desktop = ec->desktop;
1004
1005     SPItem *item = sp_desktop_selection(desktop)->singleItem();
1006
1007     if (item) {
1008         ec->shape_knot_holder = sp_item_knot_holder(item, desktop);
1009     }
1010 }
1011
1012
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 :