Ticket #8654: xbox_wip.patch

backends/platform/sdl/main.cpp

@@ -23 +23 @@
  *
  */
 
-#if defined(WIN32) && !defined(__SYMBIAN32__)
+#if defined(WIN32) && !defined(__SYMBIAN32__) && !defined(_XBOX)
 #include <windows.h>
 // winnt.h defines ARRAYSIZE, but we want our own one...
 #undef ARRAYSIZE
@@ -39 +39 @@
 
 #if !defined(__MAEMO__) && !defined(_WIN32_WCE)
 
-#if defined (WIN32)
+#if defined (WIN32) && !defined(_XBOX)
 int __stdcall WinMain(HINSTANCE /*hInst*/, HINSTANCE /*hPrevInst*/,  LPSTR /*lpCmdLine*/, int /*iShowCmd*/) {
         SDL_SetModuleHandle(GetModuleHandle(NULL));
         return main(__argc, __argv);
@@ -95 +95 @@
         // Create our OSystem instance
 #if defined(__SYMBIAN32__)
         g_system = new OSystem_SDL_Symbian();
+#elif defined(_XBOX)
+        g_system = new OSystem_XBOX();
 #else
         g_system = new OSystem_SDL();
 #endif

backends/platform/sdl/sdl.cpp

@@ -23 +23 @@
  *
  */
 
-#if defined(WIN32)
+#if defined(WIN32) && !defined(_XBOX)
 #include <windows.h>
 #if defined(ARRAYSIZE)
 // winnt.h defines ARRAYSIZE, but we want our own one... - this is needed before including util.h
@@ -31 +31 @@
 #endif
 #endif
 
+#if defined(_XBOX)
+#include "backends/platform/xbox/osys_xbox.h"
+#endif
+
 #include "backends/platform/sdl/sdl.h"
 #include "common/config-manager.h"
 #include "common/events.h"

backends/platform/xbox/oskeyboard.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#include "oskeyboard.h"
+
+#include "graphics/imagedec.h"
+#include "common/events.h"
+#include "common/file.h"
+
+using namespace Graphics;
+
+const char KEYBOARD_MAPPING_ALPHA[][14] = { {"abcdefghijklm"}, {"nopqrstuvwxyz"} };
+const char KEYBOARD_MAPPING_NUMERIC[][6] = { {"12345"}, {"67890"} };
+const int  KEYBOARD_MAPPING_SPECIAL[][3][2] = { { {1,SDLK_ESCAPE}, {224,SDLK_UP}, {32,SDLK_SPACE} },
+                                              { {224,SDLK_LEFT}, {224,SDLK_DOWN}, {224,SDLK_RIGHT} } };
+
+
+OSKeyboard::OSKeyboard(OSystem *system) : _x(0), _y(0), _created(false), _visible(false), _surface(NULL) {
+        _system = system;
+}
+
+OSKeyboard::~OSKeyboard() {
+        if (_surface) {
+                delete _surface;
+                _surface = NULL;
+        }
+}
+
+bool OSKeyboard::checkInside(int16 x, int16 y) {
+        if (!_surface)
+                return false;
+
+        if (x >= _x && x <= _x + _surface->w && y >= _y && y <= _y + _surface->h)
+                return true;
+        else
+                return false;
+}
+
+bool OSKeyboard::create(Common::String filename, int16 x, int16 y) {
+        return create(SDL_RWFromFile(filename.c_str(), "rb"), x, y);
+}
+
+bool OSKeyboard::create(byte *data, uint32 datasize, int16 x, int16 y) {
+        if (!data || !datasize)
+                return false;
+
+        return create(SDL_RWFromMem(data, datasize), x, y);
+}
+
+bool OSKeyboard::create(SDL_RWops *rwops, int16 x, int16 y) {
+        _surface = SDL_LoadBMP_RW(rwops, 1);
+
+        if (!_surface)
+                return false;
+
+        _x = x;
+        _y = y;
+
+        _created = true;
+
+        return true;
+}
+
+bool OSKeyboard::draw(SDL_Surface *dest) {
+        SDL_Rect rect = getRect();
+
+        if (!_visible || !_system || !_surface || !dest)
+                return false;
+        
+        SDL_BlitSurface(_surface, 0, dest, &rect);
+        return true;
+}
+
+int16 OSKeyboard::getHeight() {
+        if (!_surface)
+                return 0;
+
+        return _surface->h;
+}
+
+void OSKeyboard::getPosition(int16* x, int16 *y) {
+        if (x)
+                *x = _x;
+
+        if (y)
+                *y = _y;
+}
+
+SDL_Rect OSKeyboard::getRect() {
+        SDL_Rect r = {0};
+
+        if (_surface) {
+                r.x = _x;
+                r.y = _y;
+                r.w = _surface->w;
+                r.h = _surface->h;
+        }
+
+        return r;
+}
+
+int16 OSKeyboard::getWidth() {
+        if (!_surface)
+                return 0;
+
+        return _surface->w;
+}
+
+bool OSKeyboard::action(int16 x, int16 y, bool pushed) {
+        if (!_visible || !checkInside(x, y))
+                return false;
+
+        int keyAscii = 0;
+        int keyCode = 0;
+
+        x -= _x;
+        //y -= _y;
+
+        if (x < 185) {
+                // Alpha selection
+                keyCode = keyAscii = KEYBOARD_MAPPING_ALPHA[y >= _y+20][((x + 10) / 14) - 1];
+        } else if (x >= 186 && x <= 255) {
+                // Numeric selection
+                keyCode = keyAscii = KEYBOARD_MAPPING_NUMERIC[y >= _y+20][((x - 187 + 10) / 14) - 1];
+        } else if (x >= 258 && x <= 300) {
+                // Special keys
+                keyAscii = KEYBOARD_MAPPING_SPECIAL[y >= _y+20][((x - 259 + 10) / 14) - 1][0];
+                keyCode = KEYBOARD_MAPPING_SPECIAL[y >= _y+20][((x - 259 + 10) / 14) - 1][1];
+        } else if (x >= 302 && x <= 316) {
+                if (y < _y +20) {
+                        // Backspace
+                        keyAscii = 1; //VK_BACK; 
+                        keyCode = SDLK_BACKSPACE; //keyAscii;
+                } else {
+                        // Enter
+                        keyAscii = 13; 
+                        keyCode = 10;
+                }
+        }
+
+        if (keyAscii != 0) {
+                _key.setAscii(keyAscii);
+                _key.setKeycode(tolower(keyCode));
+                return simulateKey(&_key, pushed);
+        }
+
+        return false;
+}
+
+bool OSKeyboard::isCreated() {
+        return _created;
+}
+
+bool OSKeyboard::isVisible() {
+        return _visible;
+}
+
+void OSKeyboard::setPosition(int16 x, int16 y) {
+        _x = x;
+        _y = y;
+}
+
+void OSKeyboard::setVisible(bool visible) {
+        _visible = visible;
+}
+
+bool OSKeyboard::simulateKey(GUI::Key *key, bool pushed) {
+        SDL_Event ev = {0};
+
+        if (!key->keycode())
+                key->setKeycode(key->ascii());
+
+        if (!key->ascii())
+                key->setAscii(key->keycode());
+
+        ev.type = (pushed ? SDL_KEYDOWN : SDL_KEYUP);
+        ev.key.keysym.mod = (SDLMod)key->flags();
+        ev.key.keysym.sym = (SDLKey)key->keycode();
+        ev.key.keysym.unicode = key->keycode();
+        ev.key.keysym.mod = KMOD_RESERVED;
+        return (SDL_PushEvent(&ev) == 0);
+}
+
+void OSKeyboard::toggleVisible() {
+        _visible = !_visible;
+}

backends/platform/xbox/oskeyboard.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#ifndef OSKEYBOARD_H
+#define OSKEYBOARD_H
+
+#include "backends/platform/sdl/sdl-common.h"
+#include "graphics/surface.h"
+
+#include "common/stream.h"
+#include "gui/key.h"
+
+class OSKeyboard {
+public:
+        OSKeyboard(OSystem* system);
+        virtual ~OSKeyboard();
+
+        virtual bool create(byte *data, uint32 datasize, int16 x, int16 y);
+        virtual bool create(Common::String filename, int16 x, int16 y);
+        virtual bool draw(SDL_Surface *dest);
+
+        virtual int16 getHeight();
+        virtual int16 getWidth();
+        virtual void getPosition(int16 *x, int16 *y);
+
+        virtual SDL_Rect getRect();
+
+        virtual bool action(int16 x, int16 y, bool pushed);
+
+        virtual bool isCreated();
+        virtual bool isVisible();
+
+        virtual void setPosition(int16 x, int16 y);
+        virtual void setVisible(bool visible);
+
+        virtual void toggleVisible();
+
+protected:
+        int16 _x;
+        int16 _y;
+
+        OSystem *_system;
+        
+        bool _created;
+        bool _visible;
+
+        SDL_Surface *_surface;
+
+        GUI::Key _key;
+
+        virtual bool checkInside(int16 x, int16 y);
+
+        virtual bool create(SDL_RWops *rwops, int16 x, int16 y);
+
+        virtual bool simulateKey(GUI::Key *key, bool pushed);
+};
+
+#endif

backends/platform/xbox/osys_xbox.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#include <xtl.h>
+#undef FORCEINLINE
+
+#include "backends/platform/sdl/sdl-common.h"
+#include "backends/platform/xbox/osys_xbox.h"
+#include "backends/platform/xbox/xbox_saves.h"
+#include "common/config-manager.h"
+#include "common/events.h"
+
+#include "xbox_utils.h"
+
+// 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
+
+#define JOY_ANALOG
+
+// #define JOY_INVERT_Y
+
+#define XB_XAXIS_L                              0
+#define XB_YAXIS_L                              1
+
+#define XB_XAXIS_R                              2
+#define XB_YAXIS_R                              3
+
+#define XB_BUTTON_A                             0
+#define XB_BUTTON_B                             1
+#define XB_BUTTON_X                             2
+#define XB_BUTTON_Y                             3
+#define XB_BUTTON_BLACK                 4
+#define XB_BUTTON_WHITE                 5
+#define XB_BUTTON_LTRIG                 6
+#define XB_BUTTON_RTRIG                 7
+#define XB_BUTTON_START                 8
+#define XB_BUTTON_BACK                  9
+#define XB_BUTTON_LTHUMB                10
+#define XB_BUTTON_RTHUMB                11
+
+#define XB_DPAD_CENTERED                SDL_HAT_CENTERED
+#define XB_DPAD_UP                              SDL_HAT_UP
+#define XB_DPAD_DOWN                    SDL_HAT_DOWN
+#define XB_DPAD_LEFT                    SDL_HAT_LEFT
+#define XB_DPAD_RIGHT                   SDL_HAT_RIGHT
+
+//uint16 padValues[] = {
+//         1, // XB_BUTTON_A
+//         2, // XB_BUTTON_B
+//         4, // XB_BUTTON_X
+//         8, // XB_BUTTON_Y
+//        16, // XB_BUTTON_BLACK
+//        32, // XB_BUTTON_WHITE
+//        64, // XB_BUTTON_LTRIG
+//       128, // XB_BUTTON_RTRIG
+//       256, // XB_BUTTON_START
+//       512, // XB_BUTTON_BACK
+//      1024, // XB_BUTTON_LTHUMB
+//      2048  // XB_BUTTON_RTHUMB
+//};
+
+void xbox_exit() {
+        XLaunchNewImage(NULL, NULL);
+}
+
+static byte SDLModToOSystemKeyFlags(SDLMod mod) {
+        byte b = 0;
+#ifdef LINUPY
+        // Yopy has no ALT key, steal the SHIFT key
+        // (which isn't used much anyway)
+        if (mod & KMOD_SHIFT)
+                b |= Common::KBD_ALT;
+#else
+        if (mod & KMOD_SHIFT)
+                b |= Common::KBD_SHIFT;
+        if (mod & KMOD_ALT)
+                b |= Common::KBD_ALT;
+#endif
+        if (mod & KMOD_CTRL)
+                b |= Common::KBD_CTRL;
+
+        return b;
+}
+
+static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode) {
+        if (key >= SDLK_F1 && key <= SDLK_F9) {
+                return key - SDLK_F1 + 315;
+        } 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;
+}
+
+OSystem_XBOX::OSystem_XBOX() : _keyboard(this), _padValues(0), _oldpadValues(0), _axisRYValue(0), _oldaxisRYValue(0) {
+        XBOXUtils::SetupDrives();
+}
+
+OSystem_XBOX::~OSystem_XBOX() {
+}
+
+bool OSystem_XBOX::hasFeature(Feature f) {
+        return (f == kFeatureVirtualKeyboard) ||
+                OSystem_SDL::hasFeature(f);
+}
+
+void OSystem_XBOX::setFeatureState(Feature f, bool enable) {
+        switch(f) {
+        case kFeatureVirtualKeyboard:
+                _keyboard.setVisible(enable);
+                break;
+        default:
+                OSystem_SDL::setFeatureState(f, enable);
+                break;
+        }
+}
+
+bool OSystem_XBOX::getFeatureState(Feature f) {
+        switch(f) {
+        case kFeatureVirtualKeyboard:
+                return _keyboard.isVisible();
+                break;
+        }
+        return OSystem_SDL::getFeatureState(f);
+}
+
+void OSystem_XBOX::createOSKeyboard() {
+        void *pData = NULL;
+        uint32 dataSize = 0;
+
+        dataSize = XBOXUtils::LoadSectionData("IMG_KEYB", &pData);
+
+        if (_keyboard.create((byte*)pData, dataSize, 0, 0)) {
+                int posX = (this->getOverlayWidth() - _keyboard.getWidth()) / 2;
+                int posY = (this->getOverlayHeight() - _keyboard.getHeight()) - 20;
+
+                _keyboard.setPosition(posX, posY);
+        }
+
+        if (pData) {
+                delete [] pData;
+                pData = NULL;
+        }
+}
+
+void OSystem_XBOX::drawMouse() {
+        drawKeyboard();
+        OSystem_SDL::drawMouse();
+}
+
+void OSystem_XBOX::undrawMouse() {
+        undrawKeyboard();
+        OSystem_SDL::undrawMouse();
+}
+
+void OSystem_XBOX::undrawKeyboard() {
+        if (_keyboardBackup.w != 0 && _keyboardBackup.h != 0)
+                addDirtyRect(_keyboardBackup.x, _keyboardBackup.y, _keyboardBackup.w, _keyboardBackup.h);
+}
+
+void OSystem_XBOX::drawKeyboard() {
+        if (!_keyboard.isCreated() || !_keyboard.isVisible()) {
+                _keyboardBackup.x = _keyboardBackup.y = _keyboardBackup.w = _keyboardBackup.h = 0;
+                return;
+        }
+
+        int16 x, y;
+        _keyboard.getPosition(&x, &y);
+        if (x < 0 || y < 0) {
+                int w = _keyboard.getWidth();
+                int h = _keyboard.getHeight();
+
+                _keyboard.setPosition( (this->getOverlayWidth() - w) / 2, this->getOverlayHeight() - (h + 20) );
+        }
+
+        SDL_Rect dst = _keyboard.getRect();
+
+        _keyboardBackup.x = dst.x;
+        _keyboardBackup.y = dst.y;
+        _keyboardBackup.w = dst.w;
+        _keyboardBackup.h = dst.h;
+
+        _keyboard.draw(_hwscreen);
+
+        addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
+}
+
+void OSystem_XBOX::initBackend() {
+        ConfMan.set("themepath", "media:\\");
+        ConfMan.set("extrapath", "media:\\");
+        ConfMan.set("savepath", "saves:\\");
+        ConfMan.set("joystick_num", "0");
+
+        if (_savefile == 0) {
+                _savefile = new XboxSaveFileManager();
+        }
+
+        OSystem_SDL::initBackend();
+
+        createOSKeyboard();
+}
+
+void OSystem_XBOX::updateScreen() {
+        OSystem_SDL::updateScreen();
+}
+
+bool OSystem_XBOX::pollEvent(Common::Event &event) {
+        SDL_Event ev;
+        int axis;
+
+        memset(&event, 0, sizeof(Common::Event));
+
+        handleKbdMouse();
+
+        // If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
+        if (_modeChanged) {
+                _modeChanged = false;
+                event.type = Common::EVENT_SCREEN_CHANGED;
+                _screenChangeCount++;
+                return true;
+        }
+
+        while (SDL_PollEvent(&ev)) {
+                switch (ev.type) {
+                case SDL_KEYDOWN:
+                        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);
+
+                        return true;
+
+                case SDL_KEYUP:
+                        event.type = Common::EVENT_KEYUP;
+                        event.kbd.keycode = ev.key.keysym.sym;
+                        event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
+
+                        return true;
+
+                case SDL_MOUSEMOTION:
+                        event.type = Common::EVENT_MOUSEMOVE;
+                        fillMouseEvent(event, ev.motion.x, ev.motion.y);
+
+                        setMousePos(event.mouse.x, event.mouse.y);
+                        return true;
+
+                case SDL_JOYBUTTONDOWN:
+                        _padValues |= (1 << ev.jbutton.button);
+                        break;
+
+                case SDL_JOYBUTTONUP:
+                        _padValues ^= (1 << ev.jbutton.button);
+                        break;
+
+                case SDL_JOYAXISMOTION:
+                        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 == XB_XAXIS_L) {
+#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 == XB_YAXIS_L) {
+#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
+                        }
+
+                        if (ev.jaxis.axis == XB_YAXIS_R) {
+                                _axisRYValue = axis;
+                                break;
+                        }
+
+                        fillMouseEvent(event, _km.x, _km.y);
+
+                        return true;
+
+                case SDL_JOYHATMOTION:
+                        if (_padValues & (1 << XB_BUTTON_RTRIG)) {
+                                if (ev.jhat.value == SDL_HAT_CENTERED) {
+                                        event.type = Common::EVENT_KEYUP;
+                                }
+                                else {
+                                        event.type = Common::EVENT_KEYDOWN;
+
+                                        if (ev.jhat.value == SDL_HAT_UP)
+                                                event.kbd.keycode = SDLK_KP8;
+
+                                        if (ev.jhat.value == SDL_HAT_RIGHTUP) 
+                                                event.kbd.keycode = SDLK_KP9;
+
+                                        if (ev.jhat.value == SDL_HAT_RIGHT) 
+                                                event.kbd.keycode = SDLK_KP6;
+
+                                        if (ev.jhat.value == SDL_HAT_RIGHTDOWN) 
+                                                event.kbd.keycode = SDLK_KP3;
+
+                                        if (ev.jhat.value == SDL_HAT_DOWN) 
+                                                event.kbd.keycode = SDLK_KP2;
+
+                                        if (ev.jhat.value == SDL_HAT_LEFTDOWN) 
+                                                event.kbd.keycode = SDLK_KP1;
+
+                                        if (ev.jhat.value == SDL_HAT_LEFT) 
+                                                event.kbd.keycode = SDLK_KP4;
+
+                                        if (ev.jhat.value == SDL_HAT_LEFTUP) 
+                                                event.kbd.keycode = SDLK_KP7;
+                                }
+
+                                event.kbd.ascii = mapKey((SDLKey)event.kbd.keycode, KMOD_NONE, 0);
+                                event.kbd.flags = SDLModToOSystemKeyFlags(KMOD_NONE);
+
+                                return true;
+                        }
+                        else {
+                                if (ev.jhat.value == SDL_HAT_CENTERED) {
+                                        _km.x_vel = _km.x_down_count = 0;
+                                        _km.y_vel = _km.y_down_count = 0;
+                                }
+                                else {
+                                        if (ev.jhat.value & SDL_HAT_UP) {
+                                                _km.y_vel = -1;
+                                                _km.y_down_count = 1;
+                                        }
+
+                                        if (ev.jhat.value & SDL_HAT_DOWN) {
+                                                _km.y_vel =  1;
+                                                _km.y_down_count = 1;
+                                        }
+
+                                        if (ev.jhat.value & SDL_HAT_LEFT) {
+                                                _km.x_vel = -1;
+                                                _km.x_down_count = 1;
+                                        }
+
+                                        if (ev.jhat.value & SDL_HAT_RIGHT) {
+                                                _km.x_vel =  1;
+                                                _km.x_down_count = 1;
+                                        }
+                                        
+                                        break;
+                                }
+                        }
+
+                case SDL_VIDEOEXPOSE:
+                        _forceFull = true;
+                        break;
+
+                case SDL_QUIT:
+                        event.type = Common::EVENT_QUIT;
+                        return true;
+                }
+        }
+
+        uint16 buttonsChanged = _padValues ^ _oldpadValues;
+
+        if (buttonsChanged) {
+                if (buttonsChanged & (1 << XB_BUTTON_A)) {
+                        if (!_keyboard.action(_km.x, _km.y, (_padValues & (1 << XB_BUTTON_A)))) {
+                                event.type = (_padValues & (1 << XB_BUTTON_A)) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP;
+                                fillMouseEvent(event, _km.x, _km.y);
+                        }
+                }
+                else if (buttonsChanged & (1 << XB_BUTTON_B)) {
+                        event.type = (_padValues & (1 << XB_BUTTON_B)) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP;
+                        fillMouseEvent(event, _km.x, _km.y);
+                }
+                else if (buttonsChanged & (1 << XB_BUTTON_LTRIG)) {
+                        _keyboard.setVisible((_padValues & (1 << XB_BUTTON_LTRIG)) > 0);
+                }
+                else {
+                        SDLMod mod = KMOD_NONE;
+
+                        event.type = buttonsChanged & _padValues ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP;
+                        event.kbd.flags = 0;
+
+                        if (buttonsChanged & (1 << XB_BUTTON_START)) {
+                                event.kbd.keycode = SDLK_ESCAPE;
+                        }
+                        else if (buttonsChanged & (1 << XB_BUTTON_BACK)) {
+                                event.kbd.keycode = SDLK_F5;
+                        } 
+                        else if (buttonsChanged & (1 << XB_BUTTON_X)) {
+                                event.kbd.keycode = SDLK_PERIOD;
+                        }
+                        else if (buttonsChanged & (1 << XB_BUTTON_Y)) {
+                                event.kbd.keycode = SDLK_SPACE;
+                        }
+                        else if (buttonsChanged & (1 << XB_BUTTON_BLACK)) {
+                                event.kbd.keycode = SDLK_RETURN;
+                        }
+                        else if (buttonsChanged & (1 << XB_BUTTON_WHITE)) {
+                                event.kbd.keycode = SDLK_LSHIFT;
+                                if (event.type == Common::EVENT_KEYDOWN)
+                                        mod = KMOD_LSHIFT;
+                        }
+
+                        event.kbd.ascii = mapKey((SDLKey)event.kbd.keycode, mod, 0);
+                        event.kbd.flags = SDLModToOSystemKeyFlags(mod);
+                }
+
+                _oldpadValues = _padValues;
+                return true;
+        }
+
+        bool axisRYChanged = _axisRYValue != _oldaxisRYValue;
+        if (axisRYChanged) {
+                if (_axisRYValue > 0) 
+                        event.type = Common::EVENT_WHEELDOWN;
+                else if (_axisRYValue < 0) 
+                        event.type = Common::EVENT_WHEELUP;
+
+                _oldaxisRYValue = _axisRYValue;
+                return true;
+        }
+
+        return false;
+}
+
+void OSystem_XBOX::quit() {
+        OSystem_SDL::quit();
+}
+
+void OSystem_XBOX::showOSKeyboard() {
+        _keyboard.setVisible(true);
+}
+
+void OSystem_XBOX::hideOSKeyboard() {
+        _keyboard.setVisible(false);
+}

backends/platform/xbox/osys_xbox.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#ifndef OSYS_XBOX_H
+#define OSYS_XBOX_H
+
+#include "backends/platform/sdl/sdl-common.h"
+#include "backends/platform/xbox/OSKeyboard.h"
+
+class OSystem_XBOX : public OSystem_SDL {
+public:
+        OSystem_XBOX();
+        virtual ~OSystem_XBOX();
+
+        virtual void initBackend();
+
+        virtual void updateScreen();
+        virtual bool pollEvent(Common::Event &event);
+
+        virtual void quit();
+
+        virtual bool hasFeature(Feature f);
+        virtual void setFeatureState(Feature f, bool enable);
+        virtual bool getFeatureState(Feature f);
+
+protected:
+        SDL_Rect _keyboardBackup;
+
+        virtual void drawMouse();
+        virtual void undrawMouse();
+
+        virtual void drawKeyboard();
+        virtual void undrawKeyboard();
+
+private:
+        uint16 _padValues;
+        uint16 _oldpadValues;
+        
+        int16 _axisRYValue;
+        int16 _oldaxisRYValue;
+
+        OSKeyboard _keyboard;
+
+        virtual void createOSKeyboard();
+
+        virtual void showOSKeyboard();
+        virtual void hideOSKeyboard();
+};
+
+#endif

backends/platform/xbox/README.XBOX

@@ +1 @@
+ScummVM 0.10.0SVN XBOX README
+=============================
+
+Running
+=======
+
+Run the executable from an xbox format dvd or from the xbox hard drive.
+
+Use the ScummVM launcher to add games and run them.
+
+
+
+Controls
+========
+
+Left Stick                      - Mouse movement
+Right Stick                     - Mouse wheel movement
+D-Pad                           - Fine mouse movement
+A                                       - Mouse button 1
+B                                       - Mouse button 2
+X                                       - '.' (skip dialogue in some games)
+Y                                       - Space
+Black                           - Enter
+White                           - Shift
+Start                           - Escape
+Back                            - F5
+Left Trigger            - Hold to show virtual keyboard. Release to hide
+Right Trigger           - Hold and use D-Pad to emulate numeric keypad
+
+
+
+Port Author
+===========
+
+Carcharius              (carcharius@gmail.com)
+ No newline at end of file

backends/platform/xbox/xbox_saves.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#include <xtl.h>
+#undef FORCEINLINE
+#include <process.h>
+
+#include "common/stdafx.h"
+#include "common/savefile.h"
+#include "common/config-manager.h"
+#include "backends/platform/xbox/xbox_saves.h"
+#include "backends/saves/compressed/compressed-saves.h"
+
+#include "xbox_utils.h"
+
+class XboxStdioSaveFile : public Common::InSaveFile, public Common::OutSaveFile {
+private:
+        FILE *fh;
+        bool _saveContainer;
+        Common::String _savePath;
+
+        void finalizeSaveContainer();
+
+public:
+        XboxStdioSaveFile(const char *filename, bool saveOrLoad, bool saveContainer = false) {
+                fh = ::fopen(filename, (saveOrLoad? "wb" : "rb"));
+                _saveContainer = saveContainer;
+                _savePath = filename;
+        }
+        ~XboxStdioSaveFile() {
+                if (fh)
+                        ::fclose(fh);
+
+                finalize();
+
+                if (_saveContainer)
+                        finalizeSaveContainer();
+        }
+
+        bool eos() const { return feof(fh) != 0; }
+        bool ioFailed() const { return ferror(fh) != 0; }
+        void clearIOFailed() { clearerr(fh); }
+
+        bool isOpen() const { return fh != 0; }
+
+        uint32 read(void *dataPtr, uint32 dataSize) {
+                assert(fh);
+                return fread(dataPtr, 1, dataSize, fh);
+        }
+        uint32 write(const void *dataPtr, uint32 dataSize) {
+                assert(fh);
+                return fwrite(dataPtr, 1, dataSize, fh);
+        }
+
+        uint32 pos() const {
+                assert(fh);
+                return ftell(fh);
+        }
+        uint32 size() const {
+                assert(fh);
+                uint32 oldPos = ftell(fh);
+                fseek(fh, 0, SEEK_END);
+                uint32 length = ftell(fh);
+                fseek(fh, oldPos, SEEK_SET);
+                return length;
+        }
+
+        void seek(int32 offs, int whence = SEEK_SET) {
+                assert(fh);
+                fseek(fh, offs, whence);
+        }
+
+        void finalize() {
+                OutSaveFile::finalize();
+        }
+};
+
+void XboxStdioSaveFile::finalizeSaveContainer() {
+        XBOXUtils::CloseSaveContainer("saves");
+        _saveContainer = false;
+}
+
+static void join_paths(const char *filename, const char *directory,
+                                                                 char *buf, int bufsize) {
+        buf[bufsize-1] = '\0';
+        strncpy(buf, directory, bufsize - 1);
+
+        strncat(buf, filename, bufsize - 1);
+}
+
+XboxSaveFileManager::XboxSaveFileManager() {
+}
+
+Common::OutSaveFile *XboxSaveFileManager::openForSaving(const char *filename) {
+        char buf[256];
+        join_paths(filename, getSavePath(), buf, sizeof(buf));
+
+        bool needsCont = needsSaveContainer(buf);
+        if (needsCont) {
+                if (!openSaveContainer(filename, buf, sizeof(buf)))
+                        return NULL;
+        }
+
+        XboxStdioSaveFile *sf = new XboxStdioSaveFile(buf, true, needsCont);
+
+        if (!sf->isOpen()) {
+                delete sf;
+                sf = 0;
+        }
+        return wrapOutSaveFile(sf);
+}
+
+Common::InSaveFile *XboxSaveFileManager::openForLoading(const char *filename) {
+        char buf[256];
+        join_paths(filename, getSavePath(), buf, sizeof(buf));
+
+        if (needsSaveContainer(buf)) {
+                if (!openSaveContainer(filename, buf, sizeof(buf)))
+                        return NULL;
+        }
+
+        XboxStdioSaveFile *sf = new XboxStdioSaveFile(buf, false, needsSaveContainer(buf));
+
+        if (!sf->isOpen()) {
+                delete sf;
+                sf = 0;
+        }
+        return wrapInSaveFile(sf);
+}
+
+void XboxSaveFileManager::listSavefiles(const char * /* prefix */, bool *marks, int num) {
+        // TODO: Implement this properly, at least on systems that support
+        // opendir/readdir.
+        // Even better, replace this with a better design...
+        memset(marks, true, num * sizeof(bool));
+}
+
+bool XboxSaveFileManager::openSaveContainer(const char *filename, char *savepath, uint pathlen)
+{
+        return XBOXUtils::OpenSaveContainer("saves", ConfMan.get("gameid").c_str(), ConfMan.get("description").c_str(), filename, savepath, pathlen);
+}
+
+bool XboxSaveFileManager::needsSaveContainer(const char *filename)
+{
+        // If we're trying to save/load from the "saves:\" or the "u:\" drive
+        // we assume that we need to create/open a save game container
+        if (strnicmp(filename, "saves:\\", 7) == 0 || strnicmp(filename, "u:\\", 3) == 0)
+                return true;
+
+        return false;
+}

