noop: indentation

[ardour.git] / libs / ardour / session.cc

diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index e6e6f5f17aad44ab4fb4de8506ec60995a1d2316..7706aeb37af609fd9ed5c08c215567cb5c9c788a 100644 (file)
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -46,6 +46,7 @@
 #include "pbd/search_path.h"
 #include "pbd/stacktrace.h"
 #include "pbd/stl_delete.h"
+#include "pbd/replace_all.h"
 #include "pbd/unwind.h"
 
 #include "ardour/amp.h"
@@ -404,7 +405,8 @@ Session::Session (AudioEngine &eng,
                                string track_name = "";
                                for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
                                        string track_name;
-                                       remove_pattern_from_string(inputs[i], "system:capture:", track_name);
+                                       track_name = inputs[i];
+                                       replace_all (track_name, "system:capture", "");
                                        
                                        list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
                                        tracks.insert(tracks.begin(), single_track.front());
@@ -1535,9 +1537,21 @@ Session::set_auto_loop_location (Location* location)
        location->StartChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
        location->EndChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
        location->Changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
+       location->FlagsChanged.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, location));
 
        location->set_auto_loop (true, this);
 
+       if (Config->get_loop_is_mode() && play_loop && Config->get_seamless_loop()) {
+               // set all tracks to use internal looping
+               boost::shared_ptr<RouteList> rl = routes.reader ();
+               for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+                       boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+                       if (tr && !tr->hidden()) {
+                               tr->set_loop (location);
+                       }
+               }
+       }
+    
        /* take care of our stuff first */
 
        auto_loop_changed (location);
@@ -1562,10 +1576,10 @@ Session::update_marks (Location*)
 void
 Session::update_skips (Location* loc, bool consolidate)
 {
-    if (_ignore_skips_updates) {
-        return;
-    }
-    
+       if (_ignore_skips_updates) {
+               return;
+       }
+       
        Locations::LocationList skips;
 
         if (consolidate) {
@@ -2652,6 +2666,74 @@ Session::reconnect_midi_scene_ports(bool inputs)
     }
 }
 
+void
+Session::reconnect_mtc_ports()
+{
+#if 0
+       boost::shared_ptr<MidiPort> mtc_in_ptr = _midi_ports->mtc_input_port();
+
+       if (mtc_in_ptr) {
+               mtc_in_ptr->disconnect_all ();
+        
+               std::vector<EngineStateController::MidiPortState> midi_port_states;
+               EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
+        
+               std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
+        
+               for (; state_iter != midi_port_states.end(); ++state_iter) {
+                       if (state_iter->available && state_iter->mtc_in) {
+                               mtc_in_ptr->connect (state_iter->name);
+                       }
+               }
+        
+               if (!_midi_ports->mtc_input_port ()->connected () &&
+                   config.get_external_sync () &&
+                   (Config->get_sync_source () == MTC) ) {
+                       config.set_external_sync (false);
+               }
+               if ( ARDOUR::Profile->get_trx () ) {
+                       // Tracks need this signal to update timecode_source_dropdown
+                       MtcOrLtcInputPortChanged (); //emit signal
+               }
+       }
+#endif
+}
+
+void
+Session::reconnect_mmc_ports(bool inputs)
+{
+       if (inputs ) { // get all enabled midi input ports
+        
+               boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
+               if (mmc_in_ptr) {
+                       mmc_in_ptr->disconnect_all ();
+                       std::vector<std::string> enabled_midi_inputs;
+                       EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
+            
+                       std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
+            
+                       for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
+                               mmc_in_ptr->connect (*port_iter);
+                       }
+
+               }
+       } else { // get all enabled midi output ports
+        
+               boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
+               if (mmc_out_ptr ) {
+                       mmc_out_ptr->disconnect_all ();
+                       std::vector<std::string> enabled_midi_outputs;
+                       EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
+            
+                       std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
+            
+                       for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
+                               mmc_out_ptr->connect (*port_iter);
+                       }
+               }
+       }
+}
+
 #endif
 
 /** Caller must not hold process lock
@@ -2693,6 +2775,20 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
                                goto failed;
                        }
 
+                       if (ARDOUR::Profile->get_trx ()) {
+                               // TRACKS considers it's not a USE CASE, it's
+                               // a piece of behavior of the session model:
+                               //
+                               // Gain for a newly created route depends on
+                               // the current output_auto_connect mode:
+                               //
+                               //  0 for Stereo Out mode
+                               //  0 Multi Out mode
+                               if (Config->get_output_auto_connect() & AutoConnectMaster) {
+                                       track->set_gain (dB_to_coefficient (0), 0);
+                               }
+                       }
+
                        track->use_new_diskstream();
 
 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS