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
}
// Mode methods
void Window::setMode() {
if (_isFullScreen) {
setFullscreenMode();
} else {
setNormalMode();
}
}
void OpenGLSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
switch (f) {
case OSystem::kFeatureFullscreenMode:
setFullscreenMode(enable);
break;
case OSystem::kFeatureIconifyWindow:
if (enable)
SDL_WM_IconifyWindow();
break;
default:
OpenGLGraphicsManager::setFeatureState(f, enable);
}
}
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::setFeatureState(Feature f, bool enable) {
switch (f) {
case kFeatureFullscreenMode:
setFullscreenMode(enable);
break;
case kFeatureAspectRatioCorrection:
setAspectRatioCorrection(enable);
break;
case kFeatureAutoComputeDirtyRects:
if (enable)
_modeFlags |= DF_WANT_RECT_OPTIM;
else
_modeFlags &= ~DF_WANT_RECT_OPTIM;
break;
case kFeatureIconifyWindow:
if (enable)
SDL_WM_IconifyWindow();
break;
default:
break;
}
}
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;
}
