TnbTextDrawer.h

[詳解]

#pragma once
#include "TnbDrawable.h"
#include "TnbDcSelectAssistant.h"
#ifndef _TnbDOXYGEN //Document作成用シンボル
 #ifndef BS_TYPEMASK
  #define BS_TYPEMASK 0x0000000F
 #endif
 #ifndef SS_TYPEMASK
  #define SS_TYPEMASK 0x0000001FL
 #endif
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTextDrawer : public CNullDrawer
{
    DEFSUPER(CNullDrawer);
public:
 
    CTextDrawer(const SIZE& size, HFONT font, COLORREF textColor, LPCTSTR str, DWORD drawStyle = DT_CENTER | DT_VCENTER, int margin = 0)
        : _super(size), m_font(font), m_textColor(textColor), m_str(str), m_drawStyle(drawStyle), m_margin(margin)
    {
    }
 
    CTextDrawer(HFONT font, COLORREF textColor, LPCTSTR str, DWORD drawStyle = DT_CENTER | DT_VCENTER, int margin = 0)
        : _super(), m_font(font), m_textColor(textColor), m_str(str), m_drawStyle(drawStyle), m_margin(margin)
    {
        AdjustSize(0);
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CTextDrawer(m_size, m_font, m_textColor, m_str, m_drawStyle, m_margin);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x + m_margin, y, x + m_size.cx, y + m_size.cy };
        CDcSelectAssistant dca(dc);
//      int oldBkMode = ::SetBkMode(dc, TRANSPARENT);
        dca.SetBkMode(TRANSPARENT);
        if ( m_font != NULL )
        {
//          HGDIOBJ oldObj = ::SelectObject(dc, m_font);
            dca.SelectFont(m_font);
            DrawTextRect(dc, rc, m_drawStyle, m_textColor, m_str);
//          ::SelectObject(dc, oldObj);
        }
        else
        {
            DrawTextRect(dc, rc, m_drawStyle, m_textColor, m_str);
        }
//      ::SetBkMode(dc, oldBkMode);
    }
 
    void SetTextColor(COLORREF color)
    {
        m_textColor = color;
    }
 
    COLORREF GetTextColor(void) const
    {
        return m_textColor;
    }
 
    void SetString(LPCTSTR str)
    {
        m_str = str;
    }
 
    LPCTSTR GetString(void) const
    {
        return m_str;
    }
 
    void SetDrawStyle(DWORD drawStyle = DT_CENTER | DT_VCENTER)
    {
        m_drawStyle = drawStyle;
    }
 
    DWORD GetDrawStyle(void) const
    {
        return m_drawStyle;
    }
 
    bool AdjustSize(int margin = 1, HWND hWnd = NULL)
    {
        HDC dc = ::GetDC(hWnd);
        CDcSelectAssistant dca(dc);
//      HGDIOBJ oldObj = ::SelectObject(dc, m_font);
        dca.SelectFont(m_font);
        SIZE s = m_size;
        bool r = CalcTextSize(s, dc, m_drawStyle, m_str);
//      if ( oldObj != NULL )
//      {
//          ::SelectObject(dc, oldObj);
//      }
        dca.Restore();
        ::ReleaseDC(hWnd, dc);
        if ( r )
        {
            m_size.cx = s.cx + margin + m_margin;
            m_size.cy = s.cy + margin;
        }
        return r;
    }
 
    
    // -----------------
 
    
    static DWORD StaticToDrawStyle(DWORD staticStyle)
    {
        UINT r = 0;
        switch ( staticStyle & SS_TYPEMASK )
        {
        case SS_CENTER:     r = DT_CENTER;      break;
        case SS_LEFT:       r = DT_LEFT;        break;
        case SS_RIGHT:      r = DT_RIGHT;       break;
        case SS_SIMPLE:     r = DT_SINGLELINE;  break;
        };
        if ( (staticStyle & SS_TYPEMASK) != SS_LEFTNOWORDWRAP )
        {
            r |= DT_WORDBREAK;
        }
        if ( (staticStyle & SS_CENTERIMAGE) != 0 )
        {
            r |= DT_VCENTER | DT_SINGLELINE;
        }
        if ( (staticStyle & SS_NOPREFIX) != 0 )
        {
            r |= DT_NOPREFIX;
        }
        #ifndef _WIN32_WCE
            if ( (staticStyle & SS_WORDELLIPSIS) == SS_WORDELLIPSIS )
            {
                r |= DT_WORD_ELLIPSIS;
            }
            else if ( (staticStyle & SS_ENDELLIPSIS) != 0 )
            {
                r |= DT_END_ELLIPSIS;
            }
            else if ( (staticStyle & SS_PATHELLIPSIS) != 0 )
            {
                r |= DT_PATH_ELLIPSIS;
            }
        #endif
        return r;
    }
 
    static DWORD ButtonToDrawStyle(DWORD buttonStyle)
    {
        DWORD r = 0;
        bool isPushButton = false;
        if ( (buttonStyle & BS_TYPEMASK) <= BS_DEFPUSHBUTTON || (buttonStyle & BS_PUSHLIKE) != 0 )
        {
            isPushButton = true;
        }
        switch ( buttonStyle & 0x0300 )
        {
        case BS_LEFT:   /*0x00000100L*/     r |= DT_LEFT;       break;
        case BS_RIGHT:  /*0x00000200L*/     r |= DT_RIGHT;      break;
        case BS_CENTER: /*0x00000300L*/     r |= DT_CENTER;     break;
        default:
            r |= (isPushButton ? DT_CENTER : DT_LEFT);
            break;
        }
 
        switch ( buttonStyle & 0x0C00 )
        {
        case BS_TOP:    /*0x00000400L*/     r |= DT_TOP;        break;
        case BS_BOTTOM: /*0x00000800L*/     r |= DT_BOTTOM;     break;
        default:
        case BS_VCENTER:/*0x00000C00L*/     r |= DT_VCENTER;    break;
        }
        if ( (buttonStyle & BS_MULTILINE) == 0 )
        {
            r |= DT_SINGLELINE;
        }
        else
        {
            r |= DT_WORDBREAK;
        }
        return r;
    }
 
    static bool CalcTextSize(SIZE& _size, HDC dc, UINT drawStyle, LPCTSTR str)
    {
        RECT rc = { 0, 0, _size.cx, _size.cy };
        int r = ::DrawText(dc, str, -1, &rc, (drawStyle & 0xFFFFFFF0) | DT_CALCRECT);
        _size.cx = rc.right;
        _size.cy = rc.bottom;
        return r != 0;
    }
 
    static bool CalcTextRect(RECT& _rect, HDC dc, DWORD drawStyle, LPCTSTR str)
    {
        SIZE sz = { _rect.right - _rect.left, _rect.bottom - _rect.top };
        if ( ! CalcTextSize(sz, dc, drawStyle, str) ) { return false; }
        RECT rc = { 0, 0, sz.cx, sz.cy };
        int cx = (_rect.right - _rect.left) - sz.cx;
        int cy = (_rect.bottom - _rect.top) - sz.cy;
        if ( (drawStyle & DT_CENTER) != 0 )
        {
            cx /= 2;
        }
        else if ( (drawStyle & DT_RIGHT) == 0 )
        {
            cx = 0;
        }
        if ( (drawStyle & DT_VCENTER) != 0 )
        {
            cy /= 2;
        }
        else if ( (drawStyle & DT_BOTTOM) == 0 )
        {
            cy = 0;
        }
        ::OffsetRect(&rc, cx + _rect.left, cy + _rect.top);
        _rect = rc;
        return true;
    }
 
    static bool DrawTextRect(RECT& _rect, HDC dc, DWORD drawStyle, const POINT& offset, COLORREF color1, COLORREF color2, LPCTSTR str)
    {
        if ( ! CalcTextRect(_rect, dc, drawStyle, str) ) 
        {
            return false;
        }
        drawStyle &= ~DT_VCENTER;
        RECT rc = _rect;
        if ( color1 == CLR_INVALID )
        {
            #ifndef _WIN32_WCE
                ::DrawState(dc, NULL, &ms_DrawStateProc,
                    reinterpret_cast<LPARAM>(str),
                    static_cast<WPARAM>(drawStyle), 
                    rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, DST_COMPLEX | DSS_DISABLED);
                return true;
            #else
                POINT po = { 1, 1 };
                return DrawTextRect(dc, _rect, drawStyle, po, ::GetSysColor(COLOR_GRAYTEXT), ::GetSysColor(COLOR_3DHILIGHT), str);
            #endif
        }
        if ( color1 == CLR_AUTOSELECT )
        {
            color1 = ::GetTextColor(dc);
        }
        if ( color2 == CLR_INVALID )
        {
            COLORREF oldColor = ::SetTextColor(dc, color1);
            ::DrawText(dc, str, -1, &rc, drawStyle);
            ::SetTextColor(dc, oldColor);
        }
        else
        {
            COLORREF oldColor = ::SetTextColor(dc, color2);
            ::OffsetRect(&rc, offset.x, offset.y);
            ::DrawText(dc, str, -1, &rc, drawStyle);
            ::SetTextColor(dc, color1);
            rc = _rect;
            ::DrawText(dc, str, -1, &rc, drawStyle);
            ::SetTextColor(dc, oldColor);
        }
        return true;
    }
 
    static bool DrawTextRect(HDC dc, const RECT& rect, DWORD drawStyle, const POINT& offset, COLORREF color1, COLORREF color2, LPCTSTR str)
    {
        RECT rc = rect;
        return DrawTextRect(rc, dc, drawStyle, offset, color1, color2, str);
    }
 
    static bool DrawTextRect(RECT& _rect, HDC dc, DWORD drawStyle, COLORREF color, LPCTSTR str)
    {
        POINT po = { 0, 0 };
        return DrawTextRect(_rect, dc, drawStyle, po, color, CLR_INVALID, str);
    }
 
    static bool DrawTextRect(HDC dc, const RECT& rect, DWORD drawStyle, COLORREF color, LPCTSTR str)
    {
        POINT po = { 0, 0 };
        RECT rc = rect;
        return DrawTextRect(rc, dc, drawStyle, po, color, CLR_INVALID, str);
    }
 
    #ifndef _WIN32_WCE
 
    static bool ModifyText(CSimpleStr& _str, const SIZE& size, HDC dc, LPCTSTR lpsz, UINT drawStyle = DT_END_ELLIPSIS | DT_NOPREFIX)
    {
        size_t len = STRLIB::GetLen(lpsz);
        CWorkMemT<TCHAR> work(len + 10);
        STRLIB::Copy(work, lpsz);
        RECT rc = { 0, 0, size.cx, size.cy };
        int r = ::DrawTextEx(dc, work, -1, &rc, (drawStyle & 0xFFFFFFF0) | DT_MODIFYSTRING | DT_CALCRECT, NULL);
        if ( r != 0 )
        {
            _str = work;
        }
        return r != 0;
    }
 
    static bool ModifyText(CSimpleStr& _str, HWND hWnd, LPCTSTR lpsz, UINT drawStyle = DT_END_ELLIPSIS | DT_NOPREFIX)
    {
        HDC dc = ::GetDC(hWnd);
        if ( dc != NULL )
        {
//          HGDIOBJ hFont = reinterpret_cast<HGDIOBJ>(::SendMessage(hWnd, WM_GETFONT, 0, 0));
            HFONT hFont = reinterpret_cast<HFONT>(::SendMessage(hWnd, WM_GETFONT, 0, 0));
            CDcSelectAssistant dca(dc);
//          HGDIOBJ hOld = ::SelectObject(dc, hFont);
            dca.SelectFont(hFont);
            RECT rc;
            ::GetClientRect(hWnd, &rc);
            SIZE size = { rc.right - rc.left, rc.bottom - rc.top };
            bool r = ModifyText(_str, size, dc, lpsz, drawStyle);
//          ::SelectObject(dc, hOld);
            dca.Restore();
            ::ReleaseDC(hWnd, dc);
            return r;
        }
        return false;
    }
 
    #endif // _WIN32_WCE
 
protected:
    HFONT           m_font;         
    COLORREF        m_textColor;    
    CSimpleStr      m_str;          
    DWORD           m_drawStyle;    
    int             m_margin;       
 
private:
    static BOOL CALLBACK ms_DrawStateProc(HDC hDC, LPARAM lParam, WPARAM wParam, int cx, int cy)
    {
        LPCTSTR str = reinterpret_cast<LPCTSTR>(lParam);
        DWORD drawStyle = static_cast<DWORD>(wParam);
        RECT rc = { 0, 0, cx, cy };
        ::DrawText(hDC, str, -1, &rc, drawStyle);
        return TRUE;
    }
};
 
 
 
class CTextBkDrawer : public CTextDrawer
{
    DEFSUPER(CTextDrawer);
    COLORREF m_backColor;   
public:
    CTextBkDrawer(const SIZE& size, HFONT font, COLORREF textColor, COLORREF backColor, LPCTSTR str, DWORD style = DT_CENTER | DT_VCENTER, int margin = 0)
        : _super(size, font, textColor, str, style, margin), m_backColor(backColor)
    {
    }
 
    CTextBkDrawer(HFONT font, COLORREF textColor, COLORREF backColor, LPCTSTR str, DWORD style = DT_CENTER | DT_VCENTER, int margin = 0)
        : _super(font, textColor, str, style, margin), m_backColor(backColor)
    {
    }
 
    virtual IDrawable* Clone(void) const
    {
        return new CTextBkDrawer(m_size, m_font, m_textColor, m_backColor, m_str, m_drawStyle, m_margin);
    }
 
    virtual void Draw(HDC dc, int x = 0, int y = 0) const
    {
        RECT rc = { x + m_margin, y, x + m_size.cx, y + m_size.cy };
        CDcSelectAssistant dca(dc);
//      COLORREF oldBackColor = ::SetBkColor(dc, m_backColor);
        dca.SetBkColor(m_backColor);
        ::ExtTextOut(dc, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
        if ( m_font != NULL )
        {
//          HGDIOBJ oldObj = ::SelectObject(dc, m_font);
            dca.SelectFont(m_font);
            DrawTextRect(dc, rc, m_drawStyle, m_textColor, m_str);
//          ::SelectObject(dc, oldObj);
        }
        else
        {
            DrawTextRect(dc, rc, m_drawStyle, m_textColor, m_str);
        }
//      ::SetBkColor(dc, oldBackColor);
    }
 
    void SetBackColor(COLORREF color)
    {
        m_backColor = color;
    }
};
 
 
 
}; //TNB