Merge pull request #99 from Holt59/no-more-external-python

Remove support for external Python.

.gitignore

@@ -0,0 +1,5 @@
+edit
+CMakeLists.txt.user
+/msbuild.log
+/*std*.log
+/*build

CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(plugin_python)
+set(project_type plugin)
+set(enable_warnings OFF)
+set(create_translations OFF)
+
+if(DEFINED DEPENDENCIES_DIR)
+	include(${DEPENDENCIES_DIR}/modorganizer_super/cmake_common/project.cmake)
+else()
+	include(../cmake_common/project.cmake)
+endif()
+add_subdirectory(src/proxy)
+
+add_subdirectory(src/runner)

appveyor.yml

@@ -0,0 +1,48 @@
+version: 1.0.{build}
+skip_branch_with_pr: true
+image: Visual Studio 2019
+environment:
+  WEBHOOK_URL:
+    secure: gOKbXaZM9ImtMD5XrYITvdyZUW/az082G9OIN1EC1Vbg57wBaeLhi49uGjxPw5GVujHku6kxN6ab89zhbS5GVeluR76GM83IbKV4Sh7udXzoYZZdg6YudtYHzdhCgUeiedpswbuczTq9ceIkkfSEWZuh/lMAAVVwvcGsJAnoPFw=
+build:
+  parallel: true
+build_script:
+- pwsh: >-
+    $ErrorActionPreference = 'Stop'
+
+    git clone --depth=1 --no-single-branch https://github.com/ModOrganizer2/modorganizer-umbrella.git c:\projects\modorganizer-umbrella
+
+    New-Item -ItemType Directory -Path c:\projects\modorganizer-build
+
+    cd c:\projects\modorganizer-umbrella
+    
+    ($env:APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH -eq $null) ? ($branch = $env:APPVEYOR_REPO_BRANCH) : ($branch = $env:APPVEYOR_PULL_REQUEST_HEAD_REPO_BRANCH)
+
+    git checkout $(git show-ref --verify --quiet refs/remotes/origin/${branch} || echo '-b') ${branch}
+
+    C:\Python37-x64\python.exe unimake.py -d c:\projects\modorganizer-build -s Appveyor_Build=True ${env:APPVEYOR_PROJECT_NAME}
+    
+    if($LastExitCode -ne 0) { $host.SetShouldExit($LastExitCode )  }
+artifacts:
+- path: build\src\proxy\plugin_python.dll
+  name: plugin_python_dll
+- path: build\src\proxy\plugin_python.pdb
+  name: plugin_python_pdb
+- path: build\src\proxy\plugin_python.lib
+  name: plugin_python_lib
+- path: build\src\runner\pythonrunner.dll
+  name: pythonrunner_dll
+- path: build\src\runner\pythonrunner.pdb
+  name: pythonrunner_pdb
+- path: build\src\runner\pythonrunner.lib
+  name: pythonrunner_lib
+on_success:
+  - ps: Set-Location -Path $env:APPVEYOR_BUILD_FOLDER
+  - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
+  - ps: ./send.ps1 success $env:WEBHOOK_URL
+on_failure:
+  - ps: Set-Location -Path $env:APPVEYOR_BUILD_FOLDER
+  - ps: Push-AppveyorArtifact ${env:APPVEYOR_BUILD_FOLDER}\stdout.log
+  - ps: Push-AppveyorArtifact ${env:APPVEYOR_BUILD_FOLDER}\stderr.log
+  - ps: Invoke-RestMethod https://raw.githubusercontent.com/DiscordHooks/appveyor-discord-webhook/master/send.ps1 -o send.ps1
+  - ps: ./send.ps1 failure $env:WEBHOOK_URL

src/proxy/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.16)
+# appveyor does not build modorganizer in its standard location, so use
+# DEPENDENCIES_DIR to find cmake_common
+if(DEFINED DEPENDENCIES_DIR)
+	include(${DEPENDENCIES_DIR}/modorganizer_super/cmake_common/src.cmake)
+else()
+	include(../../../cmake_common/src.cmake)
+endif()
+
+requires_library(python)
+target_include_directories(${PROJECT_NAME} PRIVATE
+	${CMAKE_SOURCE_DIR}/src/runner)

src/proxy/SConscript

@@ -0,0 +1,32 @@
+import os
+
+Import('qt_env')
+
+env = qt_env.Clone()
+
+env.AppendUnique(CPPDEFINES = [
+    'PROXYPYTHON_LIBRARY',
+    # suppress a few warnings caused by boost vs vc++ paranoia
+    '_SCL_SECURE_NO_WARNINGS'
+])
+
+env.AppendUnique(CPPPATH = [
+    '${BOOSTPATH}',
+    '..\\..\\pythonRunner'
+])
+
+env.AppendUnique(LIBS = 'shell32')
+
+runner = env.File(os.path.join('..', '..', 'pythonRunner', 'pythonRunner.dll'))
+
+runner_env = env.Clone()
+runner_env.AppendUnique(CPPDEFINES = 'SCONS_BUILD')
+runner_env.AppendUnique(CPPPATH = runner.dir)
+
+# There's a whole load of unused C++ files in here.
+lib = env.SharedLibrary('proxyPython', [ 'proxypython.cpp' ])
+
+env.InstallModule(lib)
+
+res = env['QT_USED_MODULES']
+Return('res')

src/proxy/embedrunner.rc

@@ -1,7 +0,0 @@
-#include "resource.h"
-
-#ifdef _DEBUG
-IDR_LOADER_DLL        BINARY  MOVEABLE PURE   "..\\..\\pythonRunner\\debug\\pythonRunner.dll"
-#else // _DEBUG
-IDR_LOADER_DLL        BINARY  MOVEABLE PURE   "..\\..\\pythonRunner\\release\\pythonRunner.dll"
-#endif // _DEBUG

src/proxy/proxyPython.pro

@@ -8,9 +8,7 @@
 TARGET = proxyPython
 TEMPLATE = lib
 
-contains(QT_VERSION, "^5.*") {
-  QT += widgets
-}
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
 CONFIG += plugins
 CONFIG += dll
@@ -31,21 +29,20 @@ HEADERS += proxypython.h \
 
 OTHER_FILES += \
     proxypython.json \
-    embedrunner.rc
+    SConscript
 
-RC_FILE += \
-    embedrunner.rc
+RC_FILE +=
 
 include(../plugin_template.pri)
 
-INCLUDEPATH += "../../pythonRunner" "$(BOOSTPATH)"
+INCLUDEPATH += "../../pythonRunner" "$${BOOSTPATH}"
 
 WINPWD = $$PWD
 WINPWD ~= s,/,$$QMAKE_DIR_SEP,g
 
-//QMAKE_POST_LINK += SET VS90COMNTOOLS=%VS100COMNTOOLS% $$escape_expand(\\n)
+#QMAKE_POST_LINK += SET VS90COMNTOOLS=%VS100COMNTOOLS% $$escape_expand(\\n)
 
 
-//QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\sip.pyd $$quote($$DSTDIR)\\plugins\\data\\ $$escape_expand(\\n)
-//QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\PyQt4\\QtCore.pyd $$quote($$DSTDIR)\\plugins\\data\\PyQt4\\ $$escape_expand(\\n)
-//QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\PyQt4\\QtGui.pyd $$quote($$DSTDIR)\\plugins\\data\\PyQt4\\ $$escape_expand(\\n)
+#QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\sip.pyd $$quote($$DSTDIR)\\plugins\\data\\ $$escape_expand(\\n)
+#QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\PyQt4\\QtCore.pyd $$quote($$DSTDIR)\\plugins\\data\\PyQt4\\ $$escape_expand(\\n)
+#QMAKE_POST_LINK += copy $$(PYTHONPATH)\\lib\\site-packages\\PyQt4\\QtGui.pyd $$quote($$DSTDIR)\\plugins\\data\\PyQt4\\ $$escape_expand(\\n)

src/proxy/proxypluginwrappers.cpp

@@ -1,213 +0,0 @@
-#include "proxypluginwrappers.h"
-#include <boost/python.hpp>
-#include <utility.h>
-#include "error.h"
-#include "gilock.h"
-
-namespace bpy = boost::python;
-
-using namespace MOBase;
-
-
-#define PYCATCH catch (const bpy::error_already_set &) { reportPythonError(); throw MyException("unhandled exception"); }\
-                catch (...) { throw MyException("An unknown exception was thrown in python code"); }
-
-
-/////////////////////////////
-/// IPluginTool Wrapper
-
-
-bool IPluginToolWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-    return this->get_override("init")(bpy::ptr(moInfo));
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::name() const
-{
-  try {
-    return this->get_override("name")();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::author() const
-{
-  try {
-    return this->get_override("author")();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::description() const
-{
-  try {
-    return this->get_override("description")();
-  } PYCATCH;
-}
-
-MOBase::VersionInfo IPluginToolWrapper::version() const
-{
-  try {
-    return this->get_override("version")();
-  } PYCATCH;
-}
-
-bool IPluginToolWrapper::isActive() const
-{
-  try {
-    return this->get_override("isActive")();
-  } PYCATCH;
-}
-
-QList<MOBase::PluginSetting> IPluginToolWrapper::settings() const
-{
-  try {
-    return this->get_override("settings")();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::displayName() const
-{
-  try {
-    return this->get_override("displayName")();
-  } PYCATCH;
-}
-
-QString IPluginToolWrapper::tooltip() const
-{
-  try {
-    return this->get_override("tooltip")();
-  } PYCATCH;
-}
-
-QIcon IPluginToolWrapper::icon() const
-{
-  try {
-    return this->get_override("icon")();
-  } PYCATCH;
-}
-
-void IPluginToolWrapper::setParentWidget(QWidget *parent)
-{
-  try {
-    this->get_override("setParentWidget")(parent);
-  } PYCATCH;
-}
-
-void IPluginToolWrapper::display() const
-{
-  try {
-    GILock lock;
-
-    this->get_override("display")();
-  } PYCATCH;
-}
-
-/// end IPluginTool Wrapper
-/////////////////////////////////////
-/// IPluginInstallerCustom Wrapper
-
-
-bool IPluginInstallerCustomWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-    return this->get_override("init")(bpy::ptr(moInfo));
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::name() const
-{
-  try {
-    return this->get_override("name")();
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::author() const
-{
-  try {
-    return this->get_override("author")();
-  } PYCATCH;
-}
-
-QString IPluginInstallerCustomWrapper::description() const
-{
-  try {
-    return this->get_override("description")();
-  } PYCATCH;
-}
-
-MOBase::VersionInfo IPluginInstallerCustomWrapper::version() const
-{
-  try {
-    return this->get_override("version")();
-  } PYCATCH;
-}
-
-bool IPluginInstallerCustomWrapper::isActive() const
-{
-  try {
-    return this->get_override("isActive")();
-  } PYCATCH;
-}
-
-QList<MOBase::PluginSetting> IPluginInstallerCustomWrapper::settings() const
-{
-  try {
-    return this->get_override("settings")();
-  } PYCATCH;
-}
-
-unsigned int IPluginInstallerCustomWrapper::priority() const
-{
-  try {
-    return this->get_override("priority")();
-  } PYCATCH;
-}
-
-bool IPluginInstallerCustomWrapper::isManualInstaller() const
-{
-  try {
-    return this->get_override("isManualInstaller")();
-  } PYCATCH;
-}
-
-bool IPluginInstallerCustomWrapper::isArchiveSupported(const DirectoryTree &tree) const
-{
-  try {
-    //return this->get_override("isArchiveSupported")(tree);
-    return false;
-  } PYCATCH;
-}
-
-bool IPluginInstallerCustomWrapper::isArchiveSupported(const QString &archiveName) const
-{
-  try {
-    return this->get_override("isArchiveSupported")(archiveName);
-  } PYCATCH;
-}
-
-std::set<QString> IPluginInstallerCustomWrapper::supportedExtensions() const
-{
-  try {
-    return this->get_override("supportedExtensions")();
-  } PYCATCH;
-}
-
-
-IPluginInstaller::EInstallResult IPluginInstallerCustomWrapper::install(GuessedValue<QString> &modName, const QString &archiveName,
-                                                                        const QString &version, int modID)
-{
-  try {
-    return this->get_override("install")(modName, archiveName, version, modID);
-  } PYCATCH;
-}
-
-
-void IPluginInstallerCustomWrapper::setParentWidget(QWidget *parent)
-{
-  try {
-    this->get_override("setParentWidget")(parent);
-  } PYCATCH;
-}
-
-

src/proxy/proxypluginwrappers.h

@@ -1,80 +0,0 @@
-#ifndef PROXYPLUGINWRAPPERS_H
-#define PROXYPLUGINWRAPPERS_H
-
-
-#include <iplugintool.h>
-#include <iplugininstallersimple.h>
-#include <iplugininstallercustom.h>
-#include <iplugindiagnose.h>
-
-#ifndef Q_MOC_RUN
-#include <boost/python.hpp>
-#endif
-
-
-class IPluginWrapper : public boost::python::wrapper<MOBase::IPlugin>
-{
-public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
-};
-
-
-class IPluginToolWrapper: public MOBase::IPluginTool, public boost::python::wrapper<MOBase::IPluginTool>
-{
-  Q_OBJECT
-  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginTool)
-
-public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
-
-  virtual QString displayName() const;
-  virtual QString tooltip() const;
-  virtual QIcon icon() const;
-  virtual void setParentWidget(QWidget *parent);
-
-public slots:
-  virtual void display() const;
-};
-
-
-class IPluginInstallerCustomWrapper: public MOBase::IPluginInstallerCustom, public boost::python::wrapper<MOBase::IPluginInstallerCustom>
-{
-  Q_OBJECT
-  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginInstaller MOBase::IPluginInstallerCustom)
-
-public:
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
-
-  virtual unsigned int priority() const;
-  virtual bool isManualInstaller() const;
-  virtual bool isArchiveSupported(const MOBase::DirectoryTree &tree) const;
-  virtual bool isArchiveSupported(const QString &archiveName) const;
-  virtual std::set<QString> supportedExtensions() const;
-  virtual EInstallResult install(MOBase::GuessedValue<QString> &modName, const QString &archiveName,
-                                 const QString &version, int modID);
-  virtual void setParentWidget(QWidget *parent);
-
-};
-
-
-
-
-#endif // PROXYPLUGINWRAPPERS_H

src/proxy/proxypython.cpp

@@ -26,149 +26,101 @@ along with python proxy plugin.  If not, see <http://www.gnu.org/licenses/>.
 #include <QWidget>
 #include <QMessageBox>
 #include <QCoreApplication>
-#include "resource.h"
-
+#include "log.h"
 
 using namespace MOBase;
 
-
-const char *ProxyPython::s_DownloadPythonURL = "http://www.python.org/download/releases/";
-
-
-HMODULE GetOwnModuleHandle()
-{
-  HMODULE hMod = NULL;
-  GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
-      reinterpret_cast<LPCWSTR>(&GetOwnModuleHandle), &hMod);
-
-  return hMod;
-}
-
-
-QString ExtractResource(WORD resourceID, const QString &szFilename)
-{
-  HMODULE mod = GetOwnModuleHandle();
-
-  HRSRC hResource = FindResourceW(mod, MAKEINTRESOURCE(resourceID), L"BINARY");
-  if (hResource == NULL) {
-    throw MyException("embedded dll not available: " + windowsErrorString(::GetLastError()));
-  }
-
-  HGLOBAL hFileResource = LoadResource(mod, hResource);
-  if (hFileResource == NULL) {
-    throw MyException("failed to load embedded dll resource: " + windowsErrorString(::GetLastError()));
-  }
-
-  LPVOID lpFile = LockResource(hFileResource);
-  DWORD dwSize = SizeofResource(mod, hResource);
-
-  QString outFile = QDir::tempPath() + "/" + szFilename;
-
-  HANDLE hFile = CreateFileW(ToWString(outFile).c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-  HANDLE hFileMap = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, dwSize, NULL);
-  LPVOID lpAddress = MapViewOfFile(hFileMap, FILE_MAP_WRITE, 0, 0, 0);
-
-  CopyMemory(lpAddress, lpFile, dwSize);
-
-  UnmapViewOfFile(lpAddress);
-
-  CloseHandle(hFileMap);
-  CloseHandle(hFile);
-
-  return outFile;
-}
-
-
 ProxyPython::ProxyPython()
-  : m_MOInfo(NULL), m_Runner(NULL), m_LoadFailure(FAIL_NOTINIT)
+  : m_MOInfo{ nullptr },
+  m_RunnerLib{ nullptr },
+  m_Runner{ nullptr },
+  m_LoadFailure(FailureType::NONE)
 {
 }
 
-ProxyPython::~ProxyPython()
-{
-  if (!m_TempRunnerFile.isEmpty()) {
-    ::FreeLibrary(m_RunnerLib);
-    QFile(m_TempRunnerFile).remove();
-  }
-}
-
-typedef IPythonRunner* (*CreatePythonRunner_func)(const MOBase::IOrganizer *moInfo, const QString &pythonPath);
-
 
 bool ProxyPython::init(IOrganizer *moInfo)
 {
+  using CreatePythonRunner_func = IPythonRunner * (*)();
+
   m_MOInfo = moInfo;
-  if (!m_MOInfo->pluginSetting(name(), "enabled").toBool()) {
-    m_LoadFailure = FAIL_NONE;
+
+  if (m_MOInfo && !m_MOInfo->isPluginEnabled(this)) {
     return false;
   }
 
-  m_LoadFailure = FAIL_OTHER;
   if (QCoreApplication::applicationDirPath().contains(';')) {
-    m_LoadFailure = FAIL_SEMICOLON;
+    m_LoadFailure = FailureType::SEMICOLON;
     return true;
   }
 
-  QString pythonPath = m_MOInfo->pluginSetting(name(), "python_dir").toString();
+  // load the pythonrunner library
+  m_RunnerLib = ::LoadLibraryW(QDir::toNativeSeparators(
+    IOrganizer::getPluginDataPath() + "/pythonRunner.dll").toStdWString().c_str());
 
-  if (!pythonPath.isEmpty() && !QFile::exists(pythonPath + "/python.exe")) {
-    m_LoadFailure = FAIL_WRONGPYTHONPATH;
-    return true;
-  }
-
-  m_TempRunnerFile = ExtractResource(IDR_LOADER_DLL, "__pythonRunner.dll");
-  m_RunnerLib = ::LoadLibraryW(ToWString(m_TempRunnerFile).c_str());
-  if (m_RunnerLib != NULL) {
-    CreatePythonRunner_func CreatePythonRunner = (CreatePythonRunner_func)::GetProcAddress(m_RunnerLib, "CreatePythonRunner");
-    if (CreatePythonRunner == NULL) {
-      throw MyException("embedded dll is invalid: " + windowsErrorString(::GetLastError()));
-    }
-    if (m_MOInfo->persistent(name(), "tryInit", false).toBool()) {
-      if (pythonPath.isEmpty()) {
-        m_LoadFailure = FAIL_PYTHONDETECTION;
-      } else {
-        m_LoadFailure = FAIL_WRONGPYTHONPATH;
-      }
-      if (QMessageBox::question(parentWidget(), tr("Python Initialization failed"),
-        tr("On a previous start the Python Plugin failed to initialize.\n"
-           "Either the value in Settings->Plugins->ProxyPython->plugin_dir is set incorrectly or it is empty and auto-detection doesn't work "
-           "for whatever reason.\n"
-           "Do you want to try initializing python again (at the risk of another crash)?\n"
-           "Suggestion: Select \"no\", and click the warning sign for further help. Afterwards you have to re-enable the python plugin."),
-        QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No) {
-        m_MOInfo->setPluginSetting(name(), "enabled", false);
-        return true;
-      }
-    }
-
-    m_MOInfo->setPersistent(name(), "tryInit", true);
-    m_Runner = CreatePythonRunner(moInfo, pythonPath);
-    m_MOInfo->setPersistent(name(), "tryInit", false);
-
-    if (m_Runner != NULL) {
-      m_LoadFailure = FAIL_NONE;
-    } else {
-      m_LoadFailure = FAIL_INITFAIL;
-    }
-    return true;
-  } else {
+  if (!m_RunnerLib) {
     DWORD error = ::GetLastError();
-    qCritical("Failed to load python runner: %s", qPrintable(windowsErrorString(error)));
+    log::error("failed to load python runner ({}): {}", qUtf8Printable(windowsErrorString(error)));
     if (error == ERROR_MOD_NOT_FOUND) {
-      m_LoadFailure = FAIL_MISSINGDEPENDENCIES;
+      m_LoadFailure = FailureType::DLL_NOT_FOUND;
+    }
+    else {
+      m_LoadFailure = FailureType::INVALID_DLL;
     }
     return true;
   }
+
+  const CreatePythonRunner_func createPythonRunner = (CreatePythonRunner_func)::GetProcAddress(m_RunnerLib, "CreatePythonRunner");
+  if (!createPythonRunner) {
+    m_LoadFailure = FailureType::INVALID_DLL;
+    return true;
+  }
+
+  if (m_MOInfo && m_MOInfo->persistent(name(), "tryInit", false).toBool()) {
+    m_LoadFailure = FailureType::INITIALIZATION;
+    if (QMessageBox::question(parentWidget(), tr("Python Initialization failed"),
+      tr("On a previous start the Python Plugin failed to initialize.\n"
+         "Do you want to try initializing python again (at the risk of another crash)?\n"
+         "Suggestion: Select \"no\", and click the warning sign for further help. Afterwards you have to re-enable the python plugin."),
+      QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No) {
+
+      // we force enabled here (note: this is a persistent settings since MO2 2.4 or something), plugin
+      // usually should not handle enabled/disabled themselves but this is a base plugin so...
+      m_MOInfo->setPersistent(name(), "enabled", false, true);
+      return true;
+    }
+  }
+
+  if (m_MOInfo) {
+    m_MOInfo->setPersistent(name(), "tryInit", true);
+  }
+
+  m_Runner = std::unique_ptr<IPythonRunner>{ createPythonRunner() };
+
+  if (m_MOInfo) {
+    m_MOInfo->setPersistent(name(), "tryInit", false);
+  }
+
+  if (!m_Runner) {
+    m_LoadFailure = FailureType::INITIALIZATION;
+  }
+
+  return true;
 }
 
 QString ProxyPython::name() const
+{
+  return "Python Proxy";
+}
+
+QString ProxyPython::localizedName() const
 {
   return tr("Python Proxy");
 }
 
 QString ProxyPython::author() const
 {
-  return "Tannin";
+  return "AnyOldName3, Holt59, Silarn, Tannin";
 }
 
 QString ProxyPython::description() const
@@ -178,150 +130,113 @@ QString ProxyPython::description() const
 
 VersionInfo ProxyPython::version() const
 {
-  return VersionInfo(1, 2, 0, VersionInfo::RELEASE_FINAL);
-}
-
-bool ProxyPython::isActive() const
-{
-  return m_LoadFailure == FAIL_NONE;
+  return VersionInfo(2, 3, 0, VersionInfo::RELEASE_FINAL);
 }
 
 QList<PluginSetting> ProxyPython::settings() const
 {
-  QList<PluginSetting> result;
-  result.push_back(PluginSetting("python_dir", "Path to your python installation. Leave empty for auto-detection", ""));
-  result.push_back(PluginSetting("enabled", "Set to true to enable support for python plugins", true));
-  return result;
+  return {};
 }
 
-QStringList ProxyPython::pluginList(const QString &pluginPath) const
+QStringList ProxyPython::pluginList(const QDir& pluginPath) const
 {
-  QDirIterator iter(pluginPath, QStringList("*.py"));
+  QDir dir(pluginPath);
+  dir.setFilter(dir.filter() | QDir::NoDotAndDotDot);
+  QDirIterator iter(dir);
 
+  // Note: We put python script (.py) and directory names, not the __init__.py
+  // files in those since it is easier for the runner to import them.
   QStringList result;
   while (iter.hasNext()) {
-    result.append(iter.next());
+    QString name = iter.next();
+    QFileInfo info = iter.fileInfo();
+
+
+    if (info.isFile() && name.endsWith(".py")) {
+      result.append(name);
+    }
+    else if (info.isDir() && QDir(info.absoluteFilePath()).exists("__init__.py")) {
+      result.append(name);
+    }
   }
 
   return result;
 }
 
-
-QObject *ProxyPython::instantiate(const QString &pluginName)
+QList<QObject*> ProxyPython::load(const QString& identifier)
 {
-  if (m_Runner != NULL) {
-    QObject *result = m_Runner->instantiate(pluginName);
-    return result;
-  } else {
-    return NULL;
+  if (!m_Runner) {
+    return {};
   }
+  return m_Runner->load(identifier);
 }
 
+void ProxyPython::unload(const QString& identifier)
+{
+  if (m_Runner) {
+    return m_Runner->unload(identifier);
+  }
+}
 
 std::vector<unsigned int> ProxyPython::activeProblems() const
 {
-  std::vector<unsigned int> result;
-  if (m_LoadFailure == FAIL_MISSINGDEPENDENCIES) {
-    result.push_back(PROBLEM_PYTHONMISSING);
-  } else if (m_LoadFailure == FAIL_WRONGPYTHONPATH) {
-    result.push_back(PROBLEM_WRONGPYTHONPATH);
-  } else if (m_LoadFailure == FAIL_PYTHONDETECTION) {
-    result.push_back(PROBLEM_PYTHONDETECTION);
-  } else if (m_LoadFailure == FAIL_INITFAIL) {
-    result.push_back(PROBLEM_INITFAIL);
-  } else if (m_LoadFailure == FAIL_SEMICOLON) {
-    result.push_back(PROBLEM_SEMICOLON);
-  } else if (m_Runner != NULL) {
-    if (!m_Runner->isPythonInstalled()) {
-      // don't know how this could happen but wth
-      result.push_back(PROBLEM_PYTHONMISSING);
-    }
-    if (!m_Runner->isPythonVersionSupported()) {
-      result.push_back(PROBLEM_PYTHONWRONGVERSION);
-    }
+  auto failure = m_LoadFailure;
+
+  // don't know how this could happen but wth
+  if (m_Runner && !m_Runner->isPythonInitialized()) {
+    failure = FailureType::INITIALIZATION;
   }
 
-  return result;
+  if (failure != FailureType::NONE) {
+    return { static_cast<std::underlying_type_t<FailureType>>(failure) };
+  }
+
+  return {};
 }
 
 QString ProxyPython::shortDescription(unsigned int key) const
 {
-  switch (key) {
-    case PROBLEM_PYTHONMISSING: {
-      return tr("Python not installed or not found");
-    } break;
-    case PROBLEM_PYTHONWRONGVERSION: {
-      return tr("Python version is incompatible");
-    } break;
-    case PROBLEM_WRONGPYTHONPATH: {
-      return tr("Invalid python path");
-    } break;
-    case PROBLEM_INITFAIL: {
-      return tr("Initializing Python failed");
-    } break;
-    case PROBLEM_PYTHONDETECTION: {
-      return tr("Python auto-detection failed");
-    } break;
-    case PROBLEM_SEMICOLON: {
+  switch (static_cast<FailureType>(key)) {
+    case FailureType::SEMICOLON:
       return tr("ModOrganizer path contains a semicolon");
-    } break;
+    case FailureType::DLL_NOT_FOUND:
+      return tr("Python DLL not found");
+    case FailureType::INVALID_DLL:
+      return tr("Invalid Python DLL");
+    case FailureType::INITIALIZATION:
+      return tr("Initializing Python failed");
     default:
-      throw MyException(tr("invalid problem key %1").arg(key));
+      return tr("invalid problem key %1").arg(key);
   }
 }
 
 
 QString ProxyPython::fullDescription(unsigned int key) const
 {
-  switch (key) {
-    case PROBLEM_PYTHONMISSING: {
-      return tr("Some MO plugins require the python interpreter to be installed. "
-                "These plugins will not even show up in settings-&gt;plugins.<br>"
-                "If you want to use those plugins, please install the 32-bit version of Python 2.7.x from <a href=\"%1\">%1</a>.<br>"
-                "This is only required to use some extended functionality in MO, you do not need Python to play the game.").arg(s_DownloadPythonURL);
-    } break;
-    case PROBLEM_PYTHONWRONGVERSION: {
-      return tr("Your installed python version has a different version than 2.7. "
-                "Some MO plugins may not work.<br>"
-                "If you have multiple versions of python installed you may have to configure the path to 2.7 (32 bit) "
-                "in the settings dialog.<br>"
-                "This is only required to use some extended functionality in MO, you do not need Python to play the game.");
-    } break;
-    case PROBLEM_WRONGPYTHONPATH: {
-      return tr("Please set python_dir in Settings->Plugins->ProxyPython to the path of your python 2.7 (32 bit) installation.");
-    } break;
-    case PROBLEM_PYTHONDETECTION: {
-      return tr("The auto-detection of the python path failed. I don't know why this would happen but you can try to fix it "
-                "by setting python_dir in Settings->Plugins->ProxyPython to the path of your python 2.7 (32 bit) installation.");
-    } break;
-    case PROBLEM_INITFAIL: {
-      return tr("Sorry, I don't know any details. Most likely your python installation is not supported.");
-    } break;
-    case PROBLEM_SEMICOLON: {
-      return tr("The path to Mod Organizer (%1) contains a semicolon. <br>"
-                "While this is legal on NTFS drives there is a lot of software that doesn't handle it correctly.<br>"
-                "Unfortunately MO depends on libraries that seem to fall into that group.<br>"
-                "As a result the python plugin can't be loaded.<br>"
-                "The only solution I can offer is to remove the semicolon / move MO to a path without a semicolon.").arg(QCoreApplication::applicationDirPath());
-    } break;
-    default:
-      throw MyException(QString("invalid problem key %1").arg(key));
+  switch (static_cast<FailureType>(key)) {
+  case FailureType::SEMICOLON:
+    return tr("The path to Mod Organizer (%1) contains a semicolon. <br>"
+      "While this is legal on NTFS drives, many softwares do not handle it correctly.<br>"
+      "Unfortunately MO depends on libraries that seem to fall into that group.<br>"
+      "As a result the python plugin cannot be loaded, and the only solution we can"
+      "offer is to remove the semicolon or move MO to a path without a semicolon.").arg(QCoreApplication::applicationDirPath());
+  case FailureType::DLL_NOT_FOUND:
+    return tr("The Python plugin DLL was not found, maybe your antivirus deleted it. Re-installing MO2 might fix the problem.");
+  case FailureType::INVALID_DLL:
+    return tr("The Python plugin DLL is invalid, maybe your antivirus is blocking it. "
+      "Re-installing MO2 and adding exclusions for it to your AV might fix the problem.");
+  case FailureType::INITIALIZATION:
+    return tr("The initialization of the Python plugin DLL failed, unfortunately without any details.");
+  default:
+    return tr("invalid problem key %1").arg(key);
   }
 }
 
 bool ProxyPython::hasGuidedFix(unsigned int key) const
 {
-  return (key == PROBLEM_PYTHONMISSING) || (key == PROBLEM_PYTHONWRONGVERSION);
+  return false;
 }
 
 void ProxyPython::startGuidedFix(unsigned int key) const
 {
-  if ((key == PROBLEM_PYTHONMISSING) || (key == PROBLEM_PYTHONWRONGVERSION)) {
-    ::ShellExecuteA(NULL, "open", s_DownloadPythonURL, NULL, NULL, SW_SHOWNORMAL);
-  }
 }
-
-
-#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
-Q_EXPORT_PLUGIN2(proxyPython, ProxyPython)
-#endif

src/proxy/proxypython.h

@@ -20,15 +20,18 @@ along with python proxy plugin.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef PROXYPYTHON_H
 #define PROXYPYTHON_H
 
+#include <map>
+#include <memory>
+
+#include <Windows.h>
 
 #include <ipluginproxy.h>
 #include <iplugindiagnose.h>
-#include <map>
-#include <Windows.h>
+
 #include <pythonrunner.h>
 
 
-class ProxyPython : public QObject, MOBase::IPluginProxy, MOBase::IPluginDiagnose
+class ProxyPython : public QObject, public MOBase::IPluginProxy, public MOBase::IPluginDiagnose
 {
   Q_OBJECT
   Q_INTERFACES(MOBase::IPlugin MOBase::IPluginProxy MOBase::IPluginDiagnose)
@@ -38,58 +41,42 @@ class ProxyPython : public QObject, MOBase::IPluginProxy, MOBase::IPluginDiagnos
 
 public:
   ProxyPython();
-  ~ProxyPython();
 
   virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
+  virtual QString name() const override;
+  virtual QString localizedName() const override;
+  virtual QString author() const override;
+  virtual QString description() const override;
+  virtual MOBase::VersionInfo version() const override;
+  virtual QList<MOBase::PluginSetting> settings() const override;
 
-  QStringList pluginList(const QString &pluginPath) const;
-  QObject *instantiate(const QString &pluginName);
-
-  /**
-   * @return the parent widget for newly created dialogs
-   * @note needs to be public so it can be exposed to plugins
-   */
-  virtual QWidget *getParentWidget() { return parentWidget(); }
+  QStringList pluginList(const QDir& pluginPath) const override;
+  QList<QObject*> load(const QString& identifier) override;
+  void unload(const QString& identifier) override;
 
 public: // IPluginDiagnose
 
