Initial commit

engines/mediastation/cursors.cpp

@@ -0,0 +1,272 @@
+/* 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/>.
+ *
+ */
+
+#include "mediastation/cursors.h"
+#include "mediastation/debugchannels.h"
+#include "mediastation/mediastation.h"
+
+#include "common/system.h"
+#include "common/file.h"
+#include "common/formats/winexe_ne.h"
+#include "common/formats/winexe_pe.h"
+#include "graphics/cursorman.h"
+
+namespace MediaStation {
+
+CursorManager::~CursorManager() {
+	// It is up to the platform-specific cursor managers
+	// to actually delete their resources.
+	_cursors.clear();
+}
+
+bool CursorManager::attemptToReadFromStream(Chunk &chunk, uint param) {
+	bool handledParam = true;
+	switch (param) {
+	case kCursorManagerInit:
+		init(chunk);
+		break;
+
+	case kCursorManagerNewCursor:
+		newCursor(chunk);
+		break;
+
+	case kCursorManagerDisposeCursor:
+		disposeCursor(chunk);
+		break;
+
+	default:
+		handledParam = false;
+	}
+
+	return handledParam;
+}
+
+void CursorManager::init(Chunk &chunk) {
+	_baseCursorId = chunk.readTypedUint16();
+	_maxCursorId = chunk.readTypedUint16();
+
+	if (_maxCursorId < _baseCursorId || _baseCursorId == 0) {
+		error("%s: Got invalid cursor IDs", __func__);
+	}
+}
+
+void CursorManager::newCursor(Chunk &chunk) {
+	CursorType cursorType = static_cast<CursorType>(chunk.readTypedUint16());
+	uint16 cursorId = chunk.readTypedUint16();
+	switch (cursorType) {
+	case kPlatformCursor: {
+		uint16 platformCursorId = chunk.readTypedUint16();
+		newPlatformCursor(cursorId, platformCursorId);
+		break;
+	}
+
+	case kResourceCursor: {
+		// This first value isn't actually used.
+		chunk.readTypedUint16();
+		Common::String resourceName = chunk.readTypedFilename();
+		newResourceCursor(cursorId, resourceName);
+		break;
+	}
+
+	default:
+		error("%s: Got unknown cursor type %d", __func__, static_cast<uint>(cursorType));
+	}
+}
+
+void CursorManager::disposeCursor(Chunk &chunk) {
+	uint16 cursorId = chunk.readTypedUint16();
+	_cursors.erase(cursorId);
+	// We don't actually delete the underlying platform-specific
+	// cursor, just remove it from the hashmap. Otherwise, we'd
+	// mess up the platform-specific storage.
+}
+
+void CursorManager::newPlatformCursor(uint16 platformCursorId, uint16 cursorId) {
+	if (cursorId < _baseCursorId || cursorId > _maxCursorId || cursorId == 0) {
+		error("%s: Got invalid cursor ID %d", __func__, static_cast<uint>(cursorId));
+	}
+
+	warning("STUB: %s: Platform cursor %d, internal cursor %d", __func__, platformCursorId, cursorId);
+	// TODO: To implement this, we need have the default platform cursors for Windows and Mac.
+}
+
+void CursorManager::newResourceCursor(uint16 cursorId, const Common::String &resourceName) {
+	if (cursorId < _baseCursorId || cursorId > _maxCursorId || cursorId == 0) {
+		error("%s: Got invalid cursor ID %d", __func__, static_cast<uint>(cursorId));
+	}
+
+	Graphics::Cursor *cursor = loadResourceCursor(resourceName);
+	_cursors.setVal(cursorId, cursor);
+}
+
+void CursorManager::showCursor() {
+	CursorMan.showMouse(true);
+}
+
+void CursorManager::hideCursor() {
+	CursorMan.showMouse(false);
+}
+
+void CursorManager::registerAsPermanent(uint16 id) {
+	if (id != 0) {
+		_permanentCursorId = id;
+	}
+}
+
+void CursorManager::setAsPermanent(uint16 id) {
+	bool cursorAlreadySet = _currentCursorId == id && _permanentCursorId == id;
+	bool cursorIsEmpty = id == 0;
+	if (cursorAlreadySet || cursorIsEmpty) {
+		return;
+	}
+
+	_permanentCursorId = id;
+	_currentCursorId = id;
+	resetCurrent();
+}
+
+void CursorManager::setAsTemporary(uint16 id) {
+	bool cursorAlreadySet = _currentCursorId == id;
+	bool cursorIsEmpty = id == 0;
+	if (cursorAlreadySet || cursorIsEmpty) {
+		return;
+	}
+
+	_currentCursorId = id;
+	resetCurrent();
+}
+
+void CursorManager::unsetPermanent() {
+	_permanentCursorId = 0;
+	_currentCursorId = 0;
+}
+
+void CursorManager::unsetTemporary() {
+	if (_currentCursorId != _permanentCursorId) {
+		_currentCursorId = _permanentCursorId;
+		resetCurrent();
+	}
+}
+
+void CursorManager::resetCurrent() {
+	if (_currentCursorId != 0) {
+		Graphics::Cursor *cursor = _cursors.getVal(_currentCursorId);
+		CursorMan.replaceCursor(cursor);
+	}
+}
+
+void CursorManager::setDefaultCursor() {
+	Graphics::Cursor *cursor = Graphics::makeDefaultWinCursor();
+	CursorMan.replaceCursor(cursor);
+	delete cursor;
+}
+
+WindowsCursorManager::WindowsCursorManager(const Common::Path &appName) : CursorManager(appName) {
+	if (appName.empty()) {
+		error("%s: No executable to load cursors from", __func__);
+	} else if (!Common::File::exists(appName)) {
+		error("%s: Executable %s doesn't exist", __func__, appName.toString().c_str());
+	}
+
+	Common::WinResources *exe = Common::WinResources::createFromEXE(appName);
+	if (exe == nullptr || !exe->loadFromEXE(appName)) {
+		error("%s: Could not load resources from executable %s", __func__, appName.toString().c_str());
+	}
+
+	const Common::Array<Common::WinResourceID> cursorGroups = exe->getIDList(Common::kWinGroupCursor);
+	for (Common::WinResourceID cursorGroup : cursorGroups) {
+		Common::String resourceString = cursorGroup.getString();
+		if (resourceString.empty()) {
+			warning("%s: Got Windows cursor group with no string ID", __func__);
+			continue;
+		}
+		Graphics::WinCursorGroup *group = Graphics::WinCursorGroup::createCursorGroup(exe, cursorGroup);
+		_cursorGroups.setVal(resourceString, group);
+	}
+	delete exe;
+}
+
+WindowsCursorManager::~WindowsCursorManager() {
+	for (auto it = _cursorGroups.begin(); it != _cursorGroups.end(); ++it) {
+		delete it->_value;
+	}
+	_cursorGroups.clear();
+
+	// We don't need to delete items in _cursors itself,
+	// because those cursors are part of _cursorGroups.
+}
+
+Graphics::Cursor *WindowsCursorManager::loadResourceCursor(const Common::String &name) {
+	// Search for case-insensitive match since resource names are expected to be case-insensitive.
+	for (auto it = _cursorGroups.begin(); it != _cursorGroups.end(); ++it) {
+		if (it->_key.equalsIgnoreCase(name)) {
+			Graphics::Cursor *cursor = it->_value->cursors[0].cursor;
+			return cursor;
+		}
+	}
+
+	error("%s: Reqested Windows cursor %s not found", __func__, name.c_str());
+}
+
+MacCursorManager::MacCursorManager(const Common::Path &appName) : CursorManager(appName) {
+	if (appName.empty()) {
+		error("%s: No file to load cursors from", __func__);
+	} else if (!Common::File::exists(appName)) {
+		error("%s: File %s doesn't exist", __func__, appName.toString().c_str());
+	}
+
+	_resFork = new Common::MacResManager();
+	if (!_resFork->open(appName) || !_resFork->hasResFork()) {
+		error("%s: Could not load resource fork from %s", __func__, appName.toString().c_str());
+	}
+}
+
+MacCursorManager::~MacCursorManager() {
+	for (auto it = _cursors.begin(); it != _cursors.end(); ++it) {
+		delete it->_value;
+	}
+
+	delete _resFork;
+	_resFork = nullptr;
+}
+
+Graphics::Cursor *MacCursorManager::loadResourceCursor(const Common::String &name) {
+	// Try to load a color cursor first.
+	Common::SeekableReadStream *stream = _resFork->getResource(MKTAG('c', 'r', 's', 'r'), name);
+	if (stream == nullptr) {
+		// Fall back to attempting to load a mnochrome cursor.
+		stream = _resFork->getResource(MKTAG('C', 'U', 'R', 'S'), name);
+	}
+
+	// Make sure we got a resource.
+	if (stream == nullptr) {
+		error("%s: Reqested Mac cursor %s not found", __func__, name.c_str());
+	}
+
+	Graphics::MacCursor *macCursor = new Graphics::MacCursor();
+	if (!macCursor->readFromStream(*stream)) {
+		error("%s: Error parsing cursor %s from stream", __func__, name.c_str());
+	}
+	delete stream;
+	return macCursor;
+}
+
+} // End of namespace MediaStation