backends/platform/xbox/xbox_saves.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#ifndef XBOX_SAVES_H
+#define XBOX_SAVES_H
+
+#include "common/system.h"
+#include "common/savefile.h"
+
+
+class XboxSaveFileManager : public Common::SaveFileManager {
+public:
+        XboxSaveFileManager();
+
+        virtual Common::OutSaveFile *openForSaving(const char *filename);
+        virtual Common::InSaveFile *openForLoading(const char *filename);
+        virtual void listSavefiles(const char * /* prefix */, bool *marks, int num);
+
+private:
+        virtual bool openSaveContainer(const char *filename, char *savepath, uint pathlen);
+        virtual bool needsSaveContainer(const char *filename);
+};
+
+#endif

backends/platform/xbox/xbox_utils.cpp

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#include <xtl.h>
+#include <stdio.h>
+
+#include "common/stdafx.h"
+
+#include "xbox_utils.h"
+#include "xbox/undocumented.h"
+
+typedef ANSI_STRING OBJECT_STRING;
+
+#define CREATE_SYMBOLIC_LINK(LinkName, DeviceName)      IoCreateSymbolicLink(LinkName, DeviceName);
+
+namespace XBOXUtils {
+
+XBOX_DRIVE xbox_drives[] = {
+        {"game:\\", "game:\\"},
+        {"media:\\", "media:\\"},
+        {"saves:\\", "saves:\\"},
+        {"dvd:\\", "dvd:\\"},
+        {"e:\\", "e:\\"},
+        {"f:\\", "f:\\"},
+        {"g:\\", "g:\\"},
+        {NULL, NULL}
+};
+
+
+HRESULT GetPhysicalPath(char *szDrive, char *szPath) {
+        NTSTATUS st;
+        HANDLE hObject;
+        char szDestinationDrive[17];
+
+        if (strlen(szDrive) > 12)
+                return E_FAIL;
+
+        sprintf(szDestinationDrive, "\\??\\%s", szDrive);
+
+        OBJECT_STRING DriveName = {
+                strlen(szDestinationDrive),
+                strlen(szDestinationDrive) + 1,
+                szDestinationDrive
+        };
+
+        OBJECT_ATTRIBUTES DriveObject = {
+                NULL,
+                &DriveName,
+                OBJ_OPENLINK,
+        };
+
+        st = NtOpenSymbolicLinkObject(&hObject, &DriveObject);
+        if (STATUS_SUCCESS != st)
+                return E_FAIL;
+
+        OBJECT_STRING objName;
+        DWORD dwLength = 0;
+
+        objName.Length = 0;
+        objName.MaximumLength = 1024;
+        objName.Buffer = new CHAR[1024];
+
+        if (!objName.Buffer)
+                return E_FAIL;
+
+        ZeroMemory(objName.Buffer, sizeof(objName.Buffer));
+
+        st = NtQuerySymbolicLinkObject(hObject, &objName, &dwLength );
+
+        if (STATUS_SUCCESS == st) {
+                strncpy(szPath, objName.Buffer, dwLength);
+                szPath[dwLength] = 0;
+                return S_OK;
+        }
+
+        return E_FAIL;
+}
+
+
+HRESULT Mount(char* szDrive, char* szDevice) {
+        char *szSourceDevice;
+        char szDestinationDrive[17];
+
+        if (strlen(szDrive) > 12)
+                return E_FAIL;
+
+        szSourceDevice = szDevice;
+        sprintf(szDestinationDrive, "\\??\\%s", szDrive);
+
+        OBJECT_STRING stPath = {
+                strlen(szSourceDevice),
+                strlen(szSourceDevice) + 1,
+                szSourceDevice
+        };
+        OBJECT_STRING stDrive = {
+                strlen(szDestinationDrive),
+                strlen(szDestinationDrive) + 1,
+                szDestinationDrive
+        };
+
+        NTSTATUS st = CREATE_SYMBOLIC_LINK(&stDrive, &stPath);
+
+        if (STATUS_SUCCESS != st)
+                return E_FAIL;
+
+        return S_OK;
+}
+
+
+void SetupDrives(void) {
+        char szPath[1024];
+
+        XSetFileCacheSize(4 * 1024 * 1024);
+
+        if (SUCCEEDED(GetPhysicalPath("D:", szPath))) {
+                Mount("game:", szPath);
+                strcat(szPath, "\\media");
+                Mount("media:", szPath);
+        }
+
+        if (SUCCEEDED(GetPhysicalPath("T:", szPath)))
+                Mount("scummvm:", szPath);
+
+        Mount("dvd:", "\\Device\\Cdrom0");
+        Mount("e:", "\\Device\\Harddisk0\\Partition1");
+        Mount("f:", "\\Device\\Harddisk0\\Partition6");
+        Mount("g:", "\\Device\\Harddisk0\\Partition7");
+}
+
+
+DWORD LoadSectionData(const char* sectionName, void **buf) {
+        void* pData;
+        DWORD dwSize;
+
+        if (!sectionName)
+                return 0;
+
+        HANDLE hSection = XGetSectionHandle(sectionName);
+        if (hSection == INVALID_HANDLE_VALUE)
+                return 0;
+
+        dwSize = XGetSectionSize(hSection);
+        pData = XLoadSectionByHandle(hSection);
+        if (!pData || dwSize == 0) {
+                CloseHandle(hSection);
+                return 0;
+        }
+
+        if (pData && dwSize)
+                *buf = new byte[dwSize];
+
+        if (!*buf)
+                return 0;
+
+        memcpy(*buf, pData, dwSize);
+        return dwSize;
+
+        XFreeSectionByHandle(hSection);
+        CloseHandle(hSection);
+
+        return 0;
+}
+
+
+bool OpenSaveContainer(const char* container, const char* gameid, const char* description, const char *filename, char *savepath, unsigned int pathlen) {
+        WCHAR gameName[1024];
+        wsprintfW(gameName, L"%S", description);
+
+        if (ERROR_SUCCESS != XCreateSaveGame("U:\\", gameName, OPEN_ALWAYS, 0, savepath, pathlen))
+                return false;
+
+        strcat(savepath, filename);
+
+        return true;
+}
+
+
+void CloseSaveContainer(const char* container) {
+}
+
+} // end namespace XBOXUtils

