TnbMfcCommon.h

[詳解]

#pragma once
#include "TnbDynamicFunc.h"
#include "TnbTextDrawer.h"
#include "TnbBitmapImage.h"
 
 
#ifndef __AFX_H__
 #error
#endif
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
    
namespace MFCLIB 
{
 
    inline UINT _deprecated StaticToDrawStyle(DWORD staticStyle)
    {
        return CTextDrawer::StaticToDrawStyle(staticStyle);
    }
 
    inline bool SetControlPos(CWnd* pWnd, int x, int y, bool boIsRepaint = false)
    {
        CWnd* pParent = pWnd->GetParent();
        if ( pParent == NULL ) { return false; }
        CRect rc;
        pWnd->GetWindowRect(&rc);
        pParent->ScreenToClient(&rc);
        int xx = (x < 0) ? rc.left : x;
        int yy = (y < 0) ? rc.top : y;
        pWnd->MoveWindow(xx, yy, rc.Width(), rc.Height(), boIsRepaint);
        return true;
    }
 
    inline bool GetControlPos(CWnd* pWnd, POINT& _po)
    {
        _po.x = _po.y = 0;
        if ( ! ::IsWindow(pWnd->GetSafeHwnd()) ) { return false; }
        CWnd* pParent = pWnd->GetParent();
        if ( pParent == NULL ) { return false; }
        CRect rc;
        pWnd->GetWindowRect(&rc);
        pParent->ScreenToClient(&rc);
        _po = rc.TopLeft();
        return true;
    }
 
