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.22"

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  
    };

    static const int kDirtyRectangleThreshold = 1;

    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;

    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