X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fcanvas%2Fcanvas.cc;h=8456d44d828181462eacaec1735d5346425ac901;hb=aacb2d7be7f9c34b39f1acf9a408e05addab409e;hp=100cf7eeaa27338d2bd91f175937e751f6b04ee1;hpb=f0c18abf55a19c101bd2c4f9bccbe182df060b25;p=ardour.git diff --git a/libs/canvas/canvas.cc b/libs/canvas/canvas.cc index 100cf7eeaa..8456d44d82 100644 --- a/libs/canvas/canvas.cc +++ b/libs/canvas/canvas.cc @@ -18,6 +18,10 @@ */ +#if !defined USE_CAIRO_IMAGE_SURFACE && !defined NDEBUG +#define OPTIONAL_CAIRO_IMAGE_SURFACE +#endif + /** @file canvas/canvas.cc * @brief Implementation of the main canvas classes. */ @@ -26,21 +30,34 @@ #include #include #include +#include + +#include "gtkmm2ext/persistent_tooltip.h" #include "pbd/compose.h" #include "pbd/stacktrace.h" #include "canvas/canvas.h" +#include "gtkmm2ext/colors.h" #include "canvas/debug.h" #include "canvas/line.h" #include "canvas/scroll_group.h" +#ifdef __APPLE__ +#include +#include "gtkmm2ext/nsglview.h" +#endif + using namespace std; using namespace ArdourCanvas; +uint32_t Canvas::tooltip_timeout_msecs = 750; + /** Construct a new Canvas */ Canvas::Canvas () : _root (this) + , _bg_color (Gtkmm2ext::rgba_to_color (0, 1.0, 0.0, 1.0)) + , _last_render_start_timestamp(0) { set_epoch (); } @@ -62,7 +79,7 @@ Canvas::scroll_to (Coord x, Coord y) (*i)->scroll_to (Duple (x, y)); } - pick_current_item (0); // no current mouse position + pick_current_item (0); // no current mouse position } void @@ -84,6 +101,10 @@ Canvas::zoomed () void Canvas::render (Rect const & area, Cairo::RefPtr const & context) const { + PreRender (); // emit signal + + _last_render_start_timestamp = g_get_monotonic_time(); + #ifdef CANVAS_DEBUG if (DEBUG_ENABLED(PBD::DEBUG::CanvasRender)) { cerr << this << " RENDER: " << area << endl; @@ -94,29 +115,63 @@ Canvas::render (Rect const & area, Cairo::RefPtr const & context #endif render_count = 0; - - boost::optional root_bbox = _root.bounding_box(); + + Rect root_bbox = _root.bounding_box(); if (!root_bbox) { /* the root has no bounding box, so there's nothing to render */ return; } - boost::optional draw = root_bbox->intersection (area); + Rect 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); + _root.render (draw, context); + +#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 + } - // 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 (); +} +void +Canvas::prepare_for_render (Rect const & area) const +{ + Rect root_bbox = _root.bounding_box(); + if (!root_bbox) { + /* the root has no bounding box, so there's nothing to render */ + return; } + Rect draw = root_bbox.intersection (area); + + if (draw) { + _root.prepare_for_render (draw); + } +} + +gint64 +Canvas::get_microseconds_since_render_start () const +{ + gint64 timestamp = g_get_monotonic_time(); + + if (_last_render_start_timestamp == 0 || timestamp <= _last_render_start_timestamp) { + return 0; + } + + return timestamp - _last_render_start_timestamp; } ostream& @@ -128,7 +183,7 @@ operator<< (ostream& o, Canvas& c) std::string Canvas::indent() const -{ +{ string s; for (int n = 0; n < ArdourCanvas::dump_depth; ++n) { @@ -140,7 +195,7 @@ Canvas::indent() const std::string Canvas::render_indent() const -{ +{ string s; for (int n = 0; n < ArdourCanvas::render_depth; ++n) { @@ -155,7 +210,7 @@ Canvas::dump (ostream& o) const { dump_depth = 0; _root.dump (o); -} +} /** Called when an item has been shown or hidden. * @param item Item that has been shown or hidden. @@ -163,9 +218,11 @@ Canvas::dump (ostream& o) const void Canvas::item_shown_or_hidden (Item* item) { - boost::optional bbox = item->bounding_box (); + Rect 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); + } } } @@ -176,9 +233,11 @@ Canvas::item_shown_or_hidden (Item* item) void Canvas::item_visual_property_changed (Item* item) { - boost::optional bbox = item->bounding_box (); + Rect 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); + } } } @@ -188,39 +247,81 @@ Canvas::item_visual_property_changed (Item* item) * in the item's coordinates. */ void -Canvas::item_changed (Item* item, boost::optional pre_change_bounding_box) +Canvas::item_changed (Item* item, Rect 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); + } } - boost::optional post_change_bounding_box = item->bounding_box (); + Rect 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 ()); + Rect const window_intersection = + item->item_to_window (post_change_bounding_box).intersection (window_bbox); + + if (window_intersection) { + /* request a redraw of the item's new bounding box */ + queue_draw_item_area (item, post_change_bounding_box); + + // Allow item to do any work necessary to prepare for being rendered. + item->prepare_for_render (window_intersection); + } else { + // No intersection with visible window area + } } } Duple Canvas::window_to_canvas (Duple const & d) const { - /* 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. + ScrollGroup* best_group = 0; + ScrollGroup* sg = 0; + + /* if the coordinates are negative, clamp to zero and find the item + * that covers that "edge" position. */ - std::list const& root_children (_root.items()); - ScrollGroup* sg = 0; + Duple in_window (d); - for (std::list::const_iterator i = root_children.begin(); i != root_children.end(); ++i) { - if (((sg = dynamic_cast(*i)) != 0) && sg->covers_window (d)) { - break; + if (in_window.x < 0) { + in_window.x = 0; + } + if (in_window.y < 0) { + in_window.y = 0; + } + + for (list::const_iterator s = scrollers.begin(); s != scrollers.end(); ++s) { + + if ((*s)->covers_window (in_window)) { + sg = *s; + + /* XXX January 22nd 2015: leaving this in place for now + * but I think it fixes a bug that really should be + * fixed in a different way (and will be) by my next + * commit. But it may still be relevant. + */ + + /* If scroll groups overlap, choose the one with the highest sensitivity, + that is, choose an HV scroll group over an H or V + only group. + */ + if (!best_group || sg->sensitivity() > best_group->sensitivity()) { + best_group = sg; + if (sg->sensitivity() == (ScrollGroup::ScrollsVertically | ScrollGroup::ScrollsHorizontally)) { + /* Can't do any better than this. */ + break; + } + } } } - if (sg) { - return d.translate (sg->scroll_offset()); + if (best_group) { + return d.translate (best_group->scroll_offset()); } return d; @@ -243,7 +344,6 @@ Canvas::canvas_to_window (Duple const & d, bool rounded) const break; } } - if (sg) { wd = d.translate (-sg->scroll_offset()); @@ -267,7 +367,7 @@ Canvas::canvas_to_window (Duple const & d, bool rounded) const * the move, in its parent's coordinates. */ void -Canvas::item_moved (Item* item, boost::optional pre_change_parent_bounding_box) +Canvas::item_moved (Item* item, Rect pre_change_parent_bounding_box) { if (pre_change_parent_bounding_box) { /* request a redraw of where the item used to be. The box has @@ -279,13 +379,13 @@ Canvas::item_moved (Item* item, boost::optional pre_change_parent_bounding * invalidation area. If we use the parent (which has not * moved, then this will work. */ - queue_draw_item_area (item->parent(), pre_change_parent_bounding_box.get ()); + queue_draw_item_area (item->parent(), pre_change_parent_bounding_box); } - boost::optional post_change_bounding_box = item->bounding_box (); + Rect post_change_bounding_box = item->bounding_box (); if (post_change_bounding_box) { /* request a redraw of where the item now is */ - queue_draw_item_area (item, post_change_bounding_box.get ()); + queue_draw_item_area (item, post_change_bounding_box); } } @@ -299,16 +399,58 @@ Canvas::queue_draw_item_area (Item* item, Rect 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 (Gtkmm2ext::Color c) +{ + _bg_color = c; + + Rect r = _root.bounding_box(); + + if (r) { + request_redraw (_root.item_to_window (r)); + } +} + +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 */ GtkCanvas::GtkCanvas () : _current_item (0) , _new_current_item (0) , _grabbed_item (0) , _focused_item (0) + , _single_exposure (1) + , current_tooltip_item (0) + , tooltip_window (0) + , _in_dtor (false) + , _nsglview (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 +GtkCanvas::use_nsglview () +{ + assert (!_nsglview); + assert (!is_realized()); +#ifdef ARDOUR_CANVAS_NSVIEW_TAG // patched gdkquartz.h + _nsglview = Gtkmm2ext::nsglview_create (this); +#endif } void @@ -321,7 +463,7 @@ GtkCanvas::pick_current_item (int state) * 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. */ - + Glib::RefPtr pointer_window = Gdk::Display::get_default()->get_window_at_pointer (x, y); if (pointer_window != get_window()) { @@ -355,9 +497,9 @@ GtkCanvas::pick_current_item (Duple const & point, int state) 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; + std::cerr << "\tItem " << (*it)->whatami() << '/' << (*it)->name << " ignore events ? " << (*it)->ignore_events() << " vis ? " << (*it)->visible() << std::endl; #else - std::cerr << "\tItem " << (*it)->whatami() << std::endl; + std::cerr << "\tItem " << (*it)->whatami() << '/' << " ignore events ? " << (*it)->ignore_events() << " vis ? " << (*it)->visible() << std::endl; #endif } } @@ -368,23 +510,24 @@ GtkCanvas::pick_current_item (Duple const & point, int state) 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 * 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 */ @@ -394,15 +537,23 @@ GtkCanvas::pick_current_item (Duple const & point, int state) 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 @@ -413,9 +564,15 @@ 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; @@ -425,7 +582,7 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) /* 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; @@ -434,8 +591,8 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) leave_event.type = GDK_LEAVE_NOTIFY; Item* i; - GdkNotifyType enter_detail; - GdkNotifyType leave_detail; + GdkNotifyType enter_detail = GDK_NOTIFY_UNKNOWN; + GdkNotifyType leave_detail = GDK_NOTIFY_UNKNOWN; vector items_to_leave_virtual; vector items_to_enter_virtual; @@ -459,7 +616,7 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) enter_detail = GDK_NOTIFY_UNKNOWN; /* no current item, so also send virtual enter events to the - * entire heirarchy for the new item + * entire heirarchy for the new item */ for (i = _new_current_item->parent(); i ; i = i->parent()) { @@ -469,12 +626,12 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) } 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") + * 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); } @@ -482,7 +639,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") @@ -521,7 +677,7 @@ GtkCanvas::deliver_enter_leave (Duple const & point, int state) enter_detail = GDK_NOTIFY_NONLINEAR; leave_detail = GDK_NOTIFY_NONLINEAR; } - + if (_current_item && !_current_item->ignore_events ()) { leave_event.detail = leave_detail; @@ -550,6 +706,7 @@ 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); } @@ -585,22 +742,22 @@ GtkCanvas::deliver_event (GdkEvent* event) /* run through the items from child to parent, until one claims the event */ Item* item = const_cast (event_item); - + while (item) { Item* parent = item->parent (); - if (!item->ignore_events () && + 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", item->whatami(), item->name.empty() ? "[unknown]" : item->name) ); - + return true; } - + 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) { @@ -612,17 +769,26 @@ GtkCanvas::deliver_event (GdkEvent* event) return false; } +void +GtkCanvas::item_shown_or_hidden (Item* item) +{ + if (item == current_tooltip_item) { + stop_tooltip_timeout (); + } + Canvas::item_shown_or_hidden (item); +} + /** Called when an item is being destroyed. * @param item Item being destroyed. * @param bounding_box Last known bounding box of the item. */ void -GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) +GtkCanvas::item_going_away (Item* item, Rect bounding_box) { if (bounding_box) { - queue_draw_item_area (item, bounding_box.get ()); + queue_draw_item_area (item, bounding_box); } - + if (_new_current_item == item) { _new_current_item = 0; } @@ -635,18 +801,64 @@ GtkCanvas::item_going_away (Item* item, boost::optional bounding_box) _focused_item = 0; } + 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 + /* 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_realize () +{ + Gtk::EventBox::on_realize(); +#ifdef __APPLE__ + if (_nsglview) { + Gtkmm2ext::nsglview_overlay (_nsglview, get_window()->gobj()); + } +#endif +} + +void +GtkCanvas::on_size_allocate (Gtk::Allocation& a) +{ + EventBox::on_size_allocate (a); +#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE + if (getenv("ARDOUR_IMAGE_SURFACE")) { +#endif +#if defined USE_CAIRO_IMAGE_SURFACE || defined OPTIONAL_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 +#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE + } +#endif + +#ifdef __APPLE__ + if (_nsglview) { + gint xx, yy; + gtk_widget_translate_coordinates( + GTK_WIDGET(gobj()), + GTK_WIDGET(get_toplevel()->gobj()), + 0, 0, &xx, &yy); + Gtkmm2ext::nsglview_resize (_nsglview, xx, yy, a.get_width(), a.get_height()); + } +#endif + } /** Handler for GDK expose events. @@ -656,21 +868,165 @@ 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 (); - render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), cairo_context); + if (_in_dtor) { + return true; + } +#ifdef __APPLE__ + if (_nsglview) { + return true; + } +#endif + +#ifdef CANVAS_PROFILE + const int64_t start = g_get_monotonic_time (); +#endif + +#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE + Cairo::RefPtr draw_context; + Cairo::RefPtr window_context; + if (getenv("ARDOUR_IMAGE_SURFACE")) { + if (!canvas_image) { + canvas_image = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, get_width(), get_height()); + } + draw_context = Cairo::Context::create (canvas_image); + window_context = get_window()->create_cairo_context (); + } else { + draw_context = get_window()->create_cairo_context (); + } +#elif defined 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 + + draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height); + draw_context->clip(); + +#ifdef __APPLE__ + /* group calls cairo_quartz_surface_create() which + * effectively uses a CGBitmapContext + image-surface + * + * This avoids expensive argb32_image_mark_image() during drawing. + * Although the final paint() operation still takes the slow path + * through image_mark_image instead of ColorMaskCopyARGB888_sse :( + * + * profiling indicates a speed up of factor 2. (~ 5-10ms render time, + * instead of 10-20ms, which is still slow compared to XCB and win32 surfaces (~0.2 ms) + * + * Fixing this for good likely involves changes to GdkQuartzWindow, GdkQuartzView + */ + draw_context->push_group (); +#endif + + /* draw background color */ + draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height); + Gtkmm2ext::set_source_rgba (draw_context, _bg_color); + draw_context->fill (); + + /* render canvas */ + if ( _single_exposure ) { + + Canvas::render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), draw_context); + + } else { + GdkRectangle* rects; + gint nrects; + + gdk_region_get_rectangles (ev->region, &rects, &nrects); + for (gint n = 0; n < nrects; ++n) { + draw_context->set_identity_matrix(); //reset the cairo matrix, just in case someone left it transformed after drawing ( cough ) + Canvas::render (Rect (rects[n].x, rects[n].y, rects[n].x + rects[n].width, rects[n].y + rects[n].height), draw_context); + } + g_free (rects); + } + +#ifdef __APPLE__ + draw_context->pop_group_to_source (); + draw_context->paint (); +#endif + +#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE + if (getenv("ARDOUR_IMAGE_SURFACE")) { +#endif +#if defined USE_CAIRO_IMAGE_SURFACE || defined OPTIONAL_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 +#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE + } +#endif + +#ifdef CANVAS_PROFILE + const int64_t end = g_get_monotonic_time (); + const int64_t elapsed = end - start; + printf ("GtkCanvas::on_expose_event %f ms\n", elapsed / 1000.f); +#endif + return true; } -/** @return Our Cairo context, or 0 if we don't have one */ -Cairo::RefPtr -GtkCanvas::context () +void +GtkCanvas::prepare_for_render () const { - Glib::RefPtr w = get_window (); - if (!w) { - return Cairo::RefPtr (); - } + Rect window_bbox = visible_area (); + Canvas::prepare_for_render (window_bbox); +} + +/** 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); - return w->create_cairo_context (); + 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 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. @@ -685,17 +1041,17 @@ GtkCanvas::on_button_press_event (GdkEventButton* ev) 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)); + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button press %1 @ %2, %3 => %4\n", ev->button, ev->x, ev->y, where)); return deliver_event (reinterpret_cast(©)); } @@ -705,13 +1061,13 @@ GtkCanvas::on_button_press_event (GdkEventButton* ev) */ bool GtkCanvas::on_button_release_event (GdkEventButton* 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; @@ -721,10 +1077,32 @@ GtkCanvas::on_button_release_event (GdkEventButton* ev) 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)); + DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas button release %1 @ %2, %3 => %4\n", ev->button, 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. @@ -732,6 +1110,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); @@ -741,11 +1121,13 @@ GtkCanvas::on_motion_notify_event (GdkEventMotion* ev) copy.motion.x = where.x; copy.motion.y = where.y; - /* Coordinates in "copy" will be canvas coordinates, + /* 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 @@ -767,30 +1149,104 @@ GtkCanvas::on_enter_notify_event (GdkEventCrossing* ev) 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; deliver_enter_leave (Duple (ev->x, ev->y), ev->state); return true; } +void +GtkCanvas::on_map () +{ + Gtk::EventBox::on_map(); +#ifdef __APPLE__ + if (_nsglview) { + Gtkmm2ext::nsglview_set_visible (_nsglview, true); + Gtk::Allocation a = get_allocation(); + gint xx, yy; + gtk_widget_translate_coordinates( + GTK_WIDGET(gobj()), + GTK_WIDGET(get_toplevel()->gobj()), + 0, 0, &xx, &yy); + Gtkmm2ext::nsglview_resize (_nsglview, xx, yy, a.get_width(), a.get_height()); + } +#endif +} + +void +GtkCanvas::on_unmap () +{ + stop_tooltip_timeout (); + Gtk::EventBox::on_unmap(); +#ifdef __APPLE__ + if (_nsglview) { + Gtkmm2ext::nsglview_set_visible (_nsglview, false); + } +#endif +} + +void +GtkCanvas::queue_draw() +{ +#ifdef __APPLE__ + if (_nsglview) { + Gtkmm2ext::nsglview_queue_draw (_nsglview, 0, 0, get_width (), get_height ()); + return; + } +#endif + Gtk::Widget::queue_draw (); +} + +void +GtkCanvas::queue_draw_area (int x, int y, int width, int height) +{ +#ifdef __APPLE__ + if (_nsglview) { + Gtkmm2ext::nsglview_queue_draw (_nsglview, x, y, width, height); + return; + } +#endif + Gtk::Widget::queue_draw_area (x, y, width, height); +} + /** Called to request a redraw of our canvas. * @param area Area to redraw, in window coordinates. */ void GtkCanvas::request_redraw (Rect const & request) { - Rect real_area; - - Coord const w = width (); - Coord const h = height (); + if (_in_dtor) { + return; + } /* 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)); + Rect real_area = request.intersection (visible_area()); - queue_draw_area (real_area.x0, real_area.y0, real_area.width(), real_area.height()); + if (real_area) { + if (real_area.width () && real_area.height ()) { + // Item intersects with visible canvas area + queue_draw_area (real_area.x0, real_area.y0, real_area.width(), real_area.height()); + } + + } else { + // Item does not intersect with visible canvas area + } } /** Called to request that we try to get a particular size for ourselves. @@ -851,8 +1307,8 @@ GtkCanvas::unfocus (Item* item) } } -/** @return The visible area of the canvas, in canvas coordinates */ -Rect +/** @return The visible area of the canvas, in window coordinates */ +ArdourCanvas::Rect GtkCanvas::visible_area () const { return Rect (0, 0, get_allocation().get_width (), get_allocation().get_height ()); @@ -870,6 +1326,129 @@ GtkCanvas::height() const return get_allocation().get_height(); } +void +GtkCanvas::start_tooltip_timeout (Item* item) +{ + stop_tooltip_timeout (); + + if (item && Gtkmm2ext::PersistentTooltip::tooltips_enabled ()) { + 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 occurred 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 (1); + 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 += 30; + tooltip_window_origin.y += 45; + + /* 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 (); + + // Delete the tooltip window so it'll get re-created + // (i.e. properly re-sized) on the next usage. + delete tooltip_window; + tooltip_window = NULL; + } +} + +Glib::RefPtr +GtkCanvas::get_pango_context () +{ + return Glib::wrap (gdk_pango_context_get()); +} + /** Create a GtkCanvaSViewport. * @param hadj Adjustment to use for horizontal scrolling. * @param vadj Adjustment to use for vertica scrolling. @@ -899,7 +1478,7 @@ void GtkCanvasViewport::on_size_request (Gtk::Requisition* req) { /* force the canvas to size itself */ - // _canvas.root()->bounding_box(); + // _canvas.root()->bounding_box(); req->width = 16; req->height = 16;