backends/platform/xbox/xbox_utils.h

@@ +1 @@
+/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/iphone/blit_arm.h $
+ * $Id: blit_arm.h 29718 2007-12-05 08:07:10Z vinterstum $
+ *
+ */
+ 
+#ifndef XBOX_UTILS_H
+#define XBOX_UTILS_H
+
+namespace XBOXUtils {
+
+typedef struct _XBOX_DRIVE {
+        char* szDriveName;
+        char* szDrivePath;
+} XBOX_DRIVE;
+
+extern XBOX_DRIVE xbox_drives[];
+
+HRESULT GetPhysicalPath(char *szDrive, char *szPath);
+HRESULT Mount(char* szDrive, char* szDevice);
+
+void SetupDrives(void);
+
+DWORD LoadSectionData(const char* sectionName, void **buf);
+
+bool OpenSaveContainer(const char* container, const char* gameid, const char* description, const char *filename, har *savepath, unsigned int pathlen);
+
+void CloseSaveContainer(const char* container);
+
+} // end namespace XBOXUtils
+
+#endif

base/commandLine.cpp

@@ -732 +732 @@
         // environment variable. This is weaker than a --savepath on the
         // command line, but overrides the default savepath, hence it is
         // handled here, just before the command line gets parsed.
-#if !defined(MACOS_CARBON) && !defined(_WIN32_WCE) && !defined(PALMOS_MODE) && !defined(__GP32__)
+#if !defined(MACOS_CARBON) && !defined(_WIN32_WCE) && !defined(PALMOS_MODE) && !defined(__GP32__) && !defined(_XBOX)
         if (!settings.contains("savepath")) {
                 const char *dir = getenv("SCUMMVM_SAVEPATH");
                 if (dir && *dir && strlen(dir) < MAXPATHLEN) {

base/plugins.cpp

@@ -146 +146 @@
                 #if PLUGIN_ENABLED_STATIC(TOUCHE)
                 LINK_PLUGIN(TOUCHE)
                 #endif
+                #if PLUGIN_ENABLED_STATIC(TINSEL)
+                LINK_PLUGIN(TINSEL)
+                #endif
 
                 // Music plugins
                 // TODO: Use defines to disable or enable each MIDI driver as a

common/scummsys.h

@@ -227 +227 @@
 
         #define FORCEINLINE __forceinline
         #define NORETURN _declspec(noreturn)
-        #define PLUGIN_EXPORT __declspec(dllexport)
 
+        #if !defined(_XBOX)
+                #define PLUGIN_EXPORT __declspec(dllexport)
+        #else
+                #define SCUMMVM_USE_LONG_INT
+
+                void xbox_exit();
+                #define exit(x) xbox_exit()
+        #endif
+
         typedef signed char int8_t;
         typedef signed short int16_t;
         typedef unsigned char uint8_t;

common/system.cpp

@@ -156 +156 @@
         ((OSystem_PS2*)g_system)->makeConfigPath(configFile);
 #elif defined(__PSP__)
         strcpy(configFile, "ms0:/" DEFAULT_CONFIG_FILE);
+#elif defined(_XBOX)
+        strcpy(configFile, "scummvm:\\" DEFAULT_CONFIG_FILE);
 #else
         strcpy(configFile, DEFAULT_CONFIG_FILE);
 #endif