TnbMfcColorfulListBox.h

[詳解]

#pragma once
#include "TnbPointerVector.h"
#include "TnbMfcListBoxCp.h"
#include "TnbMfcBitmapDC.h"
#include "TnbDcSelectAssistant.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CColorfulListBox : public CListBoxCp
{
    DEFSUPER(CListBoxCp);
public:
    
    class CColor
    {
    public:
        struct TParam
        {
            size_t      len;        
            COLORREF    textColor;  
            COLORREF    backColor;  
        };
        CColor(void) : m_textColor(::GetSysColor(COLOR_WINDOWTEXT)), m_backColor(::GetSysColor(COLOR_WINDOW))
        {
        }
        CColor(COLORREF textColor, COLORREF backColor) : m_textColor(textColor), m_backColor(backColor)
        {
        }
        bool IsEmpty(void) const
        {
            return m_infos.IsEmpty();
        }
        void RemoveAll(void)
        {
            m_infos.RemoveAll();
            m_params.RemoveAll();
        }
        void Add(INDEX pos, size_t len, COLORREF textColor = CLR_INVALID, COLORREF backColor = CLR_INVALID)
        {
            if ( ! IS_RGBVALUE(textColor) )
            {
                textColor = m_textColor;
            }
            if ( ! IS_RGBVALUE(backColor) )
            {
                backColor = m_backColor;
            }
            if ( pos + len >= m_infos.GetSize() )
            {
                TInfo pa(m_textColor, m_backColor);
                loop ( i, (pos + len) - m_infos.GetSize() )
                {
                    m_infos.Add(pa);
                }
            }
            TInfo pa(textColor, backColor);
            loop ( i, len )
            {
                m_infos.Set(pos + i, pa);
            }
            m_params.RemoveAll();
        }
        const CVectorT<TParam>& GetParam(void) const
        {
            if ( m_params.IsEmpty() )
            {
                if ( m_infos.IsEmpty() )
                {
                    TParam pa = { 100000, m_textColor, m_backColor };
                    m_params.Add(pa);
                }
                else
                {
                    size_t ll = 0;
                    loop ( i, m_infos.GetSize() - 1 )
                    {
                        ll++;
                        if ( m_infos[i].textColor != m_infos[i + 1].textColor || m_infos[i].backColor != m_infos[i + 1].backColor )
                        {
                            //違う
                            TParam pa = { ll, m_infos[i].textColor, m_infos[i].backColor };
                            m_params.Add(pa);
                            ll = 0;
                        }
                    }
                    ll++;
                    INDEX i = m_infos.GetSize() - 1;
                    TParam pa = { ll, m_infos[i].textColor, m_infos[i].backColor };
                    m_params.Add(pa);
                    TParam pa2 = { 100000, m_textColor, m_backColor };
                    m_params.Add(pa2);
                }
            }
            return m_params;
        }
 
    private:
        struct TInfo
        {
            COLORREF    textColor;  
            COLORREF    backColor;  
            TInfo(COLORREF text = 0, COLORREF back = 0)
                : textColor(text), backColor(back)
            {
            }
        };
        CVectorT<TInfo>             m_infos;
        mutable CVectorT<TParam>    m_params;
        COLORREF                    m_textColor;    
        COLORREF                    m_backColor;    
    };
 
    CColorfulListBox(void)
        : _super(), m_iItemHeight(-1), m_iItemWidth(-1), m_margin(0), m_isView(true), m_postCount(-1), m_oneCharWidth(-1)
    {
    }
 
    ~CColorfulListBox(void)
    {
        m_ColorsRemoveAll();
    }
 
    void SetCurrentColor(const CColorfulListBox::CColor& color)
    {
        m_currentColor = color;
    }
 
    void SetColor(INDEX nIndex, const CColorfulListBox::CColor& color)
    {
        if ( m_colors.GetSize() > nIndex )
        {
            m_colors[nIndex]->color = color;
            RedrawWindow();
        }
    }
 
    void SetMargin(DWORD m)
    {
        m_margin = m;
        m_iItemHeight = -1;
    }
 
    void SetPostViewMode(bool isView, bool isDelayMode = false)
    {
        m_isView = isView;
        m_postCount = isDelayMode ? 0 : -1;
    }
 
    void PostString(int nIndex, LPCTSTR lpszItem)
    {
        CColor c;
        PostString(nIndex, lpszItem, c);
    }
 
    void PostString(int nIndex, LPCTSTR lpszItem, const CColorfulListBox::CColor& color)
    {
        if ( ! ::IsWindow(m_hWnd) )
        { 
            return;
        }
        TParam* P = new TParam;
        P->item = lpszItem;
        P->color = color;
        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);
    }
 
