TnbMfcColorListBox.h

[詳解]

#pragma once
#include "TnbMfcListBoxCp.h"
#include "TnbPointerHandle.h"
#include "TnbQueue.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CColorListBox : public CListBoxCp
{
    DEFSUPER(CListBoxCp);
public:
    
    CColorListBox(void) : _super(), m_itemHeight(-1), m_itemWidth(-1), m_margin(0), m_isView(true)
        , m_currentTextColor(::GetSysColor(COLOR_WINDOWTEXT)), m_currentBackColor(::GetSysColor(COLOR_WINDOW))
    {
    }
 
    void SetMaxLine(int maxLine)
    {
        m_lineDatas.SetQueueSize(maxLine + 1);
        _super::SetMaxLine(maxLine);
    }
 
    void SetBackColor(COLORREF color = CLR_AUTOSELECT)
    {
        if ( m_backBrush.GetSafeHandle() != NULL )
        {
            m_backBrush.DeleteObject();
        }
        if ( IS_RGBVALUE(color) )
        {
            m_backBrush.CreateSolidBrush(color);
            ASSERT( m_backBrush.GetSafeHandle() != NULL );
        }
    }
 
    void SetCurrentColor(COLORREF textColor, COLORREF backColor)
    {
        m_currentTextColor = textColor;
        m_currentBackColor = backColor;
    }
 
    void SetColor(int nIndex, COLORREF textColor, COLORREF backColor)
    {
        if ( m_lineDatas.IsInRange(nIndex) )
        {
            TParam& p = m_lineDatas[nIndex];
            p.textColor = textColor;
            p.backColor = backColor;
            RedrawWindow();
        }
    }
 
    void SetMargin(DWORD m)
    {
        m_margin = m;
        m_itemHeight = -1;
    }
 
    void SetPostViewMode(bool isView)
    {
        m_isView = isView;
    }
    
    void PostString(int nIndex, LPCTSTR lpszItem, COLORREF textColor = 0, COLORREF backColor = 0)
    {
        if ( ::IsWindow(m_hWnd) )
        {
            TParam* P = new TParam(lpszItem, textColor, backColor);
            if ( ! _super::PostMessage(WM_CLB_POSTSTRING, nIndex, reinterpret_cast<LPARAM>(P)) )
            {
                delete P;
            }
        }
    }
 
    int InsertString(int nIndex, LPCTSTR lpszItem)
    {
        return _super::InsertString(nIndex, lpszItem);
    }
 
    int AddString(LPCTSTR lpszItem)
    {
        return _super::AddString(lpszItem);
    }
 
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
    {
        if ( lpDrawItemStruct->CtlType != ODT_LISTBOX || lpDrawItemStruct->hwndItem != _super::GetSafeHwnd() )
        {
            return;
        }
        UINT nIndex = lpDrawItemStruct->itemID;
        if ( ! m_lineDatas.IsInRange(nIndex) )
        {
            return;
        }
        const TParam& p = m_lineDatas[nIndex];
        CString strText = p.viewItem;
        COLORREF textColor = p.textColor;
        COLORREF backColor = p.backColor;
        if ( (lpDrawItemStruct->itemState & ODS_SELECTED) != 0 )
        {
            Swap(textColor, backColor);
        }
        //
        CDC dc;
        dc.Attach(lpDrawItemStruct->hDC);
        //
        COLORREF currenttextColor = dc.SetTextColor(textColor);
        int currentBkMode = dc.SetBkMode(TRANSPARENT);
        //
        dc.FillSolidRect(&(lpDrawItemStruct->rcItem), backColor);
        RECT rect = lpDrawItemStruct->rcItem;
        rect.top += m_margin;
        dc.DrawText(strText, &rect, DT_SINGLELINE | DT_NOPREFIX);
        if ( (lpDrawItemStruct->itemState & ODS_FOCUS) != 0 )
        {
            dc.DrawFocusRect(&(lpDrawItemStruct->rcItem));  //破線
        }
        dc.SetBkMode(currentBkMode);
        dc.SetTextColor(currenttextColor);
        dc.Detach();
    }
 
    virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
    {
        if ( lpMeasureItemStruct->CtlType != ODT_LISTBOX || ToInt(lpMeasureItemStruct->CtlID) != _super::GetDlgCtrlID() )
        {
            return;
        }
        if ( m_itemHeight < 0 )
        {
            LOGFONT lf;
            GetFont()->GetLogFont(&lf);
            m_itemHeight = lf.lfHeight;
            if ( m_itemHeight < 0 )
            {
                m_itemHeight = -m_itemHeight;
            }
            m_itemHeight += m_margin * 2;
        }
        lpMeasureItemStruct->itemHeight = m_itemHeight;
    }
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        int index = ToInt(wParam);
        LPTSTR lpsz = reinterpret_cast<LPTSTR>(lParam);
        //
        switch ( message )
        {
        case WM_PAINT:
            if ( GetCount() == 0 )
            {
                CPaintDC dc(this);
                return 0;
            }
            break;
        case WM_ERASEBKGND: //背景
            {
                CDC dc;
                dc.Attach(reinterpret_cast<HDC>(wParam));
                CRect rect;
                GetClientRect(rect);
                int y = (GetCount() - GetTopIndex()) * m_itemHeight;
                int h = rect.Height();
                if( h > y )
                {
                    if ( y < 0 )
                    {
                        y = 0;
                    }
                    CBrush* B = &m_backBrush;
                    if ( B->GetSafeHandle() == NULL )
                    {
                        B = dc.GetCurrentBrush();
                    }
                    dc.FillRect(CRect(0, y, rect.Width(), h), B);
                }
                dc.Detach();
            }
            return 0;
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            RedrawWindow();
            break;
        case LB_GETTEXTLEN: //文字列長取得
            // @param index INDEX 
            // @return 長さ
            if ( m_lineDatas.IsInRange(index) )
            {
                return m_lineDatas[index].item.GetLength();
            }
            return LB_ERR;
        case LB_GETTEXT: //文字列取得
            // @param[in] index INDEX 
            // @param[out] lParam 格納先
            if ( m_lineDatas.IsInRange(index) )
            {
                CStr s = m_lineDatas[index].item;
                STRLIB::Copy(lpsz, s);
                return s.GetLength();
            }
            return LB_ERR;
        case LB_DELETESTRING: //削除
            // @param index INDEX 
            if ( index == 0 )
            {
                m_lineDatas.TakeElements(1);
            }
            else if ( m_lineDatas.IsInRange(index) )
            {
                m_lineDatas.Remove(index);
            }
            break;
        case LB_ADDSTRING: //追加
            // @param lParam 文字列アドレス 
            // @note 実際コントロールに設定するのは "" 
            {
                ASSERTLIB( ToInt(m_lineDatas.GetSize()) == _super::GetCount() );
                TParam p(lpsz, m_currentTextColor, m_currentBackColor);
                m_lineDatas.Add(p);
                m_CheckWidth(p.item);
            }
            lParam = reinterpret_cast<LPARAM>(_T(""));
            break;
        case LB_INSERTSTRING: //挿入
            // @param index INDEX 
            // @param lParam 文字列アドレス 
            // @note 実際コントロールに設定するのは "" 
            if ( index < 0 )
            {
                TParam p(lpsz, m_currentTextColor, m_currentBackColor);
                m_lineDatas.Add(p);
                m_CheckWidth(p.item);
            }
            else if ( IsInRange(index, m_lineDatas.GetSize() + 1) )
            {
                TParam p(lpsz, m_currentTextColor, m_currentBackColor);
                m_lineDatas.Insert(index, p);
                m_CheckWidth(p.item);
            }
            lParam = reinterpret_cast<LPARAM>(_T(""));
            break;
        case LB_RESETCONTENT: //全消し
            m_lineDatas.RemoveAll();
            m_itemWidth = -1;
            _super::SetHorizontalExtent(m_itemWidth);
            break;
        case WM_CLB_POSTSTRING:
            {
                TParam* P = reinterpret_cast<TParam*>(lParam);
                if ( P->textColor != P->backColor )
                {
                    m_currentTextColor = P->textColor;
                    m_currentBackColor = P->backColor;
                }
                if ( ::IsWindow(m_hWnd) )
                {
                    LRESULT r = _super::InsertString(index, P->item);
                    if ( m_isView )
                    {
                        _super::SetTopIndex(ToInt(r));
                    }
                }
                delete P;
                return 0;
            }
            break;
        case WM_DESTROY:
            {
                MSG msg;
                while ( ::PeekMessage(&msg, m_hWnd, WM_CLB_POSTSTRING, WM_CLB_POSTSTRING, PM_REMOVE) )
                {
                    if ( msg.message == WM_CLB_POSTSTRING )
                    {
                        TParam* P = reinterpret_cast<TParam*>(msg.lParam);
                        delete P;
                    }
                }
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        #ifdef _DEBUG
            DWORD dwStyle = _super::GetStyle();
            ASSERT( dwStyle & LBS_EXTENDEDSEL );
            ASSERT( m_lineDatas.GetSize() == 0 );
            #ifndef _WIN32_WCE
                ASSERT( (dwStyle & LBS_OWNERDRAWVARIABLE) != 0 );
//              ASSERT( (dwStyle & LBS_HASSTRINGS) == 0 );
            #endif
        #endif
        _super::PreSubclassWindow();
        m_lineDatas.SetQueueSize(_super::GetMaxLine() + 1);
    }
 
    virtual void PostNcDestroy(void) 
    {
        m_lineDatas.RemoveAll();
        _super::PostNcDestroy();
    }
 
private:
    struct TParam
    {
        CStr        item;       
        CStr        viewItem;   
        COLORREF    textColor;  
        COLORREF    backColor;  
        TParam(void){}
        TParam(LPCTSTR lpsz, COLORREF ct, COLORREF cb) : item(lpsz), textColor(ct), backColor(cb) 
        {
            viewItem = item;
            const int TABSTOP = 4;
            while ( true )
            {
                INT_PTR tabPos = viewItem.Find('\t');
                if ( tabPos < 0)
                {
                    break;
                }
                CStr s = viewItem.Mid(tabPos + 1);
                viewItem = viewItem.Left(tabPos) 
                        + CStr::Lineup(' ', TABSTOP - (tabPos % TABSTOP)) + s;
            }
        }
    };
    int                     m_itemHeight;           
    int                     m_itemWidth;            
    CBrush                  m_backBrush;            
    COLORREF                m_currentTextColor;     
    COLORREF                m_currentBackColor;     
    CRingQueueT<TParam>     m_lineDatas;            
    DWORD                   m_margin;               
    bool                    m_isView;               
    //
    DWORD                   m_lastPostIndex;        
 
    void m_CheckWidth(LPCTSTR lpszItem)
    {
        CDC* pDC = GetDC();
        CFont* pFont = _super::GetFont();
        CFont* pFontOld = pDC->SelectObject(pFont);
        const CSize& size = pDC->GetTextExtent(lpszItem);
        if ( m_itemWidth < size.cx )
        {
            m_itemWidth = size.cx;
            _super::SetHorizontalExtent(m_itemWidth);
        }
        pDC->SelectObject(pFontOld);
        ReleaseDC(pDC);
    }
};
 
 
 
}; // MFC
}; // TNB