Various small stuff to finish up last beta release

.clang-format

@@ -2,11 +2,10 @@
 BasedOnStyle: Google
 AlignAfterOpenBracket: DontAlign
 AllowAllConstructorInitializersOnNextLine: 'true'
-AllowShortBlocksOnASingleLine: 'true'
+AllowShortBlocksOnASingleLine: 'false'
 AllowShortCaseLabelsOnASingleLine: 'true'
 AllowShortFunctionsOnASingleLine: Inline
-AllowShortIfStatementsOnASingleLine: WithoutElse
-AllowShortLoopsOnASingleLine: 'true'
+AllowShortLoopsOnASingleLine: 'false'
 AlwaysBreakTemplateDeclarations: 'Yes'
 BinPackArguments: 'true'
 BinPackParameters: 'true'
@@ -28,7 +27,7 @@ BraceWrapping:
   SplitEmptyNamespace: false
 BreakBeforeBraces: Custom
 BreakConstructorInitializers: BeforeColon
-ColumnLimit: '100'
+ColumnLimit: '200'
 ConstructorInitializerAllOnOneLineOrOnePerLine: 'false'
 Cpp11BracedListStyle: 'true'
 DerivePointerAlignment: 'true'

README.md

@@ -36,10 +36,10 @@ For documentation, please see: https://scirun.readthedocs.io/en/latest/
 Please see https://scirun.readthedocs.io/en/latest/start/build.html
 
 #### Python API
-Please see https://scirun.readthedocs.io/en/latest/user_doc/python.html 
+Please see https://scirun.readthedocs.io/en/latest/user_doc/python.html
 
 ### Questions and Answers
-For help, email the testing mailing list at [email protected].
+For help, check out the discussion page: https://github.com/SCIInstitute/SCIRun/discussions.
 
 ### License and Credits
   For more information, please see: http://software.sci.utah.edu

src/CMakeLists.txt

@@ -752,6 +752,9 @@ SET_PROPERTY(TARGET Modules_Factory   PROPERTY FOLDER "Modules")
 SET_PROPERTY(TARGET Graphics_Glyphs   PROPERTY FOLDER "Graphics")
 SET_PROPERTY(TARGET Graphics_Widgets   PROPERTY FOLDER "Graphics")
 SET_PROPERTY(TARGET Graphics_Datatypes   PROPERTY FOLDER "Graphics")
+SET_PROPERTY(TARGET spire   PROPERTY FOLDER "Graphics")
+
+SET_PROPERTY(TARGET pugixml   PROPERTY FOLDER "Externals")
 
 IF(BUILD_TESTING)
   SET_PROPERTY(TARGET gmock         PROPERTY FOLDER "Testing Support")
@@ -796,6 +799,7 @@ IF(BUILD_TESTING)
   SET_PROPERTY(TARGET Core_ImportExport_Tests         PROPERTY FOLDER "Core/Tests")
   SET_PROPERTY(TARGET Core_IEPlugin_Tests         PROPERTY FOLDER "Core/Tests")
   SET_PROPERTY(TARGET Graphics_Widgets_Tests         PROPERTY FOLDER "Graphics/Tests")
+  SET_PROPERTY(TARGET Graphics_Datatypes_Tests PROPERTY FOLDER "Graphics/Tests")
 
   SET_PROPERTY(TARGET Engine_Network_Tests   PROPERTY FOLDER "Dataflow/Engine/Tests")
   SET_PROPERTY(TARGET Engine_Scheduler_Tests   PROPERTY FOLDER "Dataflow/Engine/Tests")

src/Dataflow/Engine/Controller/ControllerInterfaces.h

