TnbMfcLightListBox.h

[詳解]

#pragma once
#include "TnbMfcListBoxCp.h"
#include "TnbMfcDelayedRedraw.h"
#include "TnbPointerHandle.h"
#include "TnbQueue.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CLightListBox : public CDelayedRedrawAddinT<CListBoxCp>
{
    DEFSUPER(CDelayedRedrawAddinT<CListBoxCp>);
public:
 
    typedef CRingQueueT<CArrayPtrHandleT<TCHAR> > CDatas;
    
    CLightListBox(void) : _super(), m_itemHeight(-1), m_margin(0)
    {
        m_clientSize.cx = -1;
        SetMaxLine(10 * 10000);
    }
 
    void SetMaxLine(int maxLine)
    {
        _super::SetMaxLine(maxLine);
        m_lineDatas.SetQueueSize(maxLine);
    }
 
    void SetMargin(DWORD m)
    {
        m_margin = m;
        m_itemHeight = -1;
    }
 
    void PostString(int nIndex, LPCTSTR lpszItem)
    {
        LPTSTR P = CloneString(lpszItem);
        if ( ! _super::PostMessage(WM_CLB_POSTSTRING, nIndex, reinterpret_cast<LPARAM>(P)) )
        {
            delete P;
        }
    }
 
    int InsertString(int nIndex, LPCTSTR lpszItem)
    {
        LPTSTR P = CloneString(lpszItem);
        return m_InsertString(nIndex, P);
    }
 
    int AddString(LPCTSTR lpszItem)
    {
        return InsertString(-1, lpszItem);
    }
 
    virtual int GetText(int nIndex, LPTSTR lpszBuffer) const
    {
        if ( m_lineDatas.IsInRange(nIndex) )
        {
            STRLIB::Copy(lpszBuffer, m_lineDatas[nIndex]);
            return STRLIB::GetLen(m_lineDatas[nIndex]);
        }
        return LB_ERR;
    }
 
    virtual void GetText(int nIndex, CString& rString) const
    {
        if ( m_lineDatas.IsInRange(nIndex) )
        {
            rString = m_lineDatas[nIndex];
        }
    }
 
    void SetAllString(const CDatas& datas, int index = -1)
    {
        int l = ToInt(datas.GetQueueSize());
        if ( l != GetMaxLine() )
        {
            _super::SetMaxLine(l);
        }
        m_lineDatas = datas;
        m_Settle(ToInt((index < 0) ? (datas.GetSize() - 1) : index));
    }
 
    const CDatas& GetAllString(void) const
    {
        return m_lineDatas;
    }
 
    static LPTSTR CloneString(LPCTSTR lpszText)
    {
        size_t len = STRLIB::GetLen(lpszText) + 1;
        LPTSTR P = new TCHAR[len];
        MemCopy(P, lpszText, len);
        return P;
    }
 
protected:
 
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
    {
        if ( lpDrawItemStruct->CtlType != ODT_LISTBOX || lpDrawItemStruct->hwndItem != _super::GetSafeHwnd() )
        {
            return;
        }
        UINT index = lpDrawItemStruct->itemID;
        if ( ! m_lineDatas.IsInRange(index) )
        {
            return;
        }
        LPTSTR P = m_lineDatas[index];
        HDC dc = lpDrawItemStruct->hDC;
        COLORREF textColor = 0;
        HBRUSH backBrush = NULL;
        if ( (lpDrawItemStruct->itemState & ODS_SELECTED) == 0 )
        {
            textColor = ::GetSysColor(COLOR_WINDOWTEXT);
            backBrush = ::GetSysColorBrush(COLOR_WINDOW);
        }
        else
        {
            textColor = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
            backBrush = ::GetSysColorBrush(COLOR_HIGHLIGHT);
        }
        COLORREF currentTextColor = ::SetTextColor(dc, textColor);
        int currentBkMode = ::SetBkMode(dc, TRANSPARENT);
        ::FillRect(dc, &(lpDrawItemStruct->rcItem), backBrush);
        RECT rect = lpDrawItemStruct->rcItem;
        rect.top += m_margin;
        ::DrawText(dc, P, -1, &rect, DT_SINGLELINE | DT_NOPREFIX);
        if ( (lpDrawItemStruct->itemState & ODS_FOCUS) != 0 )
        {
            ::SetTextColor(dc, 0);
            ::DrawFocusRect(dc, &(lpDrawItemStruct->rcItem));   //破線
        }
        ::SetBkMode(dc, currentBkMode);
        ::SetTextColor(dc, currentTextColor);
    }
 
    virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct)
    {
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        int index = ToInt(wParam);
        switch ( message )
        {
        case WM_SETFONT:
            {
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                m_itemHeight = -1;
                m_Settle();
                return r;
            }
            break;
        case WM_ERASEBKGND: //背景
            {
                if ( m_clientSize.cx < 0 )
                {
                    CRect rc;
                    _super::GetClientRect(rc);
                    m_clientSize.cy = rc.Height();
                    m_clientSize.cx = rc.Width();
                }
                HDC dc = reinterpret_cast<HDC>(wParam);
                int y = (_super::GetCount() - _super::GetTopIndex()) * m_itemHeight;
                int h = m_clientSize.cy;
                if( h > y )
                {
                    if ( y < 0 )
                    {
                        y = 0;
                    }
                    HBRUSH b = static_cast<HBRUSH>(::GetCurrentObject(dc, OBJ_BRUSH));
                    ::FillRect(dc, CRect(0, y, m_clientSize.cx, h), b);
                }
            }
            return 0;
        case WM_SIZE:
            m_clientSize.cy = HIWORD(lParam);
            m_clientSize.cx = LOWORD(lParam);
            break;
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            _super::RedrawWindow();
            break;
        case WM_CLB_POSTSTRING:
            {
                LPTSTR P = reinterpret_cast<LPTSTR>(lParam);
                m_InsertString(index, P);
                return 0;
            }
            break;
        case LB_GETTEXTLEN: //文字列長取得
            // @param index INDEX 
            // @return 長さ
            if ( m_lineDatas.IsInRange(index) )
            {
                return STRLIB::GetLen(m_lineDatas[index]);
            }
            return LB_ERR;
        case LB_GETTEXT: //文字列取得
            // @param[in] index INDEX 
            // @param[out] lParam 格納先
            if ( m_lineDatas.IsInRange(index) )
            {
                STRLIB::Copy(reinterpret_cast<TCHAR*>(lParam), m_lineDatas[index]);
                return STRLIB::GetLen(m_lineDatas[index]);
            }
            return LB_ERR;
        case LB_DELETESTRING:
            if ( lParam != MAGIC_LPARAM )
            {
                if ( m_lineDatas.IsInRange(index) )
                {
                    m_lineDatas.Remove(index);
                    m_Settle();
                }
                return 0;
            }
            break;
        case LB_RESETCONTENT:
            if ( lParam != MAGIC_LPARAM )
            {
                if ( m_lineDatas.GetSize() > 0 )
                {
                    m_lineDatas.RemoveAll();
                    m_Settle();
                }
            }
            break;
        case WM_DESTROY:
            {
                UINT wm = WM_CLB_POSTSTRING;
                MSG msg;
                while ( ::PeekMessage(&msg, _super::GetSafeHwnd(), wm, wm, PM_REMOVE) )
                {
                    if ( msg.message == wm )
                    {
                        LPTSTR P = reinterpret_cast<LPTSTR>(msg.lParam);
                        delete P;
                    }
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        #ifdef _DEBUG
            DWORD dwStyle = _super::GetStyle();
            ASSERT( (dwStyle & LBS_OWNERDRAWFIXED) != 0 );
            ASSERT( (dwStyle & LBS_HASSTRINGS) == 0 );
            ASSERT( (dwStyle & LBS_MULTICOLUMN) == 0 );
            ASSERT( m_lineDatas.GetSize() == 0 );
            #ifndef _WIN32_WCE
                ASSERT( (dwStyle & LBS_NODATA) != 0 );
            #endif
        #endif
        _super::PreSubclassWindow();
    }
 
    virtual void PostNcDestroy(void) 
    {
        m_lineDatas.RemoveAll();
        _super::PostNcDestroy();
    }
 
private:
    enum { 
        MAGIC_LPARAM = 'Tllb'       // CE用
    };
    // 確定
    void m_Settle(int index = -1)
    {
        int l = ToInt(m_lineDatas.GetSize());
        #ifndef _WIN32_WCE
            _super::SendMessage(LB_SETCOUNT, l ,0);
        #else
            if ( l == 0 )
            {
                _super::SendMessage(LB_RESETCONTENT, 0, MAGIC_LPARAM);
            }
            else
            {
                size_t ll = _super::GetCount();
                int d = ll - l;
                if ( d < 0 )
                {
                    loop ( i, -d )
                    {
                        _super::SendMessage(LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(_T("")));
                    }
                }
                else if ( d > 0 )
                {
                    loop ( i, d )
                    {
                        _super::SendMessage(LB_DELETESTRING, 0, MAGIC_LPARAM);
                    }
                }
            }
            ASSERT( l == _super::GetCount() );
        #endif
        if ( index >= 0 )
        {
            _super::SetTopIndex(index);
        }
        if ( m_itemHeight < 0 )
        {
            LOGFONT lf;
            _super::GetFont()->GetLogFont(&lf);
            m_itemHeight = lf.lfHeight;
            if ( m_itemHeight < 0 )
            {
                m_itemHeight = -m_itemHeight;
            }
            m_itemHeight += m_margin * 2;
            _super::SetItemHeight(0, m_itemHeight);
        }
        _super::DelayedRedraw();
    }
    int m_InsertString(int index, LPTSTR lpszItem)
    {
        CArrayPtrHandleT<TCHAR> p = lpszItem;
        INDEX r = m_lineDatas.Add(p);
        if ( r == INVALID_INDEX )
        {
            int ml = _super::GetMaxLine();
            int ll = (ml > 1000) ? 20 : 5;
            m_lineDatas.TakeElements(ll);
            r = m_lineDatas.Add(p);
        }
        if ( r != INVALID_INDEX )
        {
            m_Settle(ToInt(r));
            return ToInt(r);
        }
        return -1;
    }
    int     m_itemHeight;   
    CDatas  m_lineDatas;    
    DWORD   m_margin;       
    SIZE    m_clientSize;   
};
 
 
 
}; //MFC
}; //TNB