From da679b1d6da889a5a7ba1b0860c5b9631fdbda0e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mika=C3=ABl=20Capelle?= <capelle.mikael@gmail.com>
Date: Thu, 21 May 2020 23:11:56 +0200
Subject: [PATCH] Common code for basicWrapperFunction functions.

---
 src/runner/gamefeatureswrappers.cpp |  62 ++++++-------
 src/runner/proxypluginwrappers.cpp  | 130 ++++++++++++++--------------
 src/runner/pythonrunner.cpp         |   1 +
 src/runner/pythonwrapperutilities.h | 116 +++++++++----------------
 src/runner/uibasewrappers.h         |  12 +--
 5 files changed, 146 insertions(+), 175 deletions(-)

diff --git a/src/runner/gamefeatureswrappers.cpp b/src/runner/gamefeatureswrappers.cpp
index 462ce91..dd70821 100644
--- a/src/runner/gamefeatureswrappers.cpp
+++ b/src/runner/gamefeatureswrappers.cpp
@@ -17,22 +17,22 @@
 
 bool BSAInvalidationWrapper::isInvalidationBSA(const QString &bsaName)
 {
-  return basicWrapperFunctionImplementation<BSAInvalidationWrapper, bool>(this, "isInvalidationBSA", bsaName);
+  return basicWrapperFunctionImplementation<bool>(this, "isInvalidationBSA", bsaName);
 }
 
 void BSAInvalidationWrapper::deactivate(MOBase::IProfile *profile)
 {
-  return basicWrapperFunctionImplementation<BSAInvalidationWrapper, void>(this, "deactivate", boost::python::ptr(profile));
+  return basicWrapperFunctionImplementation<void>(this, "deactivate", boost::python::ptr(profile));
 }
 
 void BSAInvalidationWrapper::activate(MOBase::IProfile *profile)
 {
-  return basicWrapperFunctionImplementation<BSAInvalidationWrapper, void>(this, "activate", boost::python::ptr(profile));
+  return basicWrapperFunctionImplementation<void>(this, "activate", boost::python::ptr(profile));
 }
 
 bool BSAInvalidationWrapper::prepareProfile(MOBase::IProfile *profile)
 {
-  return basicWrapperFunctionImplementation<BSAInvalidationWrapper, bool>(this, "prepareProfile", boost::python::ptr(profile));
+  return basicWrapperFunctionImplementation<bool>(this, "prepareProfile", boost::python::ptr(profile));
 }
 /// end BSAInvalidation Wrapper
 /////////////////////////////
@@ -41,22 +41,22 @@ bool BSAInvalidationWrapper::prepareProfile(MOBase::IProfile *profile)
 
 QStringList DataArchivesWrapper::vanillaArchives() const
 {
-  return basicWrapperFunctionImplementation<DataArchivesWrapper, QStringList>(this, "vanillaArchives");
+  return basicWrapperFunctionImplementation<QStringList>(this, "vanillaArchives");
 }
 
 QStringList DataArchivesWrapper::archives(const MOBase::IProfile *profile) const
 {
-  return basicWrapperFunctionImplementation<DataArchivesWrapper, QStringList>(this, "archives", boost::python::ptr(profile));
+  return basicWrapperFunctionImplementation<QStringList>(this, "archives", boost::python::ptr(profile));
 }
 
 void DataArchivesWrapper::addArchive(MOBase::IProfile *profile, int index, const QString &archiveName)
 {
-  return basicWrapperFunctionImplementation<DataArchivesWrapper, void>(this, "addArchive", boost::python::ptr(profile), index, archiveName);
+  return basicWrapperFunctionImplementation<void>(this, "addArchive", boost::python::ptr(profile), index, archiveName);
 }
 
 void DataArchivesWrapper::removeArchive(MOBase::IProfile *profile, const QString &archiveName)
 {
-  return basicWrapperFunctionImplementation<DataArchivesWrapper, void>(this, "removeArchive", boost::python::ptr(profile), archiveName);
+  return basicWrapperFunctionImplementation<void>(this, "removeArchive", boost::python::ptr(profile), archiveName);
 }
 /// end DataArchives Wrapper
 /////////////////////////////
