Initial commit

backends/platform/sdl/win32/win32-main.cpp

@@ -0,0 +1,87 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+#include "common/scummsys.h"
+
+#ifdef WIN32
+
+// Fix for bug #4700 "MSVC compilation broken with r47595":
+// We need to keep this on top of the "common/scummsys.h"(base/main.h) include,
+// otherwise we will get errors about the windows headers redefining
+// "ARRAYSIZE" for example.
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include "backends/platform/sdl/win32/win32.h"
+#include "backends/platform/sdl/win32/win32_wrapper.h"
+#include "backends/plugins/win32/win32-provider.h"
+#include "base/main.h"
+
+int __stdcall WinMain(HINSTANCE /*hInst*/, HINSTANCE /*hPrevInst*/,  LPSTR /*lpCmdLine*/, int /*iShowCmd*/) {
+#if !SDL_VERSION_ATLEAST(2, 0, 0)
+	SDL_SetModuleHandle(GetModuleHandle(NULL));
+#endif
+// HACK: __argc, __argv are broken and return zero when using mingwrt 4.0+ on MinGW
+// HACK: MinGW-w64 based toolchains neither feature _argc nor _argv. The 32 bit
+// incarnation only defines __MINGW32__. This leads to build breakage due to
+// missing declarations. Luckily MinGW-w64 based toolchains define
+// __MINGW64_VERSION_foo macros inside _mingw.h, which is included from all
+// system headers. Thus we abuse that to detect them.
+#if defined(__GNUC__) && defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+	return main(_argc, _argv);
+#else
+	return main(__argc, __argv);
+#endif
+}
+
+int main(int argc, char *argv[]) {
+#ifdef UNICODE
+	argv = Win32::getArgvUtf8(&argc);
+#endif
+
+	// Create our OSystem instance
+	g_system = new OSystem_Win32();
+	assert(g_system);
+
+	// Pre initialize the backend
+	g_system->init();
+
+#ifdef DYNAMIC_MODULES
+	PluginManager::instance().addPluginProvider(new Win32PluginProvider());
+#endif
+
+	// Invoke the actual ScummVM main entry point:
+	int res = scummvm_main(argc, argv);
+
+	// Free OSystem
+	g_system->destroy();
+
+#ifdef UNICODE
+	Win32::freeArgvUtf8(argc, argv);
+#endif
+
+	return res;
+}
+
+#endif

backends/platform/sdl/win32/win32-window.cpp

@@ -0,0 +1,65 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+#ifdef WIN32
+
+#include "backends/platform/sdl/win32/win32-window.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+void SdlWindow_Win32::setupIcon() {
+	HMODULE handle = GetModuleHandle(nullptr);
+	HICON   ico    = LoadIcon(handle, MAKEINTRESOURCE(1001 /* IDI_ICON */));
+	if (ico) {
+		HWND hwnd = getHwnd();
+		if (hwnd) {
+			// Replace the handle to the icon associated with the window class by our custom icon
+			SetClassLongPtr(hwnd, GCLP_HICON, (ULONG_PTR)ico);
+
+			// Since there wasn't any default icon, we can't use the return value from SetClassLong
+			// to check for errors (it would be 0 in both cases: error or no previous value for the
+			// icon handle). Instead we check for the last-error code value.
+			if (GetLastError() == ERROR_SUCCESS)
+				return;
+		}
+	}
+
+	// If no icon has been set, fallback to default path
+	SdlWindow::setupIcon();
+}
+
+HWND SdlWindow_Win32::getHwnd() {
+	SDL_SysWMinfo wminfo;
+	if (getSDLWMInformation(&wminfo)) {
+#if SDL_VERSION_ATLEAST(2, 0, 0)
+		return wminfo.info.win.window;
+#else
+		return wminfo.window;
+#endif
+	}
+	return nullptr;
+}
+
+#endif

backends/platform/sdl/win32/win32-window.h

@@ -0,0 +1,37 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef BACKENDS_PLATFORM_SDL_WIN32_WIN32_WINDOW_H
+#define BACKENDS_PLATFORM_SDL_WIN32_WIN32_WINDOW_H
+
+#ifdef WIN32
+
+#include "backends/platform/sdl/sdl-window.h"
+
+class SdlWindow_Win32 final : public SdlWindow {
+public:
+	void setupIcon() override;
+	HWND getHwnd();
+};
+
+#endif
+
+#endif

backends/platform/sdl/win32/win32.cpp

