X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fcanvas%2Fcanvas%2Fcanvas.h;h=d1521593cd8c07b5dd23edf1f2a7e4d86cba8a18;hb=30b087ab3d28f1585987fa3f6ae006562ae192e3;hp=3a6659b7f2348543c97dd77bac8d1f5b390c4bfa;hpb=1676789907b95aa8d5bf6cc2ce62aa66a80b9aae;p=ardour.git diff --git a/libs/canvas/canvas/canvas.h b/libs/canvas/canvas/canvas.h index 3a6659b7f2..d1521593cd 100644 --- a/libs/canvas/canvas/canvas.h +++ b/libs/canvas/canvas/canvas.h @@ -33,13 +33,27 @@ #include #include "pbd/signals.h" + +#include "gtkmm2ext/cairo_canvas.h" + +#include "canvas/visibility.h" #include "canvas/root_group.h" +namespace Gtk { + class Window; + class Label; +} + +namespace Pango { + class Context; +} + namespace ArdourCanvas { +struct Rect; -class Rect; -class Group; +class Item; +class ScrollGroup; /** The base class for our different types of canvas. * @@ -50,14 +64,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; @@ -73,64 +87,111 @@ public: void render (Rect const &, Cairo::RefPtr const &) const; + void prepare_for_render (Rect const &) const; + + gint64 get_last_render_start_timestamp () const { return _last_render_start_timestamp; } + + gint64 get_microseconds_since_render_start () const; + /** @return root group */ - Group* root () { + Item* root () { return &_root; } + void set_background_color (Gtkmm2ext::Color); + Gtkmm2ext::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 *); + virtual void item_going_away (Item *, Rect) {} + virtual void item_shown_or_hidden (Item *); void item_visual_property_changed (Item*); - void item_changed (Item *, boost::optional); - void item_moved (Item *, boost::optional); - - virtual Cairo::RefPtr context () = 0; + void item_changed (Item *, Rect); + void item_moved (Item *, Rect); - Rect canvas_to_window (Rect const&) const; - Rect window_to_canvas (Rect const&) const; - Duple canvas_to_window (Duple const&) const; - Duple window_to_canvas (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) { + void canvas_to_window (Coord cx, Coord cy, Coord& wx, Coord& wy) { Duple d = canvas_to_window (Duple (cx, cy)); wx = d.x; wy = d.y; - } + } - void window_to_canvas (Coord wx, Coord wy, Coord& cx, Coord& cy) { + void window_to_canvas (Coord wx, Coord wy, Coord& cx, Coord& cy) { Duple d = window_to_canvas (Duple (wx, wy)); cx = d.x; cy = d.y; - } + } + + void scroll_to (Coord x, Coord y); + 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; + + sigc::signal PreRender; + + /** 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 () {} - void scroll_to (Coord x, Coord y); - virtual Rect visible_area () const = 0; + /** Set the timeout used to display tooltips, in milliseconds + */ + static void set_tooltip_timeout (uint32_t msecs); + + virtual Glib::RefPtr get_pango_context() = 0; - void zoomed(); - - std::string indent() const; - std::string render_indent() const; - void dump (std::ostream&) const; - protected: - void queue_draw_item_area (Item *, Rect); - - /** our root group */ - RootGroup _root; + Root _root; + Gtkmm2ext::Color _bg_color; - Coord _scroll_offset_x; - Coord _scroll_offset_y; + mutable gint64 _last_render_start_timestamp; - virtual void enter_leave_items (int state) = 0; - virtual void enter_leave_items (Duple const &, int state) = 0; + 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; + + 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 Gtkmm2ext::CairoCanvas { public: GtkCanvas (); + ~GtkCanvas () { _in_dtor = true ; } + + void use_nsglview (); void request_redraw (Rect const &); void request_size (Duple); @@ -139,48 +200,97 @@ 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 (); + + void queue_draw (); + void queue_draw_area (int x, int y, int width, int height); + + Glib::RefPtr get_pango_context(); + + void render (Cairo::RefPtr const & ctx, cairo_rectangle_t* r) + { + ArdourCanvas::Rect rect (r->x, r->y, r->width + r->x, r->height + r->y); + Canvas::render (rect, ctx); + } + + void prepare_for_render () const; + + uint32_t background_color() { return Canvas::background_color (); } 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 on_key_press_event (GdkEventKey*); - bool on_key_release_event (GdkEventKey*); - + bool on_enter_notify_event (GdkEventCrossing*); + bool on_leave_notify_event (GdkEventCrossing*); + void on_map(); + void on_unmap(); + + void on_realize (); + bool button_handler (GdkEventButton *); bool motion_notify_handler (GdkEventMotion *); 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); + void item_going_away (Item *, Rect); + void item_shown_or_hidden (Item *); bool send_leave_event (Item const *, double, double) const; - /** Item currently chosen for event delivery based on pointer position */ - Item const * _current_item; - /** Item pending as _current_item */ - Item const * _new_current_item; + 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; + + void* _nsglview; }; /** 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 &); @@ -196,10 +306,10 @@ protected: private: /** our GtkCanvas */ GtkCanvas _canvas; - Gtk::Adjustment& hadjustment; - Gtk::Adjustment& vadjustment; + Gtk::Adjustment& hadjustment; + Gtk::Adjustment& vadjustment; - void scrolled (); + void scrolled (); }; }