GUIStyleAttribute.h

#pragma once

 
#include "DefinitionsGUI.h"
#include "DefinitionsGUIStyle.h"

namespace FLImaging
{
    namespace GUI
    {
        class FL_EXPORT CGUIStyleAttributeColor
        {
        public:
            CGUIStyleAttributeColor();

            CGUIStyleAttributeColor(COLORREF u32Color, float f32ColorAlphaRatio = g_f32StyleDefaultFillColorAlphaRatio);

            CGUIStyleAttributeColor(const CGUIStyleAttributeColor& attrBasic);

            CGUIStyleAttributeColor(const CGUIStyleAttributeColor* pAttrBasic);

            virtual ~CGUIStyleAttributeColor();

            void Clear();

            const CGUIStyleAttributeColor& operator=(const CGUIStyleAttributeColor& attrBasic);

            const CResult Assign(const CGUIStyleAttributeColor& attrBasic);

            const CResult Assign(const CGUIStyleAttributeColor* pAttrBasic);

            const CResult SetColor(COLORREF u32Color);

            const CResult SetColor(uint8_t u8Blue, uint8_t u8Green, uint8_t u8Red);

            const CResult GetColor(COLORREF& u32Color) const;

            COLORREF GetColor() const;

            const CResult ClearAttributeColor();

            const CResult SetColorAlphaRatio(float f32ColorAlphaRatio);

            const CResult GetColorAlphaRatio(float& f32ColorAlphaRatio) const;

            float GetColorAlphaRatio() const;

            const CResult ClearAttributeColorAlphaRatio();

            const CResult SetDraw(bool bDraw);

            const CResult IsDraw(bool& bDraw) const;

            bool IsDraw() const;

            const CResult ClearAttributeDrawFlag();

            bool IsParameterModified(EGUIDrawingAttributeColorParameters eAttr) const;
 
        protected:
            COLORREF m_u32Color;
            float m_f32ColorAlphaRatio;
            bool m_bDraw;
 
            bool* m_pArrBModified;
        };

        class FL_EXPORT CGUIStyleAttributeLine
        {
        public:
            CGUIStyleAttributeLine();
            
            CGUIStyleAttributeLine(int32_t i32LineWidth, Foundation::EAttributeDrawingPenStyle ePenStyle);

            CGUIStyleAttributeLine(const CGUIStyleAttributeLine& attrBasic);

            CGUIStyleAttributeLine(const CGUIStyleAttributeLine* pAttrBasic);

            virtual ~CGUIStyleAttributeLine();

            void Clear();

            const CGUIStyleAttributeLine& operator=(const CGUIStyleAttributeLine& attrBasic);

            const CResult Assign(const CGUIStyleAttributeLine& attrBasic);

            const CResult Assign(const CGUIStyleAttributeLine* pAttrBasic);

            const CResult SetLineWidth(int32_t i32LineWidth);

            const CResult GetLineWidth(int32_t& i32LineWidth) const;
            const CResult GetLineWidth(float& f32LineWidth) const;

            int32_t GetLineWidth() const;

            const CResult ClearAttributeLineWidth();

            const CResult SetPenStyle(Foundation::EAttributeDrawingPenStyle ePenStyle);

            const CResult GetPenStyle(Foundation::EAttributeDrawingPenStyle& ePenStyle) const;

            Foundation::EAttributeDrawingPenStyle GetPenStyle() const;

            const CResult ClearAttributePenStyle();

            bool IsParameterModified(EGUIDrawingAttributeLineParameters eAttr) const;
 
        protected:
            int32_t m_i32LineWidth;
            Foundation::EAttributeDrawingPenStyle m_ePenStyle;
 
            bool* m_pArrBModified;
        };

        class FL_EXPORT CGUIStyleAttributeLayout
        {
        public:
            CGUIStyleAttributeLayout();

            CGUIStyleAttributeLayout(const CGUIStyleAttributeLayout& attrBasic);

            CGUIStyleAttributeLayout(const CGUIStyleAttributeLayout* pAttrBasic);

            virtual ~CGUIStyleAttributeLayout();

            void Clear();

            const CGUIStyleAttributeLayout& operator=(const CGUIStyleAttributeLayout& attrBasic);

            const CResult Assign(const CGUIStyleAttributeLayout& attrBasic);

            const CResult Assign(const CGUIStyleAttributeLayout* pAttrBasic);

            const CResult SetMargin(const Base::TRect<int32_t>& tr);

            const CResult GetMargin(Base::TRect<int32_t>& tr) const;

            Base::TRect<int32_t> GetMargin() const;

            const CResult ClearAttributeMargin();

            const CResult SetPadding(const Base::TRect<int32_t>& tr);

            const CResult GetPadding(Base::TRect<int32_t>& tr) const;

            Base::TRect<int32_t> GetPadding() const;

            const CResult ClearAttributePadding();

            bool IsParameterModified(EGUIDrawingAttributeLayoutParameters eAttr) const;
 
        protected:
            Base::TRect<int32_t> m_trMargin;
            Base::TRect<int32_t> m_trPadding;
 
            bool* m_pArrBModified;
        };

        class FL_EXPORT CGUIStyleAttributeTextLayout
        {
        public:
            CGUIStyleAttributeTextLayout();

            CGUIStyleAttributeTextLayout(const CGUIStyleAttributeTextLayout& attrBasic);

