TnbMfcDrawingTreeCtrl.h

[詳解]

#pragma once
#include "TnbMfcAbstractCustomDraw.h"
#include "TnbMfcAbstractDrawingCtrl.h"
#include "TnbMap.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
#define TVC_CHECKCHANGED 0xFFFF
 
 
 
class CDrawingTreeCtrl : public CTreeCtrl, public CAbstractDrawingCtrl, protected CAbstractCustomDraw
{
    DEFSUPER(CTreeCtrl);
    typedef CAbstractCustomDraw _custom; 
    typedef CAbstractDrawingCtrl _mark; 
 
    void m_DrawSelectMaker(HDC dc, const RECT& rect, HTREEITEM h)
    {
        if ( (GetItemState(h, TVIS_SELECTED ) & TVIS_SELECTED) != 0  )
        {
            _mark::DrawSelectMark(dc, rect, ::GetFocus() == m_hWnd);
        }
    }
 
    void m_DeleteItem(HTREEITEM h)
    {
        HTREEITEM hh = _super::GetChildItem(h);
        while ( hh != NULL )
        {
            m_DeleteItem(hh);
            hh = _super::GetNextSiblingItem(hh);
        }
        m_map.RemoveKey(h);
    }
 
    void m_NotifyParent(HTREEITEM h)
    {
        NMTREEVIEW nm = { 0 };
        nm.hdr.hwndFrom = *this;
        nm.hdr.idFrom = GetDlgCtrlID();
        nm.hdr.code = TVN_SELCHANGED;
        nm.action = TVC_CHECKCHANGED;
        nm.itemOld.hItem = h;
        nm.itemNew.hItem = h;
        GetParent()->SendMessage(WM_NOTIFY, GetDlgCtrlID(), reinterpret_cast<LPARAM>(&nm));
    }
 
protected:
 
    virtual void OnBeginItemPaint(HDC dc) 
    {
        m_lowLine = 0;
        _mark::BeginItemPaint();
    }
 
    virtual void OnEndItemPaint(HDC dc) 
    {
        bool r = _mark::EndItemPaint();
        // 描画していないところを描画
        CRect rc;
        GetClientRect(rc);
        rc.top = m_lowLine;
        _mark::DrawBackColor(dc, rc);
        // 再描画
        if ( r )
        {
            Invalidate();
        }
    }
 
    virtual LRESULT OnItemPainting(TDrawParam* P)
    {
        HRGN rgn = ::CreateRectRgnIndirect(&P->rect);
        ::ExtSelectClipRgn(P->dc, rgn, RGN_DIFF);
        _DeleteObject(rgn);
        m_lowLine = max(m_lowLine, P->rect.bottom);
        // チェックボックスの周りが透過するので書いておく
        _mark::DrawBackColor(P->dc, CRect(0, P->rect.top, P->rect.left, P->rect.bottom));
        return CDRF_NOTIFYITEMDRAW;     // チェックボックス、線を描いてもらう
    }
 
    virtual void OnItemPainted(const TDrawParam* P) 
    {
        HTREEITEM h = reinterpret_cast<HTREEITEM>(P->itemNo);
        ::SelectClipRgn(P->dc, NULL);
        //
        CString str = GetItemText(h);
        IDrawable* pDraw = m_map[h];
        CRect rc = P->rect;
        //
        if ( pDraw != NULL && ! str.IsEmpty() )
        {
            // BG持ち描画情報用処理
            pDraw->Resize(rc.Size());
            pDraw->Draw(P->dc, rc.left, rc.top);
            pDraw->Draw(NULL, rc.left, rc.top);
            if ( _mark::GetSelectMarkType() == OVERLAP )
            {
                m_DrawSelectMaker(P->dc, rc, h);
            }
            if ( (P->state & CDIS_FOCUS) != 0 )
            {
                _mark::DrawFocusMark(P->dc, rc);
            }
            return;
        }
        rc.OffsetRect(-rc.TopLeft());
        CBitmapImage bi;
        bi.Set(rc.Width(), rc.Height(), _mark::GetBackColor());
        if ( ! bi.IsEmpty() )
        {
            CBitmapDC dc(&bi);
            _mark::DrawBackground(dc, rc);
            if ( _mark::GetSelectMarkType() == BACKGROUND )
            {
                m_DrawSelectMaker(dc, rc, h);
            }
            if ( pDraw != NULL )
            {
                pDraw->Resize(rc.Size());
                pDraw->Draw(dc, 0, 0);
            }
            else
            {
                _mark::SetDefaultTextDrawer(this);
                _mark::DrawText(dc, rc, str);
            }
            if ( _mark::GetSelectMarkType() == OVERLAP )
            {
                m_DrawSelectMaker(dc, rc, h);
            }
            if ( (P->state & CDIS_FOCUS) != 0 )
            {
                _mark::DrawFocusMark(dc, rc);
            }
            dc.Draw(P->dc, P->rect.left, P->rect.top);
            if ( pDraw != NULL )
            {
                pDraw->Draw(NULL, P->rect.left, P->rect.top);
            }
        }
    }
 
    virtual bool HasSubItem(void) const
    {
        return false;
    }
 