@@ -65,22 +65,22 @@ void DataArchivesWrapper::removeArchive(MOBase::IProfile *profile, const QString
 
 void GamePluginsWrapper::writePluginLists(const MOBase::IPluginList * pluginList)
 {
-  return basicWrapperFunctionImplementation<GamePluginsWrapper, void>(this, "writePluginLists", boost::python::ptr(pluginList));
+  return basicWrapperFunctionImplementation<void>(this, "writePluginLists", boost::python::ptr(pluginList));
 }
 
 void GamePluginsWrapper::readPluginLists(MOBase::IPluginList * pluginList)
 {
-  return basicWrapperFunctionImplementation<GamePluginsWrapper, void>(this, "readPluginLists", boost::python::ptr(pluginList));
+  return basicWrapperFunctionImplementation<void>(this, "readPluginLists", boost::python::ptr(pluginList));
 }
 
 void GamePluginsWrapper::getLoadOrder(QStringList &loadOrder)
 {
-  return basicWrapperFunctionImplementation<GamePluginsWrapper, void>(this, "getLoadOrder", loadOrder);
+  return basicWrapperFunctionImplementation<void>(this, "getLoadOrder", loadOrder);
 }
 
 bool GamePluginsWrapper::lightPluginsAreSupported()
 {
-    return basicWrapperFunctionImplementation<GamePluginsWrapper, bool>(this, "lightPluginsAreSupported");
+    return basicWrapperFunctionImplementation<bool>(this, "lightPluginsAreSupported");
 }
 
 /// end GamePlugins Wrapper
@@ -90,12 +90,12 @@ bool GamePluginsWrapper::lightPluginsAreSupported()
 
 MappingType LocalSavegamesWrapper::mappings(const QDir & profileSaveDir) const
 {
-  return basicWrapperFunctionImplementation<LocalSavegamesWrapper, MappingType>(this, "mappings", profileSaveDir);
+  return basicWrapperFunctionImplementation<MappingType>(this, "mappings", profileSaveDir);
 }
 
 bool LocalSavegamesWrapper::prepareProfile(MOBase::IProfile * profile)
 {
-  return basicWrapperFunctionImplementation<LocalSavegamesWrapper, bool>(this, "prepareProfile", boost::python::ptr(profile));
+  return basicWrapperFunctionImplementation<bool>(this, "prepareProfile", boost::python::ptr(profile));
 }
 
 /// end LocalSavegames Wrapper
@@ -103,7 +103,7 @@ bool LocalSavegamesWrapper::prepareProfile(MOBase::IProfile * profile)
 /// ModDataChecker Wrapper
 
 bool ModDataCheckerWrapper::dataLooksValid(std::shared_ptr<const MOBase::IFileTree> fileTree) const {
-  return basicWrapperFunctionImplementation<ModDataCheckerWrapper, bool>(this, "dataLooksValid", fileTree);
+  return basicWrapperFunctionImplementation<bool>(this, "dataLooksValid", fileTree);
 }
 
 /// end ModDataChecker Wrapper
@@ -113,22 +113,22 @@ bool ModDataCheckerWrapper::dataLooksValid(std::shared_ptr<const MOBase::IFileTr
 
 MOBase::ISaveGame const * SaveGameInfoWrapper::getSaveGameInfo(QString const & file) const
 {
-  return basicWrapperFunctionImplementation<SaveGameInfoWrapper, MOBase::ISaveGame*>(this, m_SaveGames[file], "getSaveGameInfo", file);
+  return basicWrapperFunctionImplementation<MOBase::ISaveGame*>(this, m_SaveGames[file], "getSaveGameInfo", file);
 }
 
 SaveGameInfoWrapper::MissingAssets SaveGameInfoWrapper::getMissingAssets(QString const & file) const
 {
-  return basicWrapperFunctionImplementation<SaveGameInfoWrapper, SaveGameInfoWrapper::MissingAssets>(this, "getMissingAssets", file);
+  return basicWrapperFunctionImplementation<SaveGameInfoWrapper::MissingAssets>(this, "getMissingAssets", file);
 }
 
 MOBase::ISaveGameInfoWidget* SaveGameInfoWrapper::getSaveGameWidget(QWidget* parent) const
 {
-  return basicWrapperFunctionImplementation<SaveGameInfoWrapper, MOBase::ISaveGameInfoWidget*>(this, m_SaveGameWidget, "getSaveGameWidget", parent);
+  return basicWrapperFunctionImplementation<MOBase::ISaveGameInfoWidget*>(this, m_SaveGameWidget, "getSaveGameWidget", parent);
 }
 
 bool SaveGameInfoWrapper::hasScriptExtenderSave(QString const & file) const
 {
-  return basicWrapperFunctionImplementation<SaveGameInfoWrapper, bool>(this, "hasScriptExtenderSave", file);
+  return basicWrapperFunctionImplementation<bool>(this, "hasScriptExtenderSave", file);
 }
 /// end SaveGameInfo Wrapper
 /////////////////////////////
@@ -136,42 +136,42 @@ bool SaveGameInfoWrapper::hasScriptExtenderSave(QString const & file) const
 
 QString ScriptExtenderWrapper::BinaryName() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QString>(this, "BinaryName");
+  return basicWrapperFunctionImplementation<QString>(this, "BinaryName");
 }
 
 QString ScriptExtenderWrapper::PluginPath() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QString>(this, "PluginPath");
+  return basicWrapperFunctionImplementation<QString>(this, "PluginPath");
 }
 
 QString ScriptExtenderWrapper::loaderName() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QString>(this, "loaderName");
+  return basicWrapperFunctionImplementation<QString>(this, "loaderName");
 }
 
 QString ScriptExtenderWrapper::loaderPath() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QString>(this, "loaderPath");
+  return basicWrapperFunctionImplementation<QString>(this, "loaderPath");
 }
 
 QStringList ScriptExtenderWrapper::saveGameAttachmentExtensions() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QStringList>(this, "saveGameAttachmentExtensions");