            CGUIStyleAttributeTextLayout(const CGUIStyleAttributeTextLayout* pAttrBasic);

            virtual ~CGUIStyleAttributeTextLayout();

            void Clear();

            const CGUIStyleAttributeTextLayout& operator=(const CGUIStyleAttributeTextLayout& attrBasic);

            const CResult Assign(const CGUIStyleAttributeTextLayout& attrBasic);

            const CResult Assign(const CGUIStyleAttributeTextLayout* pAttrBasic);
 
            const CResult SetTextFormat(uint32_t u32Format);
            const CResult GetTextFormat(uint32_t& tr) const;
            uint32_t GetTextFormat() const;
            const CResult ClearAttributeTextFormat();

            const CResult SetPadding(const Base::TRect<int32_t>& tr);

            const CResult GetPadding(Base::TRect<int32_t>& tr) const;

            Base::TRect<int32_t> GetPadding() const;

            const CResult ClearAttributePadding();

            bool IsParameterModified(EGUIDrawingAttributeTextLayoutParameters eAttr) const;
 
        protected:
            uint32_t m_u32TextFormat;
            Base::TRect<int32_t> m_trPadding;
 
            bool* m_pArrBModified;
        };

        class FL_EXPORT CGUIStyleAttributeGeometry
        {
        public:
            CGUIStyleAttributeGeometry();

            CGUIStyleAttributeGeometry(const CGUIStyleAttributeGeometry& attrBasic);

            CGUIStyleAttributeGeometry(const CGUIStyleAttributeGeometry* pAttrBasic);

            virtual ~CGUIStyleAttributeGeometry();

            void Clear();

            const CGUIStyleAttributeGeometry& operator=(const CGUIStyleAttributeGeometry& attrBasic);

            const CResult Assign(const CGUIStyleAttributeGeometry& attrBasic);

            const CResult Assign(const CGUIStyleAttributeGeometry* pAttrBasic);

            const CResult SetCornerRadius(float f32CornerRadius);

            const CResult GetCornerRadius(float& f32CornerRadius) const;

            float GetCornerRadius() const;

            const CResult ClearAttributeCornerRadius();

            const CResult SetCornerRadiusApplyMask(bool bTopLeft, bool bTopRight, bool bBottomRight, bool bBottomLeft);

            const CResult GetCornerRadiusApplyMask(bool& bTopLeft, bool& bTopRight, bool& bBottomRight, bool& bBottomLeft) const;

            const CResult ClearCornerRadiusApplyMask();

            bool IsParameterModified(EGUIDrawingAttributeGeometryParameters eAttr) const;
 
        protected:
            float m_f32CornerRadius;
            bool* m_pArrBApplyCornerRadius;
            bool* m_pArrBModified;
        };

        class FL_EXPORT CGUIStyleAttributeEffects
        {
        public:
            CGUIStyleAttributeEffects();

            CGUIStyleAttributeEffects(const CGUIStyleAttributeEffects& attrBasic);

            CGUIStyleAttributeEffects(const CGUIStyleAttributeEffects* pAttrBasic);

            virtual ~CGUIStyleAttributeEffects();

            void Clear();

            const CGUIStyleAttributeEffects& operator=(const CGUIStyleAttributeEffects& attrBasic);

            const CResult Assign(const CGUIStyleAttributeEffects& attrBasic);

            const CResult Assign(const CGUIStyleAttributeEffects* pAttrBasic);

            const CResult SetShadowOutset(const Base::TRect<int32_t>& tr);

            const CResult GetShadowOutset(Base::TRect<int32_t>& tr) const;

            Base::TRect<int32_t> GetShadowOutset() const;

            const CResult ClearAttributeShadowOutset();

            const CResult SetHighlightInset(const Base::TRect<int32_t>& tr);

            const CResult GetHighlightInset(Base::TRect<int32_t>& tr) const;

            Base::TRect<int32_t> GetHighlightInset() const;

            const CResult ClearAttributeHighlightInset();
 
            const CResult SetDrawShadow(bool bDraw);
            const CResult IsDrawShadow(bool& bDraw) const;
            bool IsDrawShadow() const;
            const CResult ClearAttributeDrawShadow();
 
            const CResult SetDrawHighlight(bool bDraw);
            const CResult IsDrawHighlight(bool& bDraw) const;
            bool IsDrawHighlight() const;
            const CResult ClearAttributeDrawHighlight();

            bool IsParameterModified(EGUIDrawingAttributeEffectsParameters eAttr) const;
 
        protected:
            bool m_bDrawShadow;
            bool m_bDrawHighlight;
            Base::TRect<int32_t> m_trShadowOutset;
            Base::TRect<int32_t> m_trHighlightInset;
 
            bool* m_pArrBModified;
        };
 
        typedef struct sStyleCacheBackBuffer
        {
            sStyleCacheBackBuffer();
            virtual ~sStyleCacheBackBuffer();
            virtual const CResult CreateBackBuffer(CWnd* pParentWnd, CWnd* pThisWnd, CRect rect);
            virtual const CResult DeleteBackBuffer();
            virtual const CResult RefreshBackBufferBackground(CWnd* pParentWnd, CWnd* pThisWnd, const CRect& rect);
 
            CDC& m_dcBk;
            CBitmap& m_bmpBk;
            CBitmap* m_pBmpOldBk;
        }SStyleCacheBackBuffer;
    }
}