TnbMfcAttributedTextCtrl.h

[詳解]

#pragma once
#include "TnbAttributedStr.h"
#include "TnbThread.h"
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CAttributedTextCtrl : public CStatic, TNB::CThread::IRunner
{
    DEFSUPER(CStatic);
public:
 
    enum EAttr
    {
        NORMAL,     
        REVERSE,    
        BLINK       
    };
 
    typedef CAttributedStrT<EAttr>  CAttrStr;       
 
private:
    
    CThread         m_thread;               
    bool            m_boIsNormalForBlink;   
    CFont*          m_pfont;                
    CRect           m_rect;                 
    CPoint          m_pointMargin;          
    COLORREF        m_colorBack;            
    COLORREF        m_colorNormal;          
    CSyncCounter    m_syncDraw;             
    enum {
        BLINK_TIMING = 500                  
    };
    CAttrStr                m_content;      
    CVectorT<INDEX>         m_vdwTopPoss;   
 
    void m_ResearchContent(void)
    {
        m_vdwTopPoss.RemoveAll();
        m_vdwTopPoss.Add(0);
        loop ( i, m_content.GetLength() )
        {
            if ( m_content.GetAt(i) == '\r' )
            {
                if ( m_content.GetAt(i + 1) == '\n' )
                {
                    m_vdwTopPoss.Add(i + 2);
                }
                else
                {
                    m_vdwTopPoss.Add(i + 1);
                }
            }
        }
    }
 
    void m_Draw(CDC* dc, bool boIsForBlink = false)
    {
        dc->SaveDC();
        CFont* pOldFont = dc->SelectObject(m_pfont);
 
        dc->IntersectClipRect(m_rect);
 
        if ( ! boIsForBlink )
        {
            dc->FillSolidRect(m_rect, m_colorBack);
        }
        LOGFONT tFont;
        m_pfont->GetLogFont(&tFont);
        dc->SetBkMode(OPAQUE/*TRANSPARENT*/);
        loop ( i, m_vdwTopPoss.GetSize() )
        {
            CRect r = m_rect;
            r.OffsetRect(m_pointMargin);
            r.OffsetRect(0, abs(static_cast<LONG>(tFont.lfHeight * i)));
            TCHAR c[3] = {0};
            UINT uChar;
            INDEX j = m_vdwTopPoss[i];
            while ( j < m_content.GetLength() )
            {
                EAttr a = m_content.GetAttribute(j);
                c[0] = m_content.GetAt(j++);
                if ( c[0] == '\n' || c[0] == 0 )
                {
                    break;
                }
                if ( a == BLINK )
                {
                    a = m_boIsNormalForBlink ? NORMAL : REVERSE;
                }
                if ( a == NORMAL )
                {
                    dc->SetTextColor(m_colorNormal);
                    dc->SetBkColor(m_colorBack);
                }
                else
                {
                    dc->SetTextColor(m_colorBack);
                    dc->SetBkColor(m_colorNormal);
                }
                uChar = c[0] & 0xff;
                if ( STRLIB::GetCharSize(c[0]) == 2 )
                {
                    //- SJISだ
                    c[1] = m_content.GetAt(j);
                    uChar = (uChar << 8) | (c[1] & 0xFF);
                    j++;
                    dc->DrawText(c, 2, r, 0);
                }
                else
                {
                    //- ASCIIだ
                    dc->DrawText(c, 1, r, 0);
                }
                //
                ABC abc;
                VERIFY(dc->GetCharABCWidths(uChar, uChar, &abc));
                r.OffsetRect(abc.abcA + abc.abcB + abc.abcC, 0);
            }
        }
        dc->SelectObject(pOldFont);
        dc->RestoreDC(-1);
    }
 
    DWORD Run(void)
    {
        while ( IsRunnable() )
        {
            ::Sleep(BLINK_TIMING);
            m_boIsNormalForBlink = ! m_boIsNormalForBlink;
            if ( m_syncDraw.Lock(0) )
            {
                if ( ::IsWindow(GetSafeHwnd()) )
                {
                    HDC hdc = ::GetDC(m_hWnd);
                    if ( hdc != NULL )
                    {
                        CDC dc;
                        dc.Attach(hdc);
                        m_Draw(&dc, true);
                        hdc = dc.Detach();
                        ::ReleaseDC(m_hWnd, dc); 
                    }
                }
                m_syncDraw.Unlock();
            }
        }
        return 0;
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( message == WM_PAINT )
        {
            CPaintDC dc(this); // 描画用のデバイス コンテキスト
            if ( m_syncDraw.Lock(0) )
            {
                m_Draw(&dc);
                m_syncDraw.Unlock();
            }
            return 0;
        }
        else if ( message == WM_PRINTCLIENT )
        {
//          if ( (lParam & PRF_CLIENT) != 0 )
            {
                CDC* pDc = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                if ( m_syncDraw.Lock(0) )
                {
                    m_Draw(pDc);
                    m_syncDraw.Unlock();
                }
            }
            return 0;
        }
        else if ( message == WM_SETTEXT )
        {
            CAttrStr s(reinterpret_cast<LPCTSTR>(lParam));
            SetContent(s);
        }
        else if ( message == WM_DESTROY )
        {
            EXCLUSIVE(&m_syncDraw);
            return _super::WindowProc(message, wParam, lParam);
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
    virtual void PreSubclassWindow(void)
    {
        _super::GetClientRect(m_rect);
        _super::PreSubclassWindow();
        CString s;
        _super::GetWindowText(s);
        m_content = s.operator LPCTSTR();
        m_ResearchContent();
        //
        CWnd* P = GetParent();
        if ( P != NULL )
        {
            m_pfont = P->GetFont();
        }
        m_thread.Start(_T("CAttributeTextCtrl Blink用"));
    }
 
public:
 
    CAttributedTextCtrl(void)
        : _super()
        , m_colorBack(::GetSysColor(COLOR_MENU))
        , m_colorNormal(::GetSysColor(COLOR_MENUTEXT))
        , m_boIsNormalForBlink(false)
        , m_pointMargin(0, 0)
    {
        m_thread.SetRunner(this);
    }
 
    ~CAttributedTextCtrl(void)
    {
        m_thread.Stop();
    }
 
    void SetMargin(int x, int y)
    {
        m_pointMargin.x = x;
        m_pointMargin.y = y;
    }
 
    void SetFont(CFont* pFont, BOOL bRedraw = TRUE)
    {
        m_pfont = pFont;
        _super::SetFont(pFont, bRedraw);
    }
 
    const CAttrStr& GetContent(void) const
    {
        return m_content;
    }
 
    void SetContent(const CAttrStr& as)
    {
        m_content = as;
        m_ResearchContent();
        RedrawWindow();
    }
 
    void AddContent(const CAttrStr& as)
    {
        m_content += as;
        m_ResearchContent();
        RedrawWindow();
    }
 
    void InsertContent(int iIndex, const CAttrStr& as)
    {
        m_content.Insert(iIndex, as);
        m_ResearchContent();
        RedrawWindow();
    }
 
    void SetAt(int iIndex, TCHAR c, EAttr attr = NORMAL)
    {
        m_content.SetAt(iIndex, c, attr);
    }
};
 
 
 
}; //MFC
}; //TNB