refactor MIDISceneChange color property addition by moving it into SceneChange to...

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

diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc
index 3ccc1f134b5ab808e5e37a35168d6dc57098e95a..fdac48e731124aa8620be3913c68bb239c8c6d6e 100644 (file)
--- a/libs/ardour/control_protocol_manager.cc
+++ b/libs/ardour/control_protocol_manager.cc
@@ -30,11 +30,7 @@
 #include "ardour/debug.h"
 #include "ardour/control_protocol_manager.h"
 
-#ifdef SearchPath
-#undef SearchPath
-#endif
-
-#include "ardour/control_protocol_search_path.h"
+#include "ardour/search_paths.h"
 
 
 using namespace ARDOUR;
@@ -78,26 +74,54 @@ ControlProtocolManager::set_session (Session* s)
 
                for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
                        if ((*i)->requested || (*i)->mandatory) {
-                               
-                               instantiate (**i);
-                               (*i)->requested = false;
-
-                               if ((*i)->protocol) {
-                                       if ((*i)->state) {
-                                               (*i)->protocol->set_state (*(*i)->state, Stateful::loading_state_version);
-                                       } else {
-                                               /* guarantee a call to
-                                                  set_state() whether we have
-                                                  existing state or not
-                                               */
-                                               (*i)->protocol->set_state (XMLNode(""), Stateful::loading_state_version);
-                                       }
-                               }
+                               (void) activate (**i);
                        }
                }
        }
 }
 
+int
+ControlProtocolManager::activate (ControlProtocolInfo& cpi)
+{
+       ControlProtocol* cp;
+
+       cpi.requested = true;
+
+       if ((cp = instantiate (cpi)) == 0) {
+               return -1;
+       }
+
+       /* we split the set_state() and set_active() operations so that
+          protocols that need state to configure themselves (e.g. "What device
+          is connected, or supposed to be connected?") can get it before
+          actually starting any interaction.
+       */
+
+       if (cpi.state) {
+               /* force this by tweaking the internals of the state
+                * XMLNode. Ugh.
+                */
+               cp->set_state (*cpi.state, Stateful::loading_state_version);
+       } else {
+               /* guarantee a call to
+                  set_state() whether we have
+                  existing state or not
+               */
+               cp->set_state (XMLNode(""), Stateful::loading_state_version);
+       }
+
+       cp->set_active (true);
+
+       return 0;
+}      
+
+int
+ControlProtocolManager::deactivate (ControlProtocolInfo& cpi)
+{
+       cpi.requested = false;
+       return teardown (cpi);
+}
+
 void
 ControlProtocolManager::session_going_away()
 {
@@ -169,6 +193,12 @@ ControlProtocolManager::teardown (ControlProtocolInfo& cpi)
        if (cpi.mandatory) {
                return 0;
        }
+       
+       /* save current state */
+
+       delete cpi.state;
+       cpi.state = new XMLNode (cpi.protocol->get_state());
+       cpi.state->add_property (X_("active"), "no");
 
        cpi.descriptor->destroy (cpi.descriptor, cpi.protocol);
 
@@ -215,14 +245,37 @@ ControlProtocolManager::discover_control_protocols ()
 {
        vector<std::string> cp_modules;
 
+#ifdef COMPILER_MSVC
+   /**
+    * Different build targets (Debug / Release etc) use different versions
+    * of the 'C' runtime (which can't be 'mixed & matched'). Therefore, in
+    * case the supplied search path contains multiple version(s) of a given
+    * module, only select the one(s) which match the current build target
+    */
+       #if defined (_DEBUG)
+               Glib::PatternSpec dll_extension_pattern("*D.dll");
+       #elif defined (RDC_BUILD)
+               Glib::PatternSpec dll_extension_pattern("*RDC.dll");
+       #elif defined (_WIN64)
+               Glib::PatternSpec dll_extension_pattern("*64.dll");
+       #else
+               Glib::PatternSpec dll_extension_pattern("*32.dll");
+       #endif
+#else
+       Glib::PatternSpec dll_extension_pattern("*.dll");
+#endif
+
        Glib::PatternSpec so_extension_pattern("*.so");
        Glib::PatternSpec dylib_extension_pattern("*.dylib");
 
-       find_matching_files_in_search_path (control_protocol_search_path (),
-                                           so_extension_pattern, cp_modules);
+       find_files_matching_pattern (cp_modules, control_protocol_search_path (),
+                                    dll_extension_pattern);
 
-       find_matching_files_in_search_path (control_protocol_search_path (),
-                                           dylib_extension_pattern, cp_modules);
+       find_files_matching_pattern (cp_modules, control_protocol_search_path (),
+                                    so_extension_pattern);
+
+       find_files_matching_pattern (cp_modules, control_protocol_search_path (),
+                                    dylib_extension_pattern);
 
        DEBUG_TRACE (DEBUG::ControlProtocols, 
                     string_compose (_("looking for control protocols in %1\n"), control_protocol_search_path().to_string()));
@@ -385,22 +438,21 @@ ControlProtocolManager::get_state ()
 
        for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
 
-               XMLNode * child;
-
                if ((*i)->protocol) {
-                       child = &((*i)->protocol->get_state());
-                       child->add_property (X_("active"), "yes");
-                       // should we update (*i)->state here?  probably.
-                       root->add_child_nocopy (*child);
+                       XMLNode& child_state ((*i)->protocol->get_state());
+                       child_state.add_property (X_("active"), "yes");
+                       root->add_child_nocopy (child_state);
                } else if ((*i)->state) {
-                       // keep ownership clear
-                       root->add_child_copy (*(*i)->state);
+                       XMLNode* child_state = new XMLNode (*(*i)->state);
+                       child_state->add_property (X_("active"), "no");
+                       root->add_child_nocopy (*child_state);
                } else {
-                       child = new XMLNode (X_("Protocol"));
-                       child->add_property (X_("name"), (*i)->name);
-                       child->add_property (X_("active"), "no");
-                       root->add_child_nocopy (*child);
+                       XMLNode* child_state = new XMLNode (X_("Protocol"));
+                       child_state->add_property (X_("name"), (*i)->name);
+                       child_state->add_property (X_("active"), "no");
+                       root->add_child_nocopy (*child_state);
                }
+
        }
 
        return *root;