TnbMfcDrawingListCtrl.h

[詳解]

#pragma once
#include "TnbMfcAbstractCustomListCtrl.h"
#include "TnbMfcAbstractDrawingCtrl.h"
#include "TnbMfcDrawingHeaderCtrl.h"
#include "TnbMfcBitmapDC.h"
#include "TnbPartsDrawable.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CDrawingListCtrl : public CAbstractCustomListCtrl, public CAbstractDrawingCtrl
{
    DEFSUPER(CAbstractCustomListCtrl);
    typedef CAbstractDrawingCtrl _mark;                 
    typedef CAutoVectorT<IDrawable::Ptr> CDrawersVector;    
    typedef CAutoVectorT<CDrawersVector> CDrawersVectors;   
public:
 
    CDrawingListCtrl(void) : _super(), m_pPartsDrawer(NULL), m_withDtEndEllipsis(false)
    {
    }
 
    ~CDrawingListCtrl(void)
    {
        m_ResetContent();
    }
 
    void SetAdjustWidthMode(bool b = true)
    {
        m_headerCtrl.SetAdjustWidthMode(b);
    }
 
    void SetTextEndEllipsisMode(bool f = false)
    {
        m_withDtEndEllipsis = f;
    }
 
    void AddCheckBox(IPartsDrawable* P)
    {
        m_pPartsDrawer = P;
        DWORD ss = _super::GetExtendedStyle();
        _super::SetExtendedStyle(ss | LVS_EX_CHECKBOXES);
    }
 
    IDrawable* GetItemDrawer(int itemNo, int subItemNo)
    {
        if ( itemNo >= 0 && itemNo < GetItemCount() )
        {
            if ( subItemNo >= 0 && subItemNo < GetHeaderCtrl()->GetItemCount() )
            {
                try
                {
                    return m_drawersGlid[itemNo][subItemNo];
                }
                catch( CTnbException& e )
                {
                    e.OnCatch();
                }
            }
        }
        return NULL;
    }
 
    BOOL SetItemText(int itemNo, int subItemNo, LPCTSTR lpszText)
    {
        BOOL r = _super::SetItemText(itemNo, subItemNo, lpszText);
        if ( r )
        {
            try
            {
                m_drawersGlid[itemNo][subItemNo].Null();
            }
            catch( CTnbException& e )
            {
                e.OnCatch();
            }
        }
        return r;
    }
 
    int SetDrawItem(int itemNo, int subItemNo, const IDrawable& draw, bool isInsert = false, LPCTSTR lpszWidth = NULL)
    {
        CSize size;
        if ( ! draw.GetSize(size) )
        {
            return -1;
        }
        CSize sz(0, 0);
        CString str;
        if ( lpszWidth == NULL )
        {
            CDC* pDC = _super::GetDC();
            CFont* pOldFont = pDC->SelectObject(_super::GetFont());
            while ( sz.cx < size.cx )
            {
                str += _T("W");
                CTextDrawer::CalcTextSize(sz, *pDC, 0, str);
            }
            str = str.Left(str.GetLength() - 1);
            sz.cx = 0;
            while ( sz.cx < size.cx )
            {
                str += _T("l");
                CTextDrawer::CalcTextSize(sz, *pDC, 0, str);
            }
            str = str.Left(str.GetLength() - 1);
            pDC->SelectObject(pOldFont);
            _super::ReleaseDC(pDC);
        }
        else
        {
            str = lpszWidth;
        }
        _super::SetRedraw(false);
        if ( isInsert )
        {
            itemNo = _super::InsertItem(itemNo, str);
            if ( itemNo >= 0 )
            {
                subItemNo = 0;
                INDEX n = m_FindNoUseAbsoluteIndex();
                _super::SetItemData(itemNo, n);
                m_drawersGlid.Insert(itemNo, CDrawersVector());
                m_drawersLine.Insert(itemNo, IDrawable::Ptr());
                m_absoluteIndexs.Insert(itemNo, n);
                m_ClearIndexCache();
            }
        }
        else if ( subItemNo == 0 && itemNo >= _super::GetItemCount() )
        {
            itemNo = _super::InsertItem(itemNo, str);
            if ( itemNo >= 0 )
            {
                INDEX n = m_FindNoUseAbsoluteIndex();
                _super::SetItemData(itemNo, n);
                m_absoluteIndexs[itemNo] = n;
                m_ClearIndexCache();
            }
        }
        else
        {
            if ( ! _super::SetItemText(itemNo, subItemNo, str) )
            {
                itemNo = -1;
            }
        }
        _super::SetRedraw(true);
        if ( itemNo >= 0 )
        {
            m_drawersGlid[itemNo][subItemNo] = draw.Clone();
            _super::Invalidate();
        }
        m_ViewIndexCache();
        return itemNo;
    }
 
    int AddDrawItem(const IDrawable& draw)
    {
        int l = _super::GetItemCount();
        return SetDrawItem(l, 0, draw);
    }
 
    int InsertDrawItem(int itemNo, const IDrawable& draw)
    {
        return SetDrawItem(itemNo, 0, draw, true);
    }
 
    bool SwapItem(int itemNo1, int itemNo2)
    {
        int l = _super::GetItemCount();
        if ( itemNo1 < 0 || itemNo1 >= l ) { return false; }
        if ( itemNo2 < 0 || itemNo2 >= l ) { return false; }
        //
        _super::SetRedraw(false);
        m_SwapItem(itemNo1, itemNo2);   // 情報入れ替え
        _super::SetRedraw(true);
        _super::Invalidate();
        m_ViewIndexCache();
        return true;
    }
        
    int MoveItem(int fromItemNo, int toItemNo)
    {
        int l = _super::GetItemCount();
        if ( fromItemNo < 0 || fromItemNo >= l ) { return -1; }
        if ( toItemNo < 0 || toItemNo >= l + 1 ) { return -1; }
        if ( fromItemNo == toItemNo )//|| fromItemNo == toItemNo + 1 )
        {
            return fromItemNo; //何もせずOKじゃ
        }
        _super::SetRedraw(false);
        int it = -1;
        if ( fromItemNo > toItemNo )
        {
            for ( int i = fromItemNo; i >= toItemNo + 1; i-- )
            {
                m_SwapItem(i, i - 1);
            }
            it = toItemNo;
        }
        else
        {
            for ( int i = fromItemNo; i <= toItemNo - 2; i++ )
            {
                m_SwapItem(i, i + 1);
            }
            it = toItemNo - 1;
        }
        _super::SetRedraw(true);
        m_ViewIndexCache();
        return it;
    }
 
    BOOL DeleteItem(int item)
    {
        BOOL r = _super::DeleteItem(item);
        if ( r )
        {
            m_drawersGlid.Remove(item);
            m_drawersLine.Remove(item);
            m_absoluteIndexs.Remove(item);
            m_ClearIndexCache();
            m_ViewIndexCache();
        }
        return r;
    }
 
    BOOL DeleteAllItems(void)
    {
        BOOL r = _super::DeleteAllItems();
        m_ResetContent();
        m_ViewIndexCache();
        return r;
    }
 
    int AbsoluteIndexToItemNo(INDEX index) const
    {
        return m_AbsoluteIndexToItemNo(index);
    }
 
    INDEX ItemNoToAbsoluteIndex(int itemNo) const
    {
        if ( m_absoluteIndexs.IsInRange(itemNo) )
        {
            return m_absoluteIndexs[itemNo];
        }
        return INVALID_INDEX;
    }
 
    CDrawingHeaderCtrl* GetHeaderCtrl(void)
    {
        m_CheckHeaderCtrl();
        return m_headerCtrl.IsWindow() ? &m_headerCtrl : NULL;
    }
 
    int InsertColumn(int nCol, const LVCOLUMN* pColumn)
    {
        m_CheckHeaderCtrl();
        int r = _super::InsertColumn(nCol, pColumn);
        return r;
    }
 
    int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat = LVCFMT_LEFT, int nWidth = -1, int nSubItem = -1)
    {
        m_CheckHeaderCtrl();
        int r = _super::InsertColumn(nCol, lpszColumnHeading, nFormat, nWidth, nSubItem);
        if ( r == 0 )
        {
            HDITEM hi;
            hi.mask = HDI_FORMAT;
            if ( m_headerCtrl.GetItem(nCol, &hi) )
            {
                hi.fmt = (hi.fmt & ~LVCFMT_JUSTIFYMASK) | nFormat;
                hi.mask = HDI_FORMAT;
                m_headerCtrl.SetItem(nCol, &hi);
            }
        }
        //m_headerCtrl.Reset();
        return r;
    }
 
    int InsertColumn(int nCol, int nWidth, const IDrawable& draw)
    {
        m_CheckHeaderCtrl();
        int r = _super::InsertColumn(nCol, _T(""), LVCFMT_LEFT, nWidth, -1);
        if ( r >= 0 )
        {
            m_headerCtrl.SetColumnDrawer(nCol, draw);
            //m_headerCtrl.Reset();
        }
        return r;
    }
 
    bool SetItemOverDrawer(int itemNo, const IDrawable& draw)
    {
        SIZE size;
        if ( draw.GetSize(size) )
        {
            m_drawersLine[itemNo] = draw.Clone();
            return true;
        }
        return false;
    }
 
    BOOL SetBkColor(COLORREF color)
    {
        SetBackColor(color);
        return TRUE;
    }
    
    int InsertItem(int itemNo, LPCTSTR lpszItem)
    {
        return _super::InsertItem(itemNo, lpszItem);
    }
 
    BOOL SetItemState(int nItem, UINT nState, UINT nMask)
    {
        return _super::SetItemState(nItem, nState, nMask);
    }
 
