2 Copyright (C) 2011-2013 Paul Davis
3 Author: Carl Hetherington <cth@carlh.net>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 /** @file canvas/canvas.h
21 * @brief Declaration of the main canvas classes.
24 #ifndef __CANVAS_CANVAS_H__
25 #define __CANVAS_CANVAS_H__
29 #include <gdkmm/window.h>
30 #include <gtkmm/eventbox.h>
31 #include <gtkmm/alignment.h>
32 #include <cairomm/surface.h>
33 #include <cairomm/context.h>
35 #include "pbd/signals.h"
37 #include "canvas/visibility.h"
39 #include "canvas/root_group.h"
41 namespace ArdourCanvas
47 /** The base class for our different types of canvas.
49 * A canvas is an area which holds a collection of canvas items, which in
50 * turn represent shapes, text, etc.
52 * The canvas has an arbitrarily large area, and is addressed in coordinates
53 * of screen pixels, with an origin of (0, 0) at the top left. x increases
54 * rightwards and y increases downwards.
57 class LIBCANVAS_API Canvas
63 /** called to request a redraw of an area of the canvas */
64 virtual void request_redraw (Rect const &) = 0;
65 /** called to ask the canvas to request a particular size from its host */
66 virtual void request_size (Duple) = 0;
67 /** called to ask the canvas' host to `grab' an item */
68 virtual void grab (Item *) = 0;
69 /** called to ask the canvas' host to `ungrab' any grabbed item */
70 virtual void ungrab () = 0;
72 /** called to ask the canvas' host to keyboard focus on an item */
73 virtual void focus (Item *) = 0;
74 /** called to ask the canvas' host to drop keyboard focus on an item */
75 virtual void unfocus (Item*) = 0;
77 void render (Rect const &, Cairo::RefPtr<Cairo::Context> const &) const;
79 /** @return root group */
84 /** Called when an item is being destroyed */
85 virtual void item_going_away (Item *, boost::optional<Rect>) {}
86 void item_shown_or_hidden (Item *);
87 void item_visual_property_changed (Item*);
88 void item_changed (Item *, boost::optional<Rect>);
89 void item_moved (Item *, boost::optional<Rect>);
91 virtual Cairo::RefPtr<Cairo::Context> context () = 0;
93 Rect canvas_to_window (Rect const&, bool rounded = true) const;
94 Rect window_to_canvas (Rect const&) const;
95 Duple canvas_to_window (Duple const&, bool rounded = true) const;
96 Duple window_to_canvas (Duple const&) const;
98 void canvas_to_window (Coord cx, Coord cy, Coord& wx, Coord& wy) {
99 Duple d = canvas_to_window (Duple (cx, cy));
104 void window_to_canvas (Coord wx, Coord wy, Coord& cx, Coord& cy) {
105 Duple d = window_to_canvas (Duple (wx, wy));
110 void scroll_to (Coord x, Coord y);
111 void set_global_scroll (bool);
113 virtual Rect visible_area () const = 0;
117 std::string indent() const;
118 std::string render_indent() const;
119 void dump (std::ostream&) const;
122 void queue_draw_item_area (Item *, Rect);
124 /** our root group */
127 Duple _scroll_offset;
130 virtual void pick_current_item (int state) = 0;
131 virtual void pick_current_item (Duple const &, int state) = 0;
134 /** A canvas which renders onto a GTK EventBox */
135 class LIBCANVAS_API GtkCanvas : public Canvas, public Gtk::EventBox
140 void request_redraw (Rect const &);
141 void request_size (Duple);
145 void unfocus (Item*);
147 Cairo::RefPtr<Cairo::Context> context ();
149 Rect visible_area () const;
152 bool on_expose_event (GdkEventExpose *);
153 bool on_button_press_event (GdkEventButton *);
154 bool on_button_release_event (GdkEventButton* event);
155 bool on_motion_notify_event (GdkEventMotion *);
156 bool on_enter_notify_event (GdkEventCrossing*);
157 bool on_leave_notify_event (GdkEventCrossing*);
159 bool button_handler (GdkEventButton *);
160 bool motion_notify_handler (GdkEventMotion *);
161 bool deliver_event (GdkEvent *);
162 void deliver_enter_leave (Duple const & point, int state);
164 void pick_current_item (int state);
165 void pick_current_item (Duple const &, int state);
168 void item_going_away (Item *, boost::optional<Rect>);
169 bool send_leave_event (Item const *, double, double) const;
171 /** Item currently chosen for event delivery based on pointer position */
172 Item * _current_item;
173 /** Item pending as _current_item */
174 Item * _new_current_item;
175 /** the item that is currently grabbed, or 0 */
176 Item * _grabbed_item;
177 /** the item that currently has key focus or 0 */
178 Item * _focused_item;
181 /** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for
184 * This provides a GtkCanvas that can be scrolled. It does NOT implement the
185 * Gtk::Scrollable interface.
187 class LIBCANVAS_API GtkCanvasViewport : public Gtk::Alignment
190 GtkCanvasViewport (Gtk::Adjustment &, Gtk::Adjustment &);
192 /** @return our GtkCanvas */
193 GtkCanvas* canvas () {
198 void on_size_request (Gtk::Requisition *);
203 Gtk::Adjustment& hadjustment;
204 Gtk::Adjustment& vadjustment;
211 std::ostream& operator<< (std::ostream&, const ArdourCanvas::Canvas&);