-  virtual std::vector<unsigned int> activeProblems() const;
-  virtual QString shortDescription(unsigned int key) const;
-  virtual QString fullDescription(unsigned int key) const;
-  virtual bool hasGuidedFix(unsigned int key) const;
-  virtual void startGuidedFix(unsigned int key) const;
+  virtual std::vector<unsigned int> activeProblems() const override;
+  virtual QString shortDescription(unsigned int key) const override;
+  virtual QString fullDescription(unsigned int key) const override;
+  virtual bool hasGuidedFix(unsigned int key) const override;
+  virtual void startGuidedFix(unsigned int key) const override;
 
 private:
 
-  static const unsigned int PROBLEM_PYTHONMISSING = 1;
-  static const unsigned int PROBLEM_PYTHONWRONGVERSION = 2;
-  static const unsigned int PROBLEM_WRONGPYTHONPATH = 3;
-  static const unsigned int PROBLEM_INITFAIL = 4;
-  static const unsigned int PROBLEM_PYTHONDETECTION = 5;
-  static const unsigned int PROBLEM_SEMICOLON = 6;
-  static const char *s_DownloadPythonURL;
-
   MOBase::IOrganizer *m_MOInfo;
-  QString m_TempRunnerFile;
   HMODULE m_RunnerLib;
