libs/surfaces/control_protocol/control_protocol.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3
   4     This program is free software; you can redistribute it
   5     and/or modify it under the terms of the GNU Lesser
   6     General Public License as published by the Free Software
   7     Foundation; either version 2 of the License, or (at your
   8     option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "pbd/error.h"
  22
  23 #include "ardour/gain_control.h"
  24 #include "ardour/session.h"
  25 #include "ardour/route.h"
  26 #include "ardour/audio_track.h"
  27 #include "ardour/meter.h"
  28 #include "ardour/amp.h"
  29 #include "control_protocol/control_protocol.h"
  30
  31 using namespace ARDOUR;
  32 using namespace std;
  33 using namespace PBD;
  34
  35 Signal0<void>       ControlProtocol::ZoomToSession;
  36 Signal0<void>       ControlProtocol::ZoomOut;
  37 Signal0<void>       ControlProtocol::ZoomIn;
  38 Signal0<void>       ControlProtocol::Enter;
  39 Signal0<void>       ControlProtocol::Undo;
  40 Signal0<void>       ControlProtocol::Redo;
  41 Signal1<void,float> ControlProtocol::ScrollTimeline;
  42 Signal1<void,uint32_t> ControlProtocol::GotoView;
  43 Signal0<void> ControlProtocol::CloseDialog;
  44 PBD::Signal0<void> ControlProtocol::VerticalZoomInAll;
  45 PBD::Signal0<void> ControlProtocol::VerticalZoomOutAll;
  46 PBD::Signal0<void> ControlProtocol::VerticalZoomInSelected;
  47 PBD::Signal0<void> ControlProtocol::VerticalZoomOutSelected;
  48 PBD::Signal1<void,RouteNotificationListPtr> ControlProtocol::TrackSelectionChanged;
  49 PBD::Signal1<void,uint64_t> ControlProtocol::AddRouteToSelection;
  50 PBD::Signal1<void,uint64_t> ControlProtocol::SetRouteSelection;
  51 PBD::Signal1<void,uint64_t> ControlProtocol::ToggleRouteSelection;
  52 PBD::Signal1<void,uint64_t> ControlProtocol::RemoveRouteFromSelection;
  53 PBD::Signal0<void>          ControlProtocol::ClearRouteSelection;
  54 PBD::Signal0<void>          ControlProtocol::StepTracksDown;
  55 PBD::Signal0<void>          ControlProtocol::StepTracksUp;
  56
  57 const std::string ControlProtocol::state_node_name ("Protocol");
  58
  59 ControlProtocol::ControlProtocol (Session& s, string str)
  60         : BasicUI (s)
  61         , _name (str)
  62         , _active (false)
  63 {
  64 }
  65
  66 ControlProtocol::~ControlProtocol ()
  67 {
  68 }
  69
  70 int
  71 ControlProtocol::set_active (bool yn)
  72 {
  73         _active = yn;
  74         return 0;
  75 }
  76
  77 void
  78 ControlProtocol::next_track (uint32_t initial_id)
  79 {
  80         // STRIPABLE route_table[0] = _session->get_nth_stripable (++initial_id, RemoteControlID::Route);
  81 }
  82
  83 void
  84 ControlProtocol::prev_track (uint32_t initial_id)
  85 {
  86         if (!initial_id) {
  87                 return;
  88         }
  89         // STRIPABLE route_table[0] = _session->get_nth_stripable (--initial_id, RemoteControlID::Route);
  90 }
  91
  92 void
  93 ControlProtocol::set_route_table_size (uint32_t size)
  94 {
  95         while (route_table.size() < size) {
  96                 route_table.push_back (boost::shared_ptr<Route> ((Route*) 0));
  97         }
  98 }
  99
 100 void
 101 ControlProtocol::set_route_table (uint32_t table_index, boost::shared_ptr<ARDOUR::Route> r)
 102 {
 103         if (table_index >= route_table.size()) {
 104                 return;
 105         }
 106
 107         route_table[table_index] = r;
 108
 109         // XXX SHAREDPTR need to handle r->GoingAway
 110 }
 111
 112 bool
 113 ControlProtocol::set_route_table (uint32_t table_index, uint32_t remote_control_id)
 114 {
 115 #if 0 // STRIPABLE
 116         boost::shared_ptr<Route> r = session->route_by_remote_id (remote_control_id);
 117
 118         if (!r) {
 119                 return false;
 120         }
 121
 122         set_route_table (table_index, r);
 123 #endif
 124         return true;
 125 }
 126
 127 void
 128 ControlProtocol::route_set_rec_enable (uint32_t table_index, bool yn)
 129 {
 130         if (table_index > route_table.size()) {
 131                 return;
 132         }
 133
 134         boost::shared_ptr<Route> r = route_table[table_index];
 135
 136         boost::shared_ptr<AudioTrack> at = boost::dynamic_pointer_cast<AudioTrack>(r);
 137
 138         if (at) {
 139                 at->rec_enable_control()->set_value (1.0, Controllable::UseGroup);
 140         }
 141 }
 142
 143 bool
 144 ControlProtocol::route_get_rec_enable (uint32_t table_index)
 145 {
 146         if (table_index > route_table.size()) {
 147                 return false;
 148         }
 149
 150         boost::shared_ptr<Route> r = route_table[table_index];
 151
 152         boost::shared_ptr<AudioTrack> at = boost::dynamic_pointer_cast<AudioTrack>(r);
 153
 154         if (at) {
 155                 return at->rec_enable_control()->get_value();
 156         }
 157
 158         return false;
 159 }
 160
 161
 162 float
 163 ControlProtocol::route_get_gain (uint32_t table_index)
 164 {
 165         if (table_index > route_table.size()) {
 166                 return 0.0f;
 167         }
 168
 169         boost::shared_ptr<Route> r = route_table[table_index];
 170
 171         if (r == 0) {
 172                 return 0.0f;
 173         }
 174
 175         return r->gain_control()->get_value();
 176 }
 177
 178 void
 179 ControlProtocol::route_set_gain (uint32_t table_index, float gain)
 180 {
 181         if (table_index > route_table.size()) {
 182                 return;
 183         }
 184
 185         boost::shared_ptr<Route> r = route_table[table_index];
 186
 187         if (r != 0) {
 188                 r->gain_control()->set_value (gain, Controllable::UseGroup);
 189         }
 190 }
 191
 192 float
 193 ControlProtocol::route_get_effective_gain (uint32_t table_index)
 194 {
 195         if (table_index > route_table.size()) {
 196                 return 0.0f;
 197         }
 198
 199         boost::shared_ptr<Route> r = route_table[table_index];
 200
 201         if (r == 0) {
 202                 return 0.0f;
 203         }
 204
 205         return r->amp()->gain_control()->get_value();
 206 }
 207
 208
 209 float
 210 ControlProtocol::route_get_peak_input_power (uint32_t table_index, uint32_t which_input)
 211 {
 212         if (table_index > route_table.size()) {
 213                 return 0.0f;
 214         }
 215
 216         boost::shared_ptr<Route> r = route_table[table_index];
 217
 218         if (r == 0) {
 219                 return 0.0f;
 220         }
 221
 222         return r->peak_meter()->meter_level (which_input, MeterPeak);
 223 }
 224
 225 bool
 226 ControlProtocol::route_get_muted (uint32_t table_index)
 227 {
 228         if (table_index > route_table.size()) {
 229                 return false;
 230         }
 231
 232         boost::shared_ptr<Route> r = route_table[table_index];
 233
 234         if (r == 0) {
 235                 return false;
 236         }
 237
 238         return r->mute_control()->muted ();
 239 }
 240
 241 void
 242 ControlProtocol::route_set_muted (uint32_t table_index, bool yn)
 243 {
 244         if (table_index > route_table.size()) {
 245                 return;
 246         }
 247
 248         boost::shared_ptr<Route> r = route_table[table_index];
 249
 250         if (r != 0) {
 251                 r->mute_control()->set_value (yn ? 1.0 : 0.0, Controllable::UseGroup);
 252         }
 253 }
 254
 255
 256 bool
 257 ControlProtocol::route_get_soloed (uint32_t table_index)
 258 {
 259         if (table_index > route_table.size()) {
 260                 return false;
 261         }
 262
 263         boost::shared_ptr<Route> r = route_table[table_index];
 264
 265         if (r == 0) {
 266                 return false;
 267         }
 268
 269         return r->soloed ();
 270 }
 271
 272 void
 273 ControlProtocol::route_set_soloed (uint32_t table_index, bool yn)
 274 {
 275         if (table_index > route_table.size()) {
 276                 return;
 277         }
 278
 279         boost::shared_ptr<Route> r = route_table[table_index];
 280
 281         if (r != 0) {
 282                 r->solo_control()->set_value (yn ? 1.0 : 0.0, Controllable::UseGroup);
 283         }
 284 }
 285
 286 string
 287 ControlProtocol:: route_get_name (uint32_t table_index)
 288 {
 289         if (table_index > route_table.size()) {
 290                 return "";
 291         }
 292
 293         boost::shared_ptr<Route> r = route_table[table_index];
 294
 295         if (r == 0) {
 296                 return "";
 297         }
 298
 299         return r->name();
 300 }
 301
 302 list<boost::shared_ptr<Bundle> >
 303 ControlProtocol::bundles ()
 304 {
 305         return list<boost::shared_ptr<Bundle> > ();
 306 }
 307
 308 XMLNode&
 309 ControlProtocol::get_state ()
 310 {
 311         XMLNode* node = new XMLNode (state_node_name);
 312
 313         node->add_property ("name", _name);
 314         node->add_property ("feedback", get_feedback() ? "yes" : "no");
 315
 316         return *node;
 317 }
 318
 319 int
 320 ControlProtocol::set_state (XMLNode const & node, int /* version */)
 321 {
 322         const XMLProperty* prop;
 323
 324         if ((prop = node.property ("feedback")) != 0) {
 325                 set_feedback (string_is_affirmative (prop->value()));
 326         }
 327
 328         return 0;
 329 }