@@ -0,0 +1,545 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+#ifdef WIN32
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <shellapi.h>
+#if defined(__GNUC__) && defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+// required for SHGFP_TYPE_CURRENT in shlobj.h
+#define _WIN32_IE 0x500
+#endif
+#include <shlobj.h>
+#include <tchar.h>
+
+#include "common/scummsys.h"
+#include "common/config-manager.h"
+#include "common/error.h"
+#include "common/textconsole.h"
+
+#include "backends/audiocd/win32/win32-audiocd.h"
+#include "backends/platform/sdl/win32/win32.h"
+#include "backends/platform/sdl/win32/win32-window.h"
+#include "backends/platform/sdl/win32/win32_wrapper.h"
+#include "backends/saves/windows/windows-saves.h"
+#include "backends/fs/windows/windows-fs-factory.h"
+#include "backends/taskbar/win32/win32-taskbar.h"
+#include "backends/updates/win32/win32-updates.h"
+#include "backends/dialogs/win32/win32-dialogs.h"
+
+#include "common/memstream.h"
+#include "common/ustr.h"
+
+#if defined(USE_TTS)
+#include "backends/text-to-speech/windows/windows-text-to-speech.h"
+#endif
+
+#define DEFAULT_CONFIG_FILE "scummvm.ini"
+
+OSystem_Win32::OSystem_Win32() :
+	_isPortable(false) {
+}
+
+void OSystem_Win32::init() {
+	// Initialize File System Factory
+	_fsFactory = new WindowsFilesystemFactory();
+
+	// Create Win32 specific window
+	initSDL();
+	_window = new SdlWindow_Win32();
+
+#if defined(USE_TASKBAR)
+	// Initialize taskbar manager
+	_taskbarManager = new Win32TaskbarManager((SdlWindow_Win32*)_window);
+#endif
+
+#if defined(USE_SYSDIALOGS)
+	// Initialize dialog manager
+	_dialogManager = new Win32DialogManager((SdlWindow_Win32*)_window);
+#endif
+
+#if defined(USE_JPEG)
+	initializeJpegLibraryForWin95();
+#endif
+	// Invoke parent implementation of this method
+	OSystem_SDL::init();
+}
+
+WORD GetCurrentSubsystem() {
+	// HMODULE is the module base address. And the PIMAGE_DOS_HEADER is located at the beginning.
+	PIMAGE_DOS_HEADER EXEHeader = (PIMAGE_DOS_HEADER)GetModuleHandle(nullptr);
+	assert(EXEHeader->e_magic == IMAGE_DOS_SIGNATURE);
+	// PIMAGE_NT_HEADERS is bitness dependant.
+	// Conveniently, since it's for our own process, it's always the correct bitness.
+	// IMAGE_NT_HEADERS has to be found using a byte offset from the EXEHeader,
+	// which requires the ugly cast.
+	PIMAGE_NT_HEADERS PEHeader = (PIMAGE_NT_HEADERS)(((char*)EXEHeader) + EXEHeader->e_lfanew);
+	assert(PEHeader->Signature == IMAGE_NT_SIGNATURE);
+	return PEHeader->OptionalHeader.Subsystem;
+}
+
+void OSystem_Win32::initBackend() {
+	// The console window is enabled for the console subsystem,
+	// since Windows already creates the console window for us
+	ConfMan.registerDefault("console", GetCurrentSubsystem() == IMAGE_SUBSYSTEM_WINDOWS_CUI);
+
+	// Enable or disable the window console window
+	if (ConfMan.getBool("console")) {
+		if (AllocConsole()) {
+			freopen("CONIN$","r",stdin);
+			freopen("CONOUT$","w",stdout);
+			freopen("CONOUT$","w",stderr);
+		}
+		SetConsoleTitle(TEXT("ScummVM Status Window"));
+	} else {
+		FreeConsole();
+	}
+
+	// Create the savefile manager
+	if (_savefileManager == nullptr)
+		_savefileManager = new WindowsSaveFileManager(_isPortable);
+
+#if defined(USE_SPARKLE)
+	// Initialize updates manager
+	if (!_isPortable) {
+		_updateManager = new Win32UpdateManager((SdlWindow_Win32*)_window);
+	}
+#endif
+
+	// Initialize text to speech
+#ifdef USE_TTS
+	_textToSpeechManager = new WindowsTextToSpeechManager();
+#endif
+
+	// Invoke parent implementation of this method
+	OSystem_SDL::initBackend();
+}
+
+#ifdef USE_OPENGL
+OSystem_SDL::GraphicsManagerType OSystem_Win32::getDefaultGraphicsManager() const {
+	return GraphicsManagerOpenGL;
+}
+#endif
+
+bool OSystem_Win32::hasFeature(Feature f) {
+	if (f == kFeatureDisplayLogFile || f == kFeatureOpenUrl)
+		return true;
+
+#ifdef USE_SYSDIALOGS
+	if (f == kFeatureSystemBrowserDialog)
+		return true;
+#endif
+
+	return OSystem_SDL::hasFeature(f);
+}
+
+bool OSystem_Win32::displayLogFile() {
+	if (_logFilePath.empty())
+		return false;
+
+	// Try opening the log file with the default text editor
+	// log files should be registered as "txtfile" by default and thus open in the default text editor
+	TCHAR *tLogFilePath = Win32::stringToTchar(_logFilePath.toString(Common::Path::kNativeSeparator));
+	SHELLEXECUTEINFO sei;
+
+	memset(&sei, 0, sizeof(sei));
+	sei.fMask  = SEE_MASK_FLAG_NO_UI;
+	sei.hwnd   = getHwnd();
+	sei.lpFile = tLogFilePath;
+	sei.nShow  = SW_SHOWNORMAL;
+
+	if (ShellExecuteEx(&sei)) {
+		free(tLogFilePath);
+		return true;
+	}
+
+	// ShellExecute with the default verb failed, try the "Open with..." dialog
+	PROCESS_INFORMATION processInformation;
+	STARTUPINFO startupInfo;
+	memset(&processInformation, 0, sizeof(processInformation));
+	memset(&startupInfo, 0, sizeof(startupInfo));
+	startupInfo.cb = sizeof(startupInfo);
+
+	TCHAR cmdLine[MAX_PATH * 2];  // CreateProcess may change the contents of cmdLine
+	_stprintf(cmdLine, TEXT("rundll32 shell32.dll,OpenAs_RunDLL %s"), tLogFilePath);
+	BOOL result = CreateProcess(nullptr,
+	                            cmdLine,
+	                            nullptr,
+	                            nullptr,
+	                            FALSE,
+	                            NORMAL_PRIORITY_CLASS,
+	                            nullptr,
+	                            nullptr,
+	                            &startupInfo,
+	                            &processInformation);
+	free(tLogFilePath);
+	if (result) {
+		CloseHandle(processInformation.hProcess);
+		CloseHandle(processInformation.hThread);
+		return true;
+	}
+
+	return false;
+}
+
+bool OSystem_Win32::openUrl(const Common::String &url) {
+	TCHAR *tUrl = Win32::stringToTchar(url);
+	SHELLEXECUTEINFO sei;
+
+	memset(&sei, 0, sizeof(sei));
+	sei.cbSize = sizeof(sei);
+	sei.fMask  = SEE_MASK_FLAG_NO_UI;
+	sei.hwnd   = getHwnd();
+	sei.lpFile = tUrl;
+	sei.nShow  = SW_SHOWNORMAL;
+
+	BOOL success = ShellExecuteEx(&sei);
+
+	free(tUrl);
+	if (!success) {
+		warning("ShellExecuteEx failed: error = %08lX", GetLastError());
+		return false;
+	}
+	return true;
+}
+
+void OSystem_Win32::logMessage(LogMessageType::Type type, const char *message) {
+	OSystem_SDL::logMessage(type, message);
+
+#if defined( USE_WINDBG )
+	TCHAR *tMessage = Win32::stringToTchar(message);
+	OutputDebugString(tMessage);
+	free(tMessage);
+#endif
+}
+
+Common::String OSystem_Win32::getSystemLanguage() const {
+#if defined(USE_DETECTLANG) && defined(USE_TRANSLATION)
+	// We can not use "setlocale" (at least not for MSVC builds), since it
+	// will return locales like: "English_USA.1252", thus we need a special
+	// way to determine the locale string for Win32.
+	TCHAR langName[9];
+	TCHAR ctryName[9];
+
+	if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, langName, ARRAYSIZE(langName)) != 0 &&
+		GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, ctryName, ARRAYSIZE(ctryName)) != 0) {
+		Common::String localeName = Win32::tcharToString(langName);
+		localeName += "_";
+		localeName += Win32::tcharToString(ctryName);
+
+		return localeName;
+	}
+#endif // USE_DETECTLANG
+	// Falback to SDL implementation
+	return OSystem_SDL::getSystemLanguage();
+}
+
+Common::Path OSystem_Win32::getDefaultIconsPath() {
+	TCHAR iconsPath[MAX_PATH];
+
+	if (_isPortable) {
+		Win32::getProcessDirectory(iconsPath, MAX_PATH);
+		_tcscat(iconsPath, TEXT("\\Icons\\"));
+	} else {
+		// Use the Application Data directory of the user profile
+		if (!Win32::getApplicationDataDirectory(iconsPath)) {
+			return Common::Path();
+		}
+		_tcscat(iconsPath, TEXT("\\Icons\\"));
+		CreateDirectory(iconsPath, nullptr);
+	}
+
+	return Common::Path(Win32::tcharToString(iconsPath), Common::Path::kNativeSeparator);
+}
+
+Common::Path OSystem_Win32::getDefaultDLCsPath() {
+	TCHAR dlcsPath[MAX_PATH];
+
+	if (_isPortable) {
+		Win32::getProcessDirectory(dlcsPath, MAX_PATH);
+		_tcscat(dlcsPath, TEXT("\\DLCs\\"));
+	} else {
+		// Use the Application Data directory of the user profile
+		if (!Win32::getApplicationDataDirectory(dlcsPath)) {
+			return Common::Path();
+		}
+		_tcscat(dlcsPath, TEXT("\\DLCs\\"));
+		CreateDirectory(dlcsPath, nullptr);
+	}
+
+	return Common::Path(Win32::tcharToString(dlcsPath), Common::Path::kNativeSeparator);
+}
+
+Common::Path OSystem_Win32::getScreenshotsPath() {
+	// If the user has configured a screenshots path, use it
+	Common::Path screenshotsPath = ConfMan.getPath("screenshotpath");
+	if (!screenshotsPath.empty()) {
+		return screenshotsPath;
+	}
+
+	TCHAR picturesPath[MAX_PATH];
+	if (_isPortable) {
+		Win32::getProcessDirectory(picturesPath, MAX_PATH);
+		_tcscat(picturesPath, TEXT("\\Screenshots\\"));
+	} else {
+		// Use the My Pictures folder
+		HRESULT hr = SHGetFolderPathFunc(nullptr, CSIDL_MYPICTURES, nullptr, SHGFP_TYPE_CURRENT, picturesPath);
+		if (hr != S_OK) {
+			if (hr != E_NOTIMPL) {
+				warning("Unable to locate My Pictures directory");
+			}
+			return Common::Path();
+		}
+		_tcscat(picturesPath, TEXT("\\ScummVM Screenshots\\"));
+	}
+
+	// If the directory already exists (as it should in most cases),
+	// we don't want to fail, but we need to stop on other errors (such as ERROR_PATH_NOT_FOUND)
+	if (!CreateDirectory(picturesPath, nullptr)) {
+		if (GetLastError() != ERROR_ALREADY_EXISTS)
+			error("Cannot create ScummVM Screenshots folder");
+	}
+
+	return Common::Path(Win32::tcharToString(picturesPath), Common::Path::kNativeSeparator);
+}
+
+Common::Path OSystem_Win32::getDefaultConfigFileName() {
+	TCHAR configFile[MAX_PATH];
+
+	// if this is the first time the default config file name is requested
+	// then we need detect if we should run in portable mode. (and if it's
+	// never requested before the backend is initialized then a config file
+	// was provided on the command line and portable mode doesn't apply.)
+	if (!backendInitialized()) {
+		_isPortable = detectPortableConfigFile();
+	}
+
+	if (_isPortable) {
+		// Use the current process directory in portable mode
+		Win32::getProcessDirectory(configFile, MAX_PATH);
+		_tcscat(configFile, TEXT("\\" DEFAULT_CONFIG_FILE));
+	} else {
+		// Use the Application Data directory of the user profile
+		if (Win32::getApplicationDataDirectory(configFile)) {
+			_tcscat(configFile, TEXT("\\" DEFAULT_CONFIG_FILE));
+
+			FILE *tmp = nullptr;
+			if ((tmp = _tfopen(configFile, TEXT("r"))) == nullptr) {
+				// Check windows directory
+				TCHAR oldConfigFile[MAX_PATH];
+				uint ret = GetWindowsDirectory(oldConfigFile, MAX_PATH);
+				if (ret == 0 || ret > MAX_PATH)
+					error("Cannot retrieve the path of the Windows directory");
+
+				_tcscat(oldConfigFile, TEXT("\\" DEFAULT_CONFIG_FILE));
+				if ((tmp = _tfopen(oldConfigFile, TEXT("r")))) {
+					_tcscpy(configFile, oldConfigFile);
+
+					fclose(tmp);
+				}
+			} else {
+				fclose(tmp);
+			}
+		} else {
+			// Check windows directory
+			uint ret = GetWindowsDirectory(configFile, MAX_PATH);
+			if (ret == 0 || ret > MAX_PATH)
+				error("Cannot retrieve the path of the Windows directory");
+
+			_tcscat(configFile, TEXT("\\" DEFAULT_CONFIG_FILE));
+		}
+	}
+
+	return Common::Path(Win32::tcharToString(configFile), Common::Path::kNativeSeparator);
+}
+
+Common::Path OSystem_Win32::getDefaultLogFileName() {
+	TCHAR logFile[MAX_PATH];
+
+	if (_isPortable) {
+		Win32::getProcessDirectory(logFile, MAX_PATH);
+	} else {
+		// Use the Application Data directory of the user profile
+		if (!Win32::getApplicationDataDirectory(logFile)) {
+			return Common::Path();
+		}
+		_tcscat(logFile, TEXT("\\Logs"));
+		CreateDirectory(logFile, nullptr);
+	}
+
+	_tcscat(logFile, TEXT("\\scummvm.log"));
+
+	return Common::Path(Win32::tcharToString(logFile), Common::Path::kNativeSeparator);
+}
+
+bool OSystem_Win32::detectPortableConfigFile() {
+	// ScummVM operates in a "portable mode" if there is a config file in the
+	// same directory as the executable. In this mode, the executable's
+	// directory is used instead of the user's profile for application files.
+	// This approach is modeled off of the portable mode in Notepad++.
+
+	// Check if there is a config file in the same directory as the executable.
+	TCHAR portableConfigFile[MAX_PATH];
+	Win32::getProcessDirectory(portableConfigFile, MAX_PATH);
+	_tcscat(portableConfigFile, TEXT("\\" DEFAULT_CONFIG_FILE));
+	FILE *file = _tfopen(portableConfigFile, TEXT("r"));
+	if (file == nullptr) {
+		return false;
+	}
+	fclose(file);
+
+	// Check if we're running from Program Files on Vista+.
+	// If so then don't attempt to use local files due to UAC.
+	// (Notepad++ does this too.)
+	if (Win32::confirmWindowsVersion(6, 0)) {
+		TCHAR programFiles[MAX_PATH];
+		if (SHGetFolderPathFunc(nullptr, CSIDL_PROGRAM_FILES, nullptr, SHGFP_TYPE_CURRENT, programFiles) == S_OK) {
+			_tcscat(portableConfigFile, TEXT("\\"));
+			if (_tcsstr(portableConfigFile, programFiles) == portableConfigFile) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+namespace {
+
+class Win32ResourceArchive final : public Common::Archive {
+	friend BOOL CALLBACK EnumResNameProc(HMODULE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG_PTR lParam);
+public:
+	Win32ResourceArchive();
+
+	bool hasFile(const Common::Path &path) const override;
+	int listMembers(Common::ArchiveMemberList &list) const override;
+	const Common::ArchiveMemberPtr getMember(const Common::Path &path) const override;
+	Common::SeekableReadStream *createReadStreamForMember(const Common::Path &path) const override;
+private:
+	typedef Common::List<Common::Path> FilenameList;
+
+	FilenameList _files;
+};
+
+BOOL CALLBACK EnumResNameProc(HMODULE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG_PTR lParam) {
+	if (IS_INTRESOURCE(lpszName))
+		return TRUE;
+
+	Win32ResourceArchive *arch = (Win32ResourceArchive *)lParam;
+	Common::String filename = Win32::tcharToString(lpszName);
+	// We use / as path separator in resources
+	arch->_files.push_back(Common::Path(filename, '/'));
+	return TRUE;
+}
+
+Win32ResourceArchive::Win32ResourceArchive() {
+	EnumResourceNames(nullptr, MAKEINTRESOURCE(256), &EnumResNameProc, (LONG_PTR)this);
+}
+
+bool Win32ResourceArchive::hasFile(const Common::Path &path) const {
+	for (const auto &curPath : _files) {
+		if (curPath.equalsIgnoreCase(path))
+			return true;
+	}
+
+	return false;
+}
+
+int Win32ResourceArchive::listMembers(Common::ArchiveMemberList &list) const {
+	int count = 0;
+
+	for (FilenameList::const_iterator i = _files.begin(); i != _files.end(); ++i, ++count)
+		list.push_back(Common::ArchiveMemberPtr(new Common::GenericArchiveMember(*i, *this)));
+
+	return count;
+}
+
+const Common::ArchiveMemberPtr Win32ResourceArchive::getMember(const Common::Path &path) const {
+	return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(path, *this));
+}
+
+Common::SeekableReadStream *Win32ResourceArchive::createReadStreamForMember(const Common::Path &path) const {
+	// We store paths in resources using / separator
+	Common::String name = path.toString('/');
+	TCHAR *tName = Win32::stringToTchar(name);
+	HRSRC resource = FindResource(nullptr, tName, MAKEINTRESOURCE(256));
+	free(tName);
+
+	if (resource == nullptr)
+		return nullptr;
+
+	HGLOBAL handle = LoadResource(nullptr, resource);
+
+	if (handle == nullptr)
+		return nullptr;
+
+	const byte *data = (const byte *)LockResource(handle);
+
+	if (data == nullptr)
+		return nullptr;
+
+	uint32 size = SizeofResource(nullptr, resource);
+
+	if (size == 0)
+		return nullptr;
+
+	return new Common::MemoryReadStream(data, size);
+}
+
+} // End of anonymous namespace
+
+void OSystem_Win32::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
+	s.add("Win32Res", new Win32ResourceArchive(), priority);
+
+	OSystem_SDL::addSysArchivesToSearchSet(s, priority);
+}
+
+AudioCDManager *OSystem_Win32::createAudioCDManager() {
+	return createWin32AudioCDManager();
+}
+
+uint32 OSystem_Win32::getOSDoubleClickTime() const {
+	return GetDoubleClickTime();
+}
+
+// libjpeg-turbo uses SSE instructions that error on at least some Win95 machines.
+// These can be disabled with an environment variable. Fixes bug #13643
+#if defined(USE_JPEG)
+void OSystem_Win32::initializeJpegLibraryForWin95() {
+	OSVERSIONINFO versionInfo;
+	ZeroMemory(&versionInfo, sizeof(versionInfo));
+	versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
+	GetVersionEx(&versionInfo);
+
+	// Is Win95?
+	if (versionInfo.dwMajorVersion == 4 && versionInfo.dwMinorVersion == 0) {
+		// Disable SSE instructions in libjpeg-turbo.
+		// This limits detected extensions to 3DNOW and MMX.
+		_tputenv(TEXT("JSIMD_FORCE3DNOW=1"));
+	}
+}
+#endif
+
+#endif

backends/platform/sdl/win32/win32.h

@@ -0,0 +1,77 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PLATFORM_SDL_WIN32_H
+#define PLATFORM_SDL_WIN32_H
+
+#include "backends/platform/sdl/sdl.h"
+#include "backends/platform/sdl/win32/win32-window.h"
+
+class OSystem_Win32 final : public OSystem_SDL {
+public:
+	OSystem_Win32();
+
+	void init() override;
+	void initBackend() override;
+
+#ifdef USE_OPENGL
+	GraphicsManagerType getDefaultGraphicsManager() const override;
+#endif
+
+	void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0) override;
+
+	bool hasFeature(Feature f) override;
+
+	bool displayLogFile() override;
+
+	bool openUrl(const Common::String &url) override;
+
+	void logMessage(LogMessageType::Type type, const char *message) override;
+
+	Common::String getSystemLanguage() const override;
+
+	// Default paths
+	Common::Path getDefaultIconsPath() override;
+	Common::Path getDefaultDLCsPath() override;
+	Common::Path getScreenshotsPath() override;
+
+protected:
+	Common::Path getDefaultConfigFileName() override;
+	Common::Path getDefaultLogFileName() override;
+
+	// Override createAudioCDManager() to get our Windows-specific
+	// version.
+	AudioCDManager *createAudioCDManager() override;
+
+	HWND getHwnd() { return ((SdlWindow_Win32*)_window)->getHwnd(); }
+
+	uint32 getOSDoubleClickTime() const override;
+
+private:
+	bool _isPortable;
+	bool detectPortableConfigFile();
+
+#if defined(USE_JPEG)
+	void initializeJpegLibraryForWin95();
+#endif
+};
+
+#endif

