gtk2_ardour/port_matrix_body.cc

   1 /*
   2     Copyright (C) 2002-2009 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <iostream>
  21 #include "ardour/bundle.h"
  22 #include "ardour/types.h"
  23 #include "port_matrix_body.h"
  24 #include "port_matrix.h"
  25 #include "port_matrix_column_labels.h"
  26 #include "port_matrix_row_labels.h"
  27 #include "port_matrix_grid.h"
  28
  29 PortMatrixBody::PortMatrixBody (PortMatrix* p)
  30         : _matrix (p),
  31           _xoffset (0),
  32           _yoffset (0),
  33           _mouse_over_grid (false)
  34 {
  35         _column_labels = new PortMatrixColumnLabels (p, this);
  36         _row_labels = new PortMatrixRowLabels (p, this);
  37         _grid = new PortMatrixGrid (p, this);
  38
  39         modify_bg (Gtk::STATE_NORMAL, Gdk::Color ("#00000"));
  40         add_events (Gdk::LEAVE_NOTIFY_MASK | Gdk::POINTER_MOTION_MASK);
  41 }
  42
  43
  44 PortMatrixBody::~PortMatrixBody ()
  45 {
  46         delete _column_labels;
  47         delete _row_labels;
  48         delete _grid;
  49 }
  50
  51 bool
  52 PortMatrixBody::on_expose_event (GdkEventExpose* event)
  53 {
  54         Gdk::Rectangle const exposure (
  55                 event->area.x, event->area.y, event->area.width, event->area.height
  56                 );
  57
  58         bool intersects;
  59
  60         Gdk::Rectangle r = exposure;
  61         /* the get_pixmap call may cause things to be rerendered and sizes to change,
  62            so fetch the pixmaps before calculating where to put it */
  63         GdkPixmap* p = _column_labels->get_pixmap (get_window()->gobj());
  64         r.intersect (_column_labels->parent_rectangle(), intersects);
  65
  66         if (intersects) {
  67
  68                 gdk_draw_drawable (
  69                         get_window()->gobj(),
  70                         get_style()->get_fg_gc (Gtk::STATE_NORMAL)->gobj(),
  71                         p,
  72                         _column_labels->parent_to_component_x (r.get_x()),
  73                         _column_labels->parent_to_component_y (r.get_y()),
  74                         r.get_x(),
  75                         r.get_y(),
  76                         r.get_width(),
  77                         r.get_height()
  78                         );
  79         }
  80
  81         r = exposure;
  82         p = _row_labels->get_pixmap (get_window()->gobj());
  83         r.intersect (_row_labels->parent_rectangle(), intersects);
  84
  85         if (intersects) {
  86                 gdk_draw_drawable (
  87                         get_window()->gobj(),
  88                         get_style()->get_fg_gc (Gtk::STATE_NORMAL)->gobj(),
  89                         p,
  90                         _row_labels->parent_to_component_x (r.get_x()),
  91                         _row_labels->parent_to_component_y (r.get_y()),
  92                         r.get_x(),
  93                         r.get_y(),
  94                         r.get_width(),
  95                         r.get_height()
  96                         );
  97         }
  98
  99         r = exposure;
 100         p = _grid->get_pixmap (get_window()->gobj());
 101         r.intersect (_grid->parent_rectangle(), intersects);
 102
 103         if (intersects) {
 104                 gdk_draw_drawable (
 105                         get_window()->gobj(),
 106                         get_style()->get_fg_gc (Gtk::STATE_NORMAL)->gobj(),
 107                         p,
 108                         _grid->parent_to_component_x (r.get_x()),
 109                         _grid->parent_to_component_y (r.get_y()),
 110                         r.get_x(),
 111                         r.get_y(),
 112                         r.get_width(),
 113                         r.get_height()
 114                         );
 115         }
 116
 117         cairo_t* cr = gdk_cairo_create (get_window()->gobj());
 118
 119         cairo_save (cr);
 120         set_cairo_clip (cr, _grid->parent_rectangle ());
 121         _grid->draw_extra (cr);
 122         cairo_restore (cr);
 123
 124         cairo_save (cr);
 125         set_cairo_clip (cr, _row_labels->parent_rectangle ());
 126         _row_labels->draw_extra (cr);
 127         cairo_restore (cr);
 128
 129         cairo_save (cr);
 130         set_cairo_clip (cr, _column_labels->parent_rectangle ());
 131         _column_labels->draw_extra (cr);
 132         cairo_restore (cr);
 133
 134         cairo_destroy (cr);
 135
 136         return true;
 137 }
 138
 139 void
 140 PortMatrixBody::on_size_request (Gtk::Requisition *req)
 141 {
 142         std::pair<int, int> const col = _column_labels->dimensions ();
 143         std::pair<int, int> const row = _row_labels->dimensions ();
 144         std::pair<int, int> const grid = _grid->dimensions ();
 145
 146         /* don't ask for the maximum size of our contents, otherwise GTK won't
 147            let the containing window shrink below this size */
 148
 149         req->width = std::min (512, std::max (col.first, grid.first + row.first));
 150         req->height = std::min (512, col.second + grid.second);
 151 }
 152
 153 void
 154 PortMatrixBody::on_size_allocate (Gtk::Allocation& alloc)
 155 {
 156         Gtk::EventBox::on_size_allocate (alloc);
 157
 158         _alloc_width = alloc.get_width ();
 159         _alloc_height = alloc.get_height ();
 160
 161         compute_rectangles ();
 162         _matrix->setup_scrollbars ();
 163 }
 164
 165 void
 166 PortMatrixBody::compute_rectangles ()
 167 {
 168         /* full sizes of components */
 169         std::pair<uint32_t, uint32_t> const col = _column_labels->dimensions ();
 170         std::pair<uint32_t, uint32_t> const row = _row_labels->dimensions ();
 171         std::pair<uint32_t, uint32_t> const grid = _grid->dimensions ();
 172
 173         Gdk::Rectangle col_rect;
 174         Gdk::Rectangle row_rect;
 175         Gdk::Rectangle grid_rect;
 176
 177         if (_matrix->arrangement() == PortMatrix::TOP_TO_RIGHT) {
 178
 179                 /* build from top left */
 180
 181                 col_rect.set_x (0);
 182                 col_rect.set_y (0);
 183                 grid_rect.set_x (0);
 184
 185                 if (_alloc_width > col.first) {
 186                         col_rect.set_width (col.first);
 187                 } else {
 188                         col_rect.set_width (_alloc_width);
 189                 }
 190
 191                 /* move down to y division */
 192
 193                 uint32_t y = 0;
 194                 if (_alloc_height > col.second) {
 195                         y = col.second;
 196                 } else {
 197                         y = _alloc_height;
 198                 }
 199
 200                 col_rect.set_height (y);
 201                 row_rect.set_y (y);
 202                 row_rect.set_height (_alloc_height - y);
 203                 grid_rect.set_y (y);
 204                 grid_rect.set_height (_alloc_height - y);
 205
 206                 /* move right to x division */
 207
 208                 uint32_t x = 0;
 209                 if (_alloc_width > (grid.first + row.first)) {
 210                         x = grid.first;
 211                 } else if (_alloc_width > row.first) {
 212                         x = _alloc_width - row.first;
 213                 }
 214
 215                 grid_rect.set_width (x);
 216                 row_rect.set_x (x);
 217                 row_rect.set_width (_alloc_width - x);
 218
 219
 220         } else if (_matrix->arrangement() == PortMatrix::LEFT_TO_BOTTOM) {
 221
 222                 /* build from bottom right */
 223
 224                 /* move left to x division */
 225
 226                 uint32_t x = 0;
 227                 if (_alloc_width > (grid.first + row.first)) {
 228                         x = grid.first;
 229                 } else if (_alloc_width > row.first) {
 230                         x = _alloc_width - row.first;
 231                 }
 232
 233                 grid_rect.set_x (_alloc_width - x);
 234                 grid_rect.set_width (x);
 235                 col_rect.set_width (col.first - grid.first + x);
 236                 col_rect.set_x (_alloc_width - col_rect.get_width());
 237
 238                 row_rect.set_width (std::min (_alloc_width - x, row.first));
 239                 row_rect.set_x (_alloc_width - x - row_rect.get_width());
 240
 241                 /* move up to the y division */
 242
 243                 uint32_t y = 0;
 244                 if (_alloc_height > col.second) {
 245                         y = col.second;
 246                 } else {
 247                         y = _alloc_height;
 248                 }
 249
 250                 col_rect.set_y (_alloc_height - y);
 251                 col_rect.set_height (y);
 252
 253                 grid_rect.set_height (std::min (grid.second, _alloc_height - y));
 254                 grid_rect.set_y (_alloc_height - y - grid_rect.get_height());
 255
 256                 row_rect.set_height (grid_rect.get_height());
 257                 row_rect.set_y (grid_rect.get_y());
 258         }
 259
 260         _row_labels->set_parent_rectangle (row_rect);
 261         _column_labels->set_parent_rectangle (col_rect);
 262         _grid->set_parent_rectangle (grid_rect);
 263 }
 264
 265 void
 266 PortMatrixBody::setup ()
 267 {
 268         /* Discard any old connections to bundles */
 269
 270         for (std::list<sigc::connection>::iterator i = _bundle_connections.begin(); i != _bundle_connections.end(); ++i) {
 271                 i->disconnect ();
 272         }
 273         _bundle_connections.clear ();
 274
 275         /* Connect to bundles so that we find out when their names change */
 276
 277         ARDOUR::BundleList r = _matrix->rows()->bundles ();
 278         for (ARDOUR::BundleList::iterator i = r.begin(); i != r.end(); ++i) {
 279
 280                 _bundle_connections.push_back (
 281                         (*i)->NameChanged.connect (sigc::mem_fun (*this, &PortMatrixBody::rebuild_and_draw_row_labels))
 282                         );
 283
 284         }
 285
 286         ARDOUR::BundleList c = _matrix->columns()->bundles ();
 287         for (ARDOUR::BundleList::iterator i = c.begin(); i != c.end(); ++i) {
 288                 _bundle_connections.push_back (
 289                         (*i)->NameChanged.connect (sigc::mem_fun (*this, &PortMatrixBody::rebuild_and_draw_column_labels))
 290                         );
 291         }
 292
 293         _column_labels->setup ();
 294         _row_labels->setup ();
 295         _grid->setup ();
 296
 297         set_mouseover (PortMatrixNode ());
 298         compute_rectangles ();
 299 }
 300
 301 uint32_t
 302 PortMatrixBody::full_scroll_width ()
 303 {
 304         return _grid->dimensions().first;
 305
 306 }
 307
 308 uint32_t
 309 PortMatrixBody::alloc_scroll_width ()
 310 {
 311         return _grid->parent_rectangle().get_width();
 312 }
 313
 314 uint32_t
 315 PortMatrixBody::full_scroll_height ()
 316 {
 317         return _grid->dimensions().second;
 318 }
 319
 320 uint32_t
 321 PortMatrixBody::alloc_scroll_height ()
 322 {
 323         return _grid->parent_rectangle().get_height();
 324 }
 325
 326 void
 327 PortMatrixBody::set_xoffset (uint32_t xo)
 328 {
 329         _xoffset = xo;
 330         queue_draw ();
 331 }
 332
 333 void
 334 PortMatrixBody::set_yoffset (uint32_t yo)
 335 {
 336         _yoffset = yo;
 337         queue_draw ();
 338 }
 339
 340 bool
 341 PortMatrixBody::on_button_press_event (GdkEventButton* ev)
 342 {
 343         if (Gdk::Region (_grid->parent_rectangle()).point_in (ev->x, ev->y)) {
 344
 345                 _grid->button_press (
 346                         _grid->parent_to_component_x (ev->x),
 347                         _grid->parent_to_component_y (ev->y),
 348                         ev->button
 349                         );
 350
 351         } else if (Gdk::Region (_row_labels->parent_rectangle()).point_in (ev->x, ev->y)) {
 352
 353                 _row_labels->button_press (
 354                         _row_labels->parent_to_component_x (ev->x),
 355                         _row_labels->parent_to_component_y (ev->y),
 356                         ev->button, ev->time
 357                         );
 358
 359         } else if (Gdk::Region (_column_labels->parent_rectangle()).point_in (ev->x, ev->y)) {
 360
 361                 _column_labels->button_press (
 362                         _column_labels->parent_to_component_x (ev->x),
 363                         _column_labels->parent_to_component_y (ev->y),
 364                         ev->button, ev->time
 365                         );
 366         }
 367
 368         return true;
 369 }
 370
 371 bool
 372 PortMatrixBody::on_button_release_event (GdkEventButton* ev)
 373 {
 374         if (Gdk::Region (_row_labels->parent_rectangle()).point_in (ev->x, ev->y) ||
 375             Gdk::Region (_column_labels->parent_rectangle()).point_in (ev->x, ev->y)) {
 376
 377                 _row_labels->clear_channel_highlights ();
 378                 _column_labels->clear_channel_highlights ();
 379
 380         }
 381
 382         return true;
 383 }
 384
 385 void
 386 PortMatrixBody::rebuild_and_draw_grid ()
 387 {
 388         _grid->require_rebuild ();
 389         queue_draw ();
 390 }
 391
 392 void
 393 PortMatrixBody::rebuild_and_draw_column_labels ()
 394 {
 395         _column_labels->require_rebuild ();
 396         queue_draw ();
 397 }
 398
 399 void
 400 PortMatrixBody::rebuild_and_draw_row_labels ()
 401 {
 402         _row_labels->require_rebuild ();
 403         queue_draw ();
 404 }
 405
 406 bool
 407 PortMatrixBody::on_leave_notify_event (GdkEventCrossing* ev)
 408 {
 409         if (ev->type == GDK_LEAVE_NOTIFY) {
 410                 set_mouseover (PortMatrixNode ());
 411         }
 412
 413         return true;
 414 }
 415
 416 bool
 417 PortMatrixBody::on_motion_notify_event (GdkEventMotion* ev)
 418 {
 419         if (Gdk::Region (_grid->parent_rectangle()).point_in (ev->x, ev->y)) {
 420                 _grid->mouseover_event (
 421                         _grid->parent_to_component_x (ev->x),
 422                         _grid->parent_to_component_y (ev->y)
 423                         );
 424                 _mouse_over_grid = true;
 425         } else {
 426                 if (_mouse_over_grid) {
 427                         set_mouseover (PortMatrixNode ());
 428                         _mouse_over_grid = false;
 429                 }
 430         }
 431
 432         return true;
 433 }
 434
 435 void
 436 PortMatrixBody::set_mouseover (PortMatrixNode const & n)
 437 {
 438         if (n == _mouseover) {
 439                 return;
 440         }
 441
 442         PortMatrixNode old = _mouseover;
 443         _mouseover = n;
 444
 445         _grid->mouseover_changed (old);
 446         _row_labels->mouseover_changed (old);
 447         _column_labels->mouseover_changed (old);
 448 }
 449
 450
 451
 452 void
 453 PortMatrixBody::highlight_associated_channels (int dim, uint32_t N)
 454 {
 455         ARDOUR::BundleChannel bc[2];
 456
 457         ARDOUR::BundleList const a = _matrix->ports(dim)->bundles ();
 458         for (ARDOUR::BundleList::const_iterator i = a.begin(); i != a.end(); ++i) {
 459                 if (N < (*i)->nchannels ()) {
 460                         bc[dim] = ARDOUR::BundleChannel (*i, N);
 461                         break;
 462                 } else {
 463                         N -= (*i)->nchannels ();
 464                 }
 465         }
 466
 467         if (!bc[dim].bundle) {
 468                 return;
 469         }
 470
 471         if (dim == _matrix->column_index()) {
 472                 _column_labels->add_channel_highlight (bc[dim]);
 473         } else {
 474                 _row_labels->add_channel_highlight (bc[dim]);
 475         }
 476
 477         ARDOUR::BundleList const b = _matrix->ports(1 - dim)->bundles ();
 478
 479         for (ARDOUR::BundleList::const_iterator i = b.begin(); i != b.end(); ++i) {
 480                 for (uint32_t j = 0; j < (*i)->nchannels(); ++j) {
 481                         bc[1 - dim] = ARDOUR::BundleChannel (*i, j);
 482                         if (_matrix->get_state (bc) == PortMatrix::ASSOCIATED) {
 483                                 if (dim == _matrix->column_index()) {
 484                                         _row_labels->add_channel_highlight (bc[1 - dim]);
 485                                 } else {
 486                                         _column_labels->add_channel_highlight (bc[1 - dim]);
 487                                 }
 488                         }
 489                 }
 490         }
 491 }
 492
 493 void
 494 PortMatrixBody::set_cairo_clip (cairo_t* cr, Gdk::Rectangle const & r) const
 495 {
 496         cairo_rectangle (cr, r.get_x(), r.get_y(), r.get_width(), r.get_height());
 497         cairo_clip (cr);
 498 }
 499
 500 void
 501 PortMatrixBody::component_size_changed ()
 502 {
 503         compute_rectangles ();
 504         _matrix->setup_scrollbars ();
 505 }
 506