    inline bool ChangeClientSize(CWnd* pWnd, int cx = -1, int cy = -1)
    {
        CRect rcWin;
        CRect rcCli;
        pWnd->GetWindowRect(&rcWin);
        pWnd->GetClientRect(&rcCli);
        int wx = rcWin.Width() - rcCli.Width();
        int wy = rcWin.Height() - rcCli.Height();
        int xx = (cx < 0) ? rcCli.Width() : cx;
        int yy = (cy < 0) ? rcCli.Height() : cy;
        return !! pWnd->SetWindowPos(NULL, 0, 0, wx + xx, wy + yy, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
    }
 
    inline CPoint GetClientPoint(CWnd* pWnd)
    {
        CRect winRc;
        pWnd->GetWindowRect(&winRc);
        CRect cliRc;
        pWnd->GetClientRect(&cliRc);
        pWnd->ClientToScreen(&cliRc);
        return cliRc.TopLeft() - winRc.TopLeft();
    }
 
    inline void DrawBox(CDC* pDC, const RECT& rect, CPen& pen)
    {
        CPen* pOldPen = pDC->SelectObject(&pen);
        pDC->MoveTo(rect.left, rect.top);
        pDC->LineTo(rect.right - 1, rect.top);
        pDC->LineTo(rect.right - 1, rect.bottom - 1);
        pDC->LineTo(rect.left, rect.bottom - 1);
        pDC->LineTo(rect.left, rect.top);
        pDC->SelectObject(pOldPen);
    }
 
    inline void DrawBox(CDC* pDC, const RECT& rect, int nPenStyle, int nWidth, COLORREF color)
    {
        CPen pen;
        pen.CreatePen(nPenStyle, nWidth, color);
        DrawBox(pDC, rect, pen);
    }
 
    inline void DrawDottedBox(CDC* pDC, const RECT& rect, COLORREF color)
    {
        DrawBox(pDC, rect, PS_DOT, 1, color);
    }
 
    inline void DrawParent(CWnd* pWndControl, bool boIsRedraw = true)
    {
        if ( pWndControl != NULL )
        {
            CRect rect;
            pWndControl->GetWindowRect(&rect);
            CWnd* pWnd = pWndControl->GetParent();
            if ( pWnd != NULL )
            {
                pWnd->ScreenToClient(&rect);
                if ( boIsRedraw )
                {
                    pWnd->RedrawWindow(&rect);
                }
                else
                {
                    pWnd->InvalidateRect(&rect);
                }
            }
        }
    }
 
    inline void AdjustClientSize(CWnd* pWnd, CDC* pDC, UINT drawStyle, LPCTSTR lpsz, int margin = 2)
    {
        CString str = lpsz;
        if ( str.IsEmpty() ) { return; }
        CRect rect;
        pWnd->GetClientRect(&rect);
        CSize sz(rect.Width(), 0);
        if ( CTextDrawer::CalcTextSize(sz, *pDC, drawStyle, str) )
        {
            if ( margin >= 0 )
            {
                ChangeClientSize(pWnd, sz.cx + margin, sz.cy + margin);
            }
            else
            {
                CPoint po;
                ChangeClientSize(pWnd, sz.cx - margin * 2, sz.cy - margin * 2);
                GetControlPos(pWnd, po);
                SetControlPos(pWnd, po.x + margin, po.y + margin);
            }
        }
    }
 
#ifndef _WIN32_WCE
    inline void AdjustClientSize(CDC* pDC, UINT drawStyle, LPCTSTR lpsz, int margin = 2)
    {
        AdjustClientSize(pDC->GetWindow(), pDC, drawStyle, lpsz, margin);
    }
#endif
 
    inline CBitmapHandle GetParentImage(CWnd* pWndControl, COLORREF backColor = CLR_INVALID)
    {
        CBitmapHandle b;
        if ( pWndControl != NULL )
        {
            CWnd* pWnd = pWndControl->GetParent();
            if ( pWnd != NULL )
            {
                CRect rc;
                pWndControl->GetClientRect(rc);
                pWndControl->ClientToScreen(rc);
                pWnd->ScreenToClient(rc);
                CBitmapImage bi;
                bi.SetFromClient(*pWnd, rc, backColor);
                b = bi.GetBitmapHandle();
            }
        }
        return b;
    }
 
    inline void SetTextForStatic(CWnd* pWnd, LPCTSTR lpsz, int margin = 2)
    {
        CString str = lpsz;
        pWnd->SetWindowText(str);
        if ( str.IsEmpty() ) { return; }
        UINT drawStyle = CTextDrawer::StaticToDrawStyle(pWnd->GetStyle());
        CDC* pDC = pWnd->GetDC();
        CGdiObject* pOld = pDC->SelectObject(pWnd->GetFont());
        AdjustClientSize(pWnd, pDC, drawStyle, lpsz, margin);
        pDC->SelectObject(pOld);
        pWnd->ReleaseDC(pDC);
    }
 
    inline int SelectClipRgnOrg(CDC* pDC, HRGN rgn, int mode = RGN_COPY)
    {
        int r = ERROR;
        CPoint offset = pDC->GetWindowOrg();
        if ( offset.x == 0 && offset.y == 0 )
        {
            r = ::ExtSelectClipRgn(*pDC, rgn, mode);
        }
        else
        {
            HRGN tmp= ::CreateRectRgn(0, 0, 0, 0);
            ::CombineRgn(tmp, rgn, NULL, RGN_COPY);
            ::OffsetRgn(tmp, -offset.x, -offset.y);
            r = ::ExtSelectClipRgn(*pDC, tmp, mode);
            _DeleteObject(tmp);
        }
        return r;
    }
 
    enum ELayeredAction
    {
        E_ColorKey          = _BIT(0),  
        E_Alpha             = _BIT(1),  
        E_SetLayeredStyle   = _BIT(31), 
    };
 
    inline bool SetLayeredWindow(CWnd* pWnd, COLORREF crKey = 0, BYTE bAlpha = 255, DWORD dwFlags = E_Alpha | E_SetLayeredStyle)
    {
        bool r = false;
        if ( (dwFlags & E_SetLayeredStyle) != 0 )
        {
            dwFlags &= ~E_SetLayeredStyle;
            pWnd->ModifyStyleEx(0, WS_EX_LAYERED);
        }
        try
        {
            typedef BOOL (__stdcall *PSETLAYEREDATTR)(HWND, COLORREF, BYTE, DWORD); 
            r = !! CDynamicFuncT<PSETLAYEREDATTR>("user32.dll", "SetLayeredWindowAttributes")()
                                        (pWnd->m_hWnd, crKey, bAlpha, dwFlags);
        }
        catch (CNullPointerException& e)
        {
            e.OnCatch();
            r = false;
        }
        return r;
    }
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
        enum 
        {
            _TnbProcessingFlag  = WS_SYSMENU,
            _TnbWndLong     = GWL_STYLE
        };
        
    #endif
 
    inline void SetProcessingFlag(HWND hWnd, bool isEnable)
    {
        LONG l = ::GetWindowLong(hWnd, _TnbWndLong);
        if ( isEnable )
        {
            l |= _TnbProcessingFlag;
        }
        else
        {
            l &= ~_TnbProcessingFlag;
        }
        ::SetWindowLong(hWnd, _TnbWndLong, l);
        ASSERT( l == ::GetWindowLong(hWnd, _TnbWndLong) );
    }
 
    inline bool IsProcessingFlag(HWND hWnd)
    {
        LONG l = ::GetWindowLong(hWnd, _TnbWndLong);
        return (l & _TnbProcessingFlag) != 0;
    }
 
    inline void PumpMessage(void)
    {
        MSG msg;
        while ( ::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE) )
        {
            AfxGetThread()->PumpMessage();
        }
    }
 