protected:
 
    virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
    {
        if ( lpDrawItemStruct->CtlType != ODT_LISTBOX || lpDrawItemStruct->hwndItem != _super::GetSafeHwnd() )
        {
            return;
        }
        UINT nIndex = lpDrawItemStruct->itemID;
//      if ( static_cast<UINT>(m_linesString.GetSize()) <= nIndex )
        if ( static_cast<UINT>(m_colors.GetSize()) <= nIndex )
        {
            return;
        }
        CString strText = m_colors[nIndex]->item;
        CRect rcItem = lpDrawItemStruct->rcItem;
        const CColor& colors = m_colors[nIndex]->color;
        const CVectorT<CColor::TParam> vp = colors.GetParam();
        //
        CBitmapImage bi;
        bi.Set(rcItem.Width(), rcItem.Height());
        {
            CRect rect = rcItem;
            rect.OffsetRect(-rect.left, -rect.top);
            CRect rc2 = rect;
            //
            CBitmapDC dc(&bi);
            CDcSelectAssistant dca(dc);
            dca.SelectFont(_super::GetFont());
            dca.SetBkMode(TRANSPARENT);
            rect.top += m_margin;
            COLORREF colorText = 0;
            COLORREF colorBack = 0;
            loop ( i, vp.GetSize() )
            {
                const CColor::TParam& v = vp[i];
                CString s = strText.Left(ToInt(v.len));
                colorText = v.textColor;
                colorBack = v.backColor;
                if ( (lpDrawItemStruct->itemState & ODS_SELECTED) != 0 )
                {
                    colorText = v.backColor;
                    colorBack = v.textColor;
                }
                if ( s.IsEmpty() )
                {
                    rect.right = rect.left;
                }
                else
                {
                    dc.DrawText(s, &rect, DT_SINGLELINE | DT_NOPREFIX | DT_CALCRECT);
                    dc.FillSolidRect(&rect, colorBack);
                    dca.SetTextColor(colorText);
                    dc.DrawText(s, &rect, DT_SINGLELINE | DT_NOPREFIX);
                    rect.left = rect.right;
                }
                rect.right = lpDrawItemStruct->rcItem.right;
                if ( strText.GetLength() > ToInt(v.len) )
                {
                    strText = strText.Mid(ToInt(v.len));
                }
                else
                {
                    strText.Empty();
                }
            }
            dc.FillSolidRect(&rect, colorBack);
            if ( ! strText.IsEmpty() )
            {
                dca.SetTextColor(colorText);
                dc.DrawText(strText, &rect, DT_SINGLELINE | DT_NOPREFIX);
            }
            //
            if ( (lpDrawItemStruct->itemState & ODS_FOCUS) != 0 )
            {
                dca.SetTextColor(RGB(255, 255, 255));
                dc.DrawFocusRect(&rc2); //破線
            }
        }
        bi.Draw(lpDrawItemStruct->hDC, rcItem.left, rcItem.top);
    }
 
    virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
    {
        if ( lpMeasureItemStruct->CtlType != ODT_LISTBOX || ToInt(lpMeasureItemStruct->CtlID) != _super::GetDlgCtrlID() )
        {
            return;
        }
        if ( m_iItemHeight < 0 )
        {
            LOGFONT lf;
            GetFont()->GetLogFont(&lf);
            m_iItemHeight = lf.lfHeight;
            if ( m_iItemHeight < 0 )
            {
                m_iItemHeight = -m_iItemHeight;
            }
            m_iItemHeight += m_margin * 2;
        }
        lpMeasureItemStruct->itemHeight = m_iItemHeight;
    }
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        int iIndex = ToInt(wParam);
        switch ( message )
        {
        case WM_ERASEBKGND: //背景
            {
                CDC dc;
                dc.Attach(reinterpret_cast<HDC>(wParam));
                CRect rect;
                GetClientRect(rect);
                int y = (GetCount() - GetTopIndex()) * m_iItemHeight;
                int h = rect.Height();
                if( h > y )
                {
                    if ( y < 0 )
                    {
                        y = 0;
                    }
                    CBrush* B = dc.GetCurrentBrush();
                    dc.FillRect(CRect(0, y, rect.Width(), h), B);
                }
                dc.Detach();
            }
            return 0;
        case WM_SETFONT:
            m_oneCharWidth = -1;
            break;
        case WM_SETFOCUS:
        case WM_KILLFOCUS:
            RedrawWindow();
            break;
        case LB_GETTEXTLEN: //文字列長取得
            // @param iIndex INDEX 
            // @return 長さ
            if ( IsInRange(iIndex, m_colors.GetSize()) )
            {
                return m_colors[iIndex]->item.GetLength();
            }
            return 0;
        case LB_GETTEXT: //文字列取得
            // @param[in] iIndex INDEX 
            // @param[out] lParam 格納先
            if ( IsInRange(iIndex, m_colors.GetSize()) )
            {
                STRLIB::Copy(reinterpret_cast<TCHAR*>(lParam), m_colors[iIndex]->item);
            }
            return 0;
        case LB_DELETESTRING: //削除
            // @param iIndex INDEX 
            if ( IsInRange(iIndex, m_colors.GetSize()) )
            {
//              m_linesString.RemoveAt(iIndex);
                delete m_colors[iIndex];
                m_colors.Remove(iIndex);
            }
            break;
        case LB_ADDSTRING: //追加
            // @param lParam 文字列アドレス 
            // @note 実際コントロールに設定するのは "" 
            {
                ASSERTLIB( ToInt(m_colors.GetSize()) == _super::GetCount() );
//              INT_PTR i = m_linesString.Add(reinterpret_cast<LPCTSTR>(lParam));
                TParam* P = new TParam;
                P->item = reinterpret_cast<LPCTSTR>(lParam);
                P->color = m_currentColor;
                m_colors.Add(P);
                m_CheckWidth(P->item);
            }
            lParam = reinterpret_cast<LPARAM>(_T(""));
            break;
        case LB_INSERTSTRING: //挿入
            // @param iIndex INDEX 
            // @param lParam 文字列アドレス 
            // @note 実際コントロールに設定するのは "" 
            if ( iIndex < 0 )
            {
                ASSERTLIB( ToInt(m_colors.GetSize()) == _super::GetCount() );
                TParam* P = new TParam;
                P->item = reinterpret_cast<LPCTSTR>(lParam);
                P->color = m_currentColor;
                m_colors.Add(P);
                m_CheckWidth(P->item);
            }
            else if ( IsInRange(iIndex, m_colors.GetSize() + 1) )
            {
    //          m_linesString.InsertAt(iIndex, reinterpret_cast<LPCTSTR>(lParam));
                TParam* P = new TParam;
                P->item = reinterpret_cast<LPCTSTR>(lParam);
                P->color = m_currentColor;
                m_colors.Insert(iIndex, P);
                m_CheckWidth(P->item);
            }
            lParam = reinterpret_cast<LPARAM>(_T(""));
            break;
        case LB_RESETCONTENT: //全消し
//          m_linesString.RemoveAll();
//          m_colors.RemoveAll();
            m_ColorsRemoveAll();
            m_iItemWidth = -1;
            _super::SetHorizontalExtent(m_iItemWidth);
            break;
        case WM_TIMER:
            if ( wParam == TIMERID_SETTOPINDEX )
            {
                KillTimer(TIMERID_SETTOPINDEX);
                m_postCount = 0;
                _super::SetTopIndex(m_lastPostIndex);
            }
            break;
        case WM_CLB_POSTSTRING:
            {
                TParam* P = reinterpret_cast<TParam*>(lParam);
                if ( ! P->color.IsEmpty() )
                {
                    m_currentColor = P->color;
                }
                if ( ::IsWindow(m_hWnd) )
                {
//                  CStr s;
//                  s.Format("%s      -(%d)", P->item, GetCount());
//                  LRESULT r = _super::InsertString(iIndex, s);
                    LRESULT r = _super::InsertString(iIndex, P->item);
                    KillTimer(TIMERID_SETTOPINDEX);
                    if ( m_isView )
                    {
                        if ( m_postCount < 0 )
                        {
                            _super::SetTopIndex(ToInt(r));
                        }
                        else if ( ++m_postCount > 4 )
                        {
                            m_postCount = 0;
                            _super::SetTopIndex(ToInt(r));
                        }
                        else
                        {
                            m_lastPostIndex = ToInt(r);
                            SetTimer(TIMERID_SETTOPINDEX, 100, NULL);
                        }
                    }
                }
                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_OWNERDRAWVARIABLE );
            ASSERT( dwStyle & LBS_EXTENDEDSEL );
            ASSERT( dwStyle & LBS_HASSTRINGS );
            ASSERT( m_colors.GetSize() == 0 );
        #endif
        _super::PreSubclassWindow();
    }
    virtual void PostNcDestroy(void) 
    {
//      m_linesString.RemoveAll();
//      m_colors.RemoveAll();
        m_ColorsRemoveAll();
        _super::PostNcDestroy();
    }
 
