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 <gdkmm/window.h>
  28 #include <gtkmm/eventbox.h>
  29 #include <gtkmm/alignment.h>
  30 #include <cairomm/surface.h>
  31 #include <cairomm/context.h>
  32 #include "pbd/signals.h"
  33 #include "canvas/root_group.h"
  34
  35 namespace ArdourCanvas
  36 {
  37
  38 class Rect;
  39 class Group;
  40
  41 /** The base class for our different types of canvas.
  42  *
  43  *  A canvas is an area which holds a collection of canvas items, which in
  44  *  turn represent shapes, text, etc.
  45  *
  46  *  The canvas has an arbitrarily large area, and is addressed in coordinates
  47  *  of screen pixels, with an origin of (0, 0) at the top left.  x increases
  48  *  rightwards and y increases downwards.
  49  */
  50
  51 class Canvas
  52 {
  53 public:
  54         Canvas ();
  55         virtual ~Canvas () {}
  56
  57         /** called to request a redraw of an area of the canvas */
  58         virtual void request_redraw (Rect const &) = 0;
  59         /** called to ask the canvas to request a particular size from its host */
  60         virtual void request_size (Duple) = 0;
  61         /** called to ask the canvas' host to `grab' an item */
  62         virtual void grab (Item *) = 0;
  63         /** called to ask the canvas' host to `ungrab' any grabbed item */
  64         virtual void ungrab () = 0;
  65
  66         void render (Rect const &, Cairo::RefPtr<Cairo::Context> const &) const;
  67
  68         /** @return root group */
  69         Group* root () {
  70                 return &_root;
  71         }
  72
  73         /** Called when an item is being destroyed */
  74         virtual void item_going_away (Item *, boost::optional<Rect>) {}
  75         void item_shown_or_hidden (Item *);
  76         void item_visual_property_changed (Item*);
  77         void item_changed (Item *, boost::optional<Rect>);
  78         void item_moved (Item *, boost::optional<Rect>);
  79
  80         virtual Cairo::RefPtr<Cairo::Context> context () = 0;
  81
  82         std::list<Rect> const & renders () const {
  83                 return _renders;
  84         }
  85
  86         void set_log_renders (bool log) {
  87                 _log_renders = log;
  88         }
  89
  90         void scroll_to (Coord x, Coord y);
  91
  92         std::string indent() const;
  93         std::string render_indent() const;
  94         void dump (std::ostream&) const;
  95
  96 protected:
  97         void queue_draw_item_area (Item *, Rect);
  98
  99         /** our root group */
 100         RootGroup _root;
 101
 102         mutable std::list<Rect> _renders;
 103         bool _log_renders;
 104
 105         Coord _scroll_offset_x;
 106         Coord _scroll_offset_y;
 107 };
 108
 109 /** A canvas which renders onto a GTK EventBox */
 110 class GtkCanvas : public Canvas, public Gtk::EventBox
 111 {
 112 public:
 113         GtkCanvas ();
 114
 115         void request_redraw (Rect const &);
 116         void request_size (Duple);
 117         void grab (Item *);
 118         void ungrab ();
 119
 120         Cairo::RefPtr<Cairo::Context> context ();
 121
 122         Rect canvas_to_window (Rect const&) const;
 123         Rect window_to_canvas (Rect const&) const;
 124
 125         Duple canvas_to_window (Duple const&) const;
 126         Duple window_to_canvas (Duple const&) const;
 127
 128 protected:
 129         bool on_expose_event (GdkEventExpose *);
 130         bool on_button_press_event (GdkEventButton *);
 131         bool on_button_release_event (GdkEventButton* event);
 132         bool on_motion_notify_event (GdkEventMotion *);
 133
 134         bool button_handler (GdkEventButton *);
 135         bool motion_notify_handler (GdkEventMotion *);
 136         bool deliver_event (Duple, GdkEvent *);
 137
 138 private:
 139         void item_going_away (Item *, boost::optional<Rect>);
 140         bool send_leave_event (Item const *, double, double) const;
 141
 142
 143         /** the item that the mouse is currently over, or 0 */
 144         Item const * _current_item;
 145         /** the item that is currently grabbed, or 0 */
 146         Item const * _grabbed_item;
 147 };
 148
 149 /** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for
 150  *   scrolling.
 151  *
 152  * This provides a GtkCanvas that can be scrolled. It does NOT implement the
 153  * Gtk::Scrollable interface.
 154  */
 155 class GtkCanvasViewport : public Gtk::Alignment
 156 {
 157 public:
 158         GtkCanvasViewport (Gtk::Adjustment &, Gtk::Adjustment &);
 159
 160         /** @return our GtkCanvas */
 161         GtkCanvas* canvas () {
 162                 return &_canvas;
 163         }
 164
 165         void window_to_canvas (int, int, Coord &, Coord &) const;
 166         Rect visible_area () const;
 167
 168 protected:
 169         void on_size_request (Gtk::Requisition *);
 170
 171 private:
 172         /** our GtkCanvas */
 173         GtkCanvas _canvas;
 174         Gtk::Adjustment& hadjustment;
 175         Gtk::Adjustment& vadjustment;
 176
 177         void scrolled ();
 178 };
 179
 180 }
 181
 182 std::ostream& operator<< (std::ostream&, const ArdourCanvas::Canvas&);
 183
 184 #endif