Merging the gsoc2010-opengl branch

svn-id: r54518

20 files changed, 6981 insertions, 0 deletions

diff --git a/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp b/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp
new file mode 100644
index 0000000000..c38d53e86b
--- /dev/null
+++ b/backends/graphics/dinguxsdl/dinguxsdl-graphics.cpp
@@ -0,0 +1,506 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined (DINGUX)
+
+#include "backends/graphics/dinguxsdl/dinguxsdl-graphics.h"
+#include "backends/events/dinguxsdl/dinguxsdl-events.h"
+#include "graphics/scaler/aspect.h"
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"1x", "Standard", GFX_NORMAL},
+	{0, 0, 0}
+};
+
+DINGUXSdlGraphicsManager::DINGUXSdlGraphicsManager(SdlEventSource *boss) : SdlGraphicsManager(boss) {
+	_evSrc = boss;
+}
+
+const OSystem::GraphicsMode *DINGUXSdlGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int DINGUXSdlGraphicsManager::getDefaultGraphicsMode() const {
+	return GFX_NORMAL;
+}
+
+bool DINGUXSdlGraphicsManager::setGraphicsMode(int mode) {
+	Common::StackLock lock(_graphicsMutex);
+
+	assert(_transactionMode == kTransactionActive);
+
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return true;
+
+	int newScaleFactor = 1;
+
+	switch (mode) {
+	case GFX_NORMAL:
+		newScaleFactor = 1;
+		break;
+	case GFX_HALF:
+		newScaleFactor = 1;
+		break;
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
+	if (_oldVideoMode.setup && _oldVideoMode.scaleFactor != newScaleFactor)
+		_transactionDetails.needHotswap = true;
+
+	_transactionDetails.needUpdatescreen = true;
+
+	_videoMode.mode = mode;
+	_videoMode.scaleFactor = newScaleFactor;
+
+	return true;
+}
+
+void DINGUXSdlGraphicsManager::setGraphicsModeIntern() {
+	Common::StackLock lock(_graphicsMutex);
+	ScalerProc *newScalerProc = 0;
+
+	switch (_videoMode.mode) {
+	case GFX_NORMAL:
+		newScalerProc = Normal1x;
+		break;
+	case GFX_HALF:
+		newScalerProc = DownscaleAllByHalf;
+		break;
+
+	default:
+		error("Unknown gfx mode %d", _videoMode.mode);
+	}
+
+	_scalerProc = newScalerProc;
+
+	if (!_screen || !_hwscreen)
+		return;
+
+	// 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();
+}
+
+void DINGUXSdlGraphicsManager::initSize(uint w, uint h) {
+	assert(_transactionMode == kTransactionActive);
+
+	// Avoid redundant res changes
+	if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight)
+		return;
+
+	_videoMode.screenWidth = w;
+	_videoMode.screenHeight = h;
+	if (w > 320 || h > 240) {
+		setGraphicsMode(GFX_HALF);
+		setGraphicsModeIntern();
+		_evSrc->toggleMouseGrab();
+	}
+
+	_transactionDetails.sizeChanged = true;
+}
+
+void DINGUXSdlGraphicsManager::drawMouse() {
+	if (!_mouseVisible || !_mouseSurface) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+		return;
+	}
+
+	SDL_Rect dst;
+	int scale;
+	int hotX, hotY;
+
+	if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+		dst.x = _mouseCurState.x / 2;
+		dst.y = _mouseCurState.y / 2;
+	} else {
+		dst.x = _mouseCurState.x;
+		dst.y = _mouseCurState.y;
+	}
+
+	if (!_overlayVisible) {
+		scale = _videoMode.scaleFactor;
+		dst.w = _mouseCurState.vW;
+		dst.h = _mouseCurState.vH;
+		hotX = _mouseCurState.vHotX;
+		hotY = _mouseCurState.vHotY;
+	} else {
+		scale = 1;
+		dst.w = _mouseCurState.rW;
+		dst.h = _mouseCurState.rH;
+		hotX = _mouseCurState.rHotX;
+		hotY = _mouseCurState.rHotY;
+	}
+
+	// The mouse is undrawn using virtual coordinates, i.e. they may be
+	// scaled and aspect-ratio corrected.
+
+	_mouseBackup.x = dst.x - hotX;
+	_mouseBackup.y = dst.y - hotY;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
+
+	// We draw the pre-scaled cursor image, so now we need to adjust for
+	// scaling, shake position and aspect ratio correction manually.
+
+	if (!_overlayVisible) {
+		dst.y += _currentShakePos;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		dst.y = real2Aspect(dst.y);
+
+	dst.x = scale * dst.x - _mouseCurState.rHotX;
+	dst.y = scale * dst.y - _mouseCurState.rHotY;
+	dst.w = _mouseCurState.rW;
+	dst.h = _mouseCurState.rH;
+
+	// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
+	// clipping necessary
+
+	if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	// The screen will be updated using real surface coordinates, i.e.
+	// they will not be scaled or aspect-ratio corrected.
+	addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+void DINGUXSdlGraphicsManager::undrawMouse() {
+	const int x = _mouseBackup.x;
+	const int y = _mouseBackup.y;
+
+	// When we switch bigger overlay off mouse jumps. Argh!
+	// This is intended to prevent undrawing offscreen mouse
+	if (!_overlayVisible && (x >= _videoMode.screenWidth || y >= _videoMode.screenHeight))
+		return;
+
+	if (_mouseBackup.w != 0 && _mouseBackup.h != 0) {
+		if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+			addDirtyRect(x*2, y*2, _mouseBackup.w*2, _mouseBackup.h*2);
+		} else {
+			addDirtyRect(x, y, _mouseBackup.w, _mouseBackup.h);
+		}
+	}
+}
+
+void DINGUXSdlGraphicsManager::internUpdateScreen() {
+	SDL_Surface *srcSurf, *origSurf;
+	int height, width;
+	ScalerProc *scalerProc;
+	int scale1;
+
+#if defined (DEBUG) && ! defined(_WIN32_WCE) // definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?)
+	assert(_hwscreen != NULL);
+	assert(_hwscreen->map->sw_data != NULL);
+#endif
+
+	// If the shake position changed, fill the dirty area with blackness
+	if (_currentShakePos != _newShakePos) {
+		SDL_Rect blackrect = {0, 0, _videoMode.screenWidth * _videoMode.scaleFactor, _newShakePos * _videoMode.scaleFactor};
+
+		if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
+		SDL_FillRect(_hwscreen, &blackrect, 0);
+
+		_currentShakePos = _newShakePos;
+
+		_forceFull = true;
+	}
+
+	// Check whether the palette was changed in the meantime and update the
+	// screen surface accordingly.
+	if (_screen && _paletteDirtyEnd != 0) {
+		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
+		              _paletteDirtyStart,
+		              _paletteDirtyEnd - _paletteDirtyStart);
+
+		_paletteDirtyEnd = 0;
+
+		_forceFull = true;
+	}
+
+#ifdef USE_OSD
+	// OSD visible (i.e. non-transparent)?
+	if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+		// Updated alpha value
+		const int diff = SDL_GetTicks() - _osdFadeStartTime;
+		if (diff > 0) {
+			if (diff >= kOSDFadeOutDuration) {
+				// Back to full transparency
+				_osdAlpha = SDL_ALPHA_TRANSPARENT;
+			} else {
+				// Do a linear fade out...
+				const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+				_osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
+			}
+			SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+			_forceFull = true;
+		}
+	}
+#endif
+
+	if (!_overlayVisible) {
+		origSurf = _screen;
+		srcSurf = _tmpscreen;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		scalerProc = _scalerProc;
+		scale1 = _videoMode.scaleFactor;
+	} else {
+		origSurf = _overlayscreen;
+		srcSurf = _tmpscreen2;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		scalerProc = Normal1x;
+		scale1 = 1;
+	}
+
+	// Add the area covered by the mouse cursor to the list of dirty rects if
+	// we have to redraw the mouse.
+	if (_mouseNeedsRedraw)
+		undrawMouse();
+
+	// Force a full redraw if requested
+	if (_forceFull) {
+		_numDirtyRects = 1;
+		_dirtyRectList[0].x = 0;
+		_dirtyRectList[0].y = 0;
+		_dirtyRectList[0].w = width;
+		_dirtyRectList[0].h = height;
+	}
+
+	// Only draw anything if necessary
+	if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
+		SDL_Rect *r;
+		SDL_Rect dst;
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			dst = *r;
+			dst.x++;	// Shift rect by one since 2xSai needs to access the data around
+			dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
+
+			if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
+				error("SDL_BlitSurface failed: %s", SDL_GetError());
+		}
+
+		SDL_LockSurface(srcSurf);
+		SDL_LockSurface(_hwscreen);
+
+		srcPitch = srcSurf->pitch;
+		dstPitch = _hwscreen->pitch;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			register int dst_y = r->y + _currentShakePos;
+			register int dst_h = 0;
+			register int dst_w = r->w;
+			register int orig_dst_y = 0;
+			register int dst_x = r->x;
+			register int src_y;
+			register int src_x;
+
+			if (dst_y < height) {
+				dst_h = r->h;
+				if (dst_h > height - dst_y)
+					dst_h = height - dst_y;
+
+				orig_dst_y = dst_y;
+				src_x = dst_x;
+				src_y = dst_y;
+
+				if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+					dst_y = real2Aspect(dst_y);
+
+				assert(scalerProc != NULL);
+
+				if ((_videoMode.mode == GFX_HALF) && (scalerProc == DownscaleAllByHalf)) {
+					if (dst_x % 2 == 1) {
+						dst_x--;
+						dst_w++;
+					}
+					if (dst_y % 2 == 1) {
+						dst_y--;
+						dst_h++;
+					}
+					src_x = dst_x;
+					src_y = dst_y;
+					dst_x = dst_x / 2;
+					dst_y = dst_y / 2;
+
+					scalerProc((byte *)srcSurf->pixels + (src_x * 2 + 2) + (src_y + 1) * srcPitch, srcPitch,
+					           (byte *)_hwscreen->pixels + dst_x * 2 + dst_y * dstPitch, dstPitch, dst_w, dst_h);
+
+				} else {
+					scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
+					           (byte *)_hwscreen->pixels + r->x * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
+				}
+			}
+
+			if (_videoMode.mode == GFX_HALF && scalerProc == DownscaleAllByHalf) {
+				r->w = r->w / 2;
+				r->h = dst_h / 2;
+			} else {
+				r->w = r->w;
+				r->h = dst_h;
+			}
+
+			r->x = dst_x;
+			r->y = dst_y;
+
+
+#ifdef USE_SCALERS
+			if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
+				r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
+#endif
+		}
+		SDL_UnlockSurface(srcSurf);
+		SDL_UnlockSurface(_hwscreen);
+
+		// Readjust the dirty rect list in case we are doing a full update.
+		// This is necessary if shaking is active.
+		if (_forceFull) {
+			_dirtyRectList[0].y = 0;
+			_dirtyRectList[0].h = (_videoMode.mode == GFX_HALF) ? effectiveScreenHeight() / 2 : effectiveScreenHeight();
+		}
+
+		drawMouse();
+
+#ifdef USE_OSD
+		if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+			SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
+		}
+#endif
+		// Finally, blit all our changes to the screen
+		SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
+	}
+
+	_numDirtyRects = 0;
+	_forceFull = false;
+	_mouseNeedsRedraw = false;
+}
+
+void DINGUXSdlGraphicsManager::showOverlay() {
+	if (_videoMode.mode == GFX_HALF) {
+		_mouseCurState.x = _mouseCurState.x / 2;
+		_mouseCurState.y = _mouseCurState.y / 2;
+	}
+	SdlGraphicsManager::showOverlay();
+}
+
+void DINGUXSdlGraphicsManager::hideOverlay() {
+	if (_videoMode.mode == GFX_HALF) {
+		_mouseCurState.x = _mouseCurState.x * 2;
+		_mouseCurState.y = _mouseCurState.y * 2;
+	}
+	SdlGraphicsManager::hideOverlay();
+}
+
+bool DINGUXSdlGraphicsManager::loadGFXMode() {
+
+	// Forcefully disable aspect ratio correction for games
+	// which starts with a native 240px height resolution.
+	// This fixes games with weird resolutions, like MM Nes (256x240)
+	if(_videoMode.screenHeight == 240) {
+		_videoMode.aspectRatioCorrection = false;
+	}
+
+	fprintf(stdout, "Game ScreenMode = %d*%d\n", _videoMode.screenWidth, _videoMode.screenHeight);
+	if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) {
+		_videoMode.aspectRatioCorrection = false;
+		setGraphicsMode(GFX_HALF);
+		fprintf(stdout, "GraphicsMode set to HALF\n");
+	} else {
+		setGraphicsMode(GFX_NORMAL);
+		fprintf(stdout, "GraphicsMode set to NORMAL\n");
+	}
+
+	if ((_videoMode.mode == GFX_HALF) && !_overlayVisible) {
+		_videoMode.overlayWidth = _videoMode.screenWidth / 2;
+		_videoMode.overlayHeight = _videoMode.screenHeight / 2;
+		_videoMode.fullscreen = true;
+	} else {
+
+		_videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+		_videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+
+		if (_videoMode.aspectRatioCorrection)
+			_videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight);
+
+		_videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+		_videoMode.hardwareHeight = effectiveScreenHeight();
+	}
+
+
+	return SdlGraphicsManager::loadGFXMode();
+}
+
+bool DINGUXSdlGraphicsManager::hasFeature(OSystem::Feature f) {
+	return
+	    (f == OSystem::kFeatureAspectRatioCorrection) ||
+	    (f == OSystem::kFeatureCursorHasPalette);
+}
+
+void DINGUXSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+	switch (f) {
+		case OSystem::kFeatureAspectRatioCorrection:
+		setAspectRatioCorrection(enable);
+		break;
+	default:
+		break;
+	}
+}
+
+bool DINGUXSdlGraphicsManager::getFeatureState(OSystem::Feature f) {
+	assert(_transactionMode == kTransactionNone);
+
+	switch (f) {
+		case OSystem::kFeatureAspectRatioCorrection:
+		return _videoMode.aspectRatioCorrection;
+	default:
+		return false;
+	}
+}
+
+SdlGraphicsManager::MousePos* DINGUXSdlGraphicsManager::getMouseCurState() {
+	return &_mouseCurState;
+}
+
+SdlGraphicsManager::VideoState* DINGUXSdlGraphicsManager::getVideoMode() {
+	return &_videoMode;
+}
+
+bool DINGUXSdlGraphicsManager::isOverlayVisible() {
+	return _overlayVisible;
+}
+
+#endif
diff --git a/backends/graphics/dinguxsdl/dinguxsdl-graphics.h b/backends/graphics/dinguxsdl/dinguxsdl-graphics.h
new file mode 100644
index 0000000000..b2edd73f6d
--- /dev/null
+++ b/backends/graphics/dinguxsdl/dinguxsdl-graphics.h
@@ -0,0 +1,69 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_SDL_DINGUX_H
+#define BACKENDS_GRAPHICS_SDL_DINGUX_H
+#if defined (DINGUX)
+
+#include "backends/graphics/sdl/sdl-graphics.h"
+
+#include "graphics/scaler/aspect.h"	// for aspect2Real 
+#include "graphics/scaler/downscaler.h"
+
+enum {
+	GFX_HALF = 12
+};
+
+class DINGUXSdlGraphicsManager : public SdlGraphicsManager {
+public:
+	DINGUXSdlGraphicsManager(SdlEventSource *boss);
+
+	bool hasFeature(OSystem::Feature f);
+	void setFeatureState(OSystem::Feature f, bool enable);
+	bool getFeatureState(OSystem::Feature f);
+	int getDefaultGraphicsMode() const;
+
+	void initSize(uint w, uint h);
+	const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	bool setGraphicsMode(const char *name);
+	bool setGraphicsMode(int mode);
+	void setGraphicsModeIntern();
+	void internUpdateScreen();
+	void showOverlay();
+	void hideOverlay();
+	bool loadGFXMode();
+	void drawMouse();
+	void undrawMouse();
+
+	SdlGraphicsManager::MousePos *getMouseCurState();
+	SdlGraphicsManager::VideoState *getVideoMode();
+	bool isOverlayVisible();
+
+protected:
+	SdlEventSource *_evSrc;
+};
+
+#endif /* DINGUX */
+#endif /* BACKENDS_GRAPHICS_SDL_DINGUX_H */
diff --git a/backends/graphics/gp2xsdl/gp2xsdl-graphics.cpp b/backends/graphics/gp2xsdl/gp2xsdl-graphics.cpp
new file mode 100644
index 0000000000..a1e351251a
--- /dev/null
+++ b/backends/graphics/gp2xsdl/gp2xsdl-graphics.cpp
@@ -0,0 +1,183 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifdef GP2X
+
+#include "backends/graphics/gp2xsdl/gp2xsdl-graphics.h"
+#include "graphics/scaler/aspect.h"
+#include <SDL_gp2x.h>
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"Fullscreen", "1x", GFX_NORMAL},
+	{0, 0, 0}
+};
+
+GP2XSdlGraphicsManager::GP2XSdlGraphicsManager()
+	:
+	_adjustZoomOnMouse(false) {
+
+}
+
+const OSystem::GraphicsMode *GP2XSdlGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int GP2XSdlGraphicsManager::getDefaultGraphicsMode() const {
+	return GFX_NORMAL;
+}
+
+
+bool GP2XSdlGraphicsManager::hasFeature(OSystem::Feature f) {
+	if (f == OSystem::kFeatureIconifyWindow)
+		return false;
+
+	return SdlGraphicsManager::hasFeature(f);
+}
+
+void GP2XSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+	if (f != OSystem::kFeatureIconifyWindow)
+		SdlGraphicsManager::setFeatureState(f, enable);
+}
+
+void GP2XSdlGraphicsManager::drawMouse() {
+	if (!_mouseVisible || !_mouseSurface) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+		return;
+	}
+
+	SDL_Rect zoomdst;
+	SDL_Rect dst;
+	int scale;
+	int hotX, hotY;
+	int tmpScreenWidth, tmpScreenHeight;
+
+	// Temp vars to ensure we zoom to the LCD resolution or greater.
+	tmpScreenWidth = _videoMode.screenWidth;
+	tmpScreenHeight = _videoMode.screenHeight;
+
+	if (_videoMode.screenHeight <= 240) {
+		tmpScreenHeight = 240;
+	}
+
+	if (_videoMode.screenWidth <= 320) {
+		tmpScreenWidth = 320;
+	}
+
+	dst.x = _mouseCurState.x;
+	dst.y = _mouseCurState.y;
+
+	if (!_overlayVisible) {
+		scale = _videoMode.scaleFactor;
+		dst.w = _mouseCurState.vW;
+		dst.h = _mouseCurState.vH;
+		hotX = _mouseCurState.vHotX;
+		hotY = _mouseCurState.vHotY;
+	} else {
+		scale = 1;
+		dst.w = _mouseCurState.rW;
+		dst.h = _mouseCurState.rH;
+		hotX = _mouseCurState.rHotX;
+		hotY = _mouseCurState.rHotY;
+	}
+
+	// The mouse is undrawn using virtual coordinates, i.e. they may be
+	// scaled and aspect-ratio corrected.
+
+	_mouseBackup.x = dst.x - hotX;
+	_mouseBackup.y = dst.y - hotY;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
+
+	// We draw the pre-scaled cursor image, so now we need to adjust for
+	// scaling, shake position and aspect ratio correction manually.
+
+	if (!_overlayVisible) {
+		dst.y += _currentShakePos;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		dst.y = real2Aspect(dst.y);
+
+	dst.x = scale * dst.x - _mouseCurState.rHotX;
+	dst.y = scale * dst.y - _mouseCurState.rHotY;
+	dst.w = _mouseCurState.rW;
+	dst.h = _mouseCurState.rH;
+
+	// Hacking about with the zoom around mouse pointer stuff.
+	if (_adjustZoomOnMouse){
+
+		zoomdst.w = (tmpScreenWidth / 2);
+		zoomdst.h = (tmpScreenHeight / 2);
+
+		// Create a zoomed rect centered on the mouse pointer.
+		// Will pan 1/4 of the screen.
+
+		if (dst.x > ((tmpScreenWidth / 4) * 3)) {
+			zoomdst.x = (tmpScreenWidth / 2);
+		} else {
+			zoomdst.x = (dst.x - (tmpScreenWidth / 4));
+			if (zoomdst.x < 0) {
+				zoomdst.x = 0;
+			}
+		}
+
+		if (dst.y > ((tmpScreenHeight / 4) * 3)) {
+			zoomdst.y = (tmpScreenHeight / 2);
+		} else {
+			zoomdst.y = (dst.y - (tmpScreenHeight / 4));
+			if (zoomdst.y < 0) {
+				zoomdst.y = 0;
+			}
+		}
+		SDL_GP2X_Display(&zoomdst);
+	} else {
+
+		// Make sure we are looking at the whole screen otherwise.
+
+		zoomdst.x = 0;
+		zoomdst.y = 0;
+		zoomdst.w = (tmpScreenWidth);
+		zoomdst.h = (tmpScreenHeight);
+
+		SDL_GP2X_Display(&zoomdst);
+	};
+
+	// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
+	// clipping necessary
+
+	if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	// The screen will be updated using real surface coordinates, i.e.
+	// they will not be scaled or aspect-ratio corrected.
+
+	addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+void GP2XSdlGraphicsManager::toggleZoomOnMouse() {
+	_adjustZoomOnMouse = !_adjustZoomOnMouse;
+}
+
+#endif
diff --git a/backends/graphics/gp2xsdl/gp2xsdl-graphics.h b/backends/graphics/gp2xsdl/gp2xsdl-graphics.h
new file mode 100644
index 0000000000..776a9b1a0f
--- /dev/null
+++ b/backends/graphics/gp2xsdl/gp2xsdl-graphics.h
@@ -0,0 +1,48 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_SDL_GP2X_H
+#define BACKENDS_GRAPHICS_SDL_GP2X_H
+
+#include "backends/graphics/sdl/sdl-graphics.h"
+
+class GP2XSdlGraphicsManager : public SdlGraphicsManager {
+public:
+	
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual void drawMouse();
+
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+
+	// Toggles zoom adjust on mouse
+	void toggleZoomOnMouse();
+
+protected:
+	bool _adjustZoomOnMouse;
+};
+
+#endif
diff --git a/backends/graphics/graphics.h b/backends/graphics/graphics.h
new file mode 100644
index 0000000000..d2ce6534e1
--- /dev/null
+++ b/backends/graphics/graphics.h
@@ -0,0 +1,91 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_ABSTRACT_H
+#define BACKENDS_GRAPHICS_ABSTRACT_H
+
+#include "common/system.h"
+#include "common/noncopyable.h"
+#include "common/keyboard.h"
+
+/**
+ * Abstract class for graphics manager. Subclasses
+ * implement the real functionality.
+ */
+class GraphicsManager : Common::NonCopyable {
+public:
+	virtual ~GraphicsManager() {}
+
+	virtual bool hasFeature(OSystem::Feature f) = 0;
+	virtual void setFeatureState(OSystem::Feature f, bool enable) = 0;
+	virtual bool getFeatureState(OSystem::Feature f) = 0;
+
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const = 0;
+	virtual int getDefaultGraphicsMode() const = 0;
+	virtual bool setGraphicsMode(int mode) = 0;
+	virtual void resetGraphicsScale() = 0;
+	virtual int getGraphicsMode() const = 0;
+#ifdef USE_RGB_COLOR
+	virtual Graphics::PixelFormat getScreenFormat() const = 0;
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const = 0;
+#endif
+	virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format = NULL) = 0;
+	virtual int getScreenChangeID() const = 0;
+
+	virtual void beginGFXTransaction() = 0;
+	virtual OSystem::TransactionError endGFXTransaction() = 0;
+
+	virtual int16 getHeight() = 0;
+	virtual int16 getWidth() = 0;
+	virtual void setPalette(const byte *colors, uint start, uint num) = 0;
+	virtual void grabPalette(byte *colors, uint start, uint num) = 0;
+	virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) = 0;
+	virtual Graphics::Surface *lockScreen() = 0;
+	virtual void unlockScreen() = 0;
+	virtual void fillScreen(uint32 col) = 0;
+	virtual void updateScreen() = 0;
+	virtual void setShakePos(int shakeOffset) = 0;
+	virtual void setFocusRectangle(const Common::Rect& rect) = 0;
+	virtual void clearFocusRectangle() = 0;
+
+	virtual void showOverlay() = 0;
+	virtual void hideOverlay() = 0;
+	virtual Graphics::PixelFormat getOverlayFormat() const = 0;
+	virtual void clearOverlay() = 0;
+	virtual void grabOverlay(OverlayColor *buf, int pitch) = 0;
+	virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h)= 0;
+	virtual int16 getOverlayHeight() = 0;
+	virtual int16 getOverlayWidth() = 0;
+
+	virtual bool showMouse(bool visible) = 0;
+	virtual void warpMouse(int x, int y) = 0;
+	virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale = 1, const Graphics::PixelFormat *format = NULL) = 0;
+	virtual void setCursorPalette(const byte *colors, uint start, uint num) = 0;
+	virtual void disableCursorPalette(bool disable) = 0;
+
+	virtual void displayMessageOnOSD(const char *msg) {}
+};
+
+#endif
diff --git a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp
new file mode 100644
index 0000000000..dbedb2e1a7
--- /dev/null
+++ b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.cpp
@@ -0,0 +1,495 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifdef LINUXMOTO 
+
+#include "backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h"
+#include "backends/events/linuxmotosdl/linuxmotosdl-events.h"
+#include "common/mutex.h"
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+#include "graphics/scaler.h"
+#include "graphics/scaler/aspect.h"
+#include "graphics/scaler/downscaler.h"
+#include "graphics/surface.h"
+
+enum {
+	GFX_HALF = 12
+};
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"1x", "Fullscreen", GFX_NORMAL},
+	{"½x", "Downscale", GFX_HALF},
+	{0, 0, 0}
+};
+
+const OSystem::GraphicsMode *LinuxmotoSdlGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int LinuxmotoSdlGraphicsManager::getDefaultGraphicsMode() const {
+	return GFX_NORMAL;
+}
+
+bool LinuxmotoSdlGraphicsManager::setGraphicsMode(int mode) {
+	Common::StackLock lock(_graphicsMutex);
+
+	assert(_transactionMode == kTransactionActive);
+
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return true;
+
+	int newScaleFactor = 1;
+
+	switch (mode) {
+	case GFX_NORMAL:
+		newScaleFactor = 1;
+		break;
+	case GFX_HALF:
+		newScaleFactor = 1;
+		break;
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
+	if (_oldVideoMode.setup && _oldVideoMode.scaleFactor != newScaleFactor)
+		_transactionDetails.needHotswap = true;
+
+	_transactionDetails.needUpdatescreen = true;
+
+	_videoMode.mode = mode;
+	_videoMode.scaleFactor = newScaleFactor;
+
+	return true;
+}
+
+void LinuxmotoSdlGraphicsManager::setGraphicsModeIntern() {
+	Common::StackLock lock(_graphicsMutex);
+	ScalerProc *newScalerProc = 0;
+
+	switch (_videoMode.mode) {
+	case GFX_NORMAL:
+		newScalerProc = Normal1x;
+		break;
+	case GFX_HALF:
+		newScalerProc = DownscaleAllByHalf;
+		break;
+
+	default:
+		error("Unknown gfx mode %d", _videoMode.mode);
+	}
+
+	_scalerProc = newScalerProc;
+
+	if (!_screen || !_hwscreen)
+		return;
+
+	// 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();
+}
+
+
+void LinuxmotoSdlGraphicsManager::initSize(uint w, uint h) {
+	assert(_transactionMode == kTransactionActive);
+
+	// Avoid redundant res changes
+	if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight)
+		return;
+
+	_videoMode.screenWidth = w;
+	_videoMode.screenHeight = h;
+
+	if	(w > 320 || h > 240) {
+		setGraphicsMode(GFX_HALF);
+		setGraphicsModeIntern();
+		((LinuxmotoSdlEventManager *)g_system->getEventManager())->toggleMouseGrab();
+	}
+
+	_transactionDetails.sizeChanged = true;
+}
+
+bool LinuxmotoSdlGraphicsManager::loadGFXMode() {
+	printf("Game ScreenMode = %d*%d\n",_videoMode.screenWidth, _videoMode.screenHeight);
+	if (_videoMode.screenWidth > 320 || _videoMode.screenHeight > 240) {
+		_videoMode.aspectRatioCorrection = false;
+		setGraphicsMode(GFX_HALF);
+		printf("GraphicsMode set to HALF\n");
+	} else {
+		setGraphicsMode(GFX_NORMAL);
+		printf("GraphicsMode set to NORMAL\n");
+	}
+	if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+		_videoMode.overlayWidth = 320;
+		_videoMode.overlayHeight = 240;
+		_videoMode.fullscreen = true;
+	} else {
+
+		_videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+		_videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+
+		if (_videoMode.aspectRatioCorrection)
+			_videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight);
+
+		_videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+		_videoMode.hardwareHeight = effectiveScreenHeight();
+	}
+
+	return SdlGraphicsManager::loadGFXMode();
+}
+
+void LinuxmotoSdlGraphicsManager::drawMouse() {
+	if (!_mouseVisible || !_mouseSurface) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+		return;
+	}
+
+	SDL_Rect dst;
+	int scale;
+	int hotX, hotY;
+
+	if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+		dst.x = _mouseCurState.x/2;
+		dst.y = _mouseCurState.y/2;
+	} else {
+		dst.x = _mouseCurState.x;
+		dst.y = _mouseCurState.y;
+	}
+
+	if (!_overlayVisible) {
+		scale = _videoMode.scaleFactor;
+		dst.w = _mouseCurState.vW;
+		dst.h = _mouseCurState.vH;
+		hotX = _mouseCurState.vHotX;
+		hotY = _mouseCurState.vHotY;
+	} else {
+		scale = 1;
+		dst.w = _mouseCurState.rW;
+		dst.h = _mouseCurState.rH;
+		hotX = _mouseCurState.rHotX;
+		hotY = _mouseCurState.rHotY;
+	}
+
+	// The mouse is undrawn using virtual coordinates, i.e. they may be
+	// scaled and aspect-ratio corrected.
+
+	_mouseBackup.x = dst.x - hotX;
+	_mouseBackup.y = dst.y - hotY;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
+
+	// We draw the pre-scaled cursor image, so now we need to adjust for
+	// scaling, shake position and aspect ratio correction manually.
+
+	if (!_overlayVisible) {
+		dst.y += _currentShakePos;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		dst.y = real2Aspect(dst.y);
+
+	dst.x = scale * dst.x - _mouseCurState.rHotX;
+	dst.y = scale * dst.y - _mouseCurState.rHotY;
+	dst.w = _mouseCurState.rW;
+	dst.h = _mouseCurState.rH;
+
+	// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
+	// clipping necessary
+
+	if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	// The screen will be updated using real surface coordinates, i.e.
+	// they will not be scaled or aspect-ratio corrected.
+	addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+void LinuxmotoSdlGraphicsManager::undrawMouse() {
+	const int x = _mouseBackup.x;
+	const int y = _mouseBackup.y;
+
+	// When we switch bigger overlay off mouse jumps. Argh!
+	// This is intended to prevent undrawing offscreen mouse
+	if (!_overlayVisible && (x >= _videoMode.screenWidth || y >= _videoMode.screenHeight))
+		return;
+
+	if (_mouseBackup.w != 0 && _mouseBackup.h != 0) {
+		if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+			addDirtyRect(x*2, y*2, _mouseBackup.w*2, _mouseBackup.h*2);
+		} else {
+			addDirtyRect(x, y, _mouseBackup.w, _mouseBackup.h);
+		}
+	}
+}
+
+void LinuxmotoSdlGraphicsManager::internUpdateScreen() {
+	SDL_Surface *srcSurf, *origSurf;
+	int height, width;
+	ScalerProc *scalerProc;
+	int scale1;
+
+#if defined (DEBUG) // definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?)
+	assert(_hwscreen != NULL);
+	assert(_hwscreen->map->sw_data != NULL);
+#endif
+
+	// If the shake position changed, fill the dirty area with blackness
+	if (_currentShakePos != _newShakePos) {
+		SDL_Rect blackrect = {0, 0, _videoMode.screenWidth * _videoMode.scaleFactor, _newShakePos * _videoMode.scaleFactor};
+
+		if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
+		SDL_FillRect(_hwscreen, &blackrect, 0);
+
+		_currentShakePos = _newShakePos;
+
+		_forceFull = true;
+	}
+
+	// Check whether the palette was changed in the meantime and update the
+	// screen surface accordingly.
+	if (_screen && _paletteDirtyEnd != 0) {
+		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
+			_paletteDirtyStart,
+			_paletteDirtyEnd - _paletteDirtyStart);
+
+		_paletteDirtyEnd = 0;
+
+		_forceFull = true;
+	}
+
+#ifdef USE_OSD
+	// OSD visible (i.e. non-transparent)?
+	if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+		// Updated alpha value
+		const int diff = SDL_GetTicks() - _osdFadeStartTime;
+		if (diff > 0) {
+			if (diff >= kOSDFadeOutDuration) {
+				// Back to full transparency
+				_osdAlpha = SDL_ALPHA_TRANSPARENT;
+			} else {
+				// Do a linear fade out...
+				const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+				_osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
+			}
+			SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+			_forceFull = true;
+		}
+	}
+#endif
+
+	if (!_overlayVisible) {
+		origSurf = _screen;
+		srcSurf = _tmpscreen;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		scalerProc = _scalerProc;
+		scale1 = _videoMode.scaleFactor;
+	} else {
+		origSurf = _overlayscreen;
+		srcSurf = _tmpscreen2;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		scalerProc = Normal1x;
+		scale1 = 1;
+	}
+
+	// Add the area covered by the mouse cursor to the list of dirty rects if
+	// we have to redraw the mouse.
+	if (_mouseNeedsRedraw)
+		undrawMouse();
+
+	// Force a full redraw if requested
+	if (_forceFull) {
+		_numDirtyRects = 1;
+		_dirtyRectList[0].x = 0;
+		_dirtyRectList[0].y = 0;
+		_dirtyRectList[0].w = width;
+		_dirtyRectList[0].h = height;
+	}
+
+	// Only draw anything if necessary
+	if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
+		SDL_Rect *r;
+		SDL_Rect dst;
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			dst = *r;
+			dst.x++;	// Shift rect by one since 2xSai needs to access the data around
+			dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
+
+			if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
+				error("SDL_BlitSurface failed: %s", SDL_GetError());
+		}
+
+		SDL_LockSurface(srcSurf);
+		SDL_LockSurface(_hwscreen);
+
+		srcPitch = srcSurf->pitch;
+		dstPitch = _hwscreen->pitch;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			register int dst_y = r->y + _currentShakePos;
+			register int dst_h = 0;
+			register int dst_w = r->w;
+			register int orig_dst_y = 0;
+			register int dst_x = r->x;
+			register int src_y;
+			register int src_x;
+
+			if (dst_y < height) {
+				dst_h = r->h;
+				if (dst_h > height - dst_y)
+					dst_h = height - dst_y;
+
+				orig_dst_y = dst_y;
+				src_x = dst_x;
+				src_y = dst_y;
+
+				if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+					dst_y = real2Aspect(dst_y);
+
+				assert(scalerProc != NULL);
+
+				if (_videoMode.mode == GFX_HALF && scalerProc == DownscaleAllByHalf) {
+
+					if (dst_x%2==1) {
+						dst_x--;
+						dst_w++;
+					}
+					if (dst_y%2==1) {
+						dst_y--;
+						dst_h++;
+					}
+
+					if (dst_w&1)
+						dst_w++;
+					if (dst_h&1)
+						dst_h++;
+
+					src_x = dst_x;
+					src_y = dst_y;
+					dst_x = dst_x / 2;
+					dst_y = dst_y / 2;
+				}
+				scalerProc((byte *)srcSurf->pixels + (src_x * 2 + 2) + (src_y + 1) * srcPitch, srcPitch,
+						   (byte *)_hwscreen->pixels + dst_x * 2 + dst_y * dstPitch, dstPitch, dst_w, dst_h);
+			}
+
+			if (_videoMode.mode == GFX_HALF && scalerProc == DownscaleAllByHalf) {
+				r->w = r->w / 2;
+				r->h = dst_h / 2;
+			} else {
+				r->w = r->w;
+				r->h = dst_h;
+			}
+
+			r->x = dst_x;
+			r->y = dst_y;
+
+#ifdef USE_SCALERS
+			if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
+				r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
+#endif
+		}
+		SDL_UnlockSurface(srcSurf);
+		SDL_UnlockSurface(_hwscreen);
+
+		// Readjust the dirty rect list in case we are doing a full update.
+		// This is necessary if shaking is active.
+		if (_forceFull) {
+			_dirtyRectList[0].y = 0;
+			_dirtyRectList[0].h = (_videoMode.mode == GFX_HALF) ? effectiveScreenHeight()/2 : effectiveScreenHeight();
+		}
+
+		drawMouse();
+
+#ifdef USE_OSD
+		if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+			SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
+		}
+#endif
+		// Finally, blit all our changes to the screen
+		SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
+	}
+
+	_numDirtyRects = 0;
+	_forceFull = false;
+	_mouseNeedsRedraw = false;
+}
+
+void LinuxmotoSdlGraphicsManager::showOverlay() {
+	if (_videoMode.mode == GFX_HALF) {
+		_mouseCurState.x = _mouseCurState.x / 2;
+		_mouseCurState.y = _mouseCurState.y / 2;
+	}
+	SdlGraphicsManager::showOverlay();
+}
+
+void LinuxmotoSdlGraphicsManager::hideOverlay() {
+	if (_videoMode.mode == GFX_HALF) {
+		_mouseCurState.x = _mouseCurState.x * 2;
+		_mouseCurState.y = _mouseCurState.y * 2;
+	}
+	SdlGraphicsManager::hideOverlay();
+}
+
+void LinuxmotoSdlGraphicsManager::warpMouse(int x, int y) {
+	if (_mouseCurState.x != x || _mouseCurState.y != y) {
+		if (_videoMode.mode == GFX_HALF && !_overlayVisible) {
+			x = x / 2;
+			y = y / 2;
+		}
+	}
+	SdlGraphicsManager::warpMouse(x, y);
+}
+
+void LinuxmotoSdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
+	if (!event.synthetic) {
+		Common::Event newEvent(event);
+		newEvent.synthetic = true;
+		if (!_overlayVisible) {
+			if (_videoMode.mode == GFX_HALF) {
+				event.mouse.x *= 2;
+				event.mouse.y *= 2;
+			}
+			newEvent.mouse.x /= _videoMode.scaleFactor;
+			newEvent.mouse.y /= _videoMode.scaleFactor;
+			if (_videoMode.aspectRatioCorrection)
+				newEvent.mouse.y = aspect2Real(newEvent.mouse.y);
+		}
+		g_system->getEventManager()->pushEvent(newEvent);
+	}
+}
+
+#endif
diff --git a/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h
new file mode 100644
index 0000000000..1b387ca189
--- /dev/null
+++ b/backends/graphics/linuxmotosdl/linuxmotosdl-graphics.h
@@ -0,0 +1,50 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_SDL_LINUXMOTO_H
+#define BACKENDS_GRAPHICS_SDL_LINUXMOTO_H
+
+#include "backends/graphics/sdl/sdl-graphics.h"
+
+class LinuxmotoSdlGraphicsManager : public SdlGraphicsManager {
+public:
+	virtual void initSize(uint w, uint h);
+	virtual void setGraphicsModeIntern();
+	virtual bool setGraphicsMode(int mode);
+	virtual void internUpdateScreen();
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool loadGFXMode();
+	virtual void drawMouse();
+	virtual void undrawMouse();
+	virtual void showOverlay();
+	virtual void hideOverlay();
+	virtual void warpMouse(int x, int y);
+
+protected:
+	virtual void adjustMouseEvent(const Common::Event &event);
+};
+
+#endif
diff --git a/backends/graphics/null/null-graphics.h b/backends/graphics/null/null-graphics.h
new file mode 100644
index 0000000000..4c75a9faba
--- /dev/null
+++ b/backends/graphics/null/null-graphics.h
@@ -0,0 +1,88 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_NULL_H
+#define BACKENDS_GRAPHICS_NULL_H
+
+#include "backends/graphics/graphics.h"
+
+static const OSystem::GraphicsMode s_noGraphicsModes[] = { {0, 0, 0} };
+
+class NullGraphicsManager : GraphicsManager {
+public:
+	virtual ~NullGraphicsManager() {}
+
+	bool hasFeature(OSystem::Feature f) { return false; }
+	void setFeatureState(OSystem::Feature f, bool enable) {}
+	bool getFeatureState(OSystem::Feature f) { return false; }
+
+	const OSystem::GraphicsMode *getSupportedGraphicsModes() const { return s_noGraphicsModes; }
+	int getDefaultGraphicsMode() const { return 0; }
+	bool setGraphicsMode(int mode) { return true; }
+	int getGraphicsMode() const { return 0; }
+	inline Graphics::PixelFormat getScreenFormat() const {
+		return Graphics::PixelFormat::createFormatCLUT8();
+	};
+	inline Common::List<Graphics::PixelFormat> getSupportedFormats() {
+		Common::List<Graphics::PixelFormat> list;
+		list.push_back(Graphics::PixelFormat::createFormatCLUT8());
+		return list;
+	};
+	void initSize(uint width, uint height, const Graphics::PixelFormat *format = NULL) {}
+	virtual int getScreenChangeID() const { return 0; }
+
+	void beginGFXTransaction() {}
+	OSystem::TransactionError endGFXTransaction() { return OSystem::kTransactionSuccess; }
+
+	int16 getHeight() { return 0; }
+	int16 getWidth() { return 0; }
+	void setPalette(const byte *colors, uint start, uint num) {}
+	void grabPalette(byte *colors, uint start, uint num) {}
+	void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) {}
+	Graphics::Surface *lockScreen() { return NULL; }
+	void unlockScreen() {}
+	void fillScreen(uint32 col) {}
+	void updateScreen() {}
+	void setShakePos(int shakeOffset) {}
+	void setFocusRectangle(const Common::Rect& rect) {}
+	void clearFocusRectangle() {}
+
+	void showOverlay() {}
+	void hideOverlay() {}
+	Graphics::PixelFormat getOverlayFormat() const { return Graphics::PixelFormat(); }
+	void clearOverlay() {}
+	void grabOverlay(OverlayColor *buf, int pitch) {}
+	void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {}
+	int16 getOverlayHeight() { return 0; }
+	int16 getOverlayWidth() { return 0; }
+
+	bool showMouse(bool visible) { return !visible; }
+	void warpMouse(int x, int y) {}
+	void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale = 1, const Graphics::PixelFormat *format = NULL) {}
+	void setCursorPalette(const byte *colors, uint start, uint num) {}
+	void disableCursorPalette(bool disable) {}
+};
+
+#endif
diff --git a/backends/graphics/opengl/glerrorcheck.cpp b/backends/graphics/opengl/glerrorcheck.cpp
new file mode 100644
index 0000000000..ee177f0ac5
--- /dev/null
+++ b/backends/graphics/opengl/glerrorcheck.cpp
@@ -0,0 +1,69 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined(DEBUG) && defined(USE_OPENGL)
+
+#include "backends/graphics/opengl/glerrorcheck.h"
+#include "common/debug.h"
+
+#ifdef WIN32
+#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
+#undef ARRAYSIZE
+#endif
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef ARRAYSIZE
+#endif
+
+#ifdef MACOSX
+#include <gl.h>
+#elif defined(USE_GLES)
+#include <GLES/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+
+static const char *getGlErrStr(GLenum error) {
+	switch (error) {
+	case GL_NO_ERROR:			return "GL_NO_ERROR";
+	case GL_INVALID_ENUM:		return "GL_INVALID_ENUM";
+	case GL_INVALID_OPERATION:	return "GL_INVALID_OPERATION";
+	case GL_STACK_OVERFLOW:		return "GL_STACK_OVERFLOW";
+	case GL_STACK_UNDERFLOW:	return "GL_STACK_UNDERFLOW";
+	case GL_OUT_OF_MEMORY:		return "GL_OUT_OF_MEMORY";
+	}
+
+	static char buf[40];
+	snprintf(buf, sizeof(buf), "(Unknown GL error code 0x%x)", error);
+	return buf;
+}
+
+void checkGlError(const char *file, int line) {
+	GLenum error = glGetError();
+	if (error != GL_NO_ERROR)
+		warning("%s:%d: GL error: %s", file, line, getGlErrStr(error));
+}
+
+#endif
diff --git a/backends/graphics/opengl/glerrorcheck.h b/backends/graphics/opengl/glerrorcheck.h
new file mode 100644
index 0000000000..a94699ce1d
--- /dev/null
+++ b/backends/graphics/opengl/glerrorcheck.h
@@ -0,0 +1,38 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if !defined(DEBUG)
+
+// If not in debug, do nothing
+#define CHECK_GL_ERROR() do {} while (false)
+
+#else
+
+// If in debug, check for an error after a GL call
+#define CHECK_GL_ERROR() checkGlError(__FILE__, __LINE__)
+
+void checkGlError(const char *file, int line);
+
+#endif
diff --git a/backends/graphics/opengl/gltexture.cpp b/backends/graphics/opengl/gltexture.cpp
new file mode 100644
index 0000000000..e43cbe2266
--- /dev/null
+++ b/backends/graphics/opengl/gltexture.cpp
@@ -0,0 +1,189 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined(USE_OPENGL)
+
+#include "backends/graphics/opengl/gltexture.h"
+#include "backends/graphics/opengl/glerrorcheck.h"
+
+#include "common/rect.h"
+#include "common/array.h"
+#include "common/util.h"
+#include "common/tokenizer.h"
+
+// Supported GL extensions
+static bool npot_supported = false;
+
+/*static inline GLint xdiv(int numerator, int denominator) {
+	assert(numerator < (1 << 16));
+	return (numerator << 16) / denominator;
+}*/
+
+static GLuint nextHigher2(GLuint v) {
+	if (v == 0)
+		return 1;
+	v--;
+	v |= v >> 1;
+	v |= v >> 2;
+	v |= v >> 4;
+	v |= v >> 8;
+	v |= v >> 16;
+	return ++v;
+}
+
+void GLTexture::initGLExtensions() {
+	static bool inited = false;
+
+	// Return if extensions were already checked
+	if (inited)
+		return;
+
+	// Get a string with all extensions
+	const char* ext_string =
+		reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
+	CHECK_GL_ERROR();
+	Common::StringTokenizer tokenizer(ext_string, " ");
+	// Iterate all string tokens
+	while (!tokenizer.empty()) {
+		Common::String token = tokenizer.nextToken();
+		if (token == "GL_ARB_texture_non_power_of_two")
+			npot_supported = true;
+	}
+
+	inited = true;
+}
+
+GLTexture::GLTexture(byte bpp, GLenum internalFormat, GLenum format, GLenum type)
+	:
+	_bytesPerPixel(bpp),
+	_internalFormat(internalFormat),
+	_glFormat(format),
+	_glType(type),
+	_textureWidth(0),
+	_textureHeight(0),
+	_realWidth(0),
+	_realHeight(0),
+	_refresh(false),
+	_filter(GL_NEAREST) {
+
+	// Generate the texture ID
+	glGenTextures(1, &_textureName); CHECK_GL_ERROR();
+}
+
+GLTexture::~GLTexture() {
+	// Delete the texture
+	glDeleteTextures(1, &_textureName); CHECK_GL_ERROR();
+}
+
+void GLTexture::refresh() {
+	// Delete previous texture
+	glDeleteTextures(1, &_textureName); CHECK_GL_ERROR();
+
+	// Generate the texture ID
+	glGenTextures(1, &_textureName); CHECK_GL_ERROR();
+	_refresh = true;
+}
+
+void GLTexture::allocBuffer(GLuint w, GLuint h) {
+	_realWidth = w;
+	_realHeight = h;
+	
+	if (w <= _textureWidth && h <= _textureHeight && !_refresh)
+		// Already allocated a sufficiently large buffer
+		return;
+
+	if (npot_supported) {
+		_textureWidth = w;
+		_textureHeight = h;
+	} else {
+		_textureWidth = nextHigher2(w);
+		_textureHeight = nextHigher2(h);
+	}
+
+	// Select this OpenGL texture
+	glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
+
+	// Set the texture parameters
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _filter); CHECK_GL_ERROR();
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, _filter); CHECK_GL_ERROR();
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
+
+	// Allocate room for the texture
+	glTexImage2D(GL_TEXTURE_2D, 0, _internalFormat,
+		_textureWidth, _textureHeight, 0, _glFormat, _glType, NULL); CHECK_GL_ERROR();
+
+	_refresh = false;
+}
+
+void GLTexture::updateBuffer(const void *buf, int pitch, GLuint x, GLuint y, GLuint w, GLuint h) {
+	// Select this OpenGL texture
+	glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
+
+	// Check if the buffer has its data contiguously
+	if (static_cast<int>(w) * _bytesPerPixel == pitch && w == _textureWidth) {
+		glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h,
+						_glFormat, _glType, buf); CHECK_GL_ERROR();
+	} else {
+		// Update the texture row by row
+		const byte *src = static_cast<const byte *>(buf);
+		do {
+			glTexSubImage2D(GL_TEXTURE_2D, 0, x, y,
+							w, 1, _glFormat, _glType, src); CHECK_GL_ERROR();
+			++y;
+			src += pitch;
+		} while (--h);
+	}
+}
+
+void GLTexture::drawTexture(GLshort x, GLshort y, GLshort w, GLshort h) {
+	// Select this OpenGL texture
+	glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
+
+	// Calculate the texture rect that will be drawn
+	const GLfloat texWidth = (GLfloat)_realWidth / _textureWidth;//xdiv(_surface.w, _textureWidth);
+	const GLfloat texHeight = (GLfloat)_realHeight / _textureHeight;//xdiv(_surface.h, _textureHeight);
+	const GLfloat texcoords[] = {
+		0, 0,
+		texWidth, 0,
+		0, texHeight,
+		texWidth, texHeight,
+	};
+	glTexCoordPointer(2, GL_FLOAT, 0, texcoords); CHECK_GL_ERROR();
+
+	// Calculate the screen rect where the texture will be drawn
+	const GLshort vertices[] = {
+		x,		y,
+		x + w,	y,
+		x,		y + h,
+		x + w,	y + h,
+	};
+	glVertexPointer(2, GL_SHORT, 0, vertices); CHECK_GL_ERROR();
+
+	// Draw the texture to the screen buffer
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); CHECK_GL_ERROR();
+}
+
+#endif
diff --git a/backends/graphics/opengl/gltexture.h b/backends/graphics/opengl/gltexture.h
new file mode 100644
index 0000000000..9864f6816c
--- /dev/null
+++ b/backends/graphics/opengl/gltexture.h
@@ -0,0 +1,115 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifdef WIN32
+#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
+#undef ARRAYSIZE
+#endif
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef ARRAYSIZE
+#endif
+
+#if defined(USE_GLES)
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+#elif defined(MACOSX)
+#include <gl.h>
+#include <glext.h>
+#else
+#include <GL/gl.h>
+#include <GL/glext.h>
+#endif
+
+#include "graphics/surface.h"
+
+#include "common/rect.h"
+#include "common/array.h"
+
+/**
+ * OpenGL texture manager class
+ */
+class GLTexture {
+public:
+	/**
+	 * Initialize OpenGL Extensions
+	 */
+	static void initGLExtensions();
+
+	GLTexture(byte bpp, GLenum internalFormat, GLenum format, GLenum type);
+	virtual ~GLTexture();
+
+	/**
+	 * Refresh the texture after a context change. The
+	 * process will be completed on next allocBuffer call.
+	 */
+	virtual void refresh();
+
+	/**
+	 * Allocates memory needed for the given size.
+	 */
+	virtual void allocBuffer(GLuint width, GLuint height);
+
+	/**
+	 * Updates the texture pixels.
+	 */
+	virtual void updateBuffer(const void *buf, int pitch, GLuint x, GLuint y,
+		GLuint w, GLuint h);
+
+	/**
+	 * Draws the texture to the screen buffer.
+	 */
+	virtual void drawTexture(GLshort x, GLshort y, GLshort w, GLshort h);
+
+	/**
+	 * Get the texture width.
+	 */
+	GLuint getWidth() const { return _realWidth; }
+
+	/**
+	 * Get the texture height.
+	 */
+	GLuint getHeight() const { return _realHeight; }
+
+	/**
+	 * Set the texture filter.
+	 * @filter the filter type, GL_NEAREST or GL_LINEAR
+	 */
+	void setFilter(GLint filter) { _filter = filter; }
+
+protected:
+	const byte _bytesPerPixel;
+	const GLenum _internalFormat;
+	const GLenum _glFormat;
+	const GLenum _glType;
+
+	GLuint _realWidth;
+	GLuint _realHeight;
+	GLuint _textureName;
+	GLuint _textureWidth;
+	GLuint _textureHeight;
+	GLint _filter;
+	bool _refresh;
+};
diff --git a/backends/graphics/opengl/opengl-graphics.cpp b/backends/graphics/opengl/opengl-graphics.cpp
new file mode 100644
index 0000000000..8682c54921
--- /dev/null
+++ b/backends/graphics/opengl/opengl-graphics.cpp
@@ -0,0 +1,1304 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined(USE_OPENGL)
+
+#include "backends/graphics/opengl/opengl-graphics.h"
+#include "backends/graphics/opengl/glerrorcheck.h"
+#include "common/config-manager.h"
+#include "common/file.h"
+#include "common/mutex.h"
+#include "common/translation.h"
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+
+OpenGLGraphicsManager::OpenGLGraphicsManager()
+	:
+#ifdef USE_OSD
+	_osdTexture(0), _osdAlpha(0), _osdFadeStartTime(0),
+#endif
+	_gameTexture(0), _overlayTexture(0), _cursorTexture(0),
+	_screenChangeCount(1 << (sizeof(int) * 8 - 2)), _screenNeedsRedraw(false),
+	_shakePos(0),
+	_overlayVisible(false), _overlayNeedsRedraw(false),
+	_transactionMode(kTransactionNone),
+	_cursorNeedsRedraw(false), _cursorPaletteDisabled(true),
+	_cursorVisible(false), _cursorKeyColor(0),
+	_cursorTargetScale(1),
+	_formatBGR(false),
+	_displayX(0), _displayY(0), _displayWidth(0), _displayHeight(0),
+	_aspectRatioCorrection(false) {
+
+	memset(&_oldVideoMode, 0, sizeof(_oldVideoMode));
+	memset(&_videoMode, 0, sizeof(_videoMode));
+	memset(&_transactionDetails, 0, sizeof(_transactionDetails));
+
+	_videoMode.mode = OpenGL::GFX_NORMAL;
+	_videoMode.scaleFactor = 2;
+	_videoMode.fullscreen = ConfMan.getBool("fullscreen");
+	_videoMode.antialiasing = false;
+
+	_gamePalette = (byte *)calloc(sizeof(byte) * 4, 256);
+	_cursorPalette = (byte *)calloc(sizeof(byte) * 4, 256);
+}
+
+OpenGLGraphicsManager::~OpenGLGraphicsManager() {
+	// Unregister the event observer
+	if (g_system->getEventManager()->getEventDispatcher() != NULL)
+		g_system->getEventManager()->getEventDispatcher()->unregisterObserver(this);
+
+	free(_gamePalette);
+	free(_cursorPalette);
+
+	if (_gameTexture != NULL)
+		delete _gameTexture;
+	if (_overlayTexture != NULL)
+		delete _overlayTexture;
+	if (_cursorTexture != NULL)
+		delete _cursorTexture;
+}
+
+void OpenGLGraphicsManager::initEventObserver() {
+	// Register the graphics manager as a event observer
+	g_system->getEventManager()->getEventDispatcher()->registerObserver(this, 10, false);
+}
+
+//
+// Feature
+//
+
+bool OpenGLGraphicsManager::hasFeature(OSystem::Feature f) {
+	return
+		(f == OSystem::kFeatureAspectRatioCorrection) ||
+		(f == OSystem::kFeatureCursorHasPalette);
+}
+
+void OpenGLGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+	switch (f) {
+	case OSystem::kFeatureAspectRatioCorrection:
+		_videoMode.mode = OpenGL::GFX_4_3;
+		_aspectRatioCorrection = enable;
+		break;
+	default:
+		break;
+	}
+}
+
+bool OpenGLGraphicsManager::getFeatureState(OSystem::Feature f) {
+	return false;
+}
+
+//
+// Screen format and modes
+//
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"gl1", _s("OpenGL Normal"), OpenGL::GFX_NORMAL},
+	{"gl2", _s("OpenGL Conserve"), OpenGL::GFX_CONSERVE},
+	{"gl3", _s("OpenGL 4/3"), OpenGL::GFX_4_3},
+	{"gl4", _s("OpenGL Original"), OpenGL::GFX_ORIGINAL},
+	{0, 0, 0}
+};
+
+const OSystem::GraphicsMode *OpenGLGraphicsManager::supportedGraphicsModes() {
+	return s_supportedGraphicsModes;
+}
+
+const OSystem::GraphicsMode *OpenGLGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int OpenGLGraphicsManager::getDefaultGraphicsMode() const {
+	return OpenGL::GFX_NORMAL;
+}
+
+bool OpenGLGraphicsManager::setGraphicsMode(int mode) {
+	assert(_transactionMode == kTransactionActive);
+
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return true;
+
+	switch (mode) {
+	case OpenGL::GFX_NORMAL:
+	case OpenGL::GFX_CONSERVE:
+	case OpenGL::GFX_4_3:
+	case OpenGL::GFX_ORIGINAL:
+		break;
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_videoMode.mode = mode;
+	_transactionDetails.needRefresh = true;
+
+	return true;
+}
+
+int OpenGLGraphicsManager::getGraphicsMode() const {
+	assert (_transactionMode == kTransactionNone);
+	return _videoMode.mode;
+}
+
+void OpenGLGraphicsManager::resetGraphicsScale() {
+	setScale(1);
+}
+
+#ifdef USE_RGB_COLOR
+
+Graphics::PixelFormat OpenGLGraphicsManager::getScreenFormat() const {
+	return _screenFormat;
+}
+
+#endif
+
+void OpenGLGraphicsManager::initSize(uint width, uint height, const Graphics::PixelFormat *format) {
+	assert(_transactionMode == kTransactionActive);
+
+#ifdef USE_RGB_COLOR
+	Graphics::PixelFormat newFormat;
+	if (!format)
+		newFormat = Graphics::PixelFormat::createFormatCLUT8();
+	else
+		newFormat = *format;
+
+	assert(newFormat.bytesPerPixel > 0);
+
+	// Avoid redundant format changes
+	if (newFormat != _videoMode.format) {
+		_videoMode.format = newFormat;
+		_transactionDetails.formatChanged = true;
+		_screenFormat = newFormat;
+	}
+#endif
+
+	// Avoid redundant res changes
+	if ((int)width == _videoMode.screenWidth && (int)height == _videoMode.screenHeight)
+		return;
+
+	_videoMode.screenWidth = width;
+	_videoMode.screenHeight = height;
+
+	_transactionDetails.sizeChanged = true;
+}
+
+int OpenGLGraphicsManager::getScreenChangeID() const {
+	return _screenChangeCount;
+}
+
+//
+// GFX
+//
+
+void OpenGLGraphicsManager::beginGFXTransaction() {
+	assert(_transactionMode == kTransactionNone);
+
+	_transactionMode = kTransactionActive;
+	_transactionDetails.sizeChanged = false;
+	_transactionDetails.needRefresh = false;
+	_transactionDetails.needUpdatescreen = false;
+	_transactionDetails.filterChanged = false;
+#ifdef USE_RGB_COLOR
+	_transactionDetails.formatChanged = false;
+#endif
+
+	_oldVideoMode = _videoMode;
+}
+
+OSystem::TransactionError OpenGLGraphicsManager::endGFXTransaction() {
+	int errors = OSystem::kTransactionSuccess;
+
+	assert(_transactionMode != kTransactionNone);
+
+	if (_transactionMode == kTransactionRollback) {
+		if (_videoMode.fullscreen != _oldVideoMode.fullscreen) {
+			errors |= OSystem::kTransactionFullscreenFailed;
+
+			_videoMode.fullscreen = _oldVideoMode.fullscreen;
+		} else if (_videoMode.mode != _oldVideoMode.mode) {
+			errors |= OSystem::kTransactionModeSwitchFailed;
+
+			_videoMode.mode = _oldVideoMode.mode;
+			_videoMode.scaleFactor = _oldVideoMode.scaleFactor;
+#ifdef USE_RGB_COLOR
+		} else if (_videoMode.format != _oldVideoMode.format) {
+			errors |= OSystem::kTransactionFormatNotSupported;
+
+			_videoMode.format = _oldVideoMode.format;
+			_screenFormat = _videoMode.format;
+#endif
+		} else if (_videoMode.screenWidth != _oldVideoMode.screenWidth || _videoMode.screenHeight != _oldVideoMode.screenHeight) {
+			errors |= OSystem::kTransactionSizeChangeFailed;
+
+			_videoMode.screenWidth = _oldVideoMode.screenWidth;
+			_videoMode.screenHeight = _oldVideoMode.screenHeight;
+			_videoMode.overlayWidth = _oldVideoMode.overlayWidth;
+			_videoMode.overlayHeight = _oldVideoMode.overlayHeight;
+		}
+
+		if (_videoMode.fullscreen == _oldVideoMode.fullscreen &&
+			_videoMode.mode == _oldVideoMode.mode &&
+			_videoMode.screenWidth == _oldVideoMode.screenWidth &&
+			_videoMode.screenHeight == _oldVideoMode.screenHeight) {
+
+			_oldVideoMode.setup = false;
+		}
+	}
+
+	if (_transactionDetails.sizeChanged || _transactionDetails.needRefresh) {
+		unloadGFXMode();
+		if (!loadGFXMode()) {
+			if (_oldVideoMode.setup) {
+				_transactionMode = kTransactionRollback;
+				errors |= endGFXTransaction();
+			}
+		} else {
+			clearOverlay();
+
+			_videoMode.setup = true;
+			_screenChangeCount++;
+		}
+#ifdef USE_RGB_COLOR
+	} else if (_transactionDetails.filterChanged || _transactionDetails.formatChanged) {
+#else
+	} else if (_transactionDetails.filterChanged) {
+#endif
+		loadTextures();
+		internUpdateScreen();
+	} else if (_transactionDetails.needUpdatescreen) {
+		internUpdateScreen();
+	}
+
+	_transactionMode = kTransactionNone;
+	return (OSystem::TransactionError)errors;
+}
+
+//
+// Screen
+//
+
+int16 OpenGLGraphicsManager::getHeight() {
+	return _videoMode.screenHeight;
+}
+
+int16 OpenGLGraphicsManager::getWidth() {
+	return _videoMode.screenWidth;
+}
+
+void OpenGLGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+	
+#ifdef USE_RGB_COLOR
+	assert(_screenFormat.bytesPerPixel == 1);
+#endif
+
+	// Save the screen palette
+	memcpy(_gamePalette + start * 4, colors, num * 4);
+
+	_screenNeedsRedraw = true;
+
+	if (_cursorPaletteDisabled)
+		_cursorNeedsRedraw = true;
+}
+
+void OpenGLGraphicsManager::grabPalette(byte *colors, uint start, uint num) {
+	assert(colors);
+	
+#ifdef USE_RGB_COLOR
+	assert(_screenFormat.bytesPerPixel == 1);
+#endif
+
+	// Copies current palette to buffer
+	memcpy(colors, _gamePalette + start * 4, num * 4);
+}
+
+void OpenGLGraphicsManager::copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) {
+	assert(x >= 0 && x < _screenData.w);
+	assert(y >= 0 && y < _screenData.h);
+	assert(h > 0 && y + h <= _screenData.h);
+	assert(w > 0 && x + w <= _screenData.w);
+
+	// Copy buffer data to game screen internal buffer
+	const byte *src = buf;
+	byte *dst = (byte *)_screenData.pixels + y * _screenData.pitch;
+	for (int i = 0; i < h; i++) {
+		memcpy(dst + x * _screenData.bytesPerPixel, src, w * _screenData.bytesPerPixel);
+		src += pitch;
+		dst += _screenData.pitch;
+	}
+
+	// Extend dirty area if not full screen redraw is flagged
+	if (!_screenNeedsRedraw) {
+		const Common::Rect dirtyRect(x, y, x + w, y + h);
+		_screenDirtyRect.extend(dirtyRect);
+	}
+}
+
+Graphics::Surface *OpenGLGraphicsManager::lockScreen() {
+	return &_screenData;
+}
+
+void OpenGLGraphicsManager::unlockScreen() {
+	_screenNeedsRedraw = true;
+}
+
+void OpenGLGraphicsManager::fillScreen(uint32 col) {
+	if (_gameTexture == NULL)
+		return;
+
+	if (_screenFormat.bytesPerPixel == 1) {
+		memset(_screenData.pixels, col, _screenData.h * _screenData.pitch);
+	} else if (_screenFormat.bytesPerPixel == 2) {
+		uint16 *pixels = (uint16 *)_screenData.pixels;
+		uint16 col16 = (uint16)col;
+		for (int i = 0; i < _screenData.w * _screenData.h; i++) {
+			pixels[i] = col16;
+		}
+	} else if (_screenFormat.bytesPerPixel == 3) {
+		uint8 *pixels = (uint8 *)_screenData.pixels;
+		byte r = (col >> 16) & 0xFF;
+		byte g = (col >> 8) & 0xFF;
+		byte b = col & 0xFF;
+		for (int i = 0; i < _screenData.w * _screenData.h; i++) {
+			pixels[0] = r;
+			pixels[1] = g;
+			pixels[2] = b;
+			pixels += 3;
+		}
+	} else if (_screenFormat.bytesPerPixel == 4) {
+		uint32 *pixels = (uint32 *)_screenData.pixels;
+		for (int i = 0; i < _screenData.w * _screenData.h; i++) {
+			pixels[i] = col;
+		}
+	}
+
+	_screenNeedsRedraw = true;
+}
+
+void OpenGLGraphicsManager::updateScreen() {
+	assert (_transactionMode == kTransactionNone);
+	internUpdateScreen();
+}
+
+void OpenGLGraphicsManager::setShakePos(int shakeOffset) {
+	assert (_transactionMode == kTransactionNone);
+	_shakePos = shakeOffset;
+}
+
+void OpenGLGraphicsManager::setFocusRectangle(const Common::Rect& rect) {
+
+}
+
+void OpenGLGraphicsManager::clearFocusRectangle() {
+
+}
+
+//
+// Overlay
+//
+
+void OpenGLGraphicsManager::showOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayVisible)
+		return;
+
+	_overlayVisible = true;
+
+	clearOverlay();
+}
+
+void OpenGLGraphicsManager::hideOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	if (!_overlayVisible)
+		return;
+
+	_overlayVisible = false;
+
+	clearOverlay();
+}
+
+Graphics::PixelFormat OpenGLGraphicsManager::getOverlayFormat() const {
+	return _overlayFormat;
+}
+
+void OpenGLGraphicsManager::clearOverlay() {
+	// Set all pixels to 0
+	memset(_overlayData.pixels, 0, _overlayData.h * _overlayData.pitch);
+	_overlayNeedsRedraw = true;
+}
+
+void OpenGLGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
+	assert(_overlayData.bytesPerPixel == sizeof(buf[0]));
+	const byte *src = (byte *)_overlayData.pixels;
+	for (int i = 0; i < _overlayData.h; i++) {
+		// Copy overlay data to buffer
+		memcpy(buf, src, _overlayData.pitch);
+		buf += pitch;
+		src += _overlayData.pitch;
+	}
+}
+
+void OpenGLGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayTexture == NULL)
+		return;
+
+	// Clip the coordinates
+	if (x < 0) {
+		w += x;
+		buf -= x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y; buf -= y * pitch;
+		y = 0;
+	}
+
+	if (w > _overlayData.w - x)
+		w = _overlayData.w - x;
+
+	if (h > _overlayData.h - y)
+		h = _overlayData.h - y;
+
+	if (w <= 0 || h <= 0)
+		return;
+
+	if (_overlayFormat.aBits() == 1) {
+		// Copy buffer with the alpha bit on for all pixels for correct
+		// overlay drawing.
+		const uint16 *src = (const uint16 *)buf;
+		uint16 *dst = (uint16 *)_overlayData.pixels + y * _overlayData.w + x;
+		for (int i = 0; i < h; i++) {
+			for (int e = 0; e < w; e++)
+				dst[e] = src[e] | 0x1;
+			src += pitch;
+			dst += _overlayData.w;
+		}
+	} else {
+		// Copy buffer data to internal overlay surface
+		const byte *src = (const byte *)buf;
+		byte *dst = (byte *)_overlayData.pixels + y * _overlayData.pitch;
+		for (int i = 0; i < h; i++) {
+			memcpy(dst + x * _overlayData.bytesPerPixel, src, w * _overlayData.bytesPerPixel);
+			src += pitch * sizeof(buf[0]);
+			dst += _overlayData.pitch;
+		}
+	}
+
+	// Extend dirty area if not full screen redraw is flagged
+	if (!_overlayNeedsRedraw) {
+		const Common::Rect dirtyRect(x, y, x + w, y + h);
+		_overlayDirtyRect.extend(dirtyRect);
+	}
+}
+
+int16 OpenGLGraphicsManager::getOverlayHeight() {
+	return _videoMode.overlayHeight;
+}
+
+int16 OpenGLGraphicsManager::getOverlayWidth() {
+	return _videoMode.overlayWidth;
+}
+
+//
+// Cursor
+//
+
+bool OpenGLGraphicsManager::showMouse(bool visible) {
+	if (_cursorVisible == visible)
+		return visible;
+
+	bool last = _cursorVisible;
+	_cursorVisible = visible;
+
+	return last;
+}
+
+void OpenGLGraphicsManager::setMousePos(int x, int y) {
+	_cursorState.x = x;
+	_cursorState.y = y;
+}
+
+void OpenGLGraphicsManager::warpMouse(int x, int y) {
+	setMousePos(x, y);
+}
+
+void OpenGLGraphicsManager::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) {
+#ifdef USE_RGB_COLOR
+	if (format)
+		_cursorFormat = *format;
+	else
+		_cursorFormat = Graphics::PixelFormat::createFormatCLUT8();
+#else
+	assert(keycolor <= 255);
+	_cursorFormat = Graphics::PixelFormat::createFormatCLUT8();
+#endif
+
+	// Allocate space for cursor data
+	if (_cursorData.w != w || _cursorData.h != h)
+		_cursorData.create(w, h, _cursorFormat.bytesPerPixel);
+
+	// Save cursor data
+	memcpy(_cursorData.pixels, buf, h * _cursorData.pitch);
+
+	// Set cursor info
+	_cursorState.w = w;
+	_cursorState.h = h;
+	_cursorState.hotX = hotspotX;
+	_cursorState.hotY = hotspotY;
+	_cursorKeyColor = keycolor;
+	_cursorTargetScale = cursorTargetScale;
+	_cursorNeedsRedraw = true;
+
+	refreshCursorScale();
+}
+
+void OpenGLGraphicsManager::setCursorPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+	
+	// Save the cursor palette
+	memcpy(_cursorPalette + start * 4, colors, num * 4);
+
+	_cursorPaletteDisabled = false;
+	_cursorNeedsRedraw = true;
+}
+
+void OpenGLGraphicsManager::disableCursorPalette(bool disable) {
+	_cursorPaletteDisabled = disable;
+	_cursorNeedsRedraw = true;
+}
+
+//
+// Misc
+//
+
+void OpenGLGraphicsManager::displayMessageOnOSD(const char *msg) {
+	assert (_transactionMode == kTransactionNone);
+	assert(msg);
+
+	// The font we are going to use:
+	const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kOSDFont);
+
+	if (_osdSurface.w != _osdTexture->getWidth() || _osdSurface.h != _osdTexture->getHeight())
+		_osdSurface.create(_osdTexture->getWidth(), _osdTexture->getHeight(), 2);
+	else
+		// Clear everything
+		memset(_osdSurface.pixels, 0, _osdSurface.h * _osdSurface.pitch);
+
+	// Split the message into separate lines.
+	Common::Array<Common::String> lines;
+	const char *ptr;
+	for (ptr = msg; *ptr; ++ptr) {
+		if (*ptr == '\n') {
+			lines.push_back(Common::String(msg, ptr - msg));
+			msg = ptr + 1;
+		}
+	}
+	lines.push_back(Common::String(msg, ptr - msg));
+
+	// Determine a rect which would contain the message string (clipped to the
+	// screen dimensions).
+	const int vOffset = 6;
+	const int lineSpacing = 1;
+	const int lineHeight = font->getFontHeight() + 2 * lineSpacing;
+	int width = 0;
+	int height = lineHeight * lines.size() + 2 * vOffset;
+	for (uint i = 0; i < lines.size(); i++) {
+		width = MAX(width, font->getStringWidth(lines[i]) + 14);
+	}
+
+	// Clip the rect
+	if (width > _osdSurface.w)
+		width = _osdSurface.w;
+	if (height > _osdSurface.h)
+		height = _osdSurface.h;
+
+	int dstX = (_osdSurface.w - width) / 2;
+	int dstY = (_osdSurface.h - height) / 2;
+
+	// Draw a dark gray rect
+	uint16 color = 0x294B;
+	uint16 *dst = (uint16 *)_osdSurface.pixels + dstY * _osdSurface.w + dstX;
+	for (int i = 0; i < height; i++) {
+		for (int j = 0; j < width; j++)
+			dst[j] = color;
+		dst += _osdSurface.w;
+	}
+
+	// Render the message, centered, and in white
+	for (uint i = 0; i < lines.size(); i++) {
+		font->drawString(&_osdSurface, lines[i],
+							dstX, dstY + i * lineHeight + vOffset + lineSpacing, width,
+							0xFFFF, Graphics::kTextAlignCenter);
+	}
+
+	// Update the texture
+	_osdTexture->updateBuffer(_osdSurface.pixels, _osdSurface.pitch, 0, 0, 
+		_osdSurface.w, _osdSurface.h);
+
+	// Init the OSD display parameters, and the fade out
+	_osdAlpha = kOSDInitialAlpha;
+	_osdFadeStartTime = g_system->getMillis() + kOSDFadeOutDelay;
+}
+
+//
+// Intern
+//
+
+void OpenGLGraphicsManager::refreshGameScreen() {
+	if (_screenNeedsRedraw)
+		_screenDirtyRect = Common::Rect(0, 0, _screenData.w, _screenData.h);
+
+	int x = _screenDirtyRect.left;
+	int y = _screenDirtyRect.top;
+	int w = _screenDirtyRect.width();
+	int h = _screenDirtyRect.height();
+
+	if (_screenData.bytesPerPixel == 1) {
+		// Create a temporary RGB888 surface
+		byte *surface = new byte[w * h * 3];
+
+		// Convert the paletted buffer to RGB888
+		const byte *src = (byte *)_screenData.pixels + y * _screenData.pitch;
+		src += x * _screenData.bytesPerPixel;
+		byte *dst = surface;
+		for (int i = 0; i < h; i++) {
+			for (int j = 0; j < w; j++) {
+				dst[0] = _gamePalette[src[j] * 4];
+				dst[1] = _gamePalette[src[j] * 4 + 1];
+				dst[2] = _gamePalette[src[j] * 4 + 2];
+				dst += 3;
+			}
+			src += _screenData.pitch;
+		}
+
+		// Update the texture
+		_gameTexture->updateBuffer(surface, w * 3, x, y, w, h);
+
+		// Free the temp surface
+		delete[] surface;
+	} else {
+		// Update the texture
+		_gameTexture->updateBuffer((byte *)_screenData.pixels + y * _screenData.pitch +
+			x * _screenData.bytesPerPixel, _screenData.pitch, x, y, w, h);
+	}
+
+	_screenNeedsRedraw = false;
+	_screenDirtyRect = Common::Rect();
+}
+
+void OpenGLGraphicsManager::refreshOverlay() {
+	if (_overlayNeedsRedraw)
+		_overlayDirtyRect = Common::Rect(0, 0, _overlayData.w, _overlayData.h);
+
+	int x = _overlayDirtyRect.left;
+	int y = _overlayDirtyRect.top;
+	int w = _overlayDirtyRect.width();
+	int h = _overlayDirtyRect.height();
+
+	if (_overlayData.bytesPerPixel == 1) {
+		// Create a temporary RGB888 surface
+		byte *surface = new byte[w * h * 3];
+
+		// Convert the paletted buffer to RGB888
+		const byte *src = (byte *)_overlayData.pixels + y * _overlayData.pitch;
+		src += x * _overlayData.bytesPerPixel;
+		byte *dst = surface;
+		for (int i = 0; i < h; i++) {
+			for (int j = 0; j < w; j++) {
+				dst[0] = _gamePalette[src[j] * 4];
+				dst[1] = _gamePalette[src[j] * 4 + 1];
+				dst[2] = _gamePalette[src[j] * 4 + 2];
+				dst += 3;
+			}
+			src += _screenData.pitch;
+		}
+
+		// Update the texture
+		_overlayTexture->updateBuffer(surface, w * 3, x, y, w, h);
+
+		// Free the temp surface
+		delete[] surface;
+	} else {
+		// Update the texture
+		_overlayTexture->updateBuffer((byte *)_overlayData.pixels + y * _overlayData.pitch +
+			x * _overlayData.bytesPerPixel, _overlayData.pitch, x, y, w, h);
+	}
+
+	_overlayNeedsRedraw = false;
+	_overlayDirtyRect = Common::Rect();
+}
+
+void OpenGLGraphicsManager::refreshCursor() {
+	_cursorNeedsRedraw = false;
+
+	if (_cursorFormat.bytesPerPixel == 1) {
+		// Create a temporary RGBA8888 surface
+		byte *surface = new byte[_cursorState.w * _cursorState.h * 4];
+		memset(surface, 0, _cursorState.w * _cursorState.h * 4);
+
+		// Select palette
+		byte *palette;
+		if (_cursorPaletteDisabled)
+			palette = _gamePalette;
+		else
+			palette = _cursorPalette;
+
+		// Convert the paletted cursor to RGBA8888
+		const byte *src = (byte *)_cursorData.pixels;
+		byte *dst = surface;
+		for (int i = 0; i < _cursorState.w * _cursorState.h; i++) {
+			// Check for keycolor
+			if (src[i] != _cursorKeyColor) {
+				dst[0] = palette[src[i] * 4];
+				dst[1] = palette[src[i] * 4 + 1];
+				dst[2] = palette[src[i] * 4 + 2];
+				dst[3] = 255;
+			}
+			dst += 4;
+		}
+
+		// Allocate a texture big enough for cursor
+		_cursorTexture->allocBuffer(_cursorState.w, _cursorState.h);
+
+		// Update the texture with new cursor
+		_cursorTexture->updateBuffer(surface, _cursorState.w * 4, 0, 0, _cursorState.w, _cursorState.h);
+
+		// Free the temp surface
+		delete[] surface;
+	}
+}
+
+void OpenGLGraphicsManager::refreshCursorScale() {
+	// Get the window minimum scale factor. The cursor will mantain its original aspect
+	// ratio, and we do not want it to get too big if only one dimension is resized
+	uint screenScaleFactor = MIN(_videoMode.hardwareWidth * 10000 / _videoMode.screenWidth,
+		_videoMode.hardwareHeight * 10000 / _videoMode.screenHeight);
+
+	// Do not scale cursor if original size is used
+	if (_videoMode.mode == OpenGL::GFX_ORIGINAL)
+		screenScaleFactor = _videoMode.scaleFactor * 10000;
+
+	if ((uint)_cursorTargetScale * 10000 >= screenScaleFactor && (uint)_videoMode.scaleFactor * 10000 >= screenScaleFactor) {
+		// If the cursor target scale and the video mode scale factor are bigger than
+		// the current window scale, do not scale the cursor for the overlay
+		_cursorState.rW = _cursorState.w;
+		_cursorState.rH = _cursorState.h;
+		_cursorState.rHotX = _cursorState.hotX;
+		_cursorState.rHotY = _cursorState.hotY;
+	} else {
+		// Otherwise, scale the cursor for the overlay
+		int targetScaleFactor = MIN(_cursorTargetScale, _videoMode.scaleFactor);
+		int actualFactor = screenScaleFactor - (targetScaleFactor - 1) * 10000;
+		_cursorState.rW = (int16)(_cursorState.w * actualFactor / 10000);
+		_cursorState.rH = (int16)(_cursorState.h * actualFactor / 10000);
+		_cursorState.rHotX = (int16)(_cursorState.hotX * actualFactor / 10000);
+		_cursorState.rHotY = (int16)(_cursorState.hotY * actualFactor / 10000);
+	}
+
+	// Always scale the cursor for the game
+	_cursorState.vW = (int16)(_cursorState.w * screenScaleFactor / 10000);
+	_cursorState.vH = (int16)(_cursorState.h * screenScaleFactor / 10000);
+	_cursorState.vHotX = (int16)(_cursorState.hotX * screenScaleFactor / 10000);
+	_cursorState.vHotY = (int16)(_cursorState.hotY * screenScaleFactor / 10000);
+}
+
+void OpenGLGraphicsManager::calculateDisplaySize(int &width, int &height) {
+	if (_videoMode.mode == OpenGL::GFX_ORIGINAL) {
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+	} else {
+		width = _videoMode.hardwareWidth;
+		height = _videoMode.hardwareHeight;
+
+		uint aspectRatio = (_videoMode.hardwareWidth * 10000 + 5000) / _videoMode.hardwareHeight;
+		uint desiredAspectRatio = getAspectRatio();
+
+		// Adjust one screen dimension for mantaining the aspect ratio
+		if (aspectRatio < desiredAspectRatio)
+			height = (width * 10000 + 5000) / desiredAspectRatio;
+		else if (aspectRatio > desiredAspectRatio)
+			width = (height * desiredAspectRatio + 5000) / 10000;
+	}
+}
+
+void OpenGLGraphicsManager::refreshDisplaySize() {
+	calculateDisplaySize(_displayWidth, _displayHeight);
+
+	// Adjust x and y for centering the screen
+	_displayX = (_videoMode.hardwareWidth - _displayWidth) / 2;
+	_displayY = (_videoMode.hardwareHeight - _displayHeight) / 2;
+}
+
+void OpenGLGraphicsManager::getGLPixelFormat(Graphics::PixelFormat pixelFormat, byte &bpp, GLenum &intFormat, GLenum &glFormat, GLenum &gltype) {
+	if (pixelFormat == Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)) { // RGBA8888
+		bpp = 4;
+		intFormat = GL_RGBA;
+		glFormat = GL_RGBA;
+		gltype = GL_UNSIGNED_BYTE;
+	} else if (pixelFormat == Graphics::PixelFormat(3, 8, 8, 8, 0, 16, 8, 0, 0)) { // RGB888
+		bpp = 3;
+		intFormat = GL_RGB;
+		glFormat = GL_RGB;
+		gltype = GL_UNSIGNED_BYTE;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0)) { // RGB565
+		bpp = 2;
+		intFormat = GL_RGB;
+		glFormat = GL_RGB;
+		gltype = GL_UNSIGNED_SHORT_5_6_5;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0)) { // RGB5551
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_RGBA;
+		gltype = GL_UNSIGNED_SHORT_5_5_5_1;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0)) { // RGBA4444
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_RGBA;
+		gltype = GL_UNSIGNED_SHORT_4_4_4_4;
+	} else if (pixelFormat.bytesPerPixel == 1) { // CLUT8
+		// If uses a palette, create texture as RGB888. The pixel data will be converted
+		// later.
+		bpp = 3;
+		intFormat = GL_RGB;
+		glFormat = GL_RGB;
+		gltype = GL_UNSIGNED_BYTE;
+#ifndef USE_GLES
+	} else if (pixelFormat == Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24)) { // ARGB8888
+		bpp = 4;
+		intFormat = GL_RGBA;
+		glFormat = GL_BGRA;
+		gltype = GL_UNSIGNED_INT_8_8_8_8_REV;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 4, 4, 4, 4, 8, 4, 0, 12)) { // ARGB4444
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_BGRA;
+		gltype = GL_UNSIGNED_SHORT_4_4_4_4_REV;
+	} else if (pixelFormat == Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24)) { // ABGR8888
+		bpp = 4;
+		intFormat = GL_RGBA;
+		glFormat = GL_RGBA;
+		gltype = GL_UNSIGNED_INT_8_8_8_8_REV;
+	} else if (pixelFormat == Graphics::PixelFormat(4, 8, 8, 8, 8, 8, 16, 24, 0)) { // BGRA8888
+		bpp = 4;
+		intFormat = GL_RGBA;
+		glFormat = GL_BGRA;
+		gltype = GL_UNSIGNED_BYTE;
+	} else if (pixelFormat == Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 8, 16, 0)) { // BGR888
+		bpp = 3;
+		intFormat = GL_RGB;
+		glFormat = GL_BGR;
+		gltype = GL_UNSIGNED_BYTE;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 5, 6, 5, 0, 0, 5, 11, 0)) { // BGR565
+		bpp = 2;
+		intFormat = GL_RGB;
+		glFormat = GL_BGR;
+		gltype = GL_UNSIGNED_SHORT_5_6_5;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 5, 5, 5, 1, 1, 6, 11, 0)) { // BGRA5551
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_BGRA;
+		gltype = GL_UNSIGNED_SHORT_5_5_5_1;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 4, 4, 4, 4, 0, 4, 8, 12)) { // ABGR4444
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_RGBA;
+		gltype = GL_UNSIGNED_SHORT_4_4_4_4_REV;
+	} else if (pixelFormat == Graphics::PixelFormat(2, 4, 4, 4, 4, 4, 8, 12, 0)) { // BGRA4444
+		bpp = 2;
+		intFormat = GL_RGBA;
+		glFormat = GL_BGRA;
+		gltype = GL_UNSIGNED_SHORT_4_4_4_4;
+#endif
+	} else {
+		error("OpenGLGraphicsManager: Pixel format not supported");
+	}
+}
+
+void OpenGLGraphicsManager::internUpdateScreen() {
+	// Clear the screen buffer
+	glClear(GL_COLOR_BUFFER_BIT); CHECK_GL_ERROR();
+
+	if (_screenNeedsRedraw || !_screenDirtyRect.isEmpty())
+		// Refresh texture if dirty
+		refreshGameScreen();
+
+	int scaleFactor = _videoMode.hardwareHeight / _videoMode.screenHeight;
+
+	glPushMatrix();
+
+	// Adjust game screen shake position
+	glTranslatef(0, _shakePos * scaleFactor, 0); CHECK_GL_ERROR();
+
+	// Draw the game screen
+	_gameTexture->drawTexture(_displayX, _displayY, _displayWidth, _displayHeight);
+
+	glPopMatrix();
+
+	if (_overlayVisible) {
+		if (_overlayNeedsRedraw || !_overlayDirtyRect.isEmpty())
+			// Refresh texture if dirty
+			refreshOverlay();
+
+		// Draw the overlay
+		_overlayTexture->drawTexture(_displayX, _displayY, _displayWidth, _displayHeight);
+	}
+
+	if (_cursorVisible) {
+		if (_cursorNeedsRedraw)
+			// Refresh texture if dirty
+			refreshCursor();
+
+		glPushMatrix();
+
+		// Adjust mouse shake position, unless the overlay is visible
+		glTranslatef(0, _overlayVisible ? 0 : _shakePos * scaleFactor, 0); CHECK_GL_ERROR();
+
+		// Draw the cursor
+		if (_overlayVisible)
+			_cursorTexture->drawTexture(_cursorState.x - _cursorState.rHotX,
+				_cursorState.y - _cursorState.rHotY, _cursorState.rW, _cursorState.rH);
+		else
+			_cursorTexture->drawTexture(_cursorState.x - _cursorState.vHotX,
+				_cursorState.y - _cursorState.vHotY, _cursorState.vW, _cursorState.vH);
+
+		glPopMatrix();
+	}
+
+#ifdef USE_OSD
+	if (_osdAlpha > 0) {
+		// Update alpha value
+		const int diff = g_system->getMillis() - _osdFadeStartTime;
+		if (diff > 0) {
+			if (diff >= kOSDFadeOutDuration) {
+				// Back to full transparency
+				_osdAlpha = 0;
+			} else {
+				// Do a fade out
+				_osdAlpha = kOSDInitialAlpha - diff * kOSDInitialAlpha / kOSDFadeOutDuration;
+			}
+		}
+		// Set the osd transparency
+		glColor4f(1.0f, 1.0f, 1.0f, _osdAlpha / 100.0f); CHECK_GL_ERROR();
+
+		// Draw the osd texture
+		_osdTexture->drawTexture(0, 0, _videoMode.hardwareWidth, _videoMode.hardwareHeight);
+
+		// Reset color
+		glColor4f(1.0f, 1.0f, 1.0f, 1.0f); CHECK_GL_ERROR();
+	}
+#endif
+}
+
+void OpenGLGraphicsManager::initGL() {
+	// Check available GL Extensions
+	GLTexture::initGLExtensions();
+
+	// Disable 3D properties
+	glDisable(GL_CULL_FACE); CHECK_GL_ERROR();
+	glDisable(GL_DEPTH_TEST); CHECK_GL_ERROR();
+	glDisable(GL_LIGHTING); CHECK_GL_ERROR();
+	glDisable(GL_FOG); CHECK_GL_ERROR();
+	glDisable(GL_DITHER); CHECK_GL_ERROR();
+	glShadeModel(GL_FLAT); CHECK_GL_ERROR();
+	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); CHECK_GL_ERROR();
+
+	// Setup alpha blend (For overlay and cursor)
+	glEnable(GL_BLEND); CHECK_GL_ERROR();
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); CHECK_GL_ERROR();
+
+	// Enable rendering with vertex and coord arrays
+	glEnableClientState(GL_VERTEX_ARRAY); CHECK_GL_ERROR();
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY); CHECK_GL_ERROR();
+
+	glEnable(GL_TEXTURE_2D); CHECK_GL_ERROR();
+
+	// Setup the GL viewport
+	glViewport(0, 0, _videoMode.hardwareWidth, _videoMode.hardwareHeight); CHECK_GL_ERROR();
+
+	// Setup coordinates system
+	glMatrixMode(GL_PROJECTION); CHECK_GL_ERROR();
+	glLoadIdentity(); CHECK_GL_ERROR();
+#ifdef USE_GLES
+	glOrthox(0, _videoMode.hardwareWidth, _videoMode.hardwareHeight, 0, -1, 1); CHECK_GL_ERROR();
+#else
+	glOrtho(0, _videoMode.hardwareWidth, _videoMode.hardwareHeight, 0, -1, 1); CHECK_GL_ERROR();
+#endif
+	glMatrixMode(GL_MODELVIEW); CHECK_GL_ERROR();
+	glLoadIdentity(); CHECK_GL_ERROR();
+}
+
+void OpenGLGraphicsManager::loadTextures() {
+#ifdef USE_RGB_COLOR
+	if (_transactionDetails.formatChanged && _gameTexture)
+		delete _gameTexture;
+#endif
+
+	if (!_gameTexture) {
+		byte bpp;
+		GLenum intformat;
+		GLenum format;
+		GLenum type;
+#ifdef USE_RGB_COLOR
+		getGLPixelFormat(_screenFormat, bpp, intformat, format, type);
+#else
+		getGLPixelFormat(Graphics::PixelFormat::createFormatCLUT8(), bpp, intformat, format, type);
+#endif
+		_gameTexture = new GLTexture(bpp, intformat, format, type);
+	} else
+		_gameTexture->refresh();
+
+	_overlayFormat = Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0);
+
+	if (!_overlayTexture) {
+		byte bpp;
+		GLenum intformat;
+		GLenum format;
+		GLenum type;
+		getGLPixelFormat(_overlayFormat, bpp, intformat, format, type);
+		_overlayTexture = new GLTexture(bpp, intformat, format, type);
+	} else
+		_overlayTexture->refresh();
+
+	if (!_cursorTexture)
+		_cursorTexture = new GLTexture(4, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE);
+	else
+		_cursorTexture->refresh();
+		
+	GLint filter = _videoMode.antialiasing ? GL_LINEAR : GL_NEAREST;
+	_gameTexture->setFilter(filter);
+	_overlayTexture->setFilter(filter);
+	_cursorTexture->setFilter(filter);
+
+	// Allocate texture memory and finish refreshing
+	_gameTexture->allocBuffer(_videoMode.screenWidth, _videoMode.screenHeight);
+	_overlayTexture->allocBuffer(_videoMode.overlayWidth, _videoMode.overlayHeight);
+	_cursorTexture->allocBuffer(_cursorState.w, _cursorState.h);
+
+	if (_transactionDetails.formatChanged || 
+			_oldVideoMode.screenWidth != _videoMode.screenWidth ||
+			_oldVideoMode.screenHeight != _videoMode.screenHeight)
+		_screenData.create(_videoMode.screenWidth, _videoMode.screenHeight,
+			_screenFormat.bytesPerPixel);
+
+	if (_oldVideoMode.overlayWidth != _videoMode.overlayWidth ||
+		_oldVideoMode.overlayHeight != _videoMode.overlayHeight)
+		_overlayData.create(_videoMode.overlayWidth, _videoMode.overlayHeight,
+			_overlayFormat.bytesPerPixel);
+	
+	_screenNeedsRedraw = true;
+	_overlayNeedsRedraw = true;
+	_cursorNeedsRedraw = true;
+
+#ifdef USE_OSD
+	if (!_osdTexture)
+		_osdTexture = new GLTexture(2, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1);
+	else
+		_osdTexture->refresh();
+
+	_osdTexture->allocBuffer(_videoMode.overlayWidth, _videoMode.overlayHeight);
+#endif
+}
+
+bool OpenGLGraphicsManager::loadGFXMode() {
+	// Initialize OpenGL settings
+	initGL();
+
+	loadTextures();
+
+	refreshCursorScale();
+
+	refreshDisplaySize();
+
+	internUpdateScreen();
+
+	return true;
+}
+
+void OpenGLGraphicsManager::unloadGFXMode() {
+
+}
+
+void OpenGLGraphicsManager::setScale(int newScale) {
+	if (newScale == _videoMode.scaleFactor)
+		return;
+
+	_videoMode.scaleFactor = newScale;
+	_transactionDetails.sizeChanged = true;
+}
+
+uint OpenGLGraphicsManager::getAspectRatio() {
+	if (_videoMode.mode == OpenGL::GFX_NORMAL)
+		return _videoMode.hardwareWidth * 10000 / _videoMode.hardwareHeight;
+	else if (_videoMode.mode == OpenGL::GFX_4_3)
+		return 13333;
+	else
+		return _videoMode.screenWidth * 10000 / _videoMode.screenHeight;
+}
+
+void OpenGLGraphicsManager::adjustMouseEvent(const Common::Event &event) {
+	if (!event.synthetic) {
+		Common::Event newEvent(event);
+		newEvent.synthetic = true;
+
+		if (_videoMode.mode == OpenGL::GFX_NORMAL) {
+			if (_videoMode.hardwareWidth != _videoMode.overlayWidth)
+				newEvent.mouse.x = newEvent.mouse.x * _videoMode.overlayWidth / _videoMode.hardwareWidth;
+			if (_videoMode.hardwareHeight != _videoMode.overlayHeight)
+				newEvent.mouse.y = newEvent.mouse.y * _videoMode.overlayHeight / _videoMode.hardwareHeight;
+
+			if (!_overlayVisible) {
+				newEvent.mouse.x /= _videoMode.scaleFactor;
+				newEvent.mouse.y /= _videoMode.scaleFactor;
+			}
+
+		} else {
+			newEvent.mouse.x -= _displayX;
+			newEvent.mouse.y -= _displayY;
+
+			if (_overlayVisible) {
+				if (_displayWidth != _videoMode.overlayWidth)
+					newEvent.mouse.x = newEvent.mouse.x * _videoMode.overlayWidth / _displayWidth;
+				if (_displayHeight != _videoMode.overlayHeight)
+					newEvent.mouse.y = newEvent.mouse.y * _videoMode.overlayHeight / _displayHeight;
+			} else {
+				if (_displayWidth != _videoMode.screenWidth)
+					newEvent.mouse.x = newEvent.mouse.x * _videoMode.screenWidth / _displayWidth;
+				if (_displayHeight != _videoMode.screenHeight)
+					newEvent.mouse.y = newEvent.mouse.y * _videoMode.screenHeight / _displayHeight;
+			}
+		}
+
+		g_system->getEventManager()->pushEvent(newEvent);
+	}
+}
+
+bool OpenGLGraphicsManager::notifyEvent(const Common::Event &event) {
+	switch (event.type) {
+	case Common::EVENT_MOUSEMOVE:
+		if (!event.synthetic)
+			setMousePos(event.mouse.x, event.mouse.y);
+	case Common::EVENT_LBUTTONDOWN:
+	case Common::EVENT_RBUTTONDOWN:
+	case Common::EVENT_WHEELUP:
+	case Common::EVENT_WHEELDOWN:
+	case Common::EVENT_MBUTTONDOWN:
+	case Common::EVENT_LBUTTONUP:
+	case Common::EVENT_RBUTTONUP:
+	case Common::EVENT_MBUTTONUP:
+		adjustMouseEvent(event);
+		return !event.synthetic;
+
+	default:
+		break;
+	}
+
+	return false;
+}
+
+bool OpenGLGraphicsManager::saveScreenshot(const char *filename) {
+	int width = _videoMode.hardwareWidth;
+	int height = _videoMode.hardwareHeight;
+	
+	// Allocate memory for screenshot
+	uint8 *pixels = new uint8[width * height * 3];
+
+	// Get pixel data from OpenGL buffer
+#ifdef USE_GLES
+	glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); CHECK_GL_ERROR();
+#else
+	if (_formatBGR) {
+		glReadPixels(0, 0, width, height, GL_BGR, GL_UNSIGNED_BYTE, pixels); CHECK_GL_ERROR();
+	} else {
+		glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); CHECK_GL_ERROR();
+	}
+#endif
+
+	// Open file
+	Common::DumpFile out;
+	out.open(filename);
+
+	// Write BMP header
+	out.writeByte('B');
+	out.writeByte('M');
+	out.writeUint32LE(height * width * 3 + 52);
+	out.writeUint32LE(0);
+	out.writeUint32LE(52);
+	out.writeUint32LE(40);
+	out.writeUint32LE(width);
+	out.writeUint32LE(height);
+	out.writeUint16LE(1);
+	out.writeUint16LE(24);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0);
+	out.writeUint32LE(0); 
+
+	// Write pixel data to BMP
+	out.write(pixels, width * height * 3);
+
+	// Free allocated memory
+	delete[] pixels;
+
+	return true;
+}
+
+const char *OpenGLGraphicsManager::getCurrentModeName() {
+	const char *modeName = 0;
+	const OSystem::GraphicsMode *g = getSupportedGraphicsModes();
+	while (g->name) {
+		if (g->id == _videoMode.mode) {
+			modeName = g->description;
+			break;
+		}
+		g++;
+	}
+	return modeName;
+}
+
+void OpenGLGraphicsManager::switchDisplayMode(int mode) {
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		if (mode == -1) // If -1, switch to next mode
+			_videoMode.mode = (_videoMode.mode + 1) % 4;
+		else if (mode == -2) // If -2, switch to previous mode
+			_videoMode.mode = (_videoMode.mode + 3) % 4;
+		else
+			_videoMode.mode = mode;
+
+		_transactionDetails.needRefresh = true;
+		_aspectRatioCorrection = false;
+	}
+}
+
+#endif
diff --git a/backends/graphics/opengl/opengl-graphics.h b/backends/graphics/opengl/opengl-graphics.h
new file mode 100644
index 0000000000..9b3340aef2
--- /dev/null
+++ b/backends/graphics/opengl/opengl-graphics.h
@@ -0,0 +1,293 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_OPENGL_H
+#define BACKENDS_GRAPHICS_OPENGL_H
+
+#include "backends/graphics/opengl/gltexture.h"
+#include "backends/graphics/graphics.h"
+#include "common/events.h"
+
+// Uncomment this to enable the 'on screen display' code.
+#define USE_OSD	1
+
+namespace OpenGL {
+// The OpenGL GFX modes. They have to be inside the OpenGL namespace so they
+// do not clash with the SDL GFX modes.
+enum {
+	GFX_NORMAL = 0,
+	GFX_CONSERVE = 1,
+	GFX_4_3 = 2,
+	GFX_ORIGINAL = 3
+};
+
+}
+
+/**
+ * Open GL graphics manager. This is an abstract class, it does not do the
+ * window and OpenGL context initialization.
+ * Derived classes should at least override internUpdateScreen for doing
+ * the buffers swap, and implement loadGFXMode for handling the window/context if
+ * needed. If USE_RGB_COLOR is enabled, getSupportedFormats must be implemented.
+ */
+class OpenGLGraphicsManager : public GraphicsManager, public Common::EventObserver {
+public:
+	OpenGLGraphicsManager();
+	virtual ~OpenGLGraphicsManager();
+
+	virtual void initEventObserver();
+
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+	virtual bool getFeatureState(OSystem::Feature f);
+
+	static const OSystem::GraphicsMode *supportedGraphicsModes();
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+	virtual int getGraphicsMode() const;
+	virtual void resetGraphicsScale();
+#ifdef USE_RGB_COLOR
+	virtual Graphics::PixelFormat getScreenFormat() const;
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const = 0;
+#endif
+	virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format = NULL);
+	virtual int getScreenChangeID() const;
+
+	virtual void beginGFXTransaction();
+	virtual OSystem::TransactionError endGFXTransaction();
+
+	virtual int16 getHeight();
+	virtual int16 getWidth();
+	virtual void setPalette(const byte *colors, uint start, uint num);
+	virtual void grabPalette(byte *colors, uint start, uint num);
+	virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+	virtual Graphics::Surface *lockScreen();
+	virtual void unlockScreen();
+	virtual void fillScreen(uint32 col);
+	virtual void updateScreen();
+	virtual void setShakePos(int shakeOffset);
+	virtual void setFocusRectangle(const Common::Rect& rect);
+	virtual void clearFocusRectangle();
+
+	virtual void showOverlay();
+	virtual void hideOverlay();
+	virtual Graphics::PixelFormat getOverlayFormat() const;
+	virtual void clearOverlay();
+	virtual void grabOverlay(OverlayColor *buf, int pitch);
+	virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
+	virtual int16 getOverlayHeight();
+	virtual int16 getOverlayWidth();
+
+	virtual bool showMouse(bool visible);
+	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);
+	virtual void disableCursorPalette(bool disable);
+
+	virtual void displayMessageOnOSD(const char *msg);
+
+	// Override from Common::EventObserver
+	bool notifyEvent(const Common::Event &event);
+
+protected:
+	/**
+	 * Setup OpenGL settings
+	 */
+	virtual void initGL();
+
+	/**
+	 * Creates and refreshs OpenGL textures.
+	 */
+	virtual void loadTextures();
+
+	//
+	// GFX and video
+	//
+	enum {
+		kTransactionNone = 0,
+		kTransactionActive = 1,
+		kTransactionRollback = 2
+	};
+
+	struct TransactionDetails {
+		bool sizeChanged;
+		bool needRefresh;
+		bool needUpdatescreen;
+		bool filterChanged;
+#ifdef USE_RGB_COLOR
+		bool formatChanged;
+#endif
+	};
+	TransactionDetails _transactionDetails;
+	int _transactionMode;
+
+	struct VideoState {
+		bool setup;
+
+		bool fullscreen;
+		int activeFullscreenMode;
+
+		int mode;
+		int scaleFactor;
+		bool antialiasing;
+
+		int screenWidth, screenHeight;
+		int overlayWidth, overlayHeight;
+		int hardwareWidth, hardwareHeight;
+#ifdef USE_RGB_COLOR
+		Graphics::PixelFormat format;
+#endif
+	};
+	VideoState _videoMode, _oldVideoMode;
+
+	/**
+	 * Sets the OpenGL texture format for the given pixel format. If format is not support will raise an error.
+	 */
+	virtual void getGLPixelFormat(Graphics::PixelFormat pixelFormat, byte &bpp, GLenum &intFormat, GLenum &glFormat, GLenum &type);
+
+	virtual void internUpdateScreen();
+	virtual bool loadGFXMode();
+	virtual void unloadGFXMode();
+
+	virtual void setScale(int newScale);
+
+	// Drawing coordinates for the current display mode and scale
+	int _displayX;
+	int _displayY;
+	int _displayWidth;
+	int _displayHeight;
+
+	/**
+	 * Sets the dispaly mode.
+	 * @mode the dispaly mode, if -1 it will switch to next mode. If -2 to previous mode.
+	 */
+	virtual void switchDisplayMode(int mode);
+
+	virtual const char *getCurrentModeName();
+
+	virtual void calculateDisplaySize(int &width, int &height);
+	virtual void refreshDisplaySize();
+
+	bool _aspectRatioCorrection;
+
+	/**
+	 * Returns the current target aspect ratio x 10000
+	 */
+	virtual uint getAspectRatio();
+
+	bool _formatBGR;
+
+	//
+	// Game screen
+	//
+	GLTexture* _gameTexture;
+	Graphics::Surface _screenData;
+	int _screenChangeCount;
+	bool _screenNeedsRedraw;
+	Common::Rect _screenDirtyRect;
+
+#ifdef USE_RGB_COLOR
+	Graphics::PixelFormat _screenFormat;
+#endif
+	byte *_gamePalette;
+
+	virtual void refreshGameScreen();
+
+	// Shake mode
+	int _shakePos;
+
+	//
+	// Overlay
+	//
+	GLTexture* _overlayTexture;
+	Graphics::Surface _overlayData;
+	Graphics::PixelFormat _overlayFormat;
+	bool _overlayVisible;
+	bool _overlayNeedsRedraw;
+	Common::Rect _overlayDirtyRect;
+	
+	virtual void refreshOverlay();
+
+	//
+	// Mouse
+	//
+	struct MousePos {
+		// The mouse position, using either virtual (game) or real
+		// (overlay) coordinates.
+		int16 x, y;
+
+		// The size and hotspot of the original cursor image.
+		int16 w, h;
+		int16 hotX, hotY;
+
+		// The size and hotspot of the scaled cursor, in real coordinates.
+		int16 rW, rH;
+		int16 rHotX, rHotY;
+
+		// The size and hotspot of the scaled cursor, in game coordinates.
+		int16 vW, vH;
+		int16 vHotX, vHotY;
+
+		MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0),
+					rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0),
+					vHotX(0), vHotY(0)	{}
+	};
+
+	GLTexture* _cursorTexture;
+	Graphics::Surface _cursorData;
+	Graphics::PixelFormat _cursorFormat;
+	byte *_cursorPalette;
+	bool _cursorPaletteDisabled;
+	MousePos _cursorState;
+	bool _cursorVisible;
+	uint32 _cursorKeyColor;
+	int _cursorTargetScale;
+	bool _cursorNeedsRedraw;
+
+	virtual void refreshCursor();
+	virtual void refreshCursorScale();
+	virtual void adjustMouseEvent(const Common::Event &event);
+	virtual void setMousePos(int x, int y);
+
+	//
+	// Misc
+	//
+	virtual bool saveScreenshot(const char *filename);
+
+#ifdef USE_OSD
+	GLTexture *_osdTexture;
+	Graphics::Surface _osdSurface;
+	uint8 _osdAlpha;
+	uint32 _osdFadeStartTime; 
+	enum {
+		kOSDFadeOutDelay = 2 * 1000,
+		kOSDFadeOutDuration = 500,
+		kOSDInitialAlpha = 80
+	};
+#endif
+};
+
+#endif
diff --git a/backends/graphics/openglsdl/openglsdl-graphics.cpp b/backends/graphics/openglsdl/openglsdl-graphics.cpp
new file mode 100644
index 0000000000..447bc77afe
--- /dev/null
+++ b/backends/graphics/openglsdl/openglsdl-graphics.cpp
@@ -0,0 +1,671 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined(SDL_BACKEND) && defined(USE_OPENGL)
+
+#include "backends/graphics/openglsdl/openglsdl-graphics.h"
+#include "backends/platform/sdl/sdl.h"
+#include "common/config-manager.h"
+
+OpenGLSdlGraphicsManager::OpenGLSdlGraphicsManager()
+	:
+	_hwscreen(0),
+	_screenResized(false),
+	_lastFullscreenModeWidth(0),
+	_lastFullscreenModeHeight(0),
+	_desktopWidth(0),
+	_desktopHeight(0),
+	_ignoreResizeFrames(0) {
+
+	// Initialize SDL video subsystem
+	if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1) {
+		error("Could not initialize SDL: %s", SDL_GetError());
+	}
+
+	// Disable OS cursor
+	SDL_ShowCursor(SDL_DISABLE);
+
+	// Get desktop resolution
+	const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+	if (videoInfo->current_w > 0 && videoInfo->current_h > 0) {
+		_desktopWidth = videoInfo->current_w;
+		_desktopHeight = videoInfo->current_h;
+	}
+
+	if (ConfMan.hasKey("last_fullscreen_mode_width") && ConfMan.hasKey("last_fullscreen_mode_height")) {
+		_lastFullscreenModeWidth = ConfMan.getInt("last_fullscreen_mode_width");
+		_lastFullscreenModeHeight = ConfMan.getInt("last_fullscreen_mode_height");
+	}
+}
+
+OpenGLSdlGraphicsManager::~OpenGLSdlGraphicsManager() {
+
+}
+
+
+bool OpenGLSdlGraphicsManager::hasFeature(OSystem::Feature f) {
+	return
+		(f == OSystem::kFeatureFullscreenMode) ||
+		(f == OSystem::kFeatureIconifyWindow) ||
+		OpenGLGraphicsManager::hasFeature(f);
+}
+
+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);
+	}
+}
+
+#ifdef USE_RGB_COLOR
+
+Common::List<Graphics::PixelFormat> OpenGLSdlGraphicsManager::getSupportedFormats() const {
+	assert(!_supportedFormats.empty());
+	return _supportedFormats;
+}
+
+void OpenGLSdlGraphicsManager::detectSupportedFormats() {
+
+	// Clear old list
+	_supportedFormats.clear();
+
+	// Some tables with standard formats that we always list
+	// as "supported". If frontend code tries to use one of
+	// these, we will perform the necessary format
+	// conversion in the background. Of course this incurs a
+	// performance hit, but on desktop ports this should not
+	// matter. We still push the currently active format to
+	// the front, so if frontend code just uses the first
+	// available format, it will get one that is "cheap" to
+	// use.
+	const Graphics::PixelFormat RGBList[] = {
+#if defined(ENABLE_32BIT)
+		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
+#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, 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
+	};
+#ifndef USE_GLES
+	const Graphics::PixelFormat BGRList[] = {
+#ifdef ENABLE_32BIT
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24), // ABGR8888
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 8, 16, 24, 0), // BGRA8888
+		Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 8, 16, 0),  // BGR888
+#endif
+		Graphics::PixelFormat(2, 5, 6, 5, 0, 0, 5, 11, 0),  // BGR565
+		Graphics::PixelFormat(2, 5, 5, 5, 1, 1, 6, 11, 0),  // BGRA5551
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 0, 4, 8, 12),  // ABGR4444
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 4, 8, 12, 0)   // BGRA4444
+	};
+#endif
+
+	Graphics::PixelFormat format = Graphics::PixelFormat::createFormatCLUT8();
+	if (_hwscreen) {
+		// Get our currently set hardware format
+		format = Graphics::PixelFormat(_hwscreen->format->BytesPerPixel,
+			8 - _hwscreen->format->Rloss, 8 - _hwscreen->format->Gloss,
+			8 - _hwscreen->format->Bloss, 8 - _hwscreen->format->Aloss,
+			_hwscreen->format->Rshift, _hwscreen->format->Gshift,
+			_hwscreen->format->Bshift, _hwscreen->format->Ashift);
+
+		// Workaround to MacOSX SDL not providing an accurate Aloss value.
+		if (_hwscreen->format->Amask == 0)
+			format.aLoss = 8;
+
+		// Push it first, as the prefered format if available
+		for (int i = 0; i < ARRAYSIZE(RGBList); i++) {
+			if (RGBList[i] == format) {
+				_supportedFormats.push_back(format);
+				break;
+			}
+		}
+#ifndef USE_GLES
+		for (int i = 0; i < ARRAYSIZE(BGRList); i++) {
+			if (BGRList[i] == format) {
+				_supportedFormats.push_back(format);
+				break;
+			}
+		}
+#endif
+	}
+
+	// Push some RGB formats
+	for (int i = 0; i < ARRAYSIZE(RGBList); i++) {
+		if (_hwscreen && (RGBList[i].bytesPerPixel > format.bytesPerPixel))
+			continue;
+		if (RGBList[i] != format)
+			_supportedFormats.push_back(RGBList[i]);
+	}
+#ifndef USE_GLES
+	// Push some BGR formats
+	for (int i = 0; i < ARRAYSIZE(BGRList); i++) {
+		if (_hwscreen && (BGRList[i].bytesPerPixel > format.bytesPerPixel))
+			continue;
+		if (BGRList[i] != format)
+			_supportedFormats.push_back(BGRList[i]);
+	}
+#endif
+	_supportedFormats.push_back(Graphics::PixelFormat::createFormatCLUT8());
+}
+
+#endif
+
+void OpenGLSdlGraphicsManager::warpMouse(int x, int y) {
+	int scaledX = x;
+	int scaledY = y;
+
+	if (_videoMode.mode == OpenGL::GFX_NORMAL) {
+		if (_videoMode.hardwareWidth != _videoMode.overlayWidth)
+			scaledX = scaledX * _videoMode.hardwareWidth / _videoMode.overlayWidth;
+		if (_videoMode.hardwareHeight != _videoMode.overlayHeight)
+			scaledY = scaledY * _videoMode.hardwareHeight / _videoMode.overlayHeight;
+
+		if (!_overlayVisible) {
+			scaledX *= _videoMode.scaleFactor;
+			scaledY *= _videoMode.scaleFactor;
+		}
+	} else {
+		if (_overlayVisible) {
+			if (_displayWidth != _videoMode.overlayWidth)
+				scaledX = scaledX * _displayWidth / _videoMode.overlayWidth;
+			if (_displayHeight != _videoMode.overlayHeight)
+				scaledY = scaledY * _displayHeight / _videoMode.overlayHeight;
+		} else {
+			if (_displayWidth != _videoMode.screenWidth)
+				scaledX = scaledX * _displayWidth / _videoMode.screenWidth;
+			if (_displayHeight != _videoMode.screenHeight)
+				scaledY = scaledY * _displayHeight / _videoMode.screenHeight;
+		}
+
+		scaledX += _displayX;
+		scaledY += _displayY;
+	}
+
+	SDL_WarpMouse(scaledX, scaledY);
+
+	setMousePos(scaledX, scaledY);
+}
+
+void OpenGLSdlGraphicsManager::updateScreen() {
+	if (_ignoreResizeFrames)
+		_ignoreResizeFrames -= 1;
+
+	OpenGLGraphicsManager::updateScreen();
+}
+
+//
+// Intern
+//
+
+bool OpenGLSdlGraphicsManager::setupFullscreenMode() {
+	SDL_Rect const* const*availableModes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_OPENGL);
+
+	// If -2, autodetect the fullscreen mode
+	// The last used fullscreen mode will be prioritized, if there is no last fullscreen
+	// mode, the desktop resolution will be used, and in case the desktop resolution
+	// is not available as a fullscreen mode, the one with smallest metric will be selected.
+	if (_videoMode.activeFullscreenMode == -2) {
+		// Desktop resolution
+		int desktopModeIndex = -1;
+
+		// Best metric mode
+		const SDL_Rect *bestMode = availableModes[0];
+		int bestModeIndex = 0;
+		uint bestMetric = (uint)-1;
+
+		// Iterate over all available fullscreen modes
+		for (int i = 0; const SDL_Rect *mode = availableModes[i]; i++) {
+			// Try to setup the last used fullscreen mode
+			if (mode->w == _lastFullscreenModeWidth && mode->h == _lastFullscreenModeHeight) {
+				_videoMode.hardwareWidth = _lastFullscreenModeWidth;
+				_videoMode.hardwareHeight = _lastFullscreenModeHeight;
+				_videoMode.activeFullscreenMode = i;
+				return true;
+			}
+
+			if (mode->w == _desktopWidth && mode->h == _desktopHeight)
+				desktopModeIndex = i;
+
+			if (mode->w < _videoMode.overlayWidth)
+				continue;
+			if (mode->h < _videoMode.overlayHeight)
+				continue;
+
+			uint metric = mode->w * mode->h - _videoMode.overlayWidth * _videoMode.overlayHeight;
+			if (metric < bestMetric) {
+				bestMode = mode;
+				bestMetric = metric;
+				bestModeIndex = i;
+			}
+		}
+
+		if (desktopModeIndex >= 0) {
+			_videoMode.hardwareWidth = _desktopWidth;
+			_videoMode.hardwareHeight = _desktopHeight;
+
+			_videoMode.activeFullscreenMode = desktopModeIndex;
+			return true;
+		} else if (bestMode) {
+			_videoMode.hardwareWidth = bestMode->w;
+			_videoMode.hardwareHeight = bestMode->h;
+
+			_videoMode.activeFullscreenMode = bestModeIndex;
+			return true;
+		}
+	} else {
+		// Use last fullscreen mode if looping backwards from the first mode
+		if (_videoMode.activeFullscreenMode == -1) {
+			do {
+				_videoMode.activeFullscreenMode++;
+			} while(availableModes[_videoMode.activeFullscreenMode]);
+			_videoMode.activeFullscreenMode--;
+		}
+
+		// Use first fullscreen mode if looping from last mode
+		if (!availableModes[_videoMode.activeFullscreenMode])
+			_videoMode.activeFullscreenMode = 0;
+
+		// Check if the fullscreen mode is valid
+		if (availableModes[_videoMode.activeFullscreenMode]) {
+			_videoMode.hardwareWidth = availableModes[_videoMode.activeFullscreenMode]->w;
+			_videoMode.hardwareHeight = availableModes[_videoMode.activeFullscreenMode]->h;
+			return true;
+		}
+	}
+
+	// Could not find any suiting fullscreen mode, return false.
+	return false;
+}
+
+bool OpenGLSdlGraphicsManager::loadGFXMode() {
+	// Force 4/3 if feature enabled
+	if (_aspectRatioCorrection)
+		_videoMode.mode = OpenGL::GFX_4_3;
+
+	_videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+	_videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+
+	// If the screen was resized, do not change its size
+	if (!_screenResized) {
+		_videoMode.hardwareWidth = _videoMode.overlayWidth;
+		_videoMode.hardwareHeight = _videoMode.overlayHeight;
+
+		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;
+		else if (screenAspectRatio < desiredAspectRatio)
+			_videoMode.hardwareWidth = (_videoMode.overlayHeight * desiredAspectRatio + 5000) / 10000;
+
+		// Only adjust the overlay height if it is bigger than original one. If
+		// the width is modified it can break the overlay.
+		if (_videoMode.hardwareHeight > _videoMode.overlayHeight)
+			_videoMode.overlayHeight = _videoMode.hardwareHeight;
+	}
+
+	_screenResized = false;
+
+	// Setup OpenGL attributes for SDL
+	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+	if (_videoMode.fullscreen)
+		if (!setupFullscreenMode())
+			// Failed setuping a fullscreen mode
+			return false;
+
+	uint32 flags = SDL_OPENGL;
+
+	if (_videoMode.fullscreen)
+		flags |= SDL_FULLSCREEN;
+	else
+		flags |= SDL_RESIZABLE;
+
+	// Create our window
+	_hwscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 32, flags);
+#ifdef USE_RGB_COLOR
+	detectSupportedFormats();
+#endif
+
+	if (_hwscreen == NULL) {
+		// DON'T use error(), as this tries to bring up the debug
+		// console, which WON'T WORK now that _hwscreen is hosed.
+
+		if (!_oldVideoMode.setup) {
+			warning("SDL_SetVideoMode says we can't switch to that mode (%s)", SDL_GetError());
+			g_system->quit();
+		} else
+			// Cancel GFX load, and go back to last mode
+			return false;
+	}
+
+	// Check if the screen is BGR format
+	_formatBGR = _hwscreen->format->Rshift != 0;
+
+	if (_videoMode.fullscreen) {
+		_lastFullscreenModeWidth = _videoMode.hardwareWidth;
+		_lastFullscreenModeHeight = _videoMode.hardwareHeight;
+		ConfMan.setInt("last_fullscreen_mode_width", _lastFullscreenModeWidth);
+		ConfMan.setInt("last_fullscreen_mode_height", _lastFullscreenModeHeight);
+	}
+
+	// Call and return parent implementation of this method
+	return OpenGLGraphicsManager::loadGFXMode();
+}
+
+void OpenGLSdlGraphicsManager::unloadGFXMode() {
+	if (_hwscreen) {
+		SDL_FreeSurface(_hwscreen);
+		_hwscreen = NULL;
+	}
+}
+
+void OpenGLSdlGraphicsManager::internUpdateScreen() {
+	// Call to parent implementation of this method
+	OpenGLGraphicsManager::internUpdateScreen();
+
+	// Swap OpenGL buffers
+	SDL_GL_SwapBuffers(); 
+}
+
+#ifdef USE_OSD
+void OpenGLSdlGraphicsManager::displayModeChangedMsg() {
+	const char *newModeName = getCurrentModeName();
+	if (newModeName) {
+		char buffer[128];
+		sprintf(buffer, "Current display mode: %s\n%d x %d -> %d x %d",
+			newModeName,
+			_videoMode.screenWidth * _videoMode.scaleFactor,
+			_videoMode.screenHeight * _videoMode.scaleFactor,
+			_hwscreen->w, _hwscreen->h
+			);
+		displayMessageOnOSD(buffer);
+	}
+}
+void OpenGLSdlGraphicsManager::displayScaleChangedMsg() {
+	char buffer[128];
+	sprintf(buffer, "Current scale: x%d\n%d x %d -> %d x %d",
+		_videoMode.scaleFactor,
+		_videoMode.screenWidth, _videoMode.screenHeight,
+		_videoMode.overlayWidth, _videoMode.overlayHeight
+		);
+	displayMessageOnOSD(buffer);
+}
+#endif
+
+void OpenGLSdlGraphicsManager::setFullscreenMode(bool enable) {
+	if (_oldVideoMode.setup && _oldVideoMode.fullscreen == enable &&
+		_oldVideoMode.activeFullscreenMode == _videoMode.activeFullscreenMode)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		_videoMode.fullscreen = enable;
+		_transactionDetails.needRefresh = true;
+	}
+}
+
+bool OpenGLSdlGraphicsManager::isHotkey(const Common::Event &event) {
+	if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
+		if (event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS ||
+			event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS ||
+			event.kbd.keycode == 'a' || event.kbd.keycode == 'f')
+			return true;
+	} else if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_SHIFT)) == (Common::KBD_CTRL|Common::KBD_SHIFT)) {
+		if (event.kbd.keycode == 'a' || event.kbd.keycode == 'f')
+			return true;
+	} else if ((event.kbd.flags & (Common::KBD_ALT)) == (Common::KBD_ALT) && event.kbd.keycode == 's') {
+		return true;
+	}
+	return false;
+}
+
+void OpenGLSdlGraphicsManager::toggleFullScreen(int loop) {
+	beginGFXTransaction();
+		if (_videoMode.fullscreen && loop) {
+			_videoMode.activeFullscreenMode += loop;
+			setFullscreenMode(true);
+		} else {
+			_videoMode.activeFullscreenMode = -2;
+			setFullscreenMode(!_videoMode.fullscreen);
+		}
+	endGFXTransaction();
+
+	// Ignore resize events for the next 10 frames
+	_ignoreResizeFrames = 10;
+
+#ifdef USE_OSD
+	char buffer[128];
+	if (_videoMode.fullscreen)
+		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
+}
+
+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);
+}
+
+#endif
diff --git a/backends/graphics/openglsdl/openglsdl-graphics.h b/backends/graphics/openglsdl/openglsdl-graphics.h
new file mode 100644
index 0000000000..0854872315
--- /dev/null
+++ b/backends/graphics/openglsdl/openglsdl-graphics.h
@@ -0,0 +1,120 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_OPENGLSDL_H
+#define BACKENDS_GRAPHICS_OPENGLSDL_H
+
+#include <SDL.h>
+#if defined(ARRAYSIZE) && !defined(_WINDOWS_)
+#undef ARRAYSIZE
+#endif
+#include <SDL_opengl.h>
+
+#include "backends/graphics/opengl/opengl-graphics.h"
+
+/**
+ * SDL OpenGL graphics manager
+ */
+class OpenGLSdlGraphicsManager : public OpenGLGraphicsManager {
+public:
+	OpenGLSdlGraphicsManager();
+	virtual ~OpenGLSdlGraphicsManager();
+
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+
+#ifdef USE_RGB_COLOR
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const;
+#endif
+
+	virtual void warpMouse(int x, int y);
+
+	virtual bool notifyEvent(const Common::Event &event);
+
+	virtual void updateScreen();
+
+protected:
+	virtual void internUpdateScreen();
+
+	virtual bool loadGFXMode();
+	virtual void unloadGFXMode();
+
+	virtual void setFullscreenMode(bool enable);
+
+	virtual bool isHotkey(const Common::Event &event);
+
+#ifdef USE_RGB_COLOR
+	Common::List<Graphics::PixelFormat> _supportedFormats;
+
+	/**
+	 * Update the list of supported pixel formats.
+	 * This method is invoked by loadGFXMode().
+	 */
+	void detectSupportedFormats();
+#endif
+
+	/**
+	 * Toggles fullscreen.
+	 * @loop loop direction for switching fullscreen mode, if 0 toggles it.
+	 */
+	virtual void toggleFullScreen(int loop);
+
+	/**
+	 * Setup the fullscreen mode.
+	 * @return false if failed finding a mode, true otherwise.
+	 */
+	virtual bool setupFullscreenMode();
+
+	int _lastFullscreenModeWidth;
+	int _lastFullscreenModeHeight;
+	int _desktopWidth;
+	int _desktopHeight;
+
+	// Hardware screen
+	SDL_Surface *_hwscreen;
+
+	// If screen was resized by the user
+	bool _screenResized;
+
+	// Ignore resize events for the number of updateScreen() calls.
+	// Normaly resize events are user generated when resizing the window
+	// from its borders, but in some cases a resize event can be generated
+	// after a fullscreen change.
+	int _ignoreResizeFrames;
+
+#ifdef USE_OSD
+	/**
+	 * Displays a mode change message in OSD
+	 */
+	void displayModeChangedMsg();
+
+	/**
+	 * Displays a scale change message in OSD
+	 */
+	void displayScaleChangedMsg();
+#endif
+};
+
+#endif
diff --git a/backends/graphics/sdl/sdl-graphics.cpp b/backends/graphics/sdl/sdl-graphics.cpp
new file mode 100644
index 0000000000..8e36077ecb
--- /dev/null
+++ b/backends/graphics/sdl/sdl-graphics.cpp
@@ -0,0 +1,2204 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#if defined(SDL_BACKEND)
+
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_EXCEPTION_FILE
+
+#include "backends/graphics/sdl/sdl-graphics.h"
+#include "backends/events/sdl/sdl-events.h"
+#include "backends/platform/sdl/sdl.h"
+#include "common/config-manager.h"
+#include "common/mutex.h"
+#include "common/translation.h"
+#include "common/util.h"
+#ifdef USE_RGB_COLOR
+#include "common/list.h"
+#endif
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+#include "graphics/scaler.h"
+#include "graphics/scaler/aspect.h"
+#include "graphics/surface.h"
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"1x", _s("Normal (no scaling)"), GFX_NORMAL},
+#ifdef USE_SCALERS
+	{"2x", "2x", GFX_DOUBLESIZE},
+	{"3x", "3x", GFX_TRIPLESIZE},
+	{"2xsai", "2xSAI", GFX_2XSAI},
+	{"super2xsai", "Super2xSAI", GFX_SUPER2XSAI},
+	{"supereagle", "SuperEagle", GFX_SUPEREAGLE},
+	{"advmame2x", "AdvMAME2x", GFX_ADVMAME2X},
+	{"advmame3x", "AdvMAME3x", GFX_ADVMAME3X},
+#ifdef USE_HQ_SCALERS
+	{"hq2x", "HQ2x", GFX_HQ2X},
+	{"hq3x", "HQ3x", GFX_HQ3X},
+#endif
+	{"tv2x", "TV2x", GFX_TV2X},
+	{"dotmatrix", "DotMatrix", GFX_DOTMATRIX},
+#endif
+	{0, 0, 0}
+};
+
+DECLARE_TRANSLATION_ADDITIONAL_CONTEXT("Normal (no scaling)", "lowres")
+
+// Table of relative scalers magnitudes
+// [definedScale - 1][scaleFactor - 1]
+static ScalerProc *scalersMagn[3][3] = {
+#ifdef USE_SCALERS
+	{ Normal1x, AdvMame2x, AdvMame3x },
+	{ Normal1x, Normal1x, Normal1o5x },
+	{ Normal1x, Normal1x, Normal1x }
+#else // remove dependencies on other scalers
+	{ Normal1x, Normal1x, Normal1x },
+	{ Normal1x, Normal1x, Normal1x },
+	{ Normal1x, Normal1x, Normal1x }
+#endif
+};
+
+static const int s_gfxModeSwitchTable[][4] = {
+		{ GFX_NORMAL, GFX_DOUBLESIZE, GFX_TRIPLESIZE, -1 },
+		{ GFX_NORMAL, GFX_ADVMAME2X, GFX_ADVMAME3X, -1 },
+		{ GFX_NORMAL, GFX_HQ2X, GFX_HQ3X, -1 },
+		{ GFX_NORMAL, GFX_2XSAI, -1, -1 },
+		{ GFX_NORMAL, GFX_SUPER2XSAI, -1, -1 },
+		{ GFX_NORMAL, GFX_SUPEREAGLE, -1, -1 },
+		{ GFX_NORMAL, GFX_TV2X, -1, -1 },
+		{ GFX_NORMAL, GFX_DOTMATRIX, -1, -1 }
+	};
+
+#ifdef USE_SCALERS
+static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY);
+#endif
+
+AspectRatio::AspectRatio(int w, int h) {
+	// TODO : Validation and so on...
+	// Currently, we just ensure the program don't instantiate non-supported aspect ratios
+	_kw = w;
+	_kh = h;
+}
+
+#if !defined(_WIN32_WCE) && !defined(__SYMBIAN32__) && defined(USE_SCALERS)
+static AspectRatio getDesiredAspectRatio() {
+	const size_t AR_COUNT = 4;
+	const char *desiredAspectRatioAsStrings[AR_COUNT] = {	"auto",				"4/3",				"16/9",				"16/10" };
+	const AspectRatio desiredAspectRatios[AR_COUNT] = {		AspectRatio(0, 0),	AspectRatio(4,3),	AspectRatio(16,9),	AspectRatio(16,10) };
+
+	//TODO : We could parse an arbitrary string, if we code enough proper validation
+	Common::String desiredAspectRatio = ConfMan.get("desired_screen_aspect_ratio");
+
+	for (size_t i = 0; i < AR_COUNT; i++) {
+		assert(desiredAspectRatioAsStrings[i] != NULL);
+
+		if (!scumm_stricmp(desiredAspectRatio.c_str(), desiredAspectRatioAsStrings[i])) {
+			return desiredAspectRatios[i];
+		}
+	}
+	// TODO : Report a warning
+	return AspectRatio(0, 0);
+}
+#endif
+
+SdlGraphicsManager::SdlGraphicsManager(SdlEventSource *sdlEventSource)
+	:
+	_sdlEventSource(sdlEventSource),
+#ifdef USE_OSD
+	_osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0),
+#endif
+	_hwscreen(0), _screen(0), _tmpscreen(0),
+#ifdef USE_RGB_COLOR
+	_screenFormat(Graphics::PixelFormat::createFormatCLUT8()),
+	_cursorFormat(Graphics::PixelFormat::createFormatCLUT8()),
+#endif
+	_overlayVisible(false),
+	_overlayscreen(0), _tmpscreen2(0),
+	_scalerProc(0), _screenChangeCount(0),
+	_mouseVisible(false), _mouseNeedsRedraw(false), _mouseData(0), _mouseSurface(0),
+	_mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true),
+	_currentShakePos(0), _newShakePos(0),
+	_paletteDirtyStart(0), _paletteDirtyEnd(0),
+	_screenIsLocked(false),
+	_graphicsMutex(0), _transactionMode(kTransactionNone) {
+
+	if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1) {
+		error("Could not initialize SDL: %s", SDL_GetError());
+	}
+
+	// allocate palette storage
+	_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
+	_cursorPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256);
+
+	_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+
+	memset(&_mouseCurState, 0, sizeof(_mouseCurState));
+
+	_graphicsMutex = g_system->createMutex();
+
+#ifdef _WIN32_WCE
+	if (ConfMan.hasKey("use_GDI") && ConfMan.getBool("use_GDI")) {
+		SDL_VideoInit("windib", 0);
+		sdlFlags ^= SDL_INIT_VIDEO;
+	}
+#endif
+
+	SDL_ShowCursor(SDL_DISABLE);
+
+	memset(&_oldVideoMode, 0, sizeof(_oldVideoMode));
+	memset(&_videoMode, 0, sizeof(_videoMode));
+	memset(&_transactionDetails, 0, sizeof(_transactionDetails));
+
+#if !defined(_WIN32_WCE) && !defined(__SYMBIAN32__) && defined(USE_SCALERS)
+	_videoMode.mode = GFX_DOUBLESIZE;
+	_videoMode.scaleFactor = 2;
+	_videoMode.aspectRatioCorrection = ConfMan.getBool("aspect_ratio");
+	_videoMode.desiredAspectRatio = getDesiredAspectRatio();
+	_scalerProc = Normal2x;
+#else // for small screen platforms
+	_videoMode.mode = GFX_NORMAL;
+	_videoMode.scaleFactor = 1;
+	_videoMode.aspectRatioCorrection = false;
+	_scalerProc = Normal1x;
+#endif
+	_scalerType = 0;
+
+#if !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
+	_videoMode.fullscreen = ConfMan.getBool("fullscreen");
+#else
+	_videoMode.fullscreen = true;
+#endif
+}
+
+SdlGraphicsManager::~SdlGraphicsManager() {
+	// Unregister the event observer
+	if (g_system->getEventManager()->getEventDispatcher() != NULL)
+		g_system->getEventManager()->getEventDispatcher()->unregisterObserver(this);
+
+	unloadGFXMode();
+	g_system->deleteMutex(_graphicsMutex);
+
+	free(_currentPalette);
+	free(_cursorPalette);
+	free(_mouseData);
+}
+
+void SdlGraphicsManager::initEventObserver() {
+	// Register the graphics manager as a event observer
+	g_system->getEventManager()->getEventDispatcher()->registerObserver(this, 10, false);
+}
+
+bool SdlGraphicsManager::hasFeature(OSystem::Feature f) {
+	return
+		(f == OSystem::kFeatureFullscreenMode) ||
+		(f == OSystem::kFeatureAspectRatioCorrection) ||
+		(f == OSystem::kFeatureCursorHasPalette) ||
+		(f == OSystem::kFeatureIconifyWindow);
+}
+
+void SdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+	switch (f) {
+	case OSystem::kFeatureFullscreenMode:
+		setFullscreenMode(enable);
+		break;
+	case OSystem::kFeatureAspectRatioCorrection:
+		setAspectRatioCorrection(enable);
+		break;
+	case OSystem::kFeatureIconifyWindow:
+		if (enable)
+			SDL_WM_IconifyWindow();
+		break;
+	default:
+		break;
+	}
+}
+
+bool SdlGraphicsManager::getFeatureState(OSystem::Feature f) {
+	assert (_transactionMode == kTransactionNone);
+
+	switch (f) {
+	case OSystem::kFeatureFullscreenMode:
+		return _videoMode.fullscreen;
+	case OSystem::kFeatureAspectRatioCorrection:
+		return _videoMode.aspectRatioCorrection;
+	default:
+		return false;
+	}
+}
+
+const OSystem::GraphicsMode *SdlGraphicsManager::supportedGraphicsModes() {
+	return s_supportedGraphicsModes;
+}
+
+const OSystem::GraphicsMode *SdlGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+int SdlGraphicsManager::getDefaultGraphicsMode() const {
+	return GFX_DOUBLESIZE;
+}
+
+void SdlGraphicsManager::resetGraphicsScale() {
+	setGraphicsMode(s_gfxModeSwitchTable[_scalerType][0]);
+}
+
+void SdlGraphicsManager::beginGFXTransaction() {
+	assert(_transactionMode == kTransactionNone);
+
+	_transactionMode = kTransactionActive;
+
+	_transactionDetails.sizeChanged = false;
+
+	_transactionDetails.needHotswap = false;
+	_transactionDetails.needUpdatescreen = false;
+
+	_transactionDetails.normal1xScaler = false;
+#ifdef USE_RGB_COLOR
+	_transactionDetails.formatChanged = false;
+#endif
+
+	_oldVideoMode = _videoMode;
+}
+
+OSystem::TransactionError SdlGraphicsManager::endGFXTransaction() {
+	int errors = OSystem::kTransactionSuccess;
+
+	assert(_transactionMode != kTransactionNone);
+
+	if (_transactionMode == kTransactionRollback) {
+		if (_videoMode.fullscreen != _oldVideoMode.fullscreen) {
+			errors |= OSystem::kTransactionFullscreenFailed;
+
+			_videoMode.fullscreen = _oldVideoMode.fullscreen;
+		} else if (_videoMode.aspectRatioCorrection != _oldVideoMode.aspectRatioCorrection) {
+			errors |= OSystem::kTransactionAspectRatioFailed;
+
+			_videoMode.aspectRatioCorrection = _oldVideoMode.aspectRatioCorrection;
+		} else if (_videoMode.mode != _oldVideoMode.mode) {
+			errors |= OSystem::kTransactionModeSwitchFailed;
+
+			_videoMode.mode = _oldVideoMode.mode;
+			_videoMode.scaleFactor = _oldVideoMode.scaleFactor;
+#ifdef USE_RGB_COLOR
+		} else if (_videoMode.format != _oldVideoMode.format) {
+			errors |= OSystem::kTransactionFormatNotSupported;
+
+			_videoMode.format = _oldVideoMode.format;
+			_screenFormat = _videoMode.format;
+#endif
+		} else if (_videoMode.screenWidth != _oldVideoMode.screenWidth || _videoMode.screenHeight != _oldVideoMode.screenHeight) {
+			errors |= OSystem::kTransactionSizeChangeFailed;
+
+			_videoMode.screenWidth = _oldVideoMode.screenWidth;
+			_videoMode.screenHeight = _oldVideoMode.screenHeight;
+			_videoMode.overlayWidth = _oldVideoMode.overlayWidth;
+			_videoMode.overlayHeight = _oldVideoMode.overlayHeight;
+		}
+
+		if (_videoMode.fullscreen == _oldVideoMode.fullscreen &&
+			_videoMode.aspectRatioCorrection == _oldVideoMode.aspectRatioCorrection &&
+			_videoMode.mode == _oldVideoMode.mode &&
+			_videoMode.screenWidth == _oldVideoMode.screenWidth &&
+			_videoMode.screenHeight == _oldVideoMode.screenHeight) {
+
+			// Our new video mode would now be exactly the same as the
+			// old one. Since we still can not assume SDL_SetVideoMode
+			// to be working fine, we need to invalidate the old video
+			// mode, so loadGFXMode would error out properly.
+			_oldVideoMode.setup = false;
+		}
+	}
+
+#ifdef USE_RGB_COLOR
+	if (_transactionDetails.sizeChanged || _transactionDetails.formatChanged) {
+#else
+	if (_transactionDetails.sizeChanged) {
+#endif
+		unloadGFXMode();
+		if (!loadGFXMode()) {
+			if (_oldVideoMode.setup) {
+				_transactionMode = kTransactionRollback;
+				errors |= endGFXTransaction();
+			}
+		} else {
+			setGraphicsModeIntern();
+			clearOverlay();
+
+			_videoMode.setup = true;
+			// OSystem_SDL::pollEvent used to update the screen change count,
+			// but actually it gives problems when a video mode was changed
+			// but OSystem_SDL::pollEvent was not called. This for example
+			// caused a crash under certain circumstances when doing an RTL.
+			// To fix this issue we update the screen change count right here.
+			_screenChangeCount++;
+		}
+	} else if (_transactionDetails.needHotswap) {
+		setGraphicsModeIntern();
+		if (!hotswapGFXMode()) {
+			if (_oldVideoMode.setup) {
+				_transactionMode = kTransactionRollback;
+				errors |= endGFXTransaction();
+			}
+		} else {
+			_videoMode.setup = true;
+			// OSystem_SDL::pollEvent used to update the screen change count,
+			// but actually it gives problems when a video mode was changed
+			// but OSystem_SDL::pollEvent was not called. This for example
+			// caused a crash under certain circumstances when doing an RTL.
+			// To fix this issue we update the screen change count right here.
+			_screenChangeCount++;
+
+			if (_transactionDetails.needUpdatescreen)
+				internUpdateScreen();
+		}
+	} else if (_transactionDetails.needUpdatescreen) {
+		setGraphicsModeIntern();
+		internUpdateScreen();
+	}
+
+	_transactionMode = kTransactionNone;
+	return (OSystem::TransactionError)errors;
+}
+
+#ifdef USE_RGB_COLOR
+Common::List<Graphics::PixelFormat> SdlGraphicsManager::getSupportedFormats() const {
+	assert(!_supportedFormats.empty());
+	return _supportedFormats;
+}
+
+void SdlGraphicsManager::detectSupportedFormats() {
+
+	// Clear old list
+	_supportedFormats.clear();
+
+	// Some tables with standard formats that we always list
+	// as "supported". If frontend code tries to use one of
+	// these, we will perform the necessary format
+	// conversion in the background. Of course this incurs a
+	// performance hit, but on desktop ports this should not
+	// matter. We still push the currently active format to
+	// the front, so if frontend code just uses the first
+	// available format, it will get one that is "cheap" to
+	// use.
+	const Graphics::PixelFormat RGBList[] = {
+#ifdef USE_RGB_COLOR
+		// RGBA8888, ARGB8888, RGB888
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0),
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 16, 8, 0, 24),
+		Graphics::PixelFormat(3, 8, 8, 8, 0, 16, 8, 0, 0),
+#endif
+		// RGB565, XRGB1555, RGB555, RGBA4444, ARGB4444
+		Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0),
+		Graphics::PixelFormat(2, 5, 5, 5, 1, 10, 5, 0, 15),
+		Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0),
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 12, 8, 4, 0),
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 8, 4, 0, 12)
+	};
+	const Graphics::PixelFormat BGRList[] = {
+#ifdef USE_RGB_COLOR
+		// ABGR8888, BGRA8888, BGR888
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24),
+		Graphics::PixelFormat(4, 8, 8, 8, 8, 8, 16, 24, 0),
+		Graphics::PixelFormat(3, 8, 8, 8, 0, 0, 8, 16, 0),
+#endif
+		// BGR565, XBGR1555, BGR555, ABGR4444, BGRA4444
+		Graphics::PixelFormat(2, 5, 6, 5, 0, 0, 5, 11, 0),
+		Graphics::PixelFormat(2, 5, 5, 5, 1, 0, 5, 10, 15),
+		Graphics::PixelFormat(2, 5, 5, 5, 0, 0, 5, 10, 0),
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 0, 4, 8, 12),
+		Graphics::PixelFormat(2, 4, 4, 4, 4, 4, 8, 12, 0)
+	};
+
+	Graphics::PixelFormat format = Graphics::PixelFormat::createFormatCLUT8();
+	if (_hwscreen) {
+		// Get our currently set hardware format
+		format = Graphics::PixelFormat(_hwscreen->format->BytesPerPixel,
+			8 - _hwscreen->format->Rloss, 8 - _hwscreen->format->Gloss,
+			8 - _hwscreen->format->Bloss, 8 - _hwscreen->format->Aloss,
+			_hwscreen->format->Rshift, _hwscreen->format->Gshift,
+			_hwscreen->format->Bshift, _hwscreen->format->Ashift);
+
+		// Workaround to MacOSX SDL not providing an accurate Aloss value.
+		if (_hwscreen->format->Amask == 0)
+			format.aLoss = 8;
+
+		// Push it first, as the prefered format.
+		_supportedFormats.push_back(format);
+	}
+
+	// TODO: prioritize matching alpha masks
+	int i;
+
+	// Push some RGB formats
+	for (i = 0; i < ARRAYSIZE(RGBList); i++) {
+		if (_hwscreen && (RGBList[i].bytesPerPixel > format.bytesPerPixel))
+			continue;
+		if (RGBList[i] != format)
+			_supportedFormats.push_back(RGBList[i]);
+	}
+
+	// Push some BGR formats
+	for (i = 0; i < ARRAYSIZE(BGRList); i++) {
+		if (_hwscreen && (BGRList[i].bytesPerPixel > format.bytesPerPixel))
+			continue;
+		if (BGRList[i] != format)
+			_supportedFormats.push_back(BGRList[i]);
+	}
+
+	// Finally, we always supposed 8 bit palette graphics
+	_supportedFormats.push_back(Graphics::PixelFormat::createFormatCLUT8());
+}
+#endif
+
+bool SdlGraphicsManager::setGraphicsMode(int mode) {
+	Common::StackLock lock(_graphicsMutex);
+
+	assert(_transactionMode == kTransactionActive);
+
+	if (_oldVideoMode.setup && _oldVideoMode.mode == mode)
+		return true;
+
+	int newScaleFactor = 1;
+
+	switch (mode) {
+	case GFX_NORMAL:
+		newScaleFactor = 1;
+		break;
+#ifdef USE_SCALERS
+	case GFX_DOUBLESIZE:
+		newScaleFactor = 2;
+		break;
+	case GFX_TRIPLESIZE:
+		newScaleFactor = 3;
+		break;
+
+	case GFX_2XSAI:
+		newScaleFactor = 2;
+		break;
+	case GFX_SUPER2XSAI:
+		newScaleFactor = 2;
+		break;
+	case GFX_SUPEREAGLE:
+		newScaleFactor = 2;
+		break;
+	case GFX_ADVMAME2X:
+		newScaleFactor = 2;
+		break;
+	case GFX_ADVMAME3X:
+		newScaleFactor = 3;
+		break;
+#ifdef USE_HQ_SCALERS
+	case GFX_HQ2X:
+		newScaleFactor = 2;
+		break;
+	case GFX_HQ3X:
+		newScaleFactor = 3;
+		break;
+#endif
+	case GFX_TV2X:
+		newScaleFactor = 2;
+		break;
+	case GFX_DOTMATRIX:
+		newScaleFactor = 2;
+		break;
+#endif // USE_SCALERS
+
+	default:
+		warning("unknown gfx mode %d", mode);
+		return false;
+	}
+
+	_transactionDetails.normal1xScaler = (mode == GFX_NORMAL);
+	if (_oldVideoMode.setup && _oldVideoMode.scaleFactor != newScaleFactor)
+		_transactionDetails.needHotswap = true;
+
+	_transactionDetails.needUpdatescreen = true;
+
+	_videoMode.mode = mode;
+	_videoMode.scaleFactor = newScaleFactor;
+
+	return true;
+}
+
+void SdlGraphicsManager::setGraphicsModeIntern() {
+	Common::StackLock lock(_graphicsMutex);
+	ScalerProc *newScalerProc = 0;
+
+	switch (_videoMode.mode) {
+	case GFX_NORMAL:
+		newScalerProc = Normal1x;
+		break;
+#ifdef USE_SCALERS
+	case GFX_DOUBLESIZE:
+		newScalerProc = Normal2x;
+		break;
+	case GFX_TRIPLESIZE:
+		newScalerProc = Normal3x;
+		break;
+
+	case GFX_2XSAI:
+		newScalerProc = _2xSaI;
+		break;
+	case GFX_SUPER2XSAI:
+		newScalerProc = Super2xSaI;
+		break;
+	case GFX_SUPEREAGLE:
+		newScalerProc = SuperEagle;
+		break;
+	case GFX_ADVMAME2X:
+		newScalerProc = AdvMame2x;
+		break;
+	case GFX_ADVMAME3X:
+		newScalerProc = AdvMame3x;
+		break;
+#ifdef USE_HQ_SCALERS
+	case GFX_HQ2X:
+		newScalerProc = HQ2x;
+		break;
+	case GFX_HQ3X:
+		newScalerProc = HQ3x;
+		break;
+#endif
+	case GFX_TV2X:
+		newScalerProc = TV2x;
+		break;
+	case GFX_DOTMATRIX:
+		newScalerProc = DotMatrix;
+		break;
+#endif // USE_SCALERS
+
+	default:
+		error("Unknown gfx mode %d", _videoMode.mode);
+	}
+
+	_scalerProc = newScalerProc;
+
+	if (_videoMode.mode != GFX_NORMAL) {
+		for (int i = 0; i < ARRAYSIZE(s_gfxModeSwitchTable); i++) {
+			if (s_gfxModeSwitchTable[i][1] == _videoMode.mode || s_gfxModeSwitchTable[i][2] == _videoMode.mode) {
+				_scalerType = i;
+				break;
+			}
+		}
+	}
+
+	if (!_screen || !_hwscreen)
+		return;
+
+	// 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();
+}
+
+int SdlGraphicsManager::getGraphicsMode() const {
+	assert (_transactionMode == kTransactionNone);
+	return _videoMode.mode;
+}
+
+void SdlGraphicsManager::initSize(uint w, uint h, const Graphics::PixelFormat *format) {
+	assert(_transactionMode == kTransactionActive);
+
+#ifdef USE_RGB_COLOR
+	//avoid redundant format changes
+	Graphics::PixelFormat newFormat;
+	if (!format)
+		newFormat = Graphics::PixelFormat::createFormatCLUT8();
+	else
+		newFormat = *format;
+
+	assert(newFormat.bytesPerPixel > 0);
+
+	if (newFormat != _videoMode.format) {
+		_videoMode.format = newFormat;
+		_transactionDetails.formatChanged = true;
+		_screenFormat = newFormat;
+	}
+#endif
+
+	// Avoid redundant res changes
+	if ((int)w == _videoMode.screenWidth && (int)h == _videoMode.screenHeight)
+		return;
+
+	_videoMode.screenWidth = w;
+	_videoMode.screenHeight = h;
+
+	_transactionDetails.sizeChanged = true;
+}
+
+int SdlGraphicsManager::effectiveScreenHeight() const {
+	return _videoMode.scaleFactor *
+				(_videoMode.aspectRatioCorrection
+					? real2Aspect(_videoMode.screenHeight)
+					: _videoMode.screenHeight);
+}
+
+static void fixupResolutionForAspectRatio(AspectRatio desiredAspectRatio, int &width, int &height) {
+	assert(&width != &height);
+
+	if (desiredAspectRatio.isAuto())
+		return;
+
+	int kw = desiredAspectRatio.kw();
+	int kh = desiredAspectRatio.kh();
+
+	const int w = width;
+	const int h = height;
+
+	SDL_Rect const* const*availableModes = SDL_ListModes(NULL, SDL_FULLSCREEN|SDL_SWSURFACE); //TODO : Maybe specify a pixel format
+	assert(availableModes);
+
+	const SDL_Rect *bestMode = NULL;
+	uint bestMetric = (uint)-1; // Metric is wasted space
+	while (const SDL_Rect *mode = *availableModes++) {
+		if (mode->w < w)
+			continue;
+		if (mode->h < h)
+			continue;
+		if (mode->h * kw != mode->w * kh)
+			continue;
+
+		uint metric = mode->w * mode->h - w * h;
+		if (metric > bestMetric)
+			continue;
+
+		bestMetric = metric;
+		bestMode = mode;
+	}
+
+	if (!bestMode) {
+		warning("Unable to enforce the desired aspect ratio");
+		return;
+	}
+	width = bestMode->w;
+	height = bestMode->h;
+}
+
+bool SdlGraphicsManager::loadGFXMode() {
+	_forceFull = true;
+
+#if !defined(__MAEMO__) && !defined(DINGUX) && !defined(GPH_DEVICE) && !defined(LINUXMOTO) && !defined(OPENPANDORA)
+	_videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+	_videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+
+	if (_videoMode.screenHeight != 200 && _videoMode.screenHeight != 400)
+		_videoMode.aspectRatioCorrection = false;
+
+	if (_videoMode.aspectRatioCorrection)
+		_videoMode.overlayHeight = real2Aspect(_videoMode.overlayHeight);
+
+	_videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
+	_videoMode.hardwareHeight = effectiveScreenHeight();
+#else
+	_videoMode.hardwareWidth = _videoMode.overlayWidth;
+	_videoMode.hardwareHeight = _videoMode.overlayHeight;
+#endif
+
+	//
+	// Create the surface that contains the 8 bit game data
+	//
+#ifdef USE_RGB_COLOR
+	_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth, _videoMode.screenHeight,
+						_screenFormat.bytesPerPixel << 3,
+						((1 << _screenFormat.rBits()) - 1) << _screenFormat.rShift ,
+						((1 << _screenFormat.gBits()) - 1) << _screenFormat.gShift ,
+						((1 << _screenFormat.bBits()) - 1) << _screenFormat.bShift ,
+						((1 << _screenFormat.aBits()) - 1) << _screenFormat.aShift );
+	if (_screen == NULL)
+		error("allocating _screen failed");
+
+#else
+	_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth, _videoMode.screenHeight, 8, 0, 0, 0, 0);
+	if (_screen == NULL)
+		error("allocating _screen failed");
+#endif
+
+	//
+	// Create the surface that contains the scaled graphics in 16 bit mode
+	//
+
+	if (_videoMode.fullscreen) {
+		fixupResolutionForAspectRatio(_videoMode.desiredAspectRatio, _videoMode.hardwareWidth, _videoMode.hardwareHeight);
+	}
+
+	_hwscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 16,
+		_videoMode.fullscreen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
+	);
+#ifdef USE_RGB_COLOR
+	detectSupportedFormats();
+#endif
+
+	if (_hwscreen == NULL) {
+		// DON'T use error(), as this tries to bring up the debug
+		// console, which WON'T WORK now that _hwscreen is hosed.
+
+		if (!_oldVideoMode.setup) {
+			warning("SDL_SetVideoMode says we can't switch to that mode (%s)", SDL_GetError());
+			g_system->quit();
+		} else {
+			return false;
+		}
+	}
+
+	//
+	// Create the surface used for the graphics in 16 bit before scaling, and also the overlay
+	//
+
+	// Need some extra bytes around when using 2xSaI
+	_tmpscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth + 3, _videoMode.screenHeight + 3,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+	if (_tmpscreen == NULL)
+		error("allocating _tmpscreen failed");
+
+	_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth, _videoMode.overlayHeight,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+	if (_overlayscreen == NULL)
+		error("allocating _overlayscreen failed");
+
+	_overlayFormat.bytesPerPixel = _overlayscreen->format->BytesPerPixel;
+
+	_overlayFormat.rLoss = _overlayscreen->format->Rloss;
+	_overlayFormat.gLoss = _overlayscreen->format->Gloss;
+	_overlayFormat.bLoss = _overlayscreen->format->Bloss;
+	_overlayFormat.aLoss = _overlayscreen->format->Aloss;
+
+	_overlayFormat.rShift = _overlayscreen->format->Rshift;
+	_overlayFormat.gShift = _overlayscreen->format->Gshift;
+	_overlayFormat.bShift = _overlayscreen->format->Bshift;
+	_overlayFormat.aShift = _overlayscreen->format->Ashift;
+
+	_tmpscreen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth + 3, _videoMode.overlayHeight + 3,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+	if (_tmpscreen2 == NULL)
+		error("allocating _tmpscreen2 failed");
+
+#ifdef USE_OSD
+	_osdSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_hwscreen->w,
+						_hwscreen->h,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+	if (_osdSurface == NULL)
+		error("allocating _osdSurface failed");
+	SDL_SetColorKey(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kOSDColorKey);
+#endif
+
+	_sdlEventSource->resetKeyboadEmulation(
+		_videoMode.screenWidth * _videoMode.scaleFactor - 1,
+		effectiveScreenHeight() - 1);
+
+	// Distinguish 555 and 565 mode
+	if (_hwscreen->format->Rmask == 0x7C00)
+		InitScalers(555);
+	else
+		InitScalers(565);
+
+	return true;
+}
+
+void SdlGraphicsManager::unloadGFXMode() {
+	if (_screen) {
+		SDL_FreeSurface(_screen);
+		_screen = NULL;
+	}
+
+	if (_hwscreen) {
+		SDL_FreeSurface(_hwscreen);
+		_hwscreen = NULL;
+	}
+
+	if (_tmpscreen) {
+		SDL_FreeSurface(_tmpscreen);
+		_tmpscreen = NULL;
+	}
+
+	if (_tmpscreen2) {
+		SDL_FreeSurface(_tmpscreen2);
+		_tmpscreen2 = NULL;
+	}
+
+	if (_overlayscreen) {
+		SDL_FreeSurface(_overlayscreen);
+		_overlayscreen = NULL;
+	}
+
+#ifdef USE_OSD
+	if (_osdSurface) {
+		SDL_FreeSurface(_osdSurface);
+		_osdSurface = NULL;
+	}
+#endif
+	DestroyScalers();
+}
+
+bool SdlGraphicsManager::hotswapGFXMode() {
+	if (!_screen)
+		return false;
+
+	// Keep around the old _screen & _overlayscreen so we can restore the screen data
+	// after the mode switch.
+	SDL_Surface *old_screen = _screen;
+	_screen = NULL;
+	SDL_Surface *old_overlayscreen = _overlayscreen;
+	_overlayscreen = NULL;
+
+	// Release the HW screen surface
+	SDL_FreeSurface(_hwscreen); _hwscreen = NULL;
+
+	SDL_FreeSurface(_tmpscreen); _tmpscreen = NULL;
+	SDL_FreeSurface(_tmpscreen2); _tmpscreen2 = NULL;
+
+#ifdef USE_OSD
+	// Release the OSD surface
+	SDL_FreeSurface(_osdSurface); _osdSurface = NULL;
+#endif
+
+	// 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_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();
+
+	return true;
+}
+
+void SdlGraphicsManager::updateScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	internUpdateScreen();
+}
+
+void SdlGraphicsManager::internUpdateScreen() {
+	SDL_Surface *srcSurf, *origSurf;
+	int height, width;
+	ScalerProc *scalerProc;
+	int scale1;
+
+	// definitions not available for non-DEBUG here. (needed this to compile in SYMBIAN32 & linux?)
+#if defined (DEBUG) && !defined(WIN32) && !defined(_WIN32_WCE)
+	assert(_hwscreen != NULL);
+	assert(_hwscreen->map->sw_data != NULL);
+#endif
+
+	// If the shake position changed, fill the dirty area with blackness
+	if (_currentShakePos != _newShakePos ||
+		(_mouseNeedsRedraw && _mouseBackup.y <= _currentShakePos)) {
+		SDL_Rect blackrect = {0, 0, _videoMode.screenWidth * _videoMode.scaleFactor, _newShakePos * _videoMode.scaleFactor};
+
+		if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+			blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
+		SDL_FillRect(_hwscreen, &blackrect, 0);
+
+		_currentShakePos = _newShakePos;
+
+		_forceFull = true;
+	}
+
+	// Check whether the palette was changed in the meantime and update the
+	// screen surface accordingly.
+	if (_screen && _paletteDirtyEnd != 0) {
+		SDL_SetColors(_screen, _currentPalette + _paletteDirtyStart,
+			_paletteDirtyStart,
+			_paletteDirtyEnd - _paletteDirtyStart);
+
+		_paletteDirtyEnd = 0;
+
+		_forceFull = true;
+	}
+
+#ifdef USE_OSD
+	// OSD visible (i.e. non-transparent)?
+	if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+		// Updated alpha value
+		const int diff = SDL_GetTicks() - _osdFadeStartTime;
+		if (diff > 0) {
+			if (diff >= kOSDFadeOutDuration) {
+				// Back to full transparency
+				_osdAlpha = SDL_ALPHA_TRANSPARENT;
+			} else {
+				// Do a linear fade out...
+				const int startAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+				_osdAlpha = startAlpha + diff * (SDL_ALPHA_TRANSPARENT - startAlpha) / kOSDFadeOutDuration;
+			}
+			SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+			_forceFull = true;
+		}
+	}
+#endif
+
+	if (!_overlayVisible) {
+		origSurf = _screen;
+		srcSurf = _tmpscreen;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		scalerProc = _scalerProc;
+		scale1 = _videoMode.scaleFactor;
+	} else {
+		origSurf = _overlayscreen;
+		srcSurf = _tmpscreen2;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		scalerProc = Normal1x;
+
+		scale1 = 1;
+	}
+
+	// Add the area covered by the mouse cursor to the list of dirty rects if
+	// we have to redraw the mouse.
+	if (_mouseNeedsRedraw)
+		undrawMouse();
+
+	// Force a full redraw if requested
+	if (_forceFull) {
+		_numDirtyRects = 1;
+		_dirtyRectList[0].x = 0;
+		_dirtyRectList[0].y = 0;
+		_dirtyRectList[0].w = width;
+		_dirtyRectList[0].h = height;
+	}
+
+	// Only draw anything if necessary
+	if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
+		SDL_Rect *r;
+		SDL_Rect dst;
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			dst = *r;
+			dst.x++;	// Shift rect by one since 2xSai needs to access the data around
+			dst.y++;	// any pixel to scale it, and we want to avoid mem access crashes.
+
+			if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
+				error("SDL_BlitSurface failed: %s", SDL_GetError());
+		}
+
+		SDL_LockSurface(srcSurf);
+		SDL_LockSurface(_hwscreen);
+
+		srcPitch = srcSurf->pitch;
+		dstPitch = _hwscreen->pitch;
+
+		for (r = _dirtyRectList; r != lastRect; ++r) {
+			register int dst_y = r->y + _currentShakePos;
+			register int dst_h = 0;
+			register int orig_dst_y = 0;
+			register int rx1 = r->x * scale1;
+
+			if (dst_y < height) {
+				dst_h = r->h;
+				if (dst_h > height - dst_y)
+					dst_h = height - dst_y;
+
+				orig_dst_y = dst_y;
+				dst_y = dst_y * scale1;
+
+				if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+					dst_y = real2Aspect(dst_y);
+
+				assert(scalerProc != NULL);
+				scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
+					(byte *)_hwscreen->pixels + rx1 * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
+			}
+
+			r->x = rx1;
+			r->y = dst_y;
+			r->w = r->w * scale1;
+			r->h = dst_h * scale1;
+
+#ifdef USE_SCALERS
+			if (_videoMode.aspectRatioCorrection && orig_dst_y < height && !_overlayVisible)
+				r->h = stretch200To240((uint8 *) _hwscreen->pixels, dstPitch, r->w, r->h, r->x, r->y, orig_dst_y * scale1);
+#endif
+		}
+		SDL_UnlockSurface(srcSurf);
+		SDL_UnlockSurface(_hwscreen);
+
+		// Readjust the dirty rect list in case we are doing a full update.
+		// This is necessary if shaking is active.
+		if (_forceFull) {
+			_dirtyRectList[0].y = 0;
+			_dirtyRectList[0].h = effectiveScreenHeight();
+		}
+
+		drawMouse();
+
+#ifdef USE_OSD
+		if (_osdAlpha != SDL_ALPHA_TRANSPARENT) {
+			SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
+		}
+#endif
+		// Finally, blit all our changes to the screen
+		SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
+	}
+
+	_numDirtyRects = 0;
+	_forceFull = false;
+	_mouseNeedsRedraw = false;
+}
+
+bool SdlGraphicsManager::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) {
+	Common::StackLock lock(_graphicsMutex);
+
+	if (_oldVideoMode.setup && _oldVideoMode.fullscreen == enable)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		_videoMode.fullscreen = enable;
+		_transactionDetails.needHotswap = true;
+	}
+}
+
+void SdlGraphicsManager::setAspectRatioCorrection(bool enable) {
+	Common::StackLock lock(_graphicsMutex);
+
+	if (_oldVideoMode.setup && _oldVideoMode.aspectRatioCorrection == enable)
+		return;
+
+	if (_transactionMode == kTransactionActive) {
+		_videoMode.aspectRatioCorrection = enable;
+		_transactionDetails.needHotswap = true;
+	}
+}
+
+void SdlGraphicsManager::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");
+		return;
+	}
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	assert(x >= 0 && x < _videoMode.screenWidth);
+	assert(y >= 0 && y < _videoMode.screenHeight);
+	assert(h > 0 && y + h <= _videoMode.screenHeight);
+	assert(w > 0 && x + w <= _videoMode.screenWidth);
+
+	addDirtyRect(x, y, w, h);
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+#ifdef USE_RGB_COLOR
+	byte *dst = (byte *)_screen->pixels + y * _videoMode.screenWidth * _screenFormat.bytesPerPixel + x * _screenFormat.bytesPerPixel;
+	if (_videoMode.screenWidth == w && pitch == w * _screenFormat.bytesPerPixel) {
+		memcpy(dst, src, h*w*_screenFormat.bytesPerPixel);
+	} else {
+		do {
+			memcpy(dst, src, w * _screenFormat.bytesPerPixel);
+			src += pitch;
+			dst += _videoMode.screenWidth * _screenFormat.bytesPerPixel;
+		} while (--h);
+	}
+#else
+	byte *dst = (byte *)_screen->pixels + y * _videoMode.screenWidth + x;
+	if (_videoMode.screenWidth == pitch && pitch == w) {
+		memcpy(dst, src, h*w);
+	} else {
+		do {
+			memcpy(dst, src, w);
+			src += pitch;
+			dst += _videoMode.screenWidth;
+		} while (--h);
+	}
+#endif
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+}
+
+Graphics::Surface *SdlGraphicsManager::lockScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	// Lock the graphics mutex
+	g_system->lockMutex(_graphicsMutex);
+
+	// paranoia check
+	assert(!_screenIsLocked);
+	_screenIsLocked = true;
+
+	// Try to lock the screen surface
+	if (SDL_LockSurface(_screen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	_framebuffer.pixels = _screen->pixels;
+	_framebuffer.w = _screen->w;
+	_framebuffer.h = _screen->h;
+	_framebuffer.pitch = _screen->pitch;
+#ifdef USE_RGB_COLOR
+	_framebuffer.bytesPerPixel = _screenFormat.bytesPerPixel;
+#else
+	_framebuffer.bytesPerPixel = 1;
+#endif
+
+	return &_framebuffer;
+}
+
+void SdlGraphicsManager::unlockScreen() {
+	assert (_transactionMode == kTransactionNone);
+
+	// paranoia check
+	assert(_screenIsLocked);
+	_screenIsLocked = false;
+
+	// Unlock the screen surface
+	SDL_UnlockSurface(_screen);
+
+	// Trigger a full screen update
+	_forceFull = true;
+
+	// Finally unlock the graphics mutex
+	g_system->unlockMutex(_graphicsMutex);
+}
+
+void SdlGraphicsManager::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) {
+	if (_forceFull)
+		return;
+
+	if (_numDirtyRects == NUM_DIRTY_RECT) {
+		_forceFull = true;
+		return;
+	}
+
+	int height, width;
+
+	if (!_overlayVisible && !realCoordinates) {
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+	} else {
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+	}
+
+	// Extend the dirty region by 1 pixel for scalers
+	// that "smear" the screen, e.g. 2xSAI
+	if (!realCoordinates) {
+		x--;
+		y--;
+		w+=2;
+		h+=2;
+	}
+
+	// clip
+	if (x < 0) {
+		w += x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y;
+		y=0;
+	}
+
+	if (w > width - x) {
+		w = width - x;
+	}
+
+	if (h > height - y) {
+		h = height - y;
+	}
+
+#ifdef USE_SCALERS
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible && !realCoordinates) {
+		makeRectStretchable(x, y, w, h);
+	}
+#endif
+
+	if (w == width && h == height) {
+		_forceFull = true;
+		return;
+	}
+
+	if (w > 0 && h > 0) {
+		SDL_Rect *r = &_dirtyRectList[_numDirtyRects++];
+
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+	}
+}
+
+int16 SdlGraphicsManager::getHeight() {
+	return _videoMode.screenHeight;
+}
+
+int16 SdlGraphicsManager::getWidth() {
+	return _videoMode.screenWidth;
+}
+
+void SdlGraphicsManager::setPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+
+#ifdef USE_RGB_COLOR
+	assert(_screenFormat.bytesPerPixel == 1);
+#endif
+
+	// Setting the palette before _screen is created is allowed - for now -
+	// since we don't actually set the palette until the screen is updated.
+	// But it could indicate a programming error, so let's warn about it.
+
+	if (!_screen)
+		warning("SdlGraphicsManager::setPalette: _screen == NULL");
+
+	const byte *b = colors;
+	uint i;
+	SDL_Color *base = _currentPalette + start;
+	for (i = 0; i < num; i++) {
+		base[i].r = b[0];
+		base[i].g = b[1];
+		base[i].b = b[2];
+		b += 4;
+	}
+
+	if (start < _paletteDirtyStart)
+		_paletteDirtyStart = start;
+
+	if (start + num > _paletteDirtyEnd)
+		_paletteDirtyEnd = start + num;
+
+	// Some games blink cursors with palette
+	if (_cursorPaletteDisabled)
+		blitCursor();
+}
+
+void SdlGraphicsManager::grabPalette(byte *colors, uint start, uint num) {
+	assert(colors);
+
+#ifdef USE_RGB_COLOR
+	assert(_screenFormat.bytesPerPixel == 1);
+#endif
+
+	const SDL_Color *base = _currentPalette + start;
+
+	for (uint i = 0; i < num; ++i) {
+		colors[i * 4] = base[i].r;
+		colors[i * 4 + 1] = base[i].g;
+		colors[i * 4 + 2] = base[i].b;
+		colors[i * 4 + 3] = 0xFF;
+	}
+}
+
+void SdlGraphicsManager::setCursorPalette(const byte *colors, uint start, uint num) {
+	assert(colors);
+	const byte *b = colors;
+	uint i;
+	SDL_Color *base = _cursorPalette + start;
+	for (i = 0; i < num; i++) {
+		base[i].r = b[0];
+		base[i].g = b[1];
+		base[i].b = b[2];
+		b += 4;
+	}
+
+	_cursorPaletteDisabled = false;
+	blitCursor();
+}
+
+void SdlGraphicsManager::disableCursorPalette(bool disable) {
+	_cursorPaletteDisabled = disable;
+	blitCursor();
+}
+
+void SdlGraphicsManager::setShakePos(int shake_pos) {
+	assert (_transactionMode == kTransactionNone);
+
+	_newShakePos = shake_pos;
+}
+
+
+#pragma mark -
+#pragma mark --- Overlays ---
+#pragma mark -
+
+void SdlGraphicsManager::showOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	int x, y;
+
+	if (_overlayVisible)
+		return;
+
+	_overlayVisible = true;
+
+	// Since resolution could change, put mouse to adjusted position
+	// Fixes bug #1349059
+	x = _mouseCurState.x * _videoMode.scaleFactor;
+	if (_videoMode.aspectRatioCorrection)
+		y = real2Aspect(_mouseCurState.y) * _videoMode.scaleFactor;
+	else
+		y = _mouseCurState.y * _videoMode.scaleFactor;
+
+	warpMouse(x, y);
+
+	clearOverlay();
+}
+
+void SdlGraphicsManager::hideOverlay() {
+	assert (_transactionMode == kTransactionNone);
+
+	if (!_overlayVisible)
+		return;
+
+	int x, y;
+
+	_overlayVisible = false;
+
+	// Since resolution could change, put mouse to adjusted position
+	// Fixes bug #1349059
+	x = _mouseCurState.x / _videoMode.scaleFactor;
+	y = _mouseCurState.y / _videoMode.scaleFactor;
+	if (_videoMode.aspectRatioCorrection)
+		y = aspect2Real(y);
+
+	warpMouse(x, y);
+
+	clearOverlay();
+
+	_forceFull = true;
+}
+
+void SdlGraphicsManager::clearOverlay() {
+	//assert (_transactionMode == kTransactionNone);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	if (!_overlayVisible)
+		return;
+
+	// Clear the overlay by making the game screen "look through" everywhere.
+	SDL_Rect src, dst;
+	src.x = src.y = 0;
+	dst.x = dst.y = 1;
+	src.w = dst.w = _videoMode.screenWidth;
+	src.h = dst.h = _videoMode.screenHeight;
+	if (SDL_BlitSurface(_screen, &src, _tmpscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	SDL_LockSurface(_tmpscreen);
+	SDL_LockSurface(_overlayscreen);
+	_scalerProc((byte *)(_tmpscreen->pixels) + _tmpscreen->pitch + 2, _tmpscreen->pitch,
+	(byte *)_overlayscreen->pixels, _overlayscreen->pitch, _videoMode.screenWidth, _videoMode.screenHeight);
+
+#ifdef USE_SCALERS
+	if (_videoMode.aspectRatioCorrection)
+		stretch200To240((uint8 *)_overlayscreen->pixels, _overlayscreen->pitch,
+						_videoMode.overlayWidth, _videoMode.screenHeight * _videoMode.scaleFactor, 0, 0, 0);
+#endif
+	SDL_UnlockSurface(_tmpscreen);
+	SDL_UnlockSurface(_overlayscreen);
+
+	_forceFull = true;
+}
+
+void SdlGraphicsManager::grabOverlay(OverlayColor *buf, int pitch) {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayscreen == NULL)
+		return;
+
+	if (SDL_LockSurface(_overlayscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *src = (byte *)_overlayscreen->pixels;
+	int h = _videoMode.overlayHeight;
+	do {
+		memcpy(buf, src, _videoMode.overlayWidth * 2);
+		src += _overlayscreen->pitch;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_overlayscreen);
+}
+
+void SdlGraphicsManager::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) {
+	assert (_transactionMode == kTransactionNone);
+
+	if (_overlayscreen == NULL)
+		return;
+
+	// Clip the coordinates
+	if (x < 0) {
+		w += x;
+		buf -= x;
+		x = 0;
+	}
+
+	if (y < 0) {
+		h += y; buf -= y * pitch;
+		y = 0;
+	}
+
+	if (w > _videoMode.overlayWidth - x) {
+		w = _videoMode.overlayWidth - x;
+	}
+
+	if (h > _videoMode.overlayHeight - y) {
+		h = _videoMode.overlayHeight - y;
+	}
+
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Mark the modified region as dirty
+	addDirtyRect(x, y, w, h);
+
+	if (SDL_LockSurface(_overlayscreen) == -1)
+		error("SDL_LockSurface failed: %s", SDL_GetError());
+
+	byte *dst = (byte *)_overlayscreen->pixels + y * _overlayscreen->pitch + x * 2;
+	do {
+		memcpy(dst, buf, w * 2);
+		dst += _overlayscreen->pitch;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(_overlayscreen);
+}
+
+
+#pragma mark -
+#pragma mark --- Mouse ---
+#pragma mark -
+
+bool SdlGraphicsManager::showMouse(bool visible) {
+	if (_mouseVisible == visible)
+		return visible;
+
+	bool last = _mouseVisible;
+	_mouseVisible = visible;
+	_mouseNeedsRedraw = true;
+
+	return last;
+}
+
+void SdlGraphicsManager::setMousePos(int x, int y) {
+	if (x != _mouseCurState.x || y != _mouseCurState.y) {
+		_mouseNeedsRedraw = true;
+		_mouseCurState.x = x;
+		_mouseCurState.y = y;
+	}
+}
+
+void SdlGraphicsManager::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)
+	if (!(SDL_GetAppState( ) & SDL_APPMOUSEFOCUS)) {
+		setMousePos(x, y); // but change game cursor position
+		return;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		y1 = real2Aspect(y);
+
+	if (_mouseCurState.x != x || _mouseCurState.y != y) {
+		if (!_overlayVisible)
+			SDL_WarpMouse(x * _videoMode.scaleFactor, y1 * _videoMode.scaleFactor);
+		else
+			SDL_WarpMouse(x, y1);
+
+		// SDL_WarpMouse() generates a mouse movement event, so
+		// setMousePos() would be called eventually. However, the
+		// cannon script in CoMI calls this function twice each time
+		// the cannon is reloaded. Unless we update the mouse position
+		// immediately the second call is ignored, causing the cannon
+		// to change its aim.
+
+		setMousePos(x, 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) {
+#ifdef USE_RGB_COLOR
+	if (!format)
+		_cursorFormat = Graphics::PixelFormat::createFormatCLUT8();
+	else if (format->bytesPerPixel <= _screenFormat.bytesPerPixel)
+		_cursorFormat = *format;
+
+	if (_cursorFormat.bytesPerPixel < 4)
+		assert(keycolor < (uint)(1 << (_cursorFormat.bytesPerPixel << 3)));
+#else
+	assert(keycolor <= 0xFF);
+#endif
+
+	if (w == 0 || h == 0)
+		return;
+
+	_mouseCurState.hotX = hotspot_x;
+	_mouseCurState.hotY = hotspot_y;
+
+	_mouseKeyColor = keycolor;
+
+	_cursorTargetScale = cursorTargetScale;
+
+	if (_mouseCurState.w != (int)w || _mouseCurState.h != (int)h) {
+		_mouseCurState.w = w;
+		_mouseCurState.h = h;
+
+		if (_mouseOrigSurface)
+			SDL_FreeSurface(_mouseOrigSurface);
+
+		// Allocate bigger surface because AdvMame2x adds black pixel at [0,0]
+		_mouseOrigSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_mouseCurState.w + 2,
+						_mouseCurState.h + 2,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+		if (_mouseOrigSurface == NULL)
+			error("allocating _mouseOrigSurface failed");
+		SDL_SetColorKey(_mouseOrigSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+	}
+
+	free(_mouseData);
+#ifdef USE_RGB_COLOR
+	_mouseData = (byte *)malloc(w * h * _cursorFormat.bytesPerPixel);
+	memcpy(_mouseData, buf, w * h * _cursorFormat.bytesPerPixel);
+#else
+	_mouseData = (byte *)malloc(w * h);
+	memcpy(_mouseData, buf, w * h);
+#endif
+
+	blitCursor();
+}
+
+void SdlGraphicsManager::blitCursor() {
+	byte *dstPtr;
+	const byte *srcPtr = _mouseData;
+#ifdef USE_RGB_COLOR
+	uint32 color;
+#else
+	byte color;
+#endif
+	int w, h, i, j;
+
+	if (!_mouseOrigSurface || !_mouseData)
+		return;
+
+	_mouseNeedsRedraw = true;
+
+	w = _mouseCurState.w;
+	h = _mouseCurState.h;
+
+	SDL_LockSurface(_mouseOrigSurface);
+
+	// Make whole surface transparent
+	for (i = 0; i < h + 2; i++) {
+		dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch * i;
+		for (j = 0; j < w + 2; j++) {
+			*(uint16 *)dstPtr = kMouseColorKey;
+			dstPtr += 2;
+		}
+	}
+
+	// Draw from [1,1] since AdvMame2x adds artefact at 0,0
+	dstPtr = (byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2;
+
+	SDL_Color *palette;
+
+	if (_cursorPaletteDisabled)
+		palette = _currentPalette;
+	else
+		palette = _cursorPalette;
+
+	for (i = 0; i < h; i++) {
+		for (j = 0; j < w; j++) {
+#ifdef USE_RGB_COLOR
+			if (_cursorFormat.bytesPerPixel > 1) {
+				if (_cursorFormat.bytesPerPixel == 2)
+					color = *(const uint16 *)srcPtr;
+				else
+					color = *(const uint32 *)srcPtr;
+				if (color != _mouseKeyColor) {	// transparent, don't draw
+					uint8 r, g, b;
+					_cursorFormat.colorToRGB(color, r, g, b);
+					*(uint16 *)dstPtr = SDL_MapRGB(_mouseOrigSurface->format,
+						r, g, b);
+				}
+				dstPtr += 2;
+				srcPtr += _cursorFormat.bytesPerPixel;
+			} else {
+#endif
+				color = *srcPtr;
+				if (color != _mouseKeyColor) {	// transparent, don't draw
+					*(uint16 *)dstPtr = SDL_MapRGB(_mouseOrigSurface->format,
+						palette[color].r, palette[color].g, palette[color].b);
+				}
+				dstPtr += 2;
+				srcPtr++;
+#ifdef USE_RGB_COLOR
+			}
+#endif
+		}
+		dstPtr += _mouseOrigSurface->pitch - w * 2;
+	}
+
+	int rW, rH;
+
+	if (_cursorTargetScale >= _videoMode.scaleFactor) {
+		// The cursor target scale is greater or equal to the scale at
+		// which the rest of the screen is drawn. We do not downscale
+		// the cursor image, we draw it at its original size. It will
+		// appear too large on screen.
+
+		rW = w;
+		rH = h;
+		_mouseCurState.rHotX = _mouseCurState.hotX;
+		_mouseCurState.rHotY = _mouseCurState.hotY;
+
+		// The virtual dimensions may be larger than the original.
+
+		_mouseCurState.vW = w * _cursorTargetScale / _videoMode.scaleFactor;
+		_mouseCurState.vH = h * _cursorTargetScale / _videoMode.scaleFactor;
+		_mouseCurState.vHotX = _mouseCurState.hotX * _cursorTargetScale /
+			_videoMode.scaleFactor;
+		_mouseCurState.vHotY = _mouseCurState.hotY * _cursorTargetScale /
+			_videoMode.scaleFactor;
+	} else {
+		// The cursor target scale is smaller than the scale at which
+		// the rest of the screen is drawn. We scale up the cursor
+		// image to make it appear correct.
+
+		rW = w * _videoMode.scaleFactor / _cursorTargetScale;
+		rH = h * _videoMode.scaleFactor / _cursorTargetScale;
+		_mouseCurState.rHotX = _mouseCurState.hotX * _videoMode.scaleFactor /
+			_cursorTargetScale;
+		_mouseCurState.rHotY = _mouseCurState.hotY * _videoMode.scaleFactor /
+			_cursorTargetScale;
+
+		// The virtual dimensions will be the same as the original.
+
+		_mouseCurState.vW = w;
+		_mouseCurState.vH = h;
+		_mouseCurState.vHotX = _mouseCurState.hotX;
+		_mouseCurState.vHotY = _mouseCurState.hotY;
+	}
+
+#ifdef USE_SCALERS
+	int rH1 = rH; // store original to pass to aspect-correction function later
+#endif
+
+	if (_videoMode.aspectRatioCorrection && _cursorTargetScale == 1) {
+		rH = real2Aspect(rH - 1) + 1;
+		_mouseCurState.rHotY = real2Aspect(_mouseCurState.rHotY);
+	}
+
+	if (_mouseCurState.rW != rW || _mouseCurState.rH != rH) {
+		_mouseCurState.rW = rW;
+		_mouseCurState.rH = rH;
+
+		if (_mouseSurface)
+			SDL_FreeSurface(_mouseSurface);
+
+		_mouseSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
+						_mouseCurState.rW,
+						_mouseCurState.rH,
+						16,
+						_hwscreen->format->Rmask,
+						_hwscreen->format->Gmask,
+						_hwscreen->format->Bmask,
+						_hwscreen->format->Amask);
+
+		if (_mouseSurface == NULL)
+			error("allocating _mouseSurface failed");
+
+		SDL_SetColorKey(_mouseSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, kMouseColorKey);
+	}
+
+	SDL_LockSurface(_mouseSurface);
+
+	ScalerProc *scalerProc;
+
+	// If possible, use the same scaler for the cursor as for the rest of
+	// the game. This only works well with the non-blurring scalers so we
+	// actually only use the 1x, 1.5x, 2x and AdvMame scalers.
+
+	if (_cursorTargetScale == 1 && (_videoMode.mode == GFX_DOUBLESIZE || _videoMode.mode == GFX_TRIPLESIZE))
+		scalerProc = _scalerProc;
+	else
+		scalerProc = scalersMagn[_cursorTargetScale - 1][_videoMode.scaleFactor - 1];
+
+	scalerProc((byte *)_mouseOrigSurface->pixels + _mouseOrigSurface->pitch + 2,
+		_mouseOrigSurface->pitch, (byte *)_mouseSurface->pixels, _mouseSurface->pitch,
+		_mouseCurState.w, _mouseCurState.h);
+
+#ifdef USE_SCALERS
+	if (_videoMode.aspectRatioCorrection && _cursorTargetScale == 1)
+		cursorStretch200To240((uint8 *)_mouseSurface->pixels, _mouseSurface->pitch, rW, rH1, 0, 0, 0);
+#endif
+
+	SDL_UnlockSurface(_mouseSurface);
+	SDL_UnlockSurface(_mouseOrigSurface);
+}
+
+#ifdef USE_SCALERS
+// Basically it is kVeryFastAndUglyAspectMode of stretch200To240 from
+// common/scale/aspect.cpp
+static int cursorStretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY) {
+	int maxDstY = real2Aspect(origSrcY + height - 1);
+	int y;
+	const uint8 *startSrcPtr = buf + srcX * 2 + (srcY - origSrcY) * pitch;
+	uint8 *dstPtr = buf + srcX * 2 + maxDstY * pitch;
+
+	for (y = maxDstY; y >= srcY; y--) {
+		const uint8 *srcPtr = startSrcPtr + aspect2Real(y) * pitch;
+
+		if (srcPtr == dstPtr)
+			break;
+		memcpy(dstPtr, srcPtr, width * 2);
+		dstPtr -= pitch;
+	}
+
+	return 1 + maxDstY - srcY;
+}
+#endif
+
+void SdlGraphicsManager::undrawMouse() {
+	const int x = _mouseBackup.x;
+	const int y = _mouseBackup.y;
+
+	// When we switch bigger overlay off mouse jumps. Argh!
+	// This is intended to prevent undrawing offscreen mouse
+	if (!_overlayVisible && (x >= _videoMode.screenWidth || y >= _videoMode.screenHeight))
+		return;
+
+	if (_mouseBackup.w != 0 && _mouseBackup.h != 0)
+		addDirtyRect(x, y - _currentShakePos, _mouseBackup.w, _mouseBackup.h);
+}
+
+void SdlGraphicsManager::drawMouse() {
+	if (!_mouseVisible || !_mouseSurface) {
+		_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+		return;
+	}
+
+	SDL_Rect dst;
+	int scale;
+	int width, height;
+	int hotX, hotY;
+
+	dst.x = _mouseCurState.x;
+	dst.y = _mouseCurState.y;
+
+	if (!_overlayVisible) {
+		scale = _videoMode.scaleFactor;
+		width = _videoMode.screenWidth;
+		height = _videoMode.screenHeight;
+		dst.w = _mouseCurState.vW;
+		dst.h = _mouseCurState.vH;
+		hotX = _mouseCurState.vHotX;
+		hotY = _mouseCurState.vHotY;
+	} else {
+		scale = 1;
+		width = _videoMode.overlayWidth;
+		height = _videoMode.overlayHeight;
+		dst.w = _mouseCurState.rW;
+		dst.h = _mouseCurState.rH;
+		hotX = _mouseCurState.rHotX;
+		hotY = _mouseCurState.rHotY;
+	}
+
+	// The mouse is undrawn using virtual coordinates, i.e. they may be
+	// scaled and aspect-ratio corrected.
+
+	_mouseBackup.x = dst.x - hotX;
+	_mouseBackup.y = dst.y - hotY;
+	_mouseBackup.w = dst.w;
+	_mouseBackup.h = dst.h;
+
+	// We draw the pre-scaled cursor image, so now we need to adjust for
+	// scaling, shake position and aspect ratio correction manually.
+
+	if (!_overlayVisible) {
+		dst.y += _currentShakePos;
+	}
+
+	if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+		dst.y = real2Aspect(dst.y);
+
+	dst.x = scale * dst.x - _mouseCurState.rHotX;
+	dst.y = scale * dst.y - _mouseCurState.rHotY;
+	dst.w = _mouseCurState.rW;
+	dst.h = _mouseCurState.rH;
+
+	// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
+	// clipping necessary
+
+	if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0)
+		error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+	// The screen will be updated using real surface coordinates, i.e.
+	// they will not be scaled or aspect-ratio corrected.
+
+	addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+#pragma mark -
+#pragma mark --- On Screen Display ---
+#pragma mark -
+
+#ifdef USE_OSD
+void SdlGraphicsManager::displayMessageOnOSD(const char *msg) {
+	assert (_transactionMode == kTransactionNone);
+	assert(msg);
+
+	Common::StackLock lock(_graphicsMutex);	// Lock the mutex until this function ends
+
+	uint i;
+
+	// Lock the OSD surface for drawing
+	if (SDL_LockSurface(_osdSurface))
+		error("displayMessageOnOSD: SDL_LockSurface failed: %s", SDL_GetError());
+
+	Graphics::Surface dst;
+	dst.pixels = _osdSurface->pixels;
+	dst.w = _osdSurface->w;
+	dst.h = _osdSurface->h;
+	dst.pitch = _osdSurface->pitch;
+	dst.bytesPerPixel = _osdSurface->format->BytesPerPixel;
+
+	// The font we are going to use:
+	const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kOSDFont);
+
+	// Clear everything with the "transparent" color, i.e. the colorkey
+	SDL_FillRect(_osdSurface, 0, kOSDColorKey);
+
+	// Split the message into separate lines.
+	Common::Array<Common::String> lines;
+	const char *ptr;
+	for (ptr = msg; *ptr; ++ptr) {
+		if (*ptr == '\n') {
+			lines.push_back(Common::String(msg, ptr - msg));
+			msg = ptr + 1;
+		}
+	}
+	lines.push_back(Common::String(msg, ptr - msg));
+
+	// Determine a rect which would contain the message string (clipped to the
+	// screen dimensions).
+	const int vOffset = 6;
+	const int lineSpacing = 1;
+	const int lineHeight = font->getFontHeight() + 2 * lineSpacing;
+	int width = 0;
+	int height = lineHeight * lines.size() + 2 * vOffset;
+	for (i = 0; i < lines.size(); i++) {
+		width = MAX(width, font->getStringWidth(lines[i]) + 14);
+	}
+
+	// Clip the rect
+	if (width > dst.w)
+		width = dst.w;
+	if (height > dst.h)
+		height = dst.h;
+
+	// Draw a dark gray rect
+	// TODO: Rounded corners ? Border?
+	SDL_Rect osdRect;
+	osdRect.x = (dst.w - width) / 2;
+	osdRect.y = (dst.h - height) / 2;
+	osdRect.w = width;
+	osdRect.h = height;
+	SDL_FillRect(_osdSurface, &osdRect, SDL_MapRGB(_osdSurface->format, 64, 64, 64));
+
+	// Render the message, centered, and in white
+	for (i = 0; i < lines.size(); i++) {
+		font->drawString(&dst, lines[i],
+							osdRect.x, osdRect.y + i * lineHeight + vOffset + lineSpacing, osdRect.w,
+							SDL_MapRGB(_osdSurface->format, 255, 255, 255),
+							Graphics::kTextAlignCenter);
+	}
+
+	// Finished drawing, so unlock the OSD surface again
+	SDL_UnlockSurface(_osdSurface);
+
+	// Init the OSD display parameters, and the fade out
+	_osdAlpha = SDL_ALPHA_TRANSPARENT + kOSDInitialAlpha * (SDL_ALPHA_OPAQUE - SDL_ALPHA_TRANSPARENT) / 100;
+	_osdFadeStartTime = SDL_GetTicks() + kOSDFadeOutDelay;
+	SDL_SetAlpha(_osdSurface, SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA, _osdAlpha);
+
+	// Ensure a full redraw takes place next time the screen is updated
+	_forceFull = true;
+}
+#endif
+
+bool SdlGraphicsManager::handleScalerHotkeys(Common::KeyCode key) {
+
+	// Ctrl-Alt-a toggles aspect ratio correction
+	if (key == 'a') {
+		beginGFXTransaction();
+			setFeatureState(OSystem::kFeatureAspectRatioCorrection, !_videoMode.aspectRatioCorrection);
+		endGFXTransaction();
+#ifdef USE_OSD
+		char buffer[128];
+		if (_videoMode.aspectRatioCorrection)
+			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;
+	}
+
+	int newMode = -1;
+	int factor = _videoMode.scaleFactor - 1;
+	SDLKey sdlKey = (SDLKey)key;
+
+	// Increase/decrease the scale factor
+	if (sdlKey == SDLK_EQUALS || sdlKey == SDLK_PLUS || sdlKey == SDLK_MINUS ||
+		sdlKey == SDLK_KP_PLUS || sdlKey == SDLK_KP_MINUS) {
+		factor += (sdlKey == SDLK_MINUS || sdlKey == SDLK_KP_MINUS) ? -1 : +1;
+		if (0 <= factor && factor <= 3) {
+			newMode = s_gfxModeSwitchTable[_scalerType][factor];
+		}
+	}
+
+	const bool isNormalNumber = (SDLK_1 <= sdlKey && sdlKey <= SDLK_9);
+	const bool isKeypadNumber = (SDLK_KP1 <= sdlKey && sdlKey <= SDLK_KP9);
+	if (isNormalNumber || isKeypadNumber) {
+		_scalerType = sdlKey - (isNormalNumber ? SDLK_1 : SDLK_KP1);
+		if (_scalerType >= ARRAYSIZE(s_gfxModeSwitchTable))
+			return false;
+
+		while (s_gfxModeSwitchTable[_scalerType][factor] < 0) {
+			assert(factor > 0);
+			factor--;
+		}
+		newMode = s_gfxModeSwitchTable[_scalerType][factor];
+	}
+
+	if (newMode >= 0) {
+		beginGFXTransaction();
+			setGraphicsMode(newMode);
+		endGFXTransaction();
+#ifdef USE_OSD
+		if (_osdSurface) {
+			const char *newScalerName = 0;
+			const OSystem::GraphicsMode *g = getSupportedGraphicsModes();
+			while (g->name) {
+				if (g->id == _videoMode.mode) {
+					newScalerName = g->description;
+					break;
+				}
+				g++;
+			}
+			if (newScalerName) {
+				char buffer[128];
+				sprintf(buffer, "Active graphics filter: %s\n%d x %d -> %d x %d",
+					newScalerName,
+					_videoMode.screenWidth, _videoMode.screenHeight,
+					_hwscreen->w, _hwscreen->h
+					);
+				displayMessageOnOSD(buffer);
+			}
+		}
+#endif
+		internUpdateScreen();
+
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool SdlGraphicsManager::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);
+		const bool isScaleKey = (event.kbd.keycode == Common::KEYCODE_EQUALS || event.kbd.keycode == Common::KEYCODE_PLUS || event.kbd.keycode == Common::KEYCODE_MINUS ||
+			event.kbd.keycode == Common::KEYCODE_KP_PLUS || event.kbd.keycode == Common::KEYCODE_KP_MINUS);
+
+		if (isNormalNumber || isKeypadNumber) {
+			int keyValue = event.kbd.keycode - (isNormalNumber ? Common::KEYCODE_1 : Common::KEYCODE_KP1);
+			if (keyValue >= ARRAYSIZE(s_gfxModeSwitchTable))
+				return false;
+		}
+		return (isScaleKey || event.kbd.keycode == 'a');
+	}
+	return false;
+}
+
+void SdlGraphicsManager::adjustMouseEvent(const Common::Event &event) {
+	if (!event.synthetic) {
+		Common::Event newEvent(event);
+		newEvent.synthetic = true;
+		if (!_overlayVisible) {
+			newEvent.mouse.x /= _videoMode.scaleFactor;
+			newEvent.mouse.y /= _videoMode.scaleFactor;
+			if (_videoMode.aspectRatioCorrection)
+				newEvent.mouse.y = aspect2Real(newEvent.mouse.y);
+		}
+		g_system->getEventManager()->pushEvent(newEvent);
+	}
+}
+
+void SdlGraphicsManager::toggleFullScreen() {
+	beginGFXTransaction();
+		setFullscreenMode(!_videoMode.fullscreen);
+	endGFXTransaction();
+#ifdef USE_OSD
+	if (_videoMode.fullscreen)
+		displayMessageOnOSD("Fullscreen mode");
+	else
+		displayMessageOnOSD("Windowed mode");
+#endif
+}
+
+bool SdlGraphicsManager::notifyEvent(const Common::Event &event) {
+	switch ((int)event.type) {
+	case Common::EVENT_KEYDOWN:
+		// Alt-Return and Alt-Enter toggle full screen mode
+		if (event.kbd.hasFlags(Common::KBD_ALT) &&
+			(event.kbd.keycode == Common::KEYCODE_RETURN ||
+			event.kbd.keycode == (Common::KeyCode)SDLK_KP_ENTER)) {
+			toggleFullScreen();
+			return true;
+		}
+
+		// Alt-S: Create a screenshot
+		if (event.kbd.hasFlags(Common::KBD_ALT) && 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;
+		}
+
+		// Ctrl-Alt-<key> will change the GFX mode
+		if (event.kbd.hasFlags(Common::KBD_CTRL|Common::KBD_ALT)) {
+			if (handleScalerHotkeys(event.kbd.keycode))
+				return true;
+		}
+	case Common::EVENT_KEYUP:
+		return isScalerHotkey(event);
+	case Common::EVENT_MOUSEMOVE:
+		if (event.synthetic)
+			setMousePos(event.mouse.x, event.mouse.y);
+	case Common::EVENT_LBUTTONDOWN:
+	case Common::EVENT_RBUTTONDOWN:
+	case Common::EVENT_WHEELUP:
+	case Common::EVENT_WHEELDOWN:
+	case Common::EVENT_MBUTTONDOWN:
+	case Common::EVENT_LBUTTONUP:
+	case Common::EVENT_RBUTTONUP:
+	case Common::EVENT_MBUTTONUP:
+		adjustMouseEvent(event);
+		return !event.synthetic;
+
+	// HACK: Handle special SDL event
+	case OSystem_SDL::kSdlEventExpose:
+		_forceFull = true;
+		return false;
+	default:
+		break;
+	}
+
+	return false;
+}
+
+#endif
diff --git a/backends/graphics/sdl/sdl-graphics.h b/backends/graphics/sdl/sdl-graphics.h
new file mode 100644
index 0000000000..62f87ee238
--- /dev/null
+++ b/backends/graphics/sdl/sdl-graphics.h
@@ -0,0 +1,329 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_SDL_H
+#define BACKENDS_GRAPHICS_SDL_H
+
+#include "backends/graphics/graphics.h"
+#include "graphics/scaler.h"
+#include "common/events.h"
+#include "common/system.h"
+
+#include "backends/events/sdl/sdl-events.h"
+
+#if defined(__SYMBIAN32__)
+#include <esdl\SDL.h>
+#else
+#include <SDL.h>
+#endif
+
+#if !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
+// Uncomment this to enable the 'on screen display' code.
+#define USE_OSD	1
+#endif
+
+enum {
+	GFX_NORMAL = 0,
+	GFX_DOUBLESIZE = 1,
+	GFX_TRIPLESIZE = 2,
+	GFX_2XSAI = 3,
+	GFX_SUPER2XSAI = 4,
+	GFX_SUPEREAGLE = 5,
+	GFX_ADVMAME2X = 6,
+	GFX_ADVMAME3X = 7,
+	GFX_HQ2X = 8,
+	GFX_HQ3X = 9,
+	GFX_TV2X = 10,
+	GFX_DOTMATRIX = 11
+};
+
+
+class AspectRatio {
+	int _kw, _kh;
+public:
+	AspectRatio() { _kw = _kh = 0; }
+	AspectRatio(int w, int h);
+
+	bool isAuto() const { return (_kw | _kh) == 0; }
+
+	int kw() const { return _kw; }
+	int kh() const { return _kh; }
+};
+
+/**
+ * SDL graphics manager
+ */
+class SdlGraphicsManager : public GraphicsManager, public Common::EventObserver {
+public:
+	SdlGraphicsManager(SdlEventSource *sdlEventSource);
+	virtual ~SdlGraphicsManager();
+
+	virtual void initEventObserver();
+
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+	virtual bool getFeatureState(OSystem::Feature f);
+
+	static const OSystem::GraphicsMode *supportedGraphicsModes();
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+	virtual int getGraphicsMode() const;
+	virtual void resetGraphicsScale();
+#ifdef USE_RGB_COLOR
+	virtual Graphics::PixelFormat getScreenFormat() const { return _screenFormat; }
+	virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const;
+#endif
+	virtual void initSize(uint w, uint h, const Graphics::PixelFormat *format = NULL);
+	virtual int getScreenChangeID() const { return _screenChangeCount; }
+
+	virtual void beginGFXTransaction();
+	virtual OSystem::TransactionError endGFXTransaction();
+	
+	virtual int16 getHeight();
+	virtual int16 getWidth();
+	virtual void setPalette(const byte *colors, uint start, uint num);
+	virtual void grabPalette(byte *colors, uint start, uint num);
+	virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+	virtual Graphics::Surface *lockScreen();
+	virtual void unlockScreen();
+	virtual void fillScreen(uint32 col);
+	virtual void updateScreen();
+	virtual void setShakePos(int shakeOffset);
+	virtual void setFocusRectangle(const Common::Rect& rect) {}
+	virtual void clearFocusRectangle() {}
+
+	virtual void showOverlay();
+	virtual void hideOverlay();
+	virtual Graphics::PixelFormat getOverlayFormat() const { return _overlayFormat; }
+	virtual void clearOverlay();
+	virtual void grabOverlay(OverlayColor *buf, int pitch);
+	virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
+	virtual int16 getOverlayHeight() { return _videoMode.overlayHeight; }
+	virtual int16 getOverlayWidth() { return _videoMode.overlayWidth; }
+
+	virtual bool showMouse(bool visible);
+	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);
+	virtual void disableCursorPalette(bool disable);
+	
+#ifdef USE_OSD
+	virtual void displayMessageOnOSD(const char *msg);
+#endif
+
+	// Override from Common::EventObserver
+	bool notifyEvent(const Common::Event &event);
+
+protected:
+	SdlEventSource *_sdlEventSource;
+
+#ifdef USE_OSD
+	/** Surface containing the OSD message */
+	SDL_Surface *_osdSurface;
+	/** Transparency level of the OSD */
+	uint8 _osdAlpha;
+	/** When to start the fade out */
+	uint32 _osdFadeStartTime; 
+	/** Enum with OSD options */
+	enum {
+		kOSDFadeOutDelay = 2 * 1000,	/** < Delay before the OSD is faded out (in milliseconds) */
+		kOSDFadeOutDuration = 500,		/** < Duration of the OSD fade out (in milliseconds) */
+		kOSDColorKey = 1,				/** < Transparent color key */
+		kOSDInitialAlpha = 80			/** < Initial alpha level, in percent */
+	};
+#endif
+
+	/** Hardware screen */
+	SDL_Surface *_hwscreen;
+
+	/** Unseen game screen */
+	SDL_Surface *_screen;
+#ifdef USE_RGB_COLOR
+	Graphics::PixelFormat _screenFormat;
+	Graphics::PixelFormat _cursorFormat;
+	Common::List<Graphics::PixelFormat> _supportedFormats;
+
+	/**
+	 * Update the list of supported pixel formats.
+	 * This method is invoked by loadGFXMode().
+	 */
+	void detectSupportedFormats();
+#endif
+
+	/** Temporary screen (for scalers) */
+	SDL_Surface *_tmpscreen;
+	/** Temporary screen (for scalers) */
+	SDL_Surface *_tmpscreen2;
+
+	SDL_Surface *_overlayscreen;
+	bool _overlayVisible;
+	Graphics::PixelFormat _overlayFormat;
+
+	enum {
+		kTransactionNone = 0,
+		kTransactionActive = 1,
+		kTransactionRollback = 2
+	};
+
+	struct TransactionDetails {
+		bool sizeChanged;
+		bool needHotswap;
+		bool needUpdatescreen;
+		bool normal1xScaler;
+#ifdef USE_RGB_COLOR
+		bool formatChanged;
+#endif
+	};
+	TransactionDetails _transactionDetails;
+
+	struct VideoState {
+		bool setup;
+
+		bool fullscreen;
+		bool aspectRatioCorrection;
+		AspectRatio desiredAspectRatio;
+
+		int mode;
+		int scaleFactor;
+
+		int screenWidth, screenHeight;
+		int overlayWidth, overlayHeight;
+		int hardwareWidth, hardwareHeight;
+#ifdef USE_RGB_COLOR
+		Graphics::PixelFormat format;
+#endif
+	};
+	VideoState _videoMode, _oldVideoMode;
+
+	/** Force full redraw on next updateScreen */
+	bool _forceFull;
+
+	ScalerProc *_scalerProc;
+	int _scalerType;
+	int _transactionMode;
+
+	bool _screenIsLocked;
+	Graphics::Surface _framebuffer;
+
+	int _screenChangeCount;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+		MAX_SCALING = 3
+	};
+
+	// Dirty rect management
+	SDL_Rect _dirtyRectList[NUM_DIRTY_RECT];
+	int _numDirtyRects;
+
+	struct MousePos {
+		// The mouse position, using either virtual (game) or real
+		// (overlay) coordinates.
+		int16 x, y;
+
+		// The size and hotspot of the original cursor image.
+		int16 w, h;
+		int16 hotX, hotY;
+
+		// The size and hotspot of the pre-scaled cursor image, in real
+		// coordinates.
+		int16 rW, rH;
+		int16 rHotX, rHotY;
+
+		// The size and hotspot of the pre-scaled cursor image, in game
+		// coordinates.
+		int16 vW, vH;
+		int16 vHotX, vHotY;
+
+		MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0),
+					rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0),
+					vHotX(0), vHotY(0)
+			{ }
+	};
+
+	bool _mouseVisible;
+	bool _mouseNeedsRedraw;
+	byte *_mouseData;
+	SDL_Rect _mouseBackup;
+	MousePos _mouseCurState;
+#ifdef USE_RGB_COLOR
+	uint32 _mouseKeyColor;
+#else
+	byte _mouseKeyColor;
+#endif
+	int _cursorTargetScale;
+	bool _cursorPaletteDisabled;
+	SDL_Surface *_mouseOrigSurface;
+	SDL_Surface *_mouseSurface;
+	enum {
+		kMouseColorKey = 1
+	};
+
+	// Shake mode
+	int _currentShakePos;
+	int _newShakePos;
+
+	// Palette data
+	SDL_Color *_currentPalette;
+	uint _paletteDirtyStart, _paletteDirtyEnd;
+
+	// Cursor palette data
+	SDL_Color *_cursorPalette;
+
+	/**
+	 * Mutex which prevents multiple threads from interfering with each other
+	 * when accessing the screen.
+	 */
+	OSystem::MutexRef _graphicsMutex;
+
+	virtual void addDirtyRect(int x, int y, int w, int h, bool realCoordinates = false);
+
+	virtual void drawMouse();
+	virtual void undrawMouse();
+	virtual void blitCursor();
+
+	virtual void internUpdateScreen();
+
+	virtual bool loadGFXMode();
+	virtual void unloadGFXMode();
+	virtual bool hotswapGFXMode();
+
+	virtual void setFullscreenMode(bool enable);
+	virtual void setAspectRatioCorrection(bool enable);
+
+	virtual int effectiveScreenHeight() const;
+
+	virtual void setGraphicsModeIntern();
+
+	virtual bool handleScalerHotkeys(Common::KeyCode key);
+	virtual bool isScalerHotkey(const Common::Event &event);
+	virtual void adjustMouseEvent(const Common::Event &event);
+	virtual void setMousePos(int x, int y);
+	virtual void toggleFullScreen();
+	virtual bool saveScreenshot(const char *filename);
+};
+
+#endif
diff --git a/backends/graphics/symbiansdl/symbiansdl-graphics.cpp b/backends/graphics/symbiansdl/symbiansdl-graphics.cpp
new file mode 100644
index 0000000000..c89c46ddd8
--- /dev/null
+++ b/backends/graphics/symbiansdl/symbiansdl-graphics.cpp
@@ -0,0 +1,77 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifdef __SYMBIAN32__
+
+#include "backends/graphics/symbiansdl/symbiansdl-graphics.h"
+#include "backends/platform/symbian/src/SymbianActions.h"
+
+int SymbianSdlGraphicsManager::getDefaultGraphicsMode() const {
+	return GFX_NORMAL;
+}
+
+static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
+	{"1x", "Fullscreen", GFX_NORMAL},
+	{0, 0, 0}
+};
+
+const OSystem::GraphicsMode *SymbianSdlGraphicsManager::getSupportedGraphicsModes() const {
+	return s_supportedGraphicsModes;
+}
+
+// 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());
+}
+
+bool SymbianSdlGraphicsManager::hasFeature(OSystem::Feature f) {
+	switch (f) {
+	case OSystem::kFeatureFullscreenMode:
+	case OSystem::kFeatureAspectRatioCorrection:
+	case OSystem::kFeatureCursorHasPalette:
+#ifdef  USE_VIBRA_SE_PXXX
+	case OSystem::kFeatureVibration:
+#endif
+		return true;
+	default:
+		return false;
+	}
+}
+
+void SymbianSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
+	switch (f) {
+	case OSystem::kFeatureVirtualKeyboard:
+		break;
+	case OSystem::kFeatureDisableKeyFiltering:
+		GUI::Actions::Instance()->beginMapping(enable);
+		break;
+	default:
+		SdlGraphicsManager::setFeatureState(f, enable);
+	}
+}
+
+#endif
+
diff --git a/backends/graphics/symbiansdl/symbiansdl-graphics.h b/backends/graphics/symbiansdl/symbiansdl-graphics.h
new file mode 100644
index 0000000000..b0e87c8025
--- /dev/null
+++ b/backends/graphics/symbiansdl/symbiansdl-graphics.h
@@ -0,0 +1,42 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef BACKENDS_GRAPHICS_SYMBIAN_SDL_H
+#define BACKENDS_GRAPHICS_SYMBIAN_SDL_H
+
+#include "backends/graphics/sdl/sdl-graphics.h"
+
+class SymbianSdlGraphicsManager : public SdlGraphicsManager {
+public:
+	virtual bool hasFeature(OSystem::Feature f);
+	virtual void setFeatureState(OSystem::Feature f, bool enable);
+
+	virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
+	virtual int getDefaultGraphicsMode() const;
+	virtual bool setGraphicsMode(int mode);
+};
+
+#endif
+