@@ -80,6 +80,7 @@ namespace Engine {
   typedef boost::signals2::signal<void (const Networks::ConnectionDescription&)> ConnectionAddedSignalType;
   typedef boost::signals2::signal<void (const Networks::ConnectionDescription&)> InvalidConnectionSignalType;
   typedef boost::signals2::signal<void (const Networks::ConnectionId&)> ConnectionRemovedSignalType;
+  typedef boost::signals2::signal<void (const Networks::ConnectionId&, bool)> ConnectionStatusChangedSignalType;
   typedef boost::signals2::signal<void (const Networks::ModuleId&, const Networks::PortId&)> PortAddedSignalType;
   typedef boost::signals2::signal<void (const Networks::ModuleId&, const Networks::PortId&)> PortRemovedSignalType;
   typedef boost::signals2::signal<void (int)> NetworkDoneLoadingSignalType;

src/Dataflow/Engine/Controller/NetworkEditorController.cc

@@ -524,6 +524,26 @@ boost::signals2::connection NetworkEditorController::connectNetworkDoneLoading(c
   return signals_.networkDoneLoading_.connect(subscriber);
 }
 
+boost::signals2::connection NetworkEditorController::connectConnectionStatusChanged(const ConnectionStatusChangedSignalType::slot_type& subscriber)
+{
+  return signals_.connectionStatusChanged_.connect(subscriber);
+}
+
+std::string NetworkEditorController::setConnectionStatus(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex, bool enable)
+{
+  auto conn = getNetwork()->lookupConnection(moduleIdFrom, fromIndex, moduleIdTo, toIndex);
+  if (conn)
+  {
+    conn->setDisable(!enable);
+    signals_.connectionStatusChanged_(conn->id_, enable);
+    return std::string("Connection status ") + (enable ? "enabled" : "disabled") + ": " + moduleIdFrom + "(" + std::to_string(fromIndex) + ")->" + moduleIdTo + "(" + std::to_string(toIndex) + ")";
+  }
+  else
+  {
+    return "Connection not found: " + moduleIdFrom + "(" + std::to_string(fromIndex) + ")->" + moduleIdTo + "(" + std::to_string(toIndex) + ")";
+  }
+}
+
 NetworkFileHandle NetworkEditorController::serializeNetworkFragment(ModuleFilter modFilter, ConnectionFilter connFilter) const
 {
   NetworkToXML conv(collabs_.serializationManager_);

src/Dataflow/Engine/Controller/NetworkEditorController.h

@@ -78,11 +78,10 @@ namespace Engine {
     ConnectionRemovedSignalType connectionRemoved_;
     InvalidConnectionSignalType invalidConnection_;
     NetworkDoneLoadingSignalType networkDoneLoading_;
-
+    ConnectionStatusChangedSignalType connectionStatusChanged_;
 
     bool signalSwitch_, loadingContext_;
 
-
     struct LoadingContext
     {
       explicit LoadingContext(bool& load);
@@ -121,6 +120,7 @@ namespace Engine {
 
     std::optional<Networks::ConnectionId> requestConnection(const Networks::PortDescriptionInterface* from, const Networks::PortDescriptionInterface* to) override;
     void removeConnection(const Networks::ConnectionId& id);
+    std::string setConnectionStatus(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex, bool enable);
 
     std::future<int> executeAll() override;
     void executeModule(const Networks::ModuleHandle& module, bool executeUpstream);
@@ -146,6 +146,7 @@ namespace Engine {
     boost::signals2::connection connectInvalidConnection(const InvalidConnectionSignalType::slot_type& subscriber);
     boost::signals2::connection connectPortAdded(const PortAddedSignalType::slot_type& subscriber);
     boost::signals2::connection connectPortRemoved(const PortRemovedSignalType::slot_type& subscriber);
+    boost::signals2::connection connectConnectionStatusChanged(const ConnectionStatusChangedSignalType::slot_type& subscriber);
 
     boost::signals2::connection connectStaticNetworkExecutionStarts(const ExecuteAllStartsSignalType::slot_type& subscriber);
     boost::signals2::connection connectStaticNetworkExecutionFinished(const ExecuteAllFinishesSignalType::slot_type& subscriber);

src/Dataflow/Engine/Controller/PythonImpl.cc

@@ -36,6 +36,7 @@
 #include <Dataflow/Network/NetworkInterface.h>
 #include <Dataflow/Network/ModuleDescription.h>
 #include <Dataflow/Network/PortInterface.h>
+#include <Dataflow/Network/Connection.h>
 #include <Dataflow/Serialization/Network/NetworkDescriptionSerialization.h>
 #include <Core/Algorithms/Base/AlgorithmBase.h>
 #include <Dataflow/Engine/Controller/PythonImpl.h>
@@ -479,6 +480,11 @@ namespace
       return creationTime_;
     }
 
+    void setEnabled(bool enable) override
+    {
+      module_->setExecutionDisabled(!enable);
+    }
+
   private:
     ModuleHandle module_;
     NetworkEditorController& nec_;
@@ -487,19 +493,8 @@ namespace
   };
 }
 
-namespace SCIRun {
-  namespace Dataflow {
-    namespace Engine {
-      class PythonImplImpl
-      {
-      public:
-        std::map<std::string, std::map<int, std::map<std::string, std::map<int, std::string>>>> connectionIdLookup_;
-      };
-    }
-  }
-}
-
-PythonImpl::PythonImpl(NetworkEditorController& nec, GlobalCommandFactoryHandle cmdFactory) : impl_(new PythonImplImpl), nec_(nec), cmdFactory_(cmdFactory)
+PythonImpl::PythonImpl(NetworkEditorController& nec, GlobalCommandFactoryHandle cmdFactory) :
+  nec_(nec), cmdFactory_(cmdFactory)
 {
   connections_.push_back(nec_.connectStaticNetworkExecutionFinished([this](int) { executionFromPythonFinish(0); }));
   connections_.push_back(nec_.connectModuleAdded([this](const std::string& id, ModuleHandle m, ModuleCounter mc) { pythonModuleAddedSlot(id, m, mc); }));
@@ -595,29 +590,29 @@ std::string PythonImpl::connect(const std::string& moduleIdFrom, int fromIndex,
   auto modTo = network->lookupModule(ModuleId(moduleIdTo));
   auto inputPort = modTo->inputPorts().at(toIndex);
   auto id = nec_.requestConnection(outputPort.get(), inputPort.get());
-  if (id)
-  {
-    impl_->connectionIdLookup_[moduleIdFrom][fromIndex][moduleIdTo][toIndex] = id->id_;
-  }
-
-  return "PythonImpl::connect success";
+  return "PythonImpl::connect success: " + id->id_;
 }
 
 std::string PythonImpl::disconnect(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex)
 {
   //TODO: doesn't work at all since there is no GUI connection to this network change event. Issue is #...
-  auto id = impl_->connectionIdLookup_[moduleIdFrom][fromIndex][moduleIdTo][toIndex];
-  if (!id.empty())
+  auto conn = nec_.getNetwork()->lookupConnection(moduleIdFrom, fromIndex, moduleIdTo, toIndex);
+  if (conn)
   {
-    nec_.removeConnection(id);
-    return "PythonImpl::disconnect IS NOT IMPLEMENTED";
+    nec_.removeConnection(conn->id());
+    return "PythonImpl::disconnect is not connected to GUI";
   }
   else
   {
     return "PythonImpl::disconnect: connection not found";
   }
 }
 
+std::string PythonImpl::setConnectionStatus(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex, bool enable)
+{
+  return nec_.setConnectionStatus(moduleIdFrom, fromIndex, moduleIdTo, toIndex, enable);
+}
+
 std::string PythonImpl::saveNetwork(const std::string& filename)
 {
   auto save = cmdFactory_->create(GlobalCommands::SaveNetworkFile);

src/Dataflow/Engine/Controller/PythonImpl.h

@@ -64,6 +64,7 @@ namespace Engine {
     std::string importNetwork(const std::string& filename) override;
     std::string runScript(const std::string& filename) override;
     std::string quit(bool force) override;
+    std::string setConnectionStatus(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex, bool enable) override;
     void setUnlockFunc(boost::function<void()> unlock) override;
     void setModuleContext(bool inModule) override { inModule_ = inModule; }
     bool isModuleContext() const override { return inModule_; }
@@ -72,7 +73,6 @@ namespace Engine {
     void pythonModuleRemovedSlot(const Networks::ModuleId&);
     void executionFromPythonStart();
     void executionFromPythonFinish(int);
-    SharedPointer<PythonImplImpl> impl_;
     std::map<std::string, SharedPointer<PyModule>> modules_;
     NetworkEditorController& nec_;
     Core::Commands::GlobalCommandFactoryHandle cmdFactory_;

src/Dataflow/Engine/Python/NetworkEditorPythonAPI.cc

@@ -483,6 +483,16 @@ boost::python::object NetworkEditorPythonAPI::scirun_get_module_input_value(cons
   return {};
 }
 
+std::string NetworkEditorPythonAPI::scirun_enable_connection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex)
+{
+  return impl_->setConnectionStatus(moduleIdFrom, fromIndex, moduleIdTo, toIndex, true);
+}
+
+std::string NetworkEditorPythonAPI::scirun_disable_connection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex)
+{
+  return impl_->setConnectionStatus(moduleIdFrom, fromIndex, moduleIdTo, toIndex, false);
+}
+
 boost::python::object SimplePythonAPI::scirun_module_ids()
 {
   auto mods = NetworkEditorPythonAPI::modules();

src/Dataflow/Engine/Python/NetworkEditorPythonAPI.h

@@ -72,6 +72,9 @@ namespace SCIRun {
     static boost::python::dict get_output_data(const std::string& moduleId);
     static std::string set_output_data(const std::string& moduleId, const boost::python::dict& outputMap);
 
+    static std::string scirun_enable_connection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex);
+    static std::string scirun_disable_connection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex);
+
     static std::string executeAll();
     static std::string saveNetwork(const std::string& filename);
     static std::string loadNetwork(const std::string& filename);

src/Dataflow/Engine/Python/NetworkEditorPythonInterface.h

@@ -65,6 +65,7 @@ namespace SCIRun
     //ports
     virtual SharedPointer<class PyPorts> output() = 0;
     virtual SharedPointer<class PyPorts> input() = 0;
+    virtual void setEnabled(bool enable) = 0;
 
     //time added to network, for id sorting
     virtual boost::posix_time::ptime creationTime() const = 0;
@@ -130,6 +131,7 @@ namespace SCIRun
     virtual SharedPointer<PyModule> findModule(const std::string& id) const = 0;
     virtual std::string connect(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex) = 0;
     virtual std::string disconnect(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex) = 0;
+    virtual std::string setConnectionStatus(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex, bool enable) = 0;
     virtual std::string executeAll() = 0;
     virtual std::string saveNetwork(const std::string& filename) = 0;
     virtual std::string loadNetwork(const std::string& filename) = 0;

src/Dataflow/Engine/Python/SCIRunPythonModule.h

@@ -100,6 +100,9 @@ BOOST_PYTHON_MODULE(SCIRunPythonAPI)
   boost::python::def("get_output_data", &NetworkEditorPythonAPI::get_output_data);
   boost::python::def("set_output_data", &NetworkEditorPythonAPI::set_output_data);
 
+  boost::python::def("scirun_enable_connection", &NetworkEditorPythonAPI::scirun_enable_connection);
+  boost::python::def("scirun_disable_connection", &NetworkEditorPythonAPI::scirun_disable_connection);
+
   boost::python::def("scirun_save_network", &NetworkEditorPythonAPI::saveNetwork);
   boost::python::def("scirun_load_network", &NetworkEditorPythonAPI::loadNetwork);
   boost::python::def("scirun_import_network", &NetworkEditorPythonAPI::importNetwork);

src/Dataflow/Network/Network.cc

@@ -140,9 +140,34 @@ bool Network::disconnect(const ConnectionId& id)
   return false;
 }
 
-void Network::disable_connection(const ConnectionId&)
+ConnectionHandle Network::lookupConnection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex) const
 {
-  /// @todo
+  auto fromMod = lookupModule(ModuleId(moduleIdFrom));
+  if (!fromMod)
+    return nullptr;
+  auto fromPorts = fromMod->outputPorts();
+  if (fromIndex < 0 || fromIndex >= fromPorts.size())
+    return nullptr;
+  const auto outputPortId = fromPorts[fromIndex]->externalId();
+
+  auto toMod = lookupModule(ModuleId(moduleIdTo));
+  if (!toMod)
+    return nullptr;
+  auto toPorts = toMod->inputPorts();
+  if (toIndex < 0 || toIndex >= toPorts.size())
+    return nullptr;
+  const auto inputPortId = toPorts[toIndex]->externalId();
+
+  const ConnectionId id = ConnectionId::create(ConnectionDescription(
+    OutgoingConnectionDescription(ModuleId(moduleIdFrom), outputPortId),
+    IncomingConnectionDescription(ModuleId(moduleIdTo), inputPortId)));
+  const auto connIter = connections_.find(id);
+  if (connIter != connections_.end())
+  {
+    return connIter->second;
+  }
+
+  return nullptr;
 }
 
 size_t Network::nmodules() const

src/Dataflow/Network/Network.h

@@ -61,7 +61,7 @@ namespace Networks {
     ConnectionId connect(const ConnectionOutputPort&, const ConnectionInputPort&) override;
     bool disconnect(const ConnectionId&) override;
     size_t nconnections() const override;
-    void disable_connection(const ConnectionId&) override;
+    ConnectionHandle lookupConnection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex) const override;
     ConnectionDescriptionList connections(bool includeVirtual) const override;
     int errorCode() const override;
     void incrementErrorCode(const ModuleId& moduleId) override;

src/Dataflow/Network/NetworkInterface.h

@@ -88,7 +88,7 @@ namespace Networks {
     virtual ConnectionId connect(const ConnectionOutputPort&, const ConnectionInputPort&) = 0;
     virtual bool disconnect(const ConnectionId&) = 0;
     virtual size_t nconnections() const = 0;
-    virtual void disable_connection(const ConnectionId&) = 0;
+    virtual ConnectionHandle lookupConnection(const std::string& moduleIdFrom, int fromIndex, const std::string& moduleIdTo, int toIndex) const = 0;
     virtual ConnectionDescriptionList connections(bool includeVirtual) const = 0;
     virtual void incrementErrorCode(const ModuleId& moduleId) = 0;
     virtual NetworkGlobalSettings& settings() = 0;

src/Dataflow/Network/Port.h

@@ -62,7 +62,6 @@ class SCISHARE Port : virtual public PortInterface, boost::noncopyable
   Connection* connection(size_t) const override;
   bool hasConnectionCountIncreased() const override;
 
-
   PortId internalId() const override { return internalId_; }
   void setId_DynamicCase(const PortId& id) override { internalId_ = externalId_ = id; }
   void setInternalId(const PortId& id) override { internalId_ = id; }

src/Dataflow/Network/Tests/MockNetwork.h

@@ -51,8 +51,8 @@ namespace SCIRun {
           MOCK_CONST_METHOD1(lookupExecutable, ExecutableObject*(const ModuleId&));
           MOCK_METHOD2(connect, ConnectionId(const ConnectionOutputPort&, const ConnectionInputPort&));
           MOCK_METHOD1(disconnect, bool(const ConnectionId&));
+          MOCK_CONST_METHOD4(lookupConnection, ConnectionHandle(const std::string&, int, const std::string&, int));
           MOCK_CONST_METHOD0(nconnections, size_t());
-          MOCK_METHOD1(disable_connection, void(const ConnectionId&));
           MOCK_CONST_METHOD0(toString, std::string());
           MOCK_CONST_METHOD1(connections, ConnectionDescriptionList(bool));
           MOCK_CONST_METHOD0(errorCode, int());