+  return basicWrapperFunctionImplementation<QStringList>(this, "saveGameAttachmentExtensions");
 }
 
 bool ScriptExtenderWrapper::isInstalled() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, bool>(this, "isInstalled");
+  return basicWrapperFunctionImplementation<bool>(this, "isInstalled");
 }
 
 QString ScriptExtenderWrapper::getExtenderVersion() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, QString>(this, "getExtenderVersion");
+  return basicWrapperFunctionImplementation<QString>(this, "getExtenderVersion");
 }
 
 WORD ScriptExtenderWrapper::getArch() const
 {
-  return basicWrapperFunctionImplementation<ScriptExtenderWrapper, WORD>(this, "getArch");
+  return basicWrapperFunctionImplementation<WORD>(this, "getArch");
 }
 
 /// end ScriptExtender Wrapper
@@ -181,22 +181,22 @@ WORD ScriptExtenderWrapper::getArch() const
 
 QStringList UnmanagedModsWrapper::mods(bool onlyOfficial) const
 {
-  return basicWrapperFunctionImplementation<UnmanagedModsWrapper, QStringList>(this, "mods", onlyOfficial);
+  return basicWrapperFunctionImplementation<QStringList>(this, "mods", onlyOfficial);
 }
 
 QString UnmanagedModsWrapper::displayName(const QString & modName) const
 {
-  return basicWrapperFunctionImplementation<UnmanagedModsWrapper, QString>(this, "displayName", modName);
+  return basicWrapperFunctionImplementation<QString>(this, "displayName", modName);
 }
 
 QFileInfo UnmanagedModsWrapper::referenceFile(const QString & modName) const
 {
-  return basicWrapperFunctionImplementation<UnmanagedModsWrapper, QFileInfo>(this, "referenceFile", modName);
+  return basicWrapperFunctionImplementation<QFileInfo>(this, "referenceFile", modName);
 }
 
 QStringList UnmanagedModsWrapper::secondaryFiles(const QString & modName) const
 {
-  return basicWrapperFunctionImplementation<UnmanagedModsWrapper, QStringList>(this, "secondaryFiles", modName);
+  return basicWrapperFunctionImplementation<QStringList>(this, "secondaryFiles", modName);
 }
 /// end UnmanagedMods Wrapper
 /////////////////////////////
diff --git a/src/runner/proxypluginwrappers.cpp b/src/runner/proxypluginwrappers.cpp
index 6c2b849..32695eb 100644
--- a/src/runner/proxypluginwrappers.cpp
+++ b/src/runner/proxypluginwrappers.cpp
@@ -31,37 +31,37 @@ using namespace MOBase;
 #define COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(class_name) \
 bool class_name::init(MOBase::IOrganizer *moInfo) \
 { \
-  return basicWrapperFunctionImplementation<class_name, bool>(this, "init", boost::python::ptr(moInfo)); \
+  return basicWrapperFunctionImplementation<bool>(this, "init", boost::python::ptr(moInfo)); \
 } \
  \
 QString class_name::name() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, QString>(this, "name"); \
+  return basicWrapperFunctionImplementation<QString>(this, "name"); \
 } \
  \
 QString class_name::author() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, QString>(this, "author"); \
+  return basicWrapperFunctionImplementation<QString>(this, "author"); \
 } \
  \
 QString class_name::description() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, QString>(this, "description"); \
+  return basicWrapperFunctionImplementation<QString>(this, "description"); \
 } \
  \
 MOBase::VersionInfo class_name::version() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, MOBase::VersionInfo>(this, "version"); \
+  return basicWrapperFunctionImplementation<MOBase::VersionInfo>(this, "version"); \
 } \
  \
 bool class_name::isActive() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, bool>(this, "isActive"); \
+  return basicWrapperFunctionImplementation<bool>(this, "isActive"); \
 } \
  \
 QList<MOBase::PluginSetting> class_name::settings() const \
 { \
-  return basicWrapperFunctionImplementation<class_name, QList<MOBase::PluginSetting>>(this, "settings"); \
+  return basicWrapperFunctionImplementation<QList<MOBase::PluginSetting>>(this, "settings"); \
 }
 
 /// end COMMON_I_PLUGIN_WRAPPER_DEFINITIONS
