Ticket #8405: thumbnails-v3.patch

backends/sdl/graphics.cpp

@@ -720 +720 @@
         }
 }
 
+void OSystem_SDL::grabScreen(byte* buf) {
+        assert(buf); assert(_screen);
+        Common::StackLock lock(_graphicsMutex);
+        
+        memcpy(buf, _screen->pixels, sizeof(byte) * _screenWidth * _screenHeight);      
+}
+
 void OSystem_SDL::clearScreen() {
         assert (_transactionMode == kTransactionNone);
 

backends/sdl/sdl-common.h

@@ -67 +67 @@
         // 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 grabScreen(byte *buf);
+
         // 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 "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;
+                
+        const 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);
+        }
+}

common/scaler.h

@@ -59 +59 @@
 
 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
+extern void createThumbnail(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height);
+
 enum {
         GFX_NORMAL = 0,
         GFX_DOUBLESIZE = 1,

common/system.h

@@ -290 +290 @@
          * @see updateScreen
          */
         virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) = 0;
+
+        /**
+         * Copies the screen to a buffer
+         */
+        virtual void grabScreen(byte *buf) {}
         
         /**
          * Clear the screen to black.

config.h

@@ +1 @@
+/* This file is automatically generated by configure */
+/* DO NOT EDIT MANUALLY */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#define SCUMM_LITTLE_ENDIAN
+#undef SCUMM_NEED_ALIGNMENT
+#define HAVE_X86
+
+#undef LINUPY
+
+/* Data types */
+typedef unsigned char byte;
+typedef unsigned int uint;
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint32;
+typedef signed char int8;
+typedef signed short int16;
+typedef signed int int32;
+
+/* Libs */
+#define USE_VORBIS
+#undef USE_FLAC
+#define USE_MAD
+#define USE_ALSA
+#define USE_ZLIB
+#define USE_MPEG2
+#define USE_MT32EMU
+
+/* Whether we should use i386 assembly routines */
+#define USE_NASM
+
+/* Plugin settings */
+
+
+#endif /* CONFIG_H */

gui/ListWidget.cpp

@@ -380 +380 @@
 }
 
 void ListWidget::endEditMode() {
+        if(!_editMode)
+                return;
         // send a message that editing finished with a return/enter key press
         _editMode = false;
         _list[_selectedItem] = _editString;

gui/ListWidget.h

@@ -86 +86 @@
 
         // Made startEditMode for SCUMM's SaveLoadChooser
         void startEditMode();
+        void endEditMode();
 
 protected:
         void drawWidget(bool hilite);
@@ -93 +94 @@
         int findItem(int x, int y) const;
         void scrollBarRecalc();
 
-        void endEditMode();
         void abortEditMode();
         
         Common::Rect getEditRect() 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"
 
@@ -405 +406 @@
 }
 
 //
+// 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);
+}
+
+//
 // Draw the mouse cursor (animated). This is mostly ripped from the cursor code in gfx.cpp
 // We could plug in a different cursor here if we like to.
 //

gui/newgui.cpp.orig