    virtual void OnCalcItemRect(TDrawParam& _pa, bool isSub)
    {
        CRect rc;
        _super::GetItemRect(reinterpret_cast<HTREEITEM>(_pa.itemNo), rc, TRUE);
        _pa.rect.left = rc.left;    // テキストの始まる線にする
    }
 
    virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* _pResult)
    {
        if ( message == WM_NOTIFY )
        {
            LPNMHDR lpNmHdr = reinterpret_cast<LPNMHDR>(lParam);
            if ( lpNmHdr->hwndFrom == m_hWnd)
            {
                if ( _custom::OnChildNotify(message, wParam, lParam, _pResult) )
                {
                    return TRUE;
                }
            }
        }
        return _super::OnChildNotify(message, wParam, lParam, _pResult);
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case TVM_DELETEITEM:
            {
                HTREEITEM h = reinterpret_cast<HTREEITEM>(lParam);
                if ( h == TVI_ROOT )
                {
                    m_map.RemoveAll();
                }
                else
                {
                    m_DeleteItem(h);
                }
            }
            break;
        case WM_KEYDOWN:
            if ( wParam == ' ' )
            {
                HTREEITEM h = _super::GetSelectedItem();
                if ( h != NULL )
                {
                    BOOL old = GetCheck(h);
                    LRESULT r =_super::WindowProc(message, wParam, lParam);
                    if ( old != GetCheck(h) )
                    {
                        m_NotifyParent(h);
                    }
                    return r;
                }
            }
            break;
        case WM_LBUTTONDOWN:
            {
//              CPoint pos(LOWORD(lParam), HIWORD(lParam));
                CPoint pos(lParam);
                UINT fg;
                HTREEITEM h = _super::HitTest(pos, &fg);
                if ( h != NULL )
                {
                    if ( (fg & TVHT_ONITEMRIGHT) != 0 )
                    {
                        _super::SelectItem(h);
                    }
                    else if ( (fg & TVHT_ONITEMSTATEICON) != 0 )
                    {
                        BOOL old = GetCheck(h);
                        LRESULT r =_super::WindowProc(message, wParam, lParam);
                        ASSERT( old != GetCheck(h) );
                        m_NotifyParent(h);
                        return r;
                    }
                }
            }
            break;
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
        case WM_SIZE:
            Invalidate();
            break;
        case WM_VSCROLL:
        case WM_MOUSEWHEEL:
            {
                _super::SetRedraw(FALSE);
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                _super::SetRedraw(TRUE);
                return r;
            }
            break;
        case WM_ERASEBKGND:
            return 1;
        case TVM_SETBKCOLOR:
            SetBackColor(lParam);
            break;
        case WM_DESTROY:
            _mark::AllReset();
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::PreSubclassWindow();
        if ( (_super::GetStyle() & TVS_CHECKBOXES) != 0 )
        {
            // バグ？「チェックボックスがある場合、一度スタイルをなくす」
            _super::ModifyStyle(TVS_CHECKBOXES, 0, 0);
            _super::ModifyStyle(0, TVS_CHECKBOXES, 0);
        }
        _super::ModifyStyle(0, TVS_NONEVENHEIGHT, 0);
        SetBackColor(GetBkColor());
    }
 
    CMapT<HTREEITEM, IDrawable::Ptr>    m_map;      
    int                                 m_lowLine;  
    
public:
 
    CDrawingTreeCtrl(void) : m_lowLine(0)
    {
    }
 
    HTREEITEM InsertItem(const IDrawable &draw, HTREEITEM hParent = TVI_ROOT, HTREEITEM hInsertAfter = TVI_LAST, bool hasBg = false)
    {
        HTREEITEM h = _super::InsertItem(hasBg ? _T("*") : _T(""), hParent, hInsertAfter);
        if ( h != NULL )
        {
            m_map[h] = draw.Clone();
        }
        return h;
    }
 
    HTREEITEM InsertItem(LPCTSTR lpszItem, HTREEITEM hParent = TVI_ROOT, HTREEITEM hInsertAfter = TVI_LAST)
    {
        return _super::InsertItem(lpszItem, hParent, hInsertAfter);
    }
 
    IDrawable* GetItemDrawer(HTREEITEM item)
    {
        return m_map[item];
    }
 
    COLORREF SetLineColor(COLORREF clrNew = CLR_DEFAULT)
    {
        return TreeView_SetLineColor(*this, clrNew);
    }
 
    UINT GetState(HTREEITEM hItem) const
    {
        ASSERT(::IsWindow(m_hWnd));
        TVITEM item;
        item.mask = TVIF_HANDLE | TVIF_STATE;
        item.hItem = hItem;
        item.stateMask = TVIS_STATEIMAGEMASK;
        VERIFY(::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item));
        return item.state >> 12;
    }
 
    bool SetState(HTREEITEM hItem, UINT state)
    {
        ASSERT(::IsWindow(m_hWnd));
        TVITEM item;
        item.mask = TVIF_HANDLE | TVIF_STATE;
        item.hItem = hItem;
        item.stateMask = TVIS_STATEIMAGEMASK;
        item.state = INDEXTOSTATEIMAGEMASK(state);
        return !! ::SendMessage(m_hWnd, TVM_SETITEM, 0, (LPARAM)&item);
    }
};
 
 
    
}; // MFC
}; // TNB