Ticket #8405: thumbnail-v4-2pre1.patch

backends/sdl/graphics.cpp

@@ -25 +25 @@
 #include "common/util.h"
 #include "graphics/font.h"
 #include "graphics/fontman.h"
+#include "graphics/surface.h"
 
 static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
         {"1x", "Normal (no scaling)", GFX_NORMAL},
@@ -800 +801 @@
         SDL_UnlockSurface(_screen);
 }
 
+void OSystem_SDL::grabRawScreen(Graphics::Surface *surf) {
+        assert(_screen);
+        assert(surf);
+        
+        Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
+        
+        surf->create(_screenWidth, _screenHeight, _screen->format->BytesPerPixel);
+        
+        // Try to lock the screen surface
+        if (SDL_LockSurface(_screen) == -1)
+                error("SDL_LockSurface failed: %s", SDL_GetError());
+        
+        memcpy(surf->pixels, _screen->pixels, _screenWidth * _screenHeight * _screen->format->BytesPerPixel);
+        
+        // Unlock the screen surface
+        SDL_UnlockSurface(_screen);
+}
 
 void OSystem_SDL::addDirtyRect(int x, int y, int w, int h, bool mouseRect) {
         if (_forceFull)
@@ -982 +1000 @@
         // Some games blink cursors with palette
         if (!_overlayVisible && (!_cursorHasOwnPalette || _cursorPaletteDisabled))
                 blitCursor();
+}
+
+void OSystem_SDL::grabPalette(byte *colors, uint start, uint num) {
+        assert(colors); 
+        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) {

backends/sdl/sdl-common.h

@@ -78 +78 @@
 
         // 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
         void copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h);
+
+        // Copies the screen to a buffer
+        void grabRawScreen(Graphics::Surface *surf);
 
         // Clear the screen
         void clearScreen();

common/module.mk

@@ -21 +21 @@
         common/scaler/hq3x.o \
         common/scaler/scale2x.o \
         common/scaler/scale3x.o \
-        common/scaler/scalebit.o
+        common/scaler/scalebit.o \
+        common/scaler/thumbnail.o
 
 ifdef HAVE_NASM
 MODULE_OBJS += \

common/scaler/thumbnail.cpp

@@ +1 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2005 The ScummVM project
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header: $
+ *
+ */
+
+#include "stdafx.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+
+#include "scaler.h"
+#include "scaler/intern.h"
+
+template<int bitFormat>
+void createThumbnail_2(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height) {
+        for (int y = 0; y < height; y += 2) {
+                for (int x = 0; x < width; x += 2, dstPtr += 2) {
+                        uint16 colorx1y1 = *(((const uint16*)src) + x);
+                        uint16 colorx2y1 = *(((const uint16*)src) + x + 1);
+                        
+                        uint16 colorx1y2 = *(((const uint16*)(src + srcPitch)) + x);
+                        uint16 colorx2y2 = *(((const uint16*)(src + srcPitch)) + x + 1);
+                                
+                        *((uint16*)dstPtr) = Q_INTERPOLATE<bitFormat>(colorx1y1, colorx2y1, colorx1y2, colorx2y2);                      
+                }
+                dstPtr += (dstPitch - 320);
+                src += 2 * srcPitch;
+        }
+}
+
+template<int bitFormat>
+void createThumbnail_4(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height) {
+        for (int y = 0; y < height; y += 4) {
+                for (int x = 0; x < width; x += 4, dstPtr += 2) {
+                        uint16 colorx1y1 = *(((const uint16*)src) + x);
+                        uint16 colorx2y1 = *(((const uint16*)src) + x + 1);
+                        uint16 colorx3y1 = *(((const uint16*)src) + x + 2);
+                        uint16 colorx4y1 = *(((const uint16*)src) + x + 3);
+                        
+                        uint16 colorx1y2 = *(((const uint16*)(src + srcPitch)) + x);
+                        uint16 colorx2y2 = *(((const uint16*)(src + srcPitch)) + x + 1);
+                        uint16 colorx3y2 = *(((const uint16*)(src + srcPitch)) + x + 2);
+                        uint16 colorx4y2 = *(((const uint16*)(src + srcPitch)) + x + 3);
+                        
+                        uint16 colorx1y3 = *(((const uint16*)(src + srcPitch * 2)) + x);
+                        uint16 colorx2y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 1);
+                        uint16 colorx3y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 2);
+                        uint16 colorx4y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 3);
+                        
+                        uint16 colorx1y4 = *(((const uint16*)(src + srcPitch * 3)) + x);
+                        uint16 colorx2y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 1);
+                        uint16 colorx3y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 2);
+                        uint16 colorx4y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 3);
+                        
+                        uint16 upleft = Q_INTERPOLATE<bitFormat>(colorx1y1, colorx2y1, colorx1y2, colorx2y2);
+                        uint16 upright = Q_INTERPOLATE<bitFormat>(colorx3y1, colorx4y1, colorx3y2, colorx4y2);
+                        uint16 downleft = Q_INTERPOLATE<bitFormat>(colorx1y3, colorx2y3, colorx1y4, colorx2y4);
+                        uint16 downright = Q_INTERPOLATE<bitFormat>(colorx3y3, colorx4y3, colorx3y4, colorx4y4);
+                                
+                        *((uint16*)dstPtr) = Q_INTERPOLATE<bitFormat>(upleft, upright, downleft, downright);                    
+                }
+                dstPtr += (dstPitch - 320);
+                src += 4 * srcPitch;
+        }
+}
+
+void createThumbnail(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height) {
+        // only 1/2 and 1/4 downscale supported
+        if (width != 320 && width != 640)
+                return;
+        
+        int downScaleMode = (width == 320) ? 2 : 4;
+        
+        if (downScaleMode == 2) {
+                createThumbnail_2<565>(src, srcPitch, dstPtr, dstPitch, width, height);
+        } else if (downScaleMode == 4) {
+                createThumbnail_4<565>(src, srcPitch, dstPtr, dstPitch, width, height);
+        }
+}
+
+bool createThumbnailFromScreen(Graphics::Surface* surf) {
+        assert(surf);
+        
+        int screenWidth = OSystem::instance().getWidth();
+        int screenHeight = OSystem::instance().getHeight();
+        
+        Graphics::Surface screen;
+        OSystem::instance().grabScreen(&screen);
+        
+        if (!screen.pixels)
+                return false;
+
+        uint16 width = screenWidth;
+        
+        if (screenWidth < 320) {
+                width = 320;
+                
+                // center MM NES screen
+                Graphics::Surface newscreen;
+                newscreen.create(width, screen.h, screen.bytesPerPixel);
+                
+                uint8 *dst = (uint8*)newscreen.getBasePtr((320 - screenWidth) / 2, 0);
+                uint8 *src = (uint8*)screen.getBasePtr(0, 0);
+                uint16 height = screen.h;
+                
+                while (height--) {
+                        memcpy(dst, src, screen.pitch);
+                        dst += newscreen.pitch;
+                        src += screen.pitch;
+                }
+                
+                screen.free();
+                screen = newscreen;
+        }
+        
+        uint16 newHeight = !(screenHeight % 240) ? kThumbnailHeight_2 : kThumbnailHeight_1;
+        
+        surf->create(kThumbnailWidth, newHeight, sizeof(uint16));
+        createThumbnail((const uint8*)screen.pixels, width * sizeof(uint16), (uint8*)surf->pixels, surf->pitch, width, screenHeight);   
+        
+        screen.free();
+        
+        return true;
+}

common/scaler.h

@@ -23 +23 @@
 
 #include "common/stdafx.h"
 #include "common/scummsys.h"
+#include "graphics/surface.h"
 
 extern void InitScalers(uint32 BitFormat);
 
@@ -59 +60 @@
 
 extern int stretch200To240(uint8 *buf, uint32 pitch, int width, int height, int srcX, int srcY, int origSrcY);
 
+// creates a 160x100 thumbnail for 320x200 games
+// and 160x120 thumbnail for 320x240 and 640x480 games
+// only 565 mode
+enum {
+        kThumbnailWidth = 160,
+        kThumbnailHeight_1 = 100,
+        kThumbnailHeight_2 = 120
+};
+extern void createThumbnail(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height);
+
+/**
+ * creates a thumbnail from the current screen (without overlay)
+ * @param surf  a surface (will always have 16 bpp after this for now)
+ * @return              false if a error occured
+ */
+extern bool createThumbnailFromScreen(Graphics::Surface* surf);
 
 #endif

common/system.cpp

@@ -33 +33 @@
 #include "common/system.h"
 #include "common/util.h"
 
