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