-  IPythonRunner *m_Runner;
+  std::unique_ptr<IPythonRunner> m_Runner;
 
-  enum {
-    FAIL_NONE,
-    FAIL_SEMICOLON,
-    FAIL_NOTINIT,
-    FAIL_MISSINGDEPENDENCIES,
-    FAIL_INITFAIL,
-    FAIL_WRONGPYTHONPATH,
-    FAIL_PYTHONDETECTION,
-    FAIL_OTHER
-  } m_LoadFailure;
+  enum class FailureType : unsigned int {
+    NONE = 0,
+    SEMICOLON = 1,
+    DLL_NOT_FOUND = 2,
+    INVALID_DLL = 3,
+    INITIALIZATION = 4
+  };
+
+  FailureType m_LoadFailure;
 
 };
 

src/proxy/pythonpluginwrapper.cpp

@@ -1,112 +0,0 @@
-#include "pythonpluginwrapper.h"
-
-
-using boost::python::extract;
-using boost::python::handle_exception;
-
-
-PythonPluginWrapper::PythonPluginWrapper(const boost::python::object &initFunction,
-                                         const boost::python::object &nameFunction,
-                                         const boost::python::object &authorFunction,
-                                         const boost::python::object &descriptionFunction,
-                                         const boost::python::object &versionFunction,
-                                         const boost::python::object &isActiveFunction,
-                                         const boost::python::object &settingsFunction)
-  : m_InitFunction(initFunction)
-  , m_NameFunction(nameFunction)
-  , m_AuthorFunction(authorFunction)
-  , m_DescriptionFunction(descriptionFunction)
-  , m_VersionFunction(versionFunction)
-  , m_IsActiveFunction(isActiveFunction)
-  , m_SettingsFunction(settingsFunction)
-{
-}
-
-
-void PythonPluginWrapper::reportPythonError() const
-{
-  if (PyErr_Occurred()) {
-    PyErr_Print();
-  } else {
-    qCritical("An unexpected C++ exception was thrown in python code");
-  }
-}
-
-
-bool PythonPluginWrapper::init(MOBase::IOrganizer *moInfo)
-{
-  try {
-   return boost::python::extract<bool>(m_InitFunction(boost::python::ptr(moInfo)));
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return false;
-  }
-}
-
-QString PythonPluginWrapper::name() const
-{
-  try {
-    return boost::python::extract<QString>(m_NameFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QString();
-  }
-}
-
-QString PythonPluginWrapper::author() const
-{
-  try {
-    return boost::python::extract<QString>(m_AuthorFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QString();
-  }
-}
-
-QString PythonPluginWrapper::description() const
-{
-  try {
-    return boost::python::extract<QString>(m_DescriptionFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QString();
-  }
-}
-
-MOBase::VersionInfo PythonPluginWrapper::version() const
-{
-  try {
-    return boost::python::extract<MOBase::VersionInfo>(m_VersionFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return MOBase::VersionInfo();
-  }
-}
-
-bool PythonPluginWrapper::isActive() const
-{
-  try {
-    return boost::python::extract<bool>(m_IsActiveFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return false;
-  }
-}
-
-QList<MOBase::PluginSetting> PythonPluginWrapper::settings() const
-{
-  QList<MOBase::PluginSetting> result;
-  try {
-    boost::python::object l = m_SettingsFunction();
-    if (!l.is_none()) {
-//    boost::python::list l = extract<boost::python::list>(temp);
-      for (int i = 0; i < boost::python::len(l); ++i) {
-        result.append(extract<MOBase::PluginSetting>(l[i]));
-      }
-    }
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-  }
-
-  return result;
-}

src/proxy/pythonpluginwrapper.h

@@ -1,44 +0,0 @@
-#ifndef PYTHONPLUGINWRAPPER_H
-#define PYTHONPLUGINWRAPPER_H
-
-#include <iplugin.h>
-#ifndef Q_MOC_RUN
-#include <boost/python.hpp>
-#endif
-
-class PythonPluginWrapper : public virtual MOBase::IPlugin
-{
-
-public:
-  PythonPluginWrapper(const boost::python::object &initFunction,
-                      const boost::python::object &nameFunction,
-                      const boost::python::object &authorFunction,
-                      const boost::python::object &descriptionFunction,
-                      const boost::python::object &versionFunction,
-                      const boost::python::object &isActiveFunction,
-                      const boost::python::object &settingsFunction);
-
-  virtual bool init(MOBase::IOrganizer *moInfo);
-  virtual QString name() const;
-  virtual QString author() const;
-  virtual QString description() const;
-  virtual MOBase::VersionInfo version() const;
-  virtual bool isActive() const;
-  virtual QList<MOBase::PluginSetting> settings() const;
-
-protected:
-  void reportPythonError() const;
-
-private:
-
-  boost::python::object m_InitFunction;
-  boost::python::object m_NameFunction;
-  boost::python::object m_AuthorFunction;
-  boost::python::object m_DescriptionFunction;
-  boost::python::object m_VersionFunction;
-  boost::python::object m_IsActiveFunction;
-  boost::python::object m_SettingsFunction;
-
-};
-
-#endif // PYTHONPLUGINWRAPPER_H

src/proxy/pythontoolwrapper.cpp

@@ -1,80 +0,0 @@
-#include "pythontoolwrapper.h"
-#include <QApplication>
-#include <QWidget>
-
-using boost::python::extract;
-using boost::python::handle_exception;
-
-PythonToolWrapper::PythonToolWrapper(const boost::python::object &initFunction,
-                                     const boost::python::object &nameFunction,
-                                     const boost::python::object &authorFunction,
-                                     const boost::python::object &descriptionFunction,
-                                     const boost::python::object &versionFunction,
-                                     const boost::python::object &isActiveFunction,
-                                     const boost::python::object &settingsFunction,
-                                     const boost::python::object &displayNameFunction,
-                                     const boost::python::object &tooltipFunction,
-                                     const boost::python::object &iconFunction,
-                                     const boost::python::object &displayFunction,
-                                     const boost::python::object &setParentWidget)
-  : PythonPluginWrapper(initFunction, nameFunction, authorFunction, descriptionFunction,
-                        versionFunction, isActiveFunction, settingsFunction)
-  , m_DisplayNameFunction(displayNameFunction)
-  , m_ToolTipFunction(tooltipFunction)
-  , m_IconFunction(iconFunction)
-  , m_DisplayFunction(displayFunction)
-  , m_SetParentWidget(setParentWidget)
-{
-}
-
-
-
-QString PythonToolWrapper::displayName() const
-{
-  try {
-    return boost::python::extract<QString>(m_DisplayNameFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QString();
-  }
-}
-
-QString PythonToolWrapper::tooltip() const
-{
-  try {
-    return boost::python::extract<QString>(m_ToolTipFunction());
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QString();
-  }
-}
-
-QIcon PythonToolWrapper::icon() const
-{
-  try {
-    std::vector<const char*> rows;
-    boost::python::object l = m_IconFunction();
-    if (!l.is_none()) {
-      for (int i = 0; i < boost::python::len(l); ++i) {
-        rows.push_back(extract<const char*>(l[i]));
-      }
-      return QIcon(QPixmap(&rows[0]));
-    } else {
-      return QIcon();
-    }
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-    return QIcon();
-  }
-}
-
-void PythonToolWrapper::display() const
-{
-  try {
-    m_SetParentWidget(parentWidget());
-
-    m_DisplayFunction();
-  } catch (const boost::python::error_already_set&) {
-    reportPythonError();
-  }
-}

src/proxy/pythontoolwrapper.h

@@ -1,56 +0,0 @@
-#ifndef PYTHONTOOLWRAPPER_H
-#define PYTHONTOOLWRAPPER_H
-
-
-#include <iplugintool.h>
-#ifndef Q_MOC_RUN
-#include <boost/python.hpp>
-#endif
-
-#include "pythonpluginwrapper.h"
-
-
-class PythonToolWrapper : public QObject, public MOBase::IPluginTool, public PythonPluginWrapper
-{
-
-  Q_OBJECT
-  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginTool)
-
-public:
-  PythonToolWrapper(const boost::python::object &initFunction,
-                    const boost::python::object &nameFunction,
-                    const boost::python::object &authorFunction,
-                    const boost::python::object &descriptionFunction,
-                    const boost::python::object &versionFunction,
-                    const boost::python::object &isActiveFunction,
-                    const boost::python::object &settingsFunction,
-                    const boost::python::object &displayNameFunction,
-                    const boost::python::object &tooltipFunction,
-                    const boost::python::object &iconFunction,
-                    const boost::python::object &displayFunction,
-                    const boost::python::object &setParentWidget);
-
-  using PythonPluginWrapper::init;
-  using PythonPluginWrapper::name;
-
-  virtual QString displayName() const;
-  virtual QString tooltip() const;
-  virtual QIcon icon() const;
-
-public slots:
-
-   virtual void display() const;
-
-private:
-
-  boost::python::object m_DisplayNameFunction;
-  boost::python::object m_ToolTipFunction;
-  boost::python::object m_IconFunction;
-  boost::python::object m_DisplayFunction;
-
-  boost::python::object m_SetParentWidget;
-};
-
-
-
-#endif // PYTHONTOOLWRAPPER_H

src/pythonrunner_en.ts

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.1" language="en_US">
+<context>
+    <name>QObject</name>
+    <message>
+        <location filename="runner/error.h" line="68"/>
+        <source>An unexpected C++ exception was thrown in python code.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="runner/error.h" line="117"/>
+        <source>An unknown exception was thrown in python code.</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+</TS>

src/runner/CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(pythonrunner)
+set(project_type plugin)
+set(enable_warnings OFF)
+set(enable_bigobj ON)
+set(install_dir bin/plugins/data)
+set(create_translations ON)
+
+add_compile_definitions(
+	QT_NO_KEYWORDS
+	PYTHONRUNNER_LIBRARY)
+
+# appveyor does not build modorganizer in its standard location, so use
+# DEPENDENCIES_DIR to find cmake_common
+if(DEFINED DEPENDENCIES_DIR)
+	include(${DEPENDENCIES_DIR}/modorganizer_super/cmake_common/project.cmake)
+	include(${DEPENDENCIES_DIR}/modorganizer_super/cmake_common/src.cmake)
+else()
+	include(../../../cmake_common/project.cmake)
+	include(../../../cmake_common/src.cmake)
+endif()
+
+requires_project(game_features)
+requires_library(python)
+
+add_filter(NAME src/converters GROUPS
+	converters
+	pythonutils
+	shared_ptr_converter
+	tuple_helper
+	variant_helper
+)
+
+add_filter(NAME src/runner GROUPS
+	pythonrunner
+	pylogger
+	widgets
+)
+
+add_filter(NAME src/utils GROUPS
+	error
+	gilock
+	sipapiaccess
+)
+
+add_filter(NAME src/wrappers GROUPS
+	gamefeatureswrappers
+	proxypluginwrappers
+	pythonwrapperutilities
+	uibasewrappers
+)

src/runner/SConscript

@@ -0,0 +1,63 @@
+Import('qt_env')
+
+env = qt_env.Clone()
+
+env.EnableQtModules('Core', 'Gui', 'Widgets')
+
+env.AppendUnique(CPPDEFINES = 'PYTHONRUNNER_LIBRARY')
+
+# suppress a few warnings caused by boost vs vc++ paranoia
+# NB HAVE_ROUND causes a warning because it's defined in pythonrunner.cpp
+env.AppendUnique(CPPDEFINES = [
+    '_SCL_SECURE_NO_WARNINGS',
+    'HAVE_ROUND'
+])
+
+# Boost produces very long names with msvc truncates. Doesn't seem to cause
+# problems.
+env.AppendUnique(CPPFLAGS = [ '-wd4503' ])
+
+#  QMAKE_CXXFLAGS += /Zi
+#  QMAKE_LFLAGS += /DEBUG
+
+env.RequireLibraries('uibase')
+
+# AppendUnique appears not to work with QT4
+env['CPPPATH'] += [
+    '${BOOSTPATH}',
+    '${PYTHONPATH}\\include',
+]
+
+env.AppendUnique(LIBS = [
+    'python27',  # Could be done better
+])
+
+env.AppendUnique(LIBPATH = [
+    '${PYTHONPATH}/libs',  # Could be done better
+])
+
+# We have to 'persuade' moc to generate certain other targets and inject them
+# into the list of cpps
+targets = env.AddExtraMoc(env.Glob('*.h'))
+
+# pythontoolwrapper doesnt compile and isn't in the project file
+cpp_files = [
+    x for x in Glob('*.cpp') if x.name != 'pythontoolwrapper.cpp'
+]
+
+lib = env.SharedLibrary('pythonRunner', cpp_files + targets)
+
+env.InstallModule(lib, 'plugins/data')
+
+# However...
+# we do need boost-python and pythonvv.dll and pythonvv.zip (though the last
+# isn't needed to just bring up the module)
+#env.Pseudo('install')
+#env.Depends('install',
+#            (env.Install('${INSTALL_PATH}', 'pyCfg.py'),
+#             env.Install(os.path.join('${INSTALL_PATH}', 'data'),
+#                         ( ui, rc, 'settings.json' )),
+#             ))
+
+res = env['QT_USED_MODULES']
+Return('res')

src/runner/error.cpp

@@ -1,24 +1,48 @@
+#ifndef Q_MOC_RUN
 #include <boost/python.hpp>
-#include <QString>
+#endif
 #include <utility.h>
+#include <QDebug>
+#include "error.h"
 
 using namespace MOBase;
 namespace bpy = boost::python;
 
-void reportPythonError()
+ErrWrapper & ErrWrapper::instance()
 {
-  if (PyErr_Occurred()) {
-    // prints to s_ErrIO buffer
-    PyErr_Print();
-    // extract data from python buffer
-    bpy::object mainModule = bpy::import("__main__");
-    bpy::object mainNamespace = mainModule.attr("__dict__");
-    bpy::object errMsgObj = bpy::eval("s_ErrIO.getvalue()", mainNamespace);
-    QString errMsg = bpy::extract<QString>(errMsgObj.ptr());
-    bpy::eval("s_ErrIO.truncate(0)", mainNamespace);
+  static ErrWrapper err;
+  return err;
+}
 
-    throw MyException(errMsg);
-  } else {
-    throw MyException("An unexpected C++ exception was thrown in python code");
+void ErrWrapper::write(const char * message)
+{
+  buffer << message;
+  if (buffer.tellp() != 0 && buffer.str().back() == '\n')
+  {
+    // actually put the string in a variable so it doesn't get destroyed as soon as we get a pointer to its data
+    std::string string = buffer.str().substr(0, buffer.str().length() - 1);
+    qCritical().nospace().noquote() << string.c_str();
+    buffer = std::stringstream();
+  }
+  
+  if (recordingExceptionMessage)
+  {
+    lastException << message;
   }
 }
+
+void ErrWrapper::startRecordingExceptionMessage()
+{
+  recordingExceptionMessage = true;
+  lastException = std::stringstream();
+}
+
+void ErrWrapper::stopRecordingExceptionMessage()
+{
+  recordingExceptionMessage = false;
+}
+
+QString ErrWrapper::getLastExceptionMessage()
+{
+  return QString::fromStdString(lastException.str());
+}