+#include "graphics/surface.h"
+
 DECLARE_SINGLETON(OSystem);
 
 OSystem *OSystem::makeInstance() {
@@ -91 +93 @@
 
 SaveFileManager *OSystem::getSavefileManager() {
         return new DefaultSaveFileManager();
+}
+
+void OSystem::grabScreen(Graphics::Surface *surf, int bitsPerPixel) {
+        Graphics::Surface screen;
+        grabRawScreen(&screen);
+        
+        if (screen.bytesPerPixel != 1 || screen.pixels == 0)
+                return;
+        
+        byte palette[256 * 4];
+        grabPalette(&palette[0], 0, 256);
+        
+        surf->create(screen.w, screen.h, (bitsPerPixel + 1) / 8);
+        
+        for (uint y = 0; y < screen.h; ++y) {
+                for (uint x = 0; x < screen.w; ++x) {
+                        byte r, g, b;
+                        r = palette[((uint8*)screen.pixels)[y * screen.pitch + x] * 4];
+                        g = palette[((uint8*)screen.pixels)[y * screen.pitch + x] * 4 + 1];
+                        b = palette[((uint8*)screen.pixels)[y * screen.pitch + x] * 4 + 2];
+                        
+                        if (bitsPerPixel == 15) {
+                                ((uint16*)surf->pixels)[y * surf->w + x] = (((r >> 3) & 0x1F) << 10) | (((g >> 3) & 0x1F) << 5) | ((b >> 3) & 0x1F);
+                        } else if (bitsPerPixel == 16) {
+                                ((uint16*)surf->pixels)[y * surf->w + x] = (((r >> 3) & 0x1F) << 11) | (((g >> 2) & 0x3F) << 5) | ((b >> 3) & 0x1F);
+                        } else if (bitsPerPixel == 24) {
+#ifdef SCUMM_BIG_ENDIAN
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel + 2] = r;
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel + 1] = g;
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel] = b;
+#else
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel] = r;
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel + 1] = g;
+                                ((uint8*)surf->pixels)[y * surf->pitch + x * surf->bytesPerPixel + 2] = b;
+#endif
+                        } else if (bitsPerPixel == 32) {
+                                ((uint32*)surf->pixels)[y * surf->w + x] = 0xFF << 24 | r << 16 | g << 8 | b << 8;
+                        }
+                }
+        }
+        
+        screen.free();
 }

common/system.h

@@ -28 +28 @@
 #include "common/rect.h"
 #include "common/singleton.h"
 
+namespace Graphics {
+class Surface;
+} // end of namespace Graphics
+
 class SaveFileManager;
 
 /**
@@ -347 +351 @@
          *       API are probably going to remove it.
          */
         virtual void setPalette(const byte *colors, uint start, uint num) = 0;
+        
+        /**
+         * Grabs a specified part of the palette
+         * format is like it is discribed in setPalette
+         *
+         * @param buf   the buffer
+         * @param start the first platte entry
+         * @param num   nummber of the entries
+         */
+        virtual void grabPalette(byte *colors, uint start, uint num) = 0;
 
         /**
          * Blit a bitmap to the virtual screen.
@@ -357 +371 @@
          * @see updateScreen
          */
         virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) = 0;
