ThemeEngine.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef GUI_THEME_ENGINE_H
#define GUI_THEME_ENGINE_H
 
#include "common/scummsys.h"
#include "common/fs.h"
#include "common/hash-str.h"
#include "common/hashmap.h"
#include "common/language.h"
#include "common/list.h"
#include "common/str.h"
#include "common/rect.h"
 
#include "graphics/managed_surface.h"
#include "graphics/font.h"
#include "graphics/pixelformat.h"
 
 
#define SCUMMVM_THEME_VERSION_STR "SCUMMVM_STX0.9.24"
 
class OSystem;
 
namespace Graphics {
struct DrawStep;
class VectorRenderer;
}
 
namespace GUI {
 
struct WidgetDrawData;
struct TextDrawData;
class Dialog;
class GuiObject;
class ThemeEval;
class ThemeParser;
 
enum DrawData {
    kDDMainDialogBackground,
    kDDSpecialColorBackground,
    kDDPlainColorBackground,
    kDDDefaultBackground,
    kDDTooltipBackground,
    kDDTextSelectionBackground,
    kDDTextSelectionFocusBackground,
    kDDThumbnailBackground,
    kDDGridItemIdle,
    kDDGridItemHover,
    kDDWidgetBackgroundDefault,
    kDDWidgetBackgroundSmall,
    kDDWidgetBackgroundEditText,
    kDDWidgetBackgroundSlider,
 
    kDDButtonIdle,
    kDDButtonHover,
    kDDButtonDisabled,
    kDDButtonPressed,
 
    kDDDropDownButtonIdle,
    kDDDropDownButtonHoverLeft,
    kDDDropDownButtonHoverRight,
    kDDDropDownButtonDisabled,
    kDDDropDownButtonPressedLeft,
    kDDDropDownButtonPressedRight,
 
    kDDDropDownButtonIdleRTL,
    kDDDropDownButtonHoverLeftRTL,
    kDDDropDownButtonHoverRightRTL,
    kDDDropDownButtonDisabledRTL,
    kDDDropDownButtonPressedLeftRTL,
    kDDDropDownButtonPressedRightRTL,
 
    kDDSliderFull,
    kDDSliderHover,
    kDDSliderDisabled,
 
    kDDCheckboxDefault,
    kDDCheckboxDisabled,
    kDDCheckboxSelected,
    kDDCheckboxDisabledSelected,
 
    kDDRadiobuttonDefault,
    kDDRadiobuttonDisabled,
    kDDRadiobuttonSelected,
 
    kDDTabActive,
    kDDTabInactive,
    kDDTabBackground,
 
    kDDScrollbarBase,
    kDDScrollbarButtonIdle,
    kDDScrollbarButtonHover,
    kDDScrollbarHandleIdle,
    kDDScrollbarHandleHover,
 
    kDDPopUpIdle,
    kDDPopUpHover,
    kDDPopUpDisabled,
 
    kDDPopUpIdleRTL,
    kDDPopUpHoverRTL,
    kDDPopUpDisabledRTL,
 
    kDDCaret,
    kDDSeparator,
    kDrawDataMAX,
    kDDNone = -1
};
 
enum DrawLayer {
    kDrawLayerBackground,
    kDrawLayerForeground
};
 
// FIXME: TextData is really a bad name, not conveying what this enum is about.
enum TextData {
    kTextDataNone = -1,
    kTextDataDefault = 0,
    kTextDataButton,
    kTextDataNormalFont,
    kTextDataTooltip,
    kTextDataConsole,
    kTextDataExtraLang,
    kTextDataMAX
};
 
enum TextColor {
    kTextColorNormal = 0,
    kTextColorNormalInverted,
    kTextColorNormalHover,
    kTextColorNormalDisabled,
    kTextColorAlternative,
    kTextColorAlternativeInverted,
    kTextColorAlternativeHover,
    kTextColorAlternativeDisabled,
    kTextColorOverride,
    kTextColorOverrideInverted,
    kTextColorOverrideHover,
    kTextColorOverrideDisabled,
    kTextColorButton,
    kTextColorButtonHover,
    kTextColorButtonDisabled,
    kTextColorMAX
};
 
struct TextColorData {
    int r, g, b;
};
 
class LangExtraFont {
public:
    LangExtraFont(TextData textId, Common::Array<Common::Language> &lngs, const Common::String &filename, const Common::String &scalableFile, int ps) : _langs(lngs) {
        storeFileNames(textId, filename, scalableFile, ps);
    }
 
    void storeFileNames(TextData textId, const Common::String &filename, const Common::String &scalableFile, int ps) {
        assert(textId < kTextDataMAX);
        _fontFilesStd[textId] = filename;
        _fontFilesScalable[textId] = scalableFile;
        _fontSize[textId] = ps;
    }
 
    bool operator==(Common::Language l) const {
        return (Common::find(_langs.begin(), _langs.end(), l) != _langs.end());
    }
 
    Common::String file(TextData textId) const { return _fontFilesStd[textId]; }
    Common::String sclFile(TextData textId) const { return _fontFilesScalable[textId]; }
    int fntSize(TextData textId) const { return _fontSize[textId]; }
 
private:
    Common::Array<Common::Language> _langs;
    Common::String _fontFilesStd[kTextDataMAX];
    Common::String _fontFilesScalable[kTextDataMAX];
    int _fontSize[kTextDataMAX];
};
 
class ThemeEngine {
protected:
    typedef Common::HashMap<Common::String, Common::SharedPtr<Graphics::ManagedSurface> > ImagesMap;
 
    friend class GUI::Dialog;
    friend class GUI::GuiObject;
 
public:
    enum TextAlignVertical {
        kTextAlignVInvalid,
        kTextAlignVBottom,
        kTextAlignVCenter,
        kTextAlignVTop
    };
 
    enum WidgetBackground {
        kWidgetBackgroundNo,            
        kWidgetBackgroundPlain,         
        kWidgetBackgroundBorder,        
        kWidgetBackgroundBorderSmall,   
        kWidgetBackgroundEditText,      
        kWidgetBackgroundSlider,        
        kThumbnailBackground,           
        kGridItemBackground,            
        kGridItemHighlight              
    };
 
    enum DialogBackground {
        kDialogBackgroundMain,
        kDialogBackgroundSpecial,
        kDialogBackgroundPlain,
        kDialogBackgroundTooltip,
        kDialogBackgroundDefault,
        kDialogBackgroundNone
    };
 
    enum State {
        kStateDisabled,     
        kStateEnabled,      
        kStateHighlight,    
        kStatePressed       
    };
 
    typedef State WidgetStateInfo;
 
    enum TextInversionState {
        kTextInversionNone, 
        kTextInversion,     
        kTextInversionFocus 
    };
 
    enum ScrollbarState {
        kScrollbarStateNo,
        kScrollbarStateUp,
        kScrollbarStateDown,
        kScrollbarStateSlider,
        kScrollbarStateSinglePage
    };
 
    enum FontStyle {
        kFontStyleBold = 0,         
        kFontStyleNormal = 1,       
        kFontStyleItalic = 2,       
        kFontStyleFixedNormal = 3,  
        kFontStyleFixedBold = 4,    
        kFontStyleFixedItalic = 5,  
        kFontStyleTooltip = 6,      
        kFontStyleConsole = 7,      
        kFontStyleLangExtra = 8,    
        kFontStyleMax
    };
 
    enum FontColor {
        kFontColorFormatting = -1,  
        kFontColorNormal = 0,       
        kFontColorAlternate = 1,    
        kFontColorOverride = 2,     
        kFontColorMax
    };
 
    enum ShadingStyle {
        kShadingNone,       
        kShadingDim,        
        kShadingLuminance   
    };
 
    enum AutoScaleMode {
        kAutoScaleNone = 0,     
        kAutoScaleStretch = 1,  
        kAutoScaleFit = 2,      
        kAutoScaleNinePatch = 3 
    };
 
    // Special image ids for images used in the GUI
    static const char *const kImageLogo;      
    static const char *const kImageLogoSmall; 
    static const char *const kImageSearch;    
    static const char *const kImageGroup;     
    static const char *const kImageEraser;     
    static const char *const kImageDelButton; 
    static const char *const kImageList;      
    static const char *const kImageGrid;      
    static const char *const kImageStopButton; 
    static const char *const kImageEditButton; 
    static const char *const kImageSwitchModeButton; 
    static const char *const kImageFastReplayButton; 
    static const char *const kImageStopSmallButton; 
    static const char *const kImageEditSmallButton; 
    static const char *const kImageSwitchModeSmallButton; 
    static const char *const kImageFastReplaySmallButton; 
 
    enum GraphicsMode {
        kGfxDisabled = 0,   
        kGfxStandard,  
        kGfxAntialias  
    };
 
    struct Renderer {
        const char *name;
        const char *shortname;
        const char *cfg;
        GraphicsMode mode;
    };
 
    static const Renderer _rendererModes[];
    static const uint _rendererModesSize;
 
    static const GraphicsMode _defaultRendererMode;
 
    static GraphicsMode findMode(const Common::String &cfg);
    static const char *findModeConfigName(GraphicsMode mode);
 
    ThemeEngine(Common::String id, GraphicsMode mode);
 
    ~ThemeEngine();
 
    void setBaseResolution(int w, int h, float s);
    bool init();
    void clearAll();
 
    void refresh();
    void enable();
 
    void showCursor();
    void hideCursor();
 
    void disable();
 
 
    const Graphics::PixelFormat getPixelFormat() const { return _overlayFormat; }
 
    void applyScreenShading(ShadingStyle shading);
 
    void drawToBackbuffer();
 
    void drawToScreen();
 
    void updateScreen();
 
    void copyBackBufferToScreen();
 
 
 
    TextData fontStyleToData(FontStyle font) const {
        if (font == kFontStyleNormal)
            return kTextDataNormalFont;
        if (font == kFontStyleTooltip)
            return kTextDataTooltip;
        if (font == kFontStyleConsole)
            return kTextDataConsole;
        if (font == kFontStyleLangExtra)
            return kTextDataExtraLang;
        return kTextDataDefault;
    }
 
    const Graphics::Font *getFont(FontStyle font = kFontStyleBold) const;
 
    int getFontHeight(FontStyle font = kFontStyleBold) const;
 
    int getStringWidth(const Common::U32String &str, FontStyle font = kFontStyleBold) const;
 
    int getCharWidth(uint32 c, FontStyle font = kFontStyleBold) const;
 
    int getKerningOffset(uint32 left, uint32 right, FontStyle font = kFontStyleBold) const;
 
 
    Common::Rect swapClipRect(const Common::Rect &newRect);
    const Common::Rect getClipRect();
 
    void disableClipRect();
 
    Common::Rect getDialogDirtyRect(const Common::Rect &r, DialogBackground bgtype);
 
 
    void drawWidgetBackground(const Common::Rect &r, WidgetBackground background);
 
    void drawButton(const Common::Rect &r, const Common::U32String &str, WidgetStateInfo state = kStateEnabled,
                    uint16 hints = 0);
 
    void drawDropDownButton(const Common::Rect &r, uint32 dropdownWidth, const Common::U32String &str,
                            WidgetStateInfo buttonState, bool inButton, bool inDropdown, bool rtl = false);
 
    void drawManagedSurface(const Common::Point &p, const Graphics::ManagedSurface &surface, Graphics::AlphaType alphaType);
 
    void drawSlider(const Common::Rect &r, int width, WidgetStateInfo state = kStateEnabled, bool rtl = false);
 
    void drawCheckbox(const Common::Rect &r, int spacing, const Common::U32String &str, bool checked,
                      WidgetStateInfo state = kStateEnabled, bool override = false, bool rtl = false);
 
    void drawRadiobutton(const Common::Rect &r, int spacing, const Common::U32String &str, bool checked,
                         WidgetStateInfo state = kStateEnabled, bool rtl = false);
 
    void drawTab(const Common::Rect &r, int tabHeight, const Common::Array<int> &tabWidths,
                 const Common::Array<Common::U32String> &tabs, int active, bool rtl,
                 ThemeEngine::TextAlignVertical alignV);
 
    void drawScrollbar(const Common::Rect &r, int sliderY, int sliderHeight, ScrollbarState scrollState);
 
    void drawPopUpWidget(const Common::Rect &r, const Common::U32String &sel, int deltax,
                         WidgetStateInfo state = kStateEnabled, bool rtl = false);
 
    void drawCaret(const Common::Rect &r, bool erase);
 
    void drawLineSeparator(const Common::Rect &r);
 
    void drawDialogBackground(const Common::Rect &r, DialogBackground type);
 
    void drawText(const Common::Rect &r, const Common::U32String &str, WidgetStateInfo state = kStateEnabled,
                  Graphics::TextAlign align = Graphics::kTextAlignCenter,
                  TextInversionState inverted = kTextInversionNone, int deltax = 0, bool useEllipsis = true,
                  FontStyle font = kFontStyleBold, FontColor color = kFontColorNormal, bool restore = true,
                  const Common::Rect &drawableTextArea = Common::Rect(0, 0, 0, 0));
 
    void drawChar(const Common::Rect &r, byte ch, const Graphics::Font *font, FontColor color = kFontColorNormal, TextInversionState inverted = ThemeEngine::kTextInversionNone);
 
    void drawFoldIndicator(const Common::Rect &r, bool expanded);
 
 
 
 
    void addDirtyRect(Common::Rect r);
 
 
    DrawData parseDrawDataId(const Common::String &name) const;
 
    TextData getTextData(DrawData ddId) const;
    TextColor getTextColor(DrawData ddId) const;
 
    TextColorData *getTextColorData(TextColor color) const;
 
    bool getDrawDataColor(DrawData ddId, uint8 &r, uint8 &g, uint8 &b) const;
 
    void addDrawStep(const Common::String &drawDataId, const Graphics::DrawStep &step);
 
    bool addDrawData(const Common::String &data, bool cached);
 
 
    bool addFont(TextData textId, const Common::String &language, const Common::String &file, const Common::String &scalableFile, const int pointsize);
 
    void storeFontNames(TextData textId, const Common::String &language, const Common::String &file, const Common::String &scalableFile, const int pointsize);
 
    bool loadExtraFont(FontStyle style, Common::Language lang);
 
    bool addTextColor(TextColor colorId, int r, int g, int b);
 
 
    bool addBitmap(const Common::String &filename, const Common::String &scalablefile, int widht, int height);
 
    bool addTextData(const Common::String &drawDataId, TextData textId, TextColor id, Graphics::TextAlign alignH, TextAlignVertical alignV);
 
public:
    enum CursorType {
        kCursorNormal = 0,
        kCursorIndex = 1,
        kCursorMax
    };
 
    void setActiveCursor(CursorType type);
 
protected:
    bool ready() const {
        return _initOk && _themeOk;
    }
 
    void loadTheme(const Common::String &themeid);
 
    void setGraphicsMode(GraphicsMode mode);
 
    struct CursorData {
        Common::SharedPtr<Graphics::ManagedSurface> surface;
        int hotspotX = 0;
        int hotspotY = 0;
    };
 
    CursorData _cursors[kCursorMax];
    CursorType _activeCursorType = kCursorNormal;
    bool _useCursor = false;
 
public:
    inline ThemeEval *getEvaluator() { return _themeEval; }
    inline Graphics::VectorRenderer *renderer() { return _vectorRenderer; }
 
    inline bool supportsImages() const { return true; }
    inline bool ownCursor() const { return _useCursor; }
 
    Common::SharedPtr<Graphics::ManagedSurface> getImageSurface(const Common::String &name) const {
        return _bitmaps.contains(name) ? _bitmaps[name] : 0;
    }
 
    bool createCursor(const Common::String &filename, int hotspotX, int hotspotY, CursorType type = kCursorNormal);
 
    void restoreBackground(Common::Rect r);
 
    const Common::String &getThemeName() const { return _themeName; }
    const Common::String &getThemeId() const { return _themeId; }
    int getGraphicsMode() const { return _graphicsMode; }
 
protected:
 
    bool loadThemeXML(const Common::String &themeId);
 
    bool loadDefaultXML();
 
    void unloadTheme();
 
    void unloadExtraFont();
 
    const Graphics::Font *loadScalableFont(const Common::String &filename, const int pointsize, Common::String &name);
    const Graphics::Font *loadFont(const Common::String &filename, Common::String &name);
    Common::String genCacheFilename(const Common::String &filename) const;
    const Graphics::Font *loadFont(const Common::String &filename, const Common::String &scalableFilename, const int pointsize, const bool makeLocalizedFont);
 
    void updateDirtyScreen();
 
    void drawDD(DrawData type, const Common::Rect &r, uint32 dynamic = 0, bool forceRestore = false);
    void drawDDText(TextData type, TextColor color, const Common::Rect &r, const Common::U32String &text, bool restoreBg,
                    bool elipsis, Graphics::TextAlign alignH = Graphics::kTextAlignLeft,
                    TextAlignVertical alignV = kTextAlignVTop, int deltax = 0,
                    const Common::Rect &drawableTextArea = Common::Rect(0, 0, 0, 0));
 
    Common::Rect getDrawDataExtendedRect(DrawData type, const Common::Rect &r) const;
 
    Common::Rect getDrawDataRestoreRect(DrawData type, const Common::Rect &r) const;
 
    void debugWidgetPosition(const char *name, const Common::Rect &r);
 
public:
    struct ThemeDescriptor {
        Common::String name;
        Common::String id;
        Common::Path filename;
    };
 
    static void listUsableThemes(Common::List<ThemeDescriptor> &list);
private:
    static bool themeConfigUsable(const Common::FSNode &node, Common::String &themeName);
    static bool themeConfigUsable(const Common::ArchiveMember &member, Common::String &themeName);
    static bool themeConfigParseHeader(Common::String header, Common::String &themeName);
 
    static Common::Path getThemeFile(const Common::String &id);
    static Common::String getThemeId(const Common::Path &filename);
    static void listUsableThemes(const Common::FSNode &node, Common::List<ThemeDescriptor> &list, int depth = -1);
    static void listUsableThemes(Common::Archive &archive, Common::List<ThemeDescriptor> &list);
 
    Common::Archive *createUnpackedThemeArchive(const Common::FSNode &themeDir);
 
protected:
    OSystem *_system; 
    Graphics::VectorRenderer *_vectorRenderer;
 
    GUI::ThemeParser *_parser;
 
    GUI::ThemeEval *_themeEval;
 
    Graphics::ManagedSurface _screen;
 
    Graphics::ManagedSurface _backBuffer;
 
    DrawLayer _layerToDraw;
 
    int _bytesPerPixel;
 
    GraphicsMode _graphicsMode;
 
    int16 _baseWidth, _baseHeight;
    float _scaleFactor;
    bool _needScaleRefresh = false;
 
    const Graphics::Font *_font;
 
    WidgetDrawData *_widgets[kDrawDataMAX];
 
    TextDrawData *_texts[kTextDataMAX];
 
    TextColorData *_textColors[kTextColorMAX];
 
    Common::Array<LangExtraFont> _langExtraFonts;
 
    ImagesMap _bitmaps;
    Graphics::PixelFormat _overlayFormat;
 
    Common::List<Common::Rect> _dirtyScreen;
 
    bool _initOk;  
    bool _themeOk; 
    bool _enabled; 
 
    Common::String _themeName; 
    Common::String _themeId;
    Common::Path _themeFile;
    Common::Archive *_themeArchive;
    Common::SearchSet _themeFiles;
 
    int _cursorHotspotX, _cursorHotspotY;
    uint32 _cursorTransparent;
    byte *_cursor;
    uint _cursorWidth, _cursorHeight;
 
    enum {
        MAX_CURS_COLORS = 255
    };
 
    Common::Rect _clip;
};
 
} // End of namespace GUI.
 
#endif