protected:
 
    virtual void OnBeginItemPaint(HDC dc)
    {
        _mark::BeginItemPaint();
        m_hasCheckBox = (GetExtendedStyle() & LVS_EX_CHECKBOXES) != 0;
        CDrawingHeaderCtrl* H = GetHeaderCtrl();
        if ( H != NULL )
        {
            CRect rc;
            H->GetClientRect(&rc);
            HRGN rgn = ::CreateRectRgnIndirect(&rc);
            ::ExtSelectClipRgn(dc, rgn, RGN_DIFF);
            _DeleteObject(rgn);
        }
        if ( (_super::GetStyle() & LVS_NOCOLUMNHEADER) != 0 )
        {
            if ( m_headerCtrl.IsAdjustWidthMode() )
            {
                CRect rc;
                _super::GetClientRect(rc);
                int right = rc.right;
                int cnt = m_headerCtrl.GetItemCount();
                for ( int i = 0; i < cnt; i++ )
                {
                    CRect subRc;
                    m_headerCtrl.GetItemRect(i, subRc);
                    rc.right = rc.left + subRc.Width();
                    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; }
                        m_headerCtrl.SetItem(i, &h);
                        rc.right = right;
                    }
                    rc.left = rc.right;
                }
            }
        }
    }
 
    virtual void OnEndItemPaint(HDC dc)
    {
        if ( _mark::EndItemPaint() )
        {
            Invalidate();
        }
    }
 
    virtual LPARAM CalcDrawParam(DWORD_PTR itemNo, DWORD subItemNo) const
    {
        return itemNo;
    }
    
    virtual LRESULT OnItemPainting(TDrawParam* P)
    {
//      TRACE3("OnSubItemPaint[%d, %d, %08X]\n", pParam->itemNo, pParam->subItemNo, pParam->state);
        CRect rc = P->rect;
        rc.OffsetRect(-rc.TopLeft());
        CBitmapImage bi;
        bi.Set(rc.Width(), rc.Height(), _mark::GetBackColor());
        LPARAM lParam = CalcDrawParam(P->itemNo, P->subItemNo);
        if ( ! bi.IsEmpty() )
        {
            CBitmapDC dc(&bi);
            _mark::DrawBackground(dc, rc, lParam);
            int x = 0;
            if ( P->subItemNo == 0 && m_hasCheckBox && m_pPartsDrawer != NULL )
            {
                CRect r = rc;
                UINT s = DFCS_BUTTONCHECK | DFCS_FLAT;
                if ( _super::GetCheck(P->itemNo) )
                {
                    s |= DFCS_CHECKED;
                }
                m_pPartsDrawer->DrawButtonControl(NULL, &r, s);
                r.OffsetRect(1, (rc.Height() - r.Height()) / 2);
                m_pPartsDrawer->DrawButtonControl(dc, &r, s);
                m_checkboxWidth = r.Width() + 2;
                x += m_checkboxWidth;
                rc.left += m_checkboxWidth;
                if ( rc.right < rc.left )
                {
                    rc.right = rc.left;
                }
            }
            if ( _mark::GetSelectMarkType() == BACKGROUND )
            {
                m_DrawSelectMaker(dc, rc, P->state, lParam);
            }
            IDrawable* pDraw = GetItemDrawer(P->itemNo, P->subItemNo);
            if ( pDraw != NULL )
            {
                pDraw->Resize(rc.Size());
                pDraw->DrawEx(dc, x, 0, lParam);
            }
            else
            {
                CString str = GetItemText(P->itemNo, P->subItemNo);
                HDITEM hi;
                hi.mask = HDI_FORMAT;
                if ( m_headerCtrl.GetItem(P->subItemNo, &hi) )
                {
                    DWORD st = _mark::GetTextDrawStyle() & (~0x03);
                    switch ( hi.fmt & HDF_JUSTIFYMASK )
                    {
                    case HDF_RIGHT:
                        st |= DT_RIGHT;
                        break;
                    case HDF_CENTER:
                        st |= DT_CENTER;
                        break;
                    default:
                        if ( m_withDtEndEllipsis )
                        {
                            st |= DT_END_ELLIPSIS;
                        }
                        break;
                    }
                    CSize sz = P->rect.Size();
                    _mark::SetDefaultTextDrawer(this);
                    _mark::DrawText(dc, CRect(x, 0, sz.cx, sz.cy), str, st, lParam);
                }
            }
            if ( _mark::GetSelectMarkType() == OVERLAP )
            {
                m_DrawSelectMaker(dc, rc, P->state, lParam);
            }
            dc.Draw(P->dc, P->rect.left, P->rect.top);
            if ( pDraw != NULL )
            {
                pDraw->DrawEx(NULL, P->rect.left, P->rect.top, lParam);
            }
        }
        return CDRF_SKIPDEFAULT;
    }
 
    virtual void OnItemPainted(const TDrawParam* P)
    {
        CRect rc = P->rect;
        if ( m_hasCheckBox && m_pPartsDrawer != NULL )
        {
            rc.left += m_checkboxWidth;
        }
        if ( ! m_drawersLine.IsEmpty() )
        {
            IDrawable* D = m_drawersLine[P->itemNo];
            if ( D != NULL )
            {
                D->Resize(rc.Size());
                D->Draw(P->dc, rc.left, rc.top);
            }
        }
        if ( (P->state & CDIS_FOCUS) != 0 )
        {
            _mark::DrawFocusMark(P->dc, rc, P->itemNo);
        }
    }
 
    virtual void OnDrawBackground(HDC dc, const RECT& rect)
    {
        _mark::DrawBackColor(dc, rect);
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case LVM_DELETECOLUMN:
            {
                INDEX col = wParam;
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                if ( r != 0 )
                {
                    loop ( i, m_drawersGlid )
                    {
                        m_drawersGlid[i].Remove(col);
                    }
                }
                return r;
            }
            break;
        case WM_DESTROY:
            m_ResetContent();
            _mark::AllReset();
            if ( ::IsWindow(m_headerCtrl) )
            {
                m_headerCtrl.UnsubclassWindow();
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        ASSERT0( (_super::GetStyle() & LVS_TYPEMASK) == LVS_REPORT, "DrawingListCtrl", "サポートできるのは Reportタイプのみです。" );
        m_CheckHeaderCtrl();
        _super::PreSubclassWindow();
    }
 
private:
    void m_CheckHeaderCtrl(void)
    {
        if ( ! ::IsWindow(m_headerCtrl) )
        {
            CHeaderCtrl* pHeaderCtrl = _super::GetHeaderCtrl();
            if ( pHeaderCtrl != NULL )
            {
                m_headerCtrl.SubclassWindow(*pHeaderCtrl);
            }
        }
    }
    CDrawingHeaderCtrl          m_headerCtrl;               
    CDrawersVectors             m_drawersGlid;              
    CDrawersVector              m_drawersLine;              
    CAutoVectorT<INDEX>         m_absoluteIndexs;           
    mutable CAutoVectorT<INDEX> m_indexCache;               
    IPartsDrawable*             m_pPartsDrawer;             
    int                         m_checkboxWidth;            
    bool                        m_hasCheckBox;              
    bool                        m_withDtEndEllipsis;        
 
    void m_ViewIndexCache(void) const
    {
        #ifdef _TnbDEBUG_ON
        m_MakeIndexCache();
        TRACE1( "LL;cache 内容 (l = %d)\n", m_indexCache.GetSize() - 1 );
        loop ( i, m_indexCache.GetSize() )
        {
            if ( i != 0 )
            {
                TRACE2("LL;   絶対INDEX %d  ==  itemNo %d\n", i, m_indexCache[i] - 1);
            }
        }
        #endif
    }
    void m_ClearIndexCache(void)
    {
        m_indexCache.RemoveAll();
    }
    void m_MakeIndexCache(void) const
    {
        if ( m_indexCache.IsEmpty() )
        {
            m_indexCache.Add(0);
            loop ( i, m_absoluteIndexs.GetSize() )
            {
                INDEX idx = m_absoluteIndexs[i];
                m_indexCache[idx] = i + 1;
            }
        }
    }
    INDEX m_FindNoUseAbsoluteIndex(void) const
    {
        m_MakeIndexCache();
        INDEX r = m_indexCache.Find(0, 1);
        if ( r == INVALID_INDEX )
        {
            r = m_indexCache.GetSize();
        }
        return r;
    }
    int m_AbsoluteIndexToItemNo(INDEX index) const
    {
        m_MakeIndexCache();
        int r = static_cast<int>(m_indexCache[index]) - 1;
        ASSERT( r >= 0 );
        return r;
    }
    // アイテム全けし
    void m_ResetContent(void)
    {
        m_drawersGlid.RemoveAll();
        m_drawersLine.RemoveAll();
        m_absoluteIndexs.RemoveAll();
        m_ClearIndexCache();
    }
    void m_DrawSelectMaker(HDC dc, const RECT& rect, UINT itemState, LPARAM lParam)
    {
        if ( (itemState & CDIS_SELECTED) != 0 )
        {
            _mark::DrawSelectMark(dc, rect, ::GetFocus() == m_hWnd, lParam);
        }
    }
    void m_SwapItem(int itemNo1, int itemNo2)
    {
        // 情報入れ替え
        Swap(m_drawersGlid[itemNo1], m_drawersGlid[itemNo2]);
        Swap(m_drawersLine[itemNo1], m_drawersLine[itemNo2]);
        Swap(m_absoluteIndexs[itemNo1], m_absoluteIndexs[itemNo2]);
        DWORD data = ToDword(_super::GetItemData(itemNo1));
        _super::SetItemData(itemNo1, _super::GetItemData(itemNo2));
        _super::SetItemData(itemNo2, data);
        UINT state = _super::GetItemState(itemNo1, UINT_MAX);
        _super::SetItemState(itemNo1, _super::GetItemState(itemNo2, UINT_MAX), UINT_MAX);
        _super::SetItemState(itemNo2, state, UINT_MAX);
        // 各カラム情報も入れ替え
        loop ( subItemNo, GetHeaderCtrl()->GetItemCount() )
        {
            int sin = ToInt(subItemNo);
            CString s = GetItemText(itemNo1, sin);
            SetItemText(itemNo1, sin, GetItemText(itemNo2, sin));
            SetItemText(itemNo2, sin, s);
        }
        m_ClearIndexCache();
    }
 
    CImageList* GetImageList(int nImageList) const;
    CImageList* SetImageList(CImageList* pImageList, int nImageListType);
    BOOL GetItem(LVITEM* pItem) const;
    BOOL SetItem(const LVITEM* pItem);
    BOOL SetItem(int nItem, int nSubItem, UINT nMask, LPCTSTR lpszItem,
        int nImage, UINT nState, UINT nStateMask, LPARAM lParam);
    BOOL GetColumn(int nCol, LVCOLUMN* pColumn) const;
    BOOL SetColumn(int nCol, const LVCOLUMN* pColumn);
    BOOL GetOrigin(LPPOINT lpPoint) const;
    BOOL SetItemState(int nItem, LVITEM* pItem);
    BOOL SetBkImage(HBITMAP hbm, BOOL fTile = TRUE, int xOffsetPercent = 0, int yOffsetPercent = 0);
    BOOL SetBkImage(LPTSTR pszUrl, BOOL fTile = TRUE, int xOffsetPercent = 0, int yOffsetPercent = 0);
    BOOL SetBkImage(LVBKIMAGE* plvbkImage);
    int InsertItem(const LVITEM* pItem);
    int InsertItem(int nItem, LPCTSTR lpszItem, int nImage);
    BOOL Update(int nItem);
    BOOL SortItems(PFNLVCOMPARE pfnCompare, DWORD dwData);
    int InsertItem(UINT nMask, int nItem, LPCTSTR lpszItem, UINT nState,
        UINT nStateMask, int nImage, LPARAM lParam);
};
 
 
 
}; // MFC
}; // TNB