+
+        /**
+         * Copies the screen to a surface
+         * @param surf                  the surfce to store the data in it
+         * @param bitsPerPixel  must be higher than 15 and lower than 32
+         */
+        virtual void grabScreen(Graphics::Surface *surf, int bitsPerPixel = 16);
+        
+        /**
+         * Copies the screen to a surface (with original bit depth)
+         * It should return a 1 byte per pixel surface in all cases
+         * because currently all games supported by ScummVM are
+         * using 1 byte per pixel.
+         *
+         * @param surf  the surfce to store the data in it
+         */
+        virtual void grabRawScreen(Graphics::Surface *surf) = 0;
         
         /**
          * Clear the screen to black.

graphics/surface.cpp

@@ -24 +24 @@
 
 namespace Graphics {
 
+void Surface::create(uint16 width, uint16 height, uint8 bytesPP) {
+        free();
+        
+        w = width; h = height;
+        bytesPerPixel = bytesPP;
+        pitch = w * bytesPP;
+        
+        pixels = calloc(width * height, bytesPP);
+        assert(pixels);
+}
+
+void Surface::free() {
+        ::free(pixels);
+        pixels = 0;
+        w = h = pitch = 0;
+        bytesPerPixel = 0;
+}
+
 void Surface::hLine(int x, int y, int x2, uint32 color) const {
         // Clipping
         if (y < 0 || y >= h)

graphics/surface.h

@@ -43 +43 @@
                 return (void *)((byte *)pixels + y * pitch + x * bytesPerPixel);
         }
         
+        void create(uint16 width, uint16 height, uint8 bytesPP);
+        void free();
+        
         void hLine(int x, int y, int x2, uint32 color) const;
         void vLine(int x, int y, int y2, uint32 color) const;
         void fillRect(const Common::Rect &r, uint32 color) const;

gui/newgui.cpp

@@ -21 +21 @@
 #include "stdafx.h"
 #include "common/system.h"
 #include "common/util.h"
+#include "common/scaler.h"
 #include "gui/newgui.h"
 #include "gui/dialog.h"
 
@@ -434 +435 @@
                                         ptr[x] = color;
                 }
         }
+}
+
+//
+// Copies a Surface to the Overlay
+//
+void NewGui::drawSurface(const OverlayColor* data, int x, int y, int width, int height, int pitch) {
+        if(_scaleFactor == 1) {
+                uint8* dst = (uint8*)getBasePtr(x, y);  
+                for (int y_ = 0; y_ < height; ++y_, dst += _screen.pitch) {
+                        memcpy(dst, &((const uint8*)data)[y_ * pitch], width * sizeof(OverlayColor));
+                }
+        } else if(_scaleFactor == 2) {
+                Normal2x((const uint8*)data, pitch, (uint8*)getBasePtr(x * 2, y * 2), _screen.pitch, width, height);
+        }       
+        addDirtyRect(x, y, width, height);
 }
 
 //

gui/newgui.h

@@ -146 +146 @@
         int getFontHeight() const;
 
         void drawBitmap(uint32 *bitmap, int x, int y, OverlayColor color, int h = 8);
+        void drawSurface(const OverlayColor* data, int x, int y, int width, int height, int pitch);
 
         void addDirtyRect(int x, int y, int w, int h);
 };

gui/widget.cpp

@@ -24 +24 @@
 #include "gui/dialog.h"
 #include "gui/newgui.h"
 
-
 namespace GUI {
 
 Widget::Widget(GuiObject *boss, int x, int y, int w, int h)
@@ -258 +257 @@
 
 int SliderWidget::posToValue(int pos) {
         return (pos) * (_valueMax - _valueMin) / (_w - _labelWidth - 4) + _valueMin;
+}
+
+#pragma mark -
+
+GraphicsWidget::GraphicsWidget(GuiObject *boss, int x, int y, int w, int h)
+        : Widget(boss, x, y, w, h), _gfx(0), _gfxWidth(0), _gfxHeight(0), _bpp(0) {
+        _flags = WIDGET_ENABLED | WIDGET_CLEARBG; 
+        _type = kGraphicsWidget;
+}
+
+GraphicsWidget::~GraphicsWidget() {
+        delete [] _gfx;
+}
+
+void GraphicsWidget::setGfx(int width, int height, int bpp, const uint8 *data) {
+        delete [] _gfx;
+        _gfx = 0;
+        
+        if(!data)
+                return;
+        
+        _gfx = new uint8[width * height * bpp];
+        assert(_gfx);
+        
+        _gfxWidth = width;
+        _gfxHeight = height;
+        _bpp = bpp;
+
+        memcpy(_gfx, data, width * height * bpp);
+}
+
+void GraphicsWidget::drawWidget(bool hilite) {
+        if(sizeof(OverlayColor) != _bpp || !_gfx) {
+                g_gui.drawString("No preview", _x, _y + _h / 2 - g_gui.getFontHeight() / 2, _w, g_gui._textcolor, Graphics::kTextAlignCenter);
+                return;
+        }
+        
+        uint drawWidth = _gfxWidth, drawHeight = _gfxHeight;
+        
+        if(_w < _gfxWidth)
+                drawWidth = _w;
+        if(_h < _gfxHeight)
+                drawHeight = _h;
+        
+        g_gui.drawSurface((OverlayColor*)_gfx, _x, _y, drawWidth, drawHeight, _gfxWidth * _bpp);
 }
 
 } // End of namespace GUI

gui/widget.h

@@ -52 +52 @@
         kListWidget                     = 'LIST',
         kScrollBarWidget        = 'SCRB',
         kPopUpWidget            = 'POPU',
-        kTabWidget                      = 'TABW'
+        kTabWidget                      = 'TABW',
+        kGraphicsWidget         = 'GFXW'
 };
 
 enum {
@@ -208 +209 @@
 
         int valueToPos(int value);
         int posToValue(int pos);
+};
+
+/* GraphicsWidget */
+class GraphicsWidget : public Widget {
+public:
+        GraphicsWidget(GuiObject *boss, int x, int y, int w, int h);
+        ~GraphicsWidget();
+        
+        // bpp = _byte_ per pixel
+        void setGfx(int width, int height, int bpp, const uint8 *data);
+protected:
+        void drawWidget(bool hilite);
+        
+        uint8 *_gfx;
+        int _gfxWidth, _gfxHeight, _bpp;
 };
 
 } // End of namespace GUI

