X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fcanvas%2Fcanvas%2Fcanvas.h;h=b818c7eb4170ae38dee28d2fd13eba8a73d958fd;hb=d92686afb4105b84b014372b6feb0ccc454a5171;hp=981ea05346cc6b0958446910c074e7a2d5cf60a8;hpb=59da788793186d90c30b10654bcfd4d20a7d6eb3;p=ardour.git diff --git a/libs/canvas/canvas/canvas.h b/libs/canvas/canvas/canvas.h index 981ea05346..b818c7eb41 100644 --- a/libs/canvas/canvas/canvas.h +++ b/libs/canvas/canvas/canvas.h @@ -33,13 +33,22 @@ #include #include "pbd/signals.h" + +#include "canvas/visibility.h" + #include "canvas/root_group.h" +namespace Gtk { + class Window; + class Label; +} + namespace ArdourCanvas { +struct Rect; -class Rect; -class Group; +class Item; +class ScrollGroup; /** The base class for our different types of canvas. * @@ -50,14 +59,14 @@ class Group; * of screen pixels, with an origin of (0, 0) at the top left. x increases * 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,10 +83,13 @@ public: void render (Rect const &, Cairo::RefPtr const &) const; /** @return root group */ - Group* root () { + Item* root () { return &_root; } + void set_background_color (ArdourCanvas::Color); + ArdourCanvas::Color background_color() const { return _bg_color; } + /** Called when an item is being destroyed */ virtual void item_going_away (Item *, boost::optional) {} void item_shown_or_hidden (Item *); @@ -85,11 +97,7 @@ public: void item_changed (Item *, boost::optional); void item_moved (Item *, boost::optional); - virtual Cairo::RefPtr 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,32 +113,66 @@ 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 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; + + virtual void start_tooltip_timeout (Item*) {} + virtual void stop_tooltip_timeout () {} + + /** Set the timeout used to display tooltips, in milliseconds + */ + static void set_tooltip_timeout (uint32_t msecs); + protected: - void queue_draw_item_area (Item *, Rect); - - /** our root group */ - RootGroup _root; + Root _root; + Color _bg_color; - Coord _scroll_offset_x; - Coord _scroll_offset_y; + static uint32_t tooltip_timeout_msecs; + + void queue_draw_item_area (Item *, Rect); + 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 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 (); + ~GtkCanvas () { _in_dtor = true ; } void request_redraw (Rect const &); void request_size (Duple); @@ -139,44 +181,75 @@ public: void focus (Item *); void unfocus (Item*); - Cairo::RefPtr context (); - Rect visible_area () const; + Coord width() const; + Coord height() const; + + bool get_mouse_position (Duple& winpos) const; + + void set_single_exposure (bool s) { _single_exposure = s; } + bool single_exposure () { return _single_exposure; } + + void re_enter (); + + void start_tooltip_timeout (Item*); + void stop_tooltip_timeout (); protected: + void on_size_allocate (Gtk::Allocation&); + bool on_scroll_event (GdkEventScroll *); bool on_expose_event (GdkEventExpose *); + bool on_key_press_event (GdkEventKey *); + bool on_key_release_event (GdkEventKey *); bool on_button_press_event (GdkEventButton *); bool on_button_release_event (GdkEventButton* event); bool on_motion_notify_event (GdkEventMotion *); bool on_enter_notify_event (GdkEventCrossing*); bool on_leave_notify_event (GdkEventCrossing*); - + bool button_handler (GdkEventButton *); bool motion_notify_handler (GdkEventMotion *); - bool deliver_event (Duple, GdkEvent *); + bool deliver_event (GdkEvent *); + void deliver_enter_leave (Duple const & point, int state); - void enter_leave_items (int state); - void enter_leave_items (Duple const &, int state); + void pick_current_item (int state); + void pick_current_item (Duple const &, int state); private: void item_going_away (Item *, boost::optional); bool send_leave_event (Item const *, double, double) const; - /** Items that the pointer is currently within */ - std::set within_items; + Cairo::RefPtr canvas_image; + + /** 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; + + bool _single_exposure; + + sigc::connection tooltip_timeout_connection; + Item* current_tooltip_item; + Gtk::Window* tooltip_window; + Gtk::Label* tooltip_label; + bool show_tooltip (); + void hide_tooltip (); + bool really_start_tooltip_timeout (); + + bool _in_dtor; }; /** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for - * scrolling. + * scrolling. * * 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 &);