backends/platform/sdl/win32/win32.mk

@@ -0,0 +1,129 @@
+#
+# Windows specific
+#
+
+WIN32PATH ?= $(DESTDIR)
+
+clean-win32-resource-embed:
+
+clean: clean-win32-resource-embed
+
+.PHONY: clean-win32-resource-embed
+
+define win32-resource-embed-macro
+$(1): configure.stamp $(foreach filename,$($(2)), $(srcdir)/$(filename)) $($(2)_SOURCE)
+	$(QUIET)echo '    GENERATE' $$@
+	$(QUIET)mkdir -p $$(dir $$@)
+	$(QUIET)echo -n '' > $$@
+	$(QUIET)echo $$(foreach filename,$$($(2)),$$(filename)) | sed -e 's/ /\n/g' | sed -E 's/(.*\/)(.+)/\2 FILE "\1\2"/g' >> $$@
+
+dists/scummvm.o: $(1)
+
+clean-win32-resource-embed-$(1):
+	$(RM) $(1)
+
+clean-win32-resource-embed: clean-win32-resource-embed-$(1)
+
+.PHONY: clean-win32-resource-embed-$(1)
+
+endef
+
+$(eval $(call win32-resource-embed-macro,dists/scummvm_rc_engine_data_core.rh,DIST_FILES_ENGINEDATA_BASE_CORE))
+$(eval $(call win32-resource-embed-macro,dists/scummvm_rc_engine_data.rh,DIST_FILES_ENGINEDATA_BASE))
+$(eval $(call win32-resource-embed-macro,dists/scummvm_rc_engine_data_big.rh,DIST_FILES_ENGINEDATA_BASE_BIG))
+
+# Special target to create a win32 snapshot binary (for Inno Setup)
+win32-data: all
+	mkdir -p $(WIN32PATH)
+	mkdir -p $(WIN32PATH)/doc
+	mkdir -p $(WIN32PATH)/doc/cz
+	mkdir -p $(WIN32PATH)/doc/da
+	mkdir -p $(WIN32PATH)/doc/de
+	mkdir -p $(WIN32PATH)/doc/es
+	mkdir -p $(WIN32PATH)/doc/fr
+	mkdir -p $(WIN32PATH)/doc/it
+	mkdir -p $(WIN32PATH)/doc/ko
+	mkdir -p $(WIN32PATH)/doc/no-nb
+	mkdir -p $(WIN32PATH)/doc/sv
+	$(STRIP) $(EXECUTABLE) -o $(WIN32PATH)/$(EXECUTABLE)
+	cp $(srcdir)/AUTHORS $(WIN32PATH)/AUTHORS.txt
+	cp $(srcdir)/COPYING $(WIN32PATH)/COPYING.txt
+	cp $(srcdir)/LICENSES/COPYING.Apache $(WIN32PATH)/COPYING.Apache.txt
+	cp $(srcdir)/LICENSES/COPYING.BSD $(WIN32PATH)/COPYING.BSD.txt
+	cp $(srcdir)/LICENSES/COPYING.BSL $(WIN32PATH)/COPYING.BSL.txt
+	cp $(srcdir)/LICENSES/COPYING.GLAD $(WIN32PATH)/COPYING.GLAD.txt
+	cp $(srcdir)/LICENSES/COPYING.LGPL $(WIN32PATH)/COPYING.LGPL.txt
+	cp $(srcdir)/LICENSES/COPYING.LUA $(WIN32PATH)/COPYING.LUA.txt
+	cp $(srcdir)/LICENSES/COPYING.MIT $(WIN32PATH)/COPYING.MIT.txt
+	cp $(srcdir)/LICENSES/COPYING.MKV $(WIN32PATH)/COPYING.MKV.txt
+	cp $(srcdir)/LICENSES/COPYING.MPL $(WIN32PATH)/COPYING.MPL.txt
+	cp $(srcdir)/LICENSES/COPYING.OFL $(WIN32PATH)/COPYING.OFL.txt
+	cp $(srcdir)/LICENSES/COPYING.ISC $(WIN32PATH)/COPYING.ISC.txt
+	cp $(srcdir)/LICENSES/COPYING.TINYGL $(WIN32PATH)/COPYING.TINYGL.txt
+	cp $(srcdir)/LICENSES/CatharonLicense.txt $(WIN32PATH)/CatharonLicense.txt
+	cp $(srcdir)/COPYRIGHT $(WIN32PATH)/COPYRIGHT.txt
+	cp $(srcdir)/doc/cz/PrectiMe $(WIN32PATH)/doc/cz/PrectiMe.txt
+	cp $(srcdir)/doc/QuickStart $(WIN32PATH)/doc/QuickStart.txt
+	cp $(srcdir)/doc/es/InicioRapido $(WIN32PATH)/doc/es/InicioRapido.txt
+	cp $(srcdir)/doc/fr/DemarrageRapide $(WIN32PATH)/doc/fr/DemarrageRapide.txt
+	cp $(srcdir)/doc/it/GuidaRapida $(WIN32PATH)/doc/it/GuidaRapida.txt
+	cp $(srcdir)/doc/ko/QuickStart $(WIN32PATH)/doc/ko/QuickStart.txt
+	cp $(srcdir)/doc/no-nb/HurtigStart $(WIN32PATH)/doc/no-nb/HurtigStart.txt
+	cp $(srcdir)/doc/da/HurtigStart $(WIN32PATH)/doc/da/HurtigStart.txt
+	cp $(srcdir)/doc/de/Schnellstart $(WIN32PATH)/doc/de/Schnellstart.txt
+	cp $(srcdir)/doc/sv/Snabbstart $(WIN32PATH)/doc/sv/Snabbstart.txt
+ifdef USE_PANDOC
+	cp NEWS$(PANDOCEXT) $(WIN32PATH)/NEWS.txt
+	cp README$(PANDOCEXT) $(WIN32PATH)/README.txt
+	cp doc/de/NEUES$(PANDOCEXT) $(WIN32PATH)/doc/de/NEUES.txt
+else
+	cp $(srcdir)/NEWS.md $(WIN32PATH)/NEWS.txt
+	cp $(srcdir)/README.md $(WIN32PATH)/README.txt
+	cp $(srcdir)/doc/de/NEUES.md $(WIN32PATH)/doc/de/NEUES.txt
+endif
+	cp $(srcdir)/doc/de/LIESMICH $(WIN32PATH)/doc/de/LIESMICH.txt
+	cp $(srcdir)/doc/sv/LasMig $(WIN32PATH)/doc/sv/LasMig.txt
+	unix2dos $(WIN32PATH)/*.txt
+	unix2dos $(WIN32PATH)/doc/*.txt
+	unix2dos $(WIN32PATH)/doc/cz/*.txt
+	unix2dos $(WIN32PATH)/doc/da/*.txt
+	unix2dos $(WIN32PATH)/doc/de/*.txt
+	unix2dos $(WIN32PATH)/doc/es/*.txt
+	unix2dos $(WIN32PATH)/doc/fr/*.txt
+	unix2dos $(WIN32PATH)/doc/it/*.txt
+	unix2dos $(WIN32PATH)/doc/no-nb/*.txt
+	unix2dos $(WIN32PATH)/doc/sv/*.txt
+
+win32dist: win32-data
+	mkdir -p $(WIN32PATH)/graphics
+	cp $(srcdir)/dists/win32/graphics/left.bmp $(WIN32PATH)/graphics
+	cp $(srcdir)/dists/win32/graphics/scummvm-install.ico $(WIN32PATH)/graphics
+	cp $(srcdir)/dists/win32/graphics/scummvm-install.bmp $(WIN32PATH)/graphics
+	cp $(srcdir)/dists/win32/ScummVM.iss $(WIN32PATH)
+ifdef WIN32SDLDOCPATH
+	cp $(WIN32SDLDOCPATH)/README-SDL.txt $(WIN32PATH)/README-SDL.txt
+endif
+ifdef WIN32SDLPATH
+	cp $(WIN32SDLPATH)/SDL2.dll $(WIN32PATH)
+ifdef USE_SDL_NET
+	cp $(WIN32SDLPATH)/SDL2_net.dll $(WIN32PATH)
+	sed -e '/SDL2_net\.dll/ s/^;//' -i $(WIN32PATH)/ScummVM.iss
+endif
+endif
+ifdef WIN32SPARKLEPATH
+ifdef USE_SPARKLE
+	cp $(WIN32SPARKLEPATH)/WinSparkle.dll $(WIN32PATH)
+	sed -e '/WinSparkle\.dll/ s/^;//' -i $(WIN32PATH)/ScummVM.iss
+endif
+endif
+
+win32dist-mingw: win32-data
+ifneq (,$(findstring peldd,$(LDD)))
+	$(LDD) $(WIN32PATH)/$(EXECUTABLE) | xargs -I files cp -vu files $(WIN32PATH)
+else
+	ldd $(WIN32PATH)/$(EXECUTABLE) | grep -i mingw | cut -d">" -f2 | cut -d" " -f2 | sort -u | xargs -I files cp -vu files $(WIN32PATH)
+endif
+
+.PHONY: win32-data win32dist win32dist-mingw
+
+include $(srcdir)/ports.mk

backends/platform/sdl/win32/win32_wrapper.cpp

@@ -0,0 +1,258 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// For _tcscat
+#define FORBIDDEN_SYMBOL_EXCEPTION_strcat
+
+#define WIN32_LEAN_AND_MEAN
+#include <sdkddkver.h>
+#if !defined(_WIN32_IE) || (_WIN32_IE < 0x500)
+ // required for SHGetSpecialFolderPath and SHGFP_TYPE_CURRENT in shlobj.h
+#undef _WIN32_IE
+#define _WIN32_IE 0x500
+#endif
+#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x500)
+ // required for VER_MAJORVERSION, VER_MINORVERSION and VER_GREATER_EQUAL in winnt.h
+ // set to Windows 2000 which is the minimum needed for these constants
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x500
+#endif
+#include <windows.h>
+#include <shellapi.h> // for CommandLineToArgvW()
+#include <shlobj.h>
+#include <tchar.h>
+
+#include "common/ptr.h"
+#include "common/scummsys.h"
+#include "common/textconsole.h"
+#include "backends/platform/sdl/win32/win32_wrapper.h"
+
+// VerSetConditionMask, VerifyVersionInfo and SHGetFolderPath didn't appear until Windows 2000,
+// so we need to check for them at runtime
+ULONGLONG VerSetConditionMaskFunc(ULONGLONG dwlConditionMask, DWORD dwTypeMask, BYTE dwConditionMask) {
+	typedef ULONGLONG(WINAPI *VerSetConditionMaskFunction)(ULONGLONG conditionMask, DWORD typeMask, BYTE conditionOperator);
+
+	VerSetConditionMaskFunction verSetConditionMask = (VerSetConditionMaskFunction)(void *)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "VerSetConditionMask");
+	if (verSetConditionMask == nullptr)
+		return 0;
+
+	return verSetConditionMask(dwlConditionMask, dwTypeMask, dwConditionMask);
+}
+
+BOOL VerifyVersionInfoFunc(LPOSVERSIONINFOEXA lpVersionInformation, DWORD dwTypeMask, DWORDLONG dwlConditionMask) {
+	typedef BOOL(WINAPI *VerifyVersionInfoFunction)(LPOSVERSIONINFOEXA versionInformation, DWORD typeMask, DWORDLONG conditionMask);
+
+	VerifyVersionInfoFunction verifyVersionInfo = (VerifyVersionInfoFunction)(void *)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "VerifyVersionInfoA");
+	if (verifyVersionInfo == nullptr)
+		return FALSE;
+
+	return verifyVersionInfo(lpVersionInformation, dwTypeMask, dwlConditionMask);
+}
+
+HRESULT SHGetFolderPathFunc(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath) {
+	typedef HRESULT (WINAPI *SHGetFolderPathFunc)(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
+
+	SHGetFolderPathFunc pSHGetFolderPath = (SHGetFolderPathFunc)(void *)GetProcAddress(GetModuleHandle(TEXT("shell32.dll")), 
+#ifndef UNICODE
+		"SHGetFolderPathA"
+#else
+		"SHGetFolderPathW"
+#endif
+	);
+	if (pSHGetFolderPath)
+		return pSHGetFolderPath(hwnd, csidl, hToken, dwFlags, pszPath);
+
+	typedef BOOL (WINAPI *SHGetSpecialFolderPathFunc)(HWND hwnd, LPTSTR pszPath, int csidl, BOOL fCreate);
+
+	SHGetSpecialFolderPathFunc pSHGetSpecialFolderPath = (SHGetSpecialFolderPathFunc)(void *)GetProcAddress(GetModuleHandle(TEXT("shell32.dll")),
+#ifndef UNICODE
+		"SHGetSpecialFolderPathA"
+#else
+		"SHGetSpecialFolderPathW"
+#endif
+	);
+	if (pSHGetSpecialFolderPath)
+		return pSHGetSpecialFolderPath(hwnd, pszPath, csidl & ~CSIDL_FLAG_MASK, csidl & CSIDL_FLAG_CREATE) ? S_OK : E_FAIL;
+
+	return E_NOTIMPL;
+}
+
+namespace Win32 {
+
+bool getApplicationDataDirectory(TCHAR *applicationDataDirectory) {
+	HRESULT hr = SHGetFolderPathFunc(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, applicationDataDirectory);
+	if (hr != S_OK) {
+		if (hr != E_NOTIMPL) {
+			warning("Unable to locate application data directory");
+		}
+		return false;
+	}
+
+	_tcscat(applicationDataDirectory, TEXT("\\ScummVM"));
+	if (!CreateDirectory(applicationDataDirectory, NULL)) {
+		if (GetLastError() != ERROR_ALREADY_EXISTS) {
+			error("Cannot create ScummVM application data folder");
+		}
+	}
+
+	return true;
+}
+
+void getProcessDirectory(TCHAR *processDirectory, DWORD size) {
+	GetModuleFileName(NULL, processDirectory, size);
+	processDirectory[size - 1] = '\0'; // termination not guaranteed
+
+	// remove executable and final path separator
+	TCHAR *lastSeparator = _tcsrchr(processDirectory, '\\');
+	if (lastSeparator != NULL) {
+		*lastSeparator = '\0';
+	}
+}
+
+bool confirmWindowsVersion(int majorVersion, int minorVersion) {
+	OSVERSIONINFOEXA versionInfo;
+	DWORDLONG conditionMask = 0;
+
+	ZeroMemory(&versionInfo, sizeof(OSVERSIONINFOEXA));
+	versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
+	versionInfo.dwMajorVersion = majorVersion;
+	versionInfo.dwMinorVersion = minorVersion;
+
+	conditionMask = VerSetConditionMaskFunc(conditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
+	conditionMask = VerSetConditionMaskFunc(conditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
+
+	return VerifyVersionInfoFunc(&versionInfo, VER_MAJORVERSION | VER_MINORVERSION, conditionMask);
+}
+
+// for using ScopedPtr with malloc/free
+template <typename T>
+struct Freer {
+	inline void operator()(T *object) {
+		free(object);
+	}
+};
+
+bool moveFile(const Common::String &src, const Common::String &dst) {
+	Common::ScopedPtr<TCHAR, Freer<TCHAR>> tSrc(stringToTchar(src));
+	Common::ScopedPtr<TCHAR, Freer<TCHAR>> tDst(stringToTchar(dst));
+
+	if (MoveFileEx(tSrc.get(), tDst.get(), MOVEFILE_REPLACE_EXISTING)) {
+		return true;
+	}
+
+	// MoveFileEx may not be supported on the platform (Win9x)
+	if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
+		// Fall back to deleting the destination before using MoveFile.
+		// MoveFile requires that the destination not already exist.
+		DeleteFile(tDst.get());
+		return MoveFile(tSrc.get(), tDst.get());
+	}
+
+	return false;
+}
+
+bool isDriveCD(char driveLetter) {
+	TCHAR drivePath[] = TEXT("x:\\");
+	drivePath[0] = (TCHAR)driveLetter;
+
+	return (GetDriveType(drivePath) == DRIVE_CDROM);
+}
+
+wchar_t *ansiToUnicode(const char *s) {
+#ifndef UNICODE
+	uint codePage = CP_ACP;
+#else
+	uint codePage = CP_UTF8;
+#endif
+	DWORD size = MultiByteToWideChar(codePage, 0, s, -1, nullptr, 0);
+
+	if (size > 0) {
+		LPWSTR result = (LPWSTR)calloc(size, sizeof(WCHAR));
+		if (MultiByteToWideChar(codePage, 0, s, -1, result, size) != 0)
+			return result;
+	}
+
+	return nullptr;
+}
+
+char *unicodeToAnsi(const wchar_t *s) {
+#ifndef UNICODE
+	uint codePage = CP_ACP;
+#else
+	uint codePage = CP_UTF8;
+#endif
+	DWORD size = WideCharToMultiByte(codePage, 0, s, -1, nullptr, 0, nullptr, nullptr);
+
+	if (size > 0) {
+		char *result = (char *)calloc(size, sizeof(char));
+		if (WideCharToMultiByte(codePage, 0, s, -1, result, size, nullptr, nullptr) != 0)
+			return result;
+	}
+
+	return nullptr;
+}
+
+TCHAR *stringToTchar(const Common::String& s) {
+#ifndef UNICODE
+	char *t = (char *)malloc(s.size() + 1);
+	Common::strcpy_s(t, s.size() + 1, s.c_str());
+	return t;
+#else
+	return ansiToUnicode(s.c_str());
+#endif
+}
+
+Common::String tcharToString(const TCHAR *t) {
+#ifndef UNICODE
+	return t;
+#else
+	char *utf8 = unicodeToAnsi(t);
+	Common::String s = utf8;
+	free(utf8);
+	return s;
+#endif
+}
+
+#ifdef UNICODE
+char **getArgvUtf8(int *argc) {
+	// get command line arguments in wide-character
+	LPWSTR *wargv = CommandLineToArgvW(GetCommandLineW(), argc);
+
+	// convert each argument to utf8
+	char **argv = (char **)malloc((*argc + 1) * sizeof(char *));
+	for (int i = 0; i < *argc; ++i) {
+		argv[i] = Win32::unicodeToAnsi(wargv[i]);
+	}
+	argv[*argc] = nullptr; // null terminated array
+
+	LocalFree(wargv);
+	return argv;
+}
+
+void freeArgvUtf8(int argc, char **argv) {
+	for (int i = 0; i < argc; ++i) {
+		free(argv[i]);
+	}
+	free(argv);
+}
+#endif
+
+} // End of namespace Win32

backends/platform/sdl/win32/win32_wrapper.h

@@ -0,0 +1,147 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PLATFORM_SDL_WIN32_WRAPPER_H
+#define PLATFORM_SDL_WIN32_WRAPPER_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+
+HRESULT SHGetFolderPathFunc(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
+
+// Helper functions
+namespace Win32 {
+
+/**
+ * Gets the full path to the ScummVM application data directory
+ * in the user's profile and creates it if it doesn't exist.
+ *
+ * @param profileDirectory MAX_PATH sized output array
+ *
+ * @return True if the user's profile directory was found, false if
+ * it was not.
+ *
+ * @note if the user's profile directory is found but the "ScummVM"
+ * subdirectory can't be created then this function calls error().
+ */
+bool getApplicationDataDirectory(TCHAR *profileDirectory);
+
+/**
+ * Gets the full path to the directory that the currently executing
+ * process resides in.
+ *
+ * @param processDirectory output array
+ * @param size size in characters of output array
+ */
+void getProcessDirectory(TCHAR *processDirectory, DWORD size);
+
+/**
+ * Checks if the current running Windows version is greater or equal to the specified version.
+ * See: https://docs.microsoft.com/en-us/windows/win32/sysinfo/operating-system-version
+ *
+ * @param majorVersion The major version number (x.0)
+ * @param minorVersion The minor version number (0.x)
+ */
+bool confirmWindowsVersion(int majorVersion, int minorVersion);
+
+/**
+ * Moves a file within the same volume. Replaces any existing file.
+ */
+bool moveFile(const Common::String &src, const Common::String &dst);
+
+/**
+ * Returns true if the drive letter is a CDROM
+ *
+ * @param driveLetter The drive letter to test
+ */
+bool isDriveCD(char driveLetter);
+
+/**
+ * Converts a C string into a Windows wide-character string.
+ * Used to interact with Win32 Unicode APIs with no ANSI fallback.
+ * If UNICODE is defined then the conversion will use code page CP_UTF8,
+ * otherwise CP_ACP will be used.
+ *
+ * @param s Source string
+ * @return Converted string
+ *
+ * @note Return value must be freed by the caller.
+ */
+wchar_t *ansiToUnicode(const char *s);
+/**
+ * Converts a Windows wide-character string into a C string.
+ * Used to interact with Win32 Unicode APIs with no ANSI fallback.
+ * If UNICODE is defined then the conversion will use code page CP_UTF8,
+ * otherwise CP_ACP will be used.
+ *
+ * @param s Source string
+ * @return Converted string
+ *
+ * @note Return value must be freed by the caller.
+ */
+char *unicodeToAnsi(const wchar_t *s);
+
+/**
+ * Converts a Common::String to a TCHAR array for the purpose of passing to
+ * a Windows API or CRT call. If UNICODE is defined then the string will be
+ * converted from UTF8 to wide characters, otherwise the character array
+ * will be copied with no conversion.
+ *
+ * @param s Source string
+ * @return Converted string
+ *
+ * @note Return value must be freed by the caller.
+ */
+TCHAR *stringToTchar(const Common::String& s);
+
+/**
+ * Converts a TCHAR array returned from a Windows API or CRT call to a Common::String.
+ * If UNICODE is defined then the wide character array will be converted to UTF8,
+ * otherwise the char array will be copied with no conversion.
+ *
+ * @param s Source string
+ * @return Converted string
+ */
+Common::String tcharToString(const TCHAR *s);
+
+#ifdef UNICODE
+/**
+ * Returns command line arguments in argc / argv format in UTF8.
+ *
+ * @param argc argument count
+ * @return argument array
+ *
+ * @note Return value must be freed by the caller with freeArgvUtf8()
+ */
+char **getArgvUtf8(int *argc);
+
+/**
+ * Frees an argument array created by getArgvUtf8()
+ *
+ * @param argc argument count in argv
+ * @param argv argument array created by getArgvUtf8()
+ */
+void freeArgvUtf8(int argc, char **argv);
+#endif
+
+} // End of namespace Win32
+
+#endif