scumm/dialogs.cpp

@@ -22 +22 @@
 
 #include "common/config-manager.h"
 #include "common/system.h"
+#include "common/scaler.h"
 
 #include "gui/chooser.h"
 #include "gui/newgui.h"
@@ -147 +148 @@
 
 #pragma mark -
 
-
 const Common::String ScummDialog::queryResString(int stringno) {
         byte buf[256];
         byte *result;
@@ -199 +199 @@
         kQuitCmd = 'QUIT'
 };
 
-class SaveLoadChooser : public GUI::ChooserDialog {
+class SaveLoadChooser : public GUI::ChooserDialog, public ScummSaveLoadChooser {
         typedef Common::String String;
         typedef Common::StringList StringList;
 protected:
@@ -210 +210 @@
         
         virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
         const String &getResultString() const;
+        void setList(const StringList& list) { GUI::ChooserDialog::setList(list); }
+        int runModal() { return GUI::ChooserDialog::runModal(); }
 };
 
 SaveLoadChooser::SaveLoadChooser(const String &title, const String &buttonLabel, bool saveMode)
@@ -250 +252 @@
         }
 }
 
+#pragma mark -
+
+enum {
+        kChooseCmd = 'Chos'
+};
+
+// only for use with >= 640x400 resolutions
+class SaveLoadChooserEx : public GUI::Dialog, public ScummSaveLoadChooser {
+        typedef Common::String String;
+        typedef Common::StringList StringList;
+protected:
+        bool _saveMode;
+        GUI::ListWidget         *_list;
+        GUI::ButtonWidget       *_chooseButton;
+        GUI::GraphicsWidget     *_gfxWidget;
+        ScummEngine                     *_scumm;
+
+public:
+        SaveLoadChooserEx(const String &title, const String &buttonLabel, bool saveMode, ScummEngine *engine);
+        
+        virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
+        const String &getResultString() const;  
+        void setList(const StringList& list);
+        int runModal();
+};
+
+SaveLoadChooserEx::SaveLoadChooserEx(const String &title, const String &buttonLabel, bool saveMode, ScummEngine *engine)
+        : Dialog(8, 8, engine->_system->getOverlayWidth() - 2 * 8, engine->_system->getOverlayHeight() - 16), _saveMode(saveMode), _list(0), _chooseButton(0), _gfxWidget(0), _scumm(engine) {
+        
+        new StaticTextWidget(this, 10, 6, _w - 2 * 10, kLineHeight, title, kTextAlignCenter);
+        
+        // Add choice list
+        _list = new GUI::ListWidget(this, 10, 18, _w - 2 * 10 - 180, _h - 14 - 24 - 10);
+        _list->setEditable(saveMode);
+        _list->setNumberingMode(saveMode ? GUI::kListNumberingOne : GUI::kListNumberingZero);
+        
+        // Add the thumbnail displayer
+        _gfxWidget = new GUI::GraphicsWidget(this, _w - (kThumbnailWidth + 22), _y + 6, kThumbnailWidth + 8, ((_scumm->_system->getHeight() % 200) ? kThumbnailHeight_2 : kThumbnailHeight_1) + 8);
+        _gfxWidget->setFlags(GUI::WIDGET_BORDER);
+        
+        // Buttons
+        addButton(_w - 2 * (kButtonWidth + 10), _h - 24, "Cancel", kCloseCmd, 0);
+        _chooseButton = addButton(_w-(kButtonWidth + 10), _h - 24, buttonLabel, kChooseCmd, 0);
+        _chooseButton->setEnabled(false);
+}
+
+const Common::String &SaveLoadChooserEx::getResultString() const {
+        return _list->getSelectedString();
+}
+
+void SaveLoadChooserEx::setList(const StringList& list) {
+        _list->setList(list);
+}
+
+int SaveLoadChooserEx::runModal() {
+        g_gui.enableScaling(false);
+        _gfxWidget->setGfx(0, 0, 0, 0);
+        int ret = GUI::Dialog::runModal();
+        g_gui.enableScaling(true);
+        return ret;
+}
+
+void SaveLoadChooserEx::handleCommand(CommandSender *sender, uint32 cmd, uint32 data) {
+        int selItem = _list->getSelected();
+        switch (cmd) {
+        case GUI::kListItemActivatedCmd:
+        case GUI::kListItemDoubleClickedCmd:
+                if (selItem >= 0) {
+                        if (_saveMode || !getResultString().isEmpty()) {
+                                _list->endEditMode();
+                                setResult(selItem);
+                                close();
+                        }
+                }
+                break;
+        case kChooseCmd:
+                _list->endEditMode();
+                setResult(selItem);
+                close();
+                break;
+        case GUI::kListSelectionChangedCmd:
+                _scumm->getThumbnail(_saveMode ? selItem + 1 : selItem);
+                _gfxWidget->setGfx(_scumm->getThumbnailWidth(), _scumm->getThumbnailHeight(), 2, (const uint8*)_scumm->getThumbnail());
+                _gfxWidget->draw();
+
+                if (_saveMode) {
+                        _list->startEditMode();
+                }
+                // Disable button if nothing is selected, or (in load mode) if an empty
+                // list item is selected. We allow choosing an empty item in save mode
+                // because we then just assign a default name.
+                _chooseButton->setEnabled(selItem >= 0 && (_saveMode || !getResultString().isEmpty()));
+                _chooseButton->draw();
+                break;
+        case kCloseCmd:
+                setResult(-1);
+        default:
+                GUI::Dialog::handleCommand(sender, cmd, data);
+        }
+}
+
+#pragma mark -
+
 Common::StringList generateSavegameList(ScummEngine *scumm, bool saveMode) {
         // Get savegame names
         Common::StringList l;
@@ -308 +413 @@
 #ifndef DISABLE_HELP
         _helpDialog = new HelpDialog(scumm);
 #endif
-        _saveDialog = new SaveLoadChooser("Save game:", "Save", true);
-        _loadDialog = new SaveLoadChooser("Load game:", "Load", false);
+        if(scumm->_system->getOverlayWidth() <= 320) {
+                _saveDialog = new SaveLoadChooser("Save game:", "Save", true);
+                _loadDialog = new SaveLoadChooser("Load game:", "Load", false);
+        } else {
+                _saveDialog = new SaveLoadChooserEx("Save game:", "Save", true, scumm);
+                _loadDialog = new SaveLoadChooserEx("Load game:", "Load", false, scumm);
+        }
 }
 
 MainMenuDialog::~MainMenuDialog() {

scumm/dialogs.h

@@ -54 +54 @@
         const String queryResString(int stringno);
 };
 
