273 lines
8.0 KiB
C++
273 lines
8.0 KiB
C++
/* 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
|