void OpenGLSdlGraphicsManager::toggleFullScreen(int loop) {
beginGFXTransaction();
const bool isFullscreen = getFullscreenMode();
if (isFullscreen && loop) {
_activeFullscreenMode += loop;
setFullscreenMode(true);
} else {
_activeFullscreenMode = -2;
setFullscreenMode(!isFullscreen);
}
endGFXTransaction();
// Ignore resize events for the next 10 frames
_ignoreResizeFrames = 10;
#ifdef USE_OSD
char buffer[128];
if (getFullscreenMode())
sprintf(buffer, "Fullscreen mode\n%d x %d",
_hwscreen->w, _hwscreen->h
);
else
sprintf(buffer, "Windowed mode\n%d x %d",
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(buffer);
#endif
}
void OpenGLSdlGraphicsManager::toggleFullScreen(int loop) {
beginGFXTransaction();
const bool isFullscreen = getFullscreenMode();
if (isFullscreen && loop) {
_activeFullscreenMode += loop;
setFullscreenMode(true);
} else {
_activeFullscreenMode = -2;
setFullscreenMode(!isFullscreen);
}
// HACK: We need to force a refresh here, since we change the
// fullscreen mode.
_transactionDetails.needRefresh = true;
endGFXTransaction();
// Ignore resize events for the next 10 frames
_ignoreResizeFrames = 10;
#ifdef USE_OSD
Common::String osdMessage;
if (getFullscreenMode())
osdMessage = Common::String::format("%s\n%d x %d",
_("Fullscreen mode"),
_hwscreen->w, _hwscreen->h
);
else
osdMessage = Common::String::format("%s\n%d x %d",
_("Windowed mode"),
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(osdMessage.c_str());
#endif
}
void OpenGLSdlGraphicsManager::displayScaleChangedMsg() {
char buffer[128];
sprintf(buffer, "Current scale: x%d\n%d x %d -> %d x %d",
_videoMode.scaleFactor,
_videoMode.screenWidth, _videoMode.screenHeight,
_videoMode.overlayWidth, _videoMode.overlayHeight
);
displayMessageOnOSD(buffer);
}
void OpenGLSdlGraphicsManager::displayScaleChangedMsg() {
const int scaleFactor = getScale();
Common::String osdMessage = Common::String::format(
"%s: x%d\n%d x %d -> %d x %d",
_("Current scale"),
scaleFactor,
_videoMode.screenWidth, _videoMode.screenHeight,
_videoMode.overlayWidth, _videoMode.overlayHeight
);
displayMessageOnOSD(osdMessage.c_str());
}
void OpenGLSdlGraphicsManager::displayModeChangedMsg() {
const char *newModeName = getCurrentModeName();
if (newModeName) {
char buffer[128];
sprintf(buffer, "Current display mode: %s\n%d x %d -> %d x %d",
newModeName,
_videoMode.screenWidth * _videoMode.scaleFactor,
_videoMode.screenHeight * _videoMode.scaleFactor,
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(buffer);
}
}
bool OSystem_OP::handleKeyDown(SDL_Event &ev, Common::Event &event) {
switch (ev.key.keysym.sym) {
case SDLK_HOME:
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
return true;
break;
case SDLK_END:
event.type = Common::EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
return true;
break;
case SDLK_PAGEDOWN:
event.type = Common::EVENT_MAINMENU;
return true;
break;
case SDLK_PAGEUP:
OP::ToggleTapMode();
if (OP::tapmodeLevel == TAPMODE_LEFT) {
displayMessageOnOSD("Touchscreen 'Tap Mode' - Left Click");
} else if (OP::tapmodeLevel == TAPMODE_RIGHT) {
displayMessageOnOSD("Touchscreen 'Tap Mode' - Right Click");
} else if (OP::tapmodeLevel == TAPMODE_HOVER) {
displayMessageOnOSD("Touchscreen 'Tap Mode' - Hover (No Click)");
}
break;
case SDLK_RSHIFT:
BUTTON_STATE_L = true;
break;
case SDLK_RCTRL:
break;
default:
return OSystem_SDL::handleKeyDown(ev, event);
break;
}
return false;
}
void OpenGLSdlGraphicsManager::displayModeChangedMsg() {
const char *newModeName = getCurrentModeName();
if (newModeName) {
const int scaleFactor = getScale();
Common::String osdMessage = Common::String::format(
"%s: %s\n%d x %d -> %d x %d",
_("Current display mode"),
newModeName,
_videoMode.screenWidth * scaleFactor,
_videoMode.screenHeight * scaleFactor,
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(osdMessage.c_str());
}
}
void OSystem_PalmBase::battery_handler() {
// check battery level every 15secs
if ((TimGetTicks() - _batCheckLast) > _batCheckTicks) {
UInt16 voltage, warnThreshold, criticalThreshold;
Boolean pluggedIn;
voltage = SysBatteryInfoV20(false, &warnThreshold, &criticalThreshold, NULL, NULL, &pluggedIn);
if (!pluggedIn) {
if (voltage <= warnThreshold) {
if (!_showBatLow) {
_showBatLow = true;
draw_osd(kDrawBatLow, _screenDest.w - 18, -16, true, 2);
displayMessageOnOSD("Battery low.");
}
} else {
if (_showBatLow) {
_showBatLow = false;
draw_osd(kDrawBatLow, _screenDest.w - 18, -16, false);
}
}
if (voltage <= criticalThreshold) {
::EventType event;
event.eType = keyDownEvent;
event.data.keyDown.chr = vchrPowerOff;
event.data.keyDown.modifiers = commandKeyMask;
#if defined(COMPILE_OS5) && defined(PALMOS_ARM)
SysEventAddToQueue(&event);
#else
EvtAddEventToQueue(&event);
#endif
}
}
_batCheckLast = TimGetTicks();
}
}
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
switch (event.type) {
case Common::EVENT_KEYUP:
return isHotkey(event);
case Common::EVENT_KEYDOWN:
if (event.kbd.hasFlags(Common::KBD_ALT)) {
if ( event.kbd.keycode == Common::KEYCODE_RETURN
|| event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
// Alt-Return and Alt-Enter toggle full screen mode
beginGFXTransaction();
setFeatureState(OSystem::kFeatureFullscreenMode, !getFeatureState(OSystem::kFeatureFullscreenMode));
endGFXTransaction();
#ifdef USE_OSD
if (getFeatureState(OSystem::kFeatureFullscreenMode)) {
displayMessageOnOSD(_("Fullscreen mode"));
} else {
displayMessageOnOSD(_("Windowed mode"));
}
#endif
return true;
}
if (event.kbd.keycode == Common::KEYCODE_s) {
// Alt-s creates a screenshot
Common::String filename;
for (int n = 0;; n++) {
SDL_RWops *file;
filename = Common::String::format("scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename.c_str(), "r");
if (!file)
break;
SDL_RWclose(file);
}
saveScreenshot(filename.c_str());
debug("Saved screenshot '%s'", filename.c_str());
return true;
}
} else if (event.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_ALT)) {
if ( event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS
|| event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS) {
// Ctrl+Alt+Plus/Minus Increase/decrease the size
const int direction = (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS) ? +1 : -1;
if (getFeatureState(OSystem::kFeatureFullscreenMode)) {
// In case we are in fullscreen we will choose the previous
// or next mode.
// In case no modes are available we do nothing.
if (_fullscreenVideoModes.empty()) {
return true;
}
// Look for the current mode.
VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(),
_fullscreenVideoModes.end(),
VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight));
if (i == _fullscreenVideoModes.end()) {
return true;
}
// Cycle through the modes in the specified direction.
if (direction > 0) {
++i;
if (i == _fullscreenVideoModes.end()) {
i = _fullscreenVideoModes.begin();
}
} else {
if (i == _fullscreenVideoModes.begin()) {
i = _fullscreenVideoModes.end();
}
--i;
}
_desiredFullscreenWidth = i->width;
_desiredFullscreenHeight = i->height;
// Try to setup the mode.
if (!setupMode(_lastRequestedWidth, _lastRequestedHeight)) {
warning("OpenGLSdlGraphicsManager::notifyEvent: Fullscreen resize failed ('%s')", SDL_GetError());
g_system->quit();
}
} else {
// Calculate the next scaling setting. We approximate the
// current scale setting in case the user resized the
// window. Then we apply the direction change.
int windowWidth = 0, windowHeight = 0;
getWindowDimensions(&windowWidth, &windowHeight);
_graphicsScale = MAX<int>(windowWidth / _lastRequestedWidth, windowHeight / _lastRequestedHeight);
_graphicsScale = MAX<int>(_graphicsScale + direction, 1);
// Since we overwrite a user resize here we reset its
// flag here. This makes enabling AR smoother because it
// will change the window size like in surface SDL.
_gotResize = false;
// Try to setup the mode.
if (!setupMode(_lastRequestedWidth * _graphicsScale, _lastRequestedHeight * _graphicsScale)) {
warning("OpenGLSdlGraphicsManager::notifyEvent: Window resize failed ('%s')", SDL_GetError());
g_system->quit();
}
}
#ifdef USE_OSD
int windowWidth = 0, windowHeight = 0;
getWindowDimensions(&windowWidth, &windowHeight);
const Common::String osdMsg = Common::String::format(_("Resolution: %dx%d"), windowWidth, windowHeight);
displayMessageOnOSD(osdMsg.c_str());
#endif
return true;
} else if (event.kbd.keycode == Common::KEYCODE_a) {
// In case the user changed the window size manually we will
// not change the window size again here.
_ignoreLoadVideoMode = _gotResize;
// Ctrl+Alt+a toggles the aspect ratio correction state.
beginGFXTransaction();
setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
endGFXTransaction();
// Make sure we do not ignore the next resize. This
// effectively checks whether loadVideoMode has been called.
assert(!_ignoreLoadVideoMode);
#ifdef USE_OSD
if (getFeatureState(OSystem::kFeatureAspectRatioCorrection))
displayMessageOnOSD(_("Enabled aspect ratio correction"));
else
displayMessageOnOSD(_("Disabled aspect ratio correction"));
#endif
return true;
} else if (event.kbd.keycode == Common::KEYCODE_f) {
// Never ever try to resize the window when we simply want to enable or disable filtering.
// This assures that the window size does not change.
_ignoreLoadVideoMode = true;
// Ctrl+Alt+f toggles filtering on/off
beginGFXTransaction();
setFeatureState(OSystem::kFeatureFilteringMode, !getFeatureState(OSystem::kFeatureFilteringMode));
endGFXTransaction();
// Make sure we do not ignore the next resize. This
// effectively checks whether loadVideoMode has been called.
assert(!_ignoreLoadVideoMode);
#ifdef USE_OSD
if (getFeatureState(OSystem::kFeatureFilteringMode)) {
displayMessageOnOSD(_("Filtering enabled"));
} else {
displayMessageOnOSD(_("Filtering disabled"));
}
#endif
return true;
}
}
// Fall through
default:
return false;
}
}
bool OSystem_PalmBase::pollEvent(Event &event) {
::EventType ev;
Boolean handled;
UInt32 keyCurrentState;
Coord x, y;
battery_handler();
timer_handler();
sound_handler();
for(;;) {
#if defined(COMPILE_OS5) && defined(PALMOS_ARM)
SysEventGet(&ev, evtNoWait);
#else
EvtGetEvent(&ev, evtNoWait);
#endif
// check for hardkey repeat for mouse emulation
keyCurrentState = KeyCurrentState();
// check_hard_keys();
if (!(keyCurrentState & _keyMouseMask)) {
_lastKeyRepeat = 0;
} else {
if (getMillis() >= (_keyMouseRepeat + _keyMouseDelay)) {
_keyMouseRepeat = getMillis();
if (gVars->arrowKeys) {
if (keyCurrentState & _keyMouse.bitUp)
event.kbd.keycode = 273;
else if (keyCurrentState & _keyMouse.bitDown)
event.kbd.keycode = 274;
else if (keyCurrentState & _keyMouse.bitLeft)
event.kbd.keycode = 276;
else if (keyCurrentState & _keyMouse.bitRight)
event.kbd.keycode = 275;
else if (keyCurrentState & _keyMouse.bitButLeft)
event.kbd.keycode = chrLineFeed;
event.type = EVENT_KEYDOWN;
event.kbd.ascii = event.kbd.keycode;
event.kbd.flags = 0;
} else {
Int8 sx = 0;
Int8 sy = 0;
if (keyCurrentState & _keyMouse.bitUp)
sy = -1;
else if (keyCurrentState & _keyMouse.bitDown)
sy = +1;
if (keyCurrentState & _keyMouse.bitLeft)
sx = -1;
else if (keyCurrentState & _keyMouse.bitRight)
sx = +1;
if (sx || sy) {
simulate_mouse(event, sx, sy, &x, &y);
event.type = EVENT_MOUSEMOVE;
_lastKey = kKeyMouseMove;
} else {
x = _mouseCurState.x;
y = _mouseCurState.y;
if (keyCurrentState & _keyMouse.bitButLeft) {
event.type = EVENT_LBUTTONDOWN;
_lastKey = kKeyMouseLButton;
} else if (_lastKey == kKeyMouseLButton) {
event.type = EVENT_LBUTTONUP;
_lastKey = kKeyNone;
}
}
event.mouse.x = x;
event.mouse.y = y;
warpMouse(x, y);
// updateCD();
}
return true;
}
}
if (ev.eType == keyDownEvent) {
switch (ev.data.keyDown.chr) {
// ESC key
case vchrLaunch:
_lastKey = kKeyNone;
event.type = EVENT_KEYDOWN;
event.kbd.keycode = 27;
event.kbd.ascii = 27;
event.kbd.flags = 0;
return true;
// F5 = menu
case vchrMenu:
_lastKey = kKeyNone;
event.type = EVENT_KEYDOWN;
event.kbd.keycode = 319;
event.kbd.ascii = 319;
event.kbd.flags = 0;
return true;
// if hotsync pressed, etc...
case vchrHardCradle:
case vchrHardCradle2:
case vchrLowBattery:
case vchrFind:
// case vchrBrightness: // volume control on Zodiac, let other backends disable it
case vchrContrast:
// do nothing
_lastKey = kKeyNone;
return true;
}
}
if (check_event(event, &ev))
return true;
_lastKey = kKeyNone;
// prevent crash when alarm is raised
handled = ((ev.eType == keyDownEvent) &&
(ev.data.keyDown.modifiers & commandKeyMask) &&
((ev.data.keyDown.chr == vchrAttnStateChanged) ||
(ev.data.keyDown.chr == vchrAttnUnsnooze)));
// graffiti strokes, auto-off, etc...
if (!handled)
if (SysHandleEvent(&ev))
continue;
switch(ev.eType) {
case penMoveEvent:
get_coordinates(&ev, x, y);
if (y > _screenHeight || y < 0 || x > _screenWidth || x < 0)
return false;
if (_lastEvent != penMoveEvent && (abs(y - event.mouse.y) <= 2 || abs(x - event.mouse.x) <= 2)) // move only if
return false;
_lastEvent = penMoveEvent;
event.type = EVENT_MOUSEMOVE;
event.mouse.x = x;
event.mouse.y = y;
warpMouse(x, y);
return true;
case penDownEvent:
get_coordinates(&ev, x, y);
// indy fight mode
if (_useNumPad && !_overlayVisible) {
char num = '1';
num += 9 -
(3 - (3 * x / _screenWidth )) -
(3 * (3 * y / _screenHeight));
event.type = EVENT_KEYDOWN;
event.kbd.keycode = num;
event.kbd.ascii = num;
event.kbd.flags = 0;
_lastEvent = keyDownEvent;
return true;
}
_lastEvent = penDownEvent;
if (y > _screenHeight || y < 0 || x > _screenWidth || x < 0)
return false;
event.type = ((gVars->stylusClick || _overlayVisible) ? EVENT_LBUTTONDOWN : EVENT_MOUSEMOVE);
event.mouse.x = x;
event.mouse.y = y;
warpMouse(x, y);
return true;
case penUpEvent:
get_coordinates(&ev, x, y);
event.type = ((gVars->stylusClick || _overlayVisible) ? EVENT_LBUTTONUP : EVENT_MOUSEMOVE);
if (y > _screenHeight || y < 0 || x > _screenWidth || x < 0)
return false;
event.mouse.x = x;
event.mouse.y = y;
warpMouse(x, y);
return true;
case keyDownEvent:
if (ev.data.keyDown.chr == vchrCommand &&
(ev.data.keyDown.modifiers & commandKeyMask)) {
_lastKeyModifier++;
_lastKeyModifier %= kModifierCount;
if (_lastKeyModifier)
draw_osd((kDrawKeyState + _lastKeyModifier - 1), 2, _screenDest.h + 2, true);
else
draw_osd(kDrawKeyState, 2, _screenDest.h + 2, false);
return false;
}
char mask = 0;
UInt16 key = ev.data.keyDown.chr;
if (_lastKeyModifier == kModifierNone) {
// for keyboard mode
if (ev.data.keyDown.modifiers & shiftKeyMask) mask |= KBD_SHIFT;
if (ev.data.keyDown.modifiers & controlKeyMask) mask |= KBD_CTRL;
if (ev.data.keyDown.modifiers & optionKeyMask) mask |= KBD_ALT;
if (ev.data.keyDown.modifiers & commandKeyMask) mask |= KBD_CTRL|KBD_ALT;
} else {
// for grafiti mode
if (_lastKeyModifier == kModifierCommand) mask = KBD_CTRL|KBD_ALT;
if (_lastKeyModifier == kModifierAlt) mask = KBD_ALT;
if (_lastKeyModifier == kModifierCtrl) mask = KBD_CTRL;
}
if (_lastKeyModifier)
draw_osd(kDrawKeyState, 2, _screenDest.h + 2, false);
_lastKeyModifier = kModifierNone;
// F1 -> F10 key
if (key >= '0' && key <= '9' && mask == (KBD_CTRL|KBD_ALT)) {
key = (key == '0') ? 324 : (315 + key - '1');
mask = 0;
// exit
} else if ((key == 'z' && mask == KBD_CTRL) || (mask == KBD_ALT && key == 'x')) {
event.type = EVENT_QUIT;
return true;
// num pad (indy fight mode)
} else if (key == 'n' && mask == (KBD_CTRL|KBD_ALT) && !_overlayVisible) {
_useNumPad = !_useNumPad;
draw_osd(kDrawFight, _screenDest.w - 34, _screenDest.h + 2, _useNumPad, 1);
displayMessageOnOSD(_useNumPad ? "Fight mode on." : "Fight mode off.");
return false;
}
// other keys
event.type = EVENT_KEYDOWN;
event.kbd.keycode = key;
event.kbd.ascii = key;
event.kbd.flags = mask;
return true;
default:
return false;
};
}
}
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
switch (event.type) {
case Common::EVENT_KEYUP:
return isHotkey(event);
case Common::EVENT_KEYDOWN:
if (event.kbd.hasFlags(Common::KBD_ALT)) {
if ( event.kbd.keycode == Common::KEYCODE_RETURN
|| event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
// Alt-Return and Alt-Enter toggle full screen mode
beginGFXTransaction();
setFeatureState(OSystem::kFeatureFullscreenMode, !getFeatureState(OSystem::kFeatureFullscreenMode));
endGFXTransaction();
#ifdef USE_OSD
if (getFeatureState(OSystem::kFeatureFullscreenMode)) {
displayMessageOnOSD("Fullscreen mode");
} else {
displayMessageOnOSD("Windowed mode");
}
#endif
return true;
}
if (event.kbd.keycode == Common::KEYCODE_s) {
// Alt-s creates a screenshot
Common::String filename;
for (int n = 0;; n++) {
SDL_RWops *file;
filename = Common::String::format("scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename.c_str(), "r");
if (!file)
break;
SDL_RWclose(file);
}
saveScreenshot(filename.c_str());
debug("Saved screenshot '%s'", filename.c_str());
return true;
}
} else if (event.kbd.hasFlags(Common::KBD_CTRL | Common::KBD_ALT)) {
if ( event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS
|| event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS) {
// Ctrl+Alt+Plus/Minus Increase/decrease the size
const int direction = (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_KP_PLUS) ? +1 : -1;
if (getFeatureState(OSystem::kFeatureFullscreenMode)) {
// In case we are in fullscreen we will choose the previous
// or next mode.
// In case no modes are available we do nothing.
if (_fullscreenVideoModes.empty()) {
return true;
}
// Look for the current mode.
VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(),
_fullscreenVideoModes.end(),
VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight));
if (i == _fullscreenVideoModes.end()) {
return true;
}
// Cycle through the modes in the specified direction.
if (direction > 0) {
++i;
if (i == _fullscreenVideoModes.end()) {
i = _fullscreenVideoModes.begin();
}
} else {
if (i == _fullscreenVideoModes.begin()) {
i = _fullscreenVideoModes.end();
}
--i;
}
_desiredFullscreenWidth = i->width;
_desiredFullscreenHeight = i->height;
// Try to setup the mode.
if (!setupMode(_lastRequestedWidth, _lastRequestedHeight)) {
warning("OpenGLSdlGraphicsManager::notifyEvent: Fullscreen resize failed ('%s')", SDL_GetError());
g_system->quit();
}
} else {
// Calculate the next scaling setting. We approximate the
// current scale setting in case the user resized the
// window. Then we apply the direction change.
_graphicsScale = MAX<int>(_hwScreen->w / _lastRequestedWidth, _hwScreen->h / _lastRequestedHeight);
_graphicsScale = MAX<int>(_graphicsScale + direction, 1);
// Since we overwrite a user resize here we reset its
// flag here. This makes enabling AR smoother because it
// will change the window size like in surface SDL.
_gotResize = false;
// Try to setup the mode.
if (!setupMode(_lastRequestedWidth * _graphicsScale, _lastRequestedHeight * _graphicsScale)) {
warning("OpenGLSdlGraphicsManager::notifyEvent: Window resize failed ('%s')", SDL_GetError());
g_system->quit();
}
}
#ifdef USE_OSD
const Common::String osdMsg = Common::String::format("Resolution: %dx%d", _hwScreen->w, _hwScreen->h);
displayMessageOnOSD(osdMsg.c_str());
#endif
return true;
} else if (event.kbd.keycode == Common::KEYCODE_a) {
// In case the user changed the window size manually we will
// not change the window size again here.
_ignoreLoadVideoMode = _gotResize;
// Ctrl+Alt+a toggles the aspect ratio correction state.
beginGFXTransaction();
setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
endGFXTransaction();
// Make sure we do not ignore the next resize. This
// effectively checks whether loadVideoMode has been called.
assert(!_ignoreLoadVideoMode);
#ifdef USE_OSD
Common::String osdMsg = "Aspect ratio correction: ";
osdMsg += getFeatureState(OSystem::kFeatureAspectRatioCorrection) ? "enabled" : "disabled";
displayMessageOnOSD(osdMsg.c_str());
#endif
return true;
} else if (event.kbd.keycode == Common::KEYCODE_f) {
// Ctrl+Alt+f toggles the graphics modes.
// We are crazy we will allow the OpenGL base class to
// introduce new graphics modes like shaders for special
// filtering. If some other OpenGL subclass needs this,
// we can think of refactoring this.
int mode = getGraphicsMode();
const OSystem::GraphicsMode *supportedModes = getSupportedGraphicsModes();
const OSystem::GraphicsMode *modeDesc = nullptr;
// Search the current mode.
for (; supportedModes->name; ++supportedModes) {
if (supportedModes->id == mode) {
modeDesc = supportedModes;
break;
}
}
assert(modeDesc);
// Try to use the next mode in the list.
++modeDesc;
if (!modeDesc->name) {
modeDesc = getSupportedGraphicsModes();
}
// Never ever try to resize the window when we simply want to
// switch the graphics mode. This assures that the window size
// does not change.
_ignoreLoadVideoMode = true;
beginGFXTransaction();
setGraphicsMode(modeDesc->id);
endGFXTransaction();
// Make sure we do not ignore the next resize. This
// effectively checks whether loadVideoMode has been called.
assert(!_ignoreLoadVideoMode);
#ifdef USE_OSD
const Common::String osdMsg = Common::String::format("Graphics mode: %s", _(modeDesc->description));
displayMessageOnOSD(osdMsg.c_str());
#endif
return true;
}
}
// Fall through
default:
return false;
}
}
bool OSystem_IPOD::pollEvent(Event &event) {
SDL_Event ev;
int axis;
byte b = 0;
handleKbdMouse();
// If the screen mode changed, send an EVENT_SCREEN_CHANGED
if (_modeChanged) {
_modeChanged = false;
event.type = EVENT_SCREEN_CHANGED;
return true;
}
while(SDL_PollEvent(&ev)) {
switch(ev.type) {
case SDL_KEYDOWN:{
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Alt-Return and Alt-Enter toggle full screen mode
if (b == KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN
|| ev.key.keysym.sym == SDLK_KP_ENTER)) {
setFullscreenMode(!_fullscreen);
#ifdef USE_OSD
if (_fullscreen)
displayMessageOnOSD("Fullscreen mode");
else
displayMessageOnOSD("Windowed mode");
#endif
break;
}
// Alt-S: Create a screenshot
if (b == KBD_ALT && ev.key.keysym.sym == 's') {
char filename[20];
for (int n = 0;; n++) {
SDL_RWops *file;
sprintf(filename, "scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename, "r");
if (!file)
break;
SDL_RWclose(file);
}
if (saveScreenshot(filename))
printf("Saved '%s'\n", filename);
else
printf("Could not save screenshot!\n");
break;
}
// Ctrl-m toggles mouse capture
if (b == KBD_CTRL && ev.key.keysym.sym == 'm') {
toggleMouseGrab();
break;
}
#ifdef MACOSX
// On Macintosh', Cmd-Q quits
if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') {
event.type = EVENT_QUIT;
return true;
}
#elif defined(UNIX)
// On other unices, Control-Q quits
if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') {
event.type = EVENT_QUIT;
return true;
}
#else
// Ctrl-z and Alt-X quit
if ((b == KBD_CTRL && ev.key.keysym.sym == 'z') || (b == KBD_ALT && ev.key.keysym.sym == 'x')) {
event.type = EVENT_QUIT;
return true;
}
#endif
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
handleScalerHotkeys(ev.key);
break;
}
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = EVENT_KEYDOWN;
event.kbd.keycode = ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
return true;
}
case SDL_KEYUP:
{
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = EVENT_KEYUP;
event.kbd.keycode = ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (KBD_CTRL|KBD_ALT)) == (KBD_CTRL|KBD_ALT)) {
// Swallow these key up events
break;
}
return true;
}
case SDL_MOUSEMOTION:
event.type = EVENT_MOUSEMOVE;
fillMouseEvent(event, ev.motion.x, ev.motion.y);
setMousePos(event.mouse.x, event.mouse.y);
return true;
case SDL_MOUSEBUTTONDOWN:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = EVENT_LBUTTONDOWN;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = EVENT_RBUTTONDOWN;
#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
else if (ev.button.button == SDL_BUTTON_WHEELUP)
event.type = EVENT_WHEELUP;
else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
event.type = EVENT_WHEELDOWN;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_MOUSEBUTTONUP:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = EVENT_LBUTTONUP;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = EVENT_RBUTTONUP;
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_JOYBUTTONDOWN:
if (ev.jbutton.button == JOY_BUT_LMOUSE) {
event.type = EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
event.type = EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = EVENT_KEYDOWN;
switch (ev.jbutton.button) {
case JOY_BUT_ESCAPE:
event.kbd.keycode = SDLK_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_PERIOD:
event.kbd.keycode = SDLK_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case JOY_BUT_SPACE:
event.kbd.keycode = SDLK_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_F5:
event.kbd.keycode = SDLK_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
break;
}
}
return true;
case SDL_JOYBUTTONUP:
if (ev.jbutton.button == JOY_BUT_LMOUSE) {
event.type = EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
event.type = EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = EVENT_KEYUP;
switch (ev.jbutton.button) {
case JOY_BUT_ESCAPE:
event.kbd.keycode = SDLK_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_PERIOD:
event.kbd.keycode = SDLK_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case JOY_BUT_SPACE:
event.kbd.keycode = SDLK_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case JOY_BUT_F5:
event.kbd.keycode = SDLK_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
break;
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
axis -= JOY_DEADZONE;
event.type = EVENT_MOUSEMOVE;
} else if ( axis < -JOY_DEADZONE ) {
axis += JOY_DEADZONE;
event.type = EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
#ifdef JOY_ANALOG
_km.x_vel = axis/2000;
_km.x_down_count = 0;
#else
if (axis != 0) {
_km.x_vel = (axis > 0) ? 1:-1;
_km.x_down_count = 1;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
#endif
} else if (ev.jaxis.axis == JOY_YAXIS) {
#ifndef JOY_INVERT_Y
axis = -axis;
#endif
#ifdef JOY_ANALOG
_km.y_vel = -axis / 2000;
_km.y_down_count = 0;
#else
if (axis != 0) {
_km.y_vel = (-axis > 0) ? 1: -1;
_km.y_down_count = 1;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
#endif
}
fillMouseEvent(event, _km.x, _km.y);
return true;
case SDL_VIDEOEXPOSE:
_forceFull = true;
break;
case SDL_QUIT:
event.type = EVENT_QUIT;
return true;
}
}
return false;
}
/* Override the SDL pollEvent with the Wiz's own event code. */
bool OSystem_GP2XWIZ::pollEvent(Common::Event &event) {
SDL_Event ev;
int axis;
byte b = 0;
handleKbdMouse();
// If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
if (_modeChanged) {
_modeChanged = false;
event.type = Common::EVENT_SCREEN_CHANGED;
return true;
}
// GP2X Wiz Input mappings.
/*
Single Button
Movement:
GP2X_BUTTON_UP Cursor Up
GP2X_BUTTON_DOWN Cursor Down
GP2X_BUTTON_LEFT Cursor Left
GP2X_BUTTON_RIGHT Cursor Right
GP2X_BUTTON_UPLEFT Cursor Up Left
GP2X_BUTTON_UPRIGHT Cursor Up Right
GP2X_BUTTON_DOWNLEFT Cursor Down Left
GP2X_BUTTON_DOWNRIGHT Cursor Down Right
Button Emulation:
GP2X_BUTTON_A . (Period)
GP2X_BUTTON_B Left Mouse Click
GP2X_BUTTON_Y Space Bar
GP2X_BUTTON_X Right Mouse Click
GP2X_BUTTON_L Combo Modifier (Left Trigger)
GP2X_BUTTON_R Return (Right Trigger)
GP2X_BUTTON_MENU F5 (Game Menu)
GP2X_BUTTON_SELECT Escape
GP2X_BUTTON_VOLUP /dev/mixer Global Volume Up
GP2X_BUTTON_VOLDOWN /dev/mixer Global Volume Down
Combos:
GP2X_BUTTON_VOLUP & GP2X_BUTTON_VOLDOWN 0 (For Monkey 2 CP) or Virtual Keyboard if enabled
GP2X_BUTTON_L & GP2X_BUTTON_SELECT Common::EVENT_QUIT (Calls Sync() to make sure SD is flushed)
GP2X_BUTTON_L & GP2X_BUTTON_MENU Common::EVENT_MAINMENU (ScummVM Global Main Menu)
GP2X_BUTTON_L & GP2X_BUTTON_A Common::EVENT_PREDICTIVE_DIALOG for predictive text entry box (AGI games)
*/
while (SDL_PollEvent(&ev)) {
switch(ev.type) {
case SDL_KEYDOWN:{
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYDOWN;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
return true;
}
case SDL_KEYUP:
{
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYUP;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
// Swallow these key up events
break;
}
return true;
}
case SDL_MOUSEMOTION:
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, ev.motion.x, ev.motion.y);
setMousePos(event.mouse.x, event.mouse.y);
return true;
case SDL_MOUSEBUTTONDOWN:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONDOWN;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONDOWN;
#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
else if (ev.button.button == SDL_BUTTON_WHEELUP)
event.type = Common::EVENT_WHEELUP;
else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
event.type = Common::EVENT_WHEELDOWN;
#endif
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONDOWN;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_MOUSEBUTTONUP:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONUP;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONUP;
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONUP;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_JOYBUTTONDOWN:
_stickBtn[ev.jbutton.button] = 1;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (_stickBtn[GP2X_BUTTON_L] && (ev.jbutton.button == GP2X_BUTTON_SELECT)) {
event.type = Common::EVENT_QUIT;
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYDOWN;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = true;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_SELECT:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_QUIT;
} else {
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_A:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_PREDICTIVE_DIALOG;
} else {
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_Y:
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_MENU:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
WIZ_HW::mixerMoveVolume(2);
if (WIZ_HW::volumeLevel == 100) {
displayMessageOnOSD("Maximum Volume");
} else {
displayMessageOnOSD("Increasing Volume");
}
break;
case GP2X_BUTTON_VOLDOWN:
WIZ_HW::mixerMoveVolume(1);
if (WIZ_HW::volumeLevel == 0) {
displayMessageOnOSD("Minimal Volume");
} else {
displayMessageOnOSD("Decreasing Volume");
}
break;
}
}
return true;
case SDL_JOYBUTTONUP:
_stickBtn[ev.jbutton.button] = 0;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYUP;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_SELECT:
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_A:
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_Y:
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_MENU:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = false;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
break;
case GP2X_BUTTON_VOLDOWN:
break;
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
axis -= JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else if ( axis < -JOY_DEADZONE ) {
axis += JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
if (axis != 0) {
_km.x_vel = (axis > 0) ? 1:-1;
_km.x_down_count = 1;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
} else if (ev.jaxis.axis == JOY_YAXIS) {
#ifndef JOY_INVERT_Y
axis = -axis;
#endif
#ifdef JOY_ANALOG
_km.y_vel = -axis / 2000;
_km.y_down_count = 0;
#else
if (axis != 0) {
_km.y_vel = (-axis > 0) ? 1: -1;
_km.y_down_count = 1;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
#endif
}
fillMouseEvent(event, _km.x, _km.y);
return true;
case SDL_VIDEOEXPOSE:
_forceFull = true;
break;
case SDL_QUIT:
event.type = Common::EVENT_QUIT;
return true;
}
}
return false;
}
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
switch ((int)event.type) {
case Common::EVENT_KEYDOWN:
if (event.kbd.hasFlags(Common::KBD_ALT)) {
// Alt-Return and Alt-Enter toggle full screen mode
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(0);
return true;
}
// Alt-S create a screenshot
if (event.kbd.keycode == 's') {
char filename[20];
for (int n = 0;; n++) {
SDL_RWops *file;
sprintf(filename, "scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename, "r");
if (!file)
break;
SDL_RWclose(file);
}
if (saveScreenshot(filename))
debug("Saved screenshot '%s'", filename);
else
warning("Could not save screenshot");
return true;
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) {
// Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(1);
return true;
}
// Ctrl-Alt-a switch between display modes
if (event.kbd.keycode == 'a') {
beginGFXTransaction();
setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
endGFXTransaction();
#ifdef USE_OSD
char buffer[128];
if (getFeatureState(OSystem::kFeatureAspectRatioCorrection))
sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d",
_videoMode.screenWidth, _videoMode.screenHeight,
_hwscreen->w, _hwscreen->h);
else
sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d",
_videoMode.screenWidth, _videoMode.screenHeight,
_hwscreen->w, _hwscreen->h);
displayMessageOnOSD(buffer);
#endif
internUpdateScreen();
return true;
}
// Ctrl-Alt-f toggles antialiasing
if (event.kbd.keycode == 'f') {
beginGFXTransaction();
toggleAntialiasing();
endGFXTransaction();
#ifdef USE_OSD
// TODO: This makes guesses about what internal antialiasing
// modes we use, we might want to consider a better way of
// displaying information to the user.
if (getAntialiasingState())
displayMessageOnOSD("Active filter mode: Linear");
else
displayMessageOnOSD("Active filter mode: Nearest");
#endif
return true;
}
SDLKey sdlKey = (SDLKey)event.kbd.keycode;
// Ctrl+Alt+Plus/Minus Increase/decrease the scale factor
if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS ||
sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) {
int factor = getScale();
factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1;
if (0 < factor && factor < 4) {
// Check if the desktop resolution has been detected
if (_desktopWidth > 0 && _desktopHeight > 0)
// If the new scale factor is too big, do not scale
if (_videoMode.screenWidth * factor > _desktopWidth ||
_videoMode.screenHeight * factor > _desktopHeight)
return false;
beginGFXTransaction();
setScale(factor);
endGFXTransaction();
#ifdef USE_OSD
displayScaleChangedMsg();
#endif
return true;
}
}
const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_3);
const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP3);
// Ctrl-Alt-<number key> will change the GFX mode
if (isNormalNumber || isKeypadNumber) {
if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 3) {
#ifdef USE_OSD
int lastMode = _videoMode.mode;
#endif
// We need to query the scale and set it up, because
// setGraphicsMode sets the default scale to 2
int oldScale = getScale();
beginGFXTransaction();
setGraphicsMode(sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1));
setScale(oldScale);
endGFXTransaction();
#ifdef USE_OSD
if (lastMode != _videoMode.mode)
displayModeChangedMsg();
#endif
internUpdateScreen();
}
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) {
// Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(-1);
return true;
}
}
break;
case Common::EVENT_KEYUP:
return isHotkey(event);
// HACK: Handle special SDL event
// The new screen size is saved on the mouse event as part of HACK,
// there is no common resize event.
case OSystem_SDL::kSdlEventResize:
// Do not resize if ignoring resize events.
if (!_ignoreResizeFrames && !getFullscreenMode()) {
bool scaleChanged = false;
beginGFXTransaction();
_videoMode.hardwareWidth = event.mouse.x;
_videoMode.hardwareHeight = event.mouse.y;
if (_videoMode.mode != OpenGL::GFX_ORIGINAL) {
_screenResized = true;
calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight);
}
int scale = MIN(_videoMode.hardwareWidth / _videoMode.screenWidth,
_videoMode.hardwareHeight / _videoMode.screenHeight);
if (getScale() != scale) {
scaleChanged = true;
setScale(MAX(MIN(scale, 3), 1));
}
if (_videoMode.mode == OpenGL::GFX_ORIGINAL) {
calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight);
}
_transactionDetails.sizeChanged = true;
endGFXTransaction();
#ifdef USE_OSD
if (scaleChanged)
displayScaleChangedMsg();
#endif
}
return true;
default:
break;
}
return OpenGLGraphicsManager::notifyEvent(event);
}
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
switch ((int)event.type) {
case Common::EVENT_KEYDOWN:
if (event.kbd.hasFlags(Common::KBD_ALT)) {
// Alt-Return and Alt-Enter toggle full screen mode
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(0);
return true;
}
// Alt-S create a screenshot
if (event.kbd.keycode == 's') {
char filename[20];
for (int n = 0;; n++) {
SDL_RWops *file;
sprintf(filename, "scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename, "r");
if (!file)
break;
SDL_RWclose(file);
}
if (saveScreenshot(filename))
printf("Saved '%s'\n", filename);
else
printf("Could not save screenshot!\n");
return true;
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) {
// Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(1);
return true;
}
// Ctrl-Alt-a switch between display modes
if (event.kbd.keycode == 'a') {
beginGFXTransaction();
switchDisplayMode(-1);
endGFXTransaction();
#ifdef USE_OSD
displayModeChangedMsg();
#endif
internUpdateScreen();
return true;
}
// Ctrl-Alt-f toggles antialiasing
if (event.kbd.keycode == 'f') {
beginGFXTransaction();
_videoMode.antialiasing = !_videoMode.antialiasing;
_transactionDetails.filterChanged = true;
endGFXTransaction();
#ifdef USE_OSD
if (_videoMode.antialiasing)
displayMessageOnOSD("Active filter mode: Linear");
else
displayMessageOnOSD("Active filter mode: Nearest");
#endif
return true;
}
SDLKey sdlKey = (SDLKey)event.kbd.keycode;
// Ctrl+Alt+Plus/Minus Increase/decrease the scale factor
if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS ||
sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) {
int factor = _videoMode.scaleFactor;
factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1;
if (0 < factor && factor < 4) {
// Check if the desktop resolution has been detected
if (_desktopWidth > 0 && _desktopHeight > 0)
// If the new scale factor is too big, do not scale
if (_videoMode.screenWidth * factor > _desktopWidth ||
_videoMode.screenHeight * factor > _desktopHeight)
return false;
beginGFXTransaction();
setScale(factor);
endGFXTransaction();
#ifdef USE_OSD
displayScaleChangedMsg();
#endif
return true;
}
}
const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_4);
const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP4);
// Ctrl-Alt-<number key> will change the GFX mode
if (isNormalNumber || isKeypadNumber) {
if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 4) {
int lastMode = _videoMode.mode;
beginGFXTransaction();
_videoMode.mode = sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1);
_transactionDetails.needRefresh = true;
_aspectRatioCorrection = false;
endGFXTransaction();
#ifdef USE_OSD
if (lastMode != _videoMode.mode)
displayModeChangedMsg();
#endif
internUpdateScreen();
}
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) {
// Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(-1);
return true;
}
// Ctrl-Shift-a switch backwards between display modes
if (event.kbd.keycode == 'a') {
beginGFXTransaction();
switchDisplayMode(-2);
endGFXTransaction();
#ifdef USE_OSD
displayModeChangedMsg();
#endif
internUpdateScreen();
return true;
}
}
break;
case Common::EVENT_KEYUP:
return isHotkey(event);
// HACK: Handle special SDL event
// The new screen size is saved on the mouse event as part of HACK,
// there is no common resize event.
case OSystem_SDL::kSdlEventResize:
// Do not resize if ignoring resize events.
if (!_ignoreResizeFrames && !_videoMode.fullscreen) {
bool scaleChanged = false;
beginGFXTransaction();
_videoMode.hardwareWidth = event.mouse.x;
_videoMode.hardwareHeight = event.mouse.y;
if (_videoMode.mode != OpenGL::GFX_ORIGINAL) {
_screenResized = true;
calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight);
}
int scale = MIN(_videoMode.hardwareWidth / _videoMode.screenWidth,
_videoMode.hardwareHeight / _videoMode.screenHeight);
if (_videoMode.scaleFactor != scale) {
scaleChanged = true;
_videoMode.scaleFactor = MAX(MIN(scale, 3), 1);
}
if (_videoMode.mode == OpenGL::GFX_ORIGINAL) {
calculateDisplaySize(_videoMode.hardwareWidth, _videoMode.hardwareHeight);
}
_transactionDetails.sizeChanged = true;
endGFXTransaction();
#ifdef USE_OSD
if (scaleChanged)
displayScaleChangedMsg();
#endif
}
return true;
default:
break;
}
return OpenGLGraphicsManager::notifyEvent(event);
}
bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
switch ((int)event.type) {
case Common::EVENT_KEYDOWN:
if (event.kbd.hasFlags(Common::KBD_ALT)) {
// Alt-Return and Alt-Enter toggle full screen mode
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(0);
return true;
}
// Alt-S create a screenshot
if (event.kbd.keycode == 's') {
Common::String filename;
for (int n = 0;; n++) {
SDL_RWops *file;
filename = Common::String::format("scummvm%05d.bmp", n);
file = SDL_RWFromFile(filename.c_str(), "r");
if (!file)
break;
SDL_RWclose(file);
}
if (saveScreenshot(filename.c_str()))
debug("Saved screenshot '%s'", filename.c_str());
else
warning("Could not save screenshot");
return true;
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) {
// Ctrl-Alt-Return and Ctrl-Alt-Enter switch between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(1);
return true;
}
// Ctrl-Alt-a switch between display modes
if (event.kbd.keycode == 'a') {
beginGFXTransaction();
setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
endGFXTransaction();
#ifdef USE_OSD
Common::String osdMessage;
if (getFeatureState(OSystem::kFeatureAspectRatioCorrection))
osdMessage = Common::String::format("%s\n%d x %d -> %d x %d",
_("Enabled aspect ratio correction"),
_videoMode.screenWidth, _videoMode.screenHeight,
_hwscreen->w, _hwscreen->h);
else
osdMessage = Common::String::format("%s\n%d x %d -> %d x %d",
_("Disabled aspect ratio correction"),
_videoMode.screenWidth, _videoMode.screenHeight,
_hwscreen->w, _hwscreen->h);
displayMessageOnOSD(osdMessage.c_str());
#endif
internUpdateScreen();
return true;
}
// Ctrl-Alt-f toggles antialiasing
if (event.kbd.keycode == 'f') {
beginGFXTransaction();
toggleAntialiasing();
endGFXTransaction();
#ifdef USE_OSD
// TODO: This makes guesses about what internal antialiasing
// modes we use, we might want to consider a better way of
// displaying information to the user.
if (getAntialiasingState())
displayMessageOnOSD(_("Active filter mode: Linear"));
else
displayMessageOnOSD(_("Active filter mode: Nearest"));
#endif
return true;
}
SDLKey sdlKey = (SDLKey)event.kbd.keycode;
// Ctrl+Alt+Plus/Minus Increase/decrease the scale factor
if ((sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS ||
sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS)) {
int factor = getScale();
factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1;
if (0 < factor && factor < 4) {
// Check if the desktop resolution has been detected
if (_desktopWidth > 0 && _desktopHeight > 0)
// If the new scale factor is too big, do not scale
if (_videoMode.screenWidth * factor > _desktopWidth ||
_videoMode.screenHeight * factor > _desktopHeight)
return false;
beginGFXTransaction();
setScale(factor);
endGFXTransaction();
#ifdef USE_OSD
displayScaleChangedMsg();
#endif
return true;
}
}
const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_3);
const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP3);
// Ctrl-Alt-<number key> will change the GFX mode
if (isNormalNumber || isKeypadNumber) {
if (sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1) <= 3) {
#ifdef USE_OSD
int lastMode = _videoMode.mode;
#endif
// We need to query the scale and set it up, because
// setGraphicsMode sets the default scale to 2
int oldScale = getScale();
beginGFXTransaction();
setGraphicsMode(sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1));
setScale(oldScale);
endGFXTransaction();
#ifdef USE_OSD
if (lastMode != _videoMode.mode)
displayModeChangedMsg();
#endif
internUpdateScreen();
}
}
}
if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_SHIFT)) {
// Ctrl-Shift-Return and Ctrl-Shift-Enter switch backwards between full screen modes
if (event.kbd.keycode == Common::KEYCODE_RETURN ||
event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER) {
toggleFullScreen(-1);
return true;
}
}
break;
case Common::EVENT_KEYUP:
return isHotkey(event);
default:
break;
}
return false;
}
void OSystem_SDL::handleScalerHotkeys(const SDL_KeyboardEvent &key) {
// Ctrl-Alt-a toggles aspect ratio correction
if (key.keysym.sym == 'a') {
setFeatureState(kFeatureAspectRatioCorrection, !_adjustAspectRatio);
#ifdef USE_OSD
char buffer[128];
if (_adjustAspectRatio)
sprintf(buffer, "Enabled aspect ratio correction\n%d x %d -> %d x %d",
_screenWidth, _screenHeight,
_hwscreen->w, _hwscreen->h
);
else
sprintf(buffer, "Disabled aspect ratio correction\n%d x %d -> %d x %d",
_screenWidth, _screenHeight,
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(buffer);
#endif
return;
}
int newMode = -1;
int factor = _scaleFactor - 1;
// Increase/decrease the scale factor
if (key.keysym.sym == SDLK_EQUALS || key.keysym.sym == SDLK_PLUS || key.keysym.sym == SDLK_MINUS ||
key.keysym.sym == SDLK_KP_PLUS || key.keysym.sym == SDLK_KP_MINUS) {
factor += (key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_MINUS) ? -1 : +1;
if (0 <= factor && factor <= 3) {
newMode = s_gfxModeSwitchTable[_scalerType][factor];
}
}
const bool isNormalNumber = (SDLK_1 <= key.keysym.sym && key.keysym.sym <= SDLK_9);
const bool isKeypadNumber = (SDLK_KP1 <= key.keysym.sym && key.keysym.sym <= SDLK_KP9);
if (isNormalNumber || isKeypadNumber) {
_scalerType = key.keysym.sym - (isNormalNumber ? SDLK_1 : SDLK_KP1);
if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable))
return;
while (s_gfxModeSwitchTable[_scalerType][factor] < 0) {
assert(factor > 0);
factor--;
}
newMode = s_gfxModeSwitchTable[_scalerType][factor];
}
if (newMode >= 0) {
setGraphicsMode(newMode);
#ifdef USE_OSD
if (_osdSurface) {
const char *newScalerName = 0;
const GraphicsMode *g = getSupportedGraphicsModes();
while (g->name) {
if (g->id == _mode) {
newScalerName = g->description;
break;
}
g++;
}
if (newScalerName) {
char buffer[128];
sprintf(buffer, "Active graphics filter: %s\n%d x %d -> %d x %d",
newScalerName,
_screenWidth, _screenHeight,
_hwscreen->w, _hwscreen->h
);
displayMessageOnOSD(buffer);
}
}
#endif
}
}
