TnbMfcDrawingHeaderCtrl.h

[詳解]

#pragma once
#include "TnbVector.h"
#include "TnbBitmapImage.h"
#include "TnbTextDrawer.h"
#include "TnbPartsDrawable.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CDrawingHeaderCtrl : public CHeaderCtrl
{
    DEFSUPER(CHeaderCtrl);
public:
 
    CDrawingHeaderCtrl(void) : m_isStateChecking(false), m_isAutoAdjustWidth(true)
        , m_textColor(::GetSysColor(COLOR_WINDOWTEXT)), m_backColor(CLR_INVALID), m_isEnableChangeWidth(true)
    {
        m_pPartsDraw = &m_standardParts;
    }
 
    void SetTextColor(COLORREF color)
    {
        m_textColor = color;
    }
 
    void SetBackground(const IPartsDrawable* pParts, COLORREF color = CLR_INVALID)
    {
        m_pPartsDraw = pParts;
        m_backColor = color;
        if ( m_backBrush.GetSafeHandle() != NULL )
        {
            m_backBrush.DeleteObject();
        }
    }
 
    bool SetColumnDrawer(int col, const IDrawable& draw)
    {
        if ( col >=0 && _super::GetItemCount() > col )
        {
            return m_columnDrawers.Set(col, draw.Clone());
        }
        return false;
    }
 
    void SetAdjustWidthMode(bool b = true)
    {
        m_isAutoAdjustWidth = b;
    }
 
    bool IsAdjustWidthMode(void) const
    {
        return m_isAutoAdjustWidth;
    }
 
    void EnableChangeWidth(bool b = true)
    {
        m_isEnableChangeWidth = b;
    }
 
    bool IsWindow(void) const
    {
        return !! ::IsWindow(_super::GetSafeHwnd());
    }
 
    int GetItemCount() const
    {
        return IsWindow() ? _super::GetItemCount() : 1;
    }
 
    void _deprecated Reset(void)
    {
    }
 
protected:
 
    virtual void PreSubclassWindow(void)
    {
        if ( (GetStyle() & HDS_BUTTONS) == 0 )
        {
            m_isEnableChangeWidth = false;
        }
        _super::PreSubclassWindow();
    }
 
    virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        if ( message == WM_NOTIFY )
        {
            LPNMHDR lpNmHdr = reinterpret_cast<LPNMHDR>(lParam);
            if ( lpNmHdr->code == NM_CUSTOMDRAW ) 
            {
                LPNMLVCUSTOMDRAW P = reinterpret_cast<LPNMLVCUSTOMDRAW>(lParam);
                *_pResult = CDRF_DODEFAULT;
                switch ( P->nmcd.dwDrawStage )
                {
                case CDDS_PREPAINT:
                    *_pResult = CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT;
                    break;
                case CDDS_ITEMPREPAINT:
                    m_columnStates.Set(P->nmcd.dwItemSpec, P->nmcd.uItemState);
                    break;
                }
                return TRUE;
            }
        } 
        return FALSE;
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_PAINT:
            m_Draw(CPaintDC(this));
            return 0;
            break;
        case WM_PRINTCLIENT:
            if ( ! m_isStateChecking )
            {
                HDC dc = reinterpret_cast<HDC>(wParam);
                m_Draw(dc);
                return 0;
            }
            break;
        case WM_ERASEBKGND:
            if ( ! m_isStateChecking )
            {
                return 0;
            }
            break;
        case WM_MOUSEMOVE:
        case WM_SETCURSOR:
        case WM_LBUTTONDBLCLK:
            if ( ! m_isEnableChangeWidth )
            {
                return 0;
            }
            break;
        case HDM_DELETEITEM:
            {
                INDEX col = wParam;
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                if ( r != 0 )
                {
                    m_columnDrawers.Remove(col);
                }
                return r;
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
 
    void m_Draw(HDC dc)
    {
        CRect clientRect;
        _super::GetClientRect(&clientRect);
        // 状態チェックする
        m_isStateChecking = true;
        CBitmapImage orgImg;
        orgImg.SetFromClient(*this, clientRect, CLR_AUTOSELECT); //WM_PRINTCLIENT でカスタムドローを動かし、状態を拾う
        m_isStateChecking = false;
        // アイテム取得オブジェクト用意
        HDITEM hdi;
        enum { sizeOfBuffer = 256 };
        TCHAR lpBuffer[sizeOfBuffer];
        hdi.mask = HDI_TEXT | HDI_WIDTH | HDI_FORMAT;
        hdi.pszText = lpBuffer;
        hdi.cchTextMax = sizeOfBuffer;
        // 各値用意
        CPoint pushOffset;
        m_pPartsDraw->GetPushedOffset(pushOffset);
        CPoint edgeOffset;
        m_pPartsDraw->GetEdgeOffset(edgeOffset);
        int right = clientRect.right;
        CRect parentRect;
        bool isEnabled = !! _super::IsWindowEnabled();
        CWnd* pParent = _super::GetParent();
        if ( pParent != NULL )
        {
            pParent->GetClientRect(&parentRect);
            right = parentRect.right;
            isEnabled = !! pParent->IsWindowEnabled();
        }
        // 幅自動調整
        if ( m_isAutoAdjustWidth )
        {
            CRect rc = clientRect;
            int cnt = _super::GetItemCount();
            for ( int i = 0; i < cnt; i++ )
            {
                if ( ! _super::GetItem(i, &hdi) )
                {
                    continue;
                }
                rc.right = rc.left + hdi.cxy;
                bool r = (rc.right > right);
                if ( i + 1 == cnt )
                {
                    r = (rc.right != right);
                }
                if ( r )
                {
                    HDITEM h;
                    h.mask = HDI_WIDTH;
                    h.cxy = right - rc.left;
                    if ( h.cxy < 0 )
                    {
                        h.cxy = 0;
                    }
                    _super::SetItem(i, &h);
                    rc.right = right;
                }
                rc.left = rc.right;
            }
        }
        // 各アイテム描画
        CRect rc = clientRect;
        loop ( i, _super::GetItemCount() )
        {
            if ( ! _super::GetItem(ToInt(i), &hdi) )
            {
                continue;
            }
            rc.right = rc.left + hdi.cxy;
            //
            CPoint offset = edgeOffset;
            UINT state = DFCS_BUTTONPUSH | DFCS_ADJUSTRECT;
            if ( (m_columnStates[i] & CDIS_SELECTED) != 0 )
            {
                state |= DFCS_PUSHED;
                offset += pushOffset;
            }
            if ( ! isEnabled )
            {
                state |= DFCS_INACTIVE;
            }
            if ( (GetStyle() & HDS_BUTTONS) == 0 )
            {
                state |= DFCS_FLAT;
            }
            CRect r = rc;
            ::FillRect(dc, &r, static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
            m_pPartsDraw->DrawButtonControl(dc, &r, state);
            //
            HRGN hRgn = ::CreateRectRgnIndirect(&r);
            ::SelectClipRgn(dc, hRgn);
            CSize clientSize = rc.Size() - edgeOffset - edgeOffset;
            IDrawable* pDr = m_columnDrawers[i];
            if ( pDr != NULL )
            {
                pDr->Resize(clientSize);
                pDr->Draw(dc, rc.left + offset.x, rc.top + offset.y);
            }
            else
            {
                CFont* pFont = _super::GetFont();
                UINT style = DT_VCENTER | DT_NOPREFIX | DT_END_ELLIPSIS;
                if ( (hdi.fmt & HDF_CENTER) != 0 )
                {
                    style |= DT_CENTER;
                }
                else if ( (hdi.fmt & HDF_RIGHT) != 0 )
                {
                    style |= DT_RIGHT;
                }
                COLORREF c = isEnabled ? m_textColor : CLR_INVALID;
                CTextDrawer d(clientSize, *pFont, c, lpBuffer, style);
                d.Draw(dc, rc.left + offset.x, rc.top + offset.y);
            }
            rc.left = rc.right;
            ::SelectClipRgn(dc, NULL);
            _DeleteObject(hRgn);
        }
        // 余白描画
        if ( rc.right < right )
        {
            rc.right = right;
            if ( IS_RGBVALUE(m_backColor) )
            {
                if ( m_backBrush.GetSafeHandle() == NULL )
                {
                    m_backBrush.CreateSolidBrush(m_backColor);
                }
                ::FillRect(dc, rc, m_backBrush);
            }
            else
            {
                UINT state = DFCS_BUTTONPUSH;
                if ( ! _super::IsWindowEnabled() )
                {
                    state |= DFCS_INACTIVE;
                }
                rc.right += 10; // 右の片を表示させないため
                m_pPartsDraw->DrawButtonControl(dc, &rc, state);
            }
        }
    }
 
    const IPartsDrawable*           m_pPartsDraw;           
    COLORREF                        m_backColor;            
    CBrush                          m_backBrush;            
    COLORREF                        m_textColor;            
    CAutoVectorT<IDrawable::Ptr>    m_columnDrawers;        
    CAutoVectorT<UINT>              m_columnStates;         
    CStandardPartsDrawer            m_standardParts;        
    bool                            m_isStateChecking;      
    bool                            m_isAutoAdjustWidth;    
    bool                            m_isEnableChangeWidth;  
};
 
 
 
}; // MFC
}; // TNB