Merge remote branch 'upstream/master' into pegasus

20 files changed, 214 insertions, 185 deletions

diff --git a/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp b/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp
index 8a141e97a5..8075d0d45b 100644
--- a/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp
+++ b/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp
@@ -36,7 +36,7 @@ static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
 };
 
 DINGUXSdlGraphicsManager::DINGUXSdlGraphicsManager(SdlEventSource *boss)
-	: SdlGraphicsManager(boss) {
+	: SurfaceSdlGraphicsManager(boss) {
 }
 
 const OSystem::GraphicsMode *DINGUXSdlGraphicsManager::getSupportedGraphicsModes() const {
@@ -415,7 +415,7 @@ void DINGUXSdlGraphicsManager::showOverlay() {
 		_mouseCurState.x = _mouseCurState.x / 2;
 		_mouseCurState.y = _mouseCurState.y / 2;
 	}
-	SdlGraphicsManager::showOverlay();
+	SurfaceSdlGraphicsManager::showOverlay();
 }
 
 void DINGUXSdlGraphicsManager::hideOverlay() {
@@ -423,7 +423,7 @@ void DINGUXSdlGraphicsManager::hideOverlay() {
 		_mouseCurState.x = _mouseCurState.x * 2;
 		_mouseCurState.y = _mouseCurState.y * 2;
 	}
-	SdlGraphicsManager::hideOverlay();
+	SurfaceSdlGraphicsManager::hideOverlay();
 }
 
 bool DINGUXSdlGraphicsManager::loadGFXMode() {
@@ -462,7 +462,7 @@ bool DINGUXSdlGraphicsManager::loadGFXMode() {
 	}
 
 
-	return SdlGraphicsManager::loadGFXMode();
+	return SurfaceSdlGraphicsManager::loadGFXMode();
 }
 
 bool DINGUXSdlGraphicsManager::hasFeature(OSystem::Feature f) {
@@ -492,11 +492,11 @@ bool DINGUXSdlGraphicsManager::getFeatureState(OSystem::Feature f) {
 	}
 }
 
-SdlGraphicsManager::MousePos* DINGUXSdlGraphicsManager::getMouseCurState() {
+SurfaceSdlGraphicsManager::MousePos *DINGUXSdlGraphicsManager::getMouseCurState() {
 	return &_mouseCurState;
 }
 
-SdlGraphicsManager::VideoState* DINGUXSdlGraphicsManager::getVideoMode() {
+SurfaceSdlGraphicsManager::VideoState *DINGUXSdlGraphicsManager::getVideoMode() {
 	return &_videoMode;
 }
 
@@ -507,7 +507,7 @@ void DINGUXSdlGraphicsManager::warpMouse(int x, int y) {
 			y = y / 2;
 		}
 	}
-	SdlGraphicsManager::warpMouse(x, y);
+	SurfaceSdlGraphicsManager::warpMouse(x, y);
 }
 
 void DINGUXSdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
diff --git a/backends/graphics/dinguxsdl/dinguxsdl-graphics.h b/backends/graphics/dinguxsdl/dinguxsdl-graphics.h
index 9fb1170503..84a784b771 100644
--- a/backends/graphics/dinguxsdl/dinguxsdl-graphics.h
+++ b/backends/graphics/dinguxsdl/dinguxsdl-graphics.h
@@ -23,16 +23,16 @@
 #ifndef BACKENDS_GRAPHICS_SDL_DINGUX_H
 #define BACKENDS_GRAPHICS_SDL_DINGUX_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 
-#include "graphics/scaler/aspect.h"	// for aspect2Real 
+#include "graphics/scaler/aspect.h"	// for aspect2Real
 #include "graphics/scaler/downscaler.h"
 
 enum {
 	GFX_HALF = 12
 };
 
-class DINGUXSdlGraphicsManager : public SdlGraphicsManager {
+class DINGUXSdlGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	DINGUXSdlGraphicsManager(SdlEventSource *boss);
 
@@ -54,8 +54,8 @@ public:
 	void undrawMouse();
 	virtual void warpMouse(int x, int y);
 
-	SdlGraphicsManager::MousePos *getMouseCurState();
-	SdlGraphicsManager::VideoState *getVideoMode();
+	SurfaceSdlGraphicsManager::MousePos *getMouseCurState();
+	SurfaceSdlGraphicsManager::VideoState *getVideoMode();
 
 	virtual void adjustMouseEvent(const Common::Event &event);
 };
diff --git a/backends/graphics/gph/gph-graphics.cpp b/backends/graphics/gph/gph-graphics.cpp
index eb748f2fc2..82a32203fb 100644
--- a/backends/graphics/gph/gph-graphics.cpp
+++ b/backends/graphics/gph/gph-graphics.cpp
@@ -36,7 +36,7 @@ static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
 };
 
 GPHGraphicsManager::GPHGraphicsManager(SdlEventSource *sdlEventSource)
