Only show user-presets in favorite sidebar

[ardour.git] / libs / canvas / canvas.cc

diff --git a/libs/canvas/canvas.cc b/libs/canvas/canvas.cc
index eb40f785dd0361a035948ea7d98272da6c34145e..8456d44d828181462eacaec1735d5346425ac901 100644 (file)
--- a/libs/canvas/canvas.cc
+++ b/libs/canvas/canvas.cc
@@ -38,11 +38,10 @@
 #include "pbd/stacktrace.h"
 
 #include "canvas/canvas.h"
-#include "canvas/colors.h"
+#include "gtkmm2ext/colors.h"
 #include "canvas/debug.h"
 #include "canvas/line.h"
 #include "canvas/scroll_group.h"
-#include "canvas/utils.h"
 
 #ifdef __APPLE__
 #include <gdk/gdk.h>
@@ -57,7 +56,8 @@ uint32_t Canvas::tooltip_timeout_msecs = 750;
 /** Construct a new Canvas */
 Canvas::Canvas ()
        : _root (this)
-       , _bg_color (rgba_to_color (0, 1.0, 0.0, 1.0))
+       , _bg_color (Gtkmm2ext::rgba_to_color (0, 1.0, 0.0, 1.0))
+       , _last_render_start_timestamp(0)
 {
        set_epoch ();
 }
@@ -101,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;
@@ -142,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)
 {
@@ -229,9 +261,17 @@ Canvas::item_changed (Item* item, Rect pre_change_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);
+
+                       // 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
                }
        }
 }
@@ -366,7 +406,7 @@ Canvas::set_tooltip_timeout (uint32_t msecs)
 }
 
 void
-Canvas::set_background_color (Color c)
+Canvas::set_background_color (Gtkmm2ext::Color c)
 {
        _bg_color = c;
 
@@ -729,6 +769,15 @@ 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.
@@ -824,7 +873,6 @@ GtkCanvas::on_expose_event (GdkEventExpose* ev)
        }
 #ifdef __APPLE__
        if (_nsglview) {
-               Gtkmm2ext::nsglview_queue_draw (_nsglview, ev->area.x, ev->area.y, ev->area.width, ev->area.height);
                return true;
        }
 #endif
@@ -876,7 +924,7 @@ GtkCanvas::on_expose_event (GdkEventExpose* ev)
 
        /* draw background color */
        draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
-       set_source_rgba (draw_context, _bg_color);
+       Gtkmm2ext::set_source_rgba (draw_context, _bg_color);
        draw_context->fill ();
 
        /* render canvas */
@@ -926,6 +974,13 @@ GtkCanvas::on_expose_event (GdkEventExpose* ev)
        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.
@@ -1136,6 +1191,7 @@ GtkCanvas::on_map ()
 void
 GtkCanvas::on_unmap ()
 {
+       stop_tooltip_timeout ();
        Gtk::EventBox::on_unmap();
 #ifdef __APPLE__
        if (_nsglview) {
@@ -1144,6 +1200,30 @@ GtkCanvas::on_unmap ()
 #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.
  */
@@ -1154,19 +1234,19 @@ GtkCanvas::request_redraw (Rect const & request)
                return;
        }
 
-       Rect real_area;
-
-       Coord const w = width ();
-       Coord const h = height ();
-
        /* clamp area requested to actual visible window */
 
-       real_area.x0 = max (0.0, min (w, request.x0));
-       real_area.x1 = max (0.0, min (w, request.x1));
-       real_area.y0 = max (0.0, min (h, request.y0));
-       real_area.y1 = max (0.0, min (h, request.y1));
+       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.