From facb4e7fe4bcc30539ea3fc79a23ab217735a5ab Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Wed, 2 Dec 2020 21:04:18 +0100 Subject: Do not store installers in InstallationManager, use the ones from PluginContainer. --- src/plugincontainer.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 5a485dfe..1fb8638f 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -301,6 +301,9 @@ void PluginContainer::setUserInterface(IUserInterface *userInterface) for (IPluginTool* tool : bf::at_key(m_Plugins)) { tool->setParentWidget(userInterface->mainWindow()); } + for (IPluginInstaller* installer : bf::at_key(m_Plugins)) { + installer->setParentWidget(userInterface->mainWindow()); + } } m_UserInterface = userInterface; @@ -537,7 +540,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam if (initPlugin(installer, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(installer); if (m_Organizer) { - m_Organizer->installationManager()->registerInstaller(installer); + installer->setInstallationManager(m_Organizer->installationManager()); } return installer; } -- cgit v1.3.1 From 4f7f378d8d6f9ec93d7e024ce73cda6b177fc490 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Wed, 2 Dec 2020 21:07:04 +0100 Subject: Add methods to load/reload/unload plugins. --- src/plugincontainer.cpp | 346 +++++++++++++++++++++++++++++++++++++----------- src/plugincontainer.h | 53 +++++++- 2 files changed, 322 insertions(+), 77 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 1fb8638f..3579a0d3 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -106,7 +106,7 @@ const std::set PluginRequirements::s_CorePlugins{ }; PluginRequirements::PluginRequirements( - PluginContainer* pluginContainer, MOBase::IPlugin* plugin, IOrganizer* proxy, + PluginContainer* pluginContainer, MOBase::IPlugin* plugin, OrganizerProxy* proxy, MOBase::IPluginProxy* pluginProxy) : m_PluginContainer(pluginContainer) , m_Plugin(plugin) @@ -431,6 +431,8 @@ bool PluginContainer::initPlugin(IPlugin *plugin, IPluginProxy *pluginProxy, boo return false; } + proxy->setParent(as_qobject(plugin)); + // Update requirements: it->second.fetchRequirements(); @@ -442,7 +444,12 @@ void PluginContainer::registerGame(IPluginGame *game) m_SupportedGames.insert({ game->gameName(), game }); } -IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileName, MOBase::IPluginProxy* pluginProxy) +void PluginContainer::unregisterGame(MOBase::IPluginGame* game) +{ + m_SupportedGames.erase(game->gameName()); +} + +IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString& filepath, MOBase::IPluginProxy* pluginProxy) { // generic treatment for all plugins @@ -462,7 +469,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam // If both plugins are from the same proxy and the same file, this is usually // ok (in theory some one could write two different classes from the same Python file/module): if (pluginProxy && m_Requirements.at(other).proxy() == pluginProxy - && as_qobject(other)->property("filepath") == fileName) { + && this->filepath(other) == QDir::cleanPath(filepath)) { // Plugin has already been initialized: skipInit = true; @@ -487,7 +494,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam // way to cast directly between IPlugin* and IPluginDiagnose* bf::at_key(m_Plugins).push_back(plugin); - plugin->setProperty("filepath", fileName); + plugin->setProperty("filepath", QDir::cleanPath(filepath)); if (m_Organizer) { m_Organizer->settings().plugins().registerPlugin(pluginObj); @@ -499,8 +506,8 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam bf::at_key(m_Plugins).push_back(diagnose); bf::at_key(m_AccessPlugins)[diagnose] = pluginObj; m_DiagnosisConnections.push_back( - diagnose->onInvalidated([&] () { emit diagnosisUpdate(); }) - ); + diagnose->onInvalidated([&] () { emit diagnosisUpdate(); }) + ); } } { // file mapper plugin @@ -514,6 +521,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam IPluginModPage *modPage = qobject_cast(plugin); if (initPlugin(modPage, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(modPage); + emit pluginRegistered(modPage); return modPage; } } @@ -524,6 +532,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam if (initPlugin(game, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(game); registerGame(game); + emit pluginRegistered(game); return game; } } @@ -532,6 +541,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam IPluginTool *tool = qobject_cast(plugin); if (initPlugin(tool, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(tool); + emit pluginRegistered(tool); return tool; } } @@ -542,6 +552,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam if (m_Organizer) { installer->setInstallationManager(m_Organizer->installationManager()); } + emit pluginRegistered(installer); return installer; } } @@ -557,55 +568,12 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam IPluginProxy *proxy = qobject_cast(plugin); if (initPlugin(proxy, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(proxy); - QStringList pluginNames = proxy->pluginList( - QCoreApplication::applicationDirPath() + "/" + ToQString(AppConfig::pluginPath())); - for (const QString &pluginName : pluginNames) { - try { - // We get a list of matching plugins as proxies can return multiple plugins - // per file and do not have a good way of supporting multiple inheritance. - QList matchingPlugins = proxy->load(pluginName); - - // We are going to group plugin by names and "fix" them later: - std::map> proxiedByNames; - - for (QObject *proxiedPlugin : matchingPlugins) { - if (proxiedPlugin != nullptr) { - - if (IPlugin* proxied = registerPlugin(proxiedPlugin, pluginName, proxy); proxied) { - log::debug("loaded plugin '{}' from '{}' - [{}]", - proxied->name(), QFileInfo(pluginName).fileName(), implementedInterfaces(proxied).join(", ")); - - // Store the plugin for later: - proxiedByNames[proxied->name()].push_back(proxied); - } - else { - log::warn( - "plugin \"{}\" failed to load. If this plugin is for an older version of MO " - "you have to update it or delete it if no update exists.", - pluginName); - } - } - } - - // Fake masters: - for (auto& [name, proxiedPlugins] : proxiedByNames) { - if (proxiedPlugins.size() > 1) { - auto it = std::min_element(std::begin(proxiedPlugins), std::end(proxiedPlugins), - [&](auto const& lhs, auto const& rhs) { - return isBetterInterface(as_qobject(lhs), as_qobject(rhs)); - }); - - for (auto& proxiedPlugin : proxiedPlugins) { - if (proxiedPlugin != *it) { - m_Requirements.at(proxiedPlugin).setMaster(*it); - } - } - } - } + emit pluginRegistered(proxy); - } catch (const std::exception &e) { - reportError(QObject::tr("failed to initialize plugin %1: %2").arg(pluginName).arg(e.what())); - } + QStringList filepaths = proxy->pluginList( + QCoreApplication::applicationDirPath() + "/" + ToQString(AppConfig::pluginPath())); + for (const QString& filepath : filepaths) { + loadProxied(filepath, proxy); } return proxy; } @@ -616,6 +584,7 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam IPlugin *dummy = qobject_cast(plugin); if (initPlugin(dummy, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(dummy); + emit pluginRegistered(dummy); return dummy; } } @@ -623,34 +592,59 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString &fileNam return nullptr; } -void PluginContainer::unloadPlugins() +std::vector PluginContainer::loadProxied(const QString& filepath, IPluginProxy* proxy) { - if (m_UserInterface != nullptr) { - m_UserInterface->disconnectPlugins(); - } + std::vector proxiedPlugins; - // disconnect all slots before unloading plugins so plugins don't have to take care of that - if (m_Organizer) { - m_Organizer->disconnectPlugins(); - } + try { + // We get a list of matching plugins as proxies can return multiple plugins + // per file and do not have a good way of supporting multiple inheritance. + QList matchingPlugins = proxy->load(filepath); - bf::for_each(m_Plugins, [](auto& t) { t.second.clear(); }); - bf::for_each(m_AccessPlugins, [](auto& t) { t.second.clear(); }); - m_Requirements.clear(); + // We are going to group plugin by names and "fix" them later: + std::map> proxiedByNames; - for (const boost::signals2::connection &connection : m_DiagnosisConnections) { - connection.disconnect(); - } - m_DiagnosisConnections.clear(); + for (QObject* proxiedPlugin : matchingPlugins) { + if (proxiedPlugin != nullptr) { - while (!m_PluginLoaders.empty()) { - QPluginLoader *loader = m_PluginLoaders.back(); - m_PluginLoaders.pop_back(); - if ((loader != nullptr) && !loader->unload()) { - log::debug("failed to unload {}: {}", loader->fileName(), loader->errorString()); + if (IPlugin* proxied = registerPlugin(proxiedPlugin, filepath, proxy); proxied) { + log::debug("loaded plugin '{}' from '{}' - [{}]", + proxied->name(), QFileInfo(filepath).fileName(), implementedInterfaces(proxied).join(", ")); + + // Store the plugin for later: + proxiedPlugins.push_back(proxied); + proxiedByNames[proxied->name()].push_back(proxied); + } + else { + log::warn( + "plugin \"{}\" failed to load. If this plugin is for an older version of MO " + "you have to update it or delete it if no update exists.", + filepath); + } + } + } + + // Fake masters: + for (auto& [name, proxiedPlugins] : proxiedByNames) { + if (proxiedPlugins.size() > 1) { + auto it = std::min_element(std::begin(proxiedPlugins), std::end(proxiedPlugins), + [&](auto const& lhs, auto const& rhs) { + return isBetterInterface(as_qobject(lhs), as_qobject(rhs)); + }); + + for (auto& proxiedPlugin : proxiedPlugins) { + if (proxiedPlugin != *it) { + m_Requirements.at(proxiedPlugin).setMaster(*it); + } + } + } } - delete loader; } + catch (const std::exception& e) { + reportError(QObject::tr("failed to initialize plugin %1: %2").arg(filepath).arg(e.what())); + } + + return proxiedPlugins; } IPlugin* PluginContainer::managedGame() const @@ -757,6 +751,21 @@ const PluginRequirements& PluginContainer::requirements(IPlugin* plugin) const return m_Requirements.at(plugin); } +OrganizerProxy* PluginContainer::organizerProxy(MOBase::IPlugin* plugin) const +{ + return requirements(plugin).m_Organizer; +} + +MOBase::IPluginProxy* PluginContainer::pluginProxy(MOBase::IPlugin* plugin) const +{ + return requirements(plugin).proxy(); +} + +QString PluginContainer::filepath(MOBase::IPlugin* plugin) const +{ + return as_qobject(plugin)->property("filepath").toString(); +} + IPluginGame *PluginContainer::managedGame(const QString &name) const { auto iter = m_SupportedGames.find(name); @@ -772,6 +781,193 @@ const PreviewGenerator &PluginContainer::previewGenerator() const return m_PreviewGenerator; } +void PluginContainer::simulateStartup(const std::vector& plugins) const +{ + // setUserInterface() + if (m_UserInterface) { + for (auto* plugin : plugins) { + if (auto* proxy = dynamic_cast(plugin)) { + proxy->setParentWidget(m_UserInterface->mainWindow()); + } + if (auto* modPage = dynamic_cast(plugin)) { + modPage->setParentWidget(m_UserInterface->mainWindow()); + } + if (auto* tool = dynamic_cast(plugin)) { + tool->setParentWidget(m_UserInterface->mainWindow()); + } + if (auto* installer = dynamic_cast(plugin)) { + installer->setParentWidget(m_UserInterface->mainWindow()); + } + } + } + + // Simulate callbacks, e.g. onUserInterfaceInitialized and onProfileChanged. + for (auto* plugin : plugins) { + auto* oproxy = organizerProxy(plugin); + oproxy->m_UserInterfaceInitialized(m_UserInterface->mainWindow()); + oproxy->m_ProfileChanged(nullptr, m_Organizer->currentProfile()); + } +} + +void PluginContainer::loadPlugin(QString const& filepath) +{ + std::vector plugins; + if (QFileInfo(filepath).isFile() && QLibrary::isLibrary(filepath)) { + std::unique_ptr pluginLoader(new QPluginLoader(filepath, this)); + if (pluginLoader->instance() == nullptr) { + log::error("failed to load plugin {}: {}", filepath, pluginLoader->errorString()); + } + else { + if (IPlugin* plugin = registerPlugin(pluginLoader->instance(), filepath, nullptr)) { + log::debug("loaded plugin '{}' from '{}' - [{}]", + plugin->name(), QFileInfo(filepath).fileName(), implementedInterfaces(plugin).join(", ")); + m_PluginLoaders.push_back(pluginLoader.release()); + plugins.push_back(plugin); + } + else { + m_FailedPlugins.push_back(filepath); + log::warn("plugin \"{}\" failed to load (may be outdated)", filepath); + } + } + } + else { + // We need to check if this can be handled by a proxy. + for (auto* proxy : this->plugins()) { + auto filepaths = proxy->pluginList( + QCoreApplication::applicationDirPath() + "/" + ToQString(AppConfig::pluginPath())); + if (filepaths.contains(filepath)) { + plugins = loadProxied(filepath, proxy); + break; + } + } + } + + for (auto* plugin : plugins) { + emit pluginRegistered(plugin); + } + + simulateStartup(plugins); +} + +void PluginContainer::unloadPlugin(MOBase::IPlugin* plugin, QObject* object) +{ + if (auto* game = qobject_cast(object)) { + unregisterGame(game); + } + + // We need to do this BEFORE unloading from the proxy otherwise the + // qobject_cast won't work. + bf::for_each(m_Plugins, [object](auto& t) { + using type = typename std::decay_t::value_type; + + // We do not want to remove from QObject since we are iterating over them. + if constexpr (!std::is_same{}) { + auto itp = std::find(t.second.begin(), t.second.end(), qobject_cast(object)); + if (itp != t.second.end()) { + t.second.erase(itp); + } + } + }); + + emit pluginUnregistered(plugin); + + // Remove from the members. + if (auto* diagnose = qobject_cast(object)) { + bf::at_key(m_AccessPlugins).erase(diagnose); + } + if (auto* mapper = qobject_cast(object)) { + bf::at_key(m_AccessPlugins).erase(mapper); + } + + auto& mapNames = bf::at_key(m_AccessPlugins); + if (mapNames.contains(plugin->name())) { + mapNames.erase(plugin->name()); + } + + m_Organizer->settings().plugins().unregisterPlugin(plugin); + + // Is this a proxied plugin? + auto* proxy = pluginProxy(plugin); + + if (proxy) { + proxy->unload(filepath(plugin)); + } + else { + // We need to find the loader. + auto it = std::find_if(m_PluginLoaders.begin(), m_PluginLoaders.end(), + [object](auto* loader) { return loader->instance() == object; }); + + if (it != m_PluginLoaders.end()) { + if (!(*it)->unload()) { + log::error("failed to unload {}: {}", (*it)->fileName(), (*it)->errorString()); + } + delete* it; + m_PluginLoaders.erase(it); + } + else { + log::error("loader for plugin {} does not exist, cannot unload", plugin->name()); + } + + } + + // Do this at the end. + m_Requirements.erase(plugin); +} + +void PluginContainer::unloadPlugin(QString const& filepath) +{ + // We need to find all the plugins from the given path and + // unload them: + QString cleanPath = QDir::cleanPath(filepath); + auto &objects = bf::at_key(m_Plugins); + for (auto it = objects.begin(); it != objects.end(); ) { + auto* plugin = qobject_cast(*it); + if (this->filepath(plugin) == filepath) { + unloadPlugin(plugin, *it); + it = objects.erase(it); + } + else { + ++it; + } + } +} + +void PluginContainer::reloadPlugin(QString const& filepath) +{ + unloadPlugin(filepath); + loadPlugin(filepath); +} + +void PluginContainer::unloadPlugins() +{ + if (m_UserInterface != nullptr) { + m_UserInterface->disconnectPlugins(); + } + + // disconnect all slots before unloading plugins so plugins don't have to take care of that + if (m_Organizer) { + m_Organizer->disconnectPlugins(); + } + + bf::for_each(m_Plugins, [](auto& t) { t.second.clear(); }); + bf::for_each(m_AccessPlugins, [](auto& t) { t.second.clear(); }); + m_Requirements.clear(); + + for (const boost::signals2::connection& connection : m_DiagnosisConnections) { + connection.disconnect(); + } + m_DiagnosisConnections.clear(); + + while (!m_PluginLoaders.empty()) { + QPluginLoader* loader = m_PluginLoaders.back(); + m_PluginLoaders.pop_back(); + if ((loader != nullptr) && !loader->unload()) { + log::debug("failed to unload {}: {}", loader->fileName(), loader->errorString()); + } + delete loader; + } +} + void PluginContainer::loadPlugins() { TimeThis tt("PluginContainer::loadPlugins()"); diff --git a/src/plugincontainer.h b/src/plugincontainer.h index ef5f9441..213aaa70 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -103,6 +103,7 @@ private: // Set the master for this plugin. This is required to "fake" masters for proxied plugins. void setMaster(MOBase::IPlugin* master); + friend class OrganizerCore; friend class PluginContainer; PluginContainer* m_PluginContainer; @@ -110,12 +111,12 @@ private: MOBase::IPluginProxy* m_PluginProxy; MOBase::IPlugin* m_Master; std::vector> m_Requirements; - MOBase::IOrganizer* m_Organizer; + OrganizerProxy* m_Organizer; std::vector m_RequiredFor; PluginRequirements( PluginContainer* pluginContainer, MOBase::IPlugin* plugin, - MOBase::IOrganizer* proxy, MOBase::IPluginProxy* pluginProxy); + OrganizerProxy* proxy, MOBase::IPluginProxy* pluginProxy); }; @@ -190,6 +191,10 @@ public: void setUserInterface(IUserInterface *userInterface); + void loadPlugin(QString const& filepath); + void unloadPlugin(QString const& filepath); + void reloadPlugin(QString const& filepath); + void loadPlugins(); void unloadPlugins(); @@ -352,6 +357,49 @@ private: friend class PluginRequirements; + /** + * @return the organizer proxy for the given plugin. + */ + OrganizerProxy* organizerProxy(MOBase::IPlugin* plugin) const; + + /** + * @return the proxy plugin that instantiated the given plugin, or a null pointer + * if the plugin was not instantiated by a proxy. + */ + MOBase::IPluginProxy* pluginProxy(MOBase::IPlugin* plugin) const; + + /** + * @return the path to the file or folder corresponding to the plugin. + */ + QString filepath(MOBase::IPlugin* plugin) const; + + /** + * @brief Unload the given plugin. + * + * This function is not public because it's kind of dangerous trying to unload + * plugin directly since some plugins are linked together. + * + * @param plugin The plugin to unload/unregister. + * @param object The QObject corresponding to the plugin. + */ + void unloadPlugin(MOBase::IPlugin* plugin, QObject* object); + + /** + * @brief Load plugins from the given filepath using the given proxy. + * + * @param filepath Path to a folder/file containing plugin(s) that can be load by the given proxy. + * @param proxy Proxy to use to load plugins. + * + * @return the list of created plugins. + */ + std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); + + /** + * @brief Simulate MO2 startup for the given plugins. + * + * @param plugins Plugins to simulate startup for. + */ + void simulateStartup(const std::vector& plugins) const; /** * @brief Retrieved the (localized) names of interfaces implemented by the given @@ -399,6 +447,7 @@ private: bool initPlugin(MOBase::IPlugin *plugin, MOBase::IPluginProxy* proxy, bool skipInit); void registerGame(MOBase::IPluginGame *game); + void unregisterGame(MOBase::IPluginGame* game); MOBase::IPlugin* registerPlugin(QObject *pluginObj, const QString &fileName, MOBase::IPluginProxy *proxy); -- cgit v1.3.1 From 47626d654f2493cddf2126cd5e08e8be7efb67a8 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 07:44:24 +0100 Subject: Clarify comment. --- src/organizerproxy.cpp | 2 +- src/plugincontainer.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/organizerproxy.cpp b/src/organizerproxy.cpp index 13b91ff4..1f73ee13 100644 --- a/src/organizerproxy.cpp +++ b/src/organizerproxy.cpp @@ -43,7 +43,7 @@ OrganizerProxy::OrganizerProxy(OrganizerCore* organizer, PluginContainer* plugin OrganizerProxy::~OrganizerProxy() { - log::debug("~OrganizerProxy() for {}.", m_PluginName); + log::debug("Deleting organizer proxy for plugin '{}'.", m_PluginName); for (auto& conn : m_Connections) { conn.disconnect(); } diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 3579a0d3..9da467a4 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -855,8 +855,8 @@ void PluginContainer::unloadPlugin(MOBase::IPlugin* plugin, QObject* object) unregisterGame(game); } - // We need to do this BEFORE unloading from the proxy otherwise the - // qobject_cast won't work. + // We need to remove from the m_Plugins maps BEFORE unloading from the proxy + // otherwise the qobject_cast to check the plugin type will not work. bf::for_each(m_Plugins, [object](auto& t) { using type = typename std::decay_t::value_type; -- cgit v1.3.1 From a6654eaec8190d7f9297a35499f8271a8f28176c Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 07:58:58 +0100 Subject: Centralize loading Qt plugin in loadQtPlugin. --- src/plugincontainer.cpp | 61 +++++++++++++++++++++++-------------------------- src/plugincontainer.h | 7 ++++++ 2 files changed, 35 insertions(+), 33 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 9da467a4..1bcf7243 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -592,6 +592,28 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString& filepat return nullptr; } +MOBase::IPlugin* PluginContainer::loadQtPlugin(const QString& filepath) +{ + std::unique_ptr pluginLoader(new QPluginLoader(filepath, this)); + if (pluginLoader->instance() == nullptr) { + m_FailedPlugins.push_back(filepath); + log::error("failed to load plugin {}: {}",filepath, pluginLoader->errorString()); + } + else { + if (IPlugin* plugin = registerPlugin(pluginLoader->instance(), filepath, nullptr); plugin) { + log::debug("loaded plugin '{}' from '{}' - [{}]", + plugin->name(), QFileInfo(filepath).fileName(), implementedInterfaces(plugin).join(", ")); + m_PluginLoaders.push_back(pluginLoader.release()); + return plugin; + } + else { + m_FailedPlugins.push_back(filepath); + log::warn("plugin '{}' failed to load (may be outdated)", filepath); + } + } + return nullptr; +} + std::vector PluginContainer::loadProxied(const QString& filepath, IPluginProxy* proxy) { std::vector proxiedPlugins; @@ -813,21 +835,9 @@ void PluginContainer::loadPlugin(QString const& filepath) { std::vector plugins; if (QFileInfo(filepath).isFile() && QLibrary::isLibrary(filepath)) { - std::unique_ptr pluginLoader(new QPluginLoader(filepath, this)); - if (pluginLoader->instance() == nullptr) { - log::error("failed to load plugin {}: {}", filepath, pluginLoader->errorString()); - } - else { - if (IPlugin* plugin = registerPlugin(pluginLoader->instance(), filepath, nullptr)) { - log::debug("loaded plugin '{}' from '{}' - [{}]", - plugin->name(), QFileInfo(filepath).fileName(), implementedInterfaces(plugin).join(", ")); - m_PluginLoaders.push_back(pluginLoader.release()); - plugins.push_back(plugin); - } - else { - m_FailedPlugins.push_back(filepath); - log::warn("plugin \"{}\" failed to load (may be outdated)", filepath); - } + IPlugin* plugin = loadQtPlugin(filepath); + if (plugin) { + plugins.push_back(plugin); } } else { @@ -1062,24 +1072,9 @@ void PluginContainer::loadPlugins() loadCheck.flush(); } - QString pluginName = iter.filePath(); - if (QLibrary::isLibrary(pluginName)) { - std::unique_ptr pluginLoader(new QPluginLoader(pluginName, this)); - if (pluginLoader->instance() == nullptr) { - m_FailedPlugins.push_back(pluginName); - log::error( - "failed to load plugin {}: {}", - pluginName, pluginLoader->errorString()); - } else { - if (IPlugin* plugin = registerPlugin(pluginLoader->instance(), pluginName, nullptr); plugin) { - log::debug("loaded plugin '{}' from '{}' - [{}]", - plugin->name(), QFileInfo(pluginName).fileName(), implementedInterfaces(plugin).join(", ")); - m_PluginLoaders.push_back(pluginLoader.release()); - } else { - m_FailedPlugins.push_back(pluginName); - log::warn("plugin \"{}\" failed to load (may be outdated)", pluginName); - } - } + QString filepath = iter.filePath(); + if (QLibrary::isLibrary(filepath)) { + loadQtPlugin(filepath); } } diff --git a/src/plugincontainer.h b/src/plugincontainer.h index 213aaa70..43c7973f 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -394,6 +394,13 @@ private: */ std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); + /** + * @brief Load the Qt plugin from the given file. + * + * @param filepath Path to the DLL containing the Qt plugin. + */ + MOBase::IPlugin* loadQtPlugin(const QString& filepath); + /** * @brief Simulate MO2 startup for the given plugins. * -- cgit v1.3.1 From f229dbaaa7f516dc1958d0a0555b47cb17136377 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 08:03:40 +0100 Subject: Do not store the list of preview plugins in PreviewGenerator. --- src/plugincontainer.cpp | 1 - src/previewgenerator.cpp | 31 +++++++++++++++---------------- src/previewgenerator.h | 8 -------- 3 files changed, 15 insertions(+), 25 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 1bcf7243..9b73a964 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -560,7 +560,6 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString& filepat IPluginPreview *preview = qobject_cast(plugin); if (initPlugin(preview, pluginProxy, skipInit)) { bf::at_key(m_Plugins).push_back(preview); - m_PreviewGenerator.registerPlugin(preview); return preview; } } diff --git a/src/previewgenerator.cpp b/src/previewgenerator.cpp index c7df5a25..904d679f 100644 --- a/src/previewgenerator.cpp +++ b/src/previewgenerator.cpp @@ -27,33 +27,32 @@ along with Mod Organizer. If not, see . #include "plugincontainer.h" +using namespace MOBase; + PreviewGenerator::PreviewGenerator(const PluginContainer* pluginContainer) : m_PluginContainer(pluginContainer) { m_MaxSize = QGuiApplication::primaryScreen()->size() * 0.8; } -void PreviewGenerator::registerPlugin(MOBase::IPluginPreview *plugin) -{ - for (const QString &extension : plugin->supportedExtensions()) { - m_PreviewPlugins.insert(std::make_pair(extension, plugin)); - } -} - bool PreviewGenerator::previewSupported(const QString &fileExtension) const { - auto it = m_PreviewPlugins.find(fileExtension.toLower()); - if (it == m_PreviewPlugins.end()) { - return false; + auto& previews = m_PluginContainer->plugins(); + for (auto* preview : previews) { + if (preview->supportedExtensions().contains(fileExtension)) { + return true; + } } - return m_PluginContainer->isEnabled(it->second); + return false; } QWidget *PreviewGenerator::genPreview(const QString &fileName) const { - auto iter = m_PreviewPlugins.find(QFileInfo(fileName).suffix().toLower()); - if (iter != m_PreviewPlugins.end() && m_PluginContainer->isEnabled(iter->second)) { - return iter->second->genFilePreview(fileName, m_MaxSize); - } else { - return nullptr; + const QString ext = QFileInfo(fileName).suffix().toLower(); + auto& previews = m_PluginContainer->plugins(); + for (auto* preview : previews) { + if (m_PluginContainer->isEnabled(preview) && preview->supportedExtensions().contains(ext)) { + return preview->genFilePreview(fileName, m_MaxSize); + } } + return nullptr; } diff --git a/src/previewgenerator.h b/src/previewgenerator.h index 0d8f0781..f70649b5 100644 --- a/src/previewgenerator.h +++ b/src/previewgenerator.h @@ -33,21 +33,13 @@ class PreviewGenerator public: PreviewGenerator(const PluginContainer* pluginContainer); - void registerPlugin(MOBase::IPluginPreview *plugin); - bool previewSupported(const QString &fileExtension) const; QWidget *genPreview(const QString &fileName) const; -private: - - QWidget *genImagePreview(const QString &fileName) const; - QWidget *genTxtPreview(const QString &fileName) const; - private: const PluginContainer* m_PluginContainer; - std::map m_PreviewPlugins; QSize m_MaxSize; }; -- cgit v1.3.1 From a30d49f4fc845164ef6bba4d2a834efce1dc01d7 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 08:50:31 +0100 Subject: Avoid duplicating code to simulate startup. --- src/downloadmanagerproxy.cpp | 12 ++- src/downloadmanagerproxy.h | 6 ++ src/iuserinterface.h | 2 - src/mainwindow.cpp | 15 +--- src/mainwindow.h | 8 -- src/modlistproxy.cpp | 12 ++- src/modlistproxy.h | 6 ++ src/organizerproxy.cpp | 24 ++++- src/organizerproxy.h | 17 ++++ src/plugincontainer.cpp | 207 ++++++++++++++++++++----------------------- src/plugincontainer.h | 37 ++++---- src/pluginlistproxy.cpp | 12 ++- src/pluginlistproxy.h | 6 ++ 13 files changed, 208 insertions(+), 156 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/downloadmanagerproxy.cpp b/src/downloadmanagerproxy.cpp index 06dad21f..95099044 100644 --- a/src/downloadmanagerproxy.cpp +++ b/src/downloadmanagerproxy.cpp @@ -7,7 +7,14 @@ using namespace MOBase; using namespace MOShared; DownloadManagerProxy::DownloadManagerProxy(OrganizerProxy* oproxy, DownloadManager* downloadManager) : - m_OrganizerProxy(oproxy), m_Proxied(downloadManager) + m_OrganizerProxy(oproxy), m_Proxied(downloadManager) { } + +DownloadManagerProxy::~DownloadManagerProxy() +{ + disconnectSignals(); +} + +void DownloadManagerProxy::connectSignals() { m_Connections.push_back(m_Proxied->onDownloadComplete(callSignalIfPluginActive(m_OrganizerProxy, m_DownloadComplete))); m_Connections.push_back(m_Proxied->onDownloadFailed(callSignalIfPluginActive(m_OrganizerProxy, m_DownloadFailed))); @@ -15,11 +22,12 @@ DownloadManagerProxy::DownloadManagerProxy(OrganizerProxy* oproxy, DownloadManag m_Connections.push_back(m_Proxied->onDownloadPaused(callSignalIfPluginActive(m_OrganizerProxy, m_DownloadPaused))); } -DownloadManagerProxy::~DownloadManagerProxy() +void DownloadManagerProxy::disconnectSignals() { for (auto& conn : m_Connections) { conn.disconnect(); } + m_Connections.clear(); } int DownloadManagerProxy::startDownloadURLs(const QStringList& urls) diff --git a/src/downloadmanagerproxy.h b/src/downloadmanagerproxy.h index 23692179..729fde91 100644 --- a/src/downloadmanagerproxy.h +++ b/src/downloadmanagerproxy.h @@ -25,6 +25,12 @@ public: private: + friend class OrganizerProxy; + + // See OrganizerProxy::connectSignals(). + void connectSignals(); + void disconnectSignals(); + OrganizerProxy* m_OrganizerProxy; DownloadManager* m_Proxied; diff --git a/src/iuserinterface.h b/src/iuserinterface.h index a2a91e62..277d5cf5 100644 --- a/src/iuserinterface.h +++ b/src/iuserinterface.h @@ -17,8 +17,6 @@ public: virtual void installTranslator(const QString &name) = 0; - virtual void disconnectPlugins() = 0; - virtual bool closeWindow() = 0; virtual void setWindowEnabled(bool enabled) = 0; diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp index 8e08103f..a270fd10 100644 --- a/src/mainwindow.cpp +++ b/src/mainwindow.cpp @@ -512,8 +512,6 @@ MainWindow::MainWindow(Settings &settings m_Tutorial.expose("espList", m_OrganizerCore.pluginList()); m_OrganizerCore.setUserInterface(this); - m_PluginContainer.setUserInterface(this); - connect(this, &MainWindow::userInterfaceInitialized, &m_OrganizerCore, &OrganizerCore::userInterfaceInitialized); for (const QString &fileName : m_PluginContainer.pluginFileNames()) { installTranslator(QFileInfo(fileName).baseName()); } @@ -705,7 +703,6 @@ MainWindow::~MainWindow() try { cleanup(); - m_PluginContainer.setUserInterface(nullptr); m_OrganizerCore.setUserInterface(nullptr); if (m_IntegratedBrowser) { @@ -744,14 +741,6 @@ void MainWindow::onRequestsChanged(const APIStats& stats, const APIUserAccount& } -void MainWindow::disconnectPlugins() -{ - if (ui->actionTool->menu() != nullptr) { - ui->actionTool->menu()->clear(); - } -} - - void MainWindow::resizeLists(bool pluginListCustom) { // ensure the columns aren't so small you can't see them any more @@ -1413,8 +1402,8 @@ void MainWindow::showEvent(QShowEvent *event) m_WasVisible = true; updateProblemsButton(); - // Notify plugin that the UI is initialized: - emit userInterfaceInitialized(); + // Notify plugin that the MO2 is ready: + m_PluginContainer.startPlugins(this); } } diff --git a/src/mainwindow.h b/src/mainwindow.h index 17c27b29..7a1c683d 100644 --- a/src/mainwindow.h +++ b/src/mainwindow.h @@ -133,8 +133,6 @@ public: void installTranslator(const QString &name); - virtual void disconnectPlugins(); - void displayModInformation( ModInfo::Ptr modInfo, unsigned int modIndex, ModInfoTabIDs tabID) override; @@ -168,12 +166,6 @@ signals: */ void styleChanged(const QString &styleFile); - /** - * @brief emitted when the user interface has been completely initialized - */ - void userInterfaceInitialized(); - - void modListDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight); void checkForProblemsDone(); diff --git a/src/modlistproxy.cpp b/src/modlistproxy.cpp index 991476da..6165fc3f 100644 --- a/src/modlistproxy.cpp +++ b/src/modlistproxy.cpp @@ -7,7 +7,14 @@ using namespace MOBase; using namespace MOShared; ModListProxy::ModListProxy(OrganizerProxy* oproxy, ModList* modlist) : - m_OrganizerProxy(oproxy), m_Proxied(modlist) + m_OrganizerProxy(oproxy), m_Proxied(modlist) { } + +ModListProxy::~ModListProxy() +{ + disconnectSignals(); +} + +void ModListProxy::connectSignals() { m_Connections.push_back(m_Proxied->onModInstalled(callSignalIfPluginActive(m_OrganizerProxy, m_ModInstalled))); m_Connections.push_back(m_Proxied->onModMoved(callSignalIfPluginActive(m_OrganizerProxy, m_ModMoved))); @@ -15,11 +22,12 @@ ModListProxy::ModListProxy(OrganizerProxy* oproxy, ModList* modlist) : m_Connections.push_back(m_Proxied->onModStateChanged(callSignalIfPluginActive(m_OrganizerProxy, m_ModStateChanged))); } -ModListProxy::~ModListProxy() +void ModListProxy::disconnectSignals() { for (auto& conn : m_Connections) { conn.disconnect(); } + m_Connections.clear(); } QString ModListProxy::displayName(const QString& internalName) const diff --git a/src/modlistproxy.h b/src/modlistproxy.h index 12d74e4a..162b0b43 100644 --- a/src/modlistproxy.h +++ b/src/modlistproxy.h @@ -31,6 +31,12 @@ public: private: + friend class OrganizerProxy; + + // See OrganizerProxy::connectSignals(). + void connectSignals(); + void disconnectSignals(); + OrganizerProxy* m_OrganizerProxy; ModList* m_Proxied; diff --git a/src/organizerproxy.cpp b/src/organizerproxy.cpp index 1f73ee13..c41045e1 100644 --- a/src/organizerproxy.cpp +++ b/src/organizerproxy.cpp @@ -25,7 +25,14 @@ OrganizerProxy::OrganizerProxy(OrganizerCore* organizer, PluginContainer* plugin , m_PluginName(plugin->name()) , m_DownloadManagerProxy(std::make_unique(this, organizer->downloadManager())) , m_ModListProxy(std::make_unique(this, organizer->modList())) - , m_PluginListProxy(std::make_unique(this, organizer->pluginList())) + , m_PluginListProxy(std::make_unique(this, organizer->pluginList())) { } + +OrganizerProxy::~OrganizerProxy() +{ + disconnectSignals(); +} + +void OrganizerProxy::connectSignals() { m_Connections.push_back(m_Proxied->onAboutToRun(callSignalIfPluginActive(this, m_AboutToRun, true))); m_Connections.push_back(m_Proxied->onFinishedRun(callSignalIfPluginActive(this, m_FinishedRun))); @@ -39,14 +46,25 @@ OrganizerProxy::OrganizerProxy(OrganizerCore* organizer, PluginContainer* plugin m_Connections.push_back(m_Proxied->onPluginEnabled(callSignalAlways(m_PluginEnabled))); m_Connections.push_back(m_Proxied->onPluginDisabled(callSignalAlways(m_PluginDisabled))); + // Connect the child proxies. + m_DownloadManagerProxy->connectSignals(); + m_ModListProxy->connectSignals(); + m_PluginListProxy->connectSignals(); } -OrganizerProxy::~OrganizerProxy() +void OrganizerProxy::disconnectSignals() { - log::debug("Deleting organizer proxy for plugin '{}'.", m_PluginName); + log::debug("Disconnecting organizer proxy for plugin '{}'.", m_PluginName); + + // Disconnect the child proxies. + m_DownloadManagerProxy->disconnectSignals(); + m_ModListProxy->disconnectSignals(); + m_PluginListProxy->disconnectSignals(); + for (auto& conn : m_Connections) { conn.disconnect(); } + m_Connections.clear(); } IModRepositoryBridge *OrganizerProxy::createNexusBridge() const diff --git a/src/organizerproxy.h b/src/organizerproxy.h index fb463822..c52f2730 100644 --- a/src/organizerproxy.h +++ b/src/organizerproxy.h @@ -21,11 +21,15 @@ public: OrganizerProxy(OrganizerCore *organizer, PluginContainer *pluginContainer, MOBase::IPlugin *plugin); ~OrganizerProxy(); +public: + /** * @return the plugin corresponding to this proxy. */ MOBase::IPlugin* plugin() const { return m_Plugin; } +public: // IOrganizer interface + virtual MOBase::IModRepositoryBridge *createNexusBridge() const; virtual QString profileName() const; virtual QString profilePath() const; @@ -83,6 +87,19 @@ protected: // The container needs access to some callbacks to simulate startup. friend class PluginContainer; + /** + * @brief Connect the signals from this proxy and all the child proxies (plugin list, mod + * list, etc.) to the actual implementation. Before this call, plugins can register signals + * but they won't be triggered. + */ + void connectSignals(); + + /** + * @brief Disconnect the signals from this proxy and all the child proxies (plugin list, mod + * list, etc.) from the actual implementation. + */ + void disconnectSignals(); + private: OrganizerCore *m_Proxied; diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 9b73a964..3c8050cf 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -289,24 +289,10 @@ PluginContainer::~PluginContainer() { unloadPlugins(); } -void PluginContainer::setUserInterface(IUserInterface *userInterface) +void PluginContainer::startPlugins(IUserInterface *userInterface) { - if (userInterface) { - for (IPluginProxy* proxy : bf::at_key(m_Plugins)) { - proxy->setParentWidget(userInterface->mainWindow()); - } - for (IPluginModPage* modPage : bf::at_key(m_Plugins)) { - modPage->setParentWidget(userInterface->mainWindow()); - } - for (IPluginTool* tool : bf::at_key(m_Plugins)) { - tool->setParentWidget(userInterface->mainWindow()); - } - for (IPluginInstaller* installer : bf::at_key(m_Plugins)) { - installer->setParentWidget(userInterface->mainWindow()); - } - } - m_UserInterface = userInterface; + startPluginsImpl(plugins()); } QStringList PluginContainer::implementedInterfaces(IPlugin* plugin) const @@ -591,83 +577,6 @@ IPlugin* PluginContainer::registerPlugin(QObject *plugin, const QString& filepat return nullptr; } -MOBase::IPlugin* PluginContainer::loadQtPlugin(const QString& filepath) -{ - std::unique_ptr pluginLoader(new QPluginLoader(filepath, this)); - if (pluginLoader->instance() == nullptr) { - m_FailedPlugins.push_back(filepath); - log::error("failed to load plugin {}: {}",filepath, pluginLoader->errorString()); - } - else { - if (IPlugin* plugin = registerPlugin(pluginLoader->instance(), filepath, nullptr); plugin) { - log::debug("loaded plugin '{}' from '{}' - [{}]", - plugin->name(), QFileInfo(filepath).fileName(), implementedInterfaces(plugin).join(", ")); - m_PluginLoaders.push_back(pluginLoader.release()); - return plugin; - } - else { - m_FailedPlugins.push_back(filepath); - log::warn("plugin '{}' failed to load (may be outdated)", filepath); - } - } - return nullptr; -} - -std::vector PluginContainer::loadProxied(const QString& filepath, IPluginProxy* proxy) -{ - std::vector proxiedPlugins; - - try { - // We get a list of matching plugins as proxies can return multiple plugins - // per file and do not have a good way of supporting multiple inheritance. - QList matchingPlugins = proxy->load(filepath); - - // We are going to group plugin by names and "fix" them later: - std::map> proxiedByNames; - - for (QObject* proxiedPlugin : matchingPlugins) { - if (proxiedPlugin != nullptr) { - - if (IPlugin* proxied = registerPlugin(proxiedPlugin, filepath, proxy); proxied) { - log::debug("loaded plugin '{}' from '{}' - [{}]", - proxied->name(), QFileInfo(filepath).fileName(), implementedInterfaces(proxied).join(", ")); - - // Store the plugin for later: - proxiedPlugins.push_back(proxied); - proxiedByNames[proxied->name()].push_back(proxied); - } - else { - log::warn( - "plugin \"{}\" failed to load. If this plugin is for an older version of MO " - "you have to update it or delete it if no update exists.", - filepath); - } - } - } - - // Fake masters: - for (auto& [name, proxiedPlugins] : proxiedByNames) { - if (proxiedPlugins.size() > 1) { - auto it = std::min_element(std::begin(proxiedPlugins), std::end(proxiedPlugins), - [&](auto const& lhs, auto const& rhs) { - return isBetterInterface(as_qobject(lhs), as_qobject(rhs)); - }); - - for (auto& proxiedPlugin : proxiedPlugins) { - if (proxiedPlugin != *it) { - m_Requirements.at(proxiedPlugin).setMaster(*it); - } - } - } - } - } - catch (const std::exception& e) { - reportError(QObject::tr("failed to initialize plugin %1: %2").arg(filepath).arg(e.what())); - } - - return proxiedPlugins; -} - IPlugin* PluginContainer::managedGame() const { // TODO: This const_cast is safe but ugly. Most methods require a IPlugin*, so @@ -802,39 +711,119 @@ const PreviewGenerator &PluginContainer::previewGenerator() const return m_PreviewGenerator; } -void PluginContainer::simulateStartup(const std::vector& plugins) const +void PluginContainer::startPluginsImpl(const std::vector& plugins) const { // setUserInterface() if (m_UserInterface) { for (auto* plugin : plugins) { - if (auto* proxy = dynamic_cast(plugin)) { + if (auto* proxy = qobject_cast(plugin)) { proxy->setParentWidget(m_UserInterface->mainWindow()); } - if (auto* modPage = dynamic_cast(plugin)) { + if (auto* modPage = qobject_cast(plugin)) { modPage->setParentWidget(m_UserInterface->mainWindow()); } - if (auto* tool = dynamic_cast(plugin)) { + if (auto* tool = qobject_cast(plugin)) { tool->setParentWidget(m_UserInterface->mainWindow()); } - if (auto* installer = dynamic_cast(plugin)) { + if (auto* installer = qobject_cast(plugin)) { installer->setParentWidget(m_UserInterface->mainWindow()); } } } - // Simulate callbacks, e.g. onUserInterfaceInitialized and onProfileChanged. - for (auto* plugin : plugins) { + // Trigger initial callbacks, e.g. onUserInterfaceInitialized and onProfileChanged. + for (auto* object : plugins) { + auto* plugin = qobject_cast(object); auto* oproxy = organizerProxy(plugin); + oproxy->connectSignals(); oproxy->m_UserInterfaceInitialized(m_UserInterface->mainWindow()); oproxy->m_ProfileChanged(nullptr, m_Organizer->currentProfile()); } } +std::vector PluginContainer::loadProxied(const QString& filepath, IPluginProxy* proxy) +{ + std::vector proxiedPlugins; + + try { + // We get a list of matching plugins as proxies can return multiple plugins + // per file and do not have a good way of supporting multiple inheritance. + QList matchingPlugins = proxy->load(filepath); + + // We are going to group plugin by names and "fix" them later: + std::map> proxiedByNames; + + for (QObject* proxiedPlugin : matchingPlugins) { + if (proxiedPlugin != nullptr) { + + if (IPlugin* proxied = registerPlugin(proxiedPlugin, filepath, proxy); proxied) { + log::debug("loaded plugin '{}' from '{}' - [{}]", + proxied->name(), QFileInfo(filepath).fileName(), implementedInterfaces(proxied).join(", ")); + + // Store the plugin for later: + proxiedPlugins.push_back(proxiedPlugin); + proxiedByNames[proxied->name()].push_back(proxied); + } + else { + log::warn( + "plugin \"{}\" failed to load. If this plugin is for an older version of MO " + "you have to update it or delete it if no update exists.", + filepath); + } + } + } + + // Fake masters: + for (auto& [name, proxiedPlugins] : proxiedByNames) { + if (proxiedPlugins.size() > 1) { + auto it = std::min_element(std::begin(proxiedPlugins), std::end(proxiedPlugins), + [&](auto const& lhs, auto const& rhs) { + return isBetterInterface(as_qobject(lhs), as_qobject(rhs)); + }); + + for (auto& proxiedPlugin : proxiedPlugins) { + if (proxiedPlugin != *it) { + m_Requirements.at(proxiedPlugin).setMaster(*it); + } + } + } + } + } + catch (const std::exception& e) { + reportError(QObject::tr("failed to initialize plugin %1: %2").arg(filepath).arg(e.what())); + } + + return proxiedPlugins; +} + +QObject* PluginContainer::loadQtPlugin(const QString& filepath) +{ + std::unique_ptr pluginLoader(new QPluginLoader(filepath, this)); + if (pluginLoader->instance() == nullptr) { + m_FailedPlugins.push_back(filepath); + log::error("failed to load plugin {}: {}", filepath, pluginLoader->errorString()); + } + else { + QObject* object = pluginLoader->instance(); + if (IPlugin* plugin = registerPlugin(object, filepath, nullptr); plugin) { + log::debug("loaded plugin '{}' from '{}' - [{}]", + plugin->name(), QFileInfo(filepath).fileName(), implementedInterfaces(plugin).join(", ")); + m_PluginLoaders.push_back(pluginLoader.release()); + return object; + } + else { + m_FailedPlugins.push_back(filepath); + log::warn("plugin '{}' failed to load (may be outdated)", filepath); + } + } + return nullptr; +} + void PluginContainer::loadPlugin(QString const& filepath) { - std::vector plugins; + std::vector plugins; if (QFileInfo(filepath).isFile() && QLibrary::isLibrary(filepath)) { - IPlugin* plugin = loadQtPlugin(filepath); + QObject* plugin = loadQtPlugin(filepath); if (plugin) { plugins.push_back(plugin); } @@ -852,10 +841,10 @@ void PluginContainer::loadPlugin(QString const& filepath) } for (auto* plugin : plugins) { - emit pluginRegistered(plugin); + emit pluginRegistered(qobject_cast(plugin)); } - simulateStartup(plugins); + startPluginsImpl(plugins); } void PluginContainer::unloadPlugin(MOBase::IPlugin* plugin, QObject* object) @@ -895,6 +884,11 @@ void PluginContainer::unloadPlugin(MOBase::IPlugin* plugin, QObject* object) m_Organizer->settings().plugins().unregisterPlugin(plugin); + // Force disconnection of the signals from the proxies. This is a safety + // operations since those signals should be disconnected when the proxies + // are destroyed anyway. + organizerProxy(plugin)->disconnectSignals(); + // Is this a proxied plugin? auto* proxy = pluginProxy(plugin); @@ -949,10 +943,6 @@ void PluginContainer::reloadPlugin(QString const& filepath) void PluginContainer::unloadPlugins() { - if (m_UserInterface != nullptr) { - m_UserInterface->disconnectPlugins(); - } - // disconnect all slots before unloading plugins so plugins don't have to take care of that if (m_Organizer) { m_Organizer->disconnectPlugins(); @@ -1104,7 +1094,6 @@ void PluginContainer::loadPlugins() } } - std::vector PluginContainer::activeProblems() const { std::vector problems; diff --git a/src/plugincontainer.h b/src/plugincontainer.h index 43c7973f..d6503a43 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -186,10 +186,23 @@ public: public: - PluginContainer(OrganizerCore *organizer); + PluginContainer(OrganizerCore* organizer); virtual ~PluginContainer(); - void setUserInterface(IUserInterface *userInterface); + /** + * @brief Start the plugins. + * + * This function should not be called before MO2 is ready and plugins can be + * started, and will do the following: + * - connect the callbacks of the plugins, + * - set the parent widget for plugins that can have one, + * - notify plugins that MO2 has been started, including: + * - triggering a call to the "profile changed" callback for the initial profile, + * - triggering a call to the "user interface initialized" callback. + * + * @param userInterface The main user interface to use for the plugins. + */ + void startPlugins(IUserInterface* userInterface); void loadPlugin(QString const& filepath); void unloadPlugin(QString const& filepath); @@ -392,21 +405,15 @@ private: * * @return the list of created plugins. */ - std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); + std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); - /** - * @brief Load the Qt plugin from the given file. - * - * @param filepath Path to the DLL containing the Qt plugin. - */ - MOBase::IPlugin* loadQtPlugin(const QString& filepath); + // Load the Qt plugin from the given file. + QObject* loadQtPlugin(const QString& filepath); - /** - * @brief Simulate MO2 startup for the given plugins. - * - * @param plugins Plugins to simulate startup for. - */ - void simulateStartup(const std::vector& plugins) const; + // See startPlugins for more details. This is simply an intermediate function + // that can be used when loading plugins after initialization. This uses the + // user interface in m_UserInterface. + void startPluginsImpl(const std::vector& plugins) const; /** * @brief Retrieved the (localized) names of interfaces implemented by the given diff --git a/src/pluginlistproxy.cpp b/src/pluginlistproxy.cpp index b51d108b..b9ea9e36 100644 --- a/src/pluginlistproxy.cpp +++ b/src/pluginlistproxy.cpp @@ -6,18 +6,26 @@ using namespace MOBase; using namespace MOShared; PluginListProxy::PluginListProxy(OrganizerProxy* oproxy, PluginList* pluginlist) : - m_OrganizerProxy(oproxy), m_Proxied(pluginlist) + m_OrganizerProxy(oproxy), m_Proxied(pluginlist) { } + +PluginListProxy::~PluginListProxy() +{ + disconnectSignals(); +} + +void PluginListProxy::connectSignals() { m_Connections.push_back(m_Proxied->onRefreshed(callSignalIfPluginActive(m_OrganizerProxy, m_Refreshed))); m_Connections.push_back(m_Proxied->onPluginMoved(callSignalIfPluginActive(m_OrganizerProxy, m_PluginMoved))); m_Connections.push_back(m_Proxied->onPluginStateChanged(callSignalIfPluginActive(m_OrganizerProxy, m_PluginStateChanged))); } -PluginListProxy::~PluginListProxy() +void PluginListProxy::disconnectSignals() { for (auto& conn : m_Connections) { conn.disconnect(); } + m_Connections.clear(); } QStringList PluginListProxy::pluginNames() const diff --git a/src/pluginlistproxy.h b/src/pluginlistproxy.h index 04a6ad55..e421b6ee 100644 --- a/src/pluginlistproxy.h +++ b/src/pluginlistproxy.h @@ -30,6 +30,12 @@ public: private: + friend class OrganizerProxy; + + // See OrganizerProxy::connectSignals(). + void connectSignals(); + void disconnectSignals(); + OrganizerProxy* m_OrganizerProxy; PluginList* m_Proxied; -- cgit v1.3.1 From 4118aef2a28964d1bffdb489bf2223fbd6f994db Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 13:32:47 +0100 Subject: Remove disconnectPlugins() from OrganizerCore. --- src/organizercore.cpp | 19 ------------------- src/organizercore.h | 1 - src/plugincontainer.cpp | 5 ----- src/plugincontainer.h | 47 ++++++++++++++++++----------------------------- 4 files changed, 18 insertions(+), 54 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/organizercore.cpp b/src/organizercore.cpp index 6a333a22..256833a8 100644 --- a/src/organizercore.cpp +++ b/src/organizercore.cpp @@ -301,25 +301,6 @@ void OrganizerCore::connectPlugins(PluginContainer *container) [&](IPlugin* plugin) { m_PluginDisabled(plugin); }); } -void OrganizerCore::disconnectPlugins() -{ - m_AboutToRun.disconnect_all_slots(); - m_FinishedRun.disconnect_all_slots(); - m_UserInterfaceInitialized.disconnect_all_slots(); - m_ProfileChanged.disconnect_all_slots(); - m_PluginSettingChanged.disconnect_all_slots(); - - m_ModList.disconnectSlots(); - m_PluginList.disconnectSlots(); - m_Updater.setPluginContainer(nullptr); - m_DownloadManager.setPluginContainer(nullptr); - m_ModList.setPluginContainer(nullptr); - - m_Settings.plugins().clearPlugins(); - m_GamePlugin = nullptr; - m_PluginContainer = nullptr; -} - void OrganizerCore::setManagedGame(MOBase::IPluginGame *game) { m_GameName = game->gameName(); diff --git a/src/organizercore.h b/src/organizercore.h index cb612eae..f2b904cd 100644 --- a/src/organizercore.h +++ b/src/organizercore.h @@ -201,7 +201,6 @@ public: void setUserInterface(IUserInterface* ui); void connectPlugins(PluginContainer *container); - void disconnectPlugins(); void setManagedGame(MOBase::IPluginGame *game); diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index 3c8050cf..a2f0d5f0 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -943,11 +943,6 @@ void PluginContainer::reloadPlugin(QString const& filepath) void PluginContainer::unloadPlugins() { - // disconnect all slots before unloading plugins so plugins don't have to take care of that - if (m_Organizer) { - m_Organizer->disconnectPlugins(); - } - bf::for_each(m_Plugins, [](auto& t) { t.second.clear(); }); bf::for_each(m_AccessPlugins, [](auto& t) { t.second.clear(); }); m_Requirements.clear(); diff --git a/src/plugincontainer.h b/src/plugincontainer.h index d6503a43..bd19e7ef 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -209,7 +209,6 @@ public: void reloadPlugin(QString const& filepath); void loadPlugins(); - void unloadPlugins(); /** * @brief Find the game plugin corresponding to the given name. @@ -370,22 +369,30 @@ private: friend class PluginRequirements; - /** - * @return the organizer proxy for the given plugin. - */ + // Unload all the plugins. + void unloadPlugins(); + + // Retrieve the organizer proxy for the given plugin. OrganizerProxy* organizerProxy(MOBase::IPlugin* plugin) const; - /** - * @return the proxy plugin that instantiated the given plugin, or a null pointer - * if the plugin was not instantiated by a proxy. - */ + // Retrieve the proxy plugin that instantiated the given plugin, or a null pointer + // if the plugin was not instantiated by a proxy. MOBase::IPluginProxy* pluginProxy(MOBase::IPlugin* plugin) const; - /** - * @return the path to the file or folder corresponding to the plugin. - */ + // Retrieve the path to the file or folder corresponding to the plugin. QString filepath(MOBase::IPlugin* plugin) const; + // Load plugins from the given filepath using the given proxy. + std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); + + // Load the Qt plugin from the given file. + QObject* loadQtPlugin(const QString& filepath); + + // See startPlugins for more details. This is simply an intermediate function + // that can be used when loading plugins after initialization. This uses the + // user interface in m_UserInterface. + void startPluginsImpl(const std::vector& plugins) const; + /** * @brief Unload the given plugin. * @@ -397,24 +404,6 @@ private: */ void unloadPlugin(MOBase::IPlugin* plugin, QObject* object); - /** - * @brief Load plugins from the given filepath using the given proxy. - * - * @param filepath Path to a folder/file containing plugin(s) that can be load by the given proxy. - * @param proxy Proxy to use to load plugins. - * - * @return the list of created plugins. - */ - std::vector loadProxied(const QString& filepath, MOBase::IPluginProxy* proxy); - - // Load the Qt plugin from the given file. - QObject* loadQtPlugin(const QString& filepath); - - // See startPlugins for more details. This is simply an intermediate function - // that can be used when loading plugins after initialization. This uses the - // user interface in m_UserInterface. - void startPluginsImpl(const std::vector& plugins) const; - /** * @brief Retrieved the (localized) names of interfaces implemented by the given * plugin. -- cgit v1.3.1 From 7a3bc0cd23e637d66a1f78809f7229e665391cdb Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 13:33:14 +0100 Subject: Throw exception when trying to unload the current game plugin. --- src/plugincontainer.cpp | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index a2f0d5f0..c3d66913 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -850,6 +850,11 @@ void PluginContainer::loadPlugin(QString const& filepath) void PluginContainer::unloadPlugin(MOBase::IPlugin* plugin, QObject* object) { if (auto* game = qobject_cast(object)) { + + if (game == managedGame()) { + throw Exception("cannot unload the plugin for the currently managed game"); + } + unregisterGame(game); } -- cgit v1.3.1 From a1ab717e9e4fd72071cd01d9ceb74e7ba10ffafd Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 13:41:06 +0100 Subject: Minor cleaning (comments, names). --- src/organizercore.cpp | 2 +- src/plugincontainer.cpp | 2 +- src/plugincontainer.h | 26 +++++++++++++++++--------- 3 files changed, 19 insertions(+), 11 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/organizercore.cpp b/src/organizercore.cpp index 256833a8..631e49be 100644 --- a/src/organizercore.cpp +++ b/src/organizercore.cpp @@ -291,7 +291,7 @@ void OrganizerCore::connectPlugins(PluginContainer *container) m_ModList.setPluginContainer(m_PluginContainer); if (!m_GameName.isEmpty()) { - m_GamePlugin = m_PluginContainer->managedGame(m_GameName); + m_GamePlugin = m_PluginContainer->game(m_GameName); emit managedGameChanged(m_GamePlugin); } diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index c3d66913..e4eb389f 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -696,7 +696,7 @@ QString PluginContainer::filepath(MOBase::IPlugin* plugin) const return as_qobject(plugin)->property("filepath").toString(); } -IPluginGame *PluginContainer::managedGame(const QString &name) const +IPluginGame *PluginContainer::game(const QString &name) const { auto iter = m_SupportedGames.find(name); if (iter != m_SupportedGames.end()) { diff --git a/src/plugincontainer.h b/src/plugincontainer.h index bd19e7ef..4eb30db6 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -204,22 +204,19 @@ public: */ void startPlugins(IUserInterface* userInterface); + /** + * @brief Load, unload or reload the plugin at the given path. + * + */ void loadPlugin(QString const& filepath); void unloadPlugin(QString const& filepath); void reloadPlugin(QString const& filepath); - void loadPlugins(); - /** - * @brief Find the game plugin corresponding to the given name. + * @brief Load all plugins. * - * @param name The name of the game to find a plugin for (as returned by - * IPluginGame::gameName()). - * - * @return the game plugin for the given name, or a null pointer if no - * plugin exists for this game. */ - MOBase::IPluginGame *managedGame(const QString &name) const; + void loadPlugins(); /** * @brief Retrieve the list of plugins of the given type. @@ -271,6 +268,17 @@ public: MOBase::IPlugin* plugin(MOBase::IPluginDiagnose* diagnose) const; MOBase::IPlugin* plugin(MOBase::IPluginFileMapper* mapper) const; + /** + * @brief Find the game plugin corresponding to the given name. + * + * @param name The name of the game to find a plugin for (as returned by + * IPluginGame::gameName()). + * + * @return the game plugin for the given name, or a null pointer if no + * plugin exists for this game. + */ + MOBase::IPluginGame* game(const QString& name) const; + /** * @return the IPlugin interface to the currently managed game. */ -- cgit v1.3.1 From 8b02a5a7965440b883e9601ece0e30bca1169a65 Mon Sep 17 00:00:00 2001 From: Mikaël Capelle Date: Fri, 4 Dec 2020 19:32:11 +0100 Subject: Fix crash when starting MO2 without instance. --- src/plugincontainer.cpp | 22 +++++++++++++--------- src/plugincontainer.h | 2 ++ src/previewgenerator.cpp | 8 ++++---- src/previewgenerator.h | 4 ++-- 4 files changed, 21 insertions(+), 15 deletions(-) (limited to 'src/plugincontainer.cpp') diff --git a/src/plugincontainer.cpp b/src/plugincontainer.cpp index e4eb389f..c703a36a 100644 --- a/src/plugincontainer.cpp +++ b/src/plugincontainer.cpp @@ -280,7 +280,7 @@ void PluginRequirements::requiredFor(std::vector &required, st PluginContainer::PluginContainer(OrganizerCore *organizer) : m_Organizer(organizer) , m_UserInterface(nullptr) - , m_PreviewGenerator(this) + , m_PreviewGenerator(*this) { } @@ -397,6 +397,7 @@ bool PluginContainer::initPlugin(IPlugin *plugin, IPluginProxy *pluginProxy, boo OrganizerProxy* proxy = nullptr; if (m_Organizer) { proxy = new OrganizerProxy(m_Organizer, this, plugin); + proxy->setParent(as_qobject(plugin)); } // Check if it is a proxy plugin: @@ -417,8 +418,6 @@ bool PluginContainer::initPlugin(IPlugin *plugin, IPluginProxy *pluginProxy, boo return false; } - proxy->setParent(as_qobject(plugin)); - // Update requirements: it->second.fetchRequirements(); @@ -732,12 +731,17 @@ void PluginContainer::startPluginsImpl(const std::vector& plugins) con } // Trigger initial callbacks, e.g. onUserInterfaceInitialized and onProfileChanged. - for (auto* object : plugins) { - auto* plugin = qobject_cast(object); - auto* oproxy = organizerProxy(plugin); - oproxy->connectSignals(); - oproxy->m_UserInterfaceInitialized(m_UserInterface->mainWindow()); - oproxy->m_ProfileChanged(nullptr, m_Organizer->currentProfile()); + if (m_Organizer) { + for (auto* object : plugins) { + auto* plugin = qobject_cast(object); + auto* oproxy = organizerProxy(plugin); + oproxy->connectSignals(); + oproxy->m_ProfileChanged(nullptr, m_Organizer->currentProfile()); + + if (m_UserInterface) { + oproxy->m_UserInterfaceInitialized(m_UserInterface->mainWindow()); + } + } } } diff --git a/src/plugincontainer.h b/src/plugincontainer.h index 4eb30db6..386b9bca 100644 --- a/src/plugincontainer.h +++ b/src/plugincontainer.h @@ -462,8 +462,10 @@ private: MOBase::IPlugin* registerPlugin(QObject *pluginObj, const QString &fileName, MOBase::IPluginProxy *proxy); + // Core organizer, can be null (e.g. on first MO2 startup). OrganizerCore *m_Organizer; + // Main user interface, can be null until MW has been initialized. IUserInterface *m_UserInterface; PluginMap m_Plugins; diff --git a/src/previewgenerator.cpp b/src/previewgenerator.cpp index 904d679f..22332af3 100644 --- a/src/previewgenerator.cpp +++ b/src/previewgenerator.cpp @@ -29,14 +29,14 @@ along with Mod Organizer. If not, see . using namespace MOBase; -PreviewGenerator::PreviewGenerator(const PluginContainer* pluginContainer) : +PreviewGenerator::PreviewGenerator(const PluginContainer& pluginContainer) : m_PluginContainer(pluginContainer) { m_MaxSize = QGuiApplication::primaryScreen()->size() * 0.8; } bool PreviewGenerator::previewSupported(const QString &fileExtension) const { - auto& previews = m_PluginContainer->plugins(); + auto& previews = m_PluginContainer.plugins(); for (auto* preview : previews) { if (preview->supportedExtensions().contains(fileExtension)) { return true; @@ -48,9 +48,9 @@ bool PreviewGenerator::previewSupported(const QString &fileExtension) const QWidget *PreviewGenerator::genPreview(const QString &fileName) const { const QString ext = QFileInfo(fileName).suffix().toLower(); - auto& previews = m_PluginContainer->plugins(); + auto& previews = m_PluginContainer.plugins(); for (auto* preview : previews) { - if (m_PluginContainer->isEnabled(preview) && preview->supportedExtensions().contains(ext)) { + if (m_PluginContainer.isEnabled(preview) && preview->supportedExtensions().contains(ext)) { return preview->genFilePreview(fileName, m_MaxSize); } } diff --git a/src/previewgenerator.h b/src/previewgenerator.h index f70649b5..8e491116 100644 --- a/src/previewgenerator.h +++ b/src/previewgenerator.h @@ -31,7 +31,7 @@ class PluginContainer; class PreviewGenerator { public: - PreviewGenerator(const PluginContainer* pluginContainer); + PreviewGenerator(const PluginContainer& pluginContainer); bool previewSupported(const QString &fileExtension) const; @@ -39,7 +39,7 @@ public: private: - const PluginContainer* m_PluginContainer; + const PluginContainer& m_PluginContainer; QSize m_MaxSize; }; -- cgit v1.3.1