scummvm/backends/platform/sdl/win32/win32.cpp

/* 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

	// 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);
	HINSTANCE shellExec = ShellExecute(getHwnd(), nullptr, tLogFilePath, nullptr, nullptr, SW_SHOWNORMAL);
	if ((intptr_t)shellExec > 32) {
		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);
	HINSTANCE result = ShellExecute(getHwnd(), nullptr, tUrl, nullptr, nullptr, SW_SHOWNORMAL);
	free(tUrl);
	// ShellExecute returns a value greater than 32 if successful
	if ((intptr_t)result <= 32) {
		warning("ShellExecute failed: error = %p", (void*)result);
		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::String OSystem_Win32::getScreenshotsPath() {
	// If the user has configured a screenshots path, use it
	Common::String screenshotsPath = OSystem_SDL::getScreenshotsPath();
	if (!screenshotsPath.empty()) {
		// OSystem_SDL may have appended a '/' at the end
		if (screenshotsPath.hasSuffix("/")) {
			screenshotsPath.deleteLastChar();
			if (!screenshotsPath.hasSuffix("\\") && !screenshotsPath.hasSuffix("/"))
				screenshotsPath += "\\";
		}
		return screenshotsPath;
	}

	TCHAR picturesPath[MAX_PATH];
	if (_isPortable) {
		Win32::getProcessDirectory(picturesPath, MAX_PATH);
		_tcscat(picturesPath, TEXT("\\Screenshots\\"));
	} else {
		// Use the My Pictures folder
		if (SHGetFolderPathFunc(nullptr, CSIDL_MYPICTURES, nullptr, SHGFP_TYPE_CURRENT, picturesPath) != S_OK) {
			warning("Unable to access My Pictures directory");
			return Common::String();
		}
		_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 Win32::tcharToString(picturesPath);
}

Common::String 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 Win32::tcharToString(configFile);
}

Common::String 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::String();
		}
		_tcscat(logFile, TEXT("\\Logs"));
		CreateDirectory(logFile, nullptr);
	}

	_tcscat(logFile, TEXT("\\scummvm.log"));

	return Win32::tcharToString(logFile);
}

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::String> 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);
	arch->_files.push_back(filename);
	return TRUE;
}

Win32ResourceArchive::Win32ResourceArchive() {
	EnumResourceNames(nullptr, MAKEINTRESOURCE(256), &EnumResNameProc, (LONG_PTR)this);
}

bool Win32ResourceArchive::hasFile(const Common::Path &path) const {
	Common::String name = path.toString();
	for (FilenameList::const_iterator i = _files.begin(); i != _files.end(); ++i) {
		if (i->equalsIgnoreCase(name))
			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 {
	Common::String name = path.toString();
	return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this));
}

Common::SeekableReadStream *Win32ResourceArchive::createReadStreamForMember(const Common::Path &path) const {
	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();
}

#endif