TnbMfcDrawingListBox.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
#include "TnbDrawingContainer.h"
#include "TnbVector.h"
#include "TnbMfcBitmapDC.h"
#include "TnbMfcAbstractDrawingCtrl.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CDrawingListBox : public CListBox, public CAbstractDrawingCtrl
{
    DEFSUPER(CListBox);
    typedef CAbstractDrawingCtrl    _mark;          
public:
 
    CDrawingListBox(void) : _super(), m_itemsWidth(0)
    {
    }
 
    ~CDrawingListBox(void)
    {
        m_ResetContent();
    }
 
    const IDrawable* GetDrawing(int index) const
    {
        if ( ! m_drawersList.IsInRange(index) )
        {
            return NULL;
        }
        return m_drawersList[index];
    }
 
    int AddDrawing(const IDrawable& draw)
    {
        int r = _super::AddString(_T(""));
        if ( r >= 0 )
        {
            if ( ! m_InsertDrawing(r, draw) )
            {
                r = LB_ERR;
            }
        }
        return r;
    }
 
    int AddString(LPCTSTR lpszItem)
    {
        return _super::AddString(lpszItem);
    }
    
    int InsertDrawing(int index, const IDrawable& draw)
    {
        int r = _super::InsertString(index, _T(""));
        if ( r >= 0 )
        {
            if ( ! m_InsertDrawing(r, draw) )
            {
                r = LB_ERR;
            }
        }
        return r;
    }
 
    int InsertString(int index, LPCTSTR lpszItem)
    {
        return _super::InsertString(index, lpszItem);
    }
 
    int ResetDrawing(int index, const IDrawable& draw)
    {
        return m_ResetDrawing(index, draw);
    }
 
    int DeleteDrawing(UINT index)
    {
        int r = _super::DeleteString(index);
        if ( r >= 0 )
        {
            m_drawersList.Remove(index);
        }
        return r;
    }
 
    int DeleteString(UINT index)
    {
        return DeleteDrawing(index);
    }
 
    void ResetContent(void)
    {
        m_ResetContent();
        if ( ::IsWindow(GetSafeHwnd()) )
        {
            _super::SetHorizontalExtent(m_itemsWidth);
            _super::ResetContent();
        }
    }
 
protected:
 
    virtual LPARAM CalcDrawParam(DWORD_PTR itemNo) const
    {
        return itemNo;
    }
    
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch ( message )
        {
        case WM_ERASEBKGND: //背景
            {
                HDC hdc = reinterpret_cast<HDC>(wParam);
                CRect rect;
                GetClientRect(rect);
                int y = 0;
                for ( int i = GetTopIndex(); i < GetCount(); i++ )
                {
                    y += GetItemHeight(i);
                }
                int h = rect.Height();
                if( h > y )
                {
                    _mark::DrawBackColor(hdc, CRect(0, y, rect.Width(), h));
                }
                return 0;
            }
            break;
        case WM_PAINT:
            if ( GetCount() == 0 )
            {
                CPaintDC dc(this);
                return 0;
            }
            else
            {
                _mark::BeginItemPaint();
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                _mark::EndItemPaint();
                return r;
            }
            break;
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            Invalidate();
            break;
        case WM_DESTROY:
            m_ResetContent();
            _mark::AllReset();
            break;
        case LB_RESETCONTENT: //全消し
            m_ResetContent();
            _super::SetHorizontalExtent(m_itemsWidth);
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        #ifdef _DEBUG
            DWORD dwStyle = _super::GetStyle();
            ASSERT0(dwStyle & (LBS_OWNERDRAWVARIABLE | LBS_OWNERDRAWFIXED), "CDrawingListBox", "[オーナー描画]を[なし]以外にしてください");
            ASSERT0((dwStyle & LBS_SORT) == 0, "CDrawingListBox", "[ソート]はOFFにしてください");
            //          ASSERT0(dwStyle & LBS_EXTENDEDSEL, "PreSubclassWindow", "");
        #endif
        _super::PreSubclassWindow();
    }
 
    virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
    {
        if ( lpMeasureItemStruct->CtlType != ODT_LISTBOX || ToInt(lpMeasureItemStruct->CtlID) != _super::GetDlgCtrlID() )
        {
            return;
        }
    }
        
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
    {
        if ( lpDrawItemStruct->CtlType != ODT_LISTBOX || lpDrawItemStruct->hwndItem != _super::GetSafeHwnd() )
        {
            return;
        }
        UINT index = lpDrawItemStruct->itemID;
        HDC dc = lpDrawItemStruct->hDC;
        const CRect& rc = lpDrawItemStruct->rcItem;
        CSize sz = rc.Size();
        CBitmapImage bi;
        if ( bi.Set(sz.cx, sz.cy) )
        {
            LPARAM lParam = CalcDrawParam(index);
            CBitmapDC bmpDC(&bi);
            _mark::DrawBackground(bmpDC, CRect(CPoint(0, 0), sz), lParam);
            if ( GetSelectMarkType() == BACKGROUND )
            {
                m_DrawSelectMaker(bmpDC, sz, lpDrawItemStruct->itemState, lParam);
            }
            const IDrawable* pDraw = GetDrawing(index);
            if ( pDraw != NULL )
            {
                SIZE s;
                pDraw->GetSize(s);
                pDraw->DrawEx(bmpDC, 0, (sz.cy - s.cy) / 2, lParam);
            }
            else if ( ::IsWindow(m_hWnd) && static_cast<INDEX>(GetCount()) > index ) 
            {
                CString str;
                GetText(index, str);
                _mark::SetDefaultTextDrawer(this);
                _mark::DrawText(bmpDC, CRect(0, 0, sz.cx, sz.cy), str, lParam);
            }
            if ( GetSelectMarkType() == OVERLAP )
            {
                m_DrawSelectMaker(bmpDC, sz, lpDrawItemStruct->itemState, lParam);
            }
            if ( (lpDrawItemStruct->itemState & ODS_FOCUS) != 0 )
            {
                DrawFocusMark(bmpDC, CRect(CPoint(0, 0), sz), lParam);
            }
            if ( ! ::IsWindowEnabled(GetSafeHwnd()) )
            {
                DrawDisabledStyle(bmpDC, CRect(CPoint(0, 0), sz), lParam);
            }
            bmpDC.Draw(dc, rc.left, rc.top);
        }
    }
 
private:
 
    // アイテム全けし
    void m_ResetContent(void)
    {
        m_itemsWidth = 0;
        m_drawersList.RemoveAll();
    }
    //アイテムの幅計算（結果は m_iItemWidth に代入）
    void m_CalcItemWidth(bool withReheight = false)
    {
        m_itemsWidth = 0;
        loop ( i, m_drawersList.GetSize() )
        {
            SIZE size;
            IDrawable::Ptr P = m_drawersList[i];
            if ( ! P.IsNull() && m_drawersList[i]->GetSize(size) )
            {
                if ( m_itemsWidth < static_cast<DWORD>(size.cx) )
                {
                    m_itemsWidth = size.cx;
                }
                if ( withReheight )
                {
                    _super::SetItemHeight(ToInt(i), size.cy);
                }
            }
        }
    }
    bool m_InsertDrawing(int index, const IDrawable& draw)
    {
        if ( m_drawersList.Insert(index, draw.Clone()) )
        {
            SIZE size;
            draw.GetSize(size);
            m_CalcItemWidth(true);
            _super::SetHorizontalExtent(m_itemsWidth);
            _super::SetItemHeight(index, size.cy);
            return true;
        }
        _super::DeleteString(index);
        return false;
    }
    bool m_ResetDrawing(int index, const IDrawable& draw)
    {
        if ( m_drawersList.Set(index, draw.Clone()) )
        {
            SIZE size;
            draw.GetSize(size);
            m_CalcItemWidth();
            _super::SetHorizontalExtent(m_itemsWidth);
            _super::SetItemHeight(index, size.cy);
            return true;
        }
        return false;
    }
    void m_DrawSelectMaker(HDC dc, const SIZE& sz, UINT itemState, LPARAM lParam)
    {
        HWND hFocus = ::GetFocus();
        bool r = (hFocus == m_hWnd);
        if ( ! r && ::IsWindow(m_hWnd) )
        {
            CWnd* P = GetOwner();
            if ( P != NULL )
            {
                r = (hFocus == P->GetSafeHwnd());
            }
        }
        if ( (itemState & CDIS_SELECTED) != 0 )
        {
            _mark::DrawSelectMark(dc, CRect(CPoint(0, 0), sz), r, lParam);
        }
    }
 
    DWORD                           m_itemsWidth;   
    CAutoVectorT<IDrawable::Ptr>    m_drawersList;  
};
 
 
 
}; // MFC
}; // TNB