TnbMfcAbstractDrawingCtrl.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbSelectedBeltDrawer.h"
#include "TnbBitmapDrawer.h"
#include "TnbSimpleVector.h"
#include "TnbHandleHandle.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CAbstractDrawingCtrl
{
public:
    enum ESelectMarkType
    {
        BACKGROUND,         
        OVERLAP,            
    };
 
 
    //---------------------
 
 
    void SetDefaultMarkDrawer(COLORREF base = ::GetSysColor(COLOR_WINDOW))
    {
        m_pBackgroundDrawer = new CBoxFillDrawer(base);
        m_pSelectMarkDrawer = new CSelectedBeltDrawer(::GetSysColor(COLOR_HIGHLIGHT), base, true);
        m_pNoActiveSelectMarkDrawer = new CSelectedBeltDrawer(::GetSysColor(COLOR_BTNFACE), base, true);
        m_pFocusMarkDrawer = new CFocusFrameDrawer();
        {
            int c1 = ::GetSysColor(COLOR_WINDOW);
            int c2 = ::GetSysColor(COLOR_BTNFACE);
            int r1 = GetRValue(c1);
            int r2 = GetRValue(c2);
            int r = r2 - (r1 - r2);
            r = (r < 0) ? 0 : r;    
            int g1 = GetGValue(c1);
            int g2 = GetGValue(c2);
            int g = g2 - (g1 - g2);
            g = (g < 0) ? 0 : g;    
            int b1 = GetBValue(c1);
            int b2 = GetBValue(c2);
            int b = b2 - (b1 - b2);
            b = (b < 0) ? 0 : b;    
            m_pDisabledStyleDrawer = new CSemitransparentBoxFillDrawer(RGB(r, g, b), 50);
        }
        m_selectMarkType = OVERLAP;
        m_pTextDrawer.Null();
        SetBackColor(base);
    }
 
    bool SetBackgroundDrawer(const IDrawable& draw)
    {
        return m_SetDrawer(m_pBackgroundDrawer, draw);
    }
 
    bool SetSelectMarkDrawer(const IDrawable& draw, ESelectMarkType type = OVERLAP)
    {
        m_selectMarkType = type;
        bool r = m_SetDrawer(m_pSelectMarkDrawer, draw);
        if ( r )
        {
            m_pNoActiveSelectMarkDrawer = m_pSelectMarkDrawer;
        }
        return r;
    }
    
    bool SetSelectMarkDrawer(const IDrawable& draw1, const IDrawable& draw2, ESelectMarkType type = OVERLAP)
    {
        if ( ! SetSelectMarkDrawer(draw1, type) ) { return false; }
        return m_SetDrawer(m_pNoActiveSelectMarkDrawer, draw2);
    }
    
    bool SetFocusMarkDrawer(const IDrawable& draw)
    {
        return m_SetDrawer(m_pFocusMarkDrawer, draw);
    }
 
    bool SetDisabledStyleDrawer(const IDrawable& draw)
    {
        return m_SetDrawer(m_pDisabledStyleDrawer, draw);
    }
 
    void SetBackColor(COLORREF color)
    {
        m_backColor = color;
        if ( color == CLR_INVALID )
        {
            m_backColor = ::GetSysColor(COLOR_WINDOW);
        }
        m_backColorBrush.Null();
    }
 
    void SetTextDrawer(const CTextDrawer& text)
    {
        m_pTextDrawer = static_cast<CTextDrawer*>(text.Clone());
    }
 
    void AdditionRelatedHwnd(HWND hWnd)
    {
        m_wndList.Add(hWnd);
    }
 
    void PostMessageToRelatedHwnd(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
    {
        loop ( i, m_wndList.GetSize() )
        {
            ::PostMessage(m_wndList[i], message, wParam, lParam);
        }
    }
 
protected:
 
    CAbstractDrawingCtrl(void) : m_selectMarkType(OVERLAP), m_backColor(::GetSysColor(COLOR_WINDOW))
    {
    }
 
    virtual ~CAbstractDrawingCtrl(void)
    {
    }
 
    ESelectMarkType GetSelectMarkType(void) const
    {
        return m_selectMarkType;
    }
 
    COLORREF GetBackColor(void) const
    {
        return m_backColor;
    }
 
    void DrawSelectMark(HDC dc, const RECT& rect, bool isActive, LPARAM lParam = 0)
    {
        if ( isActive || m_pNoActiveSelectMarkDrawer.IsNull() )
        {
            m_DrawDrawer(m_pSelectMarkDrawer, dc, rect, lParam);
        }
        else
        {
            m_DrawDrawer(m_pNoActiveSelectMarkDrawer, dc, rect, lParam);
        }
    }
 
    void DrawBackground(HDC dc, const RECT& rect, LPARAM lParam = 0)
    {
        m_DrawDrawer(m_pBackgroundDrawer, dc, rect, lParam);
    }
 
    void DrawFocusMark(HDC dc, const RECT& rect, LPARAM lParam = 0)
    {
        m_DrawDrawer(m_pFocusMarkDrawer, dc, rect, lParam);
    }
 
    void DrawDisabledStyle(HDC dc, const RECT& rect, LPARAM lParam = 0)
    {
        m_DrawDrawer(m_pDisabledStyleDrawer, dc, rect, lParam);
    }
 
    void DrawBackColor(HDC dc, const RECT& rect)
    {
        if ( (rect.bottom - rect.top) > 0 )
        {
            if ( m_backColorBrush.IsNull() )
            {
                m_backColorBrush = ::CreateSolidBrush(m_backColor);
            }
            ::FillRect(dc, &rect, m_backColorBrush);
        }
    }
 
    void DrawText(HDC dc, const RECT& rect, LPCTSTR lpsz, LPARAM lParam = 0)
    {
        if ( ! m_pTextDrawer.IsNull() )
        {
            CSize sz = CRect(rect).Size();
            m_pTextDrawer->Resize(sz - CSize(2, 0));
            m_pTextDrawer->SetString(lpsz);
            m_pTextDrawer->DrawEx(dc, rect.left + 1, rect.top, lParam);
        }
    }
 
    void DrawText(HDC dc, const RECT& rect, LPCTSTR lpsz, DWORD drawStyle, LPARAM lParam = 0)
    {
        if ( ! m_pTextDrawer.IsNull() )
        {
            CSize sz = CRect(rect).Size();
            m_pTextDrawer->SetDrawStyle(drawStyle);
            m_pTextDrawer->Resize(sz - CSize(2, 0));
            m_pTextDrawer->SetString(lpsz);
            m_pTextDrawer->DrawEx(dc, rect.left + 1, rect.top, lParam);
        }
    }
 
    DWORD GetTextDrawStyle(void) const
    {
        if ( ! m_pTextDrawer.IsNull() )
        {
            return m_pTextDrawer->GetDrawStyle();
        }
        return 0;
    }
 
    void SetDefaultTextDrawer(CWnd* pWnd)
    {
        if ( m_pTextDrawer.IsNull() )
        {
            CFont* pFont = pWnd->GetFont();
            m_pTextDrawer = new CTextDrawer(*pFont, CLR_AUTOSELECT, _T(""), DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
        }
    }
 
    void BeginItemPaint(void) 
    {
        loop ( i, m_wndList.GetSize() )
        {
            HWND h = m_wndList[i];
            if ( ::IsWindow(h) )
            {
                MFCLIB::SetProcessingFlag(h, false);
            }
        }
    }
 
    bool EndItemPaint(void) 
    {
        bool res = false;
        for ( INT_PTR i = m_wndList.GetSize() - 1; i >= 0; i-- )
        {
            HWND h = m_wndList[i];
            if ( ::IsWindow(h) )
            {
                BOOL r = MFCLIB::IsProcessingFlag(h);
                if ( r )
                {
                    MFCLIB::SetProcessingFlag(h, false);
                }
                if ( ::IsWindowVisible(h) != r )
                {
                    ::ShowWindow(h, r ? SW_SHOW : SW_HIDE );
                    res = true;
                }
            }
            else
            {
                m_wndList.Remove(i);
            }
        }
        return res;
    }
 
    void AllReset(void)
    {
        m_selectMarkType = OVERLAP;
        m_pSelectMarkDrawer.Null();
        m_pNoActiveSelectMarkDrawer.Null();
        m_pFocusMarkDrawer.Null();
        m_pBackgroundDrawer.Null();
        m_pDisabledStyleDrawer.Null();
        //
        m_backColorBrush.Null();
        m_pTextDrawer.Null();
        m_backColor = ::GetSysColor(COLOR_WINDOW);
        //
        m_wndList.RemoveAll();
    }
 
private:
    bool m_SetDrawer(IDrawable::Ptr& _P, const IDrawable& draw)
    {
        _P = draw.Clone();
        if ( ! _P.IsNull() )
        {
            if ( ! _P->Resize(CSize(1, 1)) )
            {
                _P.Null();
            }
        }
        return ! _P.IsNull();
    }
    // 描画
    void m_DrawDrawer(IDrawable::Ptr& _pDrawer, HDC dc, const RECT& rect, LPARAM lParam = 0)
    {
        if ( ! _pDrawer.IsNull() )
        {
            const CRect& rc = rect;
            if ( ! rc.IsRectEmpty() )
            {
                _pDrawer->Resize(rc.Size());
                _pDrawer->DrawEx(dc, rc.left, rc.top, lParam);
            }
        }
    }
    ESelectMarkType     m_selectMarkType;               
    IDrawable::Ptr      m_pSelectMarkDrawer;            
    IDrawable::Ptr      m_pNoActiveSelectMarkDrawer;    
    IDrawable::Ptr      m_pFocusMarkDrawer;             
    IDrawable::Ptr      m_pBackgroundDrawer;            
    IDrawable::Ptr      m_pDisabledStyleDrawer;         
    //
    CBrushHandle                    m_backColorBrush;   
    CPointerHandleT<CTextDrawer>    m_pTextDrawer;      
    COLORREF                        m_backColor;        
    //
    CSimpleVectorT<HWND>            m_wndList;          
};
 
 
 
}; // MFC
}; // TNB