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 WINCESdlGraphicsManager::update_game_settings() {
Common::String gameid(ConfMan.get("gameid"));
// Finish panel initialization
if (!_panelInitialized && !gameid.empty()) {
CEGUI::Panel *panel;
_panelInitialized = true;
// Add the main panel
panel = new CEGUI::Panel(0, 32);
panel->setBackground(IMAGE_PANEL);
// Save
panel->add(NAME_ITEM_OPTIONS, new CEGUI::ItemAction(ITEM_OPTIONS, POCKET_ACTION_SAVE));
// Skip
panel->add(NAME_ITEM_SKIP, new CEGUI::ItemAction(ITEM_SKIP, POCKET_ACTION_SKIP));
// sound
panel->add(NAME_ITEM_SOUND, new CEGUI::ItemSwitch(ITEM_SOUND_OFF, ITEM_SOUND_ON, &OSystem_WINCE3::_soundMaster));
// bind keys
panel->add(NAME_ITEM_BINDKEYS, new CEGUI::ItemAction(ITEM_BINDKEYS, POCKET_ACTION_BINDKEYS));
// portrait/landscape - screen dependent
// FIXME : will still display the portrait/landscape icon when using a scaler (but will be disabled)
if (ConfMan.hasKey("landscape")) {
if (ConfMan.get("landscape")[0] > 57) {
_newOrientation = _orientationLandscape = ConfMan.getBool("landscape");
//ConfMan.removeKey("landscape", "");
ConfMan.setInt("landscape", _orientationLandscape);
} else
_newOrientation = _orientationLandscape = ConfMan.getInt("landscape");
} else {
_newOrientation = _orientationLandscape = 0;
}
panel->add(NAME_ITEM_ORIENTATION, new CEGUI::ItemSwitch(ITEM_VIEW_LANDSCAPE, ITEM_VIEW_PORTRAIT, &_newOrientation, 2));
_toolbarHandler.add(NAME_MAIN_PANEL, *panel);
_toolbarHandler.setActive(NAME_MAIN_PANEL);
_toolbarHandler.setVisible(true);
if (_videoMode.mode == GFX_NORMAL && ConfMan.hasKey("landscape") && ConfMan.getInt("landscape")) {
setGraphicsMode(GFX_NORMAL);
hotswapGFXMode();
}
if (_hasSmartphoneResolution)
panel->setVisible(false);
_saveToolbarState = true;
}
if (ConfMan.hasKey("no_doubletap_rightclick"))
_noDoubleTapRMB = ConfMan.getBool("no_doubletap_rightclick");
if (ConfMan.hasKey("no_doubletap_paneltoggle"))
_noDoubleTapPT = ConfMan.getBool("no_doubletap_paneltoggle");
}
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
}
}
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 WINCESdlGraphicsManager::swap_panel() {
_toolbarHighDrawn = false;
//if (!_panelStateForced) {
if (_toolbarHandler.activeName() == NAME_PANEL_KEYBOARD && _panelVisible)
_toolbarHandler.setActive(NAME_MAIN_PANEL);
else
_toolbarHandler.setActive(NAME_PANEL_KEYBOARD);
if (_videoMode.screenHeight > 240)
addDirtyRect(0, 400, 640, 80);
else
addDirtyRect(0, 200, 320, 40);
_toolbarHandler.setVisible(true);
if (!_panelVisible) {
_panelVisible = true;
update_scalers();
hotswapGFXMode();
}
//}
}
void OSystem_SDL::setAspectRatioCorrection(bool enable) {
if ((_screenHeight == 200 && _adjustAspectRatio != enable) ||
_transactionMode == kTransactionCommit) {
Common::StackLock lock(_graphicsMutex);
//assert(_hwscreen != 0);
_adjustAspectRatio = enable;
if (_transactionMode == kTransactionActive) {
_transactionDetails.ar = enable;
_transactionDetails.arChanged = true;
_transactionDetails.needHotswap = true;
return;
} else {
if (_transactionMode != kTransactionCommit)
hotswapGFXMode();
}
// Make sure that an EVENT_SCREEN_CHANGED gets sent later
_modeChanged = true;
}
}
void WINCESdlGraphicsManager::smartphone_rotate_display() {
_orientationLandscape = _newOrientation = _orientationLandscape == 1 ? 2 : 1;
ConfMan.setInt("landscape", _orientationLandscape);
ConfMan.flushToDisk();
hotswapGFXMode();
}
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;
}
