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; }
bool OSystem_PalmZodiac::check_event(Event &event, EventPtr ev) { if (ev->eType == keyDownEvent) { switch (ev->data.keyDown.chr) { // F5 = menu case vchrThumbWheelBack: _lastKey = kKeyNone; event.type = EVENT_KEYDOWN; event.kbd.keycode = 319; event.kbd.ascii = 319; event.kbd.flags = 0; return true; case vchrTriggerLeft: hotswap_gfx_mode(_mode == GFX_WIDE ? GFX_NORMAL: GFX_WIDE); return false; // not a key case vchrTriggerRight: setFeatureState(kFeatureAspectRatioCorrection, 0); return false; // not a key case vchrActionLeft: _lastKey = kKeyMouseLButton; event.type = EVENT_LBUTTONDOWN; event.mouse.x = _mouseCurState.x; event.mouse.y = _mouseCurState.y; return true; case vchrActionRight: _lastKey = kKeyNone; event.type = EVENT_RBUTTONDOWN; event.mouse.x = _mouseCurState.x; event.mouse.y = _mouseCurState.y; return true; // skip text case vchrActionDown: event.type = EVENT_KEYDOWN; event.kbd.keycode = '.'; event.kbd.ascii = '.'; event.kbd.flags = 0; return true; // trun off case vchrAutoOff: case vchrPowerOff: // pause the sound thread if any if (_sound.active) SndStreamPause(_soundEx.handle, true); break; case vchrLateWakeup: // resume the sound thread if any if (_sound.active) SndStreamPause(_soundEx.handle, false); break; } } else if (_overlayVisible) { switch (_lastKey) { case kKeyMouseLButton: _lastKey = kKeyNone; event.type = EVENT_LBUTTONUP; event.mouse.x = _mouseCurState.x; event.mouse.y = _mouseCurState.y; return true; } } 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. 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; } }
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 } }
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 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); }