aboutsummaryrefslogtreecommitdiff
path: root/backends/platform/sdl
diff options
context:
space:
mode:
Diffstat (limited to 'backends/platform/sdl')
-rw-r--r--backends/platform/sdl/amigaos/amigaos-main.cpp54
-rw-r--r--backends/platform/sdl/amigaos/amigaos.cpp39
-rw-r--r--backends/platform/sdl/amigaos/amigaos.h39
-rw-r--r--backends/platform/sdl/events.cpp573
-rw-r--r--backends/platform/sdl/graphics.cpp1946
-rw-r--r--backends/platform/sdl/macosx/macosx-main.cpp54
-rw-r--r--backends/platform/sdl/macosx/macosx.cpp76
-rw-r--r--backends/platform/sdl/macosx/macosx.h41
-rw-r--r--backends/platform/sdl/main.cpp33
-rw-r--r--backends/platform/sdl/module.mk26
-rw-r--r--backends/platform/sdl/posix/posix-main.cpp54
-rw-r--r--backends/platform/sdl/posix/posix.cpp68
-rw-r--r--backends/platform/sdl/posix/posix.h48
-rw-r--r--backends/platform/sdl/sdl.cpp834
-rw-r--r--backends/platform/sdl/sdl.h486
-rw-r--r--backends/platform/sdl/win32/win32-main.cpp66
-rw-r--r--backends/platform/sdl/win32/win32.cpp93
-rw-r--r--backends/platform/sdl/win32/win32.h39
18 files changed, 3583 insertions, 986 deletions
diff --git a/backends/platform/sdl/amigaos/amigaos-main.cpp b/backends/platform/sdl/amigaos/amigaos-main.cpp
deleted file mode 100644
index db4598e879..0000000000
--- a/backends/platform/sdl/amigaos/amigaos-main.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* 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(__amigaos4__)
-
-#include "backends/platform/sdl/amigaos/amigaos.h"
-#include "backends/plugins/sdl/sdl-provider.h"
-#include "base/main.h"
-
-int main(int argc, char *argv[]) {
-
- // Create our OSystem instance
- g_system = new OSystem_AmigaOS();
- assert(g_system);
-
- // Pre initialize the backend
- ((OSystem_AmigaOS *)g_system)->init();
-
-#ifdef DYNAMIC_MODULES
- PluginManager::instance().addPluginProvider(new SDLPluginProvider());
-#endif
-
- // Invoke the actual ScummVM main entry point:
- int res = scummvm_main(argc, argv);
-
- // Free OSystem
- delete (OSystem_AmigaOS *)g_system;
-
- return res;
-}
-
-#endif
diff --git a/backends/platform/sdl/amigaos/amigaos.cpp b/backends/platform/sdl/amigaos/amigaos.cpp
deleted file mode 100644
index d2924445a3..0000000000
--- a/backends/platform/sdl/amigaos/amigaos.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/* 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 __amigaos4__
-
-#include "backends/platform/sdl/amigaos/amigaos.h"
-#include "backends/fs/amigaos4/amigaos4-fs-factory.h"
-
-void OSystem_AmigaOS::init() {
- // Initialze File System Factory
- _fsFactory = new AmigaOSFilesystemFactory();
-
- // Invoke parent implementation of this method
- OSystem_SDL::init();
-}
-
-#endif
diff --git a/backends/platform/sdl/amigaos/amigaos.h b/backends/platform/sdl/amigaos/amigaos.h
deleted file mode 100644
index 92232ec98a..0000000000
--- a/backends/platform/sdl/amigaos/amigaos.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* 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 PLATFORM_SDL_AMIGAOS_H
-#define PLATFORM_SDL_AMIGAOS_H
-
-#include "backends/platform/sdl/sdl.h"
-
-class OSystem_AmigaOS : public OSystem_SDL {
-public:
- OSystem_AmigaOS() {}
- virtual ~OSystem_AmigaOS() {}
-
- virtual void init();
-};
-
-#endif
diff --git a/backends/platform/sdl/events.cpp b/backends/platform/sdl/events.cpp
new file mode 100644
index 0000000000..1c1d82730f
--- /dev/null
+++ b/backends/platform/sdl/events.cpp
@@ -0,0 +1,573 @@
+/* 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$
+ *
+ */
+
+#include "backends/platform/sdl/sdl.h"
+#include "common/util.h"
+#include "common/events.h"
+#include "graphics/scaler/aspect.h" // for aspect2Real
+
+// FIXME move joystick defines out and replace with confile file options
+// we should really allow users to map any key to a joystick button
+#define JOY_DEADZONE 3200
+
+#ifndef __SYMBIAN32__ // Symbian wants dialog joystick i.e cursor for movement/selection
+ #define JOY_ANALOG
+#endif
+
+// #define JOY_INVERT_Y
+#define JOY_XAXIS 0
+#define JOY_YAXIS 1
+// buttons
+#define JOY_BUT_LMOUSE 0
+#define JOY_BUT_RMOUSE 2
+#define JOY_BUT_ESCAPE 3
+#define JOY_BUT_PERIOD 1
+#define JOY_BUT_SPACE 4
+#define JOY_BUT_F5 5
+
+
+
+
+static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode) {
+ if (key >= SDLK_F1 && key <= SDLK_F9) {
+ return key - SDLK_F1 + Common::ASCII_F1;
+ } else if (key >= SDLK_KP0 && key <= SDLK_KP9) {
+ return key - SDLK_KP0 + '0';
+ } else if (key >= SDLK_UP && key <= SDLK_PAGEDOWN) {
+ return key;
+ } else if (unicode) {
+ return unicode;
+ } else if (key >= 'a' && key <= 'z' && (mod & KMOD_SHIFT)) {
+ return key & ~0x20;
+ } else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO) {
+ return 0;
+ }
+ return key;
+}
+
+void OSystem_SDL::fillMouseEvent(Common::Event &event, int x, int y) {
+ event.mouse.x = x;
+ event.mouse.y = y;
+
+ // Update the "keyboard mouse" coords
+ _km.x = x;
+ _km.y = y;
+
+ // Adjust for the screen scaling
+ if (!_overlayVisible) {
+ event.mouse.x /= _videoMode.scaleFactor;
+ event.mouse.y /= _videoMode.scaleFactor;
+ if (_videoMode.aspectRatioCorrection)
+ event.mouse.y = aspect2Real(event.mouse.y);
+ }
+}
+
+void OSystem_SDL::handleKbdMouse() {
+ uint32 curTime = getMillis();
+ if (curTime >= _km.last_time + _km.delay_time) {
+ _km.last_time = curTime;
+ if (_km.x_down_count == 1) {
+ _km.x_down_time = curTime;
+ _km.x_down_count = 2;
+ }
+ if (_km.y_down_count == 1) {
+ _km.y_down_time = curTime;
+ _km.y_down_count = 2;
+ }
+
+ if (_km.x_vel || _km.y_vel) {
+ if (_km.x_down_count) {
+ if (curTime > _km.x_down_time + _km.delay_time * 12) {
+ if (_km.x_vel > 0)
+ _km.x_vel++;
+ else
+ _km.x_vel--;
+ } else if (curTime > _km.x_down_time + _km.delay_time * 8) {
+ if (_km.x_vel > 0)
+ _km.x_vel = 5;
+ else
+ _km.x_vel = -5;
+ }
+ }
+ if (_km.y_down_count) {
+ if (curTime > _km.y_down_time + _km.delay_time * 12) {
+ if (_km.y_vel > 0)
+ _km.y_vel++;
+ else
+ _km.y_vel--;
+ } else if (curTime > _km.y_down_time + _km.delay_time * 8) {
+ if (_km.y_vel > 0)
+ _km.y_vel = 5;
+ else
+ _km.y_vel = -5;
+ }
+ }
+
+ _km.x += _km.x_vel;
+ _km.y += _km.y_vel;
+
+ if (_km.x < 0) {
+ _km.x = 0;
+ _km.x_vel = -1;
+ _km.x_down_count = 1;
+ } else if (_km.x > _km.x_max) {
+ _km.x = _km.x_max;
+ _km.x_vel = 1;
+ _km.x_down_count = 1;
+ }
+
+ if (_km.y < 0) {
+ _km.y = 0;
+ _km.y_vel = -1;
+ _km.y_down_count = 1;
+ } else if (_km.y > _km.y_max) {
+ _km.y = _km.y_max;
+ _km.y_vel = 1;
+ _km.y_down_count = 1;
+ }
+
+ SDL_WarpMouse((Uint16)_km.x, (Uint16)_km.y);
+ }
+ }
+}
+
+static void SDLModToOSystemKeyFlags(SDLMod mod, Common::Event &event) {
+
+ event.kbd.flags = 0;
+
+#ifdef LINUPY
+ // Yopy has no ALT key, steal the SHIFT key
+ // (which isn't used much anyway)
+ if (mod & KMOD_SHIFT)
+ event.kbd.flags |= Common::KBD_ALT;
+#else
+ if (mod & KMOD_SHIFT)
+ event.kbd.flags |= Common::KBD_SHIFT;
+ if (mod & KMOD_ALT)
+ event.kbd.flags |= Common::KBD_ALT;
+#endif
+ if (mod & KMOD_CTRL)
+ event.kbd.flags |= Common::KBD_CTRL;
+
+ // Sticky flags
+ if (mod & KMOD_NUM)
+ event.kbd.flags |= Common::KBD_NUM;
+ if (mod & KMOD_CAPS)
+ event.kbd.flags |= Common::KBD_CAPS;
+}
+
+bool OSystem_SDL::pollEvent(Common::Event &event) {
+ SDL_Event ev;
+ ev.type = SDL_NOEVENT;
+
+ handleKbdMouse();
+
+ // If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
+ if (_modeChanged) {
+ _modeChanged = false;
+ event.type = Common::EVENT_SCREEN_CHANGED;
+ return true;
+ }
+
+ while (SDL_PollEvent(&ev)) {
+ preprocessEvents(&ev);
+ if (dispatchSDLEvent(ev, event))
+ return true;
+ }
+ return false;
+}
+
+bool OSystem_SDL::dispatchSDLEvent(SDL_Event &ev, Common::Event &event) {
+ switch (ev.type) {
+ case SDL_KEYDOWN:
+ return handleKeyDown(ev, event);
+ case SDL_KEYUP:
+ return handleKeyUp(ev, event);
+ case SDL_MOUSEMOTION:
+ return handleMouseMotion(ev, event);
+ case SDL_MOUSEBUTTONDOWN:
+ return handleMouseButtonDown(ev, event);
+ case SDL_MOUSEBUTTONUP:
+ return handleMouseButtonUp(ev, event);
+ case SDL_JOYBUTTONDOWN:
+ return handleJoyButtonDown(ev, event);
+ case SDL_JOYBUTTONUP:
+ return handleJoyButtonUp(ev, event);
+ case SDL_JOYAXISMOTION:
+ return handleJoyAxisMotion(ev, event);
+
+ case SDL_VIDEOEXPOSE:
+ _forceFull = true;
+ break;
+
+ case SDL_QUIT:
+ event.type = Common::EVENT_QUIT;
+ return true;
+
+ }
+
+ return false;
+}
+
+
+bool OSystem_SDL::handleKeyDown(SDL_Event &ev, Common::Event &event) {
+
+ SDLModToOSystemKeyFlags(SDL_GetModState(), event);
+
+ // Handle scroll lock as a key modifier
+ if (ev.key.keysym.sym == SDLK_SCROLLOCK)
+ _scrollLock = !_scrollLock;
+
+ if (_scrollLock)
+ event.kbd.flags |= Common::KBD_SCRL;
+
+ // Alt-Return and Alt-Enter toggle full screen mode
+ if (event.kbd.hasFlags(Common::KBD_ALT) && (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_KP_ENTER)) {
+ beginGFXTransaction();
+ setFullscreenMode(!_videoMode.fullscreen);
+ endGFXTransaction();
+#ifdef USE_OSD
+ if (_videoMode.fullscreen)
+ displayMessageOnOSD("Fullscreen mode");
+ else
+ displayMessageOnOSD("Windowed mode");
+#endif
+
+ return false;
+ }
+
+ // Alt-S: Create a screenshot
+ if (event.kbd.hasFlags(Common::KBD_ALT) && ev.key.keysym.sym == 's') {
+ char filename[20];
+
+ for (int n = 0;; n++) {
+ SDL_RWops *file;
+
+ sprintf(filename, "scummvm%05d.bmp", n);
+ file = SDL_RWFromFile(filename, "r");
+ if (!file)
+ break;
+ SDL_RWclose(file);
+ }
+ if (saveScreenshot(filename))
+ printf("Saved '%s'\n", filename);
+ else
+ printf("Could not save screenshot!\n");
+ return false;
+ }
+
+ // Ctrl-m toggles mouse capture
+ if (event.kbd.hasFlags(Common::KBD_CTRL) && ev.key.keysym.sym == 'm') {
+ toggleMouseGrab();
+ return false;
+ }
+
+#if defined(MACOSX)
+ // On Macintosh', Cmd-Q quits
+ if ((ev.key.keysym.mod & KMOD_META) && ev.key.keysym.sym == 'q') {
+ event.type = Common::EVENT_QUIT;
+ return true;
+ }
+#elif defined(UNIX)
+ // On other unices, Control-Q quits
+ if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'q') {
+ event.type = Common::EVENT_QUIT;
+ return true;
+ }
+#else
+ // Ctrl-z and Alt-X quit
+ if ((event.kbd.hasFlags(Common::KBD_CTRL) && ev.key.keysym.sym == 'z') || (event.kbd.hasFlags(Common::KBD_ALT) && ev.key.keysym.sym == 'x')) {
+ event.type = Common::EVENT_QUIT;
+ return true;
+ }
+#endif
+
+ if ((ev.key.keysym.mod & KMOD_CTRL) && ev.key.keysym.sym == 'u') {
+ event.type = Common::EVENT_MUTE;
+ return true;
+ }
+
+ // Ctrl-Alt-<key> will change the GFX mode
+ if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
+ if (handleScalerHotkeys(ev.key))
+ return false;
+ }
+
+ if (remapKey(ev, event))
+ return true;
+
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
+ event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+
+ return true;
+}
+
+bool OSystem_SDL::handleKeyUp(SDL_Event &ev, Common::Event &event) {
+ if (remapKey(ev, event))
+ return true;
+
+ event.type = Common::EVENT_KEYUP;
+ event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
+ event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+
+ // Ctrl-Alt-<key> will change the GFX mode
+ SDLModToOSystemKeyFlags(SDL_GetModState(), event);
+
+ // Set the scroll lock sticky flag
+ if (_scrollLock)
+ event.kbd.flags |= Common::KBD_SCRL;
+
+ if (isScalerHotkey(event))
+ // Swallow these key up events
+ return false;
+
+ return true;
+}
+
+bool OSystem_SDL::handleMouseMotion(SDL_Event &ev, Common::Event &event) {
+ event.type = Common::EVENT_MOUSEMOVE;
+ fillMouseEvent(event, ev.motion.x, ev.motion.y);
+
+ setMousePos(event.mouse.x, event.mouse.y);
+ return true;
+}
+
+bool OSystem_SDL::handleMouseButtonDown(SDL_Event &ev, Common::Event &event) {
+ if (ev.button.button == SDL_BUTTON_LEFT)
+ event.type = Common::EVENT_LBUTTONDOWN;
+ else if (ev.button.button == SDL_BUTTON_RIGHT)
+ event.type = Common::EVENT_RBUTTONDOWN;
+#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
+ else if (ev.button.button == SDL_BUTTON_WHEELUP)
+ event.type = Common::EVENT_WHEELUP;
+ else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
+ event.type = Common::EVENT_WHEELDOWN;
+#endif
+#if defined(SDL_BUTTON_MIDDLE)
+ else if (ev.button.button == SDL_BUTTON_MIDDLE)
+ event.type = Common::EVENT_MBUTTONDOWN;
+#endif
+ else
+ return false;
+
+ fillMouseEvent(event, ev.button.x, ev.button.y);
+
+ return true;
+}
+
+bool OSystem_SDL::handleMouseButtonUp(SDL_Event &ev, Common::Event &event) {
+ if (ev.button.button == SDL_BUTTON_LEFT)
+ event.type = Common::EVENT_LBUTTONUP;
+ else if (ev.button.button == SDL_BUTTON_RIGHT)
+ event.type = Common::EVENT_RBUTTONUP;
+#if defined(SDL_BUTTON_MIDDLE)
+ else if (ev.button.button == SDL_BUTTON_MIDDLE)
+ event.type = Common::EVENT_MBUTTONUP;
+#endif
+ else
+ return false;
+ fillMouseEvent(event, ev.button.x, ev.button.y);
+
+ return true;
+}
+
+bool OSystem_SDL::handleJoyButtonDown(SDL_Event &ev, Common::Event &event) {
+ if (ev.jbutton.button == JOY_BUT_LMOUSE) {
+ event.type = Common::EVENT_LBUTTONDOWN;
+ fillMouseEvent(event, _km.x, _km.y);
+ } else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
+ event.type = Common::EVENT_RBUTTONDOWN;
+ fillMouseEvent(event, _km.x, _km.y);
+ } else {
+ event.type = Common::EVENT_KEYDOWN;
+ switch (ev.jbutton.button) {
+ case JOY_BUT_ESCAPE:
+ event.kbd.keycode = Common::KEYCODE_ESCAPE;
+ event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_PERIOD:
+ event.kbd.keycode = Common::KEYCODE_PERIOD;
+ event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_SPACE:
+ event.kbd.keycode = Common::KEYCODE_SPACE;
+ event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_F5:
+ event.kbd.keycode = Common::KEYCODE_F5;
+ event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+ break;
+ }
+ }
+ return true;
+}
+
+bool OSystem_SDL::handleJoyButtonUp(SDL_Event &ev, Common::Event &event) {
+ if (ev.jbutton.button == JOY_BUT_LMOUSE) {
+ event.type = Common::EVENT_LBUTTONUP;
+ fillMouseEvent(event, _km.x, _km.y);
+ } else if (ev.jbutton.button == JOY_BUT_RMOUSE) {
+ event.type = Common::EVENT_RBUTTONUP;
+ fillMouseEvent(event, _km.x, _km.y);
+ } else {
+ event.type = Common::EVENT_KEYUP;
+ switch (ev.jbutton.button) {
+ case JOY_BUT_ESCAPE:
+ event.kbd.keycode = Common::KEYCODE_ESCAPE;
+ event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_PERIOD:
+ event.kbd.keycode = Common::KEYCODE_PERIOD;
+ event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_SPACE:
+ event.kbd.keycode = Common::KEYCODE_SPACE;
+ event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+ break;
+ case JOY_BUT_F5:
+ event.kbd.keycode = Common::KEYCODE_F5;
+ event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+ break;
+ }
+ }
+ return true;
+}
+
+bool OSystem_SDL::handleJoyAxisMotion(SDL_Event &ev, Common::Event &event) {
+ int axis = ev.jaxis.value;
+ if ( axis > JOY_DEADZONE) {
+ axis -= JOY_DEADZONE;
+ event.type = Common::EVENT_MOUSEMOVE;
+ } else if ( axis < -JOY_DEADZONE ) {
+ axis += JOY_DEADZONE;
+ event.type = Common::EVENT_MOUSEMOVE;
+ } else
+ axis = 0;
+
+ if ( ev.jaxis.axis == JOY_XAXIS) {
+#ifdef JOY_ANALOG
+ _km.x_vel = axis/2000;
+ _km.x_down_count = 0;
+#else
+ if (axis != 0) {
+ _km.x_vel = (axis > 0) ? 1:-1;
+ _km.x_down_count = 1;
+ } else {
+ _km.x_vel = 0;
+ _km.x_down_count = 0;
+ }
+#endif
+
+ } else if (ev.jaxis.axis == JOY_YAXIS) {
+#ifndef JOY_INVERT_Y
+ axis = -axis;
+#endif
+#ifdef JOY_ANALOG
+ _km.y_vel = -axis / 2000;
+ _km.y_down_count = 0;
+#else
+ if (axis != 0) {
+ _km.y_vel = (-axis > 0) ? 1: -1;
+ _km.y_down_count = 1;
+ } else {
+ _km.y_vel = 0;
+ _km.y_down_count = 0;
+ }
+#endif
+ }
+
+ fillMouseEvent(event, _km.x, _km.y);
+
+ return true;
+}
+
+bool OSystem_SDL::remapKey(SDL_Event &ev, Common::Event &event) {
+#ifdef LINUPY
+ // On Yopy map the End button to quit
+ if ((ev.key.keysym.sym == 293)) {
+ event.type = Common::EVENT_QUIT;
+ return true;
+ }
+ // Map menu key to f5 (scumm menu)
+ if (ev.key.keysym.sym == 306) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_F5;
+ event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+ return true;
+ }
+ // Map action key to action
+ if (ev.key.keysym.sym == 291) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_TAB;
+ event.kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
+ return true;
+ }
+ // Map OK key to skip cinematic
+ if (ev.key.keysym.sym == 292) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_ESCAPE;
+ event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
+ return true;
+ }
+#endif
+
+#ifdef QTOPIA
+ // Quit on fn+backspace on zaurus
+ if (ev.key.keysym.sym == 127) {
+ event.type = Common::EVENT_QUIT;
+ return true;
+ }
+
+ // Map menu key (f11) to f5 (scumm menu)
+ if (ev.key.keysym.sym == SDLK_F11) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_F5;
+ event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
+ }
+ // Nap center (space) to tab (default action )
+ // I wanted to map the calendar button but the calendar comes up
+ //
+ else if (ev.key.keysym.sym == SDLK_SPACE) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_TAB;
+ event.kbd.ascii = mapKey(SDLK_TAB, ev.key.keysym.mod, 0);
+ }
+ // Since we stole space (pause) above we'll rebind it to the tab key on the keyboard
+ else if (ev.key.keysym.sym == SDLK_TAB) {
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = Common::KEYCODE_SPACE;
+ event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
+ } else {
+ // Let the events fall through if we didn't change them, this may not be the best way to
+ // set it up, but i'm not sure how sdl would like it if we let if fall through then redid it though.
+ // and yes i have an huge terminal size so i dont wrap soon enough.
+ event.type = Common::EVENT_KEYDOWN;
+ event.kbd.keycode = ev.key.keysym.sym;
+ event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+ }
+#endif
+ return false;
+}
diff --git a/backends/platform/sdl/graphics.cpp b/backends/platform/sdl/graphics.cpp
new file mode 100644
index 0000000000..df63c3a7d6
--- /dev/null
+++ b/backends/platform/sdl/graphics.cpp
@@ -0,0 +1,1946 @@
+/* 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$
+ *
+ */
+
+#include "backends/platform/sdl/sdl.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
+
+const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
+ return s_supportedGraphicsModes;
+}
+
+int OSystem_SDL::getDefaultGraphicsMode() const {
+ return GFX_DOUBLESIZE;
+}
+
+void OSystem_SDL::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 OSystem_SDL::endGFXTransaction() {
+ int errors = kTransactionSuccess;
+
+ assert(_transactionMode != kTransactionNone);
+
+ if (_transactionMode == kTransactionRollback) {
+ if (_videoMode.fullscreen != _oldVideoMode.fullscreen) {
+ errors |= kTransactionFullscreenFailed;
+
+ _videoMode.fullscreen = _oldVideoMode.fullscreen;
+ } else if (_videoMode.aspectRatioCorrection != _oldVideoMode.aspectRatioCorrection) {
+ errors |= kTransactionAspectRatioFailed;
+
+ _videoMode.aspectRatioCorrection = _oldVideoMode.aspectRatioCorrection;
+ } else if (_videoMode.mode != _oldVideoMode.mode) {
+ errors |= kTransactionModeSwitchFailed;
+
+ _videoMode.mode = _oldVideoMode.mode;
+ _videoMode.scaleFactor = _oldVideoMode.scaleFactor;
+#ifdef USE_RGB_COLOR
+ } else if (_videoMode.format != _oldVideoMode.format) {
+ errors |= kTransactionFormatNotSupported;
+
+ _videoMode.format = _oldVideoMode.format;
+ _screenFormat = _videoMode.format;
+#endif
+ } else if (_videoMode.screenWidth != _oldVideoMode.screenWidth || _videoMode.screenHeight != _oldVideoMode.screenHeight) {
+ errors |= 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;
+ _modeChanged = 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;
+ _modeChanged = 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 (TransactionError)errors;
+}
+
+#ifdef USE_RGB_COLOR
+
+Common::List<Graphics::PixelFormat> OSystem_SDL::getSupportedFormats() const {
+ assert(!_supportedFormats.empty());
+ return _supportedFormats;
+}
+
+void OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::getGraphicsMode() const {
+ assert (_transactionMode == kTransactionNone);
+ return _videoMode.mode;
+}
+
+void OSystem_SDL::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 OSystem_SDL::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;
+ //printf("%d %d\n", mode->w, mode->h);
+
+ 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;
+ }
+ //printf("%d %d\n", bestMode->w, bestMode->h);
+ width = bestMode->w;
+ height = bestMode->h;
+}
+
+bool OSystem_SDL::loadGFXMode() {
+ assert(_inited);
+ _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());
+ 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
+
+ // keyboard cursor control, some other better place for it?
+ _km.x_max = _videoMode.screenWidth * _videoMode.scaleFactor - 1;
+ _km.y_max = effectiveScreenHeight() - 1;
+ _km.delay_time = 25;
+ _km.last_time = 0;
+
+ // Distinguish 555 and 565 mode
+ if (_hwscreen->format->Rmask == 0x7C00)
+ InitScalers(555);
+ else
+ InitScalers(565);
+
+ return true;
+}
+
+void OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::updateScreen() {
+ assert (_transactionMode == kTransactionNone);
+
+ Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
+
+ internUpdateScreen();
+}
+
+void OSystem_SDL::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 ||
+ (_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 OSystem_SDL::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 OSystem_SDL::setFullscreenMode(bool enable) {
+ Common::StackLock lock(_graphicsMutex);
+
+ if (_oldVideoMode.setup && _oldVideoMode.fullscreen == enable)
+ return;
+
+ if (_transactionMode == kTransactionActive) {
+ _videoMode.fullscreen = enable;
+ _transactionDetails.needHotswap = true;
+ }
+}
+
+void OSystem_SDL::setAspectRatioCorrection(bool enable) {
+ Common::StackLock lock(_graphicsMutex);
+
+ if (_oldVideoMode.setup && _oldVideoMode.aspectRatioCorrection == enable)
+ return;
+
+ if (_transactionMode == kTransactionActive) {
+ _videoMode.aspectRatioCorrection = enable;
+ _transactionDetails.needHotswap = true;
+ }
+}
+
+void OSystem_SDL::copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h) {
+ assert (_transactionMode == kTransactionNone);
+ assert(src);
+
+ if (_screen == NULL) {
+ warning("OSystem_SDL::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 *OSystem_SDL::lockScreen() {
+ assert (_transactionMode == kTransactionNone);
+
+ // Lock the graphics mutex
+ 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 OSystem_SDL::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
+ unlockMutex(_graphicsMutex);
+}
+
+void OSystem_SDL::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 OSystem_SDL::getHeight() {
+ return _videoMode.screenHeight;
+}
+
+int16 OSystem_SDL::getWidth() {
+ return _videoMode.screenWidth;
+}
+
+void OSystem_SDL::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("OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::setShakePos(int shake_pos) {
+ assert (_transactionMode == kTransactionNone);
+
+ _newShakePos = shake_pos;
+}
+
+
+#pragma mark -
+#pragma mark --- Overlays ---
+#pragma mark -
+
+void OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::showMouse(bool visible) {
+ if (_mouseVisible == visible)
+ return visible;
+
+ bool last = _mouseVisible;
+ _mouseVisible = visible;
+ _mouseNeedsRedraw = true;
+
+ return last;
+}
+
+void OSystem_SDL::setMousePos(int x, int y) {
+ if (x != _mouseCurState.x || y != _mouseCurState.y) {
+ _mouseNeedsRedraw = true;
+ _mouseCurState.x = x;
+ _mouseCurState.y = y;
+ }
+}
+
+void OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::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 OSystem_SDL::toggleMouseGrab() {
+ if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF)
+ SDL_WM_GrabInput(SDL_GRAB_ON);
+ else
+ SDL_WM_GrabInput(SDL_GRAB_OFF);
+}
+
+void OSystem_SDL::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 OSystem_SDL::drawMouse() {
+ if (!_mouseVisible || !_mouseSurface) {
+ _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+ return;
+ }
+
+ SDL_Rect dst;
+ int scale;
+ int hotX, hotY;
+
+ 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);
+}
+
+#pragma mark -
+#pragma mark --- On Screen Display ---
+#pragma mark -
+
+#ifdef USE_OSD
+void OSystem_SDL::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
+
+
+#pragma mark -
+#pragma mark --- Misc ---
+#pragma mark -
+
+bool OSystem_SDL::handleScalerHotkeys(const SDL_KeyboardEvent &key) {
+ // Ctrl-Alt-a toggles aspect ratio correction
+ if (key.keysym.sym == 'a') {
+ beginGFXTransaction();
+ setFeatureState(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;
+
+ // Increase/decrease the scale factor
+ if (key.keysym.sym == SDLK_EQUALS || key.keysym.sym == SDLK_PLUS || key.keysym.sym == SDLK_MINUS ||
+ key.keysym.sym == SDLK_KP_PLUS || key.keysym.sym == SDLK_KP_MINUS) {
+ factor += (key.keysym.sym == SDLK_MINUS || key.keysym.sym == SDLK_KP_MINUS) ? -1 : +1;
+ if (0 <= factor && factor <= 3) {
+ newMode = s_gfxModeSwitchTable[_scalerType][factor];
+ }
+ }
+
+ const bool isNormalNumber = (SDLK_1 <= key.keysym.sym && key.keysym.sym <= SDLK_9);
+ const bool isKeypadNumber = (SDLK_KP1 <= key.keysym.sym && key.keysym.sym <= SDLK_KP9);
+ if (isNormalNumber || isKeypadNumber) {
+ _scalerType = key.keysym.sym - (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 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 OSystem_SDL::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;
+}
diff --git a/backends/platform/sdl/macosx/macosx-main.cpp b/backends/platform/sdl/macosx/macosx-main.cpp
deleted file mode 100644
index 023860b19f..0000000000
--- a/backends/platform/sdl/macosx/macosx-main.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* 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 MACOSX
-
-#include "backends/platform/sdl/macosx/macosx.h"
-#include "backends/plugins/sdl/sdl-provider.h"
-#include "base/main.h"
-
-int main(int argc, char *argv[]) {
-
- // Create our OSystem instance
- g_system = new OSystem_MacOSX();
- assert(g_system);
-
- // Pre initialize the backend
- ((OSystem_MacOSX *)g_system)->init();
-
-#ifdef DYNAMIC_MODULES
- PluginManager::instance().addPluginProvider(new SDLPluginProvider());
-#endif
-
- // Invoke the actual ScummVM main entry point:
- int res = scummvm_main(argc, argv);
-
- // Free OSystem
- delete (OSystem_MacOSX *)g_system;
-
- return res;
-}
-
-#endif
diff --git a/backends/platform/sdl/macosx/macosx.cpp b/backends/platform/sdl/macosx/macosx.cpp
deleted file mode 100644
index a36769b417..0000000000
--- a/backends/platform/sdl/macosx/macosx.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* 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 MACOSX
-
-#include "backends/platform/sdl/macosx/macosx.h"
-#include "backends/mixer/doublebuffersdl/doublebuffersdl-mixer.h"
-
-#include "common/archive.h"
-#include "common/fs.h"
-
-#include "CoreFoundation/CoreFoundation.h"
-
-OSystem_MacOSX::OSystem_MacOSX()
- :
- OSystem_POSIX("Library/Preferences/ScummVM Preferences") {
-}
-
-void OSystem_MacOSX::initBackend() {
- // Create the mixer manager
- if (_mixer == 0) {
- _mixerManager = new DoubleBufferSDLMixerManager();
-
- // Setup and start mixer
- _mixerManager->init();
- }
-
- // Invoke parent implementation of this method
- OSystem_POSIX::initBackend();
-}
-
-void OSystem_MacOSX::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
- // Invoke parent implementation of this method
- OSystem_POSIX::addSysArchivesToSearchSet(s, priority);
-
- // Get URL of the Resource directory of the .app bundle
- CFURLRef fileUrl = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle());
- if (fileUrl) {
- // Try to convert the URL to an absolute path
- UInt8 buf[MAXPATHLEN];
- if (CFURLGetFileSystemRepresentation(fileUrl, true, buf, sizeof(buf))) {
- // Success: Add it to the search path
- Common::String bundlePath((const char *)buf);
- s.add("__OSX_BUNDLE__", new Common::FSDirectory(bundlePath), priority);
- }
- CFRelease(fileUrl);
- }
-}
-
-void OSystem_MacOSX::setupIcon() {
- // Don't set icon on OS X, as we use a nicer external icon there.
-}
-
-#endif
diff --git a/backends/platform/sdl/macosx/macosx.h b/backends/platform/sdl/macosx/macosx.h
deleted file mode 100644
index 3c583a0ac0..0000000000
--- a/backends/platform/sdl/macosx/macosx.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* 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 PLATFORM_SDL_MACOSX_H
-#define PLATFORM_SDL_MACOSX_H
-
-#include "backends/platform/sdl/posix/posix.h"
-
-class OSystem_MacOSX : public OSystem_POSIX {
-public:
- OSystem_MacOSX();
- virtual ~OSystem_MacOSX() {}
-
- virtual void initBackend();
- virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0);
- virtual void setupIcon();
-};
-
-#endif
diff --git a/backends/platform/sdl/main.cpp b/backends/platform/sdl/main.cpp
index 00ec0b8185..a9e1f5cf4b 100644
--- a/backends/platform/sdl/main.cpp
+++ b/backends/platform/sdl/main.cpp
@@ -23,33 +23,50 @@
*
*/
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+// Fix for bug #2895217 "MSVC compilation broken with r47595":
+// We need to keep this on top of the "common/scummsys.h" include,
+// otherwise we will get errors about the windows headers redefining
+// "ARRAYSIZE" for example.
+#if defined(WIN32) && !defined(__SYMBIAN32__)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+// winnt.h defines ARRAYSIZE, but we want our own one...
+#undef ARRAYSIZE
+#endif
+
+#include "common/scummsys.h"
+
// Several SDL based ports use a custom main, and hence do not want to compile
// of this file. The following "#if" ensures that.
-#if !defined(UNIX) && !defined(WIN32) && !defined(__MAEMO__) && !defined(__SYMBIAN32__) && !defined(__amigaos4__) && !defined(DINGUX) && !defined(CAANOO) && !defined(OPENPANDORA)
+#if !defined(__MAEMO__) && !defined(__SYMBIAN32__) && !defined(_WIN32_WCE) && !defined(DINGUX) && !defined(GPH_DEVICE) && !defined(LINUXMOTO) && !defined(OPENPANDORA)
+
#include "backends/platform/sdl/sdl.h"
#include "backends/plugins/sdl/sdl-provider.h"
#include "base/main.h"
+#ifdef WIN32
+int __stdcall WinMain(HINSTANCE /*hInst*/, HINSTANCE /*hPrevInst*/, LPSTR /*lpCmdLine*/, int /*iShowCmd*/) {
+ SDL_SetModuleHandle(GetModuleHandle(NULL));
+ return main(__argc, __argv);
+}
+#endif
+
int main(int argc, char *argv[]) {
// Create our OSystem instance
g_system = new OSystem_SDL();
assert(g_system);
- // Pre initialize the backend
- ((OSystem_SDL *)g_system)->init();
-
#ifdef DYNAMIC_MODULES
PluginManager::instance().addPluginProvider(new SDLPluginProvider());
#endif
// Invoke the actual ScummVM main entry point:
int res = scummvm_main(argc, argv);
-
- // Free OSystem
- delete (OSystem_SDL *)g_system;
-
+ ((OSystem_SDL *)g_system)->deinit();
return res;
}
diff --git a/backends/platform/sdl/module.mk b/backends/platform/sdl/module.mk
index b00bb64718..43751a57b2 100644
--- a/backends/platform/sdl/module.mk
+++ b/backends/platform/sdl/module.mk
@@ -1,31 +1,13 @@
MODULE := backends/platform/sdl
MODULE_OBJS := \
- posix/posix-main.o \
- posix/posix.o \
+ events.o \
+ graphics.o \
hardwarekeys.o \
main.o \
sdl.o
-ifdef MACOSX
-MODULE_OBJS += \
- macosx/macosx-main.o \
- macosx/macosx.o
-endif
-
-ifdef WIN32
-MODULE_OBJS += \
- win32/win32-main.o \
- win32/win32.o
-endif
-
-ifdef AMIGAOS
-MODULE_OBJS += \
- amigaos/amigaos-main.o \
- amigaos/amigaos.o
-endif
-
-# We don't use the rules.mk here on purpose
+# We don't use rules.mk but rather manually update OBJS and MODULE_DIRS.
MODULE_OBJS := $(addprefix $(MODULE)/, $(MODULE_OBJS))
OBJS := $(MODULE_OBJS) $(OBJS)
-MODULE_DIRS += $(sort $(dir $(MODULE_OBJS))) \ No newline at end of file
+MODULE_DIRS += $(sort $(dir $(MODULE_OBJS)))
diff --git a/backends/platform/sdl/posix/posix-main.cpp b/backends/platform/sdl/posix/posix-main.cpp
deleted file mode 100644
index de9eb2b7ef..0000000000
--- a/backends/platform/sdl/posix/posix-main.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/* 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(UNIX) && !defined(MACOSX) && !defined(SAMSUNGTV) && !defined(LINUXMOTO) && !defined(GP2XWIZ) && !defined(GP2X) && !defined(DINGUX)
-
-#include "backends/platform/sdl/posix/posix.h"
-#include "backends/plugins/sdl/sdl-provider.h"
-#include "base/main.h"
-
-int main(int argc, char *argv[]) {
-
- // Create our OSystem instance
- g_system = new OSystem_POSIX();
- assert(g_system);
-
- // Pre initialize the backend
- ((OSystem_POSIX *)g_system)->init();
-
-#ifdef DYNAMIC_MODULES
- PluginManager::instance().addPluginProvider(new SDLPluginProvider());
-#endif
-
- // Invoke the actual ScummVM main entry point:
- int res = scummvm_main(argc, argv);
-
- // Free OSystem
- delete (OSystem_POSIX *)g_system;
-
- return res;
-}
-
-#endif
diff --git a/backends/platform/sdl/posix/posix.cpp b/backends/platform/sdl/posix/posix.cpp
deleted file mode 100644
index c9c7304c0f..0000000000
--- a/backends/platform/sdl/posix/posix.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/* 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 UNIX
-
-#include "backends/platform/sdl/posix/posix.h"
-#include "backends/saves/posix/posix-saves.h"
-#include "backends/fs/posix/posix-fs-factory.h"
-
-OSystem_POSIX::OSystem_POSIX(Common::String baseConfigName)
- :
- _baseConfigName(baseConfigName) {
-}
-
-void OSystem_POSIX::init() {
- // Initialze File System Factory
- _fsFactory = new POSIXFilesystemFactory();
-
- // Invoke parent implementation of this method
- OSystem_SDL::init();
-}
-
-void OSystem_POSIX::initBackend() {
- // Create the savefile manager
- if (_savefileManager == 0)
- _savefileManager = new POSIXSaveFileManager();
-
- // Invoke parent implementation of this method
- OSystem_SDL::initBackend();
-}
-
-Common::String OSystem_POSIX::getDefaultConfigFileName() {
- char configFile[MAXPATHLEN];
-
- // On UNIX type systems, by default we store the config file inside
- // to the HOME directory of the user.
- const char *home = getenv("HOME");
- if (home != NULL && strlen(home) < MAXPATHLEN)
- snprintf(configFile, MAXPATHLEN, "%s/%s", home, _baseConfigName.c_str());
- else
- strcpy(configFile, _baseConfigName.c_str());
-
- return configFile;
-}
-
-#endif
diff --git a/backends/platform/sdl/posix/posix.h b/backends/platform/sdl/posix/posix.h
deleted file mode 100644
index 13f9304f1e..0000000000
--- a/backends/platform/sdl/posix/posix.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/* 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 PLATFORM_SDL_POSIX_H
-#define PLATFORM_SDL_POSIX_H
-
-#include "backends/platform/sdl/sdl.h"
-
-class OSystem_POSIX : public OSystem_SDL {
-public:
- // Let the subclasses be able to change _baseConfigName in the constructor
- OSystem_POSIX(Common::String baseConfigName = ".scummvmrc");
- virtual ~OSystem_POSIX() {}
-
- virtual void init();
- virtual void initBackend();
-
-protected:
- // Base string for creating the default path and filename
- // for the configuration file
- Common::String _baseConfigName;
-
- virtual Common::String getDefaultConfigFileName();
-};
-
-#endif
diff --git a/backends/platform/sdl/sdl.cpp b/backends/platform/sdl/sdl.cpp
index fbfb83fa1d..2e3819f6f5 100644
--- a/backends/platform/sdl/sdl.cpp
+++ b/backends/platform/sdl/sdl.cpp
@@ -23,149 +23,346 @@
*
*/
+// Disable symbol overrides so that we can use system headers.
+#define FORBIDDEN_SYMBOL_ALLOW_ALL
+
+#if defined(WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+// winnt.h defines ARRAYSIZE, but we want our own one... - this is needed before including util.h
+#undef ARRAYSIZE
+#endif
+
#include "backends/platform/sdl/sdl.h"
+#include "common/archive.h"
#include "common/config-manager.h"
+#include "common/debug.h"
#include "common/EventRecorder.h"
+#include "common/util.h"
-#include "backends/saves/default/default-saves.h"
-#include "backends/audiocd/sdl/sdl-audiocd.h"
-#include "backends/events/sdl/sdl-events.h"
-#include "backends/mutex/sdl/sdl-mutex.h"
-#include "backends/timer/sdl/sdl-timer.h"
-#include "backends/graphics/sdl/sdl-graphics.h"
-#ifdef USE_OPENGL
-#include "backends/graphics/openglsdl/openglsdl-graphics.h"
+#ifdef UNIX
+ #include "backends/saves/posix/posix-saves.h"
+#else
+ #include "backends/saves/default/default-saves.h"
#endif
+#include "backends/audiocd/sdl/sdl-audiocd.h"
+#include "backends/timer/default/default-timer.h"
+#include "sound/mixer_intern.h"
#include "icons/scummvm.xpm"
-#include <time.h>
+#include <time.h> // for getTimeAndDate()
-OSystem_SDL::OSystem_SDL()
- :
-#ifdef USE_OPENGL
- _graphicsModes(0),
- _graphicsMode(0),
- _sdlModesCount(0),
- _glModesCount(0),
+//#define SAMPLES_PER_SEC 11025
+#define SAMPLES_PER_SEC 22050
+//#define SAMPLES_PER_SEC 44100
+
+
+/*
+ * Include header files needed for the getFilesystemFactory() method.
+ */
+#if defined(__amigaos4__)
+ #include "backends/fs/amigaos4/amigaos4-fs-factory.h"
+#elif defined(UNIX)
+ #include "backends/fs/posix/posix-fs-factory.h"
+#elif defined(WIN32)
+ #include "backends/fs/windows/windows-fs-factory.h"
+#endif
+
+
+#if defined(UNIX)
+#ifdef MACOSX
+#define DEFAULT_CONFIG_FILE "Library/Preferences/ScummVM Preferences"
+#elif defined(SAMSUNGTV)
+#define DEFAULT_CONFIG_FILE "/dtv/usb/sda1/.scummvmrc"
+#else
+#define DEFAULT_CONFIG_FILE ".scummvmrc"
+#endif
+#else
+#define DEFAULT_CONFIG_FILE "scummvm.ini"
+#endif
+
+#if defined(MACOSX) || defined(IPHONE)
+#include <CoreFoundation/CoreFoundation.h>
#endif
- _inited(false),
- _initedSDL(false),
- _mixerManager(0),
- _eventSource(0) {
+
+static Uint32 timer_handler(Uint32 interval, void *param) {
+ ((DefaultTimerManager *)param)->handler();
+ return interval;
}
-OSystem_SDL::~OSystem_SDL() {
- deinit();
+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;
}
-void OSystem_SDL::init() {
- // Initialize SDL
- initSDL();
+#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) };
- // Creates the early needed managers, if they don't exist yet
- // (we check for this to allow subclasses to provide their own).
- if (_mutexManager == 0)
- _mutexManager = new SdlMutexManager();
+ //TODO : We could parse an arbitrary string, if we code enough proper validation
+ Common::String desiredAspectRatio = ConfMan.get("desired_screen_aspect_ratio");
- if (_timerManager == 0)
- _timerManager = new SdlTimerManager();
+ for (size_t i = 0; i < AR_COUNT; i++) {
+ assert(desiredAspectRatioAsStrings[i] != NULL);
- #ifdef USE_OPENGL
- // Setup a list with both SDL and OpenGL graphics modes
- setupGraphicsModes();
- #endif
+ if (!scumm_stricmp(desiredAspectRatio.c_str(), desiredAspectRatioAsStrings[i])) {
+ return desiredAspectRatios[i];
+ }
+ }
+ // TODO : Report a warning
+ return AspectRatio(0, 0);
}
+#endif
+
+#if defined(WIN32)
+ struct SdlConsoleHidingWin32 {
+ DWORD myPid;
+ DWORD myTid;
+ HWND consoleHandle;
+ };
+
+ // console hiding for win32
+ static BOOL CALLBACK initBackendFindConsoleWin32Proc(HWND hWnd, LPARAM lParam) {
+ DWORD pid, tid;
+ SdlConsoleHidingWin32 *variables = (SdlConsoleHidingWin32 *)lParam;
+ tid = GetWindowThreadProcessId(hWnd, &pid);
+ if ((tid == variables->myTid) && (pid == variables->myPid)) {
+ variables->consoleHandle = hWnd;
+ return FALSE;
+ }
+ return TRUE;
+ }
+#endif
void OSystem_SDL::initBackend() {
- // Check if backend has not been initialized
assert(!_inited);
- // Create the default event source, in case a custom backend
- // manager didn't provide one yet.
- if (_eventSource == 0)
- _eventSource = new SdlEventSource();
-
- int graphicsManagerType = 0;
+ int joystick_num = ConfMan.getInt("joystick_num");
+ uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
- if (_graphicsManager == 0) {
-#ifdef USE_OPENGL
- if (ConfMan.hasKey("gfx_mode")) {
- Common::String gfxMode(ConfMan.get("gfx_mode"));
- bool use_opengl = false;
- const OSystem::GraphicsMode *mode = OpenGLSdlGraphicsManager::supportedGraphicsModes();
- while (mode->name) {
- if (scumm_stricmp(mode->name, gfxMode.c_str()) == 0)
- use_opengl = true;
+ if (ConfMan.hasKey("disable_sdl_parachute"))
+ sdlFlags |= SDL_INIT_NOPARACHUTE;
- mode++;
- }
+#ifdef _WIN32_WCE
+ if (ConfMan.hasKey("use_GDI") && ConfMan.getBool("use_GDI")) {
+ SDL_VideoInit("windib", 0);
+ sdlFlags ^= SDL_INIT_VIDEO;
+ }
+#endif
- // If the gfx_mode is from OpenGL, create the OpenGL graphics manager
- if (use_opengl) {
- _graphicsManager = new OpenGLSdlGraphicsManager();
- graphicsManagerType = 1;
- }
+ if (joystick_num > -1)
+ sdlFlags |= SDL_INIT_JOYSTICK;
+
+#if 0
+ // NEW CODE TO HIDE CONSOLE FOR WIN32
+#if defined(WIN32)
+ // console hiding for win32
+ SdlConsoleHidingWin32 consoleHidingWin32;
+ consoleHidingWin32.consoleHandle = 0;
+ consoleHidingWin32.myPid = GetCurrentProcessId();
+ consoleHidingWin32.myTid = GetCurrentThreadId();
+ EnumWindows (initBackendFindConsoleWin32Proc, (LPARAM)&consoleHidingWin32);
+
+ if (!ConfMan.getBool("show_console")) {
+ if (consoleHidingWin32.consoleHandle) {
+ // We won't find a window with our TID/PID in case we were started from command-line
+ ShowWindow(consoleHidingWin32.consoleHandle, SW_HIDE);
}
+ }
#endif
- if (_graphicsManager == 0) {
- _graphicsManager = new SdlGraphicsManager(_eventSource);
- graphicsManagerType = 0;
- }
+#endif
+
+ if (SDL_Init(sdlFlags) == -1) {
+ error("Could not initialize SDL: %s", SDL_GetError());
}
- // Creates the backend managers, if they don't exist yet (we check
- // for this to allow subclasses to provide their own).
- if (_eventManager == 0)
- _eventManager = new DefaultEventManager(_eventSource);
-
- // We have to initialize the graphics manager before the event manager
- // so the virtual keyboard can be initialized, but we have to add the
- // graphics manager as an event observer after initializing the event
- // manager.
- if (graphicsManagerType == 0)
- ((SdlGraphicsManager *)_graphicsManager)->initEventObserver();
-#ifdef USE_OPENGL
- else if (graphicsManagerType == 1)
- ((OpenGLSdlGraphicsManager *)_graphicsManager)->initEventObserver();
-#endif
+ _graphicsMutex = createMutex();
- if (_savefileManager == 0)
- _savefileManager = new DefaultSaveFileManager();
+ SDL_ShowCursor(SDL_DISABLE);
- if (_mixerManager == 0) {
- _mixerManager = new SdlMixerManager();
+ // Enable unicode support if possible
+ SDL_EnableUNICODE(1);
- // Setup and start mixer
- _mixerManager->init();
- }
+ memset(&_oldVideoMode, 0, sizeof(_oldVideoMode));
+ memset(&_videoMode, 0, sizeof(_videoMode));
+ memset(&_transactionDetails, 0, sizeof(_transactionDetails));
- if (_audiocdManager == 0)
- _audiocdManager = new SdlAudioCDManager();
+#if !defined(_WIN32_WCE) && !defined(DINGUX) && !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
+
+#if !defined(MACOSX) && !defined(__SYMBIAN32__)
// Setup a custom program icon.
+ // Don't set icon on OS X, as we use a nicer external icon there.
+ // Don't for Symbian: it uses the EScummVM.aif file for the icon.
setupIcon();
+#endif
+
+ // enable joystick
+ if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
+ printf("Using joystick: %s\n", SDL_JoystickName(0));
+ _joystick = SDL_JoystickOpen(joystick_num);
+ }
+
+
+ // Create the savefile manager, if none exists yet (we check for this to
+ // allow subclasses to provide their own).
+ if (_savefile == 0) {
+#ifdef UNIX
+ _savefile = new POSIXSaveFileManager();
+#else
+ _savefile = new DefaultSaveFileManager();
+#endif
+ }
+
+ // Create and hook up the mixer, if none exists yet (we check for this to
+ // allow subclasses to provide their own).
+ if (_mixer == 0) {
+ setupMixer();
+ }
+
+ // Create and hook up the timer manager, if none exists yet (we check for
+ // this to allow subclasses to provide their own).
+ if (_timer == 0) {
+ // Note: We could implement a custom SDLTimerManager by using
+ // SDL_AddTimer. That might yield better timer resolution, but it would
+ // also change the semantics of a timer: Right now, ScummVM timers
+ // *never* run in parallel, due to the way they are implemented. If we
+ // switched to SDL_AddTimer, each timer might run in a separate thread.
+ // However, not all our code is prepared for that, so we can't just
+ // switch. Still, it's a potential future change to keep in mind.
+ _timer = new DefaultTimerManager();
+ _timerID = SDL_AddTimer(10, &timer_handler, _timer);
+ }
+
+ // Invoke parent implementation of this method
+ OSystem::initBackend();
_inited = true;
}
-void OSystem_SDL::initSDL() {
- // Check if SDL has not been initialized
- if (!_initedSDL) {
- uint32 sdlFlags = 0;
- if (ConfMan.hasKey("disable_sdl_parachute"))
- sdlFlags |= SDL_INIT_NOPARACHUTE;
+OSystem_SDL::OSystem_SDL()
+ :
+#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),
+ _cdrom(0), _scalerProc(0), _modeChanged(false), _screenChangeCount(0),
+ _scrollLock(false),
+ _mouseVisible(false), _mouseNeedsRedraw(false), _mouseData(0), _mouseSurface(0),
+ _mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true),
+ _joystick(0),
+ _currentShakePos(0), _newShakePos(0),
+ _paletteDirtyStart(0), _paletteDirtyEnd(0),
+#if MIXER_DOUBLE_BUFFERING
+ _soundMutex(0), _soundCond(0), _soundThread(0),
+ _soundThreadIsRunning(false), _soundThreadShouldQuit(false),
+#endif
+ _fsFactory(0),
+ _savefile(0),
+ _mixer(0),
+ _timer(0),
+ _screenIsLocked(false),
+ _graphicsMutex(0), _transactionMode(kTransactionNone) {
+
+ // clear palette storage
+ memset(_currentPalette, 0, sizeof(_currentPalette));
+ memset(_cursorPalette, 0, sizeof(_cursorPalette));
+
+ _mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
+
+ // reset mouse state
+ memset(&_km, 0, sizeof(_km));
+ memset(&_mouseCurState, 0, sizeof(_mouseCurState));
+
+ _inited = false;
+
+
+ #if defined(__amigaos4__)
+ _fsFactory = new AmigaOSFilesystemFactory();
+ #elif defined(UNIX)
+ _fsFactory = new POSIXFilesystemFactory();
+ #elif defined(WIN32)
+ _fsFactory = new WindowsFilesystemFactory();
+ #elif defined(__SYMBIAN32__)
+ // Do nothing since its handled by the Symbian SDL inheritance
+ #else
+ #error Unknown and unsupported FS backend
+ #endif
+}
+
+OSystem_SDL::~OSystem_SDL() {
+ SDL_RemoveTimer(_timerID);
+ closeMixer();
- // Initialize SDL (SDL Subsystems are initiliazed in the corresponding sdl managers)
- if (SDL_Init(sdlFlags) == -1)
- error("Could not initialize SDL: %s", SDL_GetError());
+ free(_mouseData);
- // Enable unicode support if possible
- SDL_EnableUNICODE(1);
+ delete _savefile;
+ delete _timer;
+}
- _initedSDL = true;
- }
+uint32 OSystem_SDL::getMillis() {
+ uint32 millis = SDL_GetTicks();
+ g_eventRec.processMillis(millis);
+ return millis;
+}
+
+void OSystem_SDL::delayMillis(uint msecs) {
+ SDL_Delay(msecs);
+}
+
+void OSystem_SDL::getTimeAndDate(TimeDate &td) const {
+ time_t curTime = time(0);
+ struct tm t = *localtime(&curTime);
+ td.tm_sec = t.tm_sec;
+ td.tm_min = t.tm_min;
+ td.tm_hour = t.tm_hour;
+ td.tm_mday = t.tm_mday;
+ td.tm_mon = t.tm_mon;
+ td.tm_year = t.tm_year;
+}
+
+Common::TimerManager *OSystem_SDL::getTimerManager() {
+ assert(_timer);
+ return _timer;
+}
+
+Common::SaveFileManager *OSystem_SDL::getSavefileManager() {
+ assert(_savefile);
+ return _savefile;
+}
+
+FilesystemFactory *OSystem_SDL::getFilesystemFactory() {
+ assert(_fsFactory);
+ return _fsFactory;
}
void OSystem_SDL::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
@@ -179,10 +376,88 @@ void OSystem_SDL::addSysArchivesToSearchSet(Common::SearchSet &s, int priority)
}
#endif
+#ifdef MACOSX
+ // Get URL of the Resource directory of the .app bundle
+ CFURLRef fileUrl = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle());
+ if (fileUrl) {
+ // Try to convert the URL to an absolute path
+ UInt8 buf[MAXPATHLEN];
+ if (CFURLGetFileSystemRepresentation(fileUrl, true, buf, sizeof(buf))) {
+ // Success: Add it to the search path
+ Common::String bundlePath((const char *)buf);
+ s.add("__OSX_BUNDLE__", new Common::FSDirectory(bundlePath), priority);
+ }
+ CFRelease(fileUrl);
+ }
+
+#endif
+
}
-Common::String OSystem_SDL::getDefaultConfigFileName() {
- return "scummvm.ini";
+
+static Common::String getDefaultConfigFileName() {
+ char configFile[MAXPATHLEN];
+#if defined (WIN32) && !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
+ OSVERSIONINFO win32OsVersion;
+ ZeroMemory(&win32OsVersion, sizeof(OSVERSIONINFO));
+ win32OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+ GetVersionEx(&win32OsVersion);
+ // Check for non-9X version of Windows.
+ if (win32OsVersion.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS) {
+ // Use the Application Data directory of the user profile.
+ if (win32OsVersion.dwMajorVersion >= 5) {
+ if (!GetEnvironmentVariable("APPDATA", configFile, sizeof(configFile)))
+ error("Unable to access application data directory");
+ } else {
+ if (!GetEnvironmentVariable("USERPROFILE", configFile, sizeof(configFile)))
+ error("Unable to access user profile directory");
+
+ strcat(configFile, "\\Application Data");
+ CreateDirectory(configFile, NULL);
+ }
+
+ strcat(configFile, "\\ScummVM");
+ CreateDirectory(configFile, NULL);
+ strcat(configFile, "\\" DEFAULT_CONFIG_FILE);
+
+ FILE *tmp = NULL;
+ if ((tmp = fopen(configFile, "r")) == NULL) {
+ // Check windows directory
+ char oldConfigFile[MAXPATHLEN];
+ GetWindowsDirectory(oldConfigFile, MAXPATHLEN);
+ strcat(oldConfigFile, "\\" DEFAULT_CONFIG_FILE);
+ if ((tmp = fopen(oldConfigFile, "r"))) {
+ strcpy(configFile, oldConfigFile);
+
+ fclose(tmp);
+ }
+ } else {
+ fclose(tmp);
+ }
+ } else {
+ // Check windows directory
+ GetWindowsDirectory(configFile, MAXPATHLEN);
+ strcat(configFile, "\\" DEFAULT_CONFIG_FILE);
+ }
+#elif defined(UNIX)
+ // On UNIX type systems, by default we store the config file inside
+ // to the HOME directory of the user.
+ //
+ // GP2X is Linux based but Home dir can be read only so do not use
+ // it and put the config in the executable dir.
+ //
+ // On the iPhone, the home dir of the user when you launch the app
+ // from the Springboard, is /. Which we don't want.
+ const char *home = getenv("HOME");
+ if (home != NULL && strlen(home) < MAXPATHLEN)
+ snprintf(configFile, MAXPATHLEN, "%s/%s", home, DEFAULT_CONFIG_FILE);
+ else
+ strcpy(configFile, DEFAULT_CONFIG_FILE);
+#else
+ strcpy(configFile, DEFAULT_CONFIG_FILE);
+#endif
+
+ return configFile;
}
Common::SeekableReadStream *OSystem_SDL::createConfigReadStream() {
@@ -213,36 +488,78 @@ void OSystem_SDL::setWindowCaption(const char *caption) {
SDL_WM_SetCaption(cap.c_str(), cap.c_str());
}
+bool OSystem_SDL::hasFeature(Feature f) {
+ return
+ (f == kFeatureFullscreenMode) ||
+ (f == kFeatureAspectRatioCorrection) ||
+ (f == kFeatureCursorHasPalette) ||
+ (f == kFeatureIconifyWindow);
+}
+
+void OSystem_SDL::setFeatureState(Feature f, bool enable) {
+ switch (f) {
+ case kFeatureFullscreenMode:
+ setFullscreenMode(enable);
+ break;
+ case kFeatureAspectRatioCorrection:
+ setAspectRatioCorrection(enable);
+ break;
+ case kFeatureIconifyWindow:
+ if (enable)
+ SDL_WM_IconifyWindow();
+ break;
+ default:
+ break;
+ }
+}
+
+bool OSystem_SDL::getFeatureState(Feature f) {
+ assert (_transactionMode == kTransactionNone);
+
+ switch (f) {
+ case kFeatureFullscreenMode:
+ return _videoMode.fullscreen;
+ case kFeatureAspectRatioCorrection:
+ return _videoMode.aspectRatioCorrection;
+ default:
+ return false;
+ }
+}
+
void OSystem_SDL::deinit() {
+ if (_cdrom) {
+ SDL_CDStop(_cdrom);
+ SDL_CDClose(_cdrom);
+ }
+ unloadGFXMode();
+ deleteMutex(_graphicsMutex);
+
+ if (_joystick)
+ SDL_JoystickClose(_joystick);
+
SDL_ShowCursor(SDL_ENABLE);
- delete _savefileManager;
- _savefileManager = 0;
- delete _graphicsManager;
- _graphicsManager = 0;
- delete _eventManager;
- _eventManager = 0;
- delete _eventSource;
- _eventSource = 0;
- delete _audiocdManager;
- _audiocdManager = 0;
- delete _mixerManager;
- _mixerManager = 0;
- delete _timerManager;
- _timerManager = 0;
- delete _mutexManager;
- _mutexManager = 0;
-
-#ifdef USE_OPENGL
- delete[] _graphicsModes;
-#endif
+ SDL_RemoveTimer(_timerID);
+ closeMixer();
+
+ free(_mouseData);
+
+ delete _timer;
SDL_Quit();
+
+ // Event Manager requires save manager for storing
+ // recorded events
+ delete getEventManager();
+ delete _savefile;
}
void OSystem_SDL::quit() {
deinit();
+
+#if !defined(SAMSUNGTV)
exit(0);
+#endif
}
void OSystem_SDL::setupIcon() {
@@ -297,128 +614,209 @@ void OSystem_SDL::setupIcon() {
free(icon);
}
-uint32 OSystem_SDL::getMillis() {
- uint32 millis = SDL_GetTicks();
- g_eventRec.processMillis(millis);
- return millis;
+OSystem::MutexRef OSystem_SDL::createMutex() {
+ return (MutexRef) SDL_CreateMutex();
}
-void OSystem_SDL::delayMillis(uint msecs) {
- SDL_Delay(msecs);
+void OSystem_SDL::lockMutex(MutexRef mutex) {
+ SDL_mutexP((SDL_mutex *) mutex);
}
-void OSystem_SDL::getTimeAndDate(TimeDate &td) const {
- time_t curTime = time(0);
- struct tm t = *localtime(&curTime);
- td.tm_sec = t.tm_sec;
- td.tm_min = t.tm_min;
- td.tm_hour = t.tm_hour;
- td.tm_mday = t.tm_mday;
- td.tm_mon = t.tm_mon;
- td.tm_year = t.tm_year;
+void OSystem_SDL::unlockMutex(MutexRef mutex) {
+ SDL_mutexV((SDL_mutex *) mutex);
}
-Audio::Mixer *OSystem_SDL::getMixer() {
- assert(_mixerManager);
- return _mixerManager->getMixer();
+void OSystem_SDL::deleteMutex(MutexRef mutex) {
+ SDL_DestroyMutex((SDL_mutex *) mutex);
}
-SdlMixerManager *OSystem_SDL::getMixerManager() {
- assert(_mixerManager);
- return _mixerManager;
-}
+#pragma mark -
+#pragma mark --- Audio ---
+#pragma mark -
-#ifdef USE_OPENGL
+#if MIXER_DOUBLE_BUFFERING
-const OSystem::GraphicsMode *OSystem_SDL::getSupportedGraphicsModes() const {
- return _graphicsModes;
-}
+void OSystem_SDL::mixerProducerThread() {
+ byte nextSoundBuffer;
-int OSystem_SDL::getDefaultGraphicsMode() const {
- // Return the default graphics mode from the current graphics manager
- if (_graphicsMode < _sdlModesCount)
- return _graphicsManager->getDefaultGraphicsMode();
- else
- return _graphicsManager->getDefaultGraphicsMode() + _sdlModesCount;
-}
+ SDL_LockMutex(_soundMutex);
+ while (true) {
+ // Wait till we are allowed to produce data
+ SDL_CondWait(_soundCond, _soundMutex);
-bool OSystem_SDL::setGraphicsMode(int mode) {
- const OSystem::GraphicsMode *srcMode;
- int i;
- // Check if mode is from SDL or OpenGL
- if (mode < _sdlModesCount) {
- srcMode = SdlGraphicsManager::supportedGraphicsModes();
- i = 0;
- } else {
- srcMode = OpenGLSdlGraphicsManager::supportedGraphicsModes();
- i = _sdlModesCount;
- }
- // Loop through modes
- while (srcMode->name) {
- if (i == mode) {
- // If the new mode and the current mode are not from the same graphics
- // manager, delete and create the new mode graphics manager
- if (_graphicsMode >= _sdlModesCount && mode < _sdlModesCount) {
- delete _graphicsManager;
- _graphicsManager = new SdlGraphicsManager(_eventSource);
- ((SdlGraphicsManager *)_graphicsManager)->initEventObserver();
- _graphicsManager->beginGFXTransaction();
- } else if (_graphicsMode < _sdlModesCount && mode >= _sdlModesCount) {
- delete _graphicsManager;
- _graphicsManager = new OpenGLSdlGraphicsManager();
- ((OpenGLSdlGraphicsManager *)_graphicsManager)->initEventObserver();
- _graphicsManager->beginGFXTransaction();
- }
- _graphicsMode = mode;
- return _graphicsManager->setGraphicsMode(srcMode->id);
- }
- i++;
- srcMode++;
+ if (_soundThreadShouldQuit)
+ break;
+
+ // Generate samples and put them into the next buffer
+ nextSoundBuffer = _activeSoundBuf ^ 1;
+ _mixer->mixCallback(_soundBuffers[nextSoundBuffer], _soundBufSize);
+
+ // Swap buffers
+ _activeSoundBuf = nextSoundBuffer;
}
- return false;
+ SDL_UnlockMutex(_soundMutex);
}
-int OSystem_SDL::getGraphicsMode() const {
- return _graphicsMode;
+int SDLCALL OSystem_SDL::mixerProducerThreadEntry(void *arg) {
+ OSystem_SDL *this_ = (OSystem_SDL *)arg;
+ assert(this_);
+ this_->mixerProducerThread();
+ return 0;
}
-void OSystem_SDL::setupGraphicsModes() {
- const OSystem::GraphicsMode *sdlGraphicsModes = SdlGraphicsManager::supportedGraphicsModes();
- const OSystem::GraphicsMode *openglGraphicsModes = OpenGLSdlGraphicsManager::supportedGraphicsModes();
- _sdlModesCount = 0;
- _glModesCount = 0;
- // Count the number of graphics modes
- const OSystem::GraphicsMode *srcMode = sdlGraphicsModes;
- while (srcMode->name) {
- _sdlModesCount++;
- srcMode++;
- }
- srcMode = openglGraphicsModes;
- while (srcMode->name) {
- _glModesCount++;
- srcMode++;
+void OSystem_SDL::initThreadedMixer(Audio::MixerImpl *mixer, uint bufSize) {
+ _soundThreadIsRunning = false;
+ _soundThreadShouldQuit = false;
+
+ // Create mutex and condition variable
+ _soundMutex = SDL_CreateMutex();
+ _soundCond = SDL_CreateCond();
+
+ // Create two sound buffers
+ _activeSoundBuf = 0;
+ _soundBufSize = bufSize;
+ _soundBuffers[0] = (byte *)calloc(1, bufSize);
+ _soundBuffers[1] = (byte *)calloc(1, bufSize);
+
+ _soundThreadIsRunning = true;
+
+ // Finally start the thread
+ _soundThread = SDL_CreateThread(mixerProducerThreadEntry, this);
+}
+
+void OSystem_SDL::deinitThreadedMixer() {
+ // Kill thread?? _soundThread
+
+ if (_soundThreadIsRunning) {
+ // Signal the producer thread to end, and wait for it to actually finish.
+ _soundThreadShouldQuit = true;
+ SDL_CondBroadcast(_soundCond);
+ SDL_WaitThread(_soundThread, NULL);
+
+ // Kill the mutex & cond variables.
+ // Attention: AT this point, the mixer callback must not be running
+ // anymore, else we will crash!
+ SDL_DestroyMutex(_soundMutex);
+ SDL_DestroyCond(_soundCond);
+
+ _soundThreadIsRunning = false;
+
+ free(_soundBuffers[0]);
+ free(_soundBuffers[1]);
}
+}
+
- // Allocate enough space for merged array of modes
- _graphicsModes = new OSystem::GraphicsMode[_glModesCount + _sdlModesCount + 1];
+void OSystem_SDL::mixCallback(void *arg, byte *samples, int len) {
+ OSystem_SDL *this_ = (OSystem_SDL *)arg;
+ assert(this_);
+ assert(this_->_mixer);
- // Copy SDL graphics modes
- memcpy((void *)_graphicsModes, sdlGraphicsModes, _sdlModesCount * sizeof(OSystem::GraphicsMode));
+ assert((int)this_->_soundBufSize == len);
- // Copy OpenGL graphics modes
- memcpy((void *)(_graphicsModes + _sdlModesCount), openglGraphicsModes, _glModesCount * sizeof(OSystem::GraphicsMode));
+ // Lock mutex, to ensure our data is not overwritten by the producer thread
+ SDL_LockMutex(this_->_soundMutex);
- // Set a null mode at the end
- memset((void *)(_graphicsModes + _sdlModesCount + _glModesCount), 0, sizeof(OSystem::GraphicsMode));
+ // Copy data from the current sound buffer
+ memcpy(samples, this_->_soundBuffers[this_->_activeSoundBuf], len);
- // Set new internal ids for all modes
- int i = 0;
- OSystem::GraphicsMode *mode = _graphicsModes;
- while (mode->name) {
- mode->id = i++;
- mode++;
+ // Unlock mutex and wake up the produced thread
+ SDL_UnlockMutex(this_->_soundMutex);
+ SDL_CondSignal(this_->_soundCond);
+}
+
+#else
+
+void OSystem_SDL::mixCallback(void *sys, byte *samples, int len) {
+ OSystem_SDL *this_ = (OSystem_SDL *)sys;
+ assert(this_);
+ assert(this_->_mixer);
+
+ this_->_mixer->mixCallback(samples, len);
+}
+
+#endif
+
+void OSystem_SDL::setupMixer() {
+ SDL_AudioSpec desired;
+
+ // Determine the desired output sampling frequency.
+ uint32 samplesPerSec = 0;
+ if (ConfMan.hasKey("output_rate"))
+ samplesPerSec = ConfMan.getInt("output_rate");
+ if (samplesPerSec <= 0)
+ samplesPerSec = SAMPLES_PER_SEC;
+
+ // Determine the sample buffer size. We want it to store enough data for
+ // at least 1/16th of a second (though at most 8192 samples). Note
+ // that it must be a power of two. So e.g. at 22050 Hz, we request a
+ // sample buffer size of 2048.
+ uint32 samples = 8192;
+ while (samples * 16 > samplesPerSec * 2)
+ samples >>= 1;
+
+ memset(&desired, 0, sizeof(desired));
+ desired.freq = samplesPerSec;
+ desired.format = AUDIO_S16SYS;
+ desired.channels = 2;
+ desired.samples = (uint16)samples;
+ desired.callback = mixCallback;
+ desired.userdata = this;
+
+ assert(!_mixer);
+ if (SDL_OpenAudio(&desired, &_obtainedRate) != 0) {
+ warning("Could not open audio device: %s", SDL_GetError());
+ _mixer = new Audio::MixerImpl(this, samplesPerSec);
+ assert(_mixer);
+ _mixer->setReady(false);
+ } else {
+ // Note: This should be the obtained output rate, but it seems that at
+ // least on some platforms SDL will lie and claim it did get the rate
+ // even if it didn't. Probably only happens for "weird" rates, though.
+ samplesPerSec = _obtainedRate.freq;
+ debug(1, "Output sample rate: %d Hz", samplesPerSec);
+
+ // Create the mixer instance and start the sound processing
+ _mixer = new Audio::MixerImpl(this, samplesPerSec);
+ assert(_mixer);
+ _mixer->setReady(true);
+
+#if MIXER_DOUBLE_BUFFERING
+ initThreadedMixer(_mixer, _obtainedRate.samples * 4);
+#endif
+
+ // start the sound system
+ SDL_PauseAudio(0);
}
}
+void OSystem_SDL::closeMixer() {
+ if (_mixer)
+ _mixer->setReady(false);
+
+ SDL_CloseAudio();
+
+ delete _mixer;
+ _mixer = 0;
+
+#if MIXER_DOUBLE_BUFFERING
+ deinitThreadedMixer();
#endif
+
+}
+
+Audio::Mixer *OSystem_SDL::getMixer() {
+ assert(_mixer);
+ return _mixer;
+}
+
+#pragma mark -
+#pragma mark --- CD Audio ---
+#pragma mark -
+
+AudioCDManager *OSystem_SDL::getAudioCDManager() {
+ if (!_audiocdManager)
+ _audiocdManager = new SdlAudioCDManager();
+ return _audiocdManager;
+}
diff --git a/backends/platform/sdl/sdl.h b/backends/platform/sdl/sdl.h
index 5b1ce8f803..b701824517 100644
--- a/backends/platform/sdl/sdl.h
+++ b/backends/platform/sdl/sdl.h
@@ -23,8 +23,8 @@
*
*/
-#ifndef PLATFORM_SDL_H
-#define PLATFORM_SDL_H
+#ifndef SDL_COMMON_H
+#define SDL_COMMON_H
#if defined(__SYMBIAN32__)
#include <esdl\SDL.h>
@@ -32,99 +32,451 @@
#include <SDL.h>
#endif
-#include "backends/modular-backend.h"
-#include "backends/mixer/sdl/sdl-mixer.h"
-#include "backends/events/sdl/sdl-events.h"
+#include "backends/base-backend.h"
+#include "graphics/scaler.h"
-/**
- * Base OSystem class for all SDL ports.
- */
-class OSystem_SDL : public ModularBackend {
+
+namespace Audio {
+ class MixerImpl;
+}
+
+#if !defined(_WIN32_WCE) && !defined(__SYMBIAN32__)
+// Uncomment this to enable the 'on screen display' code.
+#define USE_OSD 1
+#endif
+
+#if defined(MACOSX)
+// On Mac OS X, we need to double buffer the audio buffer, else anything
+// which produces sampled data with high latency (like the MT-32 emulator)
+// will sound terribly.
+// This could be enabled for more / most ports in the future, but needs some
+// testing.
+#define MIXER_DOUBLE_BUFFERING 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; }
+};
+
+
+class OSystem_SDL : public BaseBackend {
public:
OSystem_SDL();
virtual ~OSystem_SDL();
- /**
- * Pre-initialize backend. It should be called after
- * instantiating the backend. Early needed managers are
- * created here.
- */
- virtual void init();
+ virtual void initBackend();
- /**
- * Get the Mixer Manager instance. Not to confuse with getMixer(),
- * that returns Audio::Mixer. The Mixer Manager is a SDL wrapper class
- * for the Audio::Mixer. Used by other managers.
- */
- virtual SdlMixerManager *getMixerManager();
+ void beginGFXTransaction();
+ TransactionError endGFXTransaction();
- // Override functions from ModularBackend and OSystem
- virtual void initBackend();
+#ifdef USE_RGB_COLOR
+ // Game screen
+ virtual Graphics::PixelFormat getScreenFormat() const { return _screenFormat; }
+
+ // Highest supported
+ virtual Common::List<Graphics::PixelFormat> getSupportedFormats() const;
+#endif
+
+ // Set the size and format of the video bitmap.
+ // Typically, 320x200 CLUT8
+ virtual void initSize(uint w, uint h, const Graphics::PixelFormat *format); // overloaded by CE backend
+
+ virtual int getScreenChangeID() const { return _screenChangeCount; }
+
+ // Set colors of the palette
+ void setPalette(const byte *colors, uint start, uint num);
+
+ // Get colors of the palette
+ void grabPalette(byte *colors, uint start, uint num);
+
+ // Draw a bitmap to screen.
+ // The screen will not be updated to reflect the new bitmap
+ virtual void copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h); // overloaded by CE backend (FIXME)
+
+ virtual Graphics::Surface *lockScreen();
+ virtual void unlockScreen();
+
+ // Update the dirty areas of the screen
+ void updateScreen();
+
+ // Either show or hide the mouse cursor
+ bool showMouse(bool visible);
+
+ // Warp the mouse cursor. Where set_mouse_pos() only informs the
+ // backend of the mouse cursor's current position, this function
+ // actually moves the cursor to the specified position.
+ virtual void warpMouse(int x, int y); // overloaded by CE backend (FIXME)
+
+ // Set the bitmap that's used when drawing the cursor.
+ virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format); // overloaded by CE backend (FIXME)
+
+ // Set colors of cursor palette
+ void setCursorPalette(const byte *colors, uint start, uint num);
+
+ // Disables or enables cursor palette
+ void disableCursorPalette(bool disable) {
+ _cursorPaletteDisabled = disable;
+ blitCursor();
+ }
+
+ // Shaking is used in SCUMM. Set current shake position.
+ void setShakePos(int shake_pos);
+
+ // Get the number of milliseconds since the program was started.
+ uint32 getMillis();
+
+ // Delay for a specified amount of milliseconds
+ void delayMillis(uint msecs);
+
+ // Get the next event.
+ // Returns true if an event was retrieved.
+ virtual bool pollEvent(Common::Event &event); // overloaded by CE backend
+
+protected:
+ virtual bool dispatchSDLEvent(SDL_Event &ev, Common::Event &event);
+
+ // Handlers for specific SDL events, called by pollEvent.
+ // This way, if a backend inherits fromt the SDL backend, it can
+ // change the behavior of only a single event, without having to override all
+ // of pollEvent.
+ virtual bool handleKeyDown(SDL_Event &ev, Common::Event &event);
+ virtual bool handleKeyUp(SDL_Event &ev, Common::Event &event);
+ virtual bool handleMouseMotion(SDL_Event &ev, Common::Event &event);
+ virtual bool handleMouseButtonDown(SDL_Event &ev, Common::Event &event);
+ virtual bool handleMouseButtonUp(SDL_Event &ev, Common::Event &event);
+ virtual bool handleJoyButtonDown(SDL_Event &ev, Common::Event &event);
+ virtual bool handleJoyButtonUp(SDL_Event &ev, Common::Event &event);
+ virtual bool handleJoyAxisMotion(SDL_Event &ev, Common::Event &event);
+
+public:
+
+
+ // Define all hardware keys for keymapper
virtual Common::HardwareKeySet *getHardwareKeySet();
- virtual void quit();
- virtual void deinit();
+
+ // Set function that generates samples
+ virtual void setupMixer();
+ static void mixCallback(void *s, byte *samples, int len);
+
+ virtual void closeMixer();
+
+ virtual Audio::Mixer *getMixer();
+
+ virtual AudioCDManager *getAudioCDManager();
+
+ // Quit
+ virtual void quit(); // overloaded by CE backend
+
+ void deinit();
+
+ virtual void getTimeAndDate(TimeDate &t) const;
+ virtual Common::TimerManager *getTimerManager();
+
+ // Mutex handling
+ MutexRef createMutex();
+ void lockMutex(MutexRef mutex);
+ void unlockMutex(MutexRef mutex);
+ void deleteMutex(MutexRef mutex);
+
+ // Overlay
+ virtual Graphics::PixelFormat getOverlayFormat() const { return _overlayFormat; }
+
+ virtual void showOverlay();
+ virtual void hideOverlay();
+ 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 getHeight();
+ virtual int16 getWidth();
+ virtual int16 getOverlayHeight() { return _videoMode.overlayHeight; }
+ virtual int16 getOverlayWidth() { return _videoMode.overlayWidth; }
+
+ virtual const GraphicsMode *getSupportedGraphicsModes() const;
+ virtual int getDefaultGraphicsMode() const;
+ virtual bool setGraphicsMode(int mode);
+ virtual int getGraphicsMode() const;
+
virtual void setWindowCaption(const char *caption);
+
+ virtual bool hasFeature(Feature f);
+ virtual void setFeatureState(Feature f, bool enable);
+ virtual bool getFeatureState(Feature f);
+ virtual void preprocessEvents(SDL_Event *event) {}
+
+#ifdef USE_OSD
+ void displayMessageOnOSD(const char *msg);
+#endif
+
+ virtual Common::SaveFileManager *getSavefileManager();
+ virtual FilesystemFactory *getFilesystemFactory();
virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0);
+
virtual Common::SeekableReadStream *createConfigReadStream();
virtual Common::WriteStream *createConfigWriteStream();
- virtual uint32 getMillis();
- virtual void delayMillis(uint msecs);
- virtual void getTimeAndDate(TimeDate &td) const;
- virtual Audio::Mixer *getMixer();
-
- // HACK: Special SDL events types
- enum SdlEvent {
- kSdlEventExpose = 100,
- kSdlEventResize = 101
- };
protected:
bool _inited;
- bool _initedSDL;
+ SDL_AudioSpec _obtainedRate;
- /**
- * Mixer manager that configures and setups SDL for
- * the wrapped Audio::Mixer, the true mixer.
- */
- SdlMixerManager *_mixerManager;
+#ifdef USE_OSD
+ SDL_Surface *_osdSurface;
+ Uint8 _osdAlpha; // Transparency level of the OSD
+ uint32 _osdFadeStartTime; // When to start the fade out
+ 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,
+ kOSDInitialAlpha = 80 // Initial alpha level, in percent
+ };
+#endif
- /**
- * The event source we use for obtaining SDL events.
- */
- SdlEventSource *_eventSource;
+ // hardware screen
+ SDL_Surface *_hwscreen;
- /**
- * Initialze the SDL library.
- */
- virtual void initSDL();
+ // unseen game screen
+ SDL_Surface *_screen;
+#ifdef USE_RGB_COLOR
+ Graphics::PixelFormat _screenFormat;
+ Graphics::PixelFormat _cursorFormat;
+ Common::List<Graphics::PixelFormat> _supportedFormats;
/**
- * Setup the window icon.
+ * Update the list of supported pixel formats.
+ * This method is invoked by loadGFXMode().
*/
- virtual void setupIcon();
+ void detectSupportedFormats();
+#endif
- /**
- * Get the file path where the user configuration
- * of ScummVM will be saved.
- */
- virtual Common::String getDefaultConfigFileName();
+ // temporary screen (for scalers)
+ SDL_Surface *_tmpscreen;
+ SDL_Surface *_tmpscreen2;
+
+ // overlay
+ SDL_Surface *_overlayscreen;
+ bool _overlayVisible;
+ Graphics::PixelFormat _overlayFormat;
+
+ // CD Audio
+ SDL_CD *_cdrom;
+ int _cdTrack, _cdNumLoops, _cdStartFrame, _cdDuration;
+ uint32 _cdEndTime, _cdStopTime;
+
+ 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;
+
+ virtual void setGraphicsModeIntern(); // overloaded by CE backend
+
+ /** Force full redraw on next updateScreen */
+ bool _forceFull;
+ ScalerProc *_scalerProc;
+ int _scalerType;
+ int _transactionMode;
+
+ bool _screenIsLocked;
+ Graphics::Surface _framebuffer;
+
+ /** Current video mode flags (see DF_* constants) */
+ bool _modeChanged;
+ int _screenChangeCount;
+
+ enum {
+ NUM_DIRTY_RECT = 100,
+ MAX_SCALING = 3
+ };
+
+ // Dirty rect management
+ SDL_Rect _dirtyRectList[NUM_DIRTY_RECT];
+ int _numDirtyRects;
+
+ // Keyboard mouse emulation. Disabled by fingolfin 2004-12-18.
+ // I am keeping the rest of the code in for now, since the joystick
+ // code (or rather, "hack") uses it, too.
+ struct KbdMouse {
+ int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
+ uint32 last_time, delay_time, x_down_time, y_down_time;
+ };
+
+ 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;
-#ifdef USE_OPENGL
- OSystem::GraphicsMode *_graphicsModes;
- int _graphicsMode;
- int _sdlModesCount;
- int _glModesCount;
+ // 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)
+ { }
+ };
+
+ // mouse
+ KbdMouse _km;
+ 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
+ };
+
+ // Scroll lock state - since SDL doesn't track it
+ bool _scrollLock;
+
+ // joystick
+ SDL_Joystick *_joystick;
+
+ // Shake mode
+ int _currentShakePos;
+ int _newShakePos;
+
+ // Palette data
+ SDL_Color _currentPalette[256];
+ uint _paletteDirtyStart, _paletteDirtyEnd;
+
+ // Cursor palette data
+ SDL_Color _cursorPalette[256];
/**
- * Creates the merged graphics modes list
+ * Mutex which prevents multiple threads from interfering with each other
+ * when accessing the screen.
*/
- virtual void setupGraphicsModes();
+ MutexRef _graphicsMutex;
- virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
- virtual int getDefaultGraphicsMode() const;
- virtual bool setGraphicsMode(int mode);
- virtual int getGraphicsMode() const;
+#ifdef MIXER_DOUBLE_BUFFERING
+ SDL_mutex *_soundMutex;
+ SDL_cond *_soundCond;
+ SDL_Thread *_soundThread;
+ bool _soundThreadIsRunning;
+ bool _soundThreadShouldQuit;
+
+ byte _activeSoundBuf;
+ uint _soundBufSize;
+ byte *_soundBuffers[2];
+
+ void mixerProducerThread();
+ static int SDLCALL mixerProducerThreadEntry(void *arg);
+ void initThreadedMixer(Audio::MixerImpl *mixer, uint bufSize);
+ void deinitThreadedMixer();
#endif
+
+ FilesystemFactory *_fsFactory;
+ Common::SaveFileManager *_savefile;
+ Audio::MixerImpl *_mixer;
+
+ SDL_TimerID _timerID;
+ Common::TimerManager *_timer;
+
+protected:
+ virtual void addDirtyRect(int x, int y, int w, int h, bool realCoordinates = false); // overloaded by CE backend
+
+ virtual void drawMouse(); // overloaded by CE backend
+ virtual void undrawMouse(); // overloaded by CE backend (FIXME)
+ virtual void blitCursor(); // overloaded by CE backend (FIXME)
+
+ /** Set the position of the virtual mouse cursor. */
+ void setMousePos(int x, int y);
+ virtual void fillMouseEvent(Common::Event &event, int x, int y); // overloaded by CE backend
+ void toggleMouseGrab();
+
+ virtual void internUpdateScreen(); // overloaded by CE backend
+
+ virtual bool loadGFXMode(); // overloaded by CE backend
+ virtual void unloadGFXMode(); // overloaded by CE backend
+ virtual bool hotswapGFXMode(); // overloaded by CE backend
+
+ void setFullscreenMode(bool enable);
+ void setAspectRatioCorrection(bool enable);
+
+ virtual bool saveScreenshot(const char *filename); // overloaded by CE backend
+
+ int effectiveScreenHeight() const;
+
+ void setupIcon();
+ void handleKbdMouse();
+
+ virtual bool remapKey(SDL_Event &ev, Common::Event &event);
+
+ bool handleScalerHotkeys(const SDL_KeyboardEvent &key);
+ bool isScalerHotkey(const Common::Event &event);
};
#endif
diff --git a/backends/platform/sdl/win32/win32-main.cpp b/backends/platform/sdl/win32/win32-main.cpp
deleted file mode 100644
index 25f208ddac..0000000000
--- a/backends/platform/sdl/win32/win32-main.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/* 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
-
-// Fix for bug #2895217 "MSVC compilation broken with r47595":
-// We need to keep this on top of the "common/scummsys.h"(base/main.h) include,
-// otherwise we will get errors about the windows headers redefining
-// "ARRAYSIZE" for example.
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef ARRAYSIZE // winnt.h defines ARRAYSIZE, but we want our own one...
-
-#include "backends/platform/sdl/win32/win32.h"
-#include "backends/plugins/sdl/sdl-provider.h"
-#include "base/main.h"
-
-int __stdcall WinMain(HINSTANCE /*hInst*/, HINSTANCE /*hPrevInst*/, LPSTR /*lpCmdLine*/, int /*iShowCmd*/) {
- SDL_SetModuleHandle(GetModuleHandle(NULL));
- return main(__argc, __argv);
-}
-
-int main(int argc, char *argv[]) {
- // Create our OSystem instance
- g_system = new OSystem_Win32();
- assert(g_system);
-
- // Pre initialize the backend
- ((OSystem_Win32 *)g_system)->init();
-
-#ifdef DYNAMIC_MODULES
- PluginManager::instance().addPluginProvider(new SDLPluginProvider());
-#endif
-
- // Invoke the actual ScummVM main entry point:
- int res = scummvm_main(argc, argv);
-
- // Free OSystem
- delete (OSystem_Win32 *)g_system;
-
- return res;
-}
-
-#endif
diff --git a/backends/platform/sdl/win32/win32.cpp b/backends/platform/sdl/win32/win32.cpp
deleted file mode 100644
index 05005dee6f..0000000000
--- a/backends/platform/sdl/win32/win32.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/* 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
-
-#include <windows.h>
-#define WIN32_LEAN_AND_MEAN
-#undef ARRAYSIZE // winnt.h defines ARRAYSIZE, but we want our own one...
-
-#include "backends/platform/sdl/win32/win32.h"
-#include "backends/fs/windows/windows-fs-factory.h"
-
-#define DEFAULT_CONFIG_FILE "scummvm.ini"
-
-void OSystem_Win32::init() {
- // Initialze File System Factory
- _fsFactory = new WindowsFilesystemFactory();
-
- // Invoke parent implementation of this method
- OSystem_SDL::init();
-}
-
-Common::String OSystem_Win32::getDefaultConfigFileName() {
- char configFile[MAXPATHLEN];
-
- OSVERSIONINFO win32OsVersion;
- ZeroMemory(&win32OsVersion, sizeof(OSVERSIONINFO));
- win32OsVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
- GetVersionEx(&win32OsVersion);
- // Check for non-9X version of Windows.
- if (win32OsVersion.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS) {
- // Use the Application Data directory of the user profile.
- if (win32OsVersion.dwMajorVersion >= 5) {
- if (!GetEnvironmentVariable("APPDATA", configFile, sizeof(configFile)))
- error("Unable to access application data directory");
- } else {
- if (!GetEnvironmentVariable("USERPROFILE", configFile, sizeof(configFile)))
- error("Unable to access user profile directory");
-
- strcat(configFile, "\\Application Data");
- CreateDirectory(configFile, NULL);
- }
-
- strcat(configFile, "\\ScummVM");
- CreateDirectory(configFile, NULL);
- strcat(configFile, "\\" DEFAULT_CONFIG_FILE);
-
- FILE *tmp = NULL;
- if ((tmp = fopen(configFile, "r")) == NULL) {
- // Check windows directory
- char oldConfigFile[MAXPATHLEN];
- GetWindowsDirectory(oldConfigFile, MAXPATHLEN);
- strcat(oldConfigFile, "\\" DEFAULT_CONFIG_FILE);
- if ((tmp = fopen(oldConfigFile, "r"))) {
- strcpy(configFile, oldConfigFile);
-
- fclose(tmp);
- }
- } else {
- fclose(tmp);
- }
- } else {
- // Check windows directory
- GetWindowsDirectory(configFile, MAXPATHLEN);
- strcat(configFile, "\\" DEFAULT_CONFIG_FILE);
- }
-
- return configFile;
-}
-
-#endif
diff --git a/backends/platform/sdl/win32/win32.h b/backends/platform/sdl/win32/win32.h
deleted file mode 100644
index f18ee6ead1..0000000000
--- a/backends/platform/sdl/win32/win32.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* 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 PLATFORM_SDL_WIN32_H
-#define PLATFORM_SDL_WIN32_H
-
-#include "backends/platform/sdl/sdl.h"
-
-class OSystem_Win32 : public OSystem_SDL {
-public:
- virtual void init();
-
-protected:
- virtual Common::String getDefaultConfigFileName();
-};
-
-#endif
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-18 16:31:46 +0000