-class SaveLoadChooser;
+// to have a base for all different Save/Load Choosers
+// currently only for SaveLoadChooser (320x200)
+// and for SaveLoadChooserEx (640x400/640x480)
+class ScummSaveLoadChooser
+{
+public:
+        virtual ~ScummSaveLoadChooser() {};
+        
+        virtual const Common::String &getResultString() const = 0;
+        virtual void setList(const Common::StringList& list) = 0;
+        virtual int runModal() = 0;
+};
 
 class MainMenuDialog : public ScummDialog {
 public:
@@ -68 +79 @@
 #ifndef DISABLE_HELP
         GUI::Dialog             *_helpDialog;
 #endif
-        SaveLoadChooser *_saveDialog;
-        SaveLoadChooser *_loadDialog;
+        ScummSaveLoadChooser    *_saveDialog;
+        ScummSaveLoadChooser    *_loadDialog;
 
         void save();
         void load();

scumm/module.mk

@@ -78 +78 @@
         scumm/smush/smush_player.o \
         scumm/smush/saud_channel.o \
         scumm/smush/smush_mixer.o \
-        scumm/smush/smush_font.o
+        scumm/smush/smush_font.o \
+        scumm/thumbnail.o
 
 MODULE_DIRS += \
         scumm \

scumm/saveload.cpp

@@ -83 +83 @@
         hdr.ver = TO_LE_32(CURRENT_VER);
 
         out->write(&hdr, sizeof(hdr));
+        saveThumbnail(out);
 
         Serializer ser(0, out, CURRENT_VER);
         saveOrLoad(&ser, CURRENT_VER);
@@ -120 +121 @@
                 delete in;
                 return false;
         }
