TnbMfcRowHeaderCtrl.h

[詳解]

#pragma once
#include "TnbWindowProcedureHooker.h"
#include "TnbBitmapImage.h"
#include "TnbDrawable.h"
#include "TnbMfcBitmapDC.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CRowHeaderCtrl : public CWnd
{
    DEFSUPER(CWnd);
public:
 
    CRowHeaderCtrl(void) : m_pBuddyCtrl(NULL), m_headerWidth(0), m_offset(2, 0)
        , m_textColor(::GetSysColor(COLOR_WINDOWTEXT)), m_backColor(::GetSysColor(COLOR_BTNFACE))
        , m_hCursor(NULL), m_isWidthVariable(true), m_textStyle(DT_LEFT | DT_VCENTER), m_hasCapture(false)
        , m_isPartialOk(false)
    {
    }
 
    void SetTextStyle(DWORD ts)
    {
        m_textStyle = ts;
    }
 
    void SetPartialView(bool isPartialOk = false)
    {
        m_isPartialOk = isPartialOk;
    }
 
    void SetTextColor(COLORREF color)
    {
        m_textColor = color;
    }
    
    void SetHeaderDrawer(const IDrawable* pDrawer = NULL)
    {
        m_phHeaderDrawer.Null();
        if ( pDrawer != NULL )
        {
            m_phHeaderDrawer = pDrawer->Clone();
        }
        Invalidate(FALSE);
    }
 
    void SetBackground(COLORREF color, const IDrawable* pBkDrawer = NULL, int offsetX = 2, int offsetY = 0)
    {
        m_backColor = color;
        m_phBkDrawer.Null();
        m_offset.x = offsetX;
        m_offset.y = offsetY;
        if ( pBkDrawer != NULL )
        {
            m_phBkDrawer = pBkDrawer->Clone();
        }
        if ( ::IsWindow(_super::GetSafeHwnd()) )
        {
            _super::Invalidate(FALSE);
        }
    }
 
    bool SetBuddy(CListCtrl* pCtrl, size_t headerWidth, bool isWidthVariable = false)
    {
        if ( m_pBuddyCtrl == NULL )
        {
            if ( pCtrl != NULL && ::IsWindow(pCtrl->GetSafeHwnd()) )
            {
                m_myHooker.m_hParent = GetSafeHwnd();
                m_myHooker.Attach(pCtrl->GetSafeHwnd());
                pCtrl->ModifyStyle(WS_BORDER, 0);
                pCtrl->ModifyStyleEx(WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE, 0);
                SetWindowPos(pCtrl, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
                bool isVisible = (GetStyle() & WS_VISIBLE) != 0;
                ShowWindow(isVisible ? SW_SHOW : SW_HIDE);
                SetFont(pCtrl->GetFont());
                //
                m_headerWidth = down_cast<int>(headerWidth);
                m_isWidthVariable = isWidthVariable;
                m_pBuddyCtrl = pCtrl;
                m_params.SetSize(pCtrl->GetItemCount());
                m_RewidthHeader();
                return true;
            }
        }
        return false;
    }
 
    void SetHeaderWidth(size_t headerWidth, bool isWidthVariable = false)
    {
        m_headerWidth = down_cast<int>(headerWidth);
        m_isWidthVariable = isWidthVariable;
        m_RewidthHeader();
    }
 
    size_t GetHeaderWidth(void) const
    {
        return m_headerWidth;
    }
 
    size_t GetItemCount(void) const
    {
        if ( m_pBuddyCtrl != NULL )
        {
            ASSERT( ToInt(m_params.GetSize()) == m_pBuddyCtrl->GetItemCount() );
        }
        return m_params.GetSize();
    }
 
    bool SetItemDrawer(int item, const IDrawable& draw)
    {
        if ( m_params.IsInRange(item) )
        {
            m_params[item].phDraw = draw.Clone();
            Invalidate(FALSE);
            return true;
        }
        return false;
    }
 
    bool SetItemText(int item, LPCTSTR lpszText)
    {
        if ( m_params.IsInRange(item) )
        {
            m_params[item].phDraw.Null();
            m_params[item].text = lpszText;
            Invalidate(FALSE);
            return true;
        }
        return false;
    }
 
    int InsertItem(int item, LPCTSTR lpszItem)
    {
        if ( m_pBuddyCtrl != NULL )
        {
            int r = m_pBuddyCtrl->InsertItem(item, _T(""));
            if ( r >= 0 )
            {
                SetItemText(r, lpszItem);
            }
            return r;
        }
        return -1;
    }
 
    int InsertItem(int item, const IDrawable& draw)
    {
        int r = InsertItem(item, _T(""));
        if ( r >= 0 )
        {
            SetItemDrawer(r, draw);
        }
        return r;
    }
 
    int HitTest(const CPoint& pt) const
    {
        int r = -1;
        if ( m_pBuddyCtrl != NULL )
        {
            CRect rc;
            GetClientRect(rc);
            if ( rc.PtInRect(pt) )
            {
                CHeaderCtrl* pHead = m_pBuddyCtrl->GetHeaderCtrl();
                if ( pHead != NULL )
                {
                    pHead->GetWindowRect(rc);
                    if ( pt.y >= rc.Height() )
                    {
                        r = m_pBuddyCtrl->HitTest(CPoint(0, pt.y));
                    }
                    else
                    {
                        r = -99; //　ヘッダ部
                    }
                }
            }
        }
        return r;
    }
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case CMyHooker::WM_RHC_HOOKMESSAGE:
            {
                CMyHooker::TMsg* P = reinterpret_cast<CMyHooker::TMsg*>(lParam);
                if ( P != NULL )
                {
                    m_BuddyWindowProc(P->message, P->wParam, P->lParam, P->lResult);
                }
            }
            break;
        case WM_SIZE:
            m_RewidthHeader();
            break;
        case WM_MOVE:
            m_RewidthHeader();
            break;
        case WM_ERASEBKGND:
            return 0;
        case WM_PAINT:
            m_Draw(CPaintDC(this));
            return 0;
        case WM_LBUTTONDOWN:
            if ( m_isWidthVariable )
            {
                CPoint pos(lParam);
                if ( m_IsDragSpace(pos) )
                {
                    ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
                    ::SetCapture(GetSafeHwnd());
                    m_hasCapture = true;
                    m_captureStartPos = CPoint(lParam);
                    m_captureStartHeaderWidth = m_headerWidth;
                }
            }
            break;
        case WM_LBUTTONUP:
            if ( m_hasCapture )
            {
                ::ReleaseCapture();
                m_hasCapture = false;
            }
            break;
        case WM_RBUTTONDOWN:
            if ( m_hasCapture )
            {
                ::ReleaseCapture();
                m_hasCapture = false;
                m_headerWidth = m_captureStartHeaderWidth;
                m_RewidthHeader();
            }
            break;
        case WM_MOUSEMOVE:
            if ( m_isWidthVariable )
            {
                if ( m_hCursor == NULL )
                {
                    m_hCursor = ::GetCursor();
                }
                CPoint pos(lParam);
                if ( m_hasCapture )
                {
                    ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
                    int x = m_captureStartHeaderWidth + pos.x - m_captureStartPos.x;
                    CRect rc;
                    GetClientRect(rc);
                    int l = rc.Width() - 5;
                    if ( x > l )
                    {
                        x = l;
                    }
                    if ( x < 5 )
                    {
                        x = 5;
                    }
                    m_headerWidth = x;
                    m_RewidthHeader();
                    if ( m_pBuddyCtrl != NULL )
                    {
                        m_pBuddyCtrl->GetHeaderCtrl()->RedrawWindow();  //カラムの再描画により再カラム幅調整をする
                    }
                }
                else if ( m_IsDragSpace(pos) )
                {
                    ::SetCursor(::LoadCursor(NULL, IDC_SIZEWE));
                }
                else
                {
                    ::SetCursor(m_hCursor);
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        m_pBuddyCtrl = NULL;
        m_hCursor = NULL;
        _super::ModifyStyle(0, SS_NOTIFY);
        _super::PreSubclassWindow();
    }
 
private:
    // ヘッダの幅変更
    void m_RewidthHeader(void)
    {
        if ( m_pBuddyCtrl != NULL )
        {
            CRect rc;
            GetClientRect(rc);
            ClientToScreen(rc);
            GetParent()->ScreenToClient(rc);
            rc.left += m_headerWidth;
            m_pBuddyCtrl->SetWindowPos(NULL, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER);
        }
    }
    // ドラック空間？
    bool m_IsDragSpace(const POINT& pos) const
    {
        if ( m_pBuddyCtrl != NULL )
        {
            CRect headerRect;
            CHeaderCtrl* pHead = m_pBuddyCtrl->GetHeaderCtrl();
            pHead->GetClientRect(headerRect);
            if ( pos.x >= m_headerWidth - 5 && pos.x <= m_headerWidth )
            {
                if ( pos.y < headerRect.Height() )
                {
                    return true;
                }
            }
        }
        return false;
    }
            
    // 背景描画
    void m_BkDraw(HDC hdc, const CRect& rect)
    {
        if ( m_phBkDrawer != NULL )
        {
            m_phBkDrawer->Resize(rect.Size());
            m_phBkDrawer->Draw(hdc, rect.left, rect.top);
        }
        else
        {
            CRect r = rect;
            r.top = r.bottom - 1;
            ::InvertRect(hdc, r);
            r = rect;
            r.left = r.right - 1;
            ::InvertRect(hdc, r);
        }
    }
    // 全体描画
    void m_Draw(HDC hdc)
    {
        CRect clientRect;
        GetClientRect(clientRect);
        CBitmapImage bi;
        bi.Set(m_headerWidth, clientRect.Height(), m_backColor);
        if ( m_pBuddyCtrl != NULL )
        {
            CBitmapDC dc(&bi);
            CDcSelectAssistant dsa(dc);
            dsa.SetBkMode(TRANSPARENT);
            dsa.SelectFont(GetFont());
            dsa.SetTextColor(m_textColor);
            {
                // ヘッダ部
                CRect headerRect;
                CHeaderCtrl* pHead = m_pBuddyCtrl->GetHeaderCtrl();
                pHead->GetClientRect(headerRect);
                CRect r = headerRect;
                r.left = 0;
                r.right = m_headerWidth;
                m_BkDraw(dc, r);
                if ( ! m_phHeaderDrawer.IsNull() )
                {               
                    m_phHeaderDrawer->Resize(r.Size());
                    m_phHeaderDrawer->Draw(dc, r.left, r.top);
                }
            }
            int count = m_pBuddyCtrl->GetItemCount();
            int cpp = m_pBuddyCtrl->GetCountPerPage();
            int si = m_pBuddyCtrl->GetTopIndex();
            loop ( i, cpp + (m_isPartialOk ? 1 : 0) )
            {
                if ( si >= count )
                {
                    break;
                }
                CRect rc;
                m_pBuddyCtrl->GetItemRect(si, rc, LVIR_BOUNDS);
                rc.left = 0;
                rc.right = m_headerWidth;
                m_BkDraw(dc, rc);
                rc.left += m_offset.x;
                rc.top += m_offset.y;
                HRGN hRgn = ::CreateRectRgnIndirect(&rc);
                ::SelectClipRgn(dc, hRgn);
                if ( m_params.IsInRange(si) )
                {
                    TParam& prm = m_params[si];
                    if ( prm.phDraw.IsNull() )
                    {
                        ::DrawText(dc, prm.text, -1, rc, m_textStyle);
                    }
                    else
                    {
                        prm.phDraw->Resize(rc.Size());
                        prm.phDraw->Draw(dc, rc.left, rc.top);
                    }
                }
                ::SelectClipRgn(dc, NULL);
                _DeleteObject(hRgn);    
                si++;
            }
        }
        bi.Draw(hdc);
    }
    // 相棒のプロシージャ
    void m_BuddyWindowProc(UINT message, WPARAM wParam, LPARAM lParam, LRESULT lResult)
    {
        switch ( message )
        {
        case WM_KEYDOWN:
        case WM_VSCROLL:
        case WM_MOUSEWHEEL:
        case WM_SIZE:
            {
                CRect rc;
                GetClientRect(rc);
                rc.right = m_headerWidth;
                InvalidateRect(rc, FALSE);
            }
            break;
        case WM_SHOWWINDOW:
            _super::ShowWindow((wParam != FALSE) ? SW_SHOW : SW_HIDE);
            break;
        case LVM_INSERTITEM:
            if ( lResult >= 0 )
            {
                m_params.Insert(lResult, TParam());
            }
            break;
        case LVM_DELETEITEM:
            if ( lResult != 0 )
            {
                m_params.Remove(wParam);
            }
            break;
        case LVM_DELETEALLITEMS:
            if ( lResult != 0 )
            {
                m_params.RemoveAll();
            }
            break;
        }
    }
 
    class CMyHooker : public CWindowProcedureHooker
    {
        DEFSUPER(CWindowProcedureHooker);
    public:
        enum
        {
            WM_RHC_HOOKMESSAGE = WM_APP,    
        };
        struct TMsg
        {
            LRESULT lResult;        
            UINT    message;        
            WPARAM  wParam;         
            LPARAM  lParam;         
        };
        HWND    m_hParent;          
    protected:
        virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
        {
            switch ( message )
            {
            case WM_SHOWWINDOW:
            case WM_KEYDOWN:
            case WM_VSCROLL:
            case WM_MOUSEWHEEL:
            case WM_SIZE:
            case LVM_INSERTITEM:
            case LVM_DELETEITEM:
            case LVM_DELETEALLITEMS:
                {
                    LRESULT r = _super::WindowProc(message, wParam, lParam);
                    TMsg msg = { 0 };
                    msg.message = message;
                    msg.wParam = wParam;
                    msg.lParam = lParam;
                    msg.lResult = r;
                    ::SendMessage(m_hParent, WM_RHC_HOOKMESSAGE, NULL, reinterpret_cast<LPARAM>(&msg));
                    return r;
                }
                break;
            default:
                break;
            }
            return _super::WindowProc(message, wParam, lParam);
        }
    };
 
    struct TParam
    {
        CStr            text;       
        IDrawable::Ptr  phDraw;     
    };
 
    TParam              m_headParam;                
    CVectorT<TParam>    m_params;                   
    COLORREF            m_textColor;                
    IDrawable::Ptr      m_phHeaderDrawer;           
    IDrawable::Ptr      m_phBkDrawer;               
    COLORREF            m_backColor;                
    CMyHooker           m_myHooker;                 
    CListCtrl*          m_pBuddyCtrl;               
    int                 m_headerWidth;              
    CPoint              m_offset;                   
    DWORD               m_textStyle;                
    bool                m_isWidthVariable;          
    HCURSOR             m_hCursor;                  
    bool                m_hasCapture;               
    CPoint              m_captureStartPos;          
    int                 m_captureStartHeaderWidth;  
    bool                m_isPartialOk;              
};
 
 
 
}; // MFC
}; // TNB