- : SdlGraphicsManager(sdlEventSource) {
+ : SurfaceSdlGraphicsManager(sdlEventSource) {
 }
 
 const OSystem::GraphicsMode *GPHGraphicsManager::getSupportedGraphicsModes() const {
@@ -443,7 +443,7 @@ void GPHGraphicsManager::showOverlay() {
 		_mouseCurState.x = _mouseCurState.x / 2;
 		_mouseCurState.y = _mouseCurState.y / 2;
 	}
-	SdlGraphicsManager::showOverlay();
+	SurfaceSdlGraphicsManager::showOverlay();
 }
 
 void GPHGraphicsManager::hideOverlay() {
@@ -451,7 +451,7 @@ void GPHGraphicsManager::hideOverlay() {
 		_mouseCurState.x = _mouseCurState.x * 2;
 		_mouseCurState.y = _mouseCurState.y * 2;
 	}
-	SdlGraphicsManager::hideOverlay();
+	SurfaceSdlGraphicsManager::hideOverlay();
 }
 
 
@@ -503,7 +503,7 @@ void GPHGraphicsManager::hideOverlay() {
 //
 //	}
 
-//	return SdlGraphicsManager::loadGFXMode();
+//	return SurfaceSdlGraphicsManager::loadGFXMode();
 //}
 
 bool GPHGraphicsManager::loadGFXMode() {
@@ -531,7 +531,7 @@ bool GPHGraphicsManager::loadGFXMode() {
 		_videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
 		_videoMode.hardwareHeight = effectiveScreenHeight();
 	}
-	return SdlGraphicsManager::loadGFXMode();
+	return SurfaceSdlGraphicsManager::loadGFXMode();
 }
 
 bool GPHGraphicsManager::hasFeature(OSystem::Feature f) {
@@ -561,11 +561,11 @@ bool GPHGraphicsManager::getFeatureState(OSystem::Feature f) {
 	}
 }
 
-SdlGraphicsManager::MousePos* GPHGraphicsManager::getMouseCurState() {
+SurfaceSdlGraphicsManager::MousePos *GPHGraphicsManager::getMouseCurState() {
 	return &_mouseCurState;
 }
 
-SdlGraphicsManager::VideoState* GPHGraphicsManager::getVideoMode() {
+SurfaceSdlGraphicsManager::VideoState *GPHGraphicsManager::getVideoMode() {
 	return &_videoMode;
 }
 
@@ -576,7 +576,7 @@ void GPHGraphicsManager::warpMouse(int x, int y) {
 			y = y / 2;
 		}
 	}
-	SdlGraphicsManager::warpMouse(x, y);
+	SurfaceSdlGraphicsManager::warpMouse(x, y);
 }
 
 void GPHGraphicsManager::adjustMouseEvent(const Common::Event &event) {
diff --git a/backends/graphics/gph/gph-graphics.h b/backends/graphics/gph/gph-graphics.h
index fc3dc5730d..45b8618569 100644
--- a/backends/graphics/gph/gph-graphics.h
+++ b/backends/graphics/gph/gph-graphics.h
@@ -23,7 +23,7 @@
 #ifndef BACKENDS_GRAPHICS_GPH_H
 #define BACKENDS_GRAPHICS_GPH_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 #include "graphics/scaler/aspect.h"	// for aspect2Real
 #include "graphics/scaler/downscaler.h"
 
@@ -31,7 +31,7 @@ enum {
 	GFX_HALF = 12
 };
 
-class GPHGraphicsManager : public SdlGraphicsManager {
+class GPHGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	GPHGraphicsManager(SdlEventSource *boss);
 
@@ -53,8 +53,8 @@ public:
 	void undrawMouse();
 	virtual void warpMouse(int x, int y);
 
-	SdlGraphicsManager::MousePos *getMouseCurState();
-	SdlGraphicsManager::VideoState *getVideoMode();
+	SurfaceSdlGraphicsManager::MousePos *getMouseCurState();
+	SurfaceSdlGraphicsManager::VideoState *getVideoMode();
 
 	virtual void adjustMouseEvent(const Common::Event &event);
 };
diff --git a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp
index 42db89ee33..732074b7e2 100644
--- a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp
+++ b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp
@@ -46,7 +46,7 @@ static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
 };
 
 LinuxmotoSdlGraphicsManager::LinuxmotoSdlGraphicsManager(SdlEventSource *sdlEventSource)
- : SdlGraphicsManager(sdlEventSource) {
+ : SurfaceSdlGraphicsManager(sdlEventSource) {
 }
 
 const OSystem::GraphicsMode *LinuxmotoSdlGraphicsManager::getSupportedGraphicsModes() const {
@@ -166,7 +166,7 @@ bool LinuxmotoSdlGraphicsManager::loadGFXMode() {
 		_videoMode.hardwareHeight = effectiveScreenHeight();
 	}
 
-	return SdlGraphicsManager::loadGFXMode();
+	return SurfaceSdlGraphicsManager::loadGFXMode();
 }
 
 void LinuxmotoSdlGraphicsManager::drawMouse() {
@@ -457,7 +457,7 @@ void LinuxmotoSdlGraphicsManager::showOverlay() {
 		_mouseCurState.x = _mouseCurState.x / 2;
 		_mouseCurState.y = _mouseCurState.y / 2;
 	}
-	SdlGraphicsManager::showOverlay();
+	SurfaceSdlGraphicsManager::showOverlay();
 }
 
 void LinuxmotoSdlGraphicsManager::hideOverlay() {
@@ -465,7 +465,7 @@ void LinuxmotoSdlGraphicsManager::hideOverlay() {
 		_mouseCurState.x = _mouseCurState.x * 2;
 		_mouseCurState.y = _mouseCurState.y * 2;
 	}
-	SdlGraphicsManager::hideOverlay();
+	SurfaceSdlGraphicsManager::hideOverlay();
 }
 
 void LinuxmotoSdlGraphicsManager::warpMouse(int x, int y) {
@@ -475,7 +475,7 @@ void LinuxmotoSdlGraphicsManager::warpMouse(int x, int y) {
 			y = y / 2;
 		}
 	}
-	SdlGraphicsManager::warpMouse(x, y);
+	SurfaceSdlGraphicsManager::warpMouse(x, y);
 }
 
 void LinuxmotoSdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
diff --git a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h
index c428f00447..938512f323 100644
--- a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h
+++ b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h
@@ -23,9 +23,9 @@
 #ifndef BACKENDS_GRAPHICS_SDL_LINUXMOTO_H
 #define BACKENDS_GRAPHICS_SDL_LINUXMOTO_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 
-class LinuxmotoSdlGraphicsManager : public SdlGraphicsManager {
+class LinuxmotoSdlGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	LinuxmotoSdlGraphicsManager(SdlEventSource *sdlEventSource);
 
diff --git a/backends/graphics/opengl/gltexture.cpp b/backends/graphics/opengl/gltexture.cpp
index 3d1027b44f..b7f5c90105 100644
--- a/backends/graphics/opengl/gltexture.cpp
+++ b/backends/graphics/opengl/gltexture.cpp
@@ -108,7 +108,7 @@ void GLTexture::refresh() {
 void GLTexture::allocBuffer(GLuint w, GLuint h) {
 	_realWidth = w;
 	_realHeight = h;
-	
+
 	if (w <= _textureWidth && h <= _textureHeight && !_refresh)
 		// Already allocated a sufficiently large buffer
 		return;
diff --git a/backends/graphics/opengl/opengl-graphics.cpp b/backends/graphics/opengl/opengl-graphics.cpp
index c0551de386..046be4c669 100644
--- a/backends/graphics/opengl/opengl-graphics.cpp
+++ b/backends/graphics/opengl/opengl-graphics.cpp
@@ -179,7 +179,7 @@ bool OpenGLGraphicsManager::setGraphicsMode(int mode) {
 }
 
 int OpenGLGraphicsManager::getGraphicsMode() const {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 	return _videoMode.mode;
 }
 
@@ -420,12 +420,12 @@ void OpenGLGraphicsManager::fillScreen(uint32 col) {
 }
 
 void OpenGLGraphicsManager::updateScreen() {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 	internUpdateScreen();
 }
 
 void OpenGLGraphicsManager::setShakePos(int shakeOffset) {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 	_shakePos = shakeOffset;
 }
 
@@ -440,7 +440,7 @@ void OpenGLGraphicsManager::clearFocusRectangle() {
 //
 
 void OpenGLGraphicsManager::showOverlay() {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 
 	if (_overlayVisible)
 		return;
@@ -451,7 +451,7 @@ void OpenGLGraphicsManager::showOverlay() {
 }
 
 void OpenGLGraphicsManager::hideOverlay() {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 
 	if (!_overlayVisible)
 		return;
@@ -483,7 +483,7 @@ void OpenGLGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
 }
 
 void OpenGLGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
-	assert (_transactionMode == kTransactionNone);
+	assert(_transactionMode == kTransactionNone);
 
 	if (_overlayTexture == NULL)
 		return;
@@ -642,7 +642,7 @@ void OpenGLGraphicsManager::setMouseCursor(const byte *buf, uint w, uint h, int
 
 void OpenGLGraphicsManager::setCursorPalette(const byte *colors, uint start, uint num) {
 	assert(colors);
-	
+
 	// Save the cursor palette
 	memcpy(_cursorPalette + start * 3, colors, num * 3);
 
@@ -1315,7 +1315,7 @@ bool OpenGLGraphicsManager::notifyEvent(const Common::Event &event) {
 bool OpenGLGraphicsManager::saveScreenshot(const char *filename) {
 	int width = _videoMode.hardwareWidth;
 	int height = _videoMode.hardwareHeight;
-	
+
 	// A line of a BMP image must have a size divisible by 4.
 	// We calculate the padding bytes needed here.
 	// Since we use a 3 byte per pixel mode, we can use width % 4 here, since
@@ -1358,7 +1358,7 @@ bool OpenGLGraphicsManager::saveScreenshot(const char *filename) {
 	out.writeUint32LE(0);
 	out.writeUint32LE(0);
 	out.writeUint32LE(0);
-	out.writeUint32LE(0); 
+	out.writeUint32LE(0);
 
 	// Write pixel data to BMP
 	out.write(pixels, lineSize * height);
@@ -1413,7 +1413,7 @@ void OpenGLGraphicsManager::updateOSD() {
 	int dstX = (_osdSurface.w - width) / 2;
 	int dstY = (_osdSurface.h - height) / 2;
 
-	// Draw a dark gray rect
+	// Draw a dark gray rect (R = 40, G = 40, B = 40)
 	const uint16 color = 0x294B;
 	_osdSurface.fillRect(Common::Rect(dstX, dstY, dstX + width, dstY + height), color);
 
@@ -1423,9 +1423,9 @@ void OpenGLGraphicsManager::updateOSD() {
 		                 dstX, dstY + i * lineHeight + vOffset + lineSpacing, width,
 		                 0xFFFF, Graphics::kTextAlignCenter);
 	}
- 
+
 	// Update the texture
-	_osdTexture->updateBuffer(_osdSurface.pixels, _osdSurface.pitch, 0, 0, 
+	_osdTexture->updateBuffer(_osdSurface.pixels, _osdSurface.pitch, 0, 0,
 	                          _osdSurface.w, _osdSurface.h);
 }
 #endif
diff --git a/backends/graphics/opengl/opengl-graphics.h b/backends/graphics/opengl/opengl-graphics.h
index 463715aad8..56f7d92a12 100644
--- a/backends/graphics/opengl/opengl-graphics.h
+++ b/backends/graphics/opengl/opengl-graphics.h
@@ -185,7 +185,7 @@ protected:
 
 	/**
 	 * Set the scale factor.
-	 * 
+	 *
 	 * This can only be used in a GFX transaction.
 	 *
 	 * @param newScale New scale factor.
@@ -332,7 +332,7 @@ protected:
 	GLTexture *_osdTexture;
 	Graphics::Surface _osdSurface;
 	uint8 _osdAlpha;
-	uint32 _osdFadeStartTime; 
+	uint32 _osdFadeStartTime;
 	bool _requireOSDUpdate;
 	enum {
 		kOSDFadeOutDelay = 2 * 1000,
diff --git a/backends/graphics/openglsdl/openglsdl-graphics.cpp b/backends/graphics/openglsdl/openglsdl-graphics.cpp
index 87457c3c08..bd7dd32e3b 100644
--- a/backends/graphics/openglsdl/openglsdl-graphics.cpp
+++ b/backends/graphics/openglsdl/openglsdl-graphics.cpp
@@ -54,6 +54,10 @@ OpenGLSdlGraphicsManager::OpenGLSdlGraphicsManager()
 	SDL_ShowCursor(SDL_DISABLE);
 
 	// Get desktop resolution
+	// TODO: In case the OpenGL manager is created *after* a plain SDL manager
+	// has been used, this will return the last setup graphics mode rather
+	// than the desktop resolution. We should really look into a way to
+	// properly retrieve the desktop resolution.
 	const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
 	if (videoInfo->current_w > 0 && videoInfo->current_h > 0) {
 		_desktopWidth = videoInfo->current_w;
@@ -110,16 +114,16 @@ void OpenGLSdlGraphicsManager::detectSupportedFormats() {
 	// use.
 	const Graphics::PixelFormat RGBList[] = {
 #if defined(ENABLE_32BIT)
-		Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0),	// RGBA8888
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0), // RGBA8888
 #ifndef USE_GLES
 		Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24), // ARGB8888
 #endif
-		Graphics::PixelFormat(3, 8, 8, 8, 0, 16, 8, 0, 0),	// RGB888
+		Graphics::PixelFormat(3, 8, 8, 8, 0, 16, 8, 0, 0),  // RGB888
 #endif
-		Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0),	// RGB565
-		Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0),	// RGB5551
-		Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0),	// RGB555
-		Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0),	// RGBA4444
+		Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0),  // RGB565
+		Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0),  // RGB5551
+		Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0),  // RGB555
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0),  // RGBA4444
 #ifndef USE_GLES
 		Graphics::PixelFormat(2, 4, 4, 4, 4, 8, 4, 0, 12)   // ARGB4444
 #endif
@@ -302,7 +306,7 @@ bool OpenGLSdlGraphicsManager::loadGFXMode() {
 
 		int screenAspectRatio = _videoMode.screenWidth * 10000 / _videoMode.screenHeight;
 		int desiredAspectRatio = getAspectRatio();
-	
+
 		// Do not downscale dimensions, only enlarge them if needed
 		if (screenAspectRatio > desiredAspectRatio)
 			_videoMode.hardwareHeight = (_videoMode.overlayWidth * 10000  + 5000) / desiredAspectRatio;
@@ -385,7 +389,7 @@ void OpenGLSdlGraphicsManager::internUpdateScreen() {
 	OpenGLGraphicsManager::internUpdateScreen();
 
 	// Swap OpenGL buffers
-	SDL_GL_SwapBuffers(); 
+	SDL_GL_SwapBuffers();
 }
 
 #ifdef USE_OSD
@@ -394,27 +398,27 @@ void OpenGLSdlGraphicsManager::displayModeChangedMsg() {
 	if (newModeName) {
 		const int scaleFactor = getScale();
 
-		char buffer[128];
-		sprintf(buffer, "%s: %s\n%d x %d -> %d x %d",
+		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(buffer);
+		displayMessageOnOSD(osdMessage.c_str());
 	}
 }
 void OpenGLSdlGraphicsManager::displayScaleChangedMsg() {
-	char buffer[128];
 	const int scaleFactor = getScale();
-	sprintf(buffer, "%s: x%d\n%d x %d -> %d x %d",
+	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(buffer);
+	displayMessageOnOSD(osdMessage.c_str());
 }
 #endif
 
@@ -450,18 +454,18 @@ void OpenGLSdlGraphicsManager::toggleFullScreen(int loop) {
 	_ignoreResizeFrames = 10;
 
 #ifdef USE_OSD
-	char buffer[128];
+	Common::String osdMessage;
 	if (getFullscreenMode())
-		sprintf(buffer, "%s\n%d x %d",
+		osdMessage = Common::String::format("%s\n%d x %d",
 			_("Fullscreen mode"),
 			_hwscreen->w, _hwscreen->h
 			);
 	else
-		sprintf(buffer, "%s\n%d x %d",
+		osdMessage = Common::String::format("%s\n%d x %d",
 			_("Windowed mode"),
 			_hwscreen->w, _hwscreen->h
 			);
-	displayMessageOnOSD(buffer);
+	displayMessageOnOSD(osdMessage.c_str());
 #endif
 }
 
@@ -478,19 +482,19 @@ bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
 
 			// Alt-S create a screenshot
 			if (event.kbd.keycode == 's') {
-				char filename[20];
+				Common::String filename;
 
 				for (int n = 0;; n++) {
 					SDL_RWops *file;
 
-					sprintf(filename, "scummvm%05d.bmp", n);
-					file = SDL_RWFromFile(filename, "r");
+					filename = Common::String::format("scummvm%05d.bmp", n);
+					file = SDL_RWFromFile(filename.c_str(), "r");
 					if (!file)
 						break;
 					SDL_RWclose(file);
 				}
-				if (saveScreenshot(filename))
-					debug("Saved screenshot '%s'", filename);
+				if (saveScreenshot(filename.c_str()))
+					debug("Saved screenshot '%s'", filename.c_str());
 				else
 					warning("Could not save screenshot");
 				return true;
@@ -511,18 +515,18 @@ bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
 					setFeatureState(OSystem::kFeatureAspectRatioCorrection, !getFeatureState(OSystem::kFeatureAspectRatioCorrection));
 				endGFXTransaction();
 #ifdef USE_OSD
-			char buffer[128];
+			Common::String osdMessage;
 			if (getFeatureState(OSystem::kFeatureAspectRatioCorrection))
-				sprintf(buffer, "%s\n%d x %d -> %d x %d",
-						_("Enabled aspect ratio correction"),
+				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
-				sprintf(buffer, "%s\n%d x %d -> %d x %d",
-						_("Disabled aspect ratio correction"),
+				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(buffer);
+			displayMessageOnOSD(osdMessage.c_str());
 #endif
 				internUpdateScreen();
 				return true;
@@ -557,7 +561,7 @@ bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
 					// 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 || 
+						if (_videoMode.screenWidth * factor > _desktopWidth ||
 							_videoMode.screenHeight * factor > _desktopHeight)
 							return false;
 
@@ -607,7 +611,7 @@ bool OpenGLSdlGraphicsManager::notifyEvent(const Common::Event &event) {
 		break;
 	case Common::EVENT_KEYUP:
 		return isHotkey(event);
-	// HACK: Handle special SDL 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:
diff --git a/backends/graphics/openpandora/op-graphics.cpp b/backends/graphics/openpandora/op-graphics.cpp
index c8617635a5..5f0301a0c8 100644
--- a/backends/graphics/openpandora/op-graphics.cpp
+++ b/backends/graphics/openpandora/op-graphics.cpp
@@ -32,7 +32,7 @@
 #include "common/textconsole.h"
 
 OPGraphicsManager::OPGraphicsManager(SdlEventSource *sdlEventSource)
-	: SdlGraphicsManager(sdlEventSource) {
+	: SurfaceSdlGraphicsManager(sdlEventSource) {
 }
 
 bool OPGraphicsManager::loadGFXMode() {
@@ -47,7 +47,7 @@ bool OPGraphicsManager::loadGFXMode() {
 	if (_videoMode.screenHeight != 200 && _videoMode.screenHeight != 400)
 		_videoMode.aspectRatioCorrection = false;
 
-	return SdlGraphicsManager::loadGFXMode();
+	return SurfaceSdlGraphicsManager::loadGFXMode();
 }
 
 #endif
diff --git a/backends/graphics/openpandora/op-graphics.h b/backends/graphics/openpandora/op-graphics.h
index 4bb89ca1e6..ed26df7475 100644
--- a/backends/graphics/openpandora/op-graphics.h
+++ b/backends/graphics/openpandora/op-graphics.h
@@ -23,7 +23,7 @@
 #ifndef BACKENDS_GRAPHICS_OP_H
 #define BACKENDS_GRAPHICS_OP_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 #include "graphics/scaler/aspect.h"	// for aspect2Real
 #include "graphics/scaler/downscaler.h"
 
@@ -31,7 +31,7 @@ enum {
 	GFX_HALF = 12
 };
 
-class OPGraphicsManager : public SdlGraphicsManager {
+class OPGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	OPGraphicsManager(SdlEventSource *sdlEventSource);
 
@@ -53,8 +53,8 @@ public:
 //	void undrawMouse();
 //	virtual void warpMouse(int x, int y);
 
-//	SdlGraphicsManager::MousePos *getMouseCurState();
-//	SdlGraphicsManager::VideoState *getVideoMode();
+//	SurfaceSdlGraphicsManager::MousePos *getMouseCurState();
+//	SurfaceSdlGraphicsManager::VideoState *getVideoMode();
 
 //	virtual void adjustMouseEvent(const Common::Event &event);
 };
diff --git a/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.cpp b/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.cpp
index f6832978a8..95e0875f55 100644
--- a/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.cpp
+++ b/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.cpp
@@ -29,7 +29,7 @@
 #include "backends/graphics/samsungtvsdl/samsungtvsdl-graphics.h"
 
 SamsungTVSdlGraphicsManager::SamsungTVSdlGraphicsManager(SdlEventSource *sdlEventSource)
-	: SdlGraphicsManager(sdlEventSource) {
+	: SurfaceSdlGraphicsManager(sdlEventSource) {
 }
 
 bool SamsungTVSdlGraphicsManager::hasFeature(OSystem::Feature f) {
@@ -41,7 +41,7 @@ bool SamsungTVSdlGraphicsManager::hasFeature(OSystem::Feature f) {
 void SamsungTVSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
 	switch (f) {
 	case OSystem::kFeatureAspectRatioCorrection:
-		SdlGraphicsManager::setFeatureState(f, enable);
+		SurfaceSdlGraphicsManager::setFeatureState(f, enable);
 		break;
 	default:
 		break;
@@ -51,7 +51,7 @@ void SamsungTVSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enabl
 bool SamsungTVSdlGraphicsManager::getFeatureState(OSystem::Feature f) {
 	switch (f) {
 	case OSystem::kFeatureAspectRatioCorrection:
-		return SdlGraphicsManager::getFeatureState(f);
+		return SurfaceSdlGraphicsManager::getFeatureState(f);
 	default:
 		return false;
 	}
diff --git a/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.h b/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.h
index dc65c3a696..2d0ff636f4 100644
--- a/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.h
+++ b/backends/graphics/samsungtvsdl/samsungtvsdl-graphics.h
@@ -25,9 +25,9 @@
 
 #if defined(SAMSUNGTV)
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 
-class SamsungTVSdlGraphicsManager : public SdlGraphicsManager {
+class SamsungTVSdlGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	SamsungTVSdlGraphicsManager(SdlEventSource *sdlEventSource);
 
diff --git a/backends/graphics/sdl/sdl-graphics.cpp b/backends/graphics/surfacesdl/surfacesdl-graphics.cpp
index 9063f55744..2d41ecead4 100644
--- a/backends/graphics/sdl/sdl-graphics.cpp
+++ b/backends/graphics/surfacesdl/surfacesdl-graphics.cpp
@@ -24,7 +24,7 @@
 
 #if defined(SDL_BACKEND)
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 #include "backends/events/sdl/sdl-events.h"
 #include "backends/platform/sdl/sdl.h"
 #include "common/config-manager.h"
@@ -120,7 +120,7 @@ static AspectRatio getDesiredAspectRatio() {
 }
 #endif
 
-SdlGraphicsManager::SdlGraphicsManager(SdlEventSource *sdlEventSource)
+SurfaceSdlGraphicsManager::SurfaceSdlGraphicsManager(SdlEventSource *sdlEventSource)
 	:
 	_sdlEventSource(sdlEventSource),
 #ifdef USE_OSD
@@ -195,7 +195,7 @@ SdlGraphicsManager::SdlGraphicsManager(SdlEventSource *sdlEventSource)
 #endif
 }
 
-SdlGraphicsManager::~SdlGraphicsManager() {
+SurfaceSdlGraphicsManager::~SurfaceSdlGraphicsManager() {
 	// Unregister the event observer
 	if (g_system->getEventManager()->getEventDispatcher() != NULL)
 		g_system->getEventManager()->getEventDispatcher()->unregisterObserver(this);
@@ -214,12 +214,12 @@ SdlGraphicsManager::~SdlGraphicsManager() {
 	free(_mouseData);
 }
 
-void SdlGraphicsManager::initEventObserver() {
+void SurfaceSdlGraphicsManager::initEventObserver() {
 	// Register the graphics manager as a event observer
 	g_system->getEventManager()->getEventDispatcher()->registerObserver(this, 10, false);
 }
 
-bool SdlGraphicsManager::hasFeature(OSystem::Feature f) {
+bool SurfaceSdlGraphicsManager::hasFeature(OSystem::Feature f) {
 	return
 		(f == OSystem::kFeatureFullscreenMode) ||
 		(f == OSystem::kFeatureAspectRatioCorrection) ||
@@ -227,7 +227,7 @@ bool SdlGraphicsManager::hasFeature(OSystem::Feature f) {
 		(f == OSystem::kFeatureIconifyWindow);
 }
 
-void SdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+void SurfaceSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
 	switch (f) {
 	case OSystem::kFeatureFullscreenMode:
 		setFullscreenMode(enable);
@@ -248,7 +248,7 @@ void SdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
 	}
 }
 
-bool SdlGraphicsManager::getFeatureState(OSystem::Feature f) {
+bool SurfaceSdlGraphicsManager::getFeatureState(OSystem::Feature f) {
 	assert(_transactionMode == kTransactionNone);
 
 	switch (f) {
@@ -263,23 +263,23 @@ bool SdlGraphicsManager::getFeatureState(OSystem::Feature f) {
 	}
 }
 
-const OSystem::GraphicsMode *SdlGraphicsManager::supportedGraphicsModes() {
+const OSystem::GraphicsMode *SurfaceSdlGraphicsManager::supportedGraphicsModes() {
 	return s_supportedGraphicsModes;
 }
 
-const OSystem::GraphicsMode *SdlGraphicsManager::getSupportedGraphicsModes() const {
+const OSystem::GraphicsMode *SurfaceSdlGraphicsManager::getSupportedGraphicsModes() const {
 	return s_supportedGraphicsModes;
 }
 
-int SdlGraphicsManager::getDefaultGraphicsMode() const {
+int SurfaceSdlGraphicsManager::getDefaultGraphicsMode() const {
 	return GFX_DOUBLESIZE;
 }
 
-void SdlGraphicsManager::resetGraphicsScale() {
+void SurfaceSdlGraphicsManager::resetGraphicsScale() {
 	setGraphicsMode(s_gfxModeSwitchTable[_scalerType][0]);
 }
 
-void SdlGraphicsManager::beginGFXTransaction() {
+void SurfaceSdlGraphicsManager::beginGFXTransaction() {
 	assert(_transactionMode == kTransactionNone);
 
 	_transactionMode = kTransactionActive;
@@ -297,7 +297,7 @@ void SdlGraphicsManager::beginGFXTransaction() {
 	_oldVideoMode = _videoMode;
 }
 
-OSystem::TransactionError SdlGraphicsManager::endGFXTransaction() {
+OSystem::TransactionError SurfaceSdlGraphicsManager::endGFXTransaction() {
 	int errors = OSystem::kTransactionSuccess;
 
 	assert(_transactionMode != kTransactionNone);
@@ -398,12 +398,12 @@ OSystem::TransactionError SdlGraphicsManager::endGFXTransaction() {
 }
 
 #ifdef USE_RGB_COLOR
-Common::List<Graphics::PixelFormat> SdlGraphicsManager::getSupportedFormats() const {
+Common::List<Graphics::PixelFormat> SurfaceSdlGraphicsManager::getSupportedFormats() const {
 	assert(!_supportedFormats.empty());
 	return _supportedFormats;
 }
 
-void SdlGraphicsManager::detectSupportedFormats() {
+void SurfaceSdlGraphicsManager::detectSupportedFormats() {
 
 	// Clear old list
 	_supportedFormats.clear();
@@ -487,7 +487,7 @@ void SdlGraphicsManager::detectSupportedFormats() {
 }
 #endif
 
-bool SdlGraphicsManager::setGraphicsMode(int mode) {
+bool SurfaceSdlGraphicsManager::setGraphicsMode(int mode) {
 	Common::StackLock lock(_graphicsMutex);
 
 	assert(_transactionMode == kTransactionActive);
@@ -557,7 +557,7 @@ bool SdlGraphicsManager::setGraphicsMode(int mode) {
 	return true;
 }
 
-void SdlGraphicsManager::setGraphicsModeIntern() {
+void SurfaceSdlGraphicsManager::setGraphicsModeIntern() {
 	Common::StackLock lock(_graphicsMutex);
 	ScalerProc *newScalerProc = 0;
 
@@ -630,12 +630,12 @@ void SdlGraphicsManager::setGraphicsModeIntern() {
 	blitCursor();
 }
 
-int SdlGraphicsManager::getGraphicsMode() const {
-	assert (_transactionMode == kTransactionNone);
+int SurfaceSdlGraphicsManager::getGraphicsMode() const {
+	assert(_transactionMode == kTransactionNone);
 	return _videoMode.mode;
 }
 
-void SdlGraphicsManager::initSize(uint w, uint h, const Graphics::PixelFormat *format) {
+void SurfaceSdlGraphicsManager::initSize(uint w, uint h, const Graphics::PixelFormat *format) {
 	assert(_transactionMode == kTransactionActive);
 
 #ifdef USE_RGB_COLOR
@@ -665,7 +665,7 @@ void SdlGraphicsManager::initSize(uint w, uint h, const Graphics::PixelFormat *f
 	_transactionDetails.sizeChanged = true;
 }
 
-int SdlGraphicsManager::effectiveScreenHeight() const {
+int SurfaceSdlGraphicsManager::effectiveScreenHeight() const {
 	return _videoMode.scaleFactor *
 				(_videoMode.aspectRatioCorrection
 					? real2Aspect(_videoMode.screenHeight)
@@ -713,7 +713,7 @@ static void fixupResolutionForAspectRatio(AspectRatio desiredAspectRatio, int &w
 	height = bestMode->h;
 }
 
-bool SdlGraphicsManager::loadGFXMode() {
+bool SurfaceSdlGraphicsManager::loadGFXMode() {
 	_forceFull = true;
 
 #if !defined(__MAEMO__) && !defined(DINGUX) && !defined(GPH_DEVICE) && !defined(LINUXMOTO) && !defined(OPENPANDORA)
@@ -752,6 +752,12 @@ bool SdlGraphicsManager::loadGFXMode() {
 		error("allocating _screen failed");
 #endif
 
+	// SDL 1.2 palettes default to all black,
+	// SDL 1.3 palettes default to all white,
+	// Thus set our own default palette to all black.
+	// SDL_SetColors does nothing for non indexed surfaces.
+	SDL_SetColors(_screen, _currentPalette, 0, 256);
+
 	//
 	// Create the surface that contains the scaled graphics in 16 bit mode
 	//
@@ -853,7 +859,7 @@ bool SdlGraphicsManager::loadGFXMode() {
 	return true;
 }
 
-void SdlGraphicsManager::unloadGFXMode() {
+void SurfaceSdlGraphicsManager::unloadGFXMode() {
 	if (_screen) {
 		SDL_FreeSurface(_screen);
 		_screen = NULL;
@@ -888,7 +894,7 @@ void SdlGraphicsManager::unloadGFXMode() {
 	DestroyScalers();
 }
 
-bool SdlGraphicsManager::hotswapGFXMode() {
+bool SurfaceSdlGraphicsManager::hotswapGFXMode() {
 	if (!_screen)
 		return false;
 
@@ -940,15 +946,15 @@ bool SdlGraphicsManager::hotswapGFXMode() {
 	return true;
 }
 
-void SdlGraphicsManager::updateScreen() {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::updateScreen() {
+	assert(_transactionMode == kTransactionNone);
 
 	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
 
 	internUpdateScreen();
 }
 
-void SdlGraphicsManager::internUpdateScreen() {
+void SurfaceSdlGraphicsManager::internUpdateScreen() {
 	SDL_Surface *srcSurf, *origSurf;
 	int height, width;
 	ScalerProc *scalerProc;
@@ -1191,14 +1197,14 @@ void SdlGraphicsManager::internUpdateScreen() {
 	_mouseNeedsRedraw = false;
 }
 
-bool SdlGraphicsManager::saveScreenshot(const char *filename) {
+bool SurfaceSdlGraphicsManager::saveScreenshot(const char *filename) {
 	assert(_hwscreen != NULL);
 
 	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
 	return SDL_SaveBMP(_hwscreen, filename) == 0;
 }
 
-void SdlGraphicsManager::setFullscreenMode(bool enable) {
+void SurfaceSdlGraphicsManager::setFullscreenMode(bool enable) {
 	Common::StackLock lock(_graphicsMutex);
 
 	if (_oldVideoMode.setup && _oldVideoMode.fullscreen == enable)
@@ -1210,7 +1216,7 @@ void SdlGraphicsManager::setFullscreenMode(bool enable) {
 	}
 }
 
-void SdlGraphicsManager::setAspectRatioCorrection(bool enable) {
+void SurfaceSdlGraphicsManager::setAspectRatioCorrection(bool enable) {
 	Common::StackLock lock(_graphicsMutex);
 
 	if (_oldVideoMode.setup && _oldVideoMode.aspectRatioCorrection == enable)
@@ -1222,12 +1228,12 @@ void SdlGraphicsManager::setAspectRatioCorrection(bool enable) {
 	}
 }
 
-void SdlGraphicsManager::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) {
+	assert(_transactionMode == kTransactionNone);
 	assert(src);
 
 	if (_screen == NULL) {
-		warning("SdlGraphicsManager::copyRectToScreen: _screen == NULL");
+		warning("SurfaceSdlGraphicsManager::copyRectToScreen: _screen == NULL");
 		return;
 	}
 
@@ -1272,8 +1278,8 @@ void SdlGraphicsManager::copyRectToScreen(const byte *src, int pitch, int x, int
 	SDL_UnlockSurface(_screen);
 }
 
-Graphics::Surface *SdlGraphicsManager::lockScreen() {
-	assert (_transactionMode == kTransactionNone);
+Graphics::Surface *SurfaceSdlGraphicsManager::lockScreen() {
+	assert(_transactionMode == kTransactionNone);
 
 	// Lock the graphics mutex
 	g_system->lockMutex(_graphicsMutex);
@@ -1299,8 +1305,8 @@ Graphics::Surface *SdlGraphicsManager::lockScreen() {
 	return &_framebuffer;
 }
 
-void SdlGraphicsManager::unlockScreen() {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::unlockScreen() {
+	assert(_transactionMode == kTransactionNone);
 
 	// paranoia check
 	assert(_screenIsLocked);
@@ -1316,14 +1322,14 @@ void SdlGraphicsManager::unlockScreen() {
 	g_system->unlockMutex(_graphicsMutex);
 }
 
-void SdlGraphicsManager::fillScreen(uint32 col) {
+void SurfaceSdlGraphicsManager::fillScreen(uint32 col) {
 	Graphics::Surface *screen = lockScreen();
 	if (screen && screen->pixels)
 		memset(screen->pixels, col, screen->h * screen->pitch);
 	unlockScreen();
 }
 
-void SdlGraphicsManager::addDirtyRect(int x, int y, int w, int h, bool realCoordinates) {
+void SurfaceSdlGraphicsManager::addDirtyRect(int x, int y, int w, int h, bool realCoordinates) {
 	if (_forceFull)
 		return;
 
@@ -1391,15 +1397,15 @@ void SdlGraphicsManager::addDirtyRect(int x, int y, int w, int h, bool realCoord
 	}
 }
 
-int16 SdlGraphicsManager::getHeight() {
+int16 SurfaceSdlGraphicsManager::getHeight() {
 	return _videoMode.screenHeight;
 }
 
-int16 SdlGraphicsManager::getWidth() {
+int16 SurfaceSdlGraphicsManager::getWidth() {
 	return _videoMode.screenWidth;
 }
 
-void SdlGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
+void SurfaceSdlGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
 	assert(colors);
 
 #ifdef USE_RGB_COLOR
@@ -1411,7 +1417,7 @@ void SdlGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
 	// But it could indicate a programming error, so let's warn about it.
 
 	if (!_screen)
-		warning("SdlGraphicsManager::setPalette: _screen == NULL");
+		warning("SurfaceSdlGraphicsManager::setPalette: _screen == NULL");
 
 	const byte *b = colors;
 	uint i;
@@ -1433,7 +1439,7 @@ void SdlGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
 		blitCursor();
 }
 
-void SdlGraphicsManager::grabPalette(byte *colors, uint start, uint num) {
+void SurfaceSdlGraphicsManager::grabPalette(byte *colors, uint start, uint num) {
 	assert(colors);
 
 #ifdef USE_RGB_COLOR
@@ -1449,7 +1455,7 @@ void SdlGraphicsManager::grabPalette(byte *colors, uint start, uint num) {
 	}
 }
 
-void SdlGraphicsManager::setCursorPalette(const byte *colors, uint start, uint num) {
+void SurfaceSdlGraphicsManager::setCursorPalette(const byte *colors, uint start, uint num) {
 	assert(colors);
 	const byte *b = colors;
 	uint i;
@@ -1464,13 +1470,13 @@ void SdlGraphicsManager::setCursorPalette(const byte *colors, uint start, uint n
 	blitCursor();
 }
 
-void SdlGraphicsManager::setShakePos(int shake_pos) {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::setShakePos(int shake_pos) {
+	assert(_transactionMode == kTransactionNone);
 
 	_newShakePos = shake_pos;
 }
 
-void SdlGraphicsManager::setFocusRectangle(const Common::Rect &rect) {
+void SurfaceSdlGraphicsManager::setFocusRectangle(const Common::Rect &rect) {
 #ifdef USE_SDL_DEBUG_FOCUSRECT
 	// Only enable focus rectangle debug code, when the user wants it
 	if (!_enableFocusRectDebugCode)
@@ -1480,7 +1486,7 @@ void SdlGraphicsManager::setFocusRectangle(const Common::Rect &rect) {
 	_focusRect = rect;
 
 	if (rect.left < 0 || rect.top < 0 || rect.right > _videoMode.screenWidth || rect.bottom > _videoMode.screenHeight)
-		warning("SdlGraphicsManager::setFocusRectangle: Got a rect which does not fit inside the screen bounds: %d,%d,%d,%d", rect.left, rect.top, rect.right, rect.bottom);
+		warning("SurfaceSdlGraphicsManager::setFocusRectangle: Got a rect which does not fit inside the screen bounds: %d,%d,%d,%d", rect.left, rect.top, rect.right, rect.bottom);
 
 	// It's gross but we actually sometimes get rects, which are not inside the screen bounds,
 	// thus we need to clip the rect here...
@@ -1492,7 +1498,7 @@ void SdlGraphicsManager::setFocusRectangle(const Common::Rect &rect) {
 #endif
 }
 
-void SdlGraphicsManager::clearFocusRectangle() {
+void SurfaceSdlGraphicsManager::clearFocusRectangle() {
 #ifdef USE_SDL_DEBUG_FOCUSRECT
 	// Only enable focus rectangle debug code, when the user wants it
 	if (!_enableFocusRectDebugCode)
@@ -1510,8 +1516,8 @@ void SdlGraphicsManager::clearFocusRectangle() {
 #pragma mark --- Overlays ---
 #pragma mark -
 
-void SdlGraphicsManager::showOverlay() {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::showOverlay() {
+	assert(_transactionMode == kTransactionNone);
 
 	int x, y;
 
@@ -1533,8 +1539,8 @@ void SdlGraphicsManager::showOverlay() {
 	clearOverlay();
 }
 
-void SdlGraphicsManager::hideOverlay() {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::hideOverlay() {
+	assert(_transactionMode == kTransactionNone);
 
 	if (!_overlayVisible)
 		return;
@@ -1557,8 +1563,8 @@ void SdlGraphicsManager::hideOverlay() {
 	_forceFull = true;
 }
 
-void SdlGraphicsManager::clearOverlay() {
-	//assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::clearOverlay() {
+	//assert(_transactionMode == kTransactionNone);
 
 	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
 
@@ -1590,8 +1596,8 @@ void SdlGraphicsManager::clearOverlay() {
 	_forceFull = true;
 }
 
-void SdlGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
+	assert(_transactionMode == kTransactionNone);
 
 	if (_overlayscreen == NULL)
 		return;
@@ -1610,8 +1616,8 @@ void SdlGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
 	SDL_UnlockSurface(_overlayscreen);
 }
 
-void SdlGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+	assert(_transactionMode == kTransactionNone);
 
 	if (_overlayscreen == NULL)
 		return;
@@ -1660,7 +1666,7 @@ void SdlGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, i
 #pragma mark --- Mouse ---
 #pragma mark -
 
-bool SdlGraphicsManager::showMouse(bool visible) {
+bool SurfaceSdlGraphicsManager::showMouse(bool visible) {
 	if (_mouseVisible == visible)
 		return visible;
 
@@ -1671,7 +1677,7 @@ bool SdlGraphicsManager::showMouse(bool visible) {
 	return last;
 }
 
-void SdlGraphicsManager::setMousePos(int x, int y) {
+void SurfaceSdlGraphicsManager::setMousePos(int x, int y) {
 	if (x != _mouseCurState.x || y != _mouseCurState.y) {
 		_mouseNeedsRedraw = true;
 		_mouseCurState.x = x;
@@ -1679,7 +1685,7 @@ void SdlGraphicsManager::setMousePos(int x, int y) {
 	}
 }
 
-void SdlGraphicsManager::warpMouse(int x, int y) {
+void SurfaceSdlGraphicsManager::warpMouse(int x, int y) {
 	int y1 = y;
 
 	// Don't change actual mouse position, when mouse is outside of our window (in case of windowed mode)
@@ -1708,7 +1714,7 @@ void SdlGraphicsManager::warpMouse(int x, int y) {
 	}
 }
 
-void SdlGraphicsManager::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) {
+void SurfaceSdlGraphicsManager::setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) {
 #ifdef USE_RGB_COLOR
 	if (!format)
 		_cursorFormat = Graphics::PixelFormat::createFormatCLUT8();
@@ -1765,7 +1771,7 @@ void SdlGraphicsManager::setMouseCursor(const byte *buf, uint w, uint h, int hot
 	blitCursor();
 }
 
-void SdlGraphicsManager::blitCursor() {
+void SurfaceSdlGraphicsManager::blitCursor() {
 	byte *dstPtr;
 	const byte *srcPtr = _mouseData;
 #ifdef USE_RGB_COLOR
@@ -1956,7 +1962,7 @@ static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height
 }
 #endif
 
-void SdlGraphicsManager::undrawMouse() {
+void SurfaceSdlGraphicsManager::undrawMouse() {
 	const int x = _mouseBackup.x;
 	const int y = _mouseBackup.y;
 
@@ -1969,7 +1975,7 @@ void SdlGraphicsManager::undrawMouse() {
 		addDirtyRect(x, y - _currentShakePos, _mouseBackup.w, _mouseBackup.h);
 }
 
-void SdlGraphicsManager::drawMouse() {
+void SurfaceSdlGraphicsManager::drawMouse() {
 	if (!_mouseVisible || !_mouseSurface) {
 		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
 		return;
@@ -2036,8 +2042,8 @@ void SdlGraphicsManager::drawMouse() {
 #pragma mark -
 
 #ifdef USE_OSD
-void SdlGraphicsManager::displayMessageOnOSD(const char *msg) {
-	assert (_transactionMode == kTransactionNone);
+void SurfaceSdlGraphicsManager::displayMessageOnOSD(const char *msg) {
+	assert(_transactionMode == kTransactionNone);
 	assert(msg);
 
 	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
@@ -2123,7 +2129,7 @@ void SdlGraphicsManager::displayMessageOnOSD(const char *msg) {
 }
 #endif
 
-bool SdlGraphicsManager::handleScalerHotkeys(Common::KeyCode key) {
+bool SurfaceSdlGraphicsManager::handleScalerHotkeys(Common::KeyCode key) {
 
 	// Ctrl-Alt-a toggles aspect ratio correction
 	if (key == 'a') {
@@ -2212,7 +2218,7 @@ bool SdlGraphicsManager::handleScalerHotkeys(Common::KeyCode key) {
 	}
 }
 
-bool SdlGraphicsManager::isScalerHotkey(const Common::Event &event) {
+bool SurfaceSdlGraphicsManager::isScalerHotkey(const Common::Event &event) {
 	if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
 		const bool isNormalNumber = (Common::KEYCODE_1 <= event.kbd.keycode && event.kbd.keycode <= Common::KEYCODE_9);
 		const bool isKeypadNumber = (Common::KEYCODE_KP1 <= event.kbd.keycode && event.kbd.keycode <= Common::KEYCODE_KP9);
@@ -2229,7 +2235,7 @@ bool SdlGraphicsManager::isScalerHotkey(const Common::Event &event) {
 	return false;
 }
 
-void SdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
+void SurfaceSdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
 	if (!event.synthetic) {
 		Common::Event newEvent(event);
 		newEvent.synthetic = true;
@@ -2243,7 +2249,7 @@ void SdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
 	}
 }
 
-void SdlGraphicsManager::toggleFullScreen() {
+void SurfaceSdlGraphicsManager::toggleFullScreen() {
 	beginGFXTransaction();
 		setFullscreenMode(!_videoMode.fullscreen);
 	endGFXTransaction();
@@ -2255,7 +2261,7 @@ void SdlGraphicsManager::toggleFullScreen() {
 #endif
 }
 
-bool SdlGraphicsManager::notifyEvent(const Common::Event &event) {
+bool SurfaceSdlGraphicsManager::notifyEvent(const Common::Event &event) {
 	switch ((int)event.type) {
 	case Common::EVENT_KEYDOWN:
 		// Alt-Return and Alt-Enter toggle full screen mode
diff --git a/backends/graphics/sdl/sdl-graphics.h b/backends/graphics/surfacesdl/surfacesdl-graphics.h
index 9627ab23a3..cd8710d443 100644
--- a/backends/graphics/sdl/sdl-graphics.h
+++ b/backends/graphics/surfacesdl/surfacesdl-graphics.h
@@ -20,8 +20,8 @@
  *
  */
 
-#ifndef BACKENDS_GRAPHICS_SDL_H
-#define BACKENDS_GRAPHICS_SDL_H
+#ifndef BACKENDS_GRAPHICS_SURFACESDL_GRAPHICS_H
+#define BACKENDS_GRAPHICS_SURFACESDL_GRAPHICS_H
 
 #include "backends/graphics/graphics.h"
 #include "graphics/pixelformat.h"
@@ -74,10 +74,10 @@ public:
 /**
  * SDL graphics manager
  */
-class SdlGraphicsManager : public GraphicsManager, public Common::EventObserver {
+class SurfaceSdlGraphicsManager : public GraphicsManager, public Common::EventObserver {
 public:
-	SdlGraphicsManager(SdlEventSource *sdlEventSource);
-	virtual ~SdlGraphicsManager();
+	SurfaceSdlGraphicsManager(SdlEventSource *sdlEventSource);
+	virtual ~SurfaceSdlGraphicsManager();
 
 	virtual void initEventObserver();
 
@@ -100,7 +100,7 @@ public:
 
 	virtual void beginGFXTransaction();
 	virtual OSystem::TransactionError endGFXTransaction();
-	
+
 	virtual int16 getHeight();
 	virtual int16 getWidth();
 
@@ -132,7 +132,7 @@ public:
 	virtual void warpMouse(int x, int y);
 	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale = 1, const Graphics::PixelFormat *format = NULL);
 	virtual void setCursorPalette(const byte *colors, uint start, uint num);
-	
+
 #ifdef USE_OSD
 	virtual void displayMessageOnOSD(const char *msg);
 #endif
@@ -149,7 +149,7 @@ protected:
 	/** Transparency level of the OSD */
 	uint8 _osdAlpha;
 	/** When to start the fade out */
-	uint32 _osdFadeStartTime; 
+	uint32 _osdFadeStartTime;
 	/** Enum with OSD options */
 	enum {
 		kOSDFadeOutDelay = 2 * 1000,	/** < Delay before the OSD is faded out (in milliseconds) */
diff --git a/backends/graphics/symbiansdl/symbiansdl-graphics.cpp b/backends/graphics/symbiansdl/symbiansdl-graphics.cpp
index a88c8a8ffe..4a9a219641 100644
--- a/backends/graphics/symbiansdl/symbiansdl-graphics.cpp
+++ b/backends/graphics/symbiansdl/symbiansdl-graphics.cpp
@@ -28,7 +28,7 @@
 #include "backends/platform/symbian/src/SymbianActions.h"
 
 SymbianSdlGraphicsManager::SymbianSdlGraphicsManager(SdlEventSource *sdlEventSource)
-	: SdlGraphicsManager(sdlEventSource) {
+	: SurfaceSdlGraphicsManager(sdlEventSource) {
 }
 
 int SymbianSdlGraphicsManager::getDefaultGraphicsMode() const {
@@ -47,7 +47,7 @@ const OSystem::GraphicsMode *SymbianSdlGraphicsManager::getSupportedGraphicsMode
 // make sure we always go to normal, even if the string might be set wrong!
 bool SymbianSdlGraphicsManager::setGraphicsMode(int /*name*/) {
 	// let parent OSystem_SDL handle it
-	return SdlGraphicsManager::setGraphicsMode(getDefaultGraphicsMode());
+	return SurfaceSdlGraphicsManager::setGraphicsMode(getDefaultGraphicsMode());
 }
 
 bool SymbianSdlGraphicsManager::hasFeature(OSystem::Feature f) {
@@ -72,7 +72,7 @@ void SymbianSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable)
 		GUI::Actions::Instance()->beginMapping(enable);
 		break;
 	default:
-		SdlGraphicsManager::setFeatureState(f, enable);
+		SurfaceSdlGraphicsManager::setFeatureState(f, enable);
 	}
 }
 
diff --git a/backends/graphics/symbiansdl/symbiansdl-graphics.h b/backends/graphics/symbiansdl/symbiansdl-graphics.h
index 1bad32a9b6..404ca87a0a 100644
--- a/backends/graphics/symbiansdl/symbiansdl-graphics.h
+++ b/backends/graphics/symbiansdl/symbiansdl-graphics.h
@@ -23,9 +23,9 @@
 #ifndef BACKENDS_GRAPHICS_SYMBIAN_SDL_H
 #define BACKENDS_GRAPHICS_SYMBIAN_SDL_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 
-class SymbianSdlGraphicsManager : public SdlGraphicsManager {
+class SymbianSdlGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	SymbianSdlGraphicsManager(SdlEventSource *sdlEventSource);
 
diff --git a/backends/graphics/wincesdl/wincesdl-graphics.cpp b/backends/graphics/wincesdl/wincesdl-graphics.cpp
index 8ba7b5821d..2ca78cedde 100644
--- a/backends/graphics/wincesdl/wincesdl-graphics.cpp
+++ b/backends/graphics/wincesdl/wincesdl-graphics.cpp
@@ -43,8 +43,8 @@
 #include "backends/platform/wince/CEgui/ItemAction.h"
 
 WINCESdlGraphicsManager::WINCESdlGraphicsManager(SdlEventSource *sdlEventSource)
-	: SdlGraphicsManager(sdlEventSource),
-	  _panelInitialized(false), _noDoubleTapRMB(false),
+	: SurfaceSdlGraphicsManager(sdlEventSource),
+	  _panelInitialized(false), _noDoubleTapRMB(false), _noDoubleTapPT(false),
 	  _toolbarHighDrawn(false), _newOrientation(0), _orientationLandscape(0),
 	  _panelVisible(true), _saveActiveToolbar(NAME_MAIN_PANEL), _panelStateForced(false),
 	  _canBeAspectScaled(false), _scalersChanged(false), _saveToolbarState(false),
@@ -149,7 +149,7 @@ void WINCESdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
 		return;
 
 	default:
-		SdlGraphicsManager::setFeatureState(f, enable);
+		SurfaceSdlGraphicsManager::setFeatureState(f, enable);
 	}
 }
 
@@ -160,7 +160,7 @@ bool WINCESdlGraphicsManager::getFeatureState(OSystem::Feature f) {
 	case OSystem::kFeatureVirtualKeyboard:
 		return (_panelStateForced);
 	default:
-		return SdlGraphicsManager::getFeatureState(f);
+		return SurfaceSdlGraphicsManager::getFeatureState(f);
 	}
 }
 
@@ -204,7 +204,7 @@ void WINCESdlGraphicsManager::initSize(uint w, uint h, const Graphics::PixelForm
 	_videoMode.overlayWidth = w;
 	_videoMode.overlayHeight = h;
 
-	SdlGraphicsManager::initSize(w, h, format);
+	SurfaceSdlGraphicsManager::initSize(w, h, format);
 
 	if (_scalersChanged) {
 		unloadGFXMode();
@@ -478,6 +478,9 @@ void WINCESdlGraphicsManager::update_game_settings() {
 
 	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 WINCESdlGraphicsManager::internUpdateScreen() {
@@ -1185,7 +1188,7 @@ void WINCESdlGraphicsManager::setMousePos(int x, int y) {
 Graphics::Surface *WINCESdlGraphicsManager::lockScreen() {
 	// Make sure mouse pointer is not painted over the playfield at the time of locking
 	undrawMouse();
-	return SdlGraphicsManager::lockScreen();
+	return SurfaceSdlGraphicsManager::lockScreen();
 }
 
 void WINCESdlGraphicsManager::showOverlay() {
@@ -1293,7 +1296,7 @@ void WINCESdlGraphicsManager::warpMouse(int x, int y) {
 }
 
 void WINCESdlGraphicsManager::unlockScreen() {
-	SdlGraphicsManager::unlockScreen();
+	SurfaceSdlGraphicsManager::unlockScreen();
 }
 
 void WINCESdlGraphicsManager::internDrawMouse() {
@@ -1468,7 +1471,7 @@ void WINCESdlGraphicsManager::addDirtyRect(int x, int y, int w, int h, bool mous
 	if (_forceFull || _paletteDirtyEnd)
 		return;
 
-	SdlGraphicsManager::addDirtyRect(x, y, w, h, false);
+	SurfaceSdlGraphicsManager::addDirtyRect(x, y, w, h, false);
 }
 
 void WINCESdlGraphicsManager::swap_panel_visibility() {
@@ -1599,6 +1602,19 @@ void WINCESdlGraphicsManager::swap_mouse_visibility() {
 		undrawMouse();
 }
 
+void WINCESdlGraphicsManager::init_panel() {
+	_panelVisible = true;
+	if (_panelInitialized) {
+		_toolbarHandler.setVisible(true);
+		_toolbarHandler.setActive(NAME_MAIN_PANEL);
+	}
+}
+
+void WINCESdlGraphicsManager::reset_panel() {
+	_panelVisible = false;
+	_toolbarHandler.setVisible(false);
+}
+
 // Smartphone actions
 void WINCESdlGraphicsManager::initZones() {
 	int i;
diff --git a/backends/graphics/wincesdl/wincesdl-graphics.h b/backends/graphics/wincesdl/wincesdl-graphics.h
index 2727bc0d27..92894e0dcd 100644
--- a/backends/graphics/wincesdl/wincesdl-graphics.h
+++ b/backends/graphics/wincesdl/wincesdl-graphics.h
@@ -23,7 +23,7 @@
 #ifndef BACKENDS_GRAPHICS_WINCE_SDL_H
 #define BACKENDS_GRAPHICS_WINCE_SDL_H
 
-#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/graphics/surfacesdl/surfacesdl-graphics.h"
 #include "backends/platform/wince/CEgui/CEGUI.h"
 
 // Internal GUI names
@@ -39,7 +39,7 @@
 
 extern bool _hasSmartphoneResolution;
 
-class WINCESdlGraphicsManager : public SdlGraphicsManager {
+class WINCESdlGraphicsManager : public SurfaceSdlGraphicsManager {
 public:
 	WINCESdlGraphicsManager(SdlEventSource *sdlEventSource);
 
@@ -90,6 +90,8 @@ public:
 	void swap_zoom_up();
 	void swap_zoom_down();
 	void swap_mouse_visibility();
+	void init_panel();
+	void reset_panel();
 	void swap_freeLook();
 	bool getFreeLookState();
 
@@ -115,6 +117,7 @@ public:
 
 	bool _panelInitialized; // only initialize the toolbar once
 	bool _noDoubleTapRMB;   // disable double tap -> rmb click
+	bool _noDoubleTapPT;    // disable double tap for toolbar toggling
 
 	CEGUI::ToolbarHandler _toolbarHandler;