+        
+        // Sine version 49 a thumbnail is saved directly after the header
+        if (hdr.ver >= VER(49)) {
+                if(!loadThumbnail(in)) {
+                        warning("Can not load thumbnail");
+                        delete in;
+                        return false;
+                }
+        }
 
         // Due to a bug in scummvm up to and including 0.3.0, save games could be saved
         // in the V8/V9 format but were tagged with a V7 mark. Ouch. So we just pretend V7 == V8 here
@@ -375 +385 @@
 
         memcpy(desc, hdr.name, sizeof(hdr.name));
         desc[sizeof(hdr.name) - 1] = 0;
+        return true;
+}
+
+bool ScummEngine::getThumbnail(int slot) {
+        char filename[256];
+        InSaveFile *in;
+        SaveGameHeader hdr;
+        int len;
+        
+        if (_thumbnail)
+                _thumbnail->free();
+        delete _thumbnail;
+        _thumbnail = 0;
+
+        makeSavegameName(filename, slot, false);
+        if (!(in = _saveFileMan->openForLoading(filename))) {
+                return false;
+        }
+        len = in->read(&hdr, sizeof(hdr));
+
+        if (len != sizeof(hdr) || hdr.type != MKID('SCVM')) {
+                delete in;
+                return false;
+        }
+
+        if (hdr.ver > CURRENT_VER)
+                hdr.ver = TO_LE_32(hdr.ver);
+        if (hdr.ver < VER(49)) {
+                delete in;
+                return false;
+        }
+
+        loadThumbnail(in);
+
+        delete in;
         return true;
 }
 

scumm/saveload.h

@@ -33 +33 @@
 // Can be useful for other ports too :)
 
 #define VER(x) x
-#define CURRENT_VER 48
+#define CURRENT_VER 49
 
 // To work around a warning in GCC 3.2 (and 3.1 ?) regarding non-POD types,
 // we use a small trick: instead of 0 we use 42. Why? Well, it seems newer GCC

scumm/scumm.cpp

@@ -618 +618 @@
           _features(gs.features),
           gdi(this),
           res(this),
