libs/canvas/canvas/canvas.h

   1 /*
   2     Copyright (C) 2011-2013 Paul Davis
   3     Author: Carl Hetherington <cth@carlh.net>
   4
   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.
   9
  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.
  14
  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.
  18 */
  19
  20 /** @file  canvas/canvas.h
  21  *  @brief Declaration of the main canvas classes.
  22  */
  23
  24 #ifndef __CANVAS_CANVAS_H__
  25 #define __CANVAS_CANVAS_H__
  26
  27 #include <set>
  28
  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>
  34
  35 #include "pbd/signals.h"
  36 #include "canvas/root_group.h"
  37
  38 namespace ArdourCanvas
  39 {
  40
  41 class Rect;
  42 class Group;
  43
  44 /** The base class for our different types of canvas.
  45  *
  46  *  A canvas is an area which holds a collection of canvas items, which in
  47  *  turn represent shapes, text, etc.
  48  *
  49  *  The canvas has an arbitrarily large area, and is addressed in coordinates
  50  *  of screen pixels, with an origin of (0, 0) at the top left.  x increases
  51  *  rightwards and y increases downwards.
  52  */
  53
  54 class Canvas
  55 {
  56 public:
  57         Canvas ();
  58         virtual ~Canvas () {}
  59
  60         /** called to request a redraw of an area of the canvas */
  61         virtual void request_redraw (Rect const &) = 0;
  62         /** called to ask the canvas to request a particular size from its host */
  63         virtual void request_size (Duple) = 0;
  64         /** called to ask the canvas' host to `grab' an item */
  65         virtual void grab (Item *) = 0;
  66         /** called to ask the canvas' host to `ungrab' any grabbed item */
  67         virtual void ungrab () = 0;
  68
  69         /** called to ask the canvas' host to keyboard focus on an item */
  70         virtual void focus (Item *) = 0;
  71         /** called to ask the canvas' host to drop keyboard focus on an item */
  72         virtual void unfocus (Item*) = 0;
  73
  74         void render (Rect const &, Cairo::RefPtr<Cairo::Context> const &) const;
  75
  76         /** @return root group */
  77         Group* root () {
  78                 return &_root;
  79         }
  80
  81         /** Called when an item is being destroyed */
  82         virtual void item_going_away (Item *, boost::optional<Rect>) {}
  83         void item_shown_or_hidden (Item *);
  84         void item_visual_property_changed (Item*);
  85         void item_changed (Item *, boost::optional<Rect>);
  86         void item_moved (Item *, boost::optional<Rect>);
  87
  88         virtual Cairo::RefPtr<Cairo::Context> context () = 0;
  89
  90         Rect canvas_to_window (Rect const&) const;
  91         Rect window_to_canvas (Rect const&) const;
  92         Duple canvas_to_window (Duple const&) const;
  93         Duple window_to_canvas (Duple const&) const;
  94
  95         void canvas_to_window (Coord cx, Coord cy, Coord& wx, Coord& wy) {
  96                 Duple d = canvas_to_window (Duple (cx, cy));
  97                 wx = d.x;
  98                 wy = d.y;
  99         }
 100
 101         void window_to_canvas (Coord wx, Coord wy, Coord& cx, Coord& cy) {
 102                 Duple d = window_to_canvas (Duple (wx, wy));
 103                 cx = d.x;
 104                 cy = d.y;
 105         }
 106
 107         void scroll_to (Coord x, Coord y);
 108         virtual Rect visible_area () const = 0;
 109
 110         std::string indent() const;
 111         std::string render_indent() const;
 112         void dump (std::ostream&) const;
 113
 114 protected:
 115         void queue_draw_item_area (Item *, Rect);
 116
 117         /** our root group */
 118         RootGroup _root;
 119
 120         Coord _scroll_offset_x;
 121         Coord _scroll_offset_y;
 122
 123         virtual void enter_leave_items (int state) = 0;
 124         virtual void enter_leave_items (Duple const &, int state) = 0;
 125 };
 126
 127 /** A canvas which renders onto a GTK EventBox */
 128 class GtkCanvas : public Canvas, public Gtk::EventBox
 129 {
 130 public:
 131         GtkCanvas ();
 132
 133         void request_redraw (Rect const &);
 134         void request_size (Duple);
 135         void grab (Item *);
 136         void ungrab ();
 137         void focus (Item *);
 138         void unfocus (Item*);
 139
 140         Cairo::RefPtr<Cairo::Context> context ();
 141
 142         Rect visible_area () const;
 143
 144 protected:
 145         bool on_expose_event (GdkEventExpose *);
 146         bool on_button_press_event (GdkEventButton *);
 147         bool on_button_release_event (GdkEventButton* event);
 148         bool on_motion_notify_event (GdkEventMotion *);
 149         bool on_enter_notify_event (GdkEventCrossing*);
 150         bool on_leave_notify_event (GdkEventCrossing*);
 151
 152         bool button_handler (GdkEventButton *);
 153         bool motion_notify_handler (GdkEventMotion *);
 154         bool deliver_event (Duple, GdkEvent *);
 155
 156         void enter_leave_items (int state);
 157         void enter_leave_items (Duple const &, int state);
 158
 159 private:
 160         void item_going_away (Item *, boost::optional<Rect>);
 161         bool send_leave_event (Item const *, double, double) const;
 162
 163         /** Items that the pointer is currently within */
 164         std::set<Item const *> within_items;
 165         /** the item that is currently grabbed, or 0 */
 166         Item const * _grabbed_item;
 167         /** the item that currently has key focus or 0 */
 168         Item const * _focused_item;
 169 };
 170
 171 /** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for
 172  *   scrolling.
 173  *
 174  * This provides a GtkCanvas that can be scrolled. It does NOT implement the
 175  * Gtk::Scrollable interface.
 176  */
 177 class GtkCanvasViewport : public Gtk::Alignment
 178 {
 179 public:
 180         GtkCanvasViewport (Gtk::Adjustment &, Gtk::Adjustment &);
 181
 182         /** @return our GtkCanvas */
 183         GtkCanvas* canvas () {
 184                 return &_canvas;
 185         }
 186
 187 protected:
 188         void on_size_request (Gtk::Requisition *);
 189
 190 private:
 191         /** our GtkCanvas */
 192         GtkCanvas _canvas;
 193         Gtk::Adjustment& hadjustment;
 194         Gtk::Adjustment& vadjustment;
 195
 196         void scrolled ();
 197 };
 198
 199 }
 200
 201 std::ostream& operator<< (std::ostream&, const ArdourCanvas::Canvas&);
 202
 203 #endif