X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fevent-context.cpp;h=7039c3b130c050ef37d87de12f61e4ae4f4c0991;hb=c647aff4da60b280974a1d5eceda738b5a0ab389;hp=42557abdca71a990a428f04d82a82817eda3ddd2;hpb=dbe32b890d08ee7a085dcee01234f24e32db5ee1;p=inkscape.git diff --git a/src/event-context.cpp b/src/event-context.cpp index 42557abdc..7039c3b13 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" @@ -42,15 +48,15 @@ #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 +74,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 +140,8 @@ 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; } /** @@ -155,10 +167,8 @@ 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; } G_OBJECT_CLASS(parent_class)->dispose(object); @@ -189,7 +199,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 +224,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 +285,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 +327,29 @@ 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; - - 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); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + /// @todo REmove redundant /value in preference keys + tolerance = prefs->getIntLimited( + "/options/dragtolerance/value", 0, 0, 100); + double const zoom_inc = prefs->getDoubleLimited( + "/options/zoomincrement/value", M_SQRT2, 1.01, 10); + double const acceleration = prefs->getDoubleLimited( + "/options/scrollingacceleration/value", 0, 0, 6); + int const key_scroll = prefs->getIntLimited( + "/options/keyscroll/value", 10, 0, 1000); + int const wheel_scroll = prefs->getIntLimited( + "/options/wheelscroll/value", 40, 0, 1000); gint ret = FALSE; @@ -350,26 +371,25 @@ 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) { + 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); + break; + case 2: if (event->button.state == GDK_SHIFT_MASK) { zoom_rb = 2; } else { 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 +397,9 @@ 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; 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 +413,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; sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time); ret = TRUE; @@ -419,69 +438,85 @@ 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)); 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)) { + // 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_F1: - /* Grab it away from Gtk */ shortcut = get_group0_keyval(&event->key); if (event->key.state & GDK_SHIFT_MASK) shortcut |= SP_SHORTCUT_SHIFT_MASK; @@ -492,20 +527,21 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, ret = sp_shortcut_invoke(shortcut, desktop); break; - case GDK_Tab: // disable tab/shift-tab which cycle widget focus - case GDK_ISO_Left_Tab: // they will get different functions - if (!(MOD__CTRL_ONLY || (MOD__CTRL && MOD__SHIFT))) { + 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; - } else { - /* Grab it away from Gtk */ - shortcut = get_group0_keyval(&event->key); - if (event->key.state & GDK_SHIFT_MASK) - shortcut |= SP_SHORTCUT_SHIFT_MASK; - if (event->key.state & GDK_CONTROL_MASK) - shortcut |= SP_SHORTCUT_CONTROL_MASK; - if (event->key.state & GDK_MOD1_MASK) - shortcut |= SP_SHORTCUT_ALT_MASK; - ret = sp_shortcut_invoke(shortcut, desktop); } break; case GDK_W: @@ -521,7 +557,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); @@ -532,7 +568,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); @@ -543,7 +579,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); @@ -554,7 +590,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); @@ -568,8 +604,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: @@ -582,7 +624,36 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, 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"); /* shift + wheel, pan left--right */ if (event->scroll.state & GDK_SHIFT_MASK) { switch (event->scroll.direction) { @@ -597,7 +668,7 @@ 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; switch (event->scroll.direction) { case GDK_SCROLL_UP: @@ -611,7 +682,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); } @@ -633,6 +704,7 @@ static gint sp_event_context_private_root_handler(SPEventContext *event_context, } } break; + } default: break; } @@ -667,34 +739,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); @@ -704,10 +772,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) @@ -777,10 +848,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); } } @@ -853,8 +925,8 @@ 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)); + 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); } @@ -950,7 +1022,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; @@ -974,7 +1046,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); @@ -984,38 +1056,55 @@ sp_event_context_over_item (SPDesktop *desktop, SPItem *item, NR::Point const p) return item_at_point; } -/** - * Called when SPEventContext subclass node attribute changed. - */ -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) +ShapeEditor * +sp_event_context_get_shape_editor (SPEventContext *ec) { - if (!name - || !strcmp(name, "style") - || SP_ATTRIBUTE_IS_CSS(sp_attribute_lookup(name))) { - // no need to regenrate knotholder if only style changed - return; - } + return ec->shape_editor; +} - SPEventContext *ec = SP_EVENT_CONTEXT(data); +void +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; - if (ec->shape_knot_holder) { - sp_knot_holder_destroy(ec->shape_knot_holder); - } - ec->shape_knot_holder = NULL; + case GDK_MOTION_NOTIFY: + g_print ("GDK_MOTION_NOTIFY"); + break; + case GDK_ENTER_NOTIFY: + g_print ("GDK_ENTER_NOTIFY"); + break; - SPDesktop *desktop = ec->desktop; + case GDK_LEAVE_NOTIFY: + g_print ("GDK_LEAVE_NOTIFY"); + break; + case GDK_BUTTON_RELEASE: + g_print ("GDK_BUTTON_RELEASE"); + break; - SPItem *item = sp_desktop_selection(desktop)->singleItem(); + 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; + } - if (item) { - ec->shape_knot_holder = sp_item_knot_holder(item, desktop); + if (print_return) { + g_print ("\n"); } } - /* Local Variables: mode:c++