X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fcanvas%2Fcanvas.cc;h=242f8ecbfd20acadf161e7df36b3b121fd6b7ec4;hb=a0cb2f95f0706179f88dc0175769705ddeded389;hp=30ef25e944353def853b1fccb47e8eeb62aac358;hpb=006ba7cd3640c65a4bc5cd5d2bfc22ffc47d1673;p=ardour.git diff --git a/libs/canvas/canvas.cc b/libs/canvas/canvas.cc index 30ef25e944..242f8ecbfd 100644 --- a/libs/canvas/canvas.cc +++ b/libs/canvas/canvas.cc @@ -22,6 +22,7 @@ * @brief Implementation of the main canvas classes. */ +#include #include #include #include @@ -31,6 +32,8 @@ #include "canvas/canvas.h" #include "canvas/debug.h" +#include "canvas/line.h" +#include "canvas/scroll_group.h" using namespace std; using namespace ArdourCanvas; @@ -38,8 +41,6 @@ using namespace ArdourCanvas; /** Construct a new Canvas */ Canvas::Canvas () : _root (this) - , _scroll_offset_x (0) - , _scroll_offset_y (0) { set_epoch (); } @@ -47,12 +48,37 @@ Canvas::Canvas () void Canvas::scroll_to (Coord x, Coord y) { - _scroll_offset_x = x; - _scroll_offset_y = y; + /* We do things this way because we do not want to recurse through + the canvas for every scroll. In the presence of large MIDI + tracks this means traversing item lists that include + thousands of items (notes). + + This design limits us to moving only those items (groups, typically) + that should move in certain ways as we scroll. In other terms, it + becomes O(1) rather than O(N). + */ + + for (list::iterator i = scrollers.begin(); i != scrollers.end(); ++i) { + (*i)->scroll_to (Duple (x, y)); + } + + pick_current_item (0); // no current mouse position +} + +void +Canvas::add_scroller (ScrollGroup& i) +{ + scrollers.push_back (&i); +} + +void +Canvas::zoomed () +{ + pick_current_item (0); // no current mouse position } /** Render an area of the canvas. - * @param area Area in canvas coordinates. + * @param area Area in window coordinates. * @param context Cairo context to render to. */ void @@ -60,7 +86,7 @@ Canvas::render (Rect const & area, Cairo::RefPtr const & context { #ifdef CANVAS_DEBUG if (DEBUG_ENABLED(PBD::DEBUG::CanvasRender)) { - cerr << "RENDER: " << area << endl; + cerr << this << " RENDER: " << area << endl; //cerr << "CANVAS @ " << this << endl; //dump (cerr); //cerr << "-------------------------\n"; @@ -77,12 +103,26 @@ Canvas::render (Rect const & area, Cairo::RefPtr const & context boost::optional draw = root_bbox->intersection (area); if (draw) { + /* there's a common area between the root and the requested area, so render it. */ _root.render (*draw, context); + +#ifdef CANVAS_DEBUG + if (getenv ("CANVAS_HARLEQUIN_DEBUGGING")) { + // This transparently colors the rect being rendered, after it has been drawn. + double r = (random() % 65536) /65536.0; + double g = (random() % 65536) /65536.0; + double b = (random() % 65536) /65536.0; + context->rectangle (draw->x0, draw->y0, draw->x1 - draw->x0, draw->y1 - draw->y0); + context->set_source_rgba (r, g, b, 0.25); + context->fill (); + } +#endif } + } ostream& @@ -131,7 +171,9 @@ Canvas::item_shown_or_hidden (Item* item) { boost::optional bbox = item->bounding_box (); if (bbox) { - queue_draw_item_area (item, bbox.get ()); + if (item->item_to_window (*bbox).intersection (visible_area ())) { + queue_draw_item_area (item, bbox.get ()); + } } } @@ -144,7 +186,9 @@ Canvas::item_visual_property_changed (Item* item) { boost::optional bbox = item->bounding_box (); if (bbox) { - queue_draw_item_area (item, bbox.get ()); + if (item->item_to_window (*bbox).intersection (visible_area ())) { + queue_draw_item_area (item, bbox.get ()); + } } } @@ -156,41 +200,98 @@ Canvas::item_visual_property_changed (Item* item) void Canvas::item_changed (Item* item, boost::optional pre_change_bounding_box) { + + Rect window_bbox = visible_area (); + if (pre_change_bounding_box) { - /* request a redraw of the item's old bounding box */ - queue_draw_item_area (item, pre_change_bounding_box.get ()); + + if (item->item_to_window (*pre_change_bounding_box).intersection (window_bbox)) { + /* request a redraw of the item's old bounding box */ + queue_draw_item_area (item, pre_change_bounding_box.get ()); + } } boost::optional post_change_bounding_box = item->bounding_box (); if (post_change_bounding_box) { - /* request a redraw of the item's new bounding box */ - queue_draw_item_area (item, post_change_bounding_box.get ()); + + if (item->item_to_window (*post_change_bounding_box).intersection (window_bbox)) { + /* request a redraw of the item's new bounding box */ + queue_draw_item_area (item, post_change_bounding_box.get ()); + } } } Duple Canvas::window_to_canvas (Duple const & d) const { - return d.translate (Duple (_scroll_offset_x, _scroll_offset_y)); + /* Find the scroll group that covers d (a window coordinate). Scroll groups are only allowed + * as children of the root group, so we just scan its first level + * children and see what we can find. + */ + + std::list const& root_children (_root.items()); + ScrollGroup* sg = 0; + + /* if the coordinates are negative, clamp to zero and find the item + * that covers that "edge" position. + */ + + Duple in_window (d); + + if (in_window.x < 0) { + in_window.x = 0; + } + if (in_window.y < 0) { + in_window.y = 0; + } + + for (std::list::const_iterator i = root_children.begin(); i != root_children.end(); ++i) { + if (((sg = dynamic_cast(*i)) != 0) && sg->covers_window (in_window)) { + break; + } + } + + if (sg) { + return d.translate (sg->scroll_offset()); + } + + return d; } Duple -Canvas::canvas_to_window (Duple const & d) const +Canvas::canvas_to_window (Duple const & d, bool rounded) const { - return d.translate (Duple (-_scroll_offset_x, -_scroll_offset_y)); -} + /* Find the scroll group that covers d (a canvas coordinate). Scroll groups are only allowed + * as children of the root group, so we just scan its first level + * children and see what we can find. + */ -Rect -Canvas::window_to_canvas (Rect const & r) const -{ - return r.translate (Duple (_scroll_offset_x, _scroll_offset_y)); -} + std::list const& root_children (_root.items()); + ScrollGroup* sg = 0; + Duple wd; -Rect -Canvas::canvas_to_window (Rect const & r) const -{ - return r.translate (Duple (-_scroll_offset_x, -_scroll_offset_y)); -} + for (std::list::const_iterator i = root_children.begin(); i != root_children.end(); ++i) { + if (((sg = dynamic_cast(*i)) != 0) && sg->covers_canvas (d)) { + break; + } + } + + + if (sg) { + wd = d.translate (-sg->scroll_offset()); + } else { + wd = d; + } + + /* Note that this intentionally almost always returns integer coordinates */ + + if (rounded) { + wd.x = round (wd.x); + wd.y = round (wd.y); + } + + return wd; +} /** Called when an item has moved. * @param item Item that has moved. @@ -227,57 +328,28 @@ Canvas::item_moved (Item* item, boost::optional pre_change_parent_bounding void Canvas::queue_draw_item_area (Item* item, Rect area) { - ArdourCanvas::Rect canvas_area = item->item_to_canvas (area); - // cerr << "CANVAS " << this << " for " << item->whatami() << ' ' << item->name << " invalidate " << area << " TRANSLATE AS " << canvas_area << endl; - request_redraw (canvas_area); + request_redraw (item->item_to_window (area)); } /** Construct a GtkCanvas */ GtkCanvas::GtkCanvas () : _current_item (0) + , _new_current_item (0) , _grabbed_item (0) + , _focused_item (0) { /* these are the events we want to know about */ - add_events (Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::POINTER_MOTION_MASK); -} - -/** Handler for pointer motion events on the canvas. - * @param ev GDK event. - * @return true if the motion event was handled, otherwise false. - */ -bool -GtkCanvas::motion_notify_handler (GdkEventMotion* ev) -{ - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas motion @ %1, %2\n", ev->x, ev->y)); - - if (_grabbed_item) { - /* if we have a grabbed item, it gets just the motion event, - since no enter/leave events can have happened. - */ - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("%1 %2 (%3) was grabbed, send MOTION event there\n", - _grabbed_item, _grabbed_item->whatami(), _grabbed_item->name)); - return _grabbed_item->Event (reinterpret_cast (ev)); - } - - Duple point (ev->x, ev->y); - - enter_leave_items (point, ev->state); - - /* Now deliver the motion event. It may seem a little inefficient - to recompute the items under the event, but the enter notify/leave - events may have deleted canvas items so it is important to - recompute the list in deliver_event. - */ - return deliver_event (point, reinterpret_cast (ev)); + add_events (Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::POINTER_MOTION_MASK | + Gdk::SCROLL_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK); } void -GtkCanvas::enter_leave_items (int state) +GtkCanvas::pick_current_item (int state) { int x; int y; - /* this version of ::enter_leave_items() is called after an item is + /* this version of ::pick_current_item() is called after an item is * added or removed, so we have no coordinates to work from as is the * case with a motion event. Find out where the mouse is and use that. */ @@ -288,155 +360,285 @@ GtkCanvas::enter_leave_items (int state) return; } - enter_leave_items (window_to_canvas (Duple (x, y)), state); + pick_current_item (Duple (x, y), state); } - + +/** Given @param point (a position in window coordinates) + * and mouse state @param state, check to see if _current_item + * (which will be used to deliver events) should change. + */ void -GtkCanvas::enter_leave_items (Duple const & point, int state) +GtkCanvas::pick_current_item (Duple const & point, int state) { - /* find the items at the given position */ + /* we do not enter/leave items during a drag/grab */ + + if (_grabbed_item) { + return; + } + + /* find the items at the given window position */ vector items; _root.add_items_at_point (point, items); + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("%1 covers %2 items\n", point, items.size())); + +#ifndef NDEBUG + if (DEBUG_ENABLED(PBD::DEBUG::CanvasEnterLeave)) { + for (vector::const_iterator it = items.begin(); it != items.end(); ++it) { +#ifdef CANVAS_DEBUG + std::cerr << "\tItem " << (*it)->whatami() << '/' << (*it)->name << std::endl; +#else + std::cerr << "\tItem " << (*it)->whatami() << std::endl; +#endif + } + } +#endif + + /* put all items at point that are event-sensitive and visible and NOT + groups into within_items. Note that items is sorted from bottom to + top, but we're going to reverse that for within_items so that its + first item is the upper-most item that can be chosen as _current_item. + */ + + vector::const_iterator i; + list within_items; + + for (i = items.begin(); i != items.end(); ++i) { + + Item const * possible_item = *i; + + /* We ignore invisible items, containers and items that ignore events */ + + if (!possible_item->visible() || possible_item->ignore_events() || dynamic_cast(possible_item) != 0) { + continue; + } + within_items.push_front (possible_item); + } + + if (within_items.empty()) { + + /* no items at point, just send leave event below */ + _new_current_item = 0; + + } else { + + if (within_items.front() == _current_item) { + /* uppermost item at point is already _current_item */ + return; + } + + _new_current_item = const_cast (within_items.front()); + } + + if (_new_current_item != _current_item) { + deliver_enter_leave (point, state); + } +} + +/** Deliver a series of enter & leave events based on the pointer position being at window + * coordinate @param point, and pointer @param state (modifier keys, etc) + */ +void +GtkCanvas::deliver_enter_leave (Duple const & point, int state) +{ + /* setup enter & leave event structures */ + GdkEventCrossing enter_event; enter_event.type = GDK_ENTER_NOTIFY; enter_event.window = get_window()->gobj(); enter_event.send_event = 0; enter_event.subwindow = 0; enter_event.mode = GDK_CROSSING_NORMAL; - enter_event.detail = GDK_NOTIFY_NONLINEAR; enter_event.focus = FALSE; enter_event.state = state; - enter_event.x = point.x; - enter_event.y = point.y; + + /* Events delivered to canvas items are expected to be in canvas + * coordinates but @param point is in window coordinates. + */ + + Duple c = window_to_canvas (point); + enter_event.x = c.x; + enter_event.y = c.y; GdkEventCrossing leave_event = enter_event; leave_event.type = GDK_LEAVE_NOTIFY; - leave_event.detail = GDK_NOTIFY_ANCESTOR; - leave_event.subwindow = 0; - if (items.empty()) { + Item* i; + GdkNotifyType enter_detail; + GdkNotifyType leave_detail; + vector items_to_leave_virtual; + vector items_to_enter_virtual; + + if (_new_current_item == 0) { + + leave_detail = GDK_NOTIFY_UNKNOWN; + if (_current_item) { - /* leave event */ - // cerr << "E/L: left item " << _current_item->whatami() << '/' << _current_item->name << " for ... nada" << endl; - _current_item->Event (reinterpret_cast (&leave_event)); - _current_item = 0; + + /* no current item, so also send virtual leave events to the + * entire heirarchy for the current item + */ + + for (i = _current_item->parent(); i ; i = i->parent()) { + items_to_leave_virtual.push_back (i); + } } - return; - } - /* items is sorted from top to bottom, so reverse through it from bottom - * to top to find the lowest, first event-sensitive item and notify that - * we have entered it - */ - - // cerr << "E/L: " << items.size() << " to check at " << point << endl; -#ifdef CANVAS_DEBUG - // for (vector::const_reverse_iterator i = items.rbegin(); i != items.rend(); ++i) { - // cerr << '\t' << (*i)->whatami() << ' ' << (*i)->name << " ignore ? " << (*i)->ignore_events() << " current ? " << (_current_item == (*i)) << endl; - // } -#endif - // cerr << "------------\n"; + } else if (_current_item == 0) { - for (vector::const_reverse_iterator i = items.rbegin(); i != items.rend(); ++i) { + enter_detail = GDK_NOTIFY_UNKNOWN; - Item const * new_item = *i; -#ifdef CANVAS_DEBUG - // cerr << "\tE/L check out " << new_item->whatami() << ' ' << new_item->name << " ignore ? " << new_item->ignore_events() << " current ? " << (_current_item == new_item) << endl; -#endif - if (new_item->ignore_events()) { - // cerr << "continue1\n"; - continue; + /* no current item, so also send virtual enter events to the + * entire heirarchy for the new item + */ + + for (i = _new_current_item->parent(); i ; i = i->parent()) { + items_to_enter_virtual.push_back (i); } - if (_current_item == new_item) { - // cerr << "continue2\n"; - continue; + } else if (_current_item->is_descendant_of (*_new_current_item)) { + + /* move from descendant to ancestor (X: "_current_item is an + * inferior ("child") of _new_current_item") + * + * Deliver "virtual" leave notifications to all items in the + * heirarchy between current and new_current. + */ + + for (i = _current_item->parent(); i && i != _new_current_item; i = i->parent()) { + items_to_leave_virtual.push_back (i); } - if (_current_item) { - /* leave event */ - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("Leave %1 %2\n", _current_item->whatami(), _current_item->name)); - _current_item->Event (reinterpret_cast (&leave_event)); - queue_draw (); + enter_detail = GDK_NOTIFY_INFERIOR; + leave_detail = GDK_NOTIFY_ANCESTOR; + + } else if (_new_current_item->is_descendant_of (*_current_item)) { + /* move from ancestor to descendant (X: "_new_current_item is + * an inferior ("child") of _current_item") + * + * Deliver "virtual" enter notifications to all items in the + * heirarchy between current and new_current. + */ + + for (i = _new_current_item->parent(); i && i != _current_item; i = i->parent()) { + items_to_enter_virtual.push_back (i); } - if (new_item && _current_item != new_item) { - /* enter event */ - _current_item = new_item; - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("Enter %1 %2\n", _current_item->whatami(), _current_item->name)); - _current_item->Event (reinterpret_cast (&enter_event)); - queue_draw (); - break; + enter_detail = GDK_NOTIFY_ANCESTOR; + leave_detail = GDK_NOTIFY_INFERIOR; + + } else { + + Item const * common_ancestor = _current_item->closest_ancestor_with (*_new_current_item); + + /* deliver virtual leave events to everything between _current + * and common_ancestor. + */ + + for (i = _current_item->parent(); i && i != common_ancestor; i = i->parent()) { + items_to_leave_virtual.push_back (i); + } + + /* deliver virtual enter events to everything between + * _new_current and common_ancestor. + */ + + for (i = _new_current_item->parent(); i && i != common_ancestor; i = i->parent()) { + items_to_enter_virtual.push_back (i); + } + + enter_detail = GDK_NOTIFY_NONLINEAR; + leave_detail = GDK_NOTIFY_NONLINEAR; + } + + + if (_current_item && !_current_item->ignore_events ()) { + leave_event.detail = leave_detail; + _current_item->Event ((GdkEvent*)&leave_event); + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("LEAVE %1/%2\n", _current_item->whatami(), _current_item->name)); + } + + leave_event.detail = GDK_NOTIFY_VIRTUAL; + enter_event.detail = GDK_NOTIFY_VIRTUAL; + + for (vector::iterator it = items_to_leave_virtual.begin(); it != items_to_leave_virtual.end(); ++it) { + if (!(*it)->ignore_events()) { + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("leave %1/%2\n", (*it)->whatami(), (*it)->name)); + (*it)->Event ((GdkEvent*)&leave_event); + } + } + + for (vector::iterator it = items_to_enter_virtual.begin(); it != items_to_enter_virtual.end(); ++it) { + if (!(*it)->ignore_events()) { + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("enter %1/%2\n", (*it)->whatami(), (*it)->name)); + (*it)->Event ((GdkEvent*)&enter_event); + // std::cerr << "enter " << (*it)->whatami() << '/' << (*it)->name << std::endl; } + } - // cerr << "Loop around again\n"; + if (_new_current_item && !_new_current_item->ignore_events()) { + enter_event.detail = enter_detail; + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("ENTER %1/%2\n", _new_current_item->whatami(), _new_current_item->name)); + _new_current_item->Event ((GdkEvent*)&enter_event); } + + _current_item = _new_current_item; } + /** Deliver an event to the appropriate item; either the grabbed item, or * one of the items underneath the event. * @param point Position that the event has occurred at, in canvas coordinates. * @param event The event. */ bool -GtkCanvas::deliver_event (Duple point, GdkEvent* event) +GtkCanvas::deliver_event (GdkEvent* event) { /* Point in in canvas coordinate space */ + const Item* event_item; + if (_grabbed_item) { /* we have a grabbed item, so everything gets sent there */ DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("%1 %2 (%3) was grabbed, send event there\n", _grabbed_item, _grabbed_item->whatami(), _grabbed_item->name)); - return _grabbed_item->Event (event); + event_item = _grabbed_item; + } else { + event_item = _current_item; } - /* find the items that exist at the event's position */ - vector items; - _root.add_items_at_point (point, items); + if (!event_item) { + return false; + } - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("%1 possible items to deliver event to\n", items.size())); + /* run through the items from child to parent, until one claims the event */ - /* run through the items under the event, from top to bottom, until one claims the event */ - vector::const_reverse_iterator i = items.rbegin (); - while (i != items.rend()) { + Item* item = const_cast (event_item); + + while (item) { - if ((*i)->ignore_events ()) { - DEBUG_TRACE ( - PBD::DEBUG::CanvasEvents, - string_compose ("canvas event ignored by %1 %2\n", (*i)->whatami(), (*i)->name.empty() ? "[unknown]" : (*i)->name) - ); - ++i; - continue; - } - - if ((*i)->Event (event)) { + Item* parent = item->parent (); + + if (!item->ignore_events () && + item->Event (event)) { /* this item has just handled the event */ DEBUG_TRACE ( PBD::DEBUG::CanvasEvents, - string_compose ("canvas event handled by %1 %2\n", (*i)->whatami(), (*i)->name.empty() ? "[unknown]" : (*i)->name) + string_compose ("canvas event handled by %1 %2\n", item->whatami(), item->name.empty() ? "[unknown]" : item->name) ); return true; } - DEBUG_TRACE ( - PBD::DEBUG::CanvasEvents, - string_compose ("canvas event left unhandled by %1 %2\n", (*i)->whatami(), (*i)->name.empty() ? "[unknown]" : (*i)->name) - ); - - ++i; - } + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas event %3 left unhandled by %1 %2\n", item->whatami(), item->name.empty() ? "[unknown]" : item->name, event_type_string (event->type))); - /* debugging */ - if (PBD::debug_bits & PBD::DEBUG::CanvasEvents) { - while (i != items.rend()) { - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas event not seen by %1\n", (*i)->name.empty() ? "[unknown]" : (*i)->name)); - ++i; + if ((item = parent) == 0) { + break; } + } - + return false; } @@ -451,16 +653,29 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) queue_draw_item_area (item, bounding_box.get ()); } - if (_current_item == item) { - _current_item = 0; - queue_draw (); + if (_new_current_item == item) { + _new_current_item = 0; } if (_grabbed_item == item) { _grabbed_item = 0; } - enter_leave_items (0); // no mouse state + if (_focused_item == item) { + _focused_item = 0; + } + + ScrollGroup* sg = dynamic_cast(item); + if (sg) { + scrollers.remove (sg); + } + + if (_current_item == item) { + /* no need to send a leave event to this item, since it is going away + */ + _current_item = 0; + pick_current_item (0); // no mouse state + } } @@ -471,10 +686,8 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) bool GtkCanvas::on_expose_event (GdkEventExpose* ev) { - Cairo::RefPtr c = get_window()->create_cairo_context (); - - render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), c); - + Cairo::RefPtr cairo_context = get_window()->create_cairo_context (); + render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), cairo_context); return true; } @@ -490,6 +703,32 @@ GtkCanvas::context () return w->create_cairo_context (); } +/** Handler for GDK scroll events. + * @param ev Event. + * @return true if the event was handled. + */ +bool +GtkCanvas::on_scroll_event (GdkEventScroll* ev) +{ + /* translate event coordinates from window to canvas */ + + GdkEvent copy = *((GdkEvent*)ev); + Duple winpos = Duple (ev->x, ev->y); + Duple where = window_to_canvas (winpos); + + pick_current_item (winpos, ev->state); + + copy.button.x = where.x; + copy.button.y = where.y; + + /* Coordinates in the event will be canvas coordinates, correctly adjusted + for scroll if this GtkCanvas is in a GtkCanvasViewport. + */ + + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas scroll @ %1, %2 => %3\n", ev->x, ev->y, where)); + return deliver_event (reinterpret_cast(©)); +} + /** Handler for GDK button press events. * @param ev Event. * @return true if the event was handled. @@ -499,14 +738,21 @@ GtkCanvas::on_button_press_event (GdkEventButton* ev) { /* translate event coordinates from window to canvas */ - Duple where = window_to_canvas (Duple (ev->x, ev->y)); - + GdkEvent copy = *((GdkEvent*)ev); + Duple winpos = Duple (ev->x, ev->y); + Duple where = window_to_canvas (winpos); + + pick_current_item (winpos, ev->state); + + copy.button.x = where.x; + copy.button.y = where.y; + /* Coordinates in the event will be canvas coordinates, correctly adjusted for scroll if this GtkCanvas is in a GtkCanvasViewport. */ DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button press @ %1, %2 => %3\n", ev->x, ev->y, where)); - return deliver_event (where, reinterpret_cast(ev)); + return deliver_event (reinterpret_cast(©)); } /** Handler for GDK button release events. @@ -518,14 +764,43 @@ GtkCanvas::on_button_release_event (GdkEventButton* ev) { /* translate event coordinates from window to canvas */ - Duple where = window_to_canvas (Duple (ev->x, ev->y)); + GdkEvent copy = *((GdkEvent*)ev); + Duple winpos = Duple (ev->x, ev->y); + Duple where = window_to_canvas (winpos); + + pick_current_item (winpos, ev->state); + + copy.button.x = where.x; + copy.button.y = where.y; /* Coordinates in the event will be canvas coordinates, correctly adjusted for scroll if this GtkCanvas is in a GtkCanvasViewport. */ DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button release @ %1, %2 => %3\n", ev->x, ev->y, where)); - return deliver_event (where, reinterpret_cast(ev)); + return deliver_event (reinterpret_cast(©)); +} + +bool +GtkCanvas::get_mouse_position (Duple& winpos) const +{ + int x; + int y; + Gdk::ModifierType mask; + Glib::RefPtr self = Glib::RefPtr::cast_const (get_window ()); + + if (!self) { + std::cerr << " no self window\n"; + winpos = Duple (0, 0); + return false; + } + + Glib::RefPtr win = self->get_pointer (x, y, mask); + + winpos.x = x; + winpos.y = y; + + return true; } /** Handler for GDK motion events. @@ -538,26 +813,64 @@ GtkCanvas::on_motion_notify_event (GdkEventMotion* ev) /* translate event coordinates from window to canvas */ GdkEvent copy = *((GdkEvent*)ev); - Duple where = window_to_canvas (Duple (ev->x, ev->y)); + Duple point (ev->x, ev->y); + Duple where = window_to_canvas (point); copy.motion.x = where.x; copy.motion.y = where.y; - /* Coordinates in the event will be canvas coordinates, correctly adjusted - for scroll if this GtkCanvas is in a GtkCanvasViewport. + /* Coordinates in "copy" will be canvas coordinates, + */ + + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas motion @ %1, %2 canvas @ %3, %4\n", ev->x, ev->y, copy.motion.x, copy.motion.y)); + + MouseMotion (point); /* EMIT SIGNAL */ + + pick_current_item (point, ev->state); + + /* Now deliver the motion event. It may seem a little inefficient + to recompute the items under the event, but the enter notify/leave + events may have deleted canvas items so it is important to + recompute the list in deliver_event. */ - return motion_notify_handler ((GdkEventMotion*) ©); + + return deliver_event (reinterpret_cast (©)); +} + +bool +GtkCanvas::on_enter_notify_event (GdkEventCrossing* ev) +{ + pick_current_item (Duple (ev->x, ev->y), ev->state); + return true; +} + +bool +GtkCanvas::on_leave_notify_event (GdkEventCrossing* ev) +{ + _new_current_item = 0; + deliver_enter_leave (Duple (ev->x, ev->y), ev->state); + return true; } /** Called to request a redraw of our canvas. - * @param area Area to redraw, in canvas coordinates. + * @param area Area to redraw, in window coordinates. */ void GtkCanvas::request_redraw (Rect const & request) { - Rect area = canvas_to_window (request); - // cerr << this << " Invalidate " << request << " TRANSLATE AS " << area << endl; - queue_draw_area (floor (area.x0), floor (area.y0), ceil (area.x1) - floor (area.x0), ceil (area.y1) - floor (area.y0)); + Rect real_area; + + Coord const w = width (); + Coord const h = height (); + + /* clamp area requested to actual visible window */ + + real_area.x0 = max (0.0, min (w, request.x0)); + real_area.x1 = max (0.0, min (w, request.x1)); + real_area.y0 = max (0.0, min (h, request.y0)); + real_area.y1 = max (0.0, min (h, request.y1)); + + queue_draw_area (real_area.x0, real_area.y0, real_area.width(), real_area.height()); } /** Called to request that we try to get a particular size for ourselves. @@ -591,6 +904,7 @@ GtkCanvas::grab (Item* item) _grabbed_item = item; } + /** `Ungrab' any item that was previously grabbed */ void GtkCanvas::ungrab () @@ -599,13 +913,41 @@ GtkCanvas::ungrab () _grabbed_item = 0; } -/** @return The visible area of the canvas, in canvas coordinates */ +/** Set keyboard focus on an item, so that all keyboard events are sent to that item until the focus + * moves elsewhere. + * @param item Item to grab. + */ +void +GtkCanvas::focus (Item* item) +{ + _focused_item = item; +} + +void +GtkCanvas::unfocus (Item* item) +{ + if (item == _focused_item) { + _focused_item = 0; + } +} + +/** @return The visible area of the canvas, in window coordinates */ Rect GtkCanvas::visible_area () const { - Distance const xo = _scroll_offset_x; - Distance const yo = _scroll_offset_y; - return Rect (xo, yo, xo + get_allocation().get_width (), yo + get_allocation().get_height ()); + return Rect (0, 0, get_allocation().get_width (), get_allocation().get_height ()); +} + +Coord +GtkCanvas::width() const +{ + return get_allocation().get_width(); +} + +Coord +GtkCanvas::height() const +{ + return get_allocation().get_height(); } /** Create a GtkCanvaSViewport.