    inline LRESULT SendCommandMessage(CWnd* pCtrl, UINT cmd)
    {
        CWnd* pParent = pCtrl->GetParent();
        if ( pParent != NULL && ::IsWindow(pParent->GetSafeHwnd()) )
        {
            WPARAM wp = MAKEWPARAM(pCtrl->GetDlgCtrlID(), cmd);
            LPARAM lp = reinterpret_cast<LPARAM>(pCtrl->GetSafeHwnd());
            return pParent->SendMessage(WM_COMMAND, wp, lp);
        }
        return 0;
    }
 
}; //MFCLIB
 
 
 
class CFindDescendants
{
public:
    virtual bool OnFound(HWND hWnd) = 0;
 
    bool Execute(HWND hWnd, bool bDeep = false)
    {
        for (HWND hChild = ::GetTopWindow(hWnd); hChild != NULL; hChild = ::GetNextWindow(hChild, GW_HWNDNEXT))
        {
            if ( ! OnFound(hChild) )
            {
                return false;
            }
            if (bDeep && ::GetTopWindow(hChild) != NULL)
            {
                // send to child windows after parent
                if ( ! Execute(hChild, bDeep) )
                {
                    return false;
                }
            }
        }
        return true;
    }
};
 
 
 
class CDrawTextBase
{
protected:
    struct TColor
    {
        COLORREF    forward;        
        COLORREF    back;           
        TColor(void) : forward(::GetSysColor(COLOR_WINDOWTEXT)), back(CLR_INVALID) { }
        TColor(COLORREF c) : forward(c), back(CLR_INVALID) { }
    };
    TColor          m_normalColors;     
    TColor          m_disableColors;    
    CPoint          m_offset;           
 
    virtual void DrawText(CDC* pDC, const RECT& rect, UINT drawStyle, const TColor& c, LPCTSTR str)
    {
        if ( (drawStyle & DT_VCENTER) != 0 )
        {
            drawStyle &= ~DT_VCENTER;
            int h = rect.bottom - rect.top;
            CSize sz(rect.right - rect.left, h);
            CTextDrawer::CalcTextSize(sz, *pDC, drawStyle, str);
            CRect rc = rect;
            rc.top += (h - sz.cy) / 2;
            CTextDrawer::DrawTextRect(*pDC, rc, drawStyle, m_offset, c.forward, c.back, str);
            return;
        }
        CTextDrawer::DrawTextRect(*pDC, rect, drawStyle, m_offset, c.forward, c.back, str);
    }
 
    void DrawTextEx(CDC* pDC, const RECT& rect, UINT drawStyle, bool boIsEnable, LPCTSTR str)
    {
        DrawText(pDC, rect, drawStyle, (boIsEnable ? m_normalColors : m_disableColors), str);
    }
 
public:
 
    CDrawTextBase(void) : m_normalColors(), m_disableColors(CLR_INVALID), m_offset(0, 0)
    {
    }
 
    void SetTextDeepOffset(int x, int y)
    {
        m_offset.x = x;
        m_offset.y = y;
    }
 
    void SetTextColor(COLORREF color1, COLORREF color2 = CLR_INVALID)
    {
        m_normalColors.forward = color1;
        m_normalColors.back = color2;
    }
 
    void SetTextDisableColor(COLORREF color1, COLORREF color2 = CLR_INVALID)
    {
        m_disableColors.forward = color1;
        m_disableColors.back = color2;
    }
};
 
 
 
}; //MFC
}; //TNB