X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fevent-context.cpp;h=9b846f2b7e51a5f54e88c6e15363e33be52dcae8;hb=07f872bd2a4fee3c346819cbaf5af6627e698499;hp=47447e6a0fa4263a6c10e3b09158156529a4f20d;hpb=3e14bbdccf812dcd7584c270e087aff3511c16fa;p=inkscape.git diff --git a/src/event-context.cpp b/src/event-context.cpp index 47447e6a0..9b846f2b7 100644 --- a/src/event-context.cpp +++ b/src/event-context.cpp @@ -27,9 +27,15 @@ # include "config.h" #endif +#include "event-context.h" + +#include #include #include #include +#include +#include +#include #include "display/sp-canvas.h" #include "xml/node-event-vector.h" @@ -37,20 +43,21 @@ #include "shortcuts.h" #include "desktop.h" #include "desktop-handles.h" +#include "sp-namedview.h" #include "selection.h" #include "file.h" #include "interface.h" #include "macros.h" #include "tools-switch.h" -#include "prefs-utils.h" +#include "preferences.h" #include "message-context.h" #include "gradient-drag.h" #include "object-edit.h" #include "attributes.h" #include "rubberband.h" #include "selcue.h" - -#include "event-context.h" +#include "node-context.h" +#include "lpe-tool-context.h" static void sp_event_context_class_init(SPEventContextClass *klass); static void sp_event_context_init(SPEventContext *event_context); @@ -68,6 +75,10 @@ static GObjectClass *parent_class; static bool selector_toggled = FALSE; static int switch_selector_to = 0; +// globals for temporary switching to dropper by 'D' +static bool dropper_toggled = FALSE; +static int switch_dropper_to = 0; + static gint xp = 0, yp = 0; // where drag started static gint tolerance = 0; static bool within_tolerance = false; @@ -130,6 +141,9 @@ sp_event_context_init(SPEventContext *event_context) event_context->_message_context = NULL; event_context->_selcue = NULL; event_context->_grdrag = NULL; + event_context->space_panning = false; + event_context->shape_editor = NULL; + event_context->_delayed_snap_event = NULL; } /** @@ -155,10 +169,12 @@ sp_event_context_dispose(GObject *object) ec->desktop = NULL; } - if (ec->prefs_repr) { - sp_repr_remove_listener_by_data(ec->prefs_repr, ec); - Inkscape::GC::release(ec->prefs_repr); - ec->prefs_repr = NULL; + if (ec->pref_observer) { + delete ec->pref_observer; + } + + if (ec->_delayed_snap_event) { + delete ec->_delayed_snap_event; } G_OBJECT_CLASS(parent_class)->dispose(object); @@ -189,7 +205,9 @@ sp_event_context_update_cursor(SPEventContext *ec) } } gdk_window_set_cursor(w->window, ec->cursor); + gdk_flush(); } + ec->desktop->waiting_cursor = false; } /** @@ -212,14 +230,15 @@ gint gobble_key_events(guint keyval, gint mask) event_next = gdk_event_get(); // while the next event is also a key notify with the same keyval and mask, - while (event_next && event_next->type == GDK_KEY_PRESS + while (event_next && (event_next->type == GDK_KEY_PRESS || event_next->type == GDK_KEY_RELEASE) && event_next->key.keyval == keyval - && (event_next->key.state & mask)) { + && (!mask || (event_next->key.state & mask))) { + if (event_next->type == GDK_KEY_PRESS) + i ++; // kill it gdk_event_free(event_next); // get next event_next = gdk_event_get(); - i ++; } // otherwise, put it back onto the queue if (event_next) gdk_event_put(event_next); @@ -272,19 +291,40 @@ sp_toggle_selector(SPDesktop *dt) } } +/** + * Toggles current tool between active tool and dropper tool. + * Subroutine of sp_event_context_private_root_handler(). + */ +static void +sp_toggle_dropper(SPDesktop *dt) +{ + if (!dt->event_context) return; + + if (tools_isactive(dt, TOOLS_DROPPER)) { + if (dropper_toggled) { + if (switch_dropper_to) tools_switch (dt, switch_dropper_to); + dropper_toggled = FALSE; + } else return; + } else { + dropper_toggled = TRUE; + switch_dropper_to = tools_active(dt); + tools_switch (dt, TOOLS_DROPPER); + } +} + /** * Calculates and keeps track of scroll acceleration. * Subroutine of sp_event_context_private_root_handler(). */ -static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration) +static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration, SPCanvas */*canvas*/) { guint32 time_diff = ((GdkEventKey *) event)->time - scroll_event_time; /* key pressed within 500ms ? (1/2 second) */ if (time_diff > 500 || event->key.keyval != scroll_keyval) { - scroll_multiply = 1; + scroll_multiply = 1; // abort acceleration } else { - scroll_multiply += acceleration; + scroll_multiply += acceleration; // continue acceleration } scroll_event_time = ((GdkEventKey *) event)->time; @@ -293,42 +333,21 @@ static gdouble accelerate_scroll(GdkEvent *event, gdouble acceleration) return scroll_multiply; } -// This is a hack that is necessary because when middle-clicking too fast, -// button_press events come for all clicks but there's button_release only -// for the first one. So after a release, we must prohibit the next grab for -// some time, or the grab will be stuck. Perhaps this is caused by some -// wrong handling of events among contexts and not by a GDK bug; -// if someone can fix this properly this would be great. -static gint dontgrab = 0; -static bool -grab_allow_again() -{ - dontgrab--; - if (dontgrab < 0) dontgrab = 0; - return FALSE; // so that it is only called once -} - /** * Main event dispatch, gets called from Gdk. */ static gint sp_event_context_private_root_handler(SPEventContext *event_context, GdkEvent *event) { - static NR::Point button_w; + static Geom::Point button_w; static unsigned int panning = 0; static unsigned int zoom_rb = 0; SPDesktop *desktop = event_context->desktop; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - tolerance = prefs_get_int_attribute_limited( - "options.dragtolerance","value", 0, 0, 100); - double const zoom_inc = prefs_get_double_attribute_limited( - "options.zoomincrement", "value", M_SQRT2, 1.01, 10); - double const acceleration = prefs_get_double_attribute_limited( - "options.scrollingacceleration", "value", 0, 0, 6); - int const key_scroll = prefs_get_int_attribute_limited( - "options.keyscroll", "value", 10, 0, 1000); - int const wheel_scroll = prefs_get_int_attribute_limited( - "options.wheelscroll", "value", 40, 0, 1000); + /// @todo REmove redundant /value in preference keys + tolerance = prefs->getIntLimited( + "/options/dragtolerance/value", 0, 0, 100); gint ret = FALSE; @@ -350,26 +369,29 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, yp = (gint) event->button.y; within_tolerance = true; - switch (event->button.button) { - case 2: + button_w = Geom::Point(event->button.x, event->button.y); - if (dontgrab) - // double-click, still not permitted to grab; - // increase the counter to guard against triple click - { - dontgrab ++; - gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL); - break; + switch (event->button.button) { + case 1: + if (event_context->space_panning) { + // When starting panning, make sure there are no snap events pending because these might disable the panning again + sp_event_context_discard_delayed_snap_event(event_context); + panning = 1; + sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate), + GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, + NULL, event->button.time-1); + ret = TRUE; } - - button_w = NR::Point(event->button.x, - event->button.y); - if (event->button.state == GDK_SHIFT_MASK) { + break; + case 2: + if (event->button.state & GDK_SHIFT_MASK) { zoom_rb = 2; } else { - panning = 2; + // When starting panning, make sure there are no snap events pending because these might disable the panning again + sp_event_context_discard_delayed_snap_event(event_context); + panning = 2; sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate), - GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, + GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, NULL, event->button.time-1); } ret = TRUE; @@ -377,11 +399,11 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case 3: if (event->button.state & GDK_SHIFT_MASK || event->button.state & GDK_CONTROL_MASK) { - button_w = NR::Point(event->button.x, - event->button.y); - panning = 3; + // When starting panning, make sure there are no snap events pending because these might disable the panning again + sp_event_context_discard_delayed_snap_event(event_context); + panning = 3; sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate), - GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, + GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK, NULL, event->button.time); ret = TRUE; } else { @@ -395,10 +417,11 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case GDK_MOTION_NOTIFY: if (panning) { if ((panning == 2 && !(event->motion.state & GDK_BUTTON2_MASK)) - || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK))) { + || (panning == 1 && !(event->motion.state & GDK_BUTTON1_MASK)) + || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK)) + ) { /* Gdk seems to lose button release for us sometimes :-( */ - panning = 0; - dontgrab = 0; + panning = 0; sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time); ret = TRUE; @@ -419,72 +442,89 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, // gobble subsequent motion events to prevent "sticking" // when scrolling is slow gobble_motion_events(panning == 2 ? - GDK_BUTTON2_MASK : GDK_BUTTON3_MASK); + GDK_BUTTON2_MASK : + (panning == 1 ? GDK_BUTTON1_MASK : GDK_BUTTON3_MASK)); - NR::Point const motion_w(event->motion.x, - event->motion.y); - NR::Point const moved_w( motion_w - button_w ); - event_context->desktop->scroll_world(moved_w); + Geom::Point const motion_w(event->motion.x, event->motion.y); + Geom::Point const moved_w( motion_w - button_w ); + event_context->desktop->scroll_world(moved_w, true); // we're still scrolling, do not redraw ret = TRUE; } } else if (zoom_rb) { - NR::Point const motion_w(event->motion.x, event->motion.y); - NR::Point const motion_dt(desktop->w2d(motion_w)); + Geom::Point const motion_w(event->motion.x, event->motion.y); + Geom::Point const motion_dt(desktop->w2d(motion_w)); if ( within_tolerance && ( abs( (gint) event->motion.x - xp ) < tolerance ) && ( abs( (gint) event->motion.y - yp ) < tolerance ) ) { break; // do not drag if we're within tolerance from origin } - - if (within_tolerance) { - Inkscape::Rubberband::get()->start(desktop, motion_dt); - } else { - Inkscape::Rubberband::get()->move(motion_dt); - } - // Once the user has moved farther than tolerance from the original location // (indicating they intend to move the object, not click), then always process the // motion notify coordinates as given (no snapping back to origin) within_tolerance = false; + + if (Inkscape::Rubberband::get(desktop)->is_started()) { + Inkscape::Rubberband::get(desktop)->move(motion_dt); + } else { + Inkscape::Rubberband::get(desktop)->start(desktop, motion_dt); + } + if (zoom_rb == 2) + gobble_motion_events(GDK_BUTTON2_MASK); } break; case GDK_BUTTON_RELEASE: + xp = yp = 0; if (within_tolerance && (panning || zoom_rb)) { - dontgrab ++; - NR::Point const event_w(event->button.x, event->button.y); - NR::Point const event_dt(desktop->w2d(event_w)); - double const zoom_power = ( (event->button.state & GDK_SHIFT_MASK) - ? -dontgrab : dontgrab ); + zoom_rb = 0; + if (panning) { + panning = 0; + sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), + event->button.time); + } + Geom::Point const event_w(event->button.x, event->button.y); + Geom::Point const event_dt(desktop->w2d(event_w)); + double const zoom_inc = prefs->getDoubleLimited("/options/zoomincrement/value", M_SQRT2, 1.01, 10); desktop->zoom_relative_keep_point(event_dt, - pow(zoom_inc, zoom_power)); - gtk_timeout_add(250, (GtkFunction) grab_allow_again, NULL); + (event->button.state & GDK_SHIFT_MASK) ? 1/zoom_inc : zoom_inc); desktop->updateNow(); - } - if (panning == event->button.button) { + ret = TRUE; + } else if (panning == event->button.button) { panning = 0; sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time); + + // in slow complex drawings, some of the motion events are lost; + // to make up for this, we scroll it once again to the button-up event coordinates + // (i.e. canvas will always get scrolled all the way to the mouse release point, + // even if few intermediate steps were visible) + Geom::Point const motion_w(event->button.x, event->button.y); + Geom::Point const moved_w( motion_w - button_w ); + event_context->desktop->scroll_world(moved_w); desktop->updateNow(); ret = TRUE; } else if (zoom_rb == event->button.button) { zoom_rb = 0; - NR::Maybe const b = Inkscape::Rubberband::get()->getRectangle(); - if (b != NR::Nothing() && !within_tolerance) { - desktop->set_display_area(b.assume(), 10); + Geom::OptRect const b = Inkscape::Rubberband::get(desktop)->getRectangle(); + Inkscape::Rubberband::get(desktop)->stop(); + if (b && !within_tolerance) { + desktop->set_display_area(*b, 10); } - Inkscape::Rubberband::get()->stop(); + ret = TRUE; } - xp = yp = 0; break; case GDK_KEY_PRESS: - switch (get_group0_keyval(&event->key)) { + { + double const acceleration = prefs->getDoubleLimited("/options/scrollingacceleration/value", 0, 0, 6); + int const key_scroll = prefs->getIntLimited("/options/keyscroll/value", 10, 0, 1000); + + switch (get_group0_keyval(&event->key)) { // GDK insists on stealing these keys (F1 for no idea what, tab for cycling widgets // in the editing window). So we resteal them back and run our regular shortcut // invoker on them. unsigned int shortcut; - case GDK_Tab: - case GDK_ISO_Left_Tab: + case GDK_Tab: + case GDK_ISO_Left_Tab: case GDK_F1: shortcut = get_group0_keyval(&event->key); if (event->key.state & GDK_SHIFT_MASK) @@ -496,6 +536,23 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, ret = sp_shortcut_invoke(shortcut, desktop); break; + case GDK_D: + case GDK_d: + if (!MOD__SHIFT && !MOD__CTRL && !MOD__ALT) { + sp_toggle_dropper(desktop); + ret = TRUE; + } + break; + case GDK_Q: + case GDK_q: + if (desktop->quick_zoomed()) { + ret = TRUE; + } + if (!MOD__SHIFT && !MOD__CTRL && !MOD__ALT) { + desktop->zoom_quick(true); + ret = TRUE; + } + break; case GDK_W: case GDK_w: case GDK_F4: @@ -509,7 +566,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case GDK_KP_Left: case GDK_KP_4: if (MOD__CTRL_ONLY) { - int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration)); + int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop))); gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK); event_context->desktop->scroll_world(i, 0); @@ -520,7 +577,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case GDK_KP_Up: case GDK_KP_8: if (MOD__CTRL_ONLY) { - int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration)); + int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop))); gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK); event_context->desktop->scroll_world(0, i); @@ -531,7 +588,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case GDK_KP_Right: case GDK_KP_6: if (MOD__CTRL_ONLY) { - int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration)); + int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop))); gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK); event_context->desktop->scroll_world(-i, 0); @@ -542,7 +599,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, case GDK_KP_Down: case GDK_KP_2: if (MOD__CTRL_ONLY) { - int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration)); + int i = (int) floor(key_scroll * accelerate_scroll(event, acceleration, sp_desktop_canvas(desktop))); gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK); event_context->desktop->scroll_world(0, -i); @@ -556,8 +613,14 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, } break; case GDK_space: - sp_toggle_selector(desktop); - ret= TRUE; + if (prefs->getBool("/options/spacepans/value")) { + event_context->space_panning = true; + event_context->_message_context->set(Inkscape::INFORMATION_MESSAGE, _("Space+mouse drag to pan canvas")); + ret= TRUE; + } else { + sp_toggle_selector(desktop); + ret= TRUE; + } break; case GDK_z: case GDK_Z: @@ -568,9 +631,41 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, break; default: break; + } + } + break; + case GDK_KEY_RELEASE: + switch (get_group0_keyval(&event->key)) { + case GDK_space: + if (event_context->space_panning) { + event_context->space_panning = false; + event_context->_message_context->clear(); + if (panning == 1) { + panning = 0; + sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), + event->key.time); + desktop->updateNow(); + } + ret= TRUE; + } + break; + case GDK_Q: + case GDK_q: + if (desktop->quick_zoomed()) { + desktop->zoom_quick(false); + ret = TRUE; + } + break; + default: + break; } break; case GDK_SCROLL: + { + bool ctrl = (event->scroll.state & GDK_CONTROL_MASK); + bool wheelzooms = prefs->getBool("/options/wheelzooms/value"); + int const wheel_scroll = prefs->getIntLimited("/options/wheelscroll/value", 40, 0, 1000); + /* shift + wheel, pan left--right */ if (event->scroll.state & GDK_SHIFT_MASK) { switch (event->scroll.direction) { @@ -585,8 +680,9 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, } /* ctrl + wheel, zoom in--out */ - } else if (event->scroll.state & GDK_CONTROL_MASK) { + } else if ((ctrl && !wheelzooms) || (!ctrl && wheelzooms)) { double rel_zoom; + double const zoom_inc = prefs->getDoubleLimited("/options/zoomincrement/value", M_SQRT2, 1.01, 10); switch (event->scroll.direction) { case GDK_SCROLL_UP: rel_zoom = zoom_inc; @@ -599,7 +695,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, break; } if (rel_zoom != 0.0) { - NR::Point const scroll_dt = desktop->point(); + Geom::Point const scroll_dt = desktop->point(); desktop->zoom_relative_keep_point(scroll_dt, rel_zoom); } @@ -621,6 +717,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, } } break; + } default: break; } @@ -655,34 +752,30 @@ sp_event_context_private_item_handler(SPEventContext *ec, SPItem *item, GdkEvent } /** - * Gets called when attribute changes value. + * @brief An observer that relays pref changes to the derived classes */ -static void -sp_ec_repr_attr_changed(Inkscape::XML::Node *prefs_repr, gchar const *key, gchar const *oldval, gchar const *newval, - bool is_interactive, gpointer data) -{ - SPEventContext *ec; - - ec = SP_EVENT_CONTEXT(data); - - if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) { - ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, newval); +class ToolPrefObserver : public Inkscape::Preferences::Observer { +public: + ToolPrefObserver(Glib::ustring const &path, SPEventContext *ec) : + Inkscape::Preferences::Observer(path), + _ec(ec) {} + virtual void notify(Inkscape::Preferences::Entry const &val) + { + if (((SPEventContextClass *) G_OBJECT_GET_CLASS(_ec))->set) { + ((SPEventContextClass *) G_OBJECT_GET_CLASS(_ec))->set(_ec, + const_cast(&val)); + } } -} - -Inkscape::XML::NodeEventVector sp_ec_event_vector = { - NULL, /* Child added */ - NULL, /* Child removed */ - sp_ec_repr_attr_changed, - NULL, /* Content changed */ - NULL /* Order changed */ +private: + SPEventContext * const _ec; }; /** * Creates new SPEventContext object and calls its virtual setup() function. + * @todo This is bogus. pref_path should be a private property of the inheriting objects. */ SPEventContext * -sp_event_context_new(GType type, SPDesktop *desktop, Inkscape::XML::Node *prefs_repr, unsigned int key) +sp_event_context_new(GType type, SPDesktop *desktop, gchar const *pref_path, unsigned int key) { g_return_val_if_fail(g_type_is_a(type, SP_TYPE_EVENT_CONTEXT), NULL); g_return_val_if_fail(desktop != NULL, NULL); @@ -692,10 +785,13 @@ sp_event_context_new(GType type, SPDesktop *desktop, Inkscape::XML::Node *prefs_ ec->desktop = desktop; ec->_message_context = new Inkscape::MessageContext(desktop->messageStack()); ec->key = key; - ec->prefs_repr = prefs_repr; - if (ec->prefs_repr) { - Inkscape::GC::anchor(ec->prefs_repr); - sp_repr_add_listener(ec->prefs_repr, &sp_ec_event_vector, ec); + ec->pref_observer = NULL; + + if (pref_path) { + ec->pref_observer = new ToolPrefObserver(pref_path, ec); + + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->addObserver(*(ec->pref_observer)); } if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->setup) @@ -765,10 +861,11 @@ sp_event_context_read(SPEventContext *ec, gchar const *key) g_return_if_fail(SP_IS_EVENT_CONTEXT(ec)); g_return_if_fail(key != NULL); - if (ec->prefs_repr) { - gchar const *val = ec->prefs_repr->attribute(key); - if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) - ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, key, val); + if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set) { + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + Inkscape::Preferences::Entry val = prefs->getEntry( + ec->pref_observer->observed_path + '/' + key ); + ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->set(ec, &val); } } @@ -781,6 +878,11 @@ sp_event_context_activate(SPEventContext *ec) g_return_if_fail(ec != NULL); g_return_if_fail(SP_IS_EVENT_CONTEXT(ec)); + // Make sure no delayed snapping events are carried over after switching contexts + // (this is only an additional safety measure against sloppy coding, because each + // context should take care of this by itself. + sp_event_context_discard_delayed_snap_event(ec); + if (((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate) ((SPEventContextClass *) G_OBJECT_GET_CLASS(ec))->activate(ec); } @@ -804,13 +906,36 @@ sp_event_context_deactivate(SPEventContext *ec) gint sp_event_context_root_handler(SPEventContext * event_context, GdkEvent * event) { - gint ret; - - ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event); + switch (event->type) { + case GDK_MOTION_NOTIFY: + sp_event_context_snap_delay_handler(event_context, NULL, NULL, (GdkEventMotion *)event, DelayedSnapEvent::EVENTCONTEXT_ROOT_HANDLER); + break; + case GDK_BUTTON_RELEASE: + if (event_context->_delayed_snap_event) { + // If we have any pending snapping action, then invoke it now + sp_event_context_snap_watchdog_callback(event_context->_delayed_snap_event); + } + break; + case GDK_BUTTON_PRESS: + case GDK_2BUTTON_PRESS: + case GDK_3BUTTON_PRESS: + // Snapping will be on hold if we're moving the mouse at high speeds. When starting + // drawing a new shape we really should snap though. + event_context->desktop->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(false); + break; + default: + break; + } - set_event_location(event_context->desktop, event); + return sp_event_context_virtual_root_handler(event_context, event); +} - return ret; +gint +sp_event_context_virtual_root_handler(SPEventContext * event_context, GdkEvent * event) +{ + gint ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->root_handler(event_context, event); + set_event_location(event_context->desktop, event); + return ret; } /** @@ -819,17 +944,43 @@ sp_event_context_root_handler(SPEventContext * event_context, GdkEvent * event) gint sp_event_context_item_handler(SPEventContext * event_context, SPItem * item, GdkEvent * event) { - gint ret; + switch (event->type) { + case GDK_MOTION_NOTIFY: + sp_event_context_snap_delay_handler(event_context, item, NULL, (GdkEventMotion *)event, DelayedSnapEvent::EVENTCONTEXT_ITEM_HANDLER); + break; + case GDK_BUTTON_RELEASE: + if (event_context->_delayed_snap_event) { + // If we have any pending snapping action, then invoke it now + sp_event_context_snap_watchdog_callback(event_context->_delayed_snap_event); + } + break; + /*case GDK_BUTTON_PRESS: + case GDK_2BUTTON_PRESS: + case GDK_3BUTTON_PRESS: + // Snapping will be on hold if we're moving the mouse at high speeds. When starting + // drawing a new shape we really should snap though. + event_context->desktop->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(false); + break; + */ + default: + break; + } + + return sp_event_context_virtual_item_handler(event_context, item, event); +} - ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event); +gint +sp_event_context_virtual_item_handler(SPEventContext * event_context, SPItem * item, GdkEvent * event) +{ + gint ret = ((SPEventContextClass *) G_OBJECT_GET_CLASS(event_context))->item_handler(event_context, item, event); - if (! ret) { - ret = sp_event_context_root_handler(event_context, event); - } else { - set_event_location(event_context->desktop, event); - } + if (! ret) { + ret = sp_event_context_virtual_root_handler(event_context, event); + } else { + set_event_location(event_context->desktop, event); + } - return ret; + return ret; } /** @@ -841,9 +992,9 @@ static void set_event_location(SPDesktop *desktop, GdkEvent *event) return; } - NR::Point const button_w(event->button.x, event->button.y); - NR::Point const button_dt(desktop->w2d(button_w)); - desktop-> setPosition (button_dt); + Geom::Point const button_w(event->button.x, event->button.y); + Geom::Point const button_dt(desktop->w2d(button_w)); + desktop->setPosition(button_dt); desktop->set_coordinate_status(button_dt); } @@ -938,7 +1089,7 @@ get_group0_keyval(GdkEventKey *event) * into_groups. */ SPItem * -sp_event_context_find_item (SPDesktop *desktop, NR::Point const p, +sp_event_context_find_item (SPDesktop *desktop, Geom::Point const &p, bool select_under, bool into_groups) { SPItem *item; @@ -962,7 +1113,7 @@ sp_event_context_find_item (SPDesktop *desktop, NR::Point const p, * Honors into_groups. */ SPItem * -sp_event_context_over_item (SPDesktop *desktop, SPItem *item, NR::Point const p) +sp_event_context_over_item (SPDesktop *desktop, SPItem *item, Geom::Point const &p) { GSList *temp = NULL; temp = g_slist_prepend (temp, item); @@ -972,37 +1123,178 @@ sp_event_context_over_item (SPDesktop *desktop, SPItem *item, NR::Point const p) return item_at_point; } -/** - * Called when SPEventContext subclass node attribute changed. - */ +ShapeEditor * +sp_event_context_get_shape_editor (SPEventContext *ec) +{ + return ec->shape_editor; +} + void -ec_shape_event_attr_changed(Inkscape::XML::Node *shape_repr, gchar const *name, - gchar const *old_value, gchar const *new_value, - bool const is_interactive, gpointer const data) -{ - if (!name - || !strcmp(name, "style") - || SP_ATTRIBUTE_IS_CSS(sp_attribute_lookup(name))) { - // no need to regenrate knotholder if only style changed - return; - } +event_context_print_event_info(GdkEvent *event, bool print_return) { + switch (event->type) { + case GDK_BUTTON_PRESS: + g_print ("GDK_BUTTON_PRESS"); + break; + case GDK_2BUTTON_PRESS: + g_print ("GDK_2BUTTON_PRESS"); + break; + case GDK_3BUTTON_PRESS: + g_print ("GDK_3BUTTON_PRESS"); + break; - SPEventContext *ec = SP_EVENT_CONTEXT(data); + case GDK_MOTION_NOTIFY: + g_print ("GDK_MOTION_NOTIFY"); + break; + case GDK_ENTER_NOTIFY: + g_print ("GDK_ENTER_NOTIFY"); + break; - if (ec->shape_knot_holder) { - sp_knot_holder_destroy(ec->shape_knot_holder); - } - ec->shape_knot_holder = NULL; + case GDK_LEAVE_NOTIFY: + g_print ("GDK_LEAVE_NOTIFY"); + break; + case GDK_BUTTON_RELEASE: + g_print ("GDK_BUTTON_RELEASE"); + break; - SPDesktop *desktop = ec->desktop; + case GDK_KEY_PRESS: + g_print ("GDK_KEY_PRESS: %d", get_group0_keyval(&event->key)); + break; + case GDK_KEY_RELEASE: + g_print ("GDK_KEY_RELEASE: %d", get_group0_keyval(&event->key)); + break; + default: + //g_print ("even type not recognized"); + break; + } - SPItem *item = sp_desktop_selection(desktop)->singleItem(); + if (print_return) { + g_print ("\n"); + } +} - if (item) { - ec->shape_knot_holder = sp_item_knot_holder(item, desktop); +void sp_event_context_snap_delay_handler(SPEventContext *ec, SPItem* const item, SPKnot* const knot, GdkEventMotion *event, DelayedSnapEvent::DelayedSnapEventOrigin origin) +{ + static guint32 prev_time; + static boost::optional prev_pos; + + // Snapping occurs when dragging with the left mouse button down, or when hovering e.g. in the pen tool with left mouse button up + bool const c1 = event->state & GDK_BUTTON2_MASK; // We shouldn't hold back any events when other mouse buttons have been + bool const c2 = event->state & GDK_BUTTON3_MASK; // pressed, e.g. when scrolling with the middle mouse button; if we do then + // Inkscape will get stuck in an unresponsive state + bool const c3 = tools_isactive(ec->desktop, TOOLS_CALLIGRAPHIC); + // The snap delay will repeat the last motion event, which will lead to + // erroneous points in the calligraphy context. And because we don't snap + // in this context, we might just as well disable the snap delay all together + + if (c1 || c2 || c3) { + // Make sure that we don't send any pending snap events to a context if we know in advance + // that we're not going to snap any way (e.g. while scrolling with middle mouse button) + // Any motion event might affect the state of the context, leading to unexpected behavior + sp_event_context_discard_delayed_snap_event(ec); + } else if (ec->desktop && ec->desktop->namedview->snap_manager.snapprefs.getSnapEnabledGlobally()) { + // Snap when speed drops below e.g. 0.02 px/msec, or when no motion events have occurred for some period. + // i.e. snap when we're at stand still. A speed threshold enforces snapping for tablets, which might never + // be fully at stand still and might keep spitting out motion events. + ec->desktop->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(true); // put snapping on hold + + Geom::Point event_pos(event->x, event->y); + guint32 event_t = gdk_event_get_time ( (GdkEvent *) event ); + + if (prev_pos) { + Geom::Coord dist = Geom::L2(event_pos - *prev_pos); + guint32 delta_t = event_t - prev_time; + gdouble speed = delta_t > 0 ? dist/delta_t : 1000; + //std::cout << "Mouse speed = " << speed << " px/msec " << std::endl; + if (speed > 0.02) { // Jitter threshold, might be needed for tablets + // We're moving fast, so postpone any snapping until the next GDK_MOTION_NOTIFY event. We + // will keep on postponing the snapping as long as the speed is high. + // We must snap at some point in time though, so set a watchdog timer at some time from + // now, just in case there's no future motion event that drops under the speed limit (when + // stopping abruptly) + delete ec->_delayed_snap_event; + ec->_delayed_snap_event = new DelayedSnapEvent(ec, item, knot, event, origin); // watchdog is reset, i.e. pushed forward in time + // If the watchdog expires before a new motion event is received, we will snap (as explained + // above). This means however that when the timer is too short, we will always snap and that the + // speed threshold is ineffective. In the extreme case the delay is set to zero, and snapping will + // be immediate, as it used to be in the old days ;-). + } else { // Speed is very low, so we're virtually at stand still + // But if we're really standing still, then we should snap now. We could use some low-pass filtering, + // otherwise snapping occurs for each jitter movement. For this filtering we'll leave the watchdog to expire, + // snap, and set a new watchdog again. + if (ec->_delayed_snap_event == NULL) { // no watchdog has been set + // it might have already expired, so we'll set a new one; the snapping frequency will be limited by this + ec->_delayed_snap_event = new DelayedSnapEvent(ec, item, knot, event, origin); + } // else: watchdog has been set before and we'll wait for it to expire + } + } else { + // This is the first GDK_MOTION_NOTIFY event, so postpone snapping and set the watchdog + g_assert(ec->_delayed_snap_event == NULL); + ec->_delayed_snap_event = new DelayedSnapEvent(ec, item, knot, event, origin); + } + + prev_pos = event_pos; + prev_time = event_t; } } +gboolean sp_event_context_snap_watchdog_callback(gpointer data) +{ + // Snap NOW! For this the "postponed" flag will be reset and the last motion event will be repeated + DelayedSnapEvent *dse = reinterpret_cast(data); + + if (dse == NULL) { + // This might occur when this method is called directly, i.e. not through the timer + // E.g. on GDK_BUTTON_RELEASE in sp_event_context_root_handler() + return FALSE; + } + + SPEventContext *ec = dse->getEventContext(); + if (ec == NULL || ec->desktop == NULL) { + return false; + } + + SPDesktop *dt = ec->desktop; + dt->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(false); + + switch (dse->getOrigin()) { + case DelayedSnapEvent::EVENTCONTEXT_ROOT_HANDLER: + sp_event_context_virtual_root_handler(ec, dse->getEvent()); + break; + case DelayedSnapEvent::EVENTCONTEXT_ITEM_HANDLER: + { + SPItem* item = NULL; + item = dse->getItem(); + if (item && SP_IS_ITEM(item)) { + sp_event_context_virtual_item_handler(ec, item, dse->getEvent()); + } + } + break; + case DelayedSnapEvent::KNOT_HANDLER: + { + SPKnot* knot = dse->getKnot(); + if (knot && SP_IS_KNOT(knot)) { + sp_knot_handler_request_position(dse->getEvent(), knot); + } + } + break; + default: + g_warning("Origin of snap-delay event has not been defined!;"); + break; + } + + ec->_delayed_snap_event = NULL; + delete dse; + + return FALSE; //Kills the timer and stops it from executing this callback over and over again. +} + +void sp_event_context_discard_delayed_snap_event(SPEventContext *ec) +{ + delete ec->_delayed_snap_event; + ec->_delayed_snap_event = NULL; +} + + /* Local Variables: