tb_skin.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_SKIN_H
#define TB_SKIN_H

#include "tb_core.h"
#include "tb_system.h"
#include "tb_renderer.h"
#include "tb_bitmap_fragment.h"
#include "tb_hashtable.h"
#include "tb_linklist.h"
#include "tb_dimension.h"
#include "tb_value.h"

namespace tb {

class TBNode;
class TBSkinConditionContext;

#define SKIN_VALUE_NOT_SPECIFIED TB_INVALID_DIMENSION

enum SKIN_STATE {
    SKIN_STATE_NONE         = 0,
    SKIN_STATE_DISABLED     = 1,
    SKIN_STATE_FOCUSED      = 2,
    SKIN_STATE_PRESSED      = 4,
    SKIN_STATE_SELECTED     = 8,
    SKIN_STATE_HOVERED      = 16,

    SKIN_STATE_ALL          =   SKIN_STATE_DISABLED |
                                SKIN_STATE_FOCUSED |
                                SKIN_STATE_PRESSED |
                                SKIN_STATE_SELECTED |
                                SKIN_STATE_HOVERED
};
MAKE_ENUM_FLAG_COMBO(SKIN_STATE);

enum SKIN_ELEMENT_TYPE {
    SKIN_ELEMENT_TYPE_STRETCH_BOX,      
    SKIN_ELEMENT_TYPE_STRETCH_BORDER,   
    SKIN_ELEMENT_TYPE_STRETCH_IMAGE,    
    SKIN_ELEMENT_TYPE_TILE,             
    SKIN_ELEMENT_TYPE_IMAGE             
};

class TBSkinCondition : public TBLinkOf<TBSkinCondition>
{
public:
    enum TARGET {
        TARGET_THIS,            
        TARGET_PARENT,          
        TARGET_ANCESTORS,       
        TARGET_PREV_SIBLING,    
        TARGET_NEXT_SIBLING     
    };
    enum PROPERTY {
        PROPERTY_SKIN,              
        PROPERTY_WINDOW_ACTIVE,     
        PROPERTY_AXIS,              
        PROPERTY_ALIGN,             
        PROPERTY_ID,                
        PROPERTY_STATE,             
        PROPERTY_VALUE,             
        PROPERTY_HOVER,             
        PROPERTY_CAPTURE,           
        PROPERTY_FOCUS,             
        PROPERTY_CUSTOM             
    };

    enum TEST {
        TEST_EQUAL,     
        TEST_NOT_EQUAL  
    };

    struct CONDITION_INFO {
        PROPERTY prop;          
        TBID custom_prop;       
        TBID value;             
    };

    TBSkinCondition(TARGET target, PROPERTY prop, const TBID &custom_prop, const TBID &value, TEST test);

    bool GetCondition(TBSkinConditionContext &context) const;
private:
    TARGET m_target;
    CONDITION_INFO m_info;
    TEST m_test;
};

class TBSkinConditionContext
{
public:
    virtual bool GetCondition(TBSkinCondition::TARGET target, const TBSkinCondition::CONDITION_INFO &info) = 0;
};

class TBSkinElementState : public TBLinkOf<TBSkinElementState>
{
public:
    enum MATCH_RULE {
        MATCH_RULE_DEFAULT,
        MATCH_RULE_ONLY_SPECIFIC_STATE
    };

    bool IsMatch(SKIN_STATE state, TBSkinConditionContext &context,
                MATCH_RULE rule = MATCH_RULE_DEFAULT) const;

    bool IsExactMatch(SKIN_STATE state, TBSkinConditionContext &context,
                MATCH_RULE rule = MATCH_RULE_DEFAULT) const;

    TBID element_id;
    SKIN_STATE state;
    TBLinkListAutoDeleteOf<TBSkinCondition> conditions;
};

class TBSkinElementStateList
{
public:
    ~TBSkinElementStateList();

    TBSkinElementState *GetStateElement(SKIN_STATE state, TBSkinConditionContext &context,
                        TBSkinElementState::MATCH_RULE rule = TBSkinElementState::MATCH_RULE_DEFAULT) const;

    TBSkinElementState *GetStateElementExactMatch(SKIN_STATE state, TBSkinConditionContext &context,
                        TBSkinElementState::MATCH_RULE rule = TBSkinElementState::MATCH_RULE_DEFAULT) const;

    bool HasStateElements() const { return m_state_elements.HasLinks(); }
    const TBSkinElementState *GetFirstElement() const { return m_state_elements.GetFirst(); }

    void Load(TBNode *n);
private:
    TBLinkListOf<TBSkinElementState> m_state_elements;
};

class TBSkinElement
{
public:
    TBSkinElement();
    ~TBSkinElement();

