X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fcanvas%2Fcanvas.cc;h=be0f25d7a24f1afed057e85dbc10ba947e4a35fd;hb=c4c7598adbc9e5eca5fe04a23bb7e88fc0989f34;hp=7fa3f982367d2cb183418090e6b5977fe2b853b5;hpb=a1a3f6c8265264227ce19f731bf1863aff229a94;p=ardour.git diff --git a/libs/canvas/canvas.cc b/libs/canvas/canvas.cc index 7fa3f98236..be0f25d7a2 100644 --- a/libs/canvas/canvas.cc +++ b/libs/canvas/canvas.cc @@ -26,22 +26,27 @@ #include #include #include +#include #include "pbd/compose.h" #include "pbd/stacktrace.h" #include "canvas/canvas.h" +#include "canvas/colors.h" #include "canvas/debug.h" #include "canvas/line.h" +#include "canvas/scroll_group.h" +#include "canvas/utils.h" using namespace std; using namespace ArdourCanvas; +uint32_t Canvas::tooltip_timeout_msecs = 750; + /** Construct a new Canvas */ Canvas::Canvas () : _root (this) - , _scroll_offset_x (0) - , _scroll_offset_y (0) + , _bg_color (rgba_to_color (0, 1.0, 0.0, 1.0)) { set_epoch (); } @@ -49,12 +54,29 @@ 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 () { @@ -62,7 +84,7 @@ Canvas::zoomed () } /** 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 @@ -94,11 +116,17 @@ Canvas::render (Rect const & area, Cairo::RefPtr const & context _root.render (*draw, context); - // This outlines the rect being rendered, after it has been drawn. - // context->rectangle (draw->x0, draw->y0, draw->x1 - draw->x0, draw->y1 - draw->y0); - // context->set_source_rgba (1.0, 0, 0, 1.0); - // context->stroke (); - +#if defined CANVAS_DEBUG && !PLATFORM_WINDOWS + 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 } } @@ -149,7 +177,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 ()); + } } } @@ -162,7 +192,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 ()); + } } } @@ -174,57 +206,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. + */ -Duple -Canvas::canvas_to_window (Duple const & d) const -{ - Duple wd = d.translate (Duple (-_scroll_offset_x, -_scroll_offset_y)); + std::list const& root_children (_root.items()); + ScrollGroup* sg = 0; - /* Note that this intentionally always returns integer coordinates */ + /* if the coordinates are negative, clamp to zero and find the item + * that covers that "edge" position. + */ - wd.x = round (wd.x); - wd.y = round (wd.y); + Duple in_window (d); - return wd; -} + if (in_window.x < 0) { + in_window.x = 0; + } + if (in_window.y < 0) { + in_window.y = 0; + } -Rect -Canvas::window_to_canvas (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_window (in_window)) { + break; + } + } + + if (sg) { + return d.translate (sg->scroll_offset()); + } + + return d; } -Rect -Canvas::canvas_to_window (Rect const & r) const +Duple +Canvas::canvas_to_window (Duple const & d, bool rounded) const { - Rect wr = r.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. + */ - /* Note that this intentionally always returns integer coordinates */ + std::list const& root_children (_root.items()); + ScrollGroup* sg = 0; + Duple wd; - wr.x0 = round (wr.x0); - wr.x1 = round (wr.x1); - wr.y0 = round (wr.y0); - wr.y1 = round (wr.y1); + 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; + } + } + - return wr; -} + 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. @@ -261,9 +334,33 @@ 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 << " window = " << canvas_to_window (canvas_area) << std::endl; - request_redraw (canvas_area); + request_redraw (item->item_to_window (area)); +} + +void +Canvas::set_tooltip_timeout (uint32_t msecs) +{ + tooltip_timeout_msecs = msecs; +} + +void +Canvas::set_background_color (Color c) +{ + _bg_color = c; + + boost::optional r = _root.bounding_box(); + + if (r) { + request_redraw (_root.item_to_window (r.get())); + } +} + +void +GtkCanvas::re_enter () +{ + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, "re-enter canvas by request\n"); + _current_item = 0; + pick_current_item (0); } /** Construct a GtkCanvas */ @@ -272,10 +369,13 @@ GtkCanvas::GtkCanvas () , _new_current_item (0) , _grabbed_item (0) , _focused_item (0) + , current_tooltip_item (0) + , tooltip_window (0) { /* these are the events we want to know about */ add_events (Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::POINTER_MOTION_MASK | - Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK); + Gdk::SCROLL_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK | + Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK); } void @@ -295,9 +395,13 @@ GtkCanvas::pick_current_item (int state) return; } - pick_current_item (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::pick_current_item (Duple const & point, int state) { @@ -307,11 +411,25 @@ GtkCanvas::pick_current_item (Duple const & point, int state) return; } - /* find the items at the given position */ + /* 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 << " ignore events ? " << (*it)->ignore_events() << " vis ? " << (*it)->visible() << std::endl; +#else + std::cerr << "\tItem " << (*it)->whatami() << '/' << " ignore events ? " << (*it)->ignore_events() << " vis ? " << (*it)->visible() << 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 @@ -323,51 +441,76 @@ GtkCanvas::pick_current_item (Duple const & point, int state) for (i = items.begin(); i != items.end(); ++i) { - Item const * new_item = *i; + Item const * possible_item = *i; - /* We ignore invisible items, groups and items that ignore events */ + /* We ignore invisible items, containers and items that ignore events */ - if (!new_item->visible() || new_item->ignore_events() || dynamic_cast(new_item) != 0) { + if (!possible_item->visible() || possible_item->ignore_events() || dynamic_cast(possible_item) != 0) { continue; } - - within_items.push_front (new_item); + within_items.push_front (possible_item); } + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("after filtering insensitive + containers, we have %1 items\n", within_items.size())); + 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 */ + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("CURRENT ITEM %1/%2\n", _new_current_item->whatami(), _current_item->name)); return; } - + _new_current_item = const_cast (within_items.front()); } if (_new_current_item != _current_item) { deliver_enter_leave (point, state); } + + if (_current_item) { + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("CURRENT ITEM %1/%2\n", _new_current_item->whatami(), _current_item->name)); + } else { + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, "--- no current item\n"); + } + } +/** 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 */ + Glib::RefPtr win = get_window(); + + if (!win) { + return; + } + GdkEventCrossing enter_event; enter_event.type = GDK_ENTER_NOTIFY; - enter_event.window = get_window()->gobj(); + enter_event.window = win->gobj(); enter_event.send_event = 0; enter_event.subwindow = 0; enter_event.mode = GDK_CROSSING_NORMAL; 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; @@ -414,7 +557,6 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) * 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); } @@ -422,7 +564,6 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) 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") @@ -466,7 +607,7 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) if (_current_item && !_current_item->ignore_events ()) { leave_event.detail = leave_detail; _current_item->Event ((GdkEvent*)&leave_event); - // std::cerr << "LEAVE " << _current_item->whatami() << '/' << _current_item->name << std::endl; + DEBUG_TRACE (PBD::DEBUG::CanvasEnterLeave, string_compose ("LEAVE %1/%2\n", _current_item->whatami(), _current_item->name)); } leave_event.detail = GDK_NOTIFY_VIRTUAL; @@ -474,13 +615,14 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) 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); - // std::cerr << "leave " << (*it)->whatami() << '/' << (*it)->name << std::endl; } } 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; } @@ -488,8 +630,9 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) 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)); + start_tooltip_timeout (_new_current_item); _new_current_item->Event ((GdkEvent*)&enter_event); - // std::cerr << "ENTER " << _new_current_item->whatami() << '/' << _new_current_item->name << std::endl; } _current_item = _new_current_item; @@ -506,20 +649,24 @@ 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; } - if (!_current_item) { + if (!event_item) { return false; } /* run through the items from child to parent, until one claims the event */ - Item* item = const_cast (_current_item); + Item* item = const_cast (event_item); while (item) { @@ -536,7 +683,7 @@ GtkCanvas::deliver_event (GdkEvent* event) return true; } - DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas event left unhandled by %1 %2\n", item->whatami(), item->name.empty() ? "[unknown]" : item->name)); + 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))); if ((item = parent) == 0) { break; @@ -558,17 +705,10 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) queue_draw_item_area (item, bounding_box.get ()); } - /* no need to send a leave event to this item, since it is going away - */ - if (_new_current_item == item) { _new_current_item = 0; } - if (_current_item == item) { - _current_item = 0; - } - if (_grabbed_item == item) { _grabbed_item = 0; } @@ -577,10 +717,37 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) _focused_item = 0; } - pick_current_item (0); // no mouse state + if (current_tooltip_item) { + current_tooltip_item = 0; + stop_tooltip_timeout (); + } + + 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 + } } +void +GtkCanvas::on_size_allocate (Gtk::Allocation& a) +{ + EventBox::on_size_allocate (a); +#ifdef USE_CAIRO_IMAGE_SURFACE + /* allocate an image surface as large as the canvas itself */ + + canvas_image.clear (); + canvas_image = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, a.get_width(), a.get_height()); +#endif +} + /** Handler for GDK expose events. * @param ev Event. * @return true if the event was handled. @@ -588,24 +755,86 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) bool GtkCanvas::on_expose_event (GdkEventExpose* ev) { - Cairo::RefPtr cairo_context = get_window()->create_cairo_context (); - Rect area (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height); +#ifdef USE_CAIRO_IMAGE_SURFACE + if (!canvas_image) { + canvas_image = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, get_width(), get_height()); + } + Cairo::RefPtr draw_context = Cairo::Context::create (canvas_image); + Cairo::RefPtr window_context = get_window()->create_cairo_context (); +#else + Cairo::RefPtr draw_context = get_window()->create_cairo_context (); +#endif - render (area, cairo_context); + /* draw background color */ + + draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height); + draw_context->clip_preserve (); + set_source_rgba (draw_context, _bg_color); + draw_context->fill (); + + /* render canvas */ + + render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), draw_context); + +#ifdef USE_CAIRO_IMAGE_SURFACE + /* now blit our private surface back to the GDK one */ + + window_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height); + window_context->clip (); + window_context->set_source (canvas_image, 0, 0); + window_context->set_operator (Cairo::OPERATOR_SOURCE); + window_context->paint (); +#endif return true; } -/** @return Our Cairo context, or 0 if we don't have one */ -Cairo::RefPtr -GtkCanvas::context () +/** Handler for GDK scroll events. + * @param ev Event. + * @return true if the event was handled. + */ +bool +GtkCanvas::on_scroll_event (GdkEventScroll* ev) { - Glib::RefPtr w = get_window (); - if (!w) { - return Cairo::RefPtr (); - } + /* 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. + */ - return w->create_cairo_context (); + 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 key press events. + * @param ev Event. + * @return true if the event was handled. + */ +bool +GtkCanvas::on_key_press_event (GdkEventKey* ev) +{ + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, "canvas key press\n"); + return deliver_event (reinterpret_cast(ev)); +} + +/** Handler for GDK key release events. + * @param ev Event. + * @return true if the event was handled. + */ +bool +GtkCanvas::on_key_release_event (GdkEventKey* ev) +{ + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, "canvas key release\n"); + return deliver_event (reinterpret_cast(ev)); } /** Handler for GDK button press events. @@ -618,7 +847,10 @@ GtkCanvas::on_button_press_event (GdkEventButton* ev) /* translate event coordinates from window to canvas */ GdkEvent copy = *((GdkEvent*)ev); - Duple where = window_to_canvas (Duple (ev->x, ev->y)); + 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; @@ -627,7 +859,6 @@ GtkCanvas::on_button_press_event (GdkEventButton* ev) for scroll if this GtkCanvas is in a GtkCanvasViewport. */ - pick_current_item (where, ev->state); DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button press @ %1, %2 => %3\n", ev->x, ev->y, where)); return deliver_event (reinterpret_cast(©)); } @@ -642,9 +873,10 @@ GtkCanvas::on_button_release_event (GdkEventButton* ev) /* translate event coordinates from window to canvas */ GdkEvent copy = *((GdkEvent*)ev); - Duple where = window_to_canvas (Duple (ev->x, ev->y)); + Duple winpos = Duple (ev->x, ev->y); + Duple where = window_to_canvas (winpos); - pick_current_item (where, ev->state); + pick_current_item (winpos, ev->state); copy.button.x = where.x; copy.button.y = where.y; @@ -653,11 +885,32 @@ GtkCanvas::on_button_release_event (GdkEventButton* ev) for scroll if this GtkCanvas is in a GtkCanvasViewport. */ - pick_current_item (where, ev->state); DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button release @ %1, %2 => %3\n", ev->x, ev->y, where)); 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. * @param ev Event. * @return true if the event was handled. @@ -665,6 +918,8 @@ GtkCanvas::on_button_release_event (GdkEventButton* ev) bool GtkCanvas::on_motion_notify_event (GdkEventMotion* ev) { + hide_tooltip (); + /* translate event coordinates from window to canvas */ GdkEvent copy = *((GdkEvent*)ev); @@ -677,18 +932,11 @@ GtkCanvas::on_motion_notify_event (GdkEventMotion* ev) /* Coordinates in "copy" will be canvas coordinates, */ - // DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas motion @ %1, %2\n", ev->x, ev->y)); + 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)); - 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 (©)); - } + MouseMotion (point); /* EMIT SIGNAL */ - pick_current_item (where, ev->state); + 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 @@ -702,33 +950,53 @@ GtkCanvas::on_motion_notify_event (GdkEventMotion* ev) bool GtkCanvas::on_enter_notify_event (GdkEventCrossing* ev) { - Duple where = window_to_canvas (Duple (ev->x, ev->y)); - pick_current_item (where, ev->state); + pick_current_item (Duple (ev->x, ev->y), ev->state); return true; } bool GtkCanvas::on_leave_notify_event (GdkEventCrossing* ev) { + switch (ev->detail) { + case GDK_NOTIFY_ANCESTOR: + case GDK_NOTIFY_UNKNOWN: + case GDK_NOTIFY_VIRTUAL: + case GDK_NOTIFY_NONLINEAR: + case GDK_NOTIFY_NONLINEAR_VIRTUAL: + /* leaving window, cancel any tooltips */ + stop_tooltip_timeout (); + hide_tooltip (); + break; + default: + /* we don't care about any other kind + of leave event (notably GDK_NOTIFY_INFERIOR) + */ + break; + } _new_current_item = 0; - Duple where = window_to_canvas (Duple (ev->x, ev->y)); - deliver_enter_leave (where, ev->state); + 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) { - boost::optional req = request.intersection (visible_area()); + Rect real_area; - if (req) { - Rect r = req.get(); - Rect area = canvas_to_window (r); - queue_draw_area (area.x0, area.y0, area.width(), area.height()); - } + 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. @@ -789,13 +1057,134 @@ GtkCanvas::unfocus (Item* item) } } -/** @return The visible area of the canvas, in canvas coordinates */ +/** @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(); +} + +void +GtkCanvas::start_tooltip_timeout (Item* item) +{ + stop_tooltip_timeout (); + + if (item) { + current_tooltip_item = item; + + /* wait for the first idle that happens after this is + called. this means that we've stopped processing events, which + in turn implies that the user has stopped doing stuff for a + little while. + */ + + Glib::signal_idle().connect (sigc::mem_fun (*this, &GtkCanvas::really_start_tooltip_timeout)); + } +} + +bool +GtkCanvas::really_start_tooltip_timeout () +{ + /* an idle has occured since we entered a tooltip-bearing widget. Now + * wait 1 second and if the timeout isn't cancelled, show the tooltip. + */ + + if (current_tooltip_item) { + tooltip_timeout_connection = Glib::signal_timeout().connect (sigc::mem_fun (*this, &GtkCanvas::show_tooltip), tooltip_timeout_msecs); + } + + return false; /* this is called from an idle callback, don't call it again */ +} + +void +GtkCanvas::stop_tooltip_timeout () +{ + current_tooltip_item = 0; + tooltip_timeout_connection.disconnect (); +} + +bool +GtkCanvas::show_tooltip () +{ + Rect tooltip_item_bbox; + + if (!current_tooltip_item || current_tooltip_item->tooltip().empty() || !current_tooltip_item->bounding_box()) { + return false; + } + + if (!tooltip_window) { + tooltip_window = new Gtk::Window (Gtk::WINDOW_POPUP); + tooltip_label = manage (new Gtk::Label); + tooltip_label->show (); + tooltip_window->add (*tooltip_label); + tooltip_window->set_border_width (6); + tooltip_window->set_name ("tooltip"); + } + + tooltip_label->set_text (current_tooltip_item->tooltip()); + + /* figure out where to position the tooltip */ + + Gtk::Widget* toplevel = get_toplevel(); + assert (toplevel); + int pointer_x, pointer_y; + Gdk::ModifierType mask; + + (void) toplevel->get_window()->get_pointer (pointer_x, pointer_y, mask); + + Duple tooltip_window_origin (pointer_x, pointer_y); + + /* convert to root window coordinates */ + + int win_x, win_y; + dynamic_cast(toplevel)->get_position (win_x, win_y); + + tooltip_window_origin = tooltip_window_origin.translate (Duple (win_x, win_y)); + + /* we don't want the pointer to be inside the window when it is + * displayed, because then we generate a leave/enter event pair when + * the window is displayed then hidden - the enter event will + * trigger a new tooltip timeout. + * + * So move the window right of the pointer position by just a enough + * to get it away from the pointer. + */ + + tooltip_window_origin.x += 20; + + /* move the tooltip window into position */ + + tooltip_window->move (tooltip_window_origin.x, tooltip_window_origin.y); + + /* ready to show */ + + tooltip_window->present (); + + /* called from a timeout handler, don't call it again */ + + return false; +} + +void +GtkCanvas::hide_tooltip () +{ + /* hide it if its there */ + + if (tooltip_window) { + tooltip_window->hide (); + } } /** Create a GtkCanvaSViewport.