Mesh: implemment mechanism to load MeshGui module when exporting to 3MF file

src/Mod/Mesh/App/AppMesh.cpp

@@ -26,6 +26,7 @@
 #include <Base/Interpreter.h>
 #include <App/Application.h>
 
+#include "Exporter.h"
 #include "Mesh.h"
 #include "MeshPy.h"
 #include "MeshPointPy.h"
@@ -68,6 +69,8 @@ PyMOD_INIT_FUNC(Mesh)
     Base::Interpreter().addType(&Mesh::MeshPy       ::Type,meshModule,"Mesh");
     Base::Interpreter().addType(&Mesh::MeshFeaturePy::Type,meshModule,"Feature");
 
+    Mesh::Extension3MFFactory::addProducer(new Mesh::GuiExtension3MFProducer);
+
     // init Type system
     Mesh::PropertyNormalList    ::init();
     Mesh::PropertyCurvatureList ::init();

src/Mod/Mesh/App/Exporter.cpp

@@ -229,25 +229,52 @@ bool MergeExporter::addMesh(const char *name, const MeshObject & mesh)
 
 // ----------------------------------------------------------------------------
 
-void Extension3MFFactory::addProducer(AbstractExtensionProducer* ext)
+AbstractFormatExtensionPtr GuiExtension3MFProducer::create() const
+{
+    return nullptr;
+}
+
+void GuiExtension3MFProducer::initialize()
+{
+    Base::PyGILStateLocker lock;
+    PyObject* module = PyImport_ImportModule("MeshGui");
+    if (module)
+        Py_DECREF(module);
+    else
+        PyErr_Clear();
+}
+
+void Extension3MFFactory::addProducer(Extension3MFProducer* ext)
 {
     producer.emplace_back(ext);
 }
 
+void Extension3MFFactory::initialize()
+{
+    std::vector<Extension3MFProducerPtr> ext = producer;
+    for (const auto& it : ext) {
+        it->initialize();
+    }
+}
+
 std::vector<Extension3MFPtr> Extension3MFFactory::create()
 {
     std::vector<Extension3MFPtr> ext;
-    for (const auto& it : producer)
-        ext.emplace_back(it->create());
+    for (const auto& it : producer) {
+        Extension3MFPtr ptr = std::dynamic_pointer_cast<Extension3MF>(it->create());
+        if (ptr)
+            ext.push_back(ptr);
+    }
     return ext;
 }
 
-std::vector<AbstractExtensionProducerPtr> Extension3MFFactory::producer;
+std::vector<Extension3MFProducerPtr> Extension3MFFactory::producer;
 
 class Exporter3MF::Private {
 public:
     explicit Private(const std::string& filename)
       : writer3mf(filename) {
+        Extension3MFFactory::initialize();
         ext = Extension3MFFactory::create();
     }
     MeshCore::Writer3MF writer3mf;

src/Mod/Mesh/App/Exporter.h

@@ -92,17 +92,32 @@ protected:
     std::string fName;
 };
 
+// ------------------------------------------------------------------------------------------------
+
+/*!
+ * \brief The AbstractExtension class
+ * Abstract base class for file format extensions
+ */
+class MeshExport AbstractFormatExtension
+{
+protected:
+    AbstractFormatExtension() = default;
+
+public:
+    virtual ~AbstractFormatExtension() = default;
+};
+
+using AbstractFormatExtensionPtr = std::shared_ptr<AbstractFormatExtension>;
+
 /*!
  * \brief The Extension3MF class
  * Abstract base class for 3MF extensions
  */
-class MeshExport Extension3MF
+class MeshExport Extension3MF : public AbstractFormatExtension
 {
 public:
     using Resource = MeshCore::Resource3MF;
     Extension3MF() = default;
-    virtual ~Extension3MF() = default;
-
     virtual Resource addMesh(const MeshObject & mesh) = 0;
 };
 
@@ -110,18 +125,43 @@ using Extension3MFPtr = std::shared_ptr<Extension3MF>;
 
 /*!
  * \brief The AbstractExtensionProducer class
- * Abstract base class to create an instance of an Extension3MF.
+ * Abstract base class to create an instance of an AbstractFormatExtension.
  */
 class MeshExport AbstractExtensionProducer
 {
 public:
     AbstractExtensionProducer() = default;
     virtual ~AbstractExtensionProducer() = default;
-    virtual Extension3MFPtr create() const = 0;
+    virtual AbstractFormatExtensionPtr create() const = 0;
 };
 
 using AbstractExtensionProducerPtr = std::shared_ptr<AbstractExtensionProducer>;
 
+/*!
+ * \brief The Extension3MFProducer class
+ * Abstract base class to create an instance of an Extension3MF.
+ */
+class MeshExport Extension3MFProducer : public AbstractExtensionProducer
+{
+public:
+    Extension3MFProducer() = default;
+    virtual void initialize() = 0;
+};
+
+using Extension3MFProducerPtr = std::shared_ptr<Extension3MFProducer>;
+
+/*!
+ * \brief The GuiExtension3MFProducer class
+ * This class tries to load the MeshGui module to register further 3MF extensions.
+ */
+class MeshExport GuiExtension3MFProducer : public Extension3MFProducer
+{
+public:
+    GuiExtension3MFProducer() = default;
+    void initialize() override;
+    AbstractFormatExtensionPtr create() const override;
+};
+
 /*!
  * \brief The Extension3MFFactory class
  * Factor class to manage the producers of Extension3MF
@@ -129,13 +169,16 @@ using AbstractExtensionProducerPtr = std::shared_ptr<AbstractExtensionProducer>;
 class MeshExport Extension3MFFactory
 {
 public:
-    static void addProducer(AbstractExtensionProducer* ext);
+    static void addProducer(Extension3MFProducer* ext);
+    static void initialize();
     static std::vector<Extension3MFPtr> create();
 
 private:
-    static std::vector<AbstractExtensionProducerPtr> producer;
+    static std::vector<Extension3MFProducerPtr> producer;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 /// Used for exporting to 3D Manufacturing Format (3MF)
 /*!
  * The constructor and destructor write the beginning and end of the 3MF,

src/Mod/Mesh/Gui/ThumbnailExtension.h

@@ -39,11 +39,12 @@ private:
     int index = 0;
 };
 
-class ThumbnailExtensionProducer : public Mesh::AbstractExtensionProducer {
+class ThumbnailExtensionProducer : public Mesh::Extension3MFProducer {
 public:
-    Mesh::Extension3MFPtr create() const override {
+    Mesh::AbstractFormatExtensionPtr create() const override {
         return std::make_shared<ThumbnailExtension3MF>();
     }
+    void initialize() override {}
 };
 
 } // namespace MeshGui