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::set_just_one_solo (boost::shared_ptr<Route> r, bool yn, SessionEvent::RTeventCallback after)
  76 {
  77         /* its a bit silly to have to do this, but it keeps the API for this public method sane (we're
  78            only going to solo one route) and keeps our ability to use get_rt_event() for the internal
  79            private method.
  80         */
  81
  82         boost::shared_ptr<RouteList> rl (new RouteList);
  83         rl->push_back (r);
  84
  85         queue_event (get_rt_event (rl, yn, after, false, &Session::rt_set_just_one_solo));
  86 }
  87
  88 void
  89 Session::rt_set_just_one_solo (boost::shared_ptr<RouteList> just_one, bool yn, bool /*ignored*/)
  90 {
  91         boost::shared_ptr<RouteList> rl = routes.reader ();
  92         boost::shared_ptr<Route> r = just_one->front();
  93
  94         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
  95                 if (!(*i)->is_hidden() && r != *i) {
  96                         (*i)->set_solo (!yn, (*i)->route_group());
  97                 }
  98         }
  99
 100         r->set_solo (yn, r->route_group());
 101
 102         set_dirty();
 103 }
 104
 105 void
 106 Session::set_listen (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 107 {
 108         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_listen));
 109 }
 110
 111 void
 112 Session::rt_set_listen (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/ )
 113 {
 114         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 115                 if (!(*i)->is_hidden()) {
 116                         (*i)->set_listen (yn, this);
 117                 }
 118         }
 119
 120         set_dirty();
 121 }
 122
 123 void
 124 Session::set_mute (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 125 {
 126         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_mute));
 127 }
 128
 129 void
 130 Session::rt_set_mute (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/)
 131 {
 132         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 133                 if (!(*i)->is_hidden()) {
 134                         (*i)->set_mute (yn, this);
 135                 }
 136         }
 137
 138         set_dirty();
 139 }
 140
 141 void
 142 Session::set_solo_isolated (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 143 {
 144         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_solo_isolated));
 145 }
 146
 147 void
 148 Session::rt_set_solo_isolated (boost::shared_ptr<RouteList> rl, bool yn, bool /*group_override*/)
 149 {
 150         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 151                 if (!(*i)->is_master() && !(*i)->is_monitor() && !(*i)->is_hidden()) {
 152                         (*i)->set_solo_isolated (yn, this);
 153                 }
 154         }
 155
 156         set_dirty();
 157 }
 158
 159 void
 160 Session::set_record_enabled (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override)
 161 {
 162         if (!writable()) {
 163                 return;
 164         }
 165
 166         queue_event (get_rt_event (rl, yn, after, group_override, &Session::rt_set_record_enabled));
 167 }
 168
 169 void
 170 Session::rt_set_record_enabled (boost::shared_ptr<RouteList> rl, bool yn, bool group_override)
 171 {
 172         for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
 173                 if ((*i)->is_hidden()) {
 174                         continue;
 175                 }
 176
 177                 boost::shared_ptr<Track> t;
 178
 179                 if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
 180                         t->set_record_enabled (yn, (group_override ? (void*) t->route_group() : (void *) this));
 181                 }
 182         }
 183
 184         set_dirty ();
 185 }
 186
 187 void
 188 Session::process_rtop (SessionEvent* ev)
 189 {
 190         ev->rt_slot ();
 191
 192         if (ev->event_loop) {
 193                 ev->event_loop->call_slot (MISSING_INVALIDATOR, boost::bind (ev->rt_return, ev));
 194         } else {
 195                 warning << string_compose ("programming error: %1", X_("Session RT event queued from thread without a UI - cleanup in RT thread!")) << endmsg;
 196                 ev->rt_return (ev);
 197         }
 198 }