change Metric element of a Canvas::Ruler item into a pointer internally

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

diff --git a/libs/canvas/canvas/canvas.h b/libs/canvas/canvas/canvas.h
index 981ea05346cc6b0958446910c074e7a2d5cf60a8..c3ab322b67cf12079c277743c424650151d69f8d 100644 (file)
--- a/libs/canvas/canvas/canvas.h
+++ b/libs/canvas/canvas/canvas.h
@@ -33,13 +33,17 @@
 #include <cairomm/context.h>
 
 #include "pbd/signals.h"
+
+#include "canvas/visibility.h"
+
 #include "canvas/root_group.h"
 
 namespace ArdourCanvas
 {
+struct Rect;
 
-class Rect;
-class Group;   
+class Item;
+class ScrollGroup;
 
 /** The base class for our different types of canvas.
  *
@@ -51,13 +55,13 @@ class Group;
  *  rightwards and y increases downwards.
  */
        
-class Canvas
+class LIBCANVAS_API Canvas
 {
 public:
        Canvas ();
        virtual ~Canvas () {}
 
-       /** called to request a redraw of an area of the canvas */
+       /** called to request a redraw of an area of the canvas in WINDOW coordinates */
        virtual void request_redraw (Rect const &) = 0;
        /** called to ask the canvas to request a particular size from its host */
        virtual void request_size (Duple) = 0;
@@ -74,7 +78,7 @@ public:
        void render (Rect const &, Cairo::RefPtr<Cairo::Context> const &) const;
 
        /** @return root group */
-       Group* root () {
+       Item* root () {
                return &_root;
        }
 
@@ -87,9 +91,7 @@ public:
 
         virtual Cairo::RefPtr<Cairo::Context> context () = 0;
 
-        Rect canvas_to_window (Rect const&) const;
-        Rect window_to_canvas (Rect const&) const;
-        Duple canvas_to_window (Duple const&) const;
+        Duple canvas_to_window (Duple const&, bool rounded = true) const;
         Duple window_to_canvas (Duple const&) const;
 
         void canvas_to_window (Coord cx, Coord cy, Coord& wx, Coord& wy) {
@@ -105,29 +107,54 @@ public:
         }
 
         void scroll_to (Coord x, Coord y);
-        virtual Rect visible_area () const = 0;
+       void add_scroller (ScrollGroup& i);
+        
+        virtual Rect  visible_area () const = 0;
+        virtual Coord width () const = 0;
+        virtual Coord height () const = 0;
+
+       /** Store the coordinates of the mouse pointer in window coordinates in
+          @param winpos. Return true if the position was within the window,
+          false otherwise.
+       */
+       virtual bool get_mouse_position (Duple& winpos) const = 0;
+
+       /** Signal to be used by items that need to track the mouse position
+          within the window.
+       */
+       sigc::signal<void,Duple const&> MouseMotion;
+
+       /** Ensures that the position given by @param winpos (in window
+           coordinates) is within the current window area, possibly reduced by
+           @param border.
+       */
+       Duple clamp_to_window (Duple const& winpos, Duple border = Duple());
 
         void zoomed();
     
         std::string indent() const;
         std::string render_indent() const;
         void dump (std::ostream&) const;
+
+       /** Ask the canvas to pick the current item again, and generate
+           an enter event for it.
+       */
+       virtual void re_enter () = 0;
     
 protected:
        void queue_draw_item_area (Item *, Rect);
        
-       /** our root group */
-       RootGroup _root;
+       /** our root item */
+       Root _root;
 
-        Coord _scroll_offset_x;
-        Coord _scroll_offset_y;
+        virtual void pick_current_item (int state) = 0;
+        virtual void pick_current_item (Duple const &, int state) = 0;
 
-        virtual void enter_leave_items (int state) = 0;
-        virtual void enter_leave_items (Duple const &, int state) = 0;
+       std::list<ScrollGroup*> scrollers;
 };
 
 /** A canvas which renders onto a GTK EventBox */
-class GtkCanvas : public Canvas, public Gtk::EventBox
+class LIBCANVAS_API GtkCanvas : public Canvas, public Gtk::EventBox
 {
 public:
        GtkCanvas ();
@@ -142,8 +169,15 @@ public:
        Cairo::RefPtr<Cairo::Context> context ();
 
        Rect visible_area () const;
+       Coord width() const;
+       Coord height() const;
+
+       bool get_mouse_position (Duple& winpos) const;
+
+       void re_enter ();
 
 protected:
+       bool on_scroll_event (GdkEventScroll *);
        bool on_expose_event (GdkEventExpose *);
        bool on_button_press_event (GdkEventButton *);
        bool on_button_release_event (GdkEventButton* event);
@@ -153,21 +187,24 @@ protected:
        
        bool button_handler (GdkEventButton *);
        bool motion_notify_handler (GdkEventMotion *);
-       bool deliver_event (Duple, GdkEvent *);
-
-        void enter_leave_items (int state);
-        void enter_leave_items (Duple const &, int state);
+        bool deliver_event (GdkEvent *);
+        void deliver_enter_leave (Duple const & point, int state);
+    
+        void pick_current_item (int state);
+        void pick_current_item (Duple const &, int state);
 
 private:
        void item_going_away (Item *, boost::optional<Rect>);
        bool send_leave_event (Item const *, double, double) const;
 
-        /** Items that the pointer is currently within */
-        std::set<Item const *> within_items;
+        /** Item currently chosen for event delivery based on pointer position */
+        Item * _current_item;
+        /** Item pending as _current_item */
+        Item * _new_current_item;
        /** the item that is currently grabbed, or 0 */
-       Item const * _grabbed_item;
+       Item * _grabbed_item;
         /** the item that currently has key focus or 0 */
-       Item const * _focused_item;
+       Item * _focused_item;
 };
 
 /** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for
@@ -176,7 +213,7 @@ private:
  * This provides a GtkCanvas that can be scrolled. It does NOT implement the
  * Gtk::Scrollable interface.
  */
-class GtkCanvasViewport : public Gtk::Alignment
+class LIBCANVAS_API GtkCanvasViewport : public Gtk::Alignment
 {
 public:
        GtkCanvasViewport (Gtk::Adjustment &, Gtk::Adjustment &);