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