libs/ardour/session_rtevents.cc

   1 /*
   2     Copyright (C) 1999-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 #include <boost/bind.hpp>
  20
  21 #include "pbd/error.h"
  22 #include "pbd/compose.h"
  23
  24 #include "ardour/session.h"
  25 #include "ardour/route.h"
  26 #include "ardour/track.h"
  27
  28 #include "i18n.h"
  29
  30 using namespace std;
  31 using namespace PBD;
  32 using namespace ARDOUR;
  33 using namespace Glib;
  34
  35 void
  36 Session::set_monitoring (boost::shared_ptr<RouteList> rl, MonitorChoice mc, SessionEvent::RTeventCallback after, bool group_override)
  37 {
  38         queue_event (get_rt_event (rl, mc, after, group_override, &Session::rt_set_monitoring));
  39 }
  40
  41 void
  42 Session::rt_set_monitoring (boost::shared_ptr<RouteList> rl, MonitorChoice mc, bool /* group_override */)
  43 {
  44         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
  45                 if (!(*i)->is_hidden()) {
  46                         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (*i);
  47                         if (t) {
  48                                 t->set_monitoring (mc);
  49                         }
  50                 }
  51         }
  52
  53         set_dirty();
  54 }
  55
  56 void
  57 Session::set_solo (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
  58 {
  59         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_solo));
  60 }
  61
  62 void
  63 Session::rt_set_solo (boost::shared_ptr<RouteList> rl, bool yn, bool /* group_override */)
  64 {
  65         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
  66                 if (!(*i)->is_hidden()) {
  67                         (*i)->set_solo (yn, this);
  68                 }
  69         }
  70
  71         set_dirty();
  72 }
  73
  74 void
  75 Session::cancel_solo_after_disconnect (boost::shared_ptr<Route> r, SessionEvent::RTeventCallback after)
  76 {
  77         boost::shared_ptr<RouteList> rl (new RouteList);
  78         rl->push_back (r);
  79
  80         queue_event (get_rt_event (rl, false, after, false, &Session::rt_cancel_solo_after_disconnect));
  81 }
  82
  83 void
  84 Session::rt_cancel_solo_after_disconnect (boost::shared_ptr<RouteList> rl, bool /*yn */, bool /* group_override */)
  85 {
  86         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
  87                 if (!(*i)->is_hidden()) {
  88                         (*i)->cancel_solo_after_disconnect ();
  89                 }
  90         }
  91         /* no need to call set-dirty - the disconnect will already have done that */
  92 }
  93
  94 void
  95 Session::set_just_one_solo (boost::shared_ptr<Route> r, bool yn, SessionEvent::RTeventCallback after)
  96 {
  97         /* its a bit silly to have to do this, but it keeps the API for this public method sane (we're
  98            only going to solo one route) and keeps our ability to use get_rt_event() for the internal
  99            private method.
 100         */
 101
 102         boost::shared_ptr<RouteList> rl (new RouteList);
 103         rl->push_back (r);
 104
 105         queue_event (get_rt_event (rl, yn, after, false, &Session::rt_set_just_one_solo));
 106 }
 107
 108 void
 109 Session::rt_set_just_one_solo (boost::shared_ptr<RouteList> just_one, bool yn, bool /*ignored*/)
 110 {
 111         boost::shared_ptr<RouteList> rl = routes.reader ();
 112         boost::shared_ptr<Route> r = just_one->front();
 113
 114         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 115                 if (!(*i)->is_hidden() && r != *i) {
 116                         (*i)->set_solo (!yn, (*i)->route_group());
 117                 }
 118         }
 119
 120         r->set_solo (yn, r->route_group());
 121
 122         set_dirty();
 123 }
 124
 125 void
 126 Session::set_listen (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 127 {
 128         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_listen));
 129 }
 130
 131 void
 132 Session::rt_set_listen (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/ )
 133 {
 134         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 135                 if (!(*i)->is_hidden()) {
 136                         (*i)->set_listen (yn, this);
 137                 }
 138         }
 139
 140         set_dirty();
 141 }
 142
 143 void
 144 Session::set_mute (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 145 {
 146         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_mute));
 147 }
 148
 149 void
 150 Session::rt_set_mute (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/)
 151 {
 152         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 153                 if (!(*i)->is_hidden()) {
 154                         (*i)->set_mute (yn, this);
 155                 }
 156         }
 157
 158         set_dirty();
 159 }
 160
 161 void
 162 Session::set_solo_isolated (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 163 {
 164         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_solo_isolated));
 165 }
 166
 167 void
 168 Session::rt_set_solo_isolated (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/)
 169 {
 170         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 171                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden()) {
 172                         (*i)->set_solo_isolated (yn, this);
 173                 }
 174         }
 175
 176         set_dirty();
 177 }
 178
 179 void
 180 Session::set_record_enabled (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 181 {
 182         if (!writable()) {
 183                 return;
 184         }
 185
 186         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_record_enabled));
 187 }
 188
 189 void
 190 Session::rt_set_record_enabled (boost::shared_ptr<RouteList> rl, bool yn, bool group_override)
 191 {
 192         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 193                 if ((*i)->is_hidden()) {
 194                         continue;
 195                 }
 196
 197                 boost::shared_ptr<Track> t;
 198
 199                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
 200                         t->set_record_enabled (yn, (group_override ? (void*) t->route_group() : (void *) this));
 201                 }
 202         }
 203
 204         set_dirty ();
 205 }
 206
 207 void
 208 Session::process_rtop (SessionEvent* ev)
 209 {
 210         ev->rt_slot ();
 211
 212         if (ev->event_loop) {
 213                 ev->event_loop->call_slot (MISSING_INVALIDATOR, boost::bind (ev->rt_return, ev));
 214         } else {
 215                 warning << string_compose ("programming error: %1", X_("Session RT event queued from thread without a UI - cleanup in RT thread!")) << endmsg;
 216                 ev->rt_return (ev);
 217         }
 218 }