gtk/src/tree_model.hpp

   1 #ifndef __TREE_MODEL_HPP__
   2 #define __TREE_MODEL_HPP__
   3
   4 #include <vector>
   5 #include <gtkmm/drawingarea.h>
   6 #include <cairomm/context.h>
   7 #include <libglademm.h>
   8
   9 #include "alignment.hpp"
  10 #include "word.hpp"
  11 #include "drawable.hpp"
  12 #include "edge.hpp"
  13 #include "vertex.hpp"
  14
  15 class TreeModel : public Gtk::DrawingArea
  16 {
  17 public:
  18         typedef sigc::signal<void, const Word &> word_selected_signal_t;
  19
  20         TreeModel(GtkDrawingArea *cobject, Glib::RefPtr<Gnome::Glade::Xml> &glade);
  21         ~TreeModel(void);
  22         void clear(void);
  23         void add_alignment(Alignment &alignment);
  24         void increase_hscale(void);
  25         void increase_vscale(void);
  26         void decrease_hscale(void);
  27         void decrease_vscale(void);
  28         word_selected_signal_t get_word_selected_signal(void) const;
  29 protected:
  30         bool on_expose_event(GdkEventExpose *event);
  31         bool on_button_press_event(GdkEventButton *event);
  32         bool on_button_release_event(GdkEventButton *event);
  33         bool on_motion_notify_event(GdkEventMotion *event);
  34         bool on_key_release_event(GdkEventKey *event);
  35 private:
  36         void _clear_vertices(std::vector<Vertex *> &vertices);
  37         void _clear_edges(std::vector<Edge *> &edges);
  38         void _clear_selected(void);
  39         void _add_source(void);
  40         void _add_target(void);
  41         void _add_word(Word &word, bool source);
  42         void _add_edges(void);
  43         void _invalidate_window(void);
  44         void _invalidate_vertex(Drawable *v, bool immediate);
  45         void _invalidate_edge(Drawable *e, bool immediate);
  46         void _invalidate_rect(gint x, gint y, gint width, gint height, bool immediate);
  47         template <typename T>
  48         T _highlight(std::vector<T> &obj, gdouble x, gdouble y);
  49         template <typename T>
  50         T _select(std::vector<T> &obj, gdouble x, gdouble y);
  51         Edge *_drag(std::vector<Edge *> &obj, gdouble x, gdouble y);
  52         gint _c2d_x(gdouble x) const;
  53         gint _c2d_y(gdouble y) const;
  54         gint _c2d_w(gdouble w) const;
  55         gint _c2d_h(gdouble h) const;
  56         gdouble _d2c_x(gdouble x) const;
  57         gdouble _d2c_y(gdouble y) const;
  58         gdouble _d2c_w(gdouble w) const;
  59         gdouble _d2c_h(gdouble h) const;
  60
  61         word_selected_signal_t _word_selected_signal;
  62
  63         // Layout details
  64         const gdouble _SENTENCE_SPACING;
  65         const gdouble _WORD_SPACING;
  66         const gdouble _SCALING_STEP;
  67         gdouble _xc;
  68         gdouble _yc;
  69         gdouble _hscale;
  70         gdouble _vscale;
  71
  72         Cairo::RefPtr<Cairo::Context> _cr;
  73         Alignment *_alignment;
  74         std::vector<Vertex *> _source;
  75         std::vector<Vertex *> _target;
  76         std::vector<Node *> _nodes;
  77         std::vector<Edge *> _edges;
  78         Drawable *_highlighted;
  79         std::vector<Node *> _selected;
  80         Node *_dragging_node;
  81         Edge *_dragging_edge;
  82 };
  83
  84 inline void TreeModel::increase_hscale(void)
  85 {
  86         _hscale += _SCALING_STEP;
  87
  88         _invalidate_window();
  89 }
  90
  91 inline void TreeModel::increase_vscale(void)
  92 {
  93         _vscale += _SCALING_STEP;
  94
  95         _invalidate_window();
  96 }
  97
  98 inline void TreeModel::decrease_hscale(void)
  99 {
 100         if ((_hscale - _SCALING_STEP) < 0.1) {
 101                 return;
 102         }
 103
 104         _hscale -= _SCALING_STEP;
 105
 106         _invalidate_window();
 107 }
 108
 109 inline void TreeModel::decrease_vscale(void)
 110 {
 111         if ((_vscale - _SCALING_STEP) < 0.1) {
 112                 return;
 113         }
 114
 115         _vscale -= _SCALING_STEP;
 116
 117         _invalidate_window();
 118 }
 119
 120 inline
 121 TreeModel::word_selected_signal_t TreeModel::get_word_selected_signal(void) const
 122 {
 123         return _word_selected_signal;
 124 }
 125
 126 inline gint TreeModel::_c2d_x(gdouble x) const
 127 {
 128         gdouble y = 0;
 129
 130         _cr->user_to_device(x, y);
 131
 132         return gint(x);
 133 }
 134
 135 inline gint TreeModel::_c2d_y(gdouble y) const
 136 {
 137         gdouble x = 0;
 138
 139         _cr->user_to_device(x, y);
 140
 141         return gint(y);
 142 }
 143
 144 inline gint TreeModel::_c2d_w(gdouble w) const
 145 {
 146         gdouble h = 0;
 147
 148         _cr->user_to_device_distance(w, h);
 149
 150         return gint(w);
 151 }
 152
 153 inline gint TreeModel::_c2d_h(gdouble h) const
 154 {
 155         gdouble w = 0;
 156
 157         _cr->user_to_device_distance(w, h);
 158
 159         return gint(h);
 160 }
 161
 162 inline gdouble TreeModel::_d2c_x(gdouble x) const
 163 {
 164         gdouble y = 0;
 165
 166         _cr->device_to_user(x, y);
 167
 168         return x;
 169 }
 170
 171 inline gdouble TreeModel::_d2c_y(gdouble y) const
 172 {
 173         gdouble x = 0;
 174
 175         _cr->device_to_user(x, y);
 176
 177         return y;
 178 }
 179
 180 inline gdouble TreeModel::_d2c_w(gdouble w) const
 181 {
 182         gdouble h = 0;
 183
 184         _cr->device_to_user_distance(w, h);
 185
 186         return w;
 187 }
 188
 189 inline gdouble TreeModel::_d2c_h(gdouble h) const
 190 {
 191         gdouble w = 0;
 192
 193         _cr->device_to_user_distance(w, h);
 194
 195         return h;
 196 }
 197
 198 #endif