@@ +1 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002-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: /cvsroot/scummvm/scummvm/gui/newgui.cpp,v 1.105 2005/03/25 22:11:07 sev Exp $
+ */
+
+#include "stdafx.h"
+#include "common/system.h"
+#include "common/util.h"
+#include "gui/newgui.h"
+#include "gui/dialog.h"
+
+
+DECLARE_SINGLETON(GUI::NewGui);
+
+namespace GUI {
+
+/*
+ * TODO list
+ * - add more widgets: edit field, popup, radio buttons, ...
+ *
+ * Other ideas:
+ * - allow multi line (l/c/r aligned) text via StaticTextWidget ?
+ * - add "close" widget to all dialogs (with a flag to turn it off) ?
+ * - make dialogs "moveable" ?
+ * - come up with a new look & feel / theme for the GUI
+ * - ...
+ */
+
+enum {
+        kDoubleClickDelay = 500, // milliseconds
+        kCursorAnimateDelay = 250,
+        kKeyRepeatInitialDelay = 400,
+        kKeyRepeatSustainDelay = 100
+};
+
+
+// Constructor
+NewGui::NewGui() : _scaleEnable(true), _needRedraw(false),
+        _stateIsSaved(false), _font(0), _cursorAnimateCounter(0), _cursorAnimateTimer(0) {
+
+        _system = &OSystem::instance();
+
+        // Clear the cursor
+        memset(_cursor, 0xFF, sizeof(_cursor));
+
+        // Reset key repeat
+        _currentKeyDown.keycode = 0;
+
+        // updates the scaling factor
+        updateScaleFactor();
+}
+
+void NewGui::updateColors() {
+        // Setup some default GUI colors.
+        _bgcolor = _system->RGBToColor(0, 0, 0);
+        _color = _system->RGBToColor(104, 104, 104);
+        _shadowcolor = _system->RGBToColor(64, 64, 64);
+        _textcolor = _system->RGBToColor(32, 160, 32);
+        _textcolorhi = _system->RGBToColor(0, 255, 0);
+}
+
+void NewGui::updateScaleFactor() {
+        if(!_scaleEnable) {
+                _scaleFactor = 1;
+        } else {
+                enum {
+                        kDefaultGUIWidth = 320,
+                        kDefaultGUIHeight = 200
+                };
+        
+                // NES has 256 pixels width which makes MIN() return 0 here.
+                _scaleFactor = MAX(MIN(_system->getOverlayWidth() / kDefaultGUIWidth, _system->getOverlayHeight() / kDefaultGUIHeight), 1);
+        }
+
+        // Pick the font depending on the scale factor.
+        if (_scaleFactor == 1)
+                _font = FontMan.getFontByUsage(Graphics::FontManager::kGUIFont);
+        else
+                _font = FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont);
+}
+
+void NewGui::runLoop() {
+        Dialog *activeDialog = _dialogStack.top();
+        bool didSaveState = false;
+        int button;
+
+        if (activeDialog == 0)
+                return;
+
+        // Setup some default GUI colors. Normally this will be done whenever an
+        // EVENT_SCREEN_CHANGED is received. However, not yet all backends support
+        // that event, so we also do it "manually" whenever a run loop is entered.
+        updateColors();
+        updateScaleFactor();
+
+        if (!_stateIsSaved) {
+                saveState();
+                didSaveState = true;
+        }
+
+        while (!_dialogStack.empty() && activeDialog == _dialogStack.top()) {
+                activeDialog->handleTickle();
+
+                if (_needRedraw) {
+                        // Restore the overlay to its initial state, then draw all dialogs.
+                        // This is necessary to get the blending right.
+                        _system->clearOverlay();
+                        _system->grabOverlay((OverlayColor *)_screen.pixels, _screenPitch);
+                        for (int i = 0; i < _dialogStack.size(); i++)
+                                _dialogStack[i]->drawDialog();
+                        _needRedraw = false;
+                }
+
+                animateCursor();
+                _system->updateScreen();
+
+                OSystem::Event event;
+                uint32 time = _system->getMillis();
+
+                while (_system->pollEvent(event)) {
+                        Common::Point mouse(event.mouse.x - (activeDialog->_x * _scaleFactor), event.mouse.y - (activeDialog->_y * _scaleFactor));
+                        mouse.x /= _scaleFactor;
+                        mouse.y /= _scaleFactor;
+                        
+                        switch (event.type) {
+                        case OSystem::EVENT_KEYDOWN:
+#if !defined(__PALM_OS__)
+                                // init continuous event stream
+                                // not done on PalmOS because keyboard is emulated and keyup is not generated
+                                _currentKeyDown.ascii = event.kbd.ascii;
+                                _currentKeyDown.keycode = event.kbd.keycode;
+                                _currentKeyDown.flags = event.kbd.flags;
+                                _keyRepeatTime = time + kKeyRepeatInitialDelay;
+#endif
+                                activeDialog->handleKeyDown(event.kbd.ascii, event.kbd.keycode, event.kbd.flags);
+                                break;
+                        case OSystem::EVENT_KEYUP:
+                                activeDialog->handleKeyUp(event.kbd.ascii, event.kbd.keycode, event.kbd.flags);
+                                if (event.kbd.keycode == _currentKeyDown.keycode)
+                                        // only stop firing events if it's the current key
+                                        _currentKeyDown.keycode = 0;
+                                break;
+                        case OSystem::EVENT_MOUSEMOVE:
+                                activeDialog->handleMouseMoved(mouse.x, mouse.y, 0);
+                                break;
+                        // We don't distinguish between mousebuttons (for now at least)
+                        case OSystem::EVENT_LBUTTONDOWN:
+                        case OSystem::EVENT_RBUTTONDOWN:
+                                button = (event.type == OSystem::EVENT_LBUTTONDOWN ? 1 : 2);
+                                if (_lastClick.count && (time < _lastClick.time + kDoubleClickDelay)
+                                                        && ABS(_lastClick.x - event.mouse.x) < 3
+                                                        && ABS(_lastClick.y - event.mouse.y) < 3) {
+                                        _lastClick.count++;
+                                } else {
+                                        _lastClick.x = event.mouse.x;
+                                        _lastClick.y = event.mouse.y;
+                                        _lastClick.count = 1;
+                                }
+                                _lastClick.time = time;
+                                activeDialog->handleMouseDown(mouse.x, mouse.y, button, _lastClick.count);
+                                break;
+                        case OSystem::EVENT_LBUTTONUP:
+                        case OSystem::EVENT_RBUTTONUP:
+                                button = (event.type == OSystem::EVENT_LBUTTONUP ? 1 : 2);
+                                activeDialog->handleMouseUp(mouse.x, mouse.y, button, _lastClick.count);
+                                break;
+                        case OSystem::EVENT_WHEELUP:
+                                activeDialog->handleMouseWheel(mouse.x, mouse.y, -1);
+                                break;
+                        case OSystem::EVENT_WHEELDOWN:
+                                activeDialog->handleMouseWheel(mouse.x, mouse.y, 1);
+                                break;
+                        case OSystem::EVENT_QUIT:
+                                _system->quit();
+                                return;
+                        case OSystem::EVENT_SCREEN_CHANGED:
+                                updateColors();
+                                updateScaleFactor();
+                                activeDialog->handleScreenChanged();
+                                break;
+                        }
+                }
+
+                // check if event should be sent again (keydown)
+                if (_currentKeyDown.keycode != 0) {
+                        if (_keyRepeatTime < time) {
+                                // fire event
+                                activeDialog->handleKeyDown(_currentKeyDown.ascii, _currentKeyDown.keycode, _currentKeyDown.flags);
+                                _keyRepeatTime = time + kKeyRepeatSustainDelay;
+                        }
+                }
+
+                // Delay for a moment
+                _system->delayMillis(10);
+        }
+
+        if (didSaveState)
+                restoreState();
+}
+
+#pragma mark -
+
+void NewGui::saveState() {
+
+        // Backup old cursor
+        _oldCursorMode = _system->showMouse(true);
+
+        // Enable the overlay
+        _system->showOverlay();
+
+        // Create a screen buffer for the overlay data, and fill it with
+        // whatever is visible on the screen rught now.
+        _screen.h = _system->getOverlayHeight();
+        _screen.w = _system->getOverlayWidth();
+        _screen.bytesPerPixel = sizeof(OverlayColor);
+        _screen.pitch = _screen.w * _screen.bytesPerPixel;
+        _screenPitch = _screen.w;
+        _screen.pixels = (OverlayColor*)calloc(_screen.w * _screen.h, sizeof(OverlayColor));
+
+        _system->grabOverlay((OverlayColor *)_screen.pixels, _screenPitch);
+
+        _currentKeyDown.keycode = 0;
+        _lastClick.x = _lastClick.y = 0;
+        _lastClick.time = 0;
+        _lastClick.count = 0;
+
+        _stateIsSaved = true;
+}
+
+void NewGui::restoreState() {
+        _system->showMouse(_oldCursorMode);
+
+        _system->hideOverlay();
+        if (_screen.pixels) {
+                free(_screen.pixels);
+                _screen.pixels = 0;
+        }
+
+        _system->updateScreen();
+
+        _stateIsSaved = false;
+}
+
+void NewGui::openDialog(Dialog *dialog) {
+        _dialogStack.push(dialog);
+        _needRedraw = true;
+}
+
+void NewGui::closeTopDialog() {
+        // Don't do anything if no dialog is open
+        if (_dialogStack.empty())
+                return;
+
+        // Remove the dialog from the stack
+        _dialogStack.pop();
+        _needRedraw = true;
+}
+
+#pragma mark -
+
+const Graphics::Font &NewGui::getFont() const {
+        return *_font;
+}
+
+OverlayColor *NewGui::getBasePtr(int x, int y) {
+        return (OverlayColor *)_screen.getBasePtr(x, y);
+}
+
+void NewGui::box(int x, int y, int width, int height, OverlayColor colorA, OverlayColor colorB) {
+        hLine(x + 1, y, x + width - 2, colorA);
+        hLine(x, y + 1, x + width - 1, colorA);
+        vLine(x, y + 1, y + height - 2, colorA);
+        vLine(x + 1, y, y + height - 1, colorA);
+
+        hLine(x + 1, y + height - 2, x + width - 1, colorB);
+        hLine(x + 1, y + height - 1, x + width - 2, colorB);
+        vLine(x + width - 1, y + 1, y + height - 2, colorB);
+        vLine(x + width - 2, y + 1, y + height - 1, colorB);
+}
+
+void NewGui::hLine(int x, int y, int x2, OverlayColor color) {
+        _screen.hLine(x * _scaleFactor, y * _scaleFactor, x2 * _scaleFactor, color);
+}
+
+void NewGui::vLine(int x, int y, int y2, OverlayColor color) {
+        _screen.vLine(x * _scaleFactor, y * _scaleFactor, y2 * _scaleFactor, color);
+}
+
+void NewGui::blendRect(int x, int y, int w, int h, OverlayColor color, int level) {
+#ifdef NEWGUI_256
+        fillRect(x, y, w, h, color);
+#else
+        Common::Rect rect(x * _scaleFactor, y * _scaleFactor, (x + w) * _scaleFactor, (y + h) * _scaleFactor);
+        rect.clip(_screen.w, _screen.h);
+
+        if (!rect.isValidRect())
+                return;
+
+        int r, g, b;
+        uint8 ar, ag, ab;
+        _system->colorToRGB(color, ar, ag, ab);
+        r = ar * level;
+        g = ag * level;
+        b = ab * level;
+
+        OverlayColor *ptr = getBasePtr(rect.left, rect.top);
+
+        h = rect.height();
+        w = rect.width();
+        while (h--) {
+                for (int i = 0; i < w; i++) {
+                        _system->colorToRGB(ptr[i], ar, ag, ab);
+                        ptr[i] = _system->RGBToColor((ar + r) / (level+1),
+                                                                                 (ag + g) / (level+1),
+                                                                                 (ab + b) / (level+1));
+                }
+                ptr += _screenPitch;
+        }
+#endif
+}
+
+void NewGui::fillRect(int x, int y, int w, int h, OverlayColor color) {
+        _screen.fillRect(Common::Rect(x * _scaleFactor, y * _scaleFactor, (x+w) * _scaleFactor, (y+h) * _scaleFactor), color);
+}
+
+void NewGui::frameRect(int x, int y, int w, int h, OverlayColor color) {
+        _screen.frameRect(Common::Rect(x * _scaleFactor, y * _scaleFactor, (x+w) * _scaleFactor, (y+h) * _scaleFactor), color);
+}
+
+void NewGui::addDirtyRect(int x, int y, int w, int h) {
+        Common::Rect rect(x * _scaleFactor, y * _scaleFactor, (x + w) * _scaleFactor, (y + h) * _scaleFactor);
+        rect.clip(_screen.w, _screen.h);
+
+        if (!rect.isValidRect())
+                return;
+
+        // For now we don't keep yet another list of dirty rects but simply
+        // blit the affected area directly to the overlay. At least for our current
+        // GUI/widget/dialog code that is just fine.
+        OverlayColor *buf = getBasePtr(rect.left, rect.top);
+        _system->copyRectToOverlay(buf, _screenPitch, rect.left, rect.top, rect.width(), rect.height());
+}
+
+void NewGui::drawChar(byte chr, int xx, int yy, OverlayColor color, const Graphics::Font *font) {
+        if (font == 0)
+                font = &getFont();
+        font->drawChar(&_screen, chr, xx * _scaleFactor, yy * _scaleFactor, color);
+}
+
+int NewGui::getStringWidth(const String &str) const {
+        return getFont().getStringWidth(str) / _scaleFactor;
+}
+
+int NewGui::getCharWidth(byte c) const {
+        return getFont().getCharWidth(c) / _scaleFactor;
+}
+
+int NewGui::getFontHeight() const {
+        return getFont().getFontHeight() / _scaleFactor;
+}
+
+void NewGui::drawString(const String &s, int x, int y, int w, OverlayColor color, TextAlignment align, int deltax, bool useEllipsis) {
+        getFont().drawString(&_screen, s, x * _scaleFactor, y * _scaleFactor, w * _scaleFactor, color, align, deltax, useEllipsis);
+}
+
+//
+// Draw an 8x8 bitmap at location (x,y)
+//
+void NewGui::drawBitmap(uint32 *bitmap, int tx, int ty, OverlayColor color, int h) {
+        tx *= _scaleFactor; ty *= _scaleFactor;
+        h *= _scaleFactor;
+        OverlayColor *ptr = getBasePtr(tx, ty);
+
+        for (int y = 0; y < h; y++, ptr += _screenPitch) {
+                uint32 mask = 0xF0000000;
+                if (ty + y < 0 || ty + y >= _screen.h)
+                        continue;
+                for (int x = 0; x < 8 * _scaleFactor; x++) {
+                        if(!(x % 2) && _scaleFactor != 1 && x != 0)
+                                mask >>= 4;
+                        else if(_scaleFactor == 1)
+                                mask >>= 4;
+
+                        if (tx + x < 0 || tx + x >= _screen.w)
+                                continue;
+                        if (bitmap[y / _scaleFactor] & mask)
+                                        ptr[x] = color;
+                }
+        }
+}
+
+//
+// Draw the mouse cursor (animated). This is mostly ripped from the cursor code in gfx.cpp
+// We could plug in a different cursor here if we like to.
+//
+void NewGui::animateCursor() {
+        int time = _system->getMillis();
+        if (time > _cursorAnimateTimer + kCursorAnimateDelay) {
+                const byte colors[4] = { 15, 15, 7, 8 };
+                const byte color = colors[_cursorAnimateCounter];
+                int i;
+
+                for (i = 0; i < 15; i++) {
+                        if ((i < 6) || (i > 8)) {
+                                _cursor[16 * 7 + i] = color;
+                                _cursor[16 * i + 7] = color;
+                        }
+                }
+
+                _system->setMouseCursor(_cursor, 16, 16, 7, 7);
+
+                _cursorAnimateTimer = time;
+                _cursorAnimateCounter = (_cursorAnimateCounter + 1) % 4;
+        }
+}
+
+} // End of namespace GUI

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)
@@ -260 +259 @@
         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 {
@@ -210 +211 @@
         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
 
 #endif

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 - 182, _y + 6, 168, (_scumm->_system->getHeight() % 200) ? 128 : 108);
+        _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);
+        
+        _scumm->_hasThumbnail = 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);
+        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->loadThumbnailFromSlot(_saveMode ? selItem + 1 : selItem);
+                _gfxWidget->setGfx(160, (_scumm->_system->getHeight() % 200) ? 120 : 100, 2, _scumm->_hasThumbnail == true ? (const uint8*)_scumm->getThumbnail() : 0);
+                _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

@@ -75 +75 @@
         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

@@ -87 +87 @@
         Serializer ser(out, true, CURRENT_VER);
         saveOrLoad(&ser, CURRENT_VER);
         delete out;
+        // create thumbnail file
+        makeSavegameName(filename, slot, false);
+        strcat(filename, ".tmb");       
+        if (!(out = _saveFileMan->openSavefile(filename, true)))
+                return false;           
+        createThumbnail();
+        for (uint16 p = 0; p < 160*120; ++p)
+                out->writeUint16LE(_thumbnail[p]);
+        delete out;
+        // --------------------
+
         debug(1, "State saved as '%s'", filename);
         return true;
 }

scumm/scumm.cpp

@@ -592 +592 @@
           gdi(this), _pauseDialog(0), _mainMenuDialog(0), _versionDialog(0),
           _targetName(detector->_targetName) {
 
+        // clears thumbnail
+        memset(_thumbnail, 0, sizeof(uint16)*160*120);
+
         // Copy MD5 checksum
         memcpy(_gameMD5, md5sum, 16);
 

scumm/scumm.h

@@ -544 +544 @@
 
         void lock(int type, int i);
         void unlock(int type, int i);
-
+        
+// thumbnail stuff
+public:
+        void createThumbnail();
+        void loadThumbnailFromData(const uint16* data);
+        void loadThumbnailFromSlot(int slot);
+        const uint16* getThumbnail() { return _thumbnail; }
+        
+        bool _hasThumbnail;
+protected:
+        uint16 _thumbnail[160*120];
+// ends here
+        
 protected:
         /* Heap and memory management */
         uint32 _maxHeapThreshold, _minHeapThreshold;

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 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 "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);
+}
+
+void ScummEngine::createThumbnail() {
+        if(sizeof(OverlayColor) != sizeof(uint16))
+                return;
+        
+        byte *temporaryScreen = new byte[_system->getWidth() * _system->getHeight()];
+        assert(temporaryScreen);
+        
+        _system->grabScreen(temporaryScreen);
+        
+        uint16 *screen = new uint16[_system->getWidth() * _system->getHeight()];
+        assert(screen);
+        
+        const uint8 *palette = _currentPalette;
+        
+        for(int y = 0; y < _system->getHeight(); ++y) {
+                for(int x = 0; x < _system->getWidth(); ++x) {
+                        uint8 index = temporaryScreen[y * _system->getWidth() + x];                     
+                        screen[y * _system->getWidth() + x] = RGBToColor(palette[index * 3], palette[index * 3 + 1], palette[index * 3 + 2]);
+                }
+        }
+        
+        delete [] temporaryScreen;
+        temporaryScreen = 0;
+        
+        memset(_thumbnail, 0, 160*120*2);       
+        ::createThumbnail((const uint8*)screen, _system->getWidth() * 2, (uint8*)_thumbnail, 320, _system->getWidth(), _system->getHeight());
+        
+        delete [] screen;
+}
+
+void ScummEngine::loadThumbnailFromData(const uint16* data) {
+        if(sizeof(OverlayColor) != sizeof(uint16))
+                return;
+
+        for (int y = 0; y < 120; ++y) {
+                for (int x = 0; x < 160; ++x) {
+                        uint8 r, g, b;
+                        colorToRGB(data[y * 160 + x], r, g, b);
+                        
+                        // converting to current OSystem Color
+                        _thumbnail[y * 160 + x] = _system->RGBToColor(r, g, b);
+                }
+        }
+}
+
+void ScummEngine::loadThumbnailFromSlot(int slot) {
+        char filename[256];
+        makeSavegameName(filename, slot, false);
+        strcat(filename, ".tmb");
+        
+        SaveFile *out;
+        if (!(out = _saveFileMan->openSavefile(filename, false))) {
+                delete out; 
+                memset(_thumbnail, 0, sizeof(uint16) * 160*120);
+                _hasThumbnail = false;
+                return;
+        }
+        
+        for (uint16 p = 0; p < 160*120; ++p)
+                _thumbnail[p] = out->readUint16LE();    
+        loadThumbnailFromData(_thumbnail);
+        _hasThumbnail = true;
+        delete out;
+}
+
+
+} // end of namespace Scumm