libs/ardour/session_command.cc

   1 /*
   2     Copyright (C) 2000-2007 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 <ardour/session.h>
  21 #include <ardour/route.h>
  22 #include <pbd/memento_command.h>
  23 #include <ardour/diskstream.h>
  24 #include <ardour/playlist.h>
  25 #include <ardour/audioplaylist.h>
  26 #include <ardour/audio_track.h>
  27 #include <ardour/midi_playlist.h>
  28 #include <ardour/midi_track.h>
  29 #include <ardour/tempo.h>
  30 #include <ardour/audiosource.h>
  31 #include <ardour/audioregion.h>
  32 #include <ardour/midi_source.h>
  33 #include <ardour/midi_region.h>
  34 #include <pbd/error.h>
  35 #include <pbd/id.h>
  36 #include <pbd/statefuldestructible.h>
  37 #include <pbd/failed_constructor.h>
  38
  39 using namespace PBD;
  40 using namespace ARDOUR;
  41
  42 #include "i18n.h"
  43
  44 void Session::register_with_memento_command_factory(PBD::ID id, PBD::StatefulThingWithGoingAway *ptr)
  45 {
  46     registry[id] = ptr;
  47 }
  48
  49 Command *
  50 Session::memento_command_factory(XMLNode *n)
  51 {
  52     PBD::ID id;
  53     XMLNode *before = 0, *after = 0;
  54     XMLNode *child = 0;
  55
  56     /* get id */
  57     id = PBD::ID(n->property("obj-id")->value());
  58
  59     /* get before/after */
  60
  61     if (n->name() == "MementoCommand") {
  62             before = new XMLNode(*n->children().front());
  63             after = new XMLNode(*n->children().back());
  64             child = before;
  65     } else if (n->name() == "MementoUndoCommand") {
  66             before = new XMLNode(*n->children().front());
  67             child = before;
  68     } else if (n->name() == "MementoRedoCommand") {
  69             after = new XMLNode(*n->children().front());
  70             child = after;
  71     } else if (n->name() == "PlaylistCommand") {
  72             before = new XMLNode(*n->children().front());
  73             after = new XMLNode(*n->children().back());
  74             child = before;
  75     }
  76
  77     if (!child) {
  78         error << _("Tried to reconstitute a MementoCommand with no contents, failing. id=") << id.to_s() << endmsg;
  79         return 0;
  80     }
  81
  82     /* create command */
  83     string obj_T = n->property ("type-name")->value();
  84     if (obj_T == typeid (AudioRegion).name() || obj_T == typeid (MidiRegion).name() || obj_T == typeid (Region).name()) {
  85             if (regions.count(id)) {
  86                     return new MementoCommand<Region>(*regions[id], before, after);
  87             }
  88     } else if (obj_T == typeid (AudioSource).name() || obj_T == typeid (MidiSource).name()) {
  89             if (sources.count(id))
  90                     return new MementoCommand<Source>(*sources[id], before, after);
  91     } else if (obj_T == typeid (Location).name()) {
  92             Location* loc = _locations.get_location_by_id(id);
  93             if (loc) {
  94                     return new MementoCommand<Location>(*loc, before, after);
  95             }
  96     } else if (obj_T == typeid (Locations).name()) {
  97             return new MementoCommand<Locations>(_locations, before, after);
  98     } else if (obj_T == typeid (TempoMap).name()) {
  99             return new MementoCommand<TempoMap>(*_tempo_map, before, after);
 100     } else if (obj_T == typeid (Playlist).name() || obj_T == typeid (AudioPlaylist).name() || obj_T == typeid (MidiPlaylist).name()) {
 101             if (boost::shared_ptr<Playlist> pl = playlist_by_name(child->property("name")->value())) {
 102                     return new MementoCommand<Playlist>(*(pl.get()), before, after);
 103             }
 104     } else if (obj_T == typeid (Route).name() || obj_T == typeid (AudioTrack).name() || obj_T == typeid(MidiTrack).name()) {
 105             return new MementoCommand<Route>(*route_by_id(id), before, after);
 106     } else if (obj_T == typeid (Evoral::Curve).name() || obj_T == typeid (AutomationList).name()) {
 107                 std::map<PBD::ID, AutomationList*>::iterator i = automation_lists.find(id);
 108                 if (i != automation_lists.end()) {
 109                     return new MementoCommand<AutomationList>(*i->second, before, after);
 110                 }
 111     } else if (registry.count(id)) { // For Editor and AutomationLine which are off-limits here
 112             return new MementoCommand<PBD::StatefulThingWithGoingAway>(*registry[id], before, after);
 113     }
 114
 115     /* we failed */
 116     error << string_compose (_("could not reconstitute MementoCommand from XMLNode. object type = %1 id = %2"), obj_T, id.to_s()) << endmsg;
 117
 118     return 0 ;
 119 }
 120
 121 Command *
 122 Session::global_state_command_factory (const XMLNode& node)
 123 {
 124         const XMLProperty* prop;
 125         Command* command = 0;
 126
 127         if ((prop = node.property ("type")) == 0) {
 128                 error << _("GlobalRouteStateCommand has no \"type\" node, ignoring") << endmsg;
 129                 return 0;
 130         }
 131
 132         try {
 133
 134                 if (prop->value() == "solo") {
 135                         command = new GlobalSoloStateCommand (*this, node);
 136                 } else if (prop->value() == "mute") {
 137                         command = new GlobalMuteStateCommand (*this, node);
 138                 } else if (prop->value() == "rec-enable") {
 139                         command = new GlobalRecordEnableStateCommand (*this, node);
 140                 } else if (prop->value() == "metering") {
 141                         command = new GlobalMeteringStateCommand (*this, node);
 142                 } else {
 143                         error << string_compose (_("unknown type of GlobalRouteStateCommand (%1), ignored"), prop->value()) << endmsg;
 144                 }
 145         }
 146
 147         catch (failed_constructor& err) {
 148                 return 0;
 149         }
 150
 151         return command;
 152 }
 153
 154 Session::GlobalRouteStateCommand::GlobalRouteStateCommand (Session& s, void* p)
 155         : sess (s), src (p)
 156 {
 157 }
 158
 159 Session::GlobalRouteStateCommand::GlobalRouteStateCommand (Session& s, const XMLNode& node)
 160         : sess (s), src (this)
 161 {
 162         if (set_state (node)) {
 163                 throw failed_constructor ();
 164         }
 165 }
 166
 167 int
 168 Session::GlobalRouteStateCommand::set_state (const XMLNode& node)
 169 {
 170         GlobalRouteBooleanState states;
 171         XMLNodeList nlist;
 172         const XMLProperty* prop;
 173         XMLNode* child;
 174         XMLNodeConstIterator niter;
 175         int loop;
 176
 177         before.clear ();
 178         after.clear ();
 179
 180         for (loop = 0; loop < 2; ++loop) {
 181
 182                 const char *str;
 183
 184                 if (loop) {
 185                         str = "after";
 186                 } else {
 187                         str = "before";
 188                 }
 189
 190                 if ((child = node.child (str)) == 0) {
 191                         warning << string_compose (_("global route state command has no \"%1\" node, ignoring entire command"), str) << endmsg;
 192                         return -1;
 193                 }
 194
 195                 nlist = child->children();
 196
 197                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 198
 199                         RouteBooleanState rbs;
 200                         boost::shared_ptr<Route> route;
 201                         ID id;
 202
 203                         prop = (*niter)->property ("id");
 204                         id = prop->value ();
 205
 206                         if ((route = sess.route_by_id (id)) == 0) {
 207                                 warning << string_compose (_("cannot find track/bus \"%1\" while rebuilding a global route state command, ignored"), id.to_s()) << endmsg;
 208                                 continue;
 209                         }
 210
 211                         rbs.first = boost::weak_ptr<Route> (route);
 212
 213                         prop = (*niter)->property ("yn");
 214                         rbs.second = (prop->value() == "1");
 215
 216                         if (loop) {
 217                                 after.push_back (rbs);
 218                         } else {
 219                                 before.push_back (rbs);
 220                         }
 221                 }
 222         }
 223
 224         return 0;
 225 }
 226
 227 XMLNode&
 228 Session::GlobalRouteStateCommand::get_state ()
 229 {
 230         XMLNode* node = new XMLNode (X_("GlobalRouteStateCommand"));
 231         XMLNode* nbefore = new XMLNode (X_("before"));
 232         XMLNode* nafter = new XMLNode (X_("after"));
 233
 234         for (Session::GlobalRouteBooleanState::iterator x = before.begin(); x != before.end(); ++x) {
 235                 XMLNode* child = new XMLNode ("s");
 236                 boost::shared_ptr<Route> r = x->first.lock();
 237
 238                 if (r) {
 239                         child->add_property (X_("id"), r->id().to_s());
 240                         child->add_property (X_("yn"), (x->second ? "1" : "0"));
 241                         nbefore->add_child_nocopy (*child);
 242                 }
 243         }
 244
 245         for (Session::GlobalRouteBooleanState::iterator x = after.begin(); x != after.end(); ++x) {
 246                 XMLNode* child = new XMLNode ("s");
 247                 boost::shared_ptr<Route> r = x->first.lock();
 248
 249                 if (r) {
 250                         child->add_property (X_("id"), r->id().to_s());
 251                         child->add_property (X_("yn"), (x->second ? "1" : "0"));
 252                         nafter->add_child_nocopy (*child);
 253                 }
 254         }
 255
 256         node->add_child_nocopy (*nbefore);
 257         node->add_child_nocopy (*nafter);
 258
 259         return *node;
 260 }
 261
 262 // solo
 263
 264 Session::GlobalSoloStateCommand::GlobalSoloStateCommand(Session &sess, void *src)
 265         : GlobalRouteStateCommand (sess, src)
 266 {
 267     after = before = sess.get_global_route_boolean(&Route::soloed);
 268 }
 269
 270 Session::GlobalSoloStateCommand::GlobalSoloStateCommand (Session& sess, const XMLNode& node)
 271         : Session::GlobalRouteStateCommand (sess, node)
 272 {
 273 }
 274
 275 void
 276 Session::GlobalSoloStateCommand::mark()
 277 {
 278     after = sess.get_global_route_boolean(&Route::soloed);
 279 }
 280
 281 void
 282 Session::GlobalSoloStateCommand::operator()()
 283 {
 284     sess.set_global_solo(after, src);
 285 }
 286
 287 void
 288 Session::GlobalSoloStateCommand::undo()
 289 {
 290     sess.set_global_solo(before, src);
 291 }
 292
 293 XMLNode&
 294 Session::GlobalSoloStateCommand::get_state()
 295 {
 296         XMLNode& node = GlobalRouteStateCommand::get_state();
 297         node.add_property ("type", "solo");
 298         return node;
 299 }
 300
 301 // mute
 302 Session::GlobalMuteStateCommand::GlobalMuteStateCommand(Session &sess, void *src)
 303         : GlobalRouteStateCommand (sess, src)
 304 {
 305     after = before = sess.get_global_route_boolean(&Route::muted);
 306 }
 307
 308 Session::GlobalMuteStateCommand::GlobalMuteStateCommand (Session& sess, const XMLNode& node)
 309         : Session::GlobalRouteStateCommand (sess, node)
 310 {
 311 }
 312
 313 void
 314 Session::GlobalMuteStateCommand::mark()
 315 {
 316         after = sess.get_global_route_boolean(&Route::muted);
 317 }
 318
 319 void
 320 Session::GlobalMuteStateCommand::operator()()
 321 {
 322         sess.set_global_mute(after, src);
 323 }
 324
 325 void
 326 Session::GlobalMuteStateCommand::undo()
 327 {
 328         sess.set_global_mute(before, src);
 329 }
 330
 331 XMLNode&
 332 Session::GlobalMuteStateCommand::get_state()
 333 {
 334         XMLNode& node = GlobalRouteStateCommand::get_state();
 335         node.add_property ("type", "mute");
 336         return node;
 337 }
 338
 339 // record enable
 340 Session::GlobalRecordEnableStateCommand::GlobalRecordEnableStateCommand(Session &sess, void *src)
 341         : GlobalRouteStateCommand (sess, src)
 342 {
 343         after = before = sess.get_global_route_boolean(&Route::record_enabled);
 344 }
 345
 346 Session::GlobalRecordEnableStateCommand::GlobalRecordEnableStateCommand (Session& sess, const XMLNode& node)
 347         : Session::GlobalRouteStateCommand (sess, node)
 348 {
 349 }
 350
 351 void
 352 Session::GlobalRecordEnableStateCommand::mark()
 353 {
 354         after = sess.get_global_route_boolean(&Route::record_enabled);
 355 }
 356
 357 void
 358 Session::GlobalRecordEnableStateCommand::operator()()
 359 {
 360         sess.set_global_record_enable(after, src);
 361 }
 362
 363 void
 364 Session::GlobalRecordEnableStateCommand::undo()
 365 {
 366         sess.set_global_record_enable(before, src);
 367 }
 368
 369 XMLNode&
 370 Session::GlobalRecordEnableStateCommand::get_state()
 371 {
 372         XMLNode& node = GlobalRouteStateCommand::get_state();
 373         node.add_property ("type", "rec-enable");
 374         return node;
 375 }
 376
 377 // metering
 378 Session::GlobalMeteringStateCommand::GlobalMeteringStateCommand(Session &s, void *p)
 379         : sess (s), src (p)
 380 {
 381         after = before = sess.get_global_route_metering();
 382 }
 383
 384 Session::GlobalMeteringStateCommand::GlobalMeteringStateCommand (Session& s, const XMLNode& node)
 385         : sess (s), src (this)
 386 {
 387         if (set_state (node)) {
 388                 throw failed_constructor();
 389         }
 390 }
 391
 392 void
 393 Session::GlobalMeteringStateCommand::mark()
 394 {
 395         after = sess.get_global_route_metering();
 396 }
 397
 398 void
 399 Session::GlobalMeteringStateCommand::operator()()
 400 {
 401         sess.set_global_route_metering(after, src);
 402 }
 403
 404 void
 405 Session::GlobalMeteringStateCommand::undo()
 406 {
 407         sess.set_global_route_metering(before, src);
 408 }
 409
 410 XMLNode&
 411 Session::GlobalMeteringStateCommand::get_state()
 412 {
 413         XMLNode* node = new XMLNode (X_("GlobalRouteStateCommand"));
 414         XMLNode* nbefore = new XMLNode (X_("before"));
 415         XMLNode* nafter = new XMLNode (X_("after"));
 416
 417         for (Session::GlobalRouteMeterState::iterator x = before.begin(); x != before.end(); ++x) {
 418                 XMLNode* child = new XMLNode ("s");
 419                 boost::shared_ptr<Route> r = x->first.lock();
 420
 421                 if (r) {
 422                         child->add_property (X_("id"), r->id().to_s());
 423
 424                         const char* meterstr = 0;
 425
 426                         switch (x->second) {
 427                         case MeterInput:
 428                                 meterstr = X_("input");
 429                                 break;
 430                         case MeterPreFader:
 431                                 meterstr = X_("pre");
 432                                 break;
 433                         case MeterPostFader:
 434                                 meterstr = X_("post");
 435                                 break;
 436                         default:
 437                                 fatal << string_compose (_("programming error: %1") , "no meter state in Session::GlobalMeteringStateCommand::get_state") << endmsg;
 438                         }
 439
 440                         child->add_property (X_("meter"), meterstr);
 441                         nbefore->add_child_nocopy (*child);
 442                 }
 443         }
 444
 445         for (Session::GlobalRouteMeterState::iterator x = after.begin(); x != after.end(); ++x) {
 446                 XMLNode* child = new XMLNode ("s");
 447                 boost::shared_ptr<Route> r = x->first.lock();
 448
 449                 if (r) {
 450                         child->add_property (X_("id"), r->id().to_s());
 451
 452                         const char* meterstr;
 453
 454                         switch (x->second) {
 455                         case MeterInput:
 456                                 meterstr = X_("input");
 457                                 break;
 458                         case MeterPreFader:
 459                                 meterstr = X_("pre");
 460                                 break;
 461                         case MeterPostFader:
 462                                 meterstr = X_("post");
 463                                 break;
 464                         default: meterstr = "";
 465                         }
 466
 467                         child->add_property (X_("meter"), meterstr);
 468                         nafter->add_child_nocopy (*child);
 469                 }
 470         }
 471
 472         node->add_child_nocopy (*nbefore);
 473         node->add_child_nocopy (*nafter);
 474
 475         node->add_property ("type", "metering");
 476
 477         return *node;
 478 }
 479
 480 int
 481 Session::GlobalMeteringStateCommand::set_state (const XMLNode& node)
 482 {
 483         GlobalRouteBooleanState states;
 484         XMLNodeList nlist;
 485         const XMLProperty* prop;
 486         XMLNode* child;
 487         XMLNodeConstIterator niter;
 488         int loop;
 489
 490         before.clear ();
 491         after.clear ();
 492
 493         for (loop = 0; loop < 2; ++loop) {
 494
 495                 const char *str;
 496
 497                 if (loop) {
 498                         str = "after";
 499                 } else {
 500                         str = "before";
 501                 }
 502
 503                 if ((child = node.child (str)) == 0) {
 504                         warning << string_compose (_("global route meter state command has no \"%1\" node, ignoring entire command"), str) << endmsg;
 505                         return -1;
 506                 }
 507
 508                 nlist = child->children();
 509
 510                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 511
 512                         RouteMeterState rms;
 513                         boost::shared_ptr<Route> route;
 514                         ID id;
 515
 516                         prop = (*niter)->property ("id");
 517                         id = prop->value ();
 518
 519                         if ((route = sess.route_by_id (id)) == 0) {
 520                                 warning << string_compose (_("cannot find track/bus \"%1\" while rebuilding a global route state command, ignored"), id.to_s()) << endmsg;
 521                                 continue;
 522                         }
 523
 524                         rms.first = boost::weak_ptr<Route> (route);
 525
 526                         prop = (*niter)->property ("meter");
 527
 528                         if (prop->value() == X_("pre")) {
 529                                 rms.second = MeterPreFader;
 530                         } else if (prop->value() == X_("post")) {
 531                                 rms.second = MeterPostFader;
 532                         } else {
 533                                 rms.second = MeterInput;
 534                         }
 535
 536                         if (loop) {
 537                                 after.push_back (rms);
 538                         } else {
 539                                 before.push_back (rms);
 540                         }
 541                 }
 542         }
 543
 544         return 0;
 545 }