ODStatic.cpp

Go to the documentation of this file.

#include "StdAfx.h"
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
//
//
//                                                  WTL Control Library
//                                                           by
//                                            Bright Ideas Software®
//                               Copyright © 2018 by Bright Ideas Software.
//
//
//
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------


namespace BIS_WTL_CONTROLS
{
    //----------------------------------------------------------------------------------------------
    CODStatic::CODStatic() noexcept
    {
        m_hMemDC = NULL;
        m_hOldMap = NULL;

        m_bBtnFaceBkgnd = false;
        m_clrTextColor = ::GetSysColor (COLOR_WINDOWTEXT);
        m_clrBackColor = ::GetSysColor (COLOR_BTNFACE);

        m_bMultiLine = false;
        m_bEndEllipsis = false;
        m_bPathEllipsis = false;
        m_vaVertAlign = CVertAlignment::vaMiddle;
        m_haHorzAlign = CHorzAlignment::haLeft;
        m_Text = "";

        m_iHorzMargin = 0;
        m_iVertMargin = 0;

        m_bUseTheme = false;
        m_ThemedBackStyle = CThemedBackgroundStyle::tbMainInstructionPane;
        m_ThemedTextStyle = CThemedTextStyle::ttMainInstruction;

        m_EdgeStyle = CEdgeStyle::esLine;

        m_bDirtyColor = true;
        m_bUpdateContent = true;     // redundant
        m_hbrBackBrush = NULL;

#ifndef _UNICODE
        SetThemeClassList(CA2W("TEXTSTYLE;TASKDIALOG"));
#else
        SetThemeClassList(_T("TEXTSTYLE;TASKDIALOG"));
#endif

    }
    //----------------------------------------------------------------------------------------------
    CODStatic::~CODStatic()
    {

        ATLASSERT(m_hWnd == NULL);

        DestroyGDIStuff();

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CODStatic::SubclassStatic(HWND hWnd)
    {
        CWindowImpl<CODStatic, CStatic>::SubclassWindow(hWnd);

        DWORD style = GetStyle();
        DWORD exstyle = GetExStyle();

        if (style & SS_CENTER)
            m_haHorzAlign =  CHorzAlignment::haCenter;
        else if  ((style & SS_RIGHT) ||(exstyle & WS_EX_RIGHT))
            m_haHorzAlign = CHorzAlignment::haRight;
        else
            m_haHorzAlign = CHorzAlignment::haLeft;

        if (style & SS_LEFTNOWORDWRAP)
        {
            m_bMultiLine = false;
            m_haHorzAlign = CHorzAlignment::haLeft;
        }

        if (style & SS_ENDELLIPSIS)
        {
            m_bMultiLine = false;
            m_haHorzAlign = CHorzAlignment::haLeft;
            m_bEndEllipsis = true;
        }
        else
            m_bEndEllipsis = false;

        GetWindowText(m_Text);

        OpenThemeData();

        ModifyStyle(0, SS_NOTIFY | SS_OWNERDRAW);

    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::UnSubclassStatic()
    {
        DestroyGDIStuff();

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }

        CloseThemeData();

        UnsubclassWindow();
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    bool CODStatic::GetBtnFaceBkgnd() const
    {
        return(m_bBtnFaceBkgnd);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetBtnFaceBkgnd(bool value)
    {
        if (m_bBtnFaceBkgnd != value)
        {
            m_bDirtyColor = true;
            m_bBtnFaceBkgnd = value;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    COLORREF CODStatic::GetBackColor() const
    {
        return(m_clrBackColor);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetBackColor(COLORREF value)
    {
        if (m_clrBackColor != value)
        {
            m_bDirtyColor = true;
            m_clrBackColor = value;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    COLORREF CODStatic::GetTextColor() const
    {
        return(m_clrTextColor);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetTextColor(COLORREF value)
    {
        if (m_clrTextColor != value)
        {
            m_bUpdateContent = true;
            m_clrTextColor = value;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    std::basic_string<TCHAR> CODStatic::GetCaption()    const
    {
        return((LPCTSTR)m_Text);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetCaption(LPCTSTR text)
    {
        if (m_Text.Compare(text) != 0)
        {
            m_Text = text;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    bool CODStatic::GetMultilineEnabled() const
    {
        return(m_bMultiLine);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetMultilineEnabled(bool value)
    {
        if (m_bMultiLine != value)
        {
            m_bMultiLine = value;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    bool CODStatic::GetEndEllipsisEnabled() const
    {
        return(m_bEndEllipsis);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetEndEllipsisEnabled(bool value)
    {
        if (m_bEndEllipsis != value)
        {
            m_bEndEllipsis = value;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    bool CODStatic::GetPathEllipsisEnabled() const
    {
        return(m_bPathEllipsis);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetPathEllipsisEnabled(bool value)
    {
        if (m_bPathEllipsis != value)
        {
            m_bPathEllipsis = value;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CHorzAlignment CODStatic::GetHorzTextAlignment() const
    {
        return(m_haHorzAlign);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetHorzTextAlignment(CHorzAlignment value)
    {
        if (m_haHorzAlign != value)
        {
            m_haHorzAlign = value;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CVertAlignment CODStatic::GetVertTextAlignment() const
    {
        return(m_vaVertAlign);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetVertTextAlignment(CVertAlignment value)
    {
        if (m_vaVertAlign != value)
        {
            m_vaVertAlign = value;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CEdgeStyle CODStatic::GetEdgeStyle() const
    {
        return(m_EdgeStyle);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetEdgeStyle(CEdgeStyle style)
    {
        if (m_EdgeStyle != style)
        {
            m_EdgeStyle = style;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    int CODStatic::GetVerticalMargin() const
    {
        return(m_iVertMargin);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetVerticalMargin(int margin)
    {
        if ((margin >= 0)&&(m_iVertMargin != margin))
        {
            m_iVertMargin = margin;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    int CODStatic::GetHorizontalMargin() const
    {
        return(m_iHorzMargin);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetHorizontalMargin(int margin)
    {
        if ((margin >= 0)&&(m_iHorzMargin != margin))
        {
            m_iHorzMargin = margin;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    bool CODStatic::IsUsingThemedStyle() const
    {
        return(m_bUseTheme);
    }
    //----------------------------------------------------------------------------------------------

    void CODStatic::UseThemedStyle(bool val)
    {
        if (m_bUseTheme != val)
        {
            m_bUseTheme = val;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CThemedBackgroundStyle CODStatic::GetThemedBackgroundStyle() const
    {
        return(m_ThemedBackStyle);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetThemedBackgroundStyle(CThemedBackgroundStyle val)
    {
        if (val != m_ThemedBackStyle)
        {
            m_ThemedBackStyle = val;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    CThemedTextStyle CODStatic::GetThemedTextStyle()  const
    {
        return(m_ThemedTextStyle);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::SetThemedTextStyle(CThemedTextStyle val)
    {
        if (m_ThemedTextStyle != val)
        {
            m_ThemedTextStyle = val;
            m_bUpdateContent = true;
        }
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CODStatic::UpdateContent()
    {
        m_bUpdateContent = true;
        Invalidate();
        UpdateWindow(); 
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //
    //                                                      Private Methods
    //
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    int CODStatic::GetEdgeOffset(int metric)
    {
        int retval = 0;

        switch(m_EdgeStyle)
        {
            case CEdgeStyle::esNone:
            break;

        case CEdgeStyle::esLine:
        case CEdgeStyle::esThinRaised:
        case CEdgeStyle::esThinSunken:
            retval = 1;
            break;

        case CEdgeStyle::esBump:
        case CEdgeStyle::esEtched:
        case CEdgeStyle::esRaised:
        case CEdgeStyle::esSunken:
            retval = ::GetSystemMetrics(metric);
            break;
        }

        return(retval);
    }
    //----------------------------------------------------------------------------------------------
    int CODStatic::GetHorzEdgeHeight()
    {
        return (GetEdgeOffset(SM_CXEDGE));
    }         
    //----------------------------------------------------------------------------------------------
    int CODStatic::GetVertEdgeWidth()
    {
        return (GetEdgeOffset(SM_CYEDGE));
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    void CODStatic::PrepareGDIStuff()
    {
        DestroyGDIStuff();

        CRect r;
        GetClientRect(&r);

        if (IsWindow())
        {
            if ((r.Width() > 0)&&(r.Height() > 0))
            {
                m_hCanvas.Create(r.Width(), r.Height(), 24, 0);

                if (! m_hCanvas.IsNull())
                {

                    HDC dc = ::GetDC(m_hWnd);
                    m_hMemDC = ::CreateCompatibleDC(dc);

                    if (m_hMemDC != NULL)
                        m_hOldMap = (HBITMAP)::SelectObject(m_hMemDC, (HBITMAP)m_hCanvas);
                    else
                        m_hCanvas.Destroy();

                    ::ReleaseDC(m_hWnd, dc);
                    m_bUpdateContent = true;
                }
            }
        }
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::DestroyGDIStuff()
    {

        if (m_hMemDC != NULL)
        {
            if (! m_hCanvas.IsNull())
            {
                ::SelectObject(m_hMemDC, m_hOldMap);
                m_hOldMap = NULL;

                m_hCanvas.Destroy();
            }
            ::DeleteDC(m_hMemDC);
            m_hMemDC = NULL; 
        }

    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    UINT CODStatic::GetTextFormat()
    {
        UINT format = DT_EDITCONTROL;

        switch (m_haHorzAlign)
        {
            case CHorzAlignment::haLeft:
            format = DT_LEFT;
            break;
        case CHorzAlignment::haRight:
            format = DT_RIGHT;
            break;
        case CHorzAlignment::haCenter:
            format = DT_CENTER;
            break;
        }

        switch (m_vaVertAlign)
        {
        case CVertAlignment::vaTop:
            format |= DT_TOP;
            break;
        case CVertAlignment::vaMiddle:
            format |= DT_VCENTER;
            break;
        case CVertAlignment::vaBottom:
            format |= DT_BOTTOM;
            break;
        }

        if (m_bMultiLine == true)
            format = format |DT_WORDBREAK ;
        else
            format = format | DT_SINGLELINE ;

        if (m_bEndEllipsis == true)                     
            format = format | DT_END_ELLIPSIS;  

        if (m_bPathEllipsis == true)
            format = format | DT_PATH_ELLIPSIS;

        format |= DT_NOCLIP;

        return  (format);

    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::DrawEdge(CRect r)
    {

        switch (m_EdgeStyle)
        {
            case CEdgeStyle::esNone:
            break;
        case CEdgeStyle::esLine:
            OutlineRect(m_hMemDC, r);
            break;
        case CEdgeStyle::esBump:
            ::DrawEdge(m_hMemDC, r, EDGE_BUMP,BF_RECT  );
            break;
        case CEdgeStyle::esEtched:
            ::DrawEdge(m_hMemDC, r, EDGE_ETCHED,BF_RECT );
            break;
        case CEdgeStyle::esRaised:
            ::DrawEdge(m_hMemDC, r, EDGE_RAISED,BF_RECT );
            break;
        case CEdgeStyle::esSunken:
            ::DrawEdge(m_hMemDC, r, EDGE_SUNKEN,BF_RECT);
            break;
        case CEdgeStyle::esThinRaised:
            ::DrawEdge(m_hMemDC, r, BDR_RAISEDOUTER,BF_RECT );
            break;
        case CEdgeStyle::esThinSunken:
            ::DrawEdge(m_hMemDC, r, BDR_SUNKENOUTER,BF_RECT);
            break;
        }
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::UpdateBackBrush()
    {
        m_bDirtyColor = false;

        if (m_hbrBackBrush != NULL)
        {
            ::DeleteObject (m_hbrBackBrush);
            m_hbrBackBrush = NULL;
        }

        if (m_bBtnFaceBkgnd == false)
            m_hbrBackBrush = ::CreateSolidBrush (m_clrBackColor);

        m_bUpdateContent = true;
    }
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    //
    //                                                          Message Handlers
    //
    //----------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------
    BOOL CODStatic::OnEraseBkgnd(CDCHandle dc)
    {
        return(TRUE);
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::OnSysColorChange()
    {
        if (m_bBtnFaceBkgnd == true)
            UpdateContent();
    }
    //----------------------------------------------------------------------------------------------
    void CODStatic::DrawItem(LPDRAWITEMSTRUCT lp)
    {

        CRect rect;
        HFONT cfont;
        HDC dc;
        HFONT oldfont;

        if (m_bDirtyColor == true)
            UpdateBackBrush();

        cfont = GetFont();
        dc = lp->hDC;

        GetClientRect(&rect);

        if  ((m_hMemDC == NULL)||( m_hCanvas.IsNull()))
            PrepareGDIStuff();

        if ((m_hMemDC != NULL)&&( ! m_hCanvas.IsNull()))
        {

            if ((rect.Width() != m_hCanvas.GetWidth())||(rect.Height() != m_hCanvas.GetHeight()))
                PrepareGDIStuff();

            if (m_bUpdateContent == true)
            {

                m_bUpdateContent = false;

                if ((IsThemeNull())||(m_bUseTheme == false))
                {
                    if (m_bBtnFaceBkgnd == false)
                    {
                        ::FillRect(m_hMemDC, rect, m_hbrBackBrush);
                        ::SetBkColor(m_hMemDC, m_clrBackColor);
                    }
                    else
                    {
                        ::FillRect(m_hMemDC, rect, ::GetSysColorBrush(COLOR_BTNFACE));
                        ::SetBkColor(m_hMemDC, ::GetSysColor(COLOR_BTNFACE));
                    }

                    if (IsWindowEnabled())
                        ::SetTextColor(m_hMemDC, m_clrTextColor);
                    else
                        ::SetTextColor(m_hMemDC, ::GetSysColor(COLOR_GRAYTEXT));
                }
                else
                {
                    UINT task_dialog_part = 0;
                    switch(m_ThemedBackStyle)
                    {
                        case CThemedBackgroundStyle::tbPrimaryPanel:
                            task_dialog_part = TDLG_PRIMARYPANEL;
                        break;
                        
                        case CThemedBackgroundStyle::tbMainInstructionPane:
                            task_dialog_part = TDLG_MAININSTRUCTIONPANE;
                        break;
                        
                        case CThemedBackgroundStyle::tbContentPane:
                            task_dialog_part = TDLG_CONTENTPANE;
                        break;
                        
                        case CThemedBackgroundStyle::tbSecondaryPanel:
                            task_dialog_part = TDLG_SECONDARYPANEL;
                        break;
                        
                        case CThemedBackgroundStyle::tbControlPane:
                            task_dialog_part = TDLG_CONTROLPANE;
                        break;
                    };
                    DrawThemeBackground(m_hMemDC, task_dialog_part, 0, rect);  
                }

                UINT format = GetTextFormat();

                CRect text_rect;
                text_rect.CopyRect(&rect);

                int border_height = GetHorzEdgeHeight();
                int border_width = GetVertEdgeWidth();
                text_rect.DeflateRect(border_width, border_height, border_width, border_height);
                text_rect.DeflateRect(m_iHorzMargin, m_iVertMargin, m_iHorzMargin, m_iVertMargin);

                if ((IsThemeNull())||(m_bUseTheme == false))
                {
                    oldfont = (HFONT)::SelectObject(m_hMemDC, cfont);
                    ::DrawText(m_hMemDC, m_Text, m_Text.GetLength(), text_rect, format);
                    ::SelectObject(m_hMemDC, oldfont);
                }
                else
                {

                    UINT text_part = 0;
                    UINT text_state = 0;

                    switch (m_ThemedTextStyle)
                    {
                        case CThemedTextStyle::ttMainInstruction:
                            text_part = TEXT_MAININSTRUCTION;
                        break;

                        case CThemedTextStyle::ttInstruction:
                            text_part = TEXT_INSTRUCTION;
                        break;

                        case CThemedTextStyle::ttBodyTitle:
                            text_part = TEXT_BODYTITLE;
                        break;

                        case CThemedTextStyle::ttBodyText:
                            text_part = TEXT_BODYTEXT;
                        break;

                        case CThemedTextStyle::ttSecondaryText:
                            text_part = TEXT_SECONDARYTEXT;
                        break;

                        case CThemedTextStyle::ttLabel:
                            text_part = TEXT_LABEL;
                        break;                          

                        case CThemedTextStyle::ttControlLabel_Normal:
                            text_part = TEXT_CONTROLLABEL;
                            text_state = TS_CONTROLLABEL_NORMAL;
                        break;

                        case CThemedTextStyle::ttControlLabel_Disabled:
                            text_part = TEXT_CONTROLLABEL;
                            text_state = TS_CONTROLLABEL_DISABLED;
                        break;
                    }

#ifndef _UNICODE
                    DrawThemeText(m_hMemDC, text_part ,text_state, CA2W(m_Text), m_Text.GetLength(), format, 0, text_rect);
#else
                    DrawThemeText(m_hMemDC, text_part, text_state, m_Text, m_Text.GetLength(), format, 0, text_rect);
#endif
                }

                DrawEdge(rect);

            }

            ::BitBlt (dc, 0, 0,rect.Width (), rect.Height (), m_hMemDC, 0, 0, SRCCOPY);

        }
    }
    //----------------------------------------------------------------------------------------------
};