gtk2_ardour/editor_route_list.cc

   1 /*
   2     Copyright (C) 2000 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     $Id$
  19 */
  20
  21 #include <algorithm>
  22 #include <cstdlib>
  23 #include <cmath>
  24
  25 #include "editor.h"
  26 #include "ardour_ui.h"
  27 #include "audio_time_axis.h"
  28 #include "mixer_strip.h"
  29 #include "gui_thread.h"
  30
  31 #include <ardour/route.h>
  32 #include <ardour/audio_track.h>
  33
  34 #include "i18n.h"
  35
  36 using namespace sigc;
  37 using namespace ARDOUR;
  38 using namespace Gtk;
  39
  40 void
  41 Editor::handle_new_route_p (Route* route)
  42 {
  43         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::handle_new_route_p), route));
  44         handle_new_route (*route);
  45 }
  46
  47 void
  48 Editor::handle_new_route (Route& route)
  49 {
  50         TimeAxisView *tv;
  51         AudioTimeAxisView *atv;
  52         TreeModel::Row parent;
  53         TreeModel::Row row;
  54
  55         if (route.hidden()) {
  56                 return;
  57         }
  58
  59         tv = new AudioTimeAxisView (*this, *session, route, track_canvas);
  60
  61 #if 0
  62         if (route_display_model->children().size() == 0) {
  63
  64                 /* set up basic entries */
  65
  66                 TreeModel::Row row;
  67
  68                 row = *(route_display_model->append());  // path = "0"
  69                 row[route_display_columns.text] = _("Busses");
  70                 row[route_display_columns.tv] = 0;
  71                 row = *(route_display_model->append());  // path = "1"
  72                 row[route_display_columns.text] = _("Tracks");
  73                 row[route_display_columns.tv] = 0;
  74
  75         }
  76
  77         if (dynamic_cast<AudioTrack*>(&route) != 0) {
  78                 TreeModel::iterator iter = route_display_model->get_iter ("1");  // audio tracks
  79                 parent = *iter;
  80         } else {
  81                 TreeModel::iterator iter = route_display_model->get_iter ("0");  // busses
  82                 parent = *iter;
  83         }
  84
  85
  86         row = *(route_display_model->append (parent.children()));
  87 #else
  88         row = *(route_display_model->append ());
  89 #endif
  90
  91         row[route_display_columns.text] = route.name();
  92         row[route_display_columns.visible] = tv->marked_for_display();
  93         row[route_display_columns.tv] = tv;
  94
  95         track_views.push_back (tv);
  96
  97         ignore_route_list_reorder = true;
  98
  99         if ((atv = dynamic_cast<AudioTimeAxisView*> (tv)) != 0) {
 100                 /* added a new fresh one at the end */
 101                 if (atv->route().order_key(N_("editor")) == -1) {
 102                         atv->route().set_order_key (N_("editor"), route_display_model->children().size()-1);
 103                 }
 104         }
 105
 106         ignore_route_list_reorder = false;
 107
 108         route.gui_changed.connect (mem_fun(*this, &Editor::handle_gui_changes));
 109
 110         tv->GoingAway.connect (bind (mem_fun(*this, &Editor::remove_route), tv));
 111
 112         editor_mixer_button.set_sensitive(true);
 113 }
 114
 115 void
 116 Editor::handle_gui_changes (const string & what, void *src)
 117 {
 118         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::handle_gui_changes), what, src));
 119
 120         if (what == "track_height") {
 121                 redisplay_route_list ();
 122         }
 123 }
 124
 125
 126 void
 127 Editor::remove_route (TimeAxisView *tv)
 128 {
 129         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::remove_route), tv));
 130
 131
 132         TrackViewList::iterator i;
 133         TreeModel::Children rows = route_display_model->children();
 134         TreeModel::Children::iterator ri;
 135
 136         if ((i = find (track_views.begin(), track_views.end(), tv)) != track_views.end()) {
 137                 track_views.erase (i);
 138         }
 139
 140         for (ri = rows.begin(); ri != rows.end(); ++ri) {
 141                 if ((*ri)[route_display_columns.tv] == tv) {
 142                         route_display_model->erase (ri);
 143                         break;
 144                 }
 145         }
 146         /* since the editor mixer goes away when you remove a route, set the
 147          * button to inacttive
 148          */
 149         editor_mixer_button.set_active(false);
 150
 151         /* and disable if all tracks and/or routes are gone */
 152
 153         if (track_views.size() == 0) {
 154                 editor_mixer_button.set_sensitive(false);
 155         }
 156 }
 157
 158 void
 159 Editor::route_name_changed (TimeAxisView *tv)
 160 {
 161         ENSURE_GUI_THREAD(bind (mem_fun(*this, &Editor::route_name_changed), tv));
 162
 163         TreeModel::Children rows = route_display_model->children();
 164         TreeModel::Children::iterator i;
 165
 166         for (i = rows.begin(); i != rows.end(); ++i) {
 167                 if ((*i)[route_display_columns.tv] == tv) {
 168                         (*i)[route_display_columns.text] = tv->name();
 169                         break;
 170                 }
 171         }
 172
 173 }
 174
 175 void
 176 Editor::hide_track_in_display (TimeAxisView& tv)
 177 {
 178         TreeModel::Children rows = route_display_model->children();
 179         TreeModel::Children::iterator i;
 180
 181         for (i = rows.begin(); i != rows.end(); ++i) {
 182                 if ((*i)[route_display_columns.tv] == &tv) {
 183                         (*i)[route_display_columns.visible] = false;
 184                         break;
 185                 }
 186         }
 187
 188         AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*> (&tv);
 189
 190         if (atv && current_mixer_strip && &(atv->route()) == &(current_mixer_strip->route())) {
 191                 // this will hide the mixer strip
 192                 set_selected_mixer_strip (tv);
 193         }
 194 }
 195
 196 void
 197 Editor::show_track_in_display (TimeAxisView& tv)
 198 {
 199         TreeModel::Children rows = route_display_model->children();
 200         TreeModel::Children::iterator i;
 201
 202         for (i = rows.begin(); i != rows.end(); ++i) {
 203                 if ((*i)[route_display_columns.tv] == &tv) {
 204                         (*i)[route_display_columns.visible] = true;
 205                         tv.set_marked_for_display (true);
 206                         break;
 207                 }
 208         }
 209 }
 210
 211 void
 212 Editor::route_list_reordered (const TreeModel::Path& path,const TreeModel::iterator& iter,int* what)
 213 {
 214         redisplay_route_list ();
 215 }
 216
 217 void
 218 Editor::redisplay_route_list ()
 219 {
 220         TreeModel::Children rows = route_display_model->children();
 221         TreeModel::Children::iterator i;
 222         uint32_t position;
 223         uint32_t order;
 224         int n;
 225
 226         if (no_route_list_redisplay) {
 227                 return;
 228         }
 229
 230         for (n = 0, order = 0, position = 0, i = rows.begin(); i != rows.end(); ++i) {
 231                 TimeAxisView *tv = (*i)[route_display_columns.tv];
 232                 AudioTimeAxisView* at;
 233
 234                 if (tv == 0) {
 235                         // just a "title" row
 236                         continue;
 237                 }
 238
 239                 if (!ignore_route_list_reorder) {
 240
 241                         /* this reorder is caused by user action, so reassign sort order keys
 242                            to tracks.
 243                         */
 244
 245                         if ((at = dynamic_cast<AudioTimeAxisView*> (tv)) != 0) {
 246                                 at->route().set_order_key (N_("editor"), order);
 247                                 ++order;
 248                         }
 249                 }
 250
 251                 bool visible = (*i)[route_display_columns.visible];
 252
 253                 if (visible) {
 254                         tv->set_marked_for_display (true);
 255                         position += tv->show_at (position, n, &edit_controls_vbox);
 256                         position += track_spacing;
 257                 } else {
 258                         tv->hide ();
 259                 }
 260
 261                 n++;
 262
 263         }
 264
 265         reset_scrolling_region ();
 266 }
 267
 268 void
 269 Editor::hide_all_tracks (bool with_select)
 270 {
 271         TreeModel::Children rows = route_display_model->children();
 272         TreeModel::Children::iterator i;
 273
 274         no_route_list_redisplay = true;
 275
 276         for (i = rows.begin(); i != rows.end(); ++i) {
 277
 278                 TreeModel::Row row = (*i);
 279                 TimeAxisView *tv = row[route_display_columns.tv];
 280
 281                 if (tv == 0) {
 282                         continue;
 283                 }
 284
 285                 row[route_display_columns.visible] = false;
 286         }
 287
 288         no_route_list_redisplay = false;
 289         redisplay_route_list ();
 290
 291         /* XXX this seems like a hack and half, but its not clear where to put this
 292            otherwise.
 293         */
 294
 295         reset_scrolling_region ();
 296 }
 297
 298 void
 299 Editor::build_route_list_menu ()
 300 {
 301         using namespace Menu_Helpers;
 302         using namespace Gtk;
 303
 304         route_list_menu = new Menu;
 305
 306         MenuList& items = route_list_menu->items();
 307         route_list_menu->set_name ("ArdourContextMenu");
 308
 309         items.push_back (MenuElem (_("Show All"), mem_fun(*this, &Editor::show_all_routes)));
 310         items.push_back (MenuElem (_("Hide All"), mem_fun(*this, &Editor::hide_all_routes)));
 311         items.push_back (MenuElem (_("Show All Audio Tracks"), mem_fun(*this, &Editor::show_all_audiotracks)));
 312         items.push_back (MenuElem (_("Hide All Audio Tracks"), mem_fun(*this, &Editor::hide_all_audiotracks)));
 313         items.push_back (MenuElem (_("Show All Audio Busses"), mem_fun(*this, &Editor::show_all_audiobus)));
 314         items.push_back (MenuElem (_("Hide All Audio Busses"), mem_fun(*this, &Editor::hide_all_audiobus)));
 315
 316 }
 317
 318 void
 319 Editor::set_all_tracks_visibility (bool yn)
 320 {
 321         TreeModel::Children rows = route_display_model->children();
 322         TreeModel::Children::iterator i;
 323
 324         no_route_list_redisplay = true;
 325
 326         for (i = rows.begin(); i != rows.end(); ++i) {
 327
 328                 TreeModel::Row row = (*i);
 329                 TimeAxisView* tv = row[route_display_columns.tv];
 330
 331                 if (tv == 0) {
 332                         continue;
 333                 }
 334
 335                 (*i)[route_display_columns.visible] = yn;
 336         }
 337
 338         no_route_list_redisplay = false;
 339         redisplay_route_list ();
 340 }
 341
 342 void
 343 Editor::set_all_audio_visibility (int tracks, bool yn)
 344 {
 345         TreeModel::Children rows = route_display_model->children();
 346         TreeModel::Children::iterator i;
 347
 348         no_route_list_redisplay = true;
 349
 350         for (i = rows.begin(); i != rows.end(); ++i) {
 351                 TreeModel::Row row = (*i);
 352                 TimeAxisView* tv = row[route_display_columns.tv];
 353                 AudioTimeAxisView* atv;
 354
 355                 if (tv == 0) {
 356                         continue;
 357                 }
 358
 359                 if ((atv = dynamic_cast<AudioTimeAxisView*>(tv)) != 0) {
 360                         switch (tracks) {
 361                         case 0:
 362                                 (*i)[route_display_columns.visible] = yn;
 363                                 break;
 364
 365                         case 1:
 366                                 if (atv->is_audio_track()) {
 367                                         (*i)[route_display_columns.visible] = yn;
 368                                 }
 369                                 break;
 370
 371                         case 2:
 372                                 if (!atv->is_audio_track()) {
 373                                         (*i)[route_display_columns.visible] = yn;
 374                                 }
 375                                 break;
 376                         }
 377                 }
 378         }
 379
 380         no_route_list_redisplay = false;
 381         redisplay_route_list ();
 382 }
 383
 384 void
 385 Editor::hide_all_routes ()
 386 {
 387         set_all_tracks_visibility (false);
 388 }
 389
 390 void
 391 Editor::show_all_routes ()
 392 {
 393         set_all_tracks_visibility (true);
 394 }
 395
 396 void
 397 Editor::show_all_audiobus ()
 398 {
 399         set_all_audio_visibility (2, true);
 400 }
 401 void
 402 Editor::hide_all_audiobus ()
 403 {
 404         set_all_audio_visibility (2, false);
 405 }
 406
 407 void
 408 Editor::show_all_audiotracks()
 409 {
 410         set_all_audio_visibility (1, true);
 411 }
 412 void
 413 Editor::hide_all_audiotracks ()
 414 {
 415         set_all_audio_visibility (1, false);
 416 }
 417
 418 bool
 419 Editor::route_list_display_button_press (GdkEventButton* ev)
 420 {
 421         if (Keyboard::is_context_menu_event (ev)) {
 422                 show_route_list_menu ();
 423                 return true;
 424         }
 425
 426         TreeIter iter;
 427         TreeModel::Path path;
 428         TreeViewColumn* column;
 429         int cellx;
 430         int celly;
 431
 432         if (!route_list_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
 433                 return false;
 434         }
 435
 436         switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
 437         case 0:
 438                 if ((iter = route_display_model->get_iter (path))) {
 439                         TimeAxisView* tv = (*iter)[route_display_columns.tv];
 440                         if (tv) {
 441                                 bool visible = (*iter)[route_display_columns.visible];
 442                                 (*iter)[route_display_columns.visible] = !visible;
 443                         }
 444                 }
 445                 return true;
 446
 447         case 1:
 448                 /* allow normal processing to occur */
 449                 return false;
 450
 451         default:
 452                 break;
 453         }
 454
 455         return false;
 456 }
 457
 458 void
 459 Editor::show_route_list_menu()
 460 {
 461         if (route_list_menu == 0) {
 462                 build_route_list_menu ();
 463         }
 464
 465         route_list_menu->popup (1, 0);
 466 }
 467
 468 bool
 469 Editor::route_list_selection_filter (const Glib::RefPtr<TreeModel>& model, const TreeModel::Path& path, bool yn)
 470 {
 471         return true;
 472 }
 473
 474 struct EditorOrderRouteSorter {
 475     bool operator() (Route* a, Route* b) {
 476             /* use of ">" forces the correct sort order */
 477             return a->order_key ("editor") < b->order_key ("editor");
 478     }
 479 };
 480
 481 void
 482 Editor::initial_route_list_display ()
 483 {
 484         Session::RouteList routes = session->get_routes();
 485         EditorOrderRouteSorter sorter;
 486
 487         routes.sort (sorter);
 488
 489         no_route_list_redisplay = true;
 490
 491         route_display_model->clear ();
 492
 493         for (Session::RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
 494                 handle_new_route (**i);
 495         }
 496
 497         no_route_list_redisplay = false;
 498
 499         redisplay_route_list ();
 500 }
 501
 502 void
 503 Editor::route_list_change (const Gtk::TreeModel::Path& path,const Gtk::TreeModel::iterator& iter)
 504 {
 505         redisplay_route_list ();
 506 }
 507
 508 void
 509 Editor::route_list_delete (const Gtk::TreeModel::Path& path)
 510 {
 511         redisplay_route_list ();
 512 }