Add plug-in management dialog, delete plug-in map

examples/plugin_text/CMakeLists.txt

@@ -1,6 +1,9 @@
 file(GLOB_RECURSE CPPS ./*.cpp)
 file(GLOB_RECURSE HPPS ./*.hpp)
 
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${PROJECT_BINARY_DIR}/bin/Debug/nodes")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${PROJECT_BINARY_DIR}/bin/Release/nodes")
+
 add_library(plugin_text SHARED ${CPPS} ${HPPS})
 
 target_link_libraries(plugin_text QtNodes)

examples/plugin_text/PluginDefinition.cpp

@@ -8,6 +8,12 @@ Plugin::
 Plugin()
 { _this_plugin = this; }
 
+Plugin::
+~Plugin()
+{
+  // TODO: Unregister all models here
+}
+
 void
 Plugin::
 registerDataModels(std::shared_ptr<QtNodes::NodeDelegateModelRegistry> & reg)

examples/plugin_text/PluginDefinition.hpp

@@ -5,16 +5,12 @@
 #include <QtNodes/PluginInterface>
 
 // This needs to be the same as the name of your project file ${PROJECT_NAME}
-// 这里需要和您的工程文件名一致 ${PROJECT_NAME}
-#if defined(plugin_text_EXPORTS) 
+#ifdef plugin_text_EXPORTS
 #define DLL_EXPORT Q_DECL_EXPORT
 #else
 #define DLL_EXPORT Q_DECL_IMPORT
 #endif
 
-using QtNodes::NodeDelegateModelRegistry;
-using QtNodes::PluginInterface;
-
 #define PLUGIN_NAME "pluginText"
 
 class DLL_EXPORT Plugin
@@ -27,6 +23,7 @@ class DLL_EXPORT Plugin
 
 public:
   Plugin();
+  ~Plugin();
 
   QString
   name() const override

examples/plugins_load/PluginsManagerDlg.cpp

@@ -0,0 +1,168 @@
+#include "PluginsManagerDlg.hpp"
+
+#include <QTableView>
+#include <QPushButton>
+#include <QGridLayout>
+#include <QHeaderView>
+#include <QDir>
+#include <QFileDialog>
+#include <QDesktopServices>
+#include <QCoreApplication>
+
+#include <QtNodes/NodeDelegateModelRegistry>
+#include <QtNodes/PluginInterface>
+
+using QtNodes::NodeDelegateModelRegistry;
+using QtNodes::PluginInterface;
+
+PluginsManagerDlg::
+PluginsManagerDlg(QWidget* parent) 
+  : QDialog(parent)
+{
+  setMinimumSize(300, 250);
+
+  _pluginsFolder.setPath(QDir::cleanPath(QCoreApplication::applicationDirPath() + QDir::separator() + R"(./nodes)"));
+
+  QGridLayout *layout = new QGridLayout();
+  setLayout(layout);
+
+  QTableView *pluginTable = new QTableView();
+  pluginTable->setSelectionBehavior(QAbstractItemView::SelectRows);  
+  pluginTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
+  pluginTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+  layout->addWidget(pluginTable, 0, 0, 1, 2);
+
+  _model = new QStandardItemModel(pluginTable);
+
+  _model->setColumnCount(2);
+  _model->setHeaderData(0, Qt::Horizontal, "Name");
+  _model->setHeaderData(1, Qt::Horizontal, "Version");
+  pluginTable->setModel(_model);
+
+  loadPluginsFromFolder();
+
+  pluginTable->selectRow(0);
+
+  // add button
+  QPushButton *addButton = new QPushButton("+");
+  layout->addWidget(addButton, 1, 0);
+  connect(addButton, &QPushButton::clicked, this,
+          [this]()
+          {
+            // TODO: How to switch different suffixes according to different os
+            QString fileName =
+                QFileDialog::getOpenFileName(this,
+                                             tr("Load Plugin"),
+                                             QCoreApplication::applicationDirPath(),
+                                             tr("*.dll;*.so;*.dylib"));
+
+            if (!QFileInfo::exists(fileName))
+              return;
+
+            QFileInfo f(fileName);
+
+            QFileInfo newFile(
+                QDir::cleanPath(_pluginsFolder.absolutePath() + QDir::separator() + f.fileName()));
+            QString const newPath = newFile.absoluteFilePath();
+
+            if (f.absoluteFilePath() == newPath)
+                return;
+
+            // Copy to the plug-in directory
+            if (!QFile::copy(f.absoluteFilePath(), newPath))
+                return;
+
+            PluginsManager* pluginsManager = PluginsManager::instance();
+            auto plugin = pluginsManager->loadPluginFromPath(newPath);
+            if (!plugin)
+            {
+              QFile::remove(newPath);
+              return;
+            }
+
+            QStandardItem *item = new QStandardItem(plugin->name());
+            item->setData(newPath);
+            _model->appendRow(item);
+
+            std::shared_ptr<NodeDelegateModelRegistry> reg = pluginsManager->registry();
+            plugin->registerDataModels(reg);
+          });
+
+  // delete button
+  QPushButton *deleteButton = new QPushButton("-", this);
+  layout->addWidget(deleteButton, 1, 1);
+  connect(deleteButton,
+          &QPushButton::clicked,
+          this,
+          [this, pluginTable]()
+          {
+            QItemSelectionModel *selectionModel = pluginTable->selectionModel();
+
+            int row = selectionModel->currentIndex().row();
+
+            while (selectionModel->selectedRows().count() > 0)
+            {
+              auto rowIdx = selectionModel->selectedRows().first();
+              row = std::min(row, rowIdx.row());
+
+              QStandardItem *item = _model->itemFromIndex(rowIdx);
+
+              PluginsManager *pluginsManager = PluginsManager::instance();
+
+              // FIXME: Unload plugin successfully, but cannot delete the plugin file
+              if (!pluginsManager->unloadPluginFromName(item->text()) ||
+                  !QFile::remove(item->data().toString()))
+              {
+                selectionModel->select(rowIdx, QItemSelectionModel::Deselect);
+                continue;
+              }
+
+              _model->removeRow(rowIdx.row());
+            }
+
+            pluginTable->selectRow(row);
+          });
+}
+
+PluginsManagerDlg::
+~PluginsManagerDlg()
+{
+  //
+}
+
+void
+PluginsManagerDlg::
+openPluginsFolder()
+{
+  // QDesktopServices::openUrl(QUrl::fromLocalFile(_pluginsFolderPath));
+  QDesktopServices::openUrl(QUrl(_pluginsFolder.absolutePath()));
+}
+
+QString
+PluginsManagerDlg::
+pluginsFolderPath() const
+{
+  return _pluginsFolder.absolutePath();
+}
+
+void
+PluginsManagerDlg::
+loadPluginsFromFolder()
+{
+  PluginsManager* pluginsManager = PluginsManager::instance();
+  std::shared_ptr<NodeDelegateModelRegistry> registry = pluginsManager->registry();
+  pluginsManager->loadPlugins(_pluginsFolder.absolutePath());
+
+  for(auto l : pluginsManager->loaders())
+  {
+    PluginInterface* plugin = qobject_cast<PluginInterface*>(l.second->instance());
+    if (!plugin)
+      continue;
+
+    QStandardItem *item = new QStandardItem(plugin->name());
+    item->setData(l.second->fileName());
+    _model->appendRow(item);
+
+    plugin->registerDataModels(registry);
+  }
+}

examples/plugins_load/PluginsManagerDlg.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <QDir>
+#include <QDialog>
+#include <QStandardItemModel>
+
+#include <QtNodes/PluginsManager>
+
+using QtNodes::PluginsManager;
+
+class PluginsManagerDlg : public QDialog
+{
+public:
+  PluginsManagerDlg(QWidget* parent = nullptr);
+
+  virtual
+  ~PluginsManagerDlg();
+
+public:
+  void
+  openPluginsFolder();
+
+  QString
+  pluginsFolderPath() const;
+
+private:
+  void
+  loadPluginsFromFolder();
+
+private:
+  QDir _pluginsFolder;
+
+  QStandardItemModel* _model = nullptr;
+};

examples/plugins_load/main.cpp

@@ -10,6 +10,8 @@
 #include <QtNodes/NodeDelegateModelRegistry>
 #include <QtNodes/PluginsManager>
 
+#include "PluginsManagerDlg.hpp"
+
 using QtNodes::DataFlowGraphicsScene;
 using QtNodes::DataFlowGraphModel;
 using QtNodes::GraphicsView;
@@ -37,50 +39,32 @@ main(int argc, char* argv[])
 {
   qSetMessagePattern(
     "[%{time yyyyMMdd h:mm:ss.zzz}] [%{time process}] "
-    "[%{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-"
-    "fatal}F%{endif}]: %{message}\t| (%{function}) [%{file}:%{line}]");
+    "[%{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}"
+    "%{if-fatal}F%{endif}]: %{message}\t| (%{function}) [%{file}:%{line}]");
 
   QApplication app(argc, argv);
 
   setStyle();
 
-  PluginsManager* pluginsManager = PluginsManager::instance();
-  std::shared_ptr<NodeDelegateModelRegistry> registry = pluginsManager->registry();
-  pluginsManager->loadPlugins(R"(./nodes)");
-  for (auto plugin : pluginsManager->plugins())
-  {
-    plugin.second->registerDataModels(registry);
-  }
-
   QWidget mainWidget;
 
+  // Load plugins and register models
+  PluginsManagerDlg pluginsManagerDlg(&mainWidget);
+
   auto menuBar = new QMenuBar();
   QMenu* menu = menuBar->addMenu("Plugins");
-  auto loadAction = menu->addAction("Load Plugin");
-  auto unloadAction = menu->addAction("Unload Plugin");
-
-  QObject::connect(loadAction, &QAction::triggered, 
-                  [&]()
-                  {
-                    // TODO: load plugins
-                    QString fileName =
-                      QFileDialog::getOpenFileName(nullptr,
-                                                  "Load Plugin",
-                                                  QDir::homePath());
-
-                    if (!QFileInfo::exists(fileName))
-                      return;
-
-                    auto plugin = pluginsManager->loadPluginFromPath(fileName);
-                    if (plugin)
-                    {
-                      plugin->registerDataModels(registry);
-                    }
-                  });
+  auto pluginsManagerAction = menu->addAction("Plugins Manager");
+  auto pluginsFloderAction = menu->addAction("Open Plugins Folder");
+
+  QObject::connect(pluginsManagerAction, &QAction::triggered, 
+                  &pluginsManagerDlg, &PluginsManagerDlg::exec);
+
+  QObject::connect(pluginsFloderAction, &QAction::triggered, 
+                  &pluginsManagerDlg, &PluginsManagerDlg::openPluginsFolder);
 
   QVBoxLayout* l = new QVBoxLayout(&mainWidget);
 
-  DataFlowGraphModel dataFlowGraphModel(registry);
+  DataFlowGraphModel dataFlowGraphModel(PluginsManager::instance()->registry());
 
   l->addWidget(menuBar);
   auto scene = new DataFlowGraphicsScene(dataFlowGraphModel,

include/QtNodes/internal/PluginsManager.hpp

@@ -43,34 +43,36 @@ class NODE_EDITOR_PUBLIC PluginsManager
   PluginInterface*
   loadPluginFromPath(const QString &filePath);
 
+  std::vector<PluginInterface*>
+  loadPluginFromPaths(const QStringList filePaths);
+
   /**
    * @brief Unload the plugin from the full file path
    * 
    * @param filePath "C:/plugin_text.dll"
-   * @return int 
+   * @return bool 
    */
-  int
+  bool
   unloadPluginFromPath(const QString &filePath);
 
   /**
    * @brief Uninstall a plugin by its name, not its file name
    * 
    * @param pluginName "pluginText"
-   * @return int 
+   * @return bool 
    */
-  int
+  bool
   unloadPluginFromName(const QString &pluginName);
 
   inline
-  std::unordered_map<QString, PluginInterface*>
-  plugins()
-  { return _plugins; };
+  std::unordered_map<QString, QPluginLoader*>
+  loaders()
+  { return _loaders; };
 
 private:
   static PluginsManager* _instance;
 
-  std::unordered_map<QString, PluginInterface*> _plugins;
-  std::unordered_map<QString, QPluginLoader*> _loaders; ///< plugin path
+  std::unordered_map<QString, QPluginLoader*> _loaders;   // plugin name
 
   std::shared_ptr<NodeDelegateModelRegistry> _register;
 };