@@ -79,27 +79,27 @@ COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginDiagnoseWrapper)
 
 std::vector<unsigned int> IPluginDiagnoseWrapper::activeProblems() const
 {
-  return basicWrapperFunctionImplementation<IPluginDiagnoseWrapper, std::vector<unsigned int>>(this, "activeProblems");
+  return basicWrapperFunctionImplementation<std::vector<unsigned int>>(this, "activeProblems");
 }
 
 QString IPluginDiagnoseWrapper::shortDescription(unsigned int key) const
 {
-  return basicWrapperFunctionImplementation<IPluginDiagnoseWrapper, QString>(this, "shortDescription", key);
+  return basicWrapperFunctionImplementation<QString>(this, "shortDescription", key);
 }
 
 QString IPluginDiagnoseWrapper::fullDescription(unsigned int key) const
 {
-  return basicWrapperFunctionImplementation<IPluginDiagnoseWrapper, QString>(this, "fullDescription", key);
+  return basicWrapperFunctionImplementation<QString>(this, "fullDescription", key);
 }
 
 bool IPluginDiagnoseWrapper::hasGuidedFix(unsigned int key) const
 {
-  return basicWrapperFunctionImplementation<IPluginDiagnoseWrapper, bool>(this, "hasGuidedFix", key);
+  return basicWrapperFunctionImplementation<bool>(this, "hasGuidedFix", key);
 }
 
 void IPluginDiagnoseWrapper::startGuidedFix(unsigned int key) const
 {
-  basicWrapperFunctionImplementation<IPluginDiagnoseWrapper, void>(this, "startGuidedFix", key);
+  basicWrapperFunctionImplementation<void>(this, "startGuidedFix", key);
 }
 
 /// end IPluginDiagnose Wrapper
@@ -111,7 +111,7 @@ COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginFileMapperWrapper)
 
 MappingType IPluginFileMapperWrapper::mappings() const
 {
-  return basicWrapperFunctionImplementation<IPluginFileMapperWrapper, MappingType>(this, "mappings");
+  return basicWrapperFunctionImplementation<MappingType>(this, "mappings");
 }
 /// end IPluginFileMapper Wrapper
 /////////////////////////////////////
@@ -120,178 +120,178 @@ MappingType IPluginFileMapperWrapper::mappings() const
 
 QString IPluginGameWrapper::gameName() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "gameName");
+  return basicWrapperFunctionImplementation<QString>(this, "gameName");
 }
 
 void IPluginGameWrapper::initializeProfile(const QDir & directory, ProfileSettings settings) const
 {
-  basicWrapperFunctionImplementation<IPluginGameWrapper, void>(this, "initializeProfile", directory, settings);
+  basicWrapperFunctionImplementation<void>(this, "initializeProfile", directory, settings);
 }
 
 QString IPluginGameWrapper::savegameExtension() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "savegameExtension");
+  return basicWrapperFunctionImplementation<QString>(this, "savegameExtension");
 }
 
 QString IPluginGameWrapper::savegameSEExtension() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "savegameSEExtension");
+  return basicWrapperFunctionImplementation<QString>(this, "savegameSEExtension");
 }
 
 bool IPluginGameWrapper::isInstalled() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, bool>(this, "isInstalled");
+  return basicWrapperFunctionImplementation<bool>(this, "isInstalled");
 }
 
 QIcon IPluginGameWrapper::gameIcon() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QIcon>(this, "gameIcon");
+  return basicWrapperFunctionImplementation<QIcon>(this, "gameIcon");
 }
 
 QDir IPluginGameWrapper::gameDirectory() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QDir>(this, "gameDirectory");
+  return basicWrapperFunctionImplementation<QDir>(this, "gameDirectory");
 }
 
 QDir IPluginGameWrapper::dataDirectory() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QDir>(this, "dataDirectory");
+  return basicWrapperFunctionImplementation<QDir>(this, "dataDirectory");
 }
 
 void IPluginGameWrapper::setGamePath(const QString & path)
 {
-  basicWrapperFunctionImplementation<IPluginGameWrapper, void>(this, "setGamePath", path);
+  basicWrapperFunctionImplementation<void>(this, "setGamePath", path);
 }
 
 QDir IPluginGameWrapper::documentsDirectory() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QDir>(this, "documentsDirectory");
+  return basicWrapperFunctionImplementation<QDir>(this, "documentsDirectory");
 }
 
 QDir IPluginGameWrapper::savesDirectory() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QDir>(this, "savesDirectory");
+  return basicWrapperFunctionImplementation<QDir>(this, "savesDirectory");
 }
 
 QList<MOBase::ExecutableInfo> IPluginGameWrapper::executables() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QList<MOBase::ExecutableInfo>>(this, "executables");
+  return basicWrapperFunctionImplementation<QList<MOBase::ExecutableInfo>>(this, "executables");
 }
 
 QList<MOBase::ExecutableForcedLoadSetting> IPluginGameWrapper::executableForcedLoads() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QList<MOBase::ExecutableForcedLoadSetting>>(this, "executableForcedLoads");
+  return basicWrapperFunctionImplementation<QList<MOBase::ExecutableForcedLoadSetting>>(this, "executableForcedLoads");
 }
 
 QString IPluginGameWrapper::steamAPPId() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "steamAPPId");
+  return basicWrapperFunctionImplementation<QString>(this, "steamAPPId");
 }
 
 QStringList IPluginGameWrapper::primaryPlugins() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "primaryPlugins");
+  return basicWrapperFunctionImplementation<QStringList>(this, "primaryPlugins");
 }
 
 QStringList IPluginGameWrapper::gameVariants() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "gameVariants");
