gtk2_ardour/group_tabs.cc

   1 /*
   2     Copyright (C) 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 <gtkmm/stock.h>
  21 #include "ardour/session.h"
  22 #include "ardour/route_group.h"
  23 #include "ardour/route.h"
  24
  25 #include "gui_thread.h"
  26 #include "route_group_dialog.h"
  27 #include "group_tabs.h"
  28 #include "keyboard.h"
  29 #include "i18n.h"
  30 #include "ardour_ui.h"
  31 #include "utils.h"
  32
  33 using namespace std;
  34 using namespace Gtk;
  35 using namespace ARDOUR;
  36 using Gtkmm2ext::Keyboard;
  37
  38 list<Gdk::Color> GroupTabs::_used_colors;
  39
  40 GroupTabs::GroupTabs ()
  41         : _menu (0)
  42         , _dragging (0)
  43         , _dragging_new_tab (0)
  44 {
  45         add_events (Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK|Gdk::POINTER_MOTION_MASK);
  46 }
  47
  48 GroupTabs::~GroupTabs ()
  49 {
  50         delete _menu;
  51 }
  52
  53 void
  54 GroupTabs::set_session (Session* s)
  55 {
  56         SessionHandlePtr::set_session (s);
  57
  58         if (_session) {
  59                 _session->RouteGroupPropertyChanged.connect (
  60                         _session_connections, invalidator (*this), boost::bind (&GroupTabs::route_group_property_changed, this, _1), gui_context()
  61                         );
  62                 _session->RouteAddedToRouteGroup.connect (
  63                         _session_connections, invalidator (*this), boost::bind (&GroupTabs::route_added_to_route_group, this, _1, _2), gui_context()
  64                         );
  65                 _session->RouteRemovedFromRouteGroup.connect (
  66                         _session_connections, invalidator (*this), boost::bind (&GroupTabs::route_removed_from_route_group, this, _1, _2), gui_context()
  67                         );
  68
  69                 _session->route_group_removed.connect (_session_connections, invalidator (*this), boost::bind (&GroupTabs::set_dirty, this), gui_context());
  70         }
  71 }
  72
  73
  74 /** Handle a size request.
  75  *  @param req GTK requisition
  76  */
  77 void
  78 GroupTabs::on_size_request (Gtk::Requisition *req)
  79 {
  80         /* Use a dummy, small width and the actual height that we want */
  81         req->width = 16;
  82         req->height = 16;
  83 }
  84
  85 bool
  86 GroupTabs::on_button_press_event (GdkEventButton* ev)
  87 {
  88         using namespace Menu_Helpers;
  89
  90         double const p = primary_coordinate (ev->x, ev->y);
  91
  92         list<Tab>::iterator prev;
  93         list<Tab>::iterator next;
  94         Tab* t = click_to_tab (p, &prev, &next);
  95
  96         _drag_min = prev != _tabs.end() ? prev->to : 0;
  97         _drag_max = next != _tabs.end() ? next->from : extent ();
  98
  99         if (ev->button == 1) {
 100
 101                 if (t == 0) {
 102                         Tab n;
 103                         n.from = n.to = p;
 104                         _dragging_new_tab = true;
 105
 106                         if (next == _tabs.end()) {
 107                                 _tabs.push_back (n);
 108                                 t = &_tabs.back ();
 109                         } else {
 110                                 list<Tab>::iterator j = _tabs.insert (next, n);
 111                                 t = &(*j);
 112                         }
 113
 114                 } else {
 115                         _dragging_new_tab = false;
 116                         _initial_dragging_routes = routes_for_tab (t);
 117                 }
 118
 119                 _dragging = t;
 120                 _drag_moved = false;
 121                 _drag_first = p;
 122
 123                 double const h = (t->from + t->to) / 2;
 124                 if (p < h) {
 125                         _drag_moving = t->from;
 126                         _drag_fixed = t->to;
 127                         _drag_offset = p - t->from;
 128                 } else {
 129                         _drag_moving = t->to;
 130                         _drag_fixed = t->from;
 131                         _drag_offset = p - t->to;
 132                 }
 133
 134         } else if (ev->button == 3) {
 135
 136                 RouteGroup* g = t ? t->group : 0;
 137
 138                 if (Keyboard::modifier_state_equals (ev->state, Keyboard::PrimaryModifier) && g) {
 139                         /* edit */
 140                         RouteGroupDialog d (g, false);
 141                         d.do_run ();
 142                 } else {
 143                         Menu* m = get_menu (g);
 144                         if (m) {
 145                                 m->popup (ev->button, ev->time);
 146                         }
 147                 }
 148         }
 149
 150         return true;
 151 }
 152
 153
 154 bool
 155 GroupTabs::on_motion_notify_event (GdkEventMotion* ev)
 156 {
 157         if (_dragging == 0) {
 158                 return false;
 159         }
 160
 161         double const p = primary_coordinate (ev->x, ev->y);
 162
 163         if (p != _drag_first) {
 164                 _drag_moved = true;
 165         }
 166
 167         _drag_moving = p - _drag_offset;
 168
 169         _dragging->from = min (_drag_moving, _drag_fixed);
 170         _dragging->to = max (_drag_moving, _drag_fixed);
 171
 172         _dragging->from = max (_dragging->from, _drag_min);
 173         _dragging->to = min (_dragging->to, _drag_max);
 174
 175         set_dirty ();
 176         queue_draw ();
 177
 178         gdk_event_request_motions(ev);
 179
 180         return true;
 181 }
 182
 183
 184 bool
 185 GroupTabs::on_button_release_event (GdkEventButton*)
 186 {
 187         if (_dragging == 0) {
 188                 return false;
 189         }
 190
 191         if (!_drag_moved) {
 192
 193                 if (_dragging->group) {
 194                         /* toggle active state */
 195                         _dragging->group->set_active (!_dragging->group->is_active (), this);
 196                 }
 197
 198         } else {
 199                 /* finish drag */
 200                 RouteList routes = routes_for_tab (_dragging);
 201
 202                 if (!routes.empty()) {
 203                         if (_dragging_new_tab) {
 204                                 RouteGroup* g = create_and_add_group ();
 205                                 if (g) {
 206                                         for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
 207                                                 g->add (*i);
 208                                         }
 209                                 }
 210                         } else {
 211                                 boost::shared_ptr<RouteList> r = _session->get_routes ();
 212                                 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 213
 214                                         bool const was_in_tab = find (
 215                                                 _initial_dragging_routes.begin(), _initial_dragging_routes.end(), *i
 216                                                 ) != _initial_dragging_routes.end ();
 217
 218                                         bool const now_in_tab = find (routes.begin(), routes.end(), *i) != routes.end();
 219
 220                                         if (was_in_tab && !now_in_tab) {
 221                                                 _dragging->group->remove (*i);
 222                                         } else if (!was_in_tab && now_in_tab) {
 223                                                 _dragging->group->add (*i);
 224                                         }
 225                                 }
 226                         }
 227                 }
 228
 229                 set_dirty ();
 230                 queue_draw ();
 231         }
 232
 233         _dragging = 0;
 234         _initial_dragging_routes.clear ();
 235
 236         return true;
 237 }
 238
 239 void
 240 GroupTabs::render (cairo_t* cr)
 241 {
 242         if (_dragging == 0) {
 243                 _tabs = compute_tabs ();
 244         }
 245
 246         /* background */
 247
 248         Gdk::Color c = get_style()->get_base (Gtk::STATE_NORMAL);
 249
 250         cairo_set_source_rgb (cr, c.get_red_p(), c.get_green_p(), c.get_blue_p());
 251         cairo_rectangle (cr, 0, 0, get_width(), get_height());
 252         cairo_fill (cr);
 253
 254         /* tabs */
 255
 256         for (list<Tab>::const_iterator i = _tabs.begin(); i != _tabs.end(); ++i) {
 257                 draw_tab (cr, *i);
 258         }
 259 }
 260
 261
 262 /** Convert a click position to a tab.
 263  *  @param c Click position.
 264  *  @param prev Filled in with the previous tab to the click, or _tabs.end().
 265  *  @param next Filled in with the next tab after the click, or _tabs.end().
 266  *  @return Tab under the click, or 0.
 267  */
 268
 269 GroupTabs::Tab *
 270 GroupTabs::click_to_tab (double c, list<Tab>::iterator* prev, list<Tab>::iterator* next)
 271 {
 272         *prev = *next = _tabs.end ();
 273         Tab* under = 0;
 274
 275         list<Tab>::iterator i = _tabs.begin ();
 276         while (i != _tabs.end()) {
 277
 278                 if (i->from > c) {
 279                         *next = i;
 280                         break;
 281                 }
 282
 283                 if (i->to < c) {
 284                         *prev = i;
 285                         ++i;
 286                         continue;
 287                 }
 288
 289                 if (i->from <= c && c < i->to) {
 290                         under = &(*i);
 291                 }
 292
 293                 ++i;
 294         }
 295
 296         return under;
 297 }
 298
 299 Gtk::Menu*
 300 GroupTabs::get_menu (RouteGroup* g)
 301 {
 302         using namespace Menu_Helpers;
 303
 304         delete _menu;
 305
 306         Menu* new_from = new Menu;
 307         MenuList& f = new_from->items ();
 308         f.push_back (MenuElem (_("Selection..."), sigc::mem_fun (*this, &GroupTabs::new_from_selection)));
 309         f.push_back (MenuElem (_("Record Enabled..."), sigc::mem_fun (*this, &GroupTabs::new_from_rec_enabled)));
 310         f.push_back (MenuElem (_("Soloed..."), sigc::mem_fun (*this, &GroupTabs::new_from_soloed)));
 311
 312         _menu = new Menu;
 313         _menu->set_name ("ArdourContextMenu");
 314         MenuList& items = _menu->items();
 315
 316         items.push_back (MenuElem (_("Create New Group ..."), hide_return (sigc::mem_fun(*this, &GroupTabs::create_and_add_group))));
 317         items.push_back (MenuElem (_("Create New Group From"), *new_from));
 318
 319         if (g) {
 320                 items.push_back (MenuElem (_("Edit Group..."), sigc::bind (sigc::mem_fun (*this, &GroupTabs::edit_group), g)));
 321                 items.push_back (MenuElem (_("Collect Group"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::collect), g)));
 322                 items.push_back (MenuElem (_("Remove Group"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::remove_group), g)));
 323                 items.push_back (SeparatorElem());
 324                 if (g->has_subgroup()) {
 325                         items.push_back (MenuElem (_("Remove Subgroup Bus"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::un_subgroup), g)));
 326                 } else {
 327                         items.push_back (MenuElem (_("Add New Subgroup Bus"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::subgroup), g, false, PreFader)));
 328                 }
 329                 items.push_back (MenuElem (_("Add New Aux Bus (pre-fader)"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::subgroup), g, true, PreFader)));
 330                 items.push_back (MenuElem (_("Add New Aux Bus (post-fader)"), sigc::bind (sigc::mem_fun (*this, &GroupTabs::subgroup), g, true, PostFader)));
 331         }
 332
 333         add_menu_items (_menu, g);
 334
 335         items.push_back (SeparatorElem());
 336         items.push_back (MenuElem (_("Enable All Groups"), sigc::mem_fun(*this, &GroupTabs::activate_all)));
 337         items.push_back (MenuElem (_("Disable All Groups"), sigc::mem_fun(*this, &GroupTabs::disable_all)));
 338
 339         return _menu;
 340
 341 }
 342
 343 void
 344 GroupTabs::new_from_selection ()
 345 {
 346         RouteList rl = selected_routes ();
 347         if (rl.empty()) {
 348                 return;
 349         }
 350
 351         run_new_group_dialog (rl);
 352 }
 353
 354 void
 355 GroupTabs::new_from_rec_enabled ()
 356 {
 357         boost::shared_ptr<RouteList> rl = _session->get_routes ();
 358
 359         RouteList rec_enabled;
 360
 361         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 362                 if ((*i)->record_enabled()) {
 363                         rec_enabled.push_back (*i);
 364                 }
 365         }
 366
 367         if (rec_enabled.empty()) {
 368                 return;
 369         }
 370
 371         run_new_group_dialog (rec_enabled);
 372 }
 373
 374 void
 375 GroupTabs::new_from_soloed ()
 376 {
 377         boost::shared_ptr<RouteList> rl = _session->get_routes ();
 378
 379         RouteList soloed;
 380
 381         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 382                 if (!(*i)->is_master() && (*i)->soloed()) {
 383                         soloed.push_back (*i);
 384                 }
 385         }
 386
 387         if (soloed.empty()) {
 388                 return;
 389         }
 390
 391         run_new_group_dialog (soloed);
 392 }
 393
 394 void
 395 GroupTabs::run_new_group_dialog (RouteList const & rl)
 396 {
 397         RouteGroup* g = new RouteGroup (*_session, "");
 398         g->apply_changes (default_properties ());
 399
 400         RouteGroupDialog d (g, true);
 401
 402         if (d.do_run ()) {
 403                 delete g;
 404         } else {
 405                 _session->add_route_group (g);
 406                 for (RouteList::const_iterator i = rl.begin(); i != rl.end(); ++i) {
 407                         g->add (*i);
 408                 }
 409         }
 410 }
 411
 412 RouteGroup *
 413 GroupTabs::create_and_add_group () const
 414 {
 415         RouteGroup* g = new RouteGroup (*_session, "");
 416
 417         g->apply_changes (default_properties ());
 418
 419         RouteGroupDialog d (g, true);
 420
 421         if (d.do_run ()) {
 422                 delete g;
 423                 return 0;
 424         }
 425
 426         _session->add_route_group (g);
 427         return g;
 428 }
 429
 430 void
 431 GroupTabs::edit_group (RouteGroup* g)
 432 {
 433         RouteGroupDialog d (g, false);
 434         d.do_run ();
 435 }
 436
 437 void
 438 GroupTabs::subgroup (RouteGroup* g, bool aux, Placement placement)
 439 {
 440         g->make_subgroup (aux, placement);
 441 }
 442
 443 void
 444 GroupTabs::un_subgroup (RouteGroup* g)
 445 {
 446         g->destroy_subgroup ();
 447 }
 448
 449 struct CollectSorter {
 450         bool operator () (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
 451                 return a->order_key () < b->order_key ();
 452         }
 453 };
 454
 455 struct OrderSorter {
 456         bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
 457                 return a->order_key () < b->order_key ();
 458         }
 459 };
 460
 461 /** Collect all members of a RouteGroup so that they are together in the Editor or Mixer.
 462  *  @param g Group to collect.
 463  */
 464 void
 465 GroupTabs::collect (RouteGroup* g)
 466 {
 467         boost::shared_ptr<RouteList> group_routes = g->route_list ();
 468         group_routes->sort (CollectSorter ());
 469         int const N = group_routes->size ();
 470
 471         RouteList::iterator i = group_routes->begin ();
 472         boost::shared_ptr<RouteList> routes = _session->get_routes ();
 473         routes->sort (OrderSorter ());
 474         RouteList::const_iterator j = routes->begin ();
 475
 476         int diff = 0;
 477         int coll = -1;
 478         while (i != group_routes->end() && j != routes->end()) {
 479
 480                 int const k = (*j)->order_key ();
 481
 482                 if (*i == *j) {
 483
 484                         if (coll == -1) {
 485                                 coll = k;
 486                                 diff = N - 1;
 487                         } else {
 488                                 --diff;
 489                         }
 490
 491                         (*j)->set_order_key (coll);
 492
 493                         ++coll;
 494                         ++i;
 495
 496                 } else {
 497
 498                         (*j)->set_order_key (k + diff);
 499
 500                 }
 501
 502                 ++j;
 503         }
 504
 505         sync_order_keys ();
 506 }
 507
 508 void
 509 GroupTabs::activate_all ()
 510 {
 511         _session->foreach_route_group (
 512                 sigc::bind (sigc::mem_fun (*this, &GroupTabs::set_activation), true)
 513                 );
 514 }
 515
 516 void
 517 GroupTabs::disable_all ()
 518 {
 519         _session->foreach_route_group (
 520                 sigc::bind (sigc::mem_fun (*this, &GroupTabs::set_activation), false)
 521                 );
 522 }
 523
 524 void
 525 GroupTabs::set_activation (RouteGroup* g, bool a)
 526 {
 527         g->set_active (a, this);
 528 }
 529
 530 void
 531 GroupTabs::remove_group (RouteGroup* g)
 532 {
 533         _session->remove_route_group (*g);
 534 }
 535
 536 /** Set the color of the tab of a route group */
 537 void
 538 GroupTabs::set_group_color (RouteGroup* group, Gdk::Color color)
 539 {
 540         assert (group);
 541
 542         /* Hack to disallow black route groups; force a dark grey instead */
 543         if (color.get_red() == 0 && color.get_green() == 0 && color.get_blue() == 0) {
 544                 color.set_grey_p (0.1);
 545         }
 546
 547         GUIObjectState& gui_state = *ARDOUR_UI::instance()->gui_object_state;
 548
 549         char buf[64];
 550         snprintf (buf, sizeof (buf), "%d:%d:%d", color.get_red(), color.get_green(), color.get_blue());
 551         gui_state.set_property (group_gui_id (group), "color", buf);
 552
 553         /* the group color change notification */
 554
 555         PBD::PropertyChange change;
 556         change.add (Properties::color);
 557         group->PropertyChanged (change);
 558
 559         /* This is a bit of a hack, but this might change
 560            our route's effective color, so emit gui_changed
 561            for our routes.
 562         */
 563
 564         emit_gui_changed_for_members (group);
 565 }
 566
 567 /** @return the ID string to use for the GUI state of a route group */
 568 string
 569 GroupTabs::group_gui_id (RouteGroup* group)
 570 {
 571         assert (group);
 572
 573         char buf[64];
 574         snprintf (buf, sizeof (buf), "route_group %s", group->id().to_s().c_str ());
 575
 576         return buf;
 577 }
 578
 579 /** @return the color to use for a route group tab */
 580 Gdk::Color
 581 GroupTabs::group_color (RouteGroup* group)
 582 {
 583         assert (group);
 584
 585         GUIObjectState& gui_state = *ARDOUR_UI::instance()->gui_object_state;
 586
 587         string const gui_id = group_gui_id (group);
 588
 589         bool empty;
 590         string const color = gui_state.get_string (gui_id, "color", &empty);
 591         if (empty) {
 592                 /* no color has yet been set, so use a random one */
 593                 Gdk::Color const color = unique_random_color (_used_colors);
 594                 set_group_color (group, color);
 595                 return color;
 596         }
 597
 598         Gdk::Color c;
 599
 600         int r, g, b;
 601
 602         sscanf (color.c_str(), "%d:%d:%d", &r, &g, &b);
 603
 604         c.set_red (r);
 605         c.set_green (g);
 606         c.set_blue (b);
 607
 608         return c;
 609 }
 610
 611 void
 612 GroupTabs::route_group_property_changed (RouteGroup* rg)
 613 {
 614         /* This is a bit of a hack, but this might change
 615            our route's effective color, so emit gui_changed
 616            for our routes.
 617         */
 618
 619         emit_gui_changed_for_members (rg);
 620
 621         set_dirty ();
 622 }
 623
 624 void
 625 GroupTabs::route_added_to_route_group (RouteGroup*, boost::weak_ptr<Route> w)
 626 {
 627         /* Similarly-spirited hack as in route_group_property_changed */
 628
 629         boost::shared_ptr<Route> r = w.lock ();
 630         if (!r) {
 631                 return;
 632         }
 633
 634         r->gui_changed (X_("color"), 0);
 635
 636         set_dirty ();
 637 }
 638
 639 void
 640 GroupTabs::route_removed_from_route_group (RouteGroup*, boost::weak_ptr<Route> w)
 641 {
 642         /* Similarly-spirited hack as in route_group_property_changed */
 643
 644         boost::shared_ptr<Route> r = w.lock ();
 645         if (!r) {
 646                 return;
 647         }
 648
 649         r->gui_changed (X_("color"), 0);
 650
 651         set_dirty ();
 652 }
 653
 654 void
 655 GroupTabs::emit_gui_changed_for_members (RouteGroup* rg)
 656 {
 657         for (RouteList::iterator i = rg->route_list()->begin(); i != rg->route_list()->end(); ++i) {
 658                 (*i)->gui_changed (X_("color"), 0);
 659         }
 660 }