Ticket #8405: thumbnails-v2.patch

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_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 - 160);
+                src += 4 * srcPitch;
+        }
+}
+
+template<int bitFormat>
+void createThumbnail_8(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height) {
+        for (int y = 0; y < height; y += 8) {
+                for (int x = 0; x < width; x += 8, 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);
+                        
+                        uint32 colorx5y1 = *(((const uint16*)src) + x + 4);
+                        uint16 colorx6y1 = *(((const uint16*)src) + x + 5);
+                        uint16 colorx7y1 = *(((const uint16*)src) + x + 6);
+                        uint16 colorx8y1 = *(((const uint16*)src) + x + 7);
+                        
+                        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 colorx5y2 = *(((const uint16*)(src + srcPitch)) + x + 4);
+                        uint16 colorx6y2 = *(((const uint16*)(src + srcPitch)) + x + 5);
+                        uint16 colorx7y2 = *(((const uint16*)(src + srcPitch)) + x + 6);
+                        uint16 colorx8y2 = *(((const uint16*)(src + srcPitch)) + x + 7);
+                        
+                        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 colorx5y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 4);
+                        uint16 colorx6y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 5);
+                        uint16 colorx7y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 6);
+                        uint16 colorx8y3 = *(((const uint16*)(src + srcPitch * 2)) + x + 7);
+                        
+                        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 colorx5y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 4);
+                        uint16 colorx6y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 5);
+                        uint16 colorx7y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 6);
+                        uint16 colorx8y4 = *(((const uint16*)(src + srcPitch * 3)) + x + 7);
+                        
+                        uint16 colorx1y5 = *(((const uint16*)(src + srcPitch * 3)) + x);
+                        uint16 colorx2y5 = *(((const uint16*)(src + srcPitch * 3)) + x + 1);
+                        uint16 colorx3y5 = *(((const uint16*)(src + srcPitch * 3)) + x + 2);
+                        uint16 colorx4y5 = *(((const uint16*)(src + srcPitch * 3)) + x + 3);
+                        
+                        uint16 colorx5y5 = *(((const uint16*)(src + srcPitch * 4)) + x + 4);
+                        uint16 colorx6y5 = *(((const uint16*)(src + srcPitch * 4)) + x + 5);
+                        uint16 colorx7y5 = *(((const uint16*)(src + srcPitch * 4)) + x + 6);
+                        uint16 colorx8y5 = *(((const uint16*)(src + srcPitch * 4)) + x + 7);
+                        
+                        uint16 colorx1y6 = *(((const uint16*)(src + srcPitch * 5)) + x);
+                        uint16 colorx2y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 1);
+                        uint16 colorx3y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 2);
+                        uint16 colorx4y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 3);
+                        
+                        uint16 colorx5y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 4);
+                        uint16 colorx6y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 5);
+                        uint16 colorx7y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 6);
+                        uint16 colorx8y6 = *(((const uint16*)(src + srcPitch * 5)) + x + 7);
+                        
+                        uint16 colorx1y7 = *(((const uint16*)(src + srcPitch * 6)) + x);
+                        uint16 colorx2y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 1);
+                        uint16 colorx3y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 2);
+                        uint16 colorx4y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 3);
+                        
+                        uint16 colorx5y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 4);
+                        uint16 colorx6y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 5);
+                        uint16 colorx7y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 6);
+                        uint16 colorx8y7 = *(((const uint16*)(src + srcPitch * 6)) + x + 7);
+                        
+                        uint16 colorx1y8 = *(((const uint16*)(src + srcPitch * 7)) + x);
+                        uint16 colorx2y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 1);
+                        uint16 colorx3y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 2);
+                        uint16 colorx4y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 3);
+                        
+                        uint16 colorx5y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 4);
+                        uint16 colorx6y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 5);
+                        uint16 colorx7y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 6);
+                        uint16 colorx8y8 = *(((const uint16*)(src + srcPitch * 7)) + x + 7);
+                                
+                        uint16 rectx1y1 = Q_INTERPOLATE<bitFormat>(colorx1y1, colorx2y1, colorx1y2, colorx2y2);
+                        uint16 rectx2y1 = Q_INTERPOLATE<bitFormat>(colorx3y1, colorx4y1, colorx3y2, colorx4y2);
+                        uint16 rectx3y1 = Q_INTERPOLATE<bitFormat>(colorx5y1, colorx6y1, colorx5y2, colorx6y2);
+                        uint16 rectx4y1 = Q_INTERPOLATE<bitFormat>(colorx7y1, colorx8y1, colorx7y2, colorx8y2);
+                        
+                        uint16 rectx1y2 = Q_INTERPOLATE<bitFormat>(colorx1y3, colorx2y3, colorx1y4, colorx2y4);
+                        uint16 rectx2y2 = Q_INTERPOLATE<bitFormat>(colorx3y3, colorx4y3, colorx3y4, colorx4y4);
+                        uint16 rectx3y2 = Q_INTERPOLATE<bitFormat>(colorx5y3, colorx6y3, colorx5y4, colorx6y4);
+                        uint16 rectx4y2 = Q_INTERPOLATE<bitFormat>(colorx7y3, colorx8y3, colorx7y4, colorx8y4);
+                        
+                        uint16 rectx1y3 = Q_INTERPOLATE<bitFormat>(colorx1y5, colorx2y5, colorx1y6, colorx2y6);
+                        uint16 rectx2y3 = Q_INTERPOLATE<bitFormat>(colorx3y5, colorx4y5, colorx3y6, colorx4y6);
+                        uint16 rectx3y3 = Q_INTERPOLATE<bitFormat>(colorx5y5, colorx6y5, colorx5y6, colorx6y6);
+                        uint16 rectx4y3 = Q_INTERPOLATE<bitFormat>(colorx7y5, colorx8y5, colorx7y6, colorx8y6); 
+                        
+                        uint16 rectx1y4 = Q_INTERPOLATE<bitFormat>(colorx1y7, colorx2y7, colorx1y8, colorx2y8);
+                        uint16 rectx2y4 = Q_INTERPOLATE<bitFormat>(colorx3y7, colorx4y7, colorx3y8, colorx4y8);
+                        uint16 rectx3y4 = Q_INTERPOLATE<bitFormat>(colorx5y7, colorx6y7, colorx5y8, colorx6y8);
+                        uint16 rectx4y4 = Q_INTERPOLATE<bitFormat>(colorx7y7, colorx8y7, colorx7y8, colorx8y8);                                 
+                        
+                        uint16 upleft = Q_INTERPOLATE<bitFormat>(rectx1y1, rectx2y1, rectx1y2, rectx2y2);
+                        uint16 upright = Q_INTERPOLATE<bitFormat>(rectx3y1, rectx4y1, rectx3y2, rectx4y2);
+                        uint16 downleft = Q_INTERPOLATE<bitFormat>(rectx1y3, rectx2y3, rectx1y4, rectx2y4);
+                        uint16 downright = Q_INTERPOLATE<bitFormat>(rectx3y3, rectx4y3, rectx3y4, rectx4y4);
+                                
+                        *((uint16*)dstPtr) = Q_INTERPOLATE<bitFormat>(upleft, upright, downleft, downright);                    
+                }
+                dstPtr += (dstPitch - 160);
+                src += 8 * srcPitch;
+        }
+}
+
+void createThumbnail(const uint8* src, uint32 srcPitch, uint8* dstPtr, uint32 dstPitch, int width, int height) {
+        // only 1/4 and 1/8 downscale supported
+        if(width != 320 && width != 640)
+                return;
+                
+        const int downScaleMode = (width == 320) ? 4 : 8;
+        
+        if(downScaleMode == 4) {
+                createThumbnail_4<565>(src, srcPitch, dstPtr, dstPitch, width, height);
+        } else if(downScaleMode == 8) {
+                createThumbnail_8<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 80x50 thumbnail for 320x200 games
+// and 80x60 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,

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"
 
@@ -400 +401 @@
                         if (bitmap[y / _scaleFactor] & mask)
                                         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], pitch);
+                }
+        } else if(_scaleFactor == 2) {
+                Normal2x((const uint8*)data, pitch, (uint8*)getBasePtr(x * 2, y * 2), _screen.pitch, 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);
+        g_gui.addDirtyRect(_x, _y, _w, _h);
 }
 
 } // 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

@@ -23 +23 @@
 #include "common/config-manager.h"
 #include "common/system.h"
 
-#include "gui/chooser.h"
 #include "gui/newgui.h"
 #include "gui/ListWidget.h"
 
@@ -54 +53 @@
 using GUI::WIDGET_ENABLED;
 
 typedef GUI::OptionsDialog GUI_OptionsDialog;
-typedef GUI::ChooserDialog GUI_ChooserDialog;
 typedef GUI::Dialog GUI_Dialog;
 
 namespace Scumm {
@@ -199 +197 @@
         kQuitCmd = 'QUIT'
 };
 
-class SaveLoadChooser : public GUI::ChooserDialog {
+enum {
+        kChooseCmd = 'Chos'
+};
+
+class SaveLoadChooser : public GUI::Dialog {
         typedef Common::String String;
         typedef Common::StringList StringList;
 protected:
         bool _saveMode;
+        GUI::ListWidget         *_list;
+        GUI::ButtonWidget       *_chooseButton;
+        GUI::GraphicsWidget     *_gfxWidget;
+        ScummEngine                     *_scumm;
 
 public:
-        SaveLoadChooser(const String &title, const String &buttonLabel, bool saveMode);
+        SaveLoadChooser(const String &title, const String &buttonLabel, bool saveMode, ScummEngine *engine);
         
         virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
-        const String &getResultString() const;
+        const String &getResultString() const;  
+        void setList(const StringList& list);
 };
 
-SaveLoadChooser::SaveLoadChooser(const String &title, const String &buttonLabel, bool saveMode)
-        : GUI::ChooserDialog(title, buttonLabel, 182), _saveMode(saveMode) {
-
+SaveLoadChooser::SaveLoadChooser(const String &title, const String &buttonLabel, bool saveMode, ScummEngine *engine)
+        : Dialog(8, (200 - 182) / 2, 320 - 2 * 8, 182), _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 - 100, _h - 14 - 24 - 10);
         _list->setEditable(saveMode);
         _list->setNumberingMode(saveMode ? GUI::kListNumberingOne : GUI::kListNumberingZero);
+        
+        // Add the thumbnail displayer
+        _gfxWidget = new GUI::GraphicsWidget(this, _w - 102, _y + 6, 88, 68);
+        _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 &SaveLoadChooser::getResultString() const {
         return _list->getSelectedString();
 }
 
+void SaveLoadChooser::setList(const StringList& list) {
+        _list->setList(list);
+}
+
 void SaveLoadChooser::handleCommand(CommandSender *sender, uint32 cmd, uint32 data) {
         int selItem = _list->getSelected();
         switch (cmd) {
@@ -230 +256 @@
         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(80, 60, 2, _scumm->_hasThumbnail == true ? (const uint8*)_scumm->getThumbnail() : 0);
+                _gfxWidget->draw();
                 if (_saveMode) {
                         _list->startEditMode();
                 }
@@ -245 +280 @@
                 _chooseButton->setEnabled(selItem >= 0 && (_saveMode || !getResultString().isEmpty()));
                 _chooseButton->draw();
                 break;
+        case kCloseCmd:
+                setResult(-1);
         default:
-                GUI_ChooserDialog::handleCommand(sender, cmd, data);
+                GUI::Dialog::handleCommand(sender, cmd, data);
         }
 }
 
+#pragma mark -
+
 Common::StringList generateSavegameList(ScummEngine *scumm, bool saveMode) {
         // Get savegame names
         Common::StringList l;
@@ -308 +347 @@
 #ifndef DISABLE_HELP
         _helpDialog = new HelpDialog(scumm);
 #endif
-        _saveDialog = new SaveLoadChooser("Save game:", "Save", true);
-        _loadDialog = new SaveLoadChooser("Load game:", "Load", false);
+        _saveDialog = new SaveLoadChooser("Save game:", "Save", true, scumm);
+        _loadDialog = new SaveLoadChooser("Load game:", "Load", false, scumm);
 }
 
 MainMenuDialog::~MainMenuDialog() {

scumm/gfx.cpp

@@ -525 +525 @@
                 _vm->_system->copyRectToScreen(_herculesBuf + x + y * Common::kHercW, 
                         Common::kHercW, x + (Common::kHercW - _vm->_screenWidth * 2) / 2, y, width, height);
         } else {
-                // Finally blit the whole thing to the screen
-                _vm->_system->copyRectToScreen(_compositeBuf + x + y * _vm->_screenWidth, _vm->_screenWidth, x, y, width, height);
+                if(_vm->creatingThumbnail()) {
+                        _vm->copyToThumbnailScreen(_compositeBuf + x + y * _vm->_screenWidth, _vm->_screenWidth, x, y, width, height);
+                } else {
+                        // Finally blit the whole thing to the screen
+                        _vm->_system->copyRectToScreen(_compositeBuf + x + y * _vm->_screenWidth, _vm->_screenWidth, x, y, width, height);
+                }
         }
 }
 

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/object.cpp

@@ -1535 +1535 @@
 void ScummEngine::removeBlastObjects() {
         BlastObject *eo;
         int i;
+        
+        // for thumbnails
+        if(_blastObjectQueuePos)
+                backUpBlastObjectQueue();
 
         eo = _blastObjectQueue;
         for (i = 0; i < _blastObjectQueuePos; i++, eo++) {

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();      
+        out->write(_thumbnail, sizeof(uint16) * 80*60);
+        delete out;
+        // --------------------
+        
         debug(1, "State saved as '%s'", filename);
         return true;
 }

scumm/scumm.cpp

@@ -574 +574 @@
           _heversion(gs.heversion),
           _numActors(gs.numActors),
           _features(gs.features),
-          gdi(this), _pauseDialog(0), _mainMenuDialog(0), _versionDialog(0),
+          gdi(this), _pauseDialog(0), _mainMenuDialog(0), _versionDialog(0), _createThumbnail(false), _temporaryScreen(0),
           _targetName(detector->_targetName) {
+          
+        // fill thumbnail with 0
+        memset(_thumbnail, 0, 80*60*2);
 
         // Copy MD5 checksum
         memcpy(_gameMD5, md5sum, 16);

scumm/scumm.h

@@ -542 +542 @@
         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 creatingThumbnail() { return _createThumbnail; }
+        void copyToThumbnailScreen(const byte *buf, int pitch, int x, int y, int w, int h);
+
+        bool _hasThumbnail;
+protected:
+        uint16 _thumbnail[80*60];
+        byte *_temporaryScreen;
+        bool _createThumbnail;
+        
+        void backUpBlastObjectQueue();
+        void insertBackUpedBlastObjectQueue();
+        
+        int _blastObjectQueueBackUPPos; 
+        BlastObject _blastObjectQueueBackUP[128];
+        
+        void backUpBlastTextQueue();
+        void insertBackUpedBlastTextQueue();
+
+        int _blastTextQueueBackUPPos;
+        BlastText _blastTextQueueBackUP[50];
+// ends here
+
 protected:
         /* Heap and memory management */
         uint32 _maxHeapThreshold, _minHeapThreshold;

scumm/string.cpp

@@ -785 +785 @@
 
 void ScummEngine::removeBlastTexts() {
         int i;
+        
+        // for thumbnails
+        if(_blastTextQueuePos)
+                backUpBlastTextQueue();
 
         for (i = 0; i < _blastTextQueuePos; i++) {
                 restoreBG(_blastTextQueue[i].rect);

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;
+        
+        _temporaryScreen = new byte[_system->getWidth() * _system->getHeight()];
+        assert(_temporaryScreen);
+        
+        _createThumbnail = true;        
+        int pos = 0;
+        
+        for (VirtScreen *vs = &virtscr[0]; pos < ARRAYSIZE(virtscr); ++pos, vs = &virtscr[pos]) {
+                markRectAsDirty((VirtScreenNumber)pos, 0, vs->w, 0, vs->h);
+        }
+        
+        insertBackUpedBlastObjectQueue();
+        insertBackUpedBlastTextQueue();
+        
+        if (_version >= 7 && VAR(VAR_BLAST_ABOVE_TEXT) == 1) {
+                drawBlastTexts();
+                drawBlastObjects();
+        } else {
+                drawBlastObjects();
+                drawBlastTexts();
+        }
+        
+        drawDirtyScreenParts();
+        
+        removeBlastTexts();
+        removeBlastObjects();   
+        
+        _blastTextQueuePos = _blastObjectQueuePos = 0;
+        
+        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]);
+                }
+        }
+        
+        _createThumbnail = false;
+        delete [] _temporaryScreen;
+        _temporaryScreen = 0;
+        
+        memset(_thumbnail, 0, 80*60*2); 
+        ::createThumbnail((const uint8*)screen, _system->getWidth() * 2, (uint8*)_thumbnail, 160, _system->getWidth(), _system->getHeight());
+        
+        delete [] screen;
+}
+
+void ScummEngine::loadThumbnailFromData(const uint16* data) {
+        if(sizeof(OverlayColor) != sizeof(uint16))
+                return;
+
+        for (int y = 0; y < 60; ++y) {
+                for (int x = 0; x < 80; ++x) {
+                        uint8 r, g, b;
+                        colorToRGB(data[y * 80 + x], r, g, b);
+                        
+                        // converting to current OSystem Color
+                        _thumbnail[y * 80 + x] = _system->RGBToColor(r, g, b);
+                }
+        }
+}
+
+void ScummEngine::copyToThumbnailScreen(const byte *buf, int pitch, int x, int y, int w, int h) {
+        assert(_temporaryScreen);
+        uint8* dst = _temporaryScreen + y * _system->getWidth() + x;
+        while (h--) {
+                memcpy(dst, buf, w);
+                buf += pitch;
+                dst += _system->getWidth();
+        }
+}
+
+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) * 80*60);
+                _hasThumbnail = false;
+                return;
+        }
+                
+        out->read(_thumbnail, sizeof(uint16) * 80*60);
+        loadThumbnailFromData(_thumbnail);
+        _hasThumbnail = true;
+        delete out;
+}
+
+void ScummEngine::backUpBlastObjectQueue() {
+        _blastObjectQueueBackUPPos = _blastObjectQueuePos;
+        for (int i = 0; i < _blastObjectQueuePos; i++) {
+                memcpy(&_blastObjectQueueBackUP[i], &_blastObjectQueue[i], sizeof(BlastObject));
+        }
+}
+
+void ScummEngine::insertBackUpedBlastObjectQueue() {
+        _blastObjectQueuePos = _blastObjectQueueBackUPPos;
+        for (int i = 0; i < _blastObjectQueuePos; i++) {
+                memcpy(&_blastObjectQueue[i], &_blastObjectQueueBackUP[i], sizeof(BlastObject));
+        }
+}
+
+void ScummEngine::backUpBlastTextQueue() {
+        _blastTextQueueBackUPPos = _blastTextQueuePos;
+        for (int i = 0; i < _blastTextQueuePos; i++) {
+                memcpy(&_blastTextQueueBackUP[i], &_blastTextQueue[i], sizeof(BlastText));
+        }
+}
+
+void ScummEngine::insertBackUpedBlastTextQueue() {
+        _blastTextQueuePos = _blastTextQueueBackUPPos;
+        for (int i = 0; i < _blastTextQueuePos; i++) {
+                memcpy(&_blastTextQueue[i], &_blastTextQueueBackUP[i], sizeof(BlastText));
+        }
+}
+
+} // end of namespace Scumm