+  return basicWrapperFunctionImplementation<QStringList>(this, "gameVariants");
 }
 
 void IPluginGameWrapper::setGameVariant(const QString & variant)
 {
-  basicWrapperFunctionImplementation<IPluginGameWrapper, void>(this, "setGameVariant", variant);
+  basicWrapperFunctionImplementation<void>(this, "setGameVariant", variant);
 }
 
 QString IPluginGameWrapper::binaryName() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "binaryName");
+  return basicWrapperFunctionImplementation<QString>(this, "binaryName");
 }
 
 QString IPluginGameWrapper::gameShortName() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "gameShortName");
+  return basicWrapperFunctionImplementation<QString>(this, "gameShortName");
 }
 
 QStringList IPluginGameWrapper::primarySources() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "primarySources");
+  return basicWrapperFunctionImplementation<QStringList>(this, "primarySources");
 }
 
 QStringList IPluginGameWrapper::validShortNames() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "validShortNames");
+  return basicWrapperFunctionImplementation<QStringList>(this, "validShortNames");
 }
 
 QString IPluginGameWrapper::gameNexusName() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "gameNexusName");
+  return basicWrapperFunctionImplementation<QString>(this, "gameNexusName");
 }
 
 QStringList IPluginGameWrapper::iniFiles() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "iniFiles");
+  return basicWrapperFunctionImplementation<QStringList>(this, "iniFiles");
 }
 
 QStringList IPluginGameWrapper::DLCPlugins() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "DLCPlugins");
+  return basicWrapperFunctionImplementation<QStringList>(this, "DLCPlugins");
 }
 
 QStringList IPluginGameWrapper::CCPlugins() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QStringList>(this, "CCPlugins");
+  return basicWrapperFunctionImplementation<QStringList>(this, "CCPlugins");
 }
 
 IPluginGame::LoadOrderMechanism IPluginGameWrapper::loadOrderMechanism() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, IPluginGame::LoadOrderMechanism>(this, "loadOrderMechanism");
+  return basicWrapperFunctionImplementation<IPluginGame::LoadOrderMechanism>(this, "loadOrderMechanism");
 }
 
 IPluginGame::SortMechanism IPluginGameWrapper::sortMechanism() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, IPluginGame::SortMechanism>(this, "sortMechanism");
+  return basicWrapperFunctionImplementation<IPluginGame::SortMechanism>(this, "sortMechanism");
 }
 
 int IPluginGameWrapper::nexusModOrganizerID() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, int>(this, "nexusModOrganizerID");
+  return basicWrapperFunctionImplementation<int>(this, "nexusModOrganizerID");
 }
 
 int IPluginGameWrapper::nexusGameID() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, int>(this, "nexusGameID");
+  return basicWrapperFunctionImplementation<int>(this, "nexusGameID");
 }
 
 bool IPluginGameWrapper::looksValid(QDir const & dir) const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, bool>(this, "looksValid", dir);
+  return basicWrapperFunctionImplementation<bool>(this, "looksValid", dir);
 }
 
 QString IPluginGameWrapper::gameVersion() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "gameVersion");
+  return basicWrapperFunctionImplementation<QString>(this, "gameVersion");
 }
 
 QString IPluginGameWrapper::getLauncherName() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, QString>(this, "getLauncherName");
+  return basicWrapperFunctionImplementation<QString>(this, "getLauncherName");
 }
 
 COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginGameWrapper)
 
 std::map<std::type_index, boost::any> IPluginGameWrapper::featureList() const
 {
-  return basicWrapperFunctionImplementation<IPluginGameWrapper, std::map<std::type_index, boost::any>>(this, "_featureList");
+  return basicWrapperFunctionImplementation<std::map<std::type_index, boost::any>>(this, "_featureList");
 }
 /// end IPluginGame Wrapper
 /////////////////////////////////////
 /// IPluginInstaller macro
 
 #define COMMON_I_PLUGIN_INSTALLER_WRAPPER_DEFINITIONS(class_name) \
-unsigned int class_name::priority() const { return basicWrapperFunctionImplementation<class_name, unsigned int>(this, "priority"); } \
-bool class_name::isManualInstaller() const { return basicWrapperFunctionImplementation<class_name, bool>(this, "isManualInstaller"); } \
-bool class_name::isArchiveSupported(std::shared_ptr<const IFileTree> tree) const { return basicWrapperFunctionImplementation<class_name, bool>(this, "isArchiveSupported", tree); } 
+unsigned int class_name::priority() const { return basicWrapperFunctionImplementation<unsigned int>(this, "priority"); } \
+bool class_name::isManualInstaller() const { return basicWrapperFunctionImplementation<bool>(this, "isManualInstaller"); } \
+bool class_name::isArchiveSupported(std::shared_ptr<const IFileTree> tree) const { return basicWrapperFunctionImplementation<bool>(this, "isArchiveSupported", tree); } 
 
 /// end IPluginInstaller macro
 /////////////////////////////////////
