void WINCESdlGraphicsManager::swap_zoom_down() {
if (_zoomDown) {
// restore visibility
_toolbarHandler.setVisible(_saveToolbarZoom);
// restore scaler
_scaleFactorYd = 2;
_scalerProc = DownscaleAllByHalf;
_zoomDown = false;
_zoomUp = false;
} else {
// only active if running on a PocketPC
if (_scalerProc != DownscaleAllByHalf && _scalerProc != DownscaleHorizByHalf)
return;
if (_scalerProc == DownscaleAllByHalf) {
_saveToolbarZoom = _toolbarHandler.visible();
_toolbarHandler.setVisible(false);
// set zoom scaler
_scaleFactorYd = 1;
_scalerProc = DownscaleHorizByHalf;
}
_zoomUp = false;
_zoomDown = true;
}
// redraw whole screen
addDirtyRect(0, 0, 640, 480);
internUpdateScreen();
}
void WINCESdlGraphicsManager::swap_panel_visibility() {
//if (!_forcePanelInvisible && !_panelStateForced) {
if (_zoomDown || _zoomUp)
return;
if (_panelVisible) {
if (_toolbarHandler.activeName() == NAME_PANEL_KEYBOARD)
_panelVisible = !_panelVisible;
else
_toolbarHandler.setActive(NAME_PANEL_KEYBOARD);
} else {
_toolbarHandler.setActive(NAME_MAIN_PANEL);
_panelVisible = !_panelVisible;
}
_toolbarHandler.setVisible(_panelVisible);
_toolbarHighDrawn = false;
if (_videoMode.screenHeight > 240)
addDirtyRect(0, 400, 640, 80);
else
addDirtyRect(0, 200, 320, 40);
if (_toolbarHandler.activeName() == NAME_PANEL_KEYBOARD && _panelVisible)
internUpdateScreen();
else {
update_scalers();
hotswapGFXMode();
}
//}
}
void OSystem_SDL::updateScreen() {
assert (_transactionMode == kTransactionNone);
Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
internUpdateScreen();
}
bool WINCESdlGraphicsManager::hotswapGFXMode() {
if (!_screen)
return false;
// Keep around the old _screen & _tmpscreen so we can restore the screen data
// after the mode switch. (also for the overlay)
SDL_Surface *old_screen = _screen;
SDL_Surface *old_tmpscreen = _tmpscreen;
SDL_Surface *old_overlayscreen = _overlayscreen;
SDL_Surface *old_tmpscreen2 = _tmpscreen2;
// Release the HW screen surface
SDL_FreeSurface(_hwscreen);
// Release toolbars
free(_toolbarLow->pixels);
SDL_FreeSurface(_toolbarLow);
if (_toolbarHigh) {
free(_toolbarHigh->pixels);
SDL_FreeSurface(_toolbarHigh);
}
// Setup the new GFX mode
if (!loadGFXMode()) {
unloadGFXMode();
_screen = old_screen;
_overlayscreen = old_overlayscreen;
return false;
}
// reset palette
SDL_SetColors(_screen, _currentPalette, 0, 256);
// Restore old screen content
SDL_BlitSurface(old_screen, NULL, _screen, NULL);
SDL_BlitSurface(old_tmpscreen, NULL, _tmpscreen, NULL);
if (_overlayVisible) {
SDL_BlitSurface(old_overlayscreen, NULL, _overlayscreen, NULL);
SDL_BlitSurface(old_tmpscreen2, NULL, _tmpscreen2, NULL);
}
// Free the old surfaces
SDL_FreeSurface(old_screen);
SDL_FreeSurface(old_tmpscreen);
SDL_FreeSurface(old_overlayscreen);
SDL_FreeSurface(old_tmpscreen2);
// Blit everything back to the screen
_toolbarHighDrawn = false;
internUpdateScreen();
// Make sure that a Common::EVENT_SCREEN_CHANGED gets sent later -> FIXME this crashes when no game has been loaded.
// _modeChanged = true;
return true;
}
void WINCESdlGraphicsManager::swap_smartphone_keyboard() {
_toolbarHandler.setActive(NAME_PANEL_KEYBOARD);
_panelVisible = !_panelVisible;
_toolbarHandler.setVisible(_panelVisible);
if (_videoMode.screenHeight > 240)
addDirtyRect(0, 0, 640, 80);
else
addDirtyRect(0, 0, 320, 40);
internUpdateScreen();
}
void OSystem_IPHONE::updateScreen() {
//printf("updateScreen(): %i dirty rects.\n", _dirtyRects.size());
if (_dirtyRects.size() == 0 && _dirtyOverlayRects.size() == 0 && !_mouseDirty)
return;
internUpdateScreen();
_fullScreenIsDirty = false;
_fullScreenOverlayIsDirty = false;
iPhone_updateScreen(_mouseX - _mouseHotspotX, _mouseY - _mouseHotspotY);
}
void OSystem_SDL::hotswapGFXMode() {
if (!_screen)
return;
// Keep around the old _screen & _overlayscreen so we can restore the screen data
// after the mode switch.
SDL_Surface *old_screen = _screen;
SDL_Surface *old_overlayscreen = _overlayscreen;
// Release the HW screen surface
SDL_FreeSurface(_hwscreen);
SDL_FreeSurface(_tmpscreen);
SDL_FreeSurface(_tmpscreen2);
#ifdef USE_OSD
// Release the OSD surface
SDL_FreeSurface(_osdSurface);
#endif
// Setup the new GFX mode
loadGFXMode();
// reset palette
SDL_SetColors(_screen, _currentPalette, 0, 256);
// Restore old screen content
SDL_BlitSurface(old_screen, NULL, _screen, NULL);
SDL_BlitSurface(old_overlayscreen, NULL, _overlayscreen, NULL);
// Free the old surfaces
SDL_FreeSurface(old_screen);
SDL_FreeSurface(old_overlayscreen);
// Update cursor to new scale
blitCursor();
// Blit everything to the screen
internUpdateScreen();
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
}
void OSystem_SDL::endGFXTransaction(void) {
// for each engine we run initCommonGFX() as first thing in the transaction
// and initSize() is called later. If user runs launcher at 320x200 with
// 2x overlay, setting to Nomral1x sclaler in that case will be suppressed
// and backend is forced to 2x
//
// This leads to bad results such as 1280x960 window for 640x480 engines.
// To prevent that we rerun setGraphicsMode() if there was 1x scaler request
if (_transactionDetails.normal1xScaler)
setGraphicsMode(GFX_NORMAL);
assert (_transactionMode == kTransactionActive);
_transactionMode = kTransactionCommit;
if (_transactionDetails.modeChanged)
setGraphicsMode(_transactionDetails.mode);
if (_transactionDetails.sizeChanged)
initSize(_transactionDetails.w, _transactionDetails.h);
if (_transactionDetails.arChanged)
setAspectRatioCorrection(_transactionDetails.ar);
if (_transactionDetails.needUnload) {
unloadGFXMode();
loadGFXMode();
clearOverlay();
} else {
if (!_transactionDetails.fsChanged) {
if (_transactionDetails.needHotswap)
hotswapGFXMode();
else if (_transactionDetails.needUpdatescreen)
internUpdateScreen();
}
}
if (_transactionDetails.fsChanged)
setFullscreenMode(_transactionDetails.fs);
_transactionMode = kTransactionNone;
}
void OSystem_SDL::setFullscreenMode(bool enable) {
Common::StackLock lock(_graphicsMutex);
if (_fullscreen != enable || _transactionMode == kTransactionCommit) {
assert(_hwscreen != 0);
_fullscreen = enable;
if (_transactionMode == kTransactionActive) {
_transactionDetails.fs = enable;
_transactionDetails.fsChanged = true;
_transactionDetails.needHotswap = true;
return;
}
#if (defined(MACOSX) && !SDL_VERSION_ATLEAST(1, 2, 6)) || defined(__MAEMO__)
// On OS X, SDL_WM_ToggleFullScreen is currently not implemented. Worse,
// before SDL 1.2.6 it always returned -1 (which would indicate a
// successful switch). So we simply don't call it at all and use
// hotswapGFXMode() directly to switch to fullscreen mode.
hotswapGFXMode();
#else
if (!SDL_WM_ToggleFullScreen(_hwscreen)) {
// if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode
hotswapGFXMode();
} else {
// Blit everything to the screen
internUpdateScreen();
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
}
#endif
}
}
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 TizenGraphicsManager::updateScreen() {
if (_transactionMode == kTransactionNone) {
internUpdateScreen();
}
}
bool OSystem_SDL::setGraphicsMode(int mode) {
Common::StackLock lock(_graphicsMutex);
int newScaleFactor = 1;
ScalerProc *newScalerProc;
switch(mode) {
case GFX_NORMAL:
newScaleFactor = 1;
newScalerProc = Normal1x;
break;
#ifndef DISABLE_SCALERS
case GFX_DOUBLESIZE:
newScaleFactor = 2;
newScalerProc = Normal2x;
break;
case GFX_TRIPLESIZE:
newScaleFactor = 3;
newScalerProc = Normal3x;
break;
case GFX_2XSAI:
newScaleFactor = 2;
newScalerProc = _2xSaI;
break;
case GFX_SUPER2XSAI:
newScaleFactor = 2;
newScalerProc = Super2xSaI;
break;
case GFX_SUPEREAGLE:
newScaleFactor = 2;
newScalerProc = SuperEagle;
break;
case GFX_ADVMAME2X:
newScaleFactor = 2;
newScalerProc = AdvMame2x;
break;
case GFX_ADVMAME3X:
newScaleFactor = 3;
newScalerProc = AdvMame3x;
break;
#ifndef DISABLE_HQ_SCALERS
case GFX_HQ2X:
newScaleFactor = 2;
newScalerProc = HQ2x;
break;
case GFX_HQ3X:
newScaleFactor = 3;
newScalerProc = HQ3x;
break;
#endif
case GFX_TV2X:
newScaleFactor = 2;
newScalerProc = TV2x;
break;
case GFX_DOTMATRIX:
newScaleFactor = 2;
newScalerProc = DotMatrix;
break;
#endif // DISABLE_SCALERS
default:
warning("unknown gfx mode %d", mode);
return false;
}
_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
_mode = mode;
_scalerProc = newScalerProc;
if (_transactionMode == kTransactionActive) {
_transactionDetails.mode = mode;
_transactionDetails.modeChanged = true;
if (newScaleFactor != _scaleFactor) {
_transactionDetails.needHotswap = true;
_scaleFactor = newScaleFactor;
}
_transactionDetails.needUpdatescreen = true;
return true;
}
// NOTE: This should not be executed at transaction commit
// Otherwise there is some unsolicited setGraphicsMode() call
// which should be properly removed
if (newScaleFactor != _scaleFactor) {
assert(_transactionMode != kTransactionCommit);
_scaleFactor = newScaleFactor;
hotswapGFXMode();
}
// Determine the "scaler type", i.e. essentially an index into the
// s_gfxModeSwitchTable array defined in events.cpp.
if (_mode != GFX_NORMAL) {
for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
if (s_gfxModeSwitchTable[i][1] == _mode || s_gfxModeSwitchTable[i][2] == _mode) {
_scalerType = i;
break;
}
}
}
if (!_screen)
return true;
// Blit everything to the screen
_forceFull = true;
// Even if the old and new scale factors are the same, we may have a
// different scaler for the cursor now.
blitCursor();
if (_transactionMode != kTransactionCommit)
internUpdateScreen();
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
return true;
}
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);
}
