Only show user-presets in favorite sidebar
[ardour.git] / libs / canvas / canvas.cc
index 9d1d9f3ad9df7c5965b85c827ae4f6fdbe25b79d..8456d44d828181462eacaec1735d5346425ac901 100644 (file)
 
 */
 
+#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.
  */
 #include <gtkmm/label.h>
 #include <gtkmm/window.h>
 
+#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 <gdk/gdk.h>
+#include "gtkmm2ext/nsglview.h"
+#endif
+
 using namespace std;
 using namespace ArdourCanvas;
 
@@ -44,6 +56,8 @@ 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 ();
 }
@@ -65,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
@@ -87,6 +101,10 @@ Canvas::zoomed ()
 void
 Canvas::render (Rect const & area, Cairo::RefPtr<Cairo::Context> 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;
@@ -97,21 +115,21 @@ Canvas::render (Rect const & area, Cairo::RefPtr<Cairo::Context> const & context
 #endif
 
        render_count = 0;
-       
-       boost::optional<Rect> 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<Rect> 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")) {
@@ -119,7 +137,7 @@ Canvas::render (Rect const & area, Cairo::RefPtr<Cairo::Context> const & context
                        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->rectangle (draw.x0, draw.y0, draw.x1 - draw.x0, draw.y1 - draw.y0);
                        context->set_source_rgba (r, g, b, 0.25);
                        context->fill ();
                }
@@ -128,6 +146,34 @@ Canvas::render (Rect const & area, Cairo::RefPtr<Cairo::Context> const & context
 
 }
 
+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&
 operator<< (ostream& o, Canvas& c)
 {
@@ -137,7 +183,7 @@ operator<< (ostream& o, Canvas& c)
 
 std::string
 Canvas::indent() const
-{ 
+{
        string s;
 
        for (int n = 0; n < ArdourCanvas::dump_depth; ++n) {
@@ -149,7 +195,7 @@ Canvas::indent() const
 
 std::string
 Canvas::render_indent() const
-{ 
+{
        string s;
 
        for (int n = 0; n < ArdourCanvas::render_depth; ++n) {
@@ -164,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.
@@ -172,10 +218,10 @@ Canvas::dump (ostream& o) const
 void
 Canvas::item_shown_or_hidden (Item* item)
 {
-       boost::optional<Rect> bbox = item->bounding_box ();
+       Rect bbox = item->bounding_box ();
        if (bbox) {
-               if (item->item_to_window (*bbox).intersection (visible_area ())) {
-                       queue_draw_item_area (item, bbox.get ());
+               if (item->item_to_window (bbox).intersection (visible_area ())) {
+                       queue_draw_item_area (item, bbox);
                }
        }
 }
@@ -187,10 +233,10 @@ Canvas::item_shown_or_hidden (Item* item)
 void
 Canvas::item_visual_property_changed (Item* item)
 {
-       boost::optional<Rect> bbox = item->bounding_box ();
+       Rect bbox = item->bounding_box ();
        if (bbox) {
-               if (item->item_to_window (*bbox).intersection (visible_area ())) {
-                       queue_draw_item_area (item, bbox.get ());
+               if (item->item_to_window (bbox).intersection (visible_area ())) {
+                       queue_draw_item_area (item, bbox);
                }
        }
 }
@@ -201,25 +247,31 @@ Canvas::item_visual_property_changed (Item* item)
  *  in the item's coordinates.
  */
 void
-Canvas::item_changed (Item* item, boost::optional<Rect> pre_change_bounding_box)
+Canvas::item_changed (Item* item, Rect pre_change_bounding_box)
 {
-       
        Rect window_bbox = visible_area ();
 
        if (pre_change_bounding_box) {
-
-               if (item->item_to_window (*pre_change_bounding_box).intersection (window_bbox)) {
+               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 ());
+                       queue_draw_item_area (item, pre_change_bounding_box);
                }
        }
 
-       boost::optional<Rect> post_change_bounding_box = item->bounding_box ();
+       Rect post_change_bounding_box = item->bounding_box ();
+
        if (post_change_bounding_box) {
-               
-               if (item->item_to_window (*post_change_bounding_box).intersection (window_bbox)) {
+               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.get ());
+                       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
                }
        }
 }
@@ -227,12 +279,7 @@ Canvas::item_changed (Item* item, boost::optional<Rect> pre_change_bounding_box)
 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.
-        */
-
-       std::list<Item*> const& root_children (_root.items());
+       ScrollGroup* best_group = 0;
        ScrollGroup* sg = 0;
 
        /* if the coordinates are negative, clamp to zero and find the item
@@ -248,14 +295,33 @@ Canvas::window_to_canvas (Duple const & d) const
                in_window.y = 0;
        }
 
-       for (std::list<Item*>::const_iterator i = root_children.begin(); i != root_children.end(); ++i) {
-               if (((sg = dynamic_cast<ScrollGroup*>(*i)) != 0) && sg->covers_window (in_window)) {
-                       break;
+       for (list<ScrollGroup*>::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;
@@ -278,7 +344,6 @@ Canvas::canvas_to_window (Duple const & d, bool rounded) const
                        break;
                }
        }
-       
 
        if (sg) {
                wd = d.translate (-sg->scroll_offset());
@@ -302,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<Rect> 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
@@ -314,13 +379,13 @@ Canvas::item_moved (Item* item, boost::optional<Rect> 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<Rect> 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);
        }
 }
 
@@ -340,6 +405,18 @@ 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 ()
 {
@@ -354,12 +431,26 @@ GtkCanvas::GtkCanvas ()
        , _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::SCROLL_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
@@ -372,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<const Gdk::Window> pointer_window = Gdk::Display::get_default()->get_window_at_pointer (x, y);
 
        if (pointer_window != get_window()) {
@@ -419,7 +510,7 @@ 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<Item const *>::const_iterator i;
        list<Item const *> within_items;
 
@@ -449,7 +540,7 @@ GtkCanvas::pick_current_item (Duple const & point, int state)
                        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<Item*> (within_items.front());
        }
 
@@ -491,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;
@@ -500,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<Item*> items_to_leave_virtual;
        vector<Item*> items_to_enter_virtual;
 
@@ -525,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()) {
@@ -535,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);
                }
@@ -586,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;
@@ -651,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<Item*> (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) {
@@ -678,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<Rect> 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;
        }
@@ -712,24 +812,53 @@ GtkCanvas::item_going_away (Item* item, boost::optional<Rect> bounding_box)
        }
 
        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 USE_CAIRO_IMAGE_SURFACE
+#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.
@@ -739,51 +868,119 @@ GtkCanvas::on_size_allocate (Gtk::Allocation& a)
 bool
 GtkCanvas::on_expose_event (GdkEventExpose* ev)
 {
-#ifdef USE_CAIRO_IMAGE_SURFACE
-       if (!canvas_image) {
-               canvas_image = Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, get_width(), get_height());
+       if (_in_dtor) {
+               return true;
        }
+#ifdef __APPLE__
+       if (_nsglview) {
+               return true;
+       }
+#endif
 
-       {
-               /* scope for image_context */
-               Cairo::RefPtr<Cairo::Context> image_context = Cairo::Context::create (canvas_image);
+#ifdef CANVAS_PROFILE
+       const int64_t start = g_get_monotonic_time ();
+#endif
 
-               /* clear expose area to transparent */
+#ifdef OPTIONAL_CAIRO_IMAGE_SURFACE
+       Cairo::RefPtr<Cairo::Context> draw_context;
+       Cairo::RefPtr<Cairo::Context> 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<Cairo::Context> draw_context = Cairo::Context::create (canvas_image);
+       Cairo::RefPtr<Cairo::Context> window_context = get_window()->create_cairo_context ();
+#else
+       Cairo::RefPtr<Cairo::Context> draw_context = get_window()->create_cairo_context ();
+#endif
 
-               image_context->save ();
-               image_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
-               image_context->clip ();
-               image_context->set_operator (Cairo::OPERATOR_CLEAR);
-               image_context->paint ();
-               image_context->restore ();
+       draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
+       draw_context->clip();
 
-               /* render into image surface */
+#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
 
-               render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), image_context);
+       /* 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 ();
 
-               /* image surface is flushed when image_context goes out of scope */
-       }
+       /* render canvas */
+       if ( _single_exposure ) {
 
-       /* now blit our private surface back to the GDK one */
+               Canvas::render (Rect (ev->area.x, ev->area.y, ev->area.x + ev->area.width, ev->area.y + ev->area.height), draw_context);
 
-       Cairo::RefPtr<Cairo::Context> cairo_context = get_window()->create_cairo_context ();
+       } else {
+               GdkRectangle* rects;
+               gint nrects;
 
-       cairo_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
-       cairo_context->clip ();
-       cairo_context->set_source (canvas_image, 0, 0);
-       cairo_context->set_operator (Cairo::OPERATOR_SOURCE);
-       cairo_context->paint ();
+               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);
+       }
 
-#else
+#ifdef __APPLE__
+       draw_context->pop_group_to_source ();
+       draw_context->paint ();
+#endif
 
-       Cairo::RefPtr<Cairo::Context> 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);
+#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;
 }
 
+void
+GtkCanvas::prepare_for_render () const
+{
+       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.
@@ -796,12 +993,12 @@ GtkCanvas::on_scroll_event (GdkEventScroll* 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.
        */
@@ -810,6 +1007,28 @@ GtkCanvas::on_scroll_event (GdkEventScroll* ev)
        return deliver_event (reinterpret_cast<GdkEvent*>(&copy));
 }
 
+/** 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<GdkEvent*>(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<GdkEvent*>(ev));
+}
+
 /** Handler for GDK button press events.
  *  @param ev Event.
  *  @return true if the event was handled.
@@ -822,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<GdkEvent*>(&copy));
 }
 
@@ -842,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;
@@ -858,7 +1077,7 @@ 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<GdkEvent*>(&copy));
 }
 
@@ -902,7 +1121,7 @@ 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));
@@ -951,25 +1170,83 @@ GtkCanvas::on_leave_notify_event (GdkEventCrossing* ev)
        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.
@@ -1031,7 +1308,7 @@ GtkCanvas::unfocus (Item* item)
 }
 
 /** @return The visible area of the canvas, in window coordinates */
-Rect
+ArdourCanvas::Rect
 GtkCanvas::visible_area () const
 {
        return Rect (0, 0, get_allocation().get_width (), get_allocation().get_height ());
@@ -1054,7 +1331,7 @@ GtkCanvas::start_tooltip_timeout (Item* item)
 {
        stop_tooltip_timeout ();
 
-       if (item) {
+       if (item && Gtkmm2ext::PersistentTooltip::tooltips_enabled ()) {
                current_tooltip_item = item;
 
                /* wait for the first idle that happens after this is
@@ -1070,7 +1347,7 @@ GtkCanvas::start_tooltip_timeout (Item* item)
 bool
 GtkCanvas::really_start_tooltip_timeout ()
 {
-       /* an idle has occured since we entered a tooltip-bearing widget. Now
+       /* 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.
         */
 
@@ -1102,7 +1379,7 @@ GtkCanvas::show_tooltip ()
                tooltip_label = manage (new Gtk::Label);
                tooltip_label->show ();
                tooltip_window->add (*tooltip_label);
-               tooltip_window->set_border_width (6);
+               tooltip_window->set_border_width (1);
                tooltip_window->set_name ("tooltip");
        }
 
@@ -1118,12 +1395,12 @@ GtkCanvas::show_tooltip ()
        (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<Gtk::Window*>(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
@@ -1135,7 +1412,8 @@ GtkCanvas::show_tooltip ()
         * to get it away from the pointer.
         */
 
-       tooltip_window_origin.x += 20;
+       tooltip_window_origin.x += 30;
+       tooltip_window_origin.y += 45;
 
        /* move the tooltip window into position */
 
@@ -1144,7 +1422,7 @@ GtkCanvas::show_tooltip ()
        /* ready to show */
 
        tooltip_window->present ();
-       
+
        /* called from a timeout handler, don't call it again */
 
        return false;
@@ -1157,9 +1435,20 @@ GtkCanvas::hide_tooltip ()
 
        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<Pango::Context>
+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.
@@ -1189,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;