@@ -310,7 +310,7 @@ IPluginInstaller::EInstallResult IPluginInstallerSimpleWrapper::install(
     IPluginInstaller::EInstallResult,
     std::shared_ptr<IFileTree>, 
     std::tuple<IPluginInstaller::EInstallResult, std::shared_ptr<IFileTree>, QString, int>> ;
-  auto ret = basicWrapperFunctionImplementation<IPluginInstallerSimpleWrapper, return_type>(this, "install", boost::ref(modName), tree, version, nexusID);
+  auto ret = basicWrapperFunctionImplementation<return_type>(this, "install", boost::ref(modName), tree, version, nexusID);
 
   return std::visit([&](auto const& t) {
     using type = std::decay_t<decltype(t)>;
@@ -338,12 +338,12 @@ COMMON_I_PLUGIN_INSTALLER_WRAPPER_DEFINITIONS(IPluginInstallerCustomWrapper)
 
 bool IPluginInstallerCustomWrapper::isArchiveSupported(const QString &archiveName) const
 {
-  return basicWrapperFunctionImplementation<IPluginInstallerCustomWrapper, bool>(this, "isArchiveSupported", archiveName);
+  return basicWrapperFunctionImplementation<bool>(this, "isArchiveSupported", archiveName);
 }
 
 std::set<QString> IPluginInstallerCustomWrapper::supportedExtensions() const
 {
-  return basicWrapperFunctionImplementation<IPluginInstallerCustomWrapper, std::set<QString>>(this, "supportedExtensions");
+  return basicWrapperFunctionImplementation<std::set<QString>>(this, "supportedExtensions");
 }
 
 IPluginInstaller::EInstallResult IPluginInstallerCustomWrapper::install(
@@ -351,7 +351,7 @@ IPluginInstaller::EInstallResult IPluginInstallerCustomWrapper::install(
 {
   // Note: This requires far more less trouble than the "Simple" installer version since 1) there is no tree 
   // and 2) there version and modId cannot be modified:
-  return basicWrapperFunctionImplementation<IPluginInstallerCustomWrapper, IPluginInstaller::EInstallResult>(
+  return basicWrapperFunctionImplementation<IPluginInstaller::EInstallResult>(
     this, "install", boost::ref(modName), gameName, archiveName, version, modID);
 }
 
@@ -364,32 +364,32 @@ COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginModPageWrapper)
 
 QString IPluginModPageWrapper::displayName() const
 {
-  return basicWrapperFunctionImplementation<IPluginModPageWrapper, QString>(this, "displayName");
+  return basicWrapperFunctionImplementation<QString>(this, "displayName");
 }
 
 QIcon IPluginModPageWrapper::icon() const
 {
-  return basicWrapperFunctionImplementation<IPluginModPageWrapper, QIcon>(this, "icon");
+  return basicWrapperFunctionImplementation<QIcon>(this, "icon");
 }
 
 QUrl IPluginModPageWrapper::pageURL() const
 {
-  return basicWrapperFunctionImplementation<IPluginModPageWrapper, QUrl>(this, "pageURL");
+  return basicWrapperFunctionImplementation<QUrl>(this, "pageURL");
 }
 
 bool IPluginModPageWrapper::useIntegratedBrowser() const
 {
-  return basicWrapperFunctionImplementation<IPluginModPageWrapper, bool>(this, "useIntegratedBrowser");
+  return basicWrapperFunctionImplementation<bool>(this, "useIntegratedBrowser");
 }
 
 bool IPluginModPageWrapper::handlesDownload(const QUrl & pageURL, const QUrl & downloadURL, MOBase::ModRepositoryFileInfo & fileInfo) const
 {
-  return basicWrapperFunctionImplementation<IPluginModPageWrapper, bool>(this, "handlesDownload", pageURL, downloadURL, fileInfo);
+  return basicWrapperFunctionImplementation<bool>(this, "handlesDownload", pageURL, downloadURL, fileInfo);
 }
 
 void IPluginModPageWrapper::setParentWidget(QWidget * widget)
 {
-  basicWrapperFunctionImplementationWithDefault<IPluginModPageWrapper, void>(this, &IPluginModPageWrapper::setParentWidget_Default, "setParentWidget", widget);
+  basicWrapperFunctionImplementationWithDefault<void>(this, &IPluginModPageWrapper::setParentWidget_Default, "setParentWidget", widget);
 }
 /// end IPluginModPage Wrapper
 /////////////////////////////
@@ -400,7 +400,7 @@ COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginPreviewWrapper)
 
 std::set<QString> IPluginPreviewWrapper::supportedExtensions() const
 {
-  return basicWrapperFunctionImplementation<IPluginPreviewWrapper, std::set<QString>>(this, "supportedExtensions");
+  return basicWrapperFunctionImplementation<std::set<QString>>(this, "supportedExtensions");
 }
 
 QWidget *IPluginPreviewWrapper::genFilePreview(const QString &fileName, const QSize &maxSize) const
@@ -435,27 +435,27 @@ COMMON_I_PLUGIN_WRAPPER_DEFINITIONS(IPluginToolWrapper)
 
 QString IPluginToolWrapper::displayName() const
 {
-  return basicWrapperFunctionImplementation<IPluginToolWrapper, QString>(this, "displayName");
+  return basicWrapperFunctionImplementation<QString>(this, "displayName");
 }
 
 QString IPluginToolWrapper::tooltip() const
 {
-  return basicWrapperFunctionImplementation<IPluginToolWrapper, QString>(this, "tooltip");
+  return basicWrapperFunctionImplementation<QString>(this, "tooltip");
 }
 
 QIcon IPluginToolWrapper::icon() const
 {
-  return basicWrapperFunctionImplementation<IPluginToolWrapper, QIcon>(this, "icon");
+  return basicWrapperFunctionImplementation<QIcon>(this, "icon");
 }
 
 void IPluginToolWrapper::setParentWidget(QWidget *parent)
 {
-  basicWrapperFunctionImplementationWithDefault<IPluginToolWrapper, void>(this, &IPluginToolWrapper::setParentWidget_Default, "setParentWidget", parent);
+  basicWrapperFunctionImplementationWithDefault<void>(this, &IPluginToolWrapper::setParentWidget_Default, "setParentWidget", parent);
 }
 
 void IPluginToolWrapper::display() const
 {
-  basicWrapperFunctionImplementation<IPluginToolWrapper, void>(this, "display");
+  basicWrapperFunctionImplementation<void>(this, "display");
 }
 
 /// end IPluginTool Wrapper
diff --git a/src/runner/pythonrunner.cpp b/src/runner/pythonrunner.cpp
index 87d3656..b562f06 100644
--- a/src/runner/pythonrunner.cpp
+++ b/src/runner/pythonrunner.cpp
@@ -776,6 +776,7 @@ BOOST_PYTHON_MODULE(mobase)
     .def("displayName", bpy::pure_virtual(&IPluginTool::displayName))
     .def("tooltip", bpy::pure_virtual(&IPluginTool::tooltip))
     .def("icon", bpy::pure_virtual(&IPluginTool::icon))
+    .def("display", bpy::pure_virtual(&IPluginTool::display))
     .def("setParentWidget", &IPluginTool::setParentWidget, &IPluginToolWrapper::setParentWidget_Default)
     .def("_parentWidget", &IPluginToolWrapper::parentWidget, bpy::return_value_policy<bpy::return_by_value>())
     ;
diff --git a/src/runner/pythonwrapperutilities.h b/src/runner/pythonwrapperutilities.h
index ab44ddc..6e80dbf 100644
--- a/src/runner/pythonwrapperutilities.h
+++ b/src/runner/pythonwrapperutilities.h
@@ -11,95 +11,65 @@
 #include "error.h"
 #include "gilock.h"
 
+namespace details {
+
+  /**
+   * @brief Common stuffs for all basicWrapperFunction methods.
+   */
+  template <class ReturnType, class WrapperTypePtr, class Fn, class... Args>
+  ReturnType wrapperFunctionImplementation(WrapperTypePtr wrapper, Fn fn, boost::python::object* objPtr, const char *methodName, Args... args) {
+    GILock lock;
+    boost::python::override implementation = wrapper->get_override(methodName);
+    if (!implementation) {
+      if constexpr (std::is_same_v<Fn, std::nullptr_t>) {
+        throw pyexcept::MissingImplementation(wrapper->className, methodName);
+      }
+      else {
+        return std::invoke(fn, wrapper, args...);
+      }
+    }
+    try {
+      boost::python::object result = implementation(args...);
+      if (objPtr) {
+        *objPtr = result;
+      }
+      if constexpr (!std::is_same_v<ReturnType, void>) {
+        return boost::python::extract<ReturnType>(result)();
+      }
+    }
+    catch (const boost::python::error_already_set&) {
+      throw pyexcept::PythonError();
+    }
+    catch (...) {
+      throw pyexcept::UnknownException();
+    }
+  }
+
+}
+
 /**
  * @brief Call the given method on the wrapper with the given arguments, with proper
  *     exception handling.
  */
-template <class WrapperType, class ReturnType, class... Args>
+template <class ReturnType, class WrapperType, class... Args>
 ReturnType basicWrapperFunctionImplementation(const WrapperType *wrapper, const char *methodName, Args... args)
 {
-  GILock lock;
-  boost::python::override implementation = wrapper->get_override(methodName);
-  if (!implementation) {
-    throw pyexcept::MissingImplementation(wrapper->className, methodName);
-  }
-  try {
-    return implementation(args...).as<ReturnType>();
-  }
-  catch (const boost::python::error_already_set&) {
-    throw pyexcept::PythonError();
-  }
-  catch (...) {
-    throw pyexcept::UnknownException();
-  }
+  return details::wrapperFunctionImplementation<ReturnType>(wrapper, nullptr, nullptr, methodName, args...);
 }
 
 /**
  * @brief Similar to the first-overload but also stores the python object in the given reference.
  */
-template <class WrapperType, class ReturnType, class... Args>
+template <class ReturnType, class WrapperType, class... Args>
 ReturnType basicWrapperFunctionImplementation(const WrapperType* wrapper, boost::python::object &ref, const char* methodName, Args... args)
 {
-  GILock lock;
-  boost::python::override implementation = wrapper->get_override(methodName);
-  if (!implementation) {
-    throw pyexcept::MissingImplementation(wrapper->className, methodName);
-  }
-  try {
-    ref = implementation(args...);
-    return boost::python::extract<ReturnType>(ref)();
-  }
-  catch (const boost::python::error_already_set&) {
-    throw pyexcept::PythonError();
-  }
-  catch (pyexcept::MissingImplementation const& missingImplementation) {
-    throw missingImplementation;
-  }
-  catch (...) {
-    throw pyexcept::UnknownException();
-  }
+  return details::wrapperFunctionImplementation<ReturnType>(wrapper, nullptr, &ref, methodName, args...);
 }
 
-template <class WrapperType, class ReturnType, class Fn, class... Args>
-ReturnType basicWrapperFunctionImplementationWithDefault(WrapperType* wrapper, Fn fn, const char* methodName, Args... args)
+template <class ReturnType, class WrapperTypePtr, class Fn, class... Args>
+ReturnType basicWrapperFunctionImplementationWithDefault(WrapperTypePtr wrapper, Fn fn, const char* methodName, Args... args)
 {
-  GILock lock;
-  boost::python::override implementation = wrapper->get_override(methodName);
-
-  if (!implementation) {
-    return std::invoke(fn, wrapper, args...);
-  }
-
-  try {
-    return implementation(args...).as<ReturnType>();
-  }
-  catch (const boost::python::error_already_set&) {
-    throw pyexcept::PythonError();
-  }
-  catch (...) {
-    throw pyexcept::UnknownException();
-  }
-}
-
-template <class WrapperType, class ReturnType, class Fn, class... Args>
-ReturnType basicWrapperFunctionImplementationWithDefault(const WrapperType* wrapper, Fn fn, const char* methodName, Args... args)
-{
-  GILock lock;
-  boost::python::override implementation = wrapper->get_override(methodName);
-
-  if (!implementation) {
-    return std::invoke(fn, wrapper, args...);
-  }
-
-  try {
-    return implementation(args...).as<ReturnType>();
-  }
-  catch (const boost::python::error_already_set&) {
-    throw pyexcept::PythonError();
-  }
-  catch (...) {
-    throw pyexcept::UnknownException();
-  }
+  return details::wrapperFunctionImplementation<ReturnType>(wrapper, fn, nullptr, methodName, args...);
 }
 
 #endif // PYTHONWRAPPERUTILITIES_H
diff --git a/src/runner/uibasewrappers.h b/src/runner/uibasewrappers.h
index c06c1e5..a032853 100644
--- a/src/runner/uibasewrappers.h
+++ b/src/runner/uibasewrappers.h
@@ -28,11 +28,11 @@ public:
   static constexpr const char* className = "ISaveGameWrapper";
   using boost::python::wrapper<MOBase::ISaveGame>::get_override;
 
-  virtual QString getFilename() const override { return basicWrapperFunctionImplementation<ISaveGameWrapper, QString>(this, "getFilename"); };
-  virtual QDateTime getCreationTime() const override { return basicWrapperFunctionImplementation<ISaveGameWrapper, QDateTime>(this, "getCreationTime"); };
-  virtual QString getSaveGroupIdentifier() const override { return basicWrapperFunctionImplementation<ISaveGameWrapper, QString>(this, "getSaveGroupIdentifier"); };
-  virtual QStringList allFiles() const override { return basicWrapperFunctionImplementation<ISaveGameWrapper, QStringList>(this, "allFiles"); };
-  virtual bool hasScriptExtenderFile() const override { return basicWrapperFunctionImplementation<ISaveGameWrapper, bool>(this, "hasScriptExtenderFile"); };
+  virtual QString getFilename() const override { return basicWrapperFunctionImplementation<QString>(this, "getFilename"); };
+  virtual QDateTime getCreationTime() const override { return basicWrapperFunctionImplementation<QDateTime>(this, "getCreationTime"); };
+  virtual QString getSaveGroupIdentifier() const override { return basicWrapperFunctionImplementation<QString>(this, "getSaveGroupIdentifier"); };
+  virtual QStringList allFiles() const override { return basicWrapperFunctionImplementation<QStringList>(this, "allFiles"); };
+  virtual bool hasScriptExtenderFile() const override { return basicWrapperFunctionImplementation<bool>(this, "hasScriptExtenderFile"); };
 };
 
 // This needs a wrapper but currently I have no idea how to expose this properly to python:
@@ -45,7 +45,7 @@ public:
   // Bring the constructor:
   using ISaveGameInfoWidget::ISaveGameInfoWidget;
 
-  virtual void setSave(QString const& save) override { basicWrapperFunctionImplementation<ISaveGameInfoWidgetWrapper, void>(this, "setSave", save); };
+  virtual void setSave(QString const& save) override { basicWrapperFunctionImplementation<void>(this, "setSave", save); };
 };
 
 #endif // UIBASEWRAPPERS_H