private:
    enum { TIMERID_SETTOPINDEX = 1 };
    struct TParam
    {
        CString     item;       
        CColor      color;      
    };
    int                     m_iItemHeight;          
    int                     m_iItemWidth;           
    CColor                  m_currentColor;         
    CVectorT<TParam*>       m_colors;               
//  CPointerVectorT<TParam> m_colors;               ///< 表示文字のカラー
//  CPointerVectorT<CColor> m_colors;               ///< 表示文字のカラー
//  CStringArray            m_linesString;          ///< 表示文字の内容
    DWORD                   m_margin;               
    bool                    m_isView;               
    int                     m_oneCharWidth;
    //
    DWORD                   m_lastPostIndex;
    int                     m_postCount;
 
    void m_ColorsRemoveAll(void)
    {
        loop ( i, m_colors )
        {
            delete m_colors[i];
        }
        m_colors.RemoveAll();
    }
 
    void m_CheckWidth(const CString& strItem)
    {
        if ( m_oneCharWidth < 0 )
        {
            CDC* pDC = GetDC();
            CFont* pFont = _super::GetFont();
            CFont* pFontOld = pDC->SelectObject(pFont);
            m_oneCharWidth = pDC->GetTextExtent("W").cx;
            pDC->SelectObject(pFontOld);
            ReleaseDC(pDC);
        }
        int l = strItem.GetLength() * m_oneCharWidth;
        if ( m_iItemWidth < l )
        {
            m_iItemWidth = l;
            _super::SetHorizontalExtent(m_iItemWidth);
        }
    }
};
 
 
 
}; // MFC
}; // TNB