-          _pauseDialog(0), _mainMenuDialog(0), _versionDialog(0),
+          _pauseDialog(0), _mainMenuDialog(0), _versionDialog(0), _thumbnail(0),
           _targetName(detector->_targetName) {
 
         // Copy MD5 checksum

scumm/scumm.h

@@ -28 +28 @@
 #include "common/map.h"
 #include "common/rect.h"
 #include "common/str.h"
+#include "graphics/surface.h"
 
 #include "scumm/gfx.h"
 #include "scumm/script.h"
 
+// FIXME:
+// define it in a other location
+#define THMB_VERSION 1
+
 namespace GUI {
         class Dialog;
 }
 using GUI::Dialog;
 class GameDetector;
-
+class InSaveFile;
+class OutSaveFile;
 
 namespace Scumm {
 
@@ -593 +599 @@
         
         void requestSave(int slot, const char *name, bool temporary = false);
         void requestLoad(int slot);
+
+// thumbnail stuff
+public:
+        bool getThumbnail(int slot);
+        const void* getThumbnail() { if(_thumbnail) return _thumbnail->pixels; return 0; }
+        uint16 getThumbnailHeight() { if(_thumbnail) return _thumbnail->h; return 0; }
+        uint16 getThumbnailWidth() { if(_thumbnail) return _thumbnail->w; return 0; }
+
+protected:
+        bool loadThumbnail(InSaveFile *file);
+        void saveThumbnail(OutSaveFile *file);
+        
+        Graphics::Surface *_thumbnail;
+        
+        struct ThumbnailHeader {
+                uint32 type;
+                uint32 size;
+                byte version;
+                uint16 width, height;
+                byte bpp;
+        };
+// ends here
 
 protected:
         /* Script VM - should be in Script class */

scumm/thumbnail.cpp

@@ +1 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001-2005 The ScummVM project
+ *
+ * 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 file 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header: $
+ *
+ */
+ 
+#include "common/stdafx.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/savefile.h"
+#include "common/scaler.h"
+#include "scumm.h"
+
+namespace Scumm {
+inline uint16 RGBToColor(const uint8 r, const uint8 g, const uint8 b) {
+        return ((((r >> 3) & 0x1F) << 11) | (((g >> 2) & 0x3F) << 5) | ((b >> 3) & 0x1F));
+}
+
+inline void colorToRGB(uint16 color, uint8 &r, uint8 &g, uint8 &b) {
+        r = (((color >> 11) & 0x1F) << 3);
+        g = (((color >> 5) & 0x3F) << 2);
+        b = ((color&0x1F) << 3);
+}
+
+bool ScummEngine::loadThumbnail(InSaveFile *file) {
+        if (_thumbnail)
+                _thumbnail->free();
+        delete _thumbnail;      
+        _thumbnail = 0;
+
+        ThumbnailHeader header;
+        header.type = file->readUint32BE();
+        if(header.type != MKID('THMB'))
+                return false;
+
+        header.size = file->readUint32BE();
+        header.version = file->readByte();
+
+        if (header.version > THMB_VERSION) {
+                // TODO: maybe add a skip method to the SaveFile class to get rid of this
+                byte *buf = new byte[header.size - sizeof(uint32) * 2 - sizeof(byte)];
+                file->read(buf, header.size - sizeof(uint32) * 2 - sizeof(byte));
+                delete [] buf;  
+                warning("Loading a newer thumbnail version");
+                return true;
+        }
+
+        header.width = file->readUint16BE();
+        header.height = file->readUint16BE();
+        header.bpp = file->readByte();
+        
+        // TODO: support other bpp values than 2
+        if(header.bpp != 2) {
+                // skip all data
+                // TODO: maybe add a skip method to the SaveFile class to get rid of this
+                byte *buf = new byte[header.width * header.height * header.bpp];
+                file->read(buf, header.width * header.height * header.bpp);
+                delete [] buf;
+                return true;
+        }       
+        
+        _thumbnail = new Graphics::Surface();
+        _thumbnail->create(header.width, header.height, sizeof(uint16));
+        for (uint16 p = 0; p <_thumbnail->w*_thumbnail->h; ++p)
+                ((uint16*)_thumbnail->pixels)[p] = file->readUint16BE();
+
+        uint16* pixels = (uint16*)_thumbnail->pixels;
+
+        for (int y = 0; y < _thumbnail->h; ++y) {
+                for (int x = 0; x < _thumbnail->w; ++x) {
+                        uint8 r, g, b;
+                        colorToRGB(((const uint16*)pixels)[y * _thumbnail->w + x], r, g, b);
+                        
+                        // converting to current OSystem Color
+                        pixels[y * _thumbnail->w + x] = _system->RGBToColor(r, g, b);
+                }
+        }
+
+        return true;
+}
+
+void ScummEngine::saveThumbnail(OutSaveFile *file) {
+        if (_thumbnail)
+                _thumbnail->free();
+        else if (!_thumbnail)
+                _thumbnail = new Graphics::Surface();
+ 
+        if (!createThumbnailFromScreen(_thumbnail))
+                _thumbnail->create(kThumbnailWidth, kThumbnailHeight_2, sizeof(uint16));
+        
+        ThumbnailHeader header;
+        header.type = MKID('THMB');
+        header.size = sizeof(header) + _thumbnail->w*_thumbnail->h*_thumbnail->bytesPerPixel;
+        header.version = THMB_VERSION;
+        header.width = _thumbnail->w;
+        header.height = _thumbnail->h;
+        header.bpp = _thumbnail->bytesPerPixel;
+
+        file->writeUint32BE(header.type);
+        file->writeUint32BE(header.size);
+        file->writeByte(header.version);
+        file->writeUint16BE(header.width);
+        file->writeUint16BE(header.height);
+        file->writeByte(header.bpp);
+        
+        // TODO: for later this shouldn't be hardcastet to uint16...
+        for (uint16 p = 0; p < _thumbnail->w*_thumbnail->h; ++p)
+                file->writeUint16BE(((uint16*)_thumbnail->pixels)[p]);
+
+        if (_thumbnail)
+                _thumbnail->free();
+        delete _thumbnail;
+        _thumbnail = 0;
+}
+} // end of namespace Scumm