    // Skin properties
    TBID id;            
    TBStr name;         
    TBStr bitmap_file;  
    TBBitmapFragment *bitmap;
    uint8_t cut;            
    int16_t expand;     
    SKIN_ELEMENT_TYPE type;
    bool is_painting;   
    bool is_getting;    
    int16_t padding_left;       
    int16_t padding_top;        
    int16_t padding_right;  
    int16_t padding_bottom; 
    int16_t width;          
    int16_t height;         
    int16_t pref_width;     
    int16_t pref_height;        
    int16_t min_width;      
    int16_t min_height;     
    int16_t max_width;      
    int16_t max_height;     
    int16_t spacing;            
    int16_t content_ofs_x;  
    int16_t content_ofs_y;  
    int16_t img_ofs_x;      
    int16_t img_ofs_y;      
    int8_t img_position_x;  
    int8_t img_position_y;  
    int8_t flip_x;          
    int8_t flip_y;          
    float opacity;          
    TBColor text_color;     
    TBColor bg_color;       
    TBColor bitmap_color;   
    int16_t bitmap_dpi;     
    TBValue tag;            

    int GetMinWidth() const { return min_width; }

    int GetMinHeight() const { return min_height; }

    int GetIntrinsicMinWidth() const;

    int GetIntrinsicMinHeight() const;

    int GetMaxWidth() const { return max_width; }

    int GetMaxHeight() const { return max_height; }

    int GetPrefWidth() const { return pref_width; }

    int GetPrefHeight() const { return pref_height; }

    int GetIntrinsicWidth() const;

    int GetIntrinsicHeight() const;

    void SetBitmapDPI(const TBDimensionConverter &dim_conv, int bitmap_dpi);

    TBSkinElementStateList m_override_elements;

    TBSkinElementStateList m_strong_override_elements;

    TBSkinElementStateList m_child_elements;

    TBSkinElementStateList m_overlay_elements;

    bool HasState(SKIN_STATE state, TBSkinConditionContext &context);

    bool HasOverlayElements() const { return m_overlay_elements.HasStateElements(); }

    void Load(TBNode *n, TBSkin *skin, const TBStr & skin_path);
    void Write(TBFile * file, TBSkin * skin);
};

class TBSkinListener
{
public:
    virtual void OnSkinElementLoaded(TBSkin *skin, TBSkinElement *element, TBNode *node) = 0;
};

class TBSkin : private TBRendererListener
{
public:
    TBSkin();
    virtual ~TBSkin();

    void SetListener(TBSkinListener *listener) { m_listener = listener; }
    TBSkinListener *GetListener() const { return m_listener;  }

    bool Load(const TBStr & skin_file, const TBStr & override_skin_file = TBStr());

    bool Write(const TBStr & skin_file);

    void UnloadBitmaps();

    bool ReloadBitmaps();

    const TBDimensionConverter *GetDimensionConverter() const { return &m_dim_conv; }

    TBSkinElement *GetSkinElement(const TBID &skin_id) const;

    TBSkinElement *GetSkinElementStrongOverride(const TBID &skin_id, SKIN_STATE state,
                                                TBSkinConditionContext &context) const;

    TBColor GetDefaultTextColor() const { return m_default_text_color; }

    void SetDefaultTextColor(TBColor color) { m_default_text_color = color; }

    float GetDefaultDisabledOpacity() const { return m_default_disabled_opacity; }

    float GetDefaultPlaceholderOpacity() const { return m_default_placeholder_opacity; }

    int GetDefaultSpacing() const { return m_default_spacing; }

    TBSkinElement *PaintSkin(const TBRect &dst_rect, const TBID &skin_id, SKIN_STATE state,
                             TBSkinConditionContext &context);

    TBSkinElement *PaintSkin(const TBRect &dst_rect, TBSkinElement *element, SKIN_STATE state,
                             TBSkinConditionContext &context);

    void PaintSkinOverlay(const TBRect &dst_rect, TBSkinElement *element, SKIN_STATE state,
                          TBSkinConditionContext &context);

    void PaintRect(const TBRect &dst_rect, const TBColor &color, int thickness);

    void PaintRectFill(const TBRect &dst_rect, const TBColor &color);

#ifdef TB_RUNTIME_DEBUG_INFO

    void Debug();
#endif

    TBBitmapFragmentManager *GetFragmentManager() { return &m_frag_manager; }

    // Implementing TBRendererListener
    virtual void OnContextLost();
    virtual void OnContextRestored();
private:
    friend class TBSkinElement;
    TBSkinListener *m_listener;
    TBHashTableAutoDeleteOf<TBSkinElement> m_elements;  
    TBBitmapFragmentManager m_frag_manager;             
    TBDimensionConverter m_dim_conv;                    
    TBColor m_default_text_color;                       
    TBBitmapFragment *m_color_frag;                     
    float m_default_disabled_opacity;                   
    float m_default_placeholder_opacity;                
    int16_t m_default_spacing;                          
    bool LoadInternal(const TBStr & skin_file);
    bool ReloadBitmapsInternal();
    void PaintElement(const TBRect &dst_rect, TBSkinElement *element);
    void PaintElementBGColor(const TBRect &dst_rect, TBSkinElement *element);
    void PaintElementImage(const TBRect &dst_rect, TBSkinElement *element);
    void PaintElementTile(const TBRect &dst_rect, TBSkinElement *element);
    void PaintElementStretchImage(const TBRect &dst_rect, TBSkinElement *element);
    void PaintElementStretchBox(const TBRect &dst_rect, TBSkinElement *element, bool fill_center);
    TBRect GetFlippedRect(const TBRect &src_rect, TBSkinElement *element) const;
    int GetPxFromNode(TBNode *node, int def_value) const;
};

} // namespace tb

#endif // TB_SKIN_H