TnbMfcResizeDialog.h

[詳解]

#pragma once
#include "TnbMfcCommon.h"
 
 
 
#define classCResizeDialog classCDialog
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CResizeDialog : public CDialog
{
    DEFSUPER(CDialog);
    enum { DEFAULT_LINESTEP = 20 };
public:
 
    class CPaintOrgDC : public CPaintDC
    {
        DEFSUPER(CPaintDC);
        CResizeDialog*  m_pResizeDlg;
    public:
        explicit CPaintOrgDC(CResizeDialog* pWnd) : _super(pWnd), m_pResizeDlg(pWnd)
        {
            m_pResizeDlg->SetScrollOrg(this, true);
        }
        ~CPaintOrgDC(void)
        {
            m_pResizeDlg->SetScrollOrg(this, false);
        }
    };
 
    CResizeDialog(void) 
        : _super(), m_originalSize(0, 0), m_lineStep(DEFAULT_LINESTEP)
        , m_onThemeChanged(false), m_canSizeDisp(true)
    {
    }
 
    CResizeDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL) 
        : _super(lpszTemplateName, pParentWnd), m_originalSize(0, 0), m_lineStep(DEFAULT_LINESTEP)
        , m_onThemeChanged(false), m_canSizeDisp(true)
    {
    }
 
    CResizeDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL) 
        : _super(nIDTemplate, pParentWnd), m_originalSize(0, 0), m_lineStep(DEFAULT_LINESTEP)
        , m_onThemeChanged(false), m_canSizeDisp(true)
    {
    }
 
    CPoint GetScrollPoint(void) const
    {
        return CPoint(m_horizontalParam.GetPos(), m_verticalParam.GetPos());
    }
 
    void SetScrollOrg(CDC* pDc, bool isBegin = true) const
    {
        int cx = m_horizontalParam.GetPos();
        int cy = m_verticalParam.GetPos();
        if ( isBegin )
        {
            pDc->OffsetWindowOrg(cx, cy);
        }
        else
        {
            pDc->OffsetWindowOrg(-cx, -cy);
        }
    }
 
    CSize GetOriginalWindowSize(void) const
    {
        return GetOriginalSize() + m_offsetWinToClient;
    }
 
    const CSize& GetOriginalSize(void) const
    {
        return m_originalSize;
    }
 
    void SetOriginalWindowSize(const SIZE& size)
    {
        m_CheckOffset();
        UINT r = SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE;
        m_canSizeDisp = false;
        _super::SetWindowPos(NULL, 0, 0, size.cx, size.cy, r);
        m_canSizeDisp = true;
        CRect rc;
        GetClientRect(&rc);
        m_originalSize = rc.Size();
        m_InitScrollInfo();
    }
 
    void SetOriginalSize(const SIZE& size)
    {
        m_CheckOffset();
        m_originalSize = size;
        CSize s = size;
        s += m_offsetWinToClient;
        UINT r = SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE;
        m_canSizeDisp = false;
        _super::SetWindowPos(NULL, 0, 0, s.cx, s.cy, r);
        m_canSizeDisp = true;
        m_InitScrollInfo();
    }
 
    void ChangeOriginalSize(const SIZE& size)
    {
        int dx = 0;
        int dy = 0;
        if ( m_horizontalParam.GetMax() < size.cx )
        {
            dx -= size.cx - m_horizontalParam.GetMax();
        }
        if ( m_verticalParam.GetMax() < size.cy )
        {
            dy -= size.cy - m_verticalParam.GetMax();
        }
        m_OnHScroll(SB_LEFT, 0, NULL);
        m_OnVScroll(SB_TOP, 0, NULL);
        m_horizontalParam.ShowBar(*this, SB_HORZ, false);
        m_verticalParam.ShowBar(*this, SB_VERT, false);
        //
        m_CheckOffset();
        m_originalSize = size;
        CSize s = size;
        s += m_offsetWinToClient;
        UINT r = SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE;
        _super::SetWindowPos(NULL, 0, 0, s.cx, s.cy, r);
        m_InitScrollInfo();
        //
        _super::ScrollWindow(dx, 0);
        _super::ScrollWindow(0, dy);
    }
 
    void SetLineStep(int s)
    {
        m_lineStep = s;
    }
 
    void ResetWindowsSize(void)
    {
        m_OnHScroll(SB_LEFT, 0, NULL);
        m_OnVScroll(SB_TOP, 0, NULL);
        SIZE sz;
        SetOriginalWindowSize(sz);
        SetWindowPos(NULL, 0, 0, sz.cx, sz.cy, SWP_NOMOVE | SWP_NOZORDER);
    }
 
    virtual void OnPrintClient(CDC* pDC)
    {
    }
 
protected:
    void m_CheckOffset(void)
    {
        if ( m_originalSize.cx == 0 )
        {
            CRect cliRc;
            _super::GetClientRect(&cliRc);
            CRect winRc;
            _super::GetWindowRect(&winRc);
            m_originalSize = cliRc.Size();
            m_offsetWinToClient = winRc.Size() - cliRc.Size();
        }
    }
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        LRESULT r = 0;
        switch ( message )
        {
        case WM_NCLBUTTONDBLCLK:
            TTRACE0("WM_NCLBUTTONDBLCLK\n");
            if ( wParam == HTCAPTION )
            {
                CSize s = GetOriginalWindowSize();
                _super::SetWindowPos(NULL, 0, 0, s.cx, s.cy, SWP_NOMOVE | SWP_NOZORDER);
                return 0;
            }
            break;
        case WM_SIZE:
            TTRACE0("WM_SIZE\n");
            r = _super::WindowProc(message, wParam, lParam);
            if ( m_canSizeDisp )
            {
                m_OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
            }
            return r;
        case WM_GETMINMAXINFO:
            TTRACE0("WM_GETMINMAXINFO\n");
            m_CheckOffset();
            if ( m_originalSize.cx != 0 )
            {
                LPMINMAXINFO P = reinterpret_cast<LPMINMAXINFO>(lParam);
                P->ptMaxTrackSize.x = m_originalSize.cx + m_offsetWinToClient.cx;
                P->ptMaxTrackSize.y = m_originalSize.cy + m_offsetWinToClient.cy;
            }
            break;
        case WM_HSCROLL:
            TTRACE2("WM_HSCROLL %d 0x%08X\n", LOWORD(wParam), lParam);
            m_OnHScroll(LOWORD(wParam), HIWORD(wParam), reinterpret_cast<HWND>(lParam));
            break;
        case WM_VSCROLL:
            TTRACE2("WM_VSCROLL %d 0x%08X\n", LOWORD(wParam), lParam);
            m_OnVScroll(LOWORD(wParam), HIWORD(wParam), reinterpret_cast<HWND>(lParam));
            break;
        case WM_MOUSEWHEEL:
            TTRACE0("WM_MOUSEWHEEL\n");
            if ( m_OnMouseWheel(LOWORD(wParam), static_cast<short>(HIWORD(wParam)), lParam) )
            {
                return TRUE;
            }
            break;
        case WM_PRINT:
            TTRACE1("WM_PRINT 0x%08X\n", lParam);
            r = _super::WindowProc(message, wParam, lParam & ~(PRF_OWNED | PRF_CHILDREN));
            if ( (lParam & PRF_CHILDREN) != 0 )
            {
                CRect rectWin;
                _super::GetWindowRect(rectWin);
                CDC* pDC = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                CPoint orgOrg = pDC->GetWindowOrg();
                CWnd* pWnd = CWnd::GetWindow(GW_CHILD);
                while ( pWnd != NULL )
                {
                    CRect rect;
                    pWnd->GetWindowRect(rect);
                    CSize po = rect.TopLeft() - rectWin.TopLeft();
                    pDC->SetWindowOrg(orgOrg - po);
                    pWnd->SendMessage(WM_PRINT, wParam, lParam | PRF_CHECKVISIBLE);
                    pWnd = pWnd->GetNextWindow();
                }
                pDC->SetWindowOrg(orgOrg);
                if ( (lParam & PRF_NONCLIENT) != 0 )
                {
                    SendMessage(message, wParam, PRF_NONCLIENT);
                }
            }
            return r;
        case WM_PRINTCLIENT:
            TTRACE0("WM_PRINTCLIENT\n");
            {
                CDC* pDC = CDC::FromHandle(reinterpret_cast<HDC>(wParam));
                SetScrollOrg(pDC);
                OnPrintClient(pDC);
                SetScrollOrg(pDC, false);
            }
            break;
        case WM_INITDIALOG:
            TTRACE0("WM_INITDIALOG\n");
            r = _super::WindowProc(message, wParam, lParam);
            m_InitScrollInfo();
            return r;
        case WM_THEMECHANGED:
            TTRACE0("WM_THEMECHANGED\n");
            m_onThemeChanged = true;
            break;
        case WM_EXITSIZEMOVE:
            TTRACE0("WM_EXITSIZEMOVE\n");
            m_onThemeChanged = false;
            break;
        case WM_WINDOWPOSCHANGED:
            TTRACE0("WM_WINDOWPOSCHANGED\n");
            {
                LRESULT r = _super::WindowProc(message, wParam, lParam);
                WINDOWPOS* W = reinterpret_cast<WINDOWPOS*>(lParam);
                if ( m_onThemeChanged && (W->flags & SWP_FRAMECHANGED) != 0 )
                {
                    CRect cliRc;
                    _super::GetClientRect(&cliRc);
                    CRect winRc;
                    _super::GetWindowRect(&winRc);
                    CSize sz = m_offsetWinToClient;
                    m_offsetWinToClient = winRc.Size() - cliRc.Size();
                    if ( m_horizontalParam.IsEnable() )
                    {
                        m_offsetWinToClient.cx -= ::GetSystemMetrics(SM_CYHSCROLL);
                    }
                    if ( m_verticalParam.IsEnable() )
                    {
                        m_offsetWinToClient.cy -= ::GetSystemMetrics(SM_CXHSCROLL);
                    }
                    m_OnSize(0, cliRc.right, cliRc.bottom);
                }
                return r;
            }
            break;
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
 
    class CBarParam
    {
        int     m_pos;              
        int     m_max;              
        int     m_page;             
        bool    m_boIsEnable;           
    public:
        CBarParam(void) : m_boIsEnable(false), m_pos(0), m_max(0), m_page(0) { }
        int GetPos(void) const { return m_boIsEnable ? m_pos : 0; }
        int GetMax(void) const { return m_max; }
        bool IsEnable(void) const { return m_boIsEnable; }
        void SetMax(int max)
        {
            m_pos = 0;
            m_max = max;
            m_page = max;
        }
        int SetPage(int pa)
        {
            m_page = pa;
            int delta = 0;
            if ( m_pos + m_page > m_max )
            {
                delta = m_pos - (m_max - m_page);
                m_pos = m_max - m_page;
            }
            return delta;
        }
        void ShowBar(HWND h, int nBar, bool isEnable)
        {
            m_boIsEnable = isEnable;
            if ( m_boIsEnable )
            {
                SCROLLINFO si = { sizeof(SCROLLINFO), SIF_ALL, 0, m_max - 1, m_page, m_pos, 0 };
                ASSERTLIB( si.cbSize == sizeof(SCROLLINFO) && si.nPos == m_pos );
                ::SetScrollInfo(h, nBar, &si, TRUE);
                ::ShowScrollBar(h, nBar, TRUE);
            }
            else
            {
                ::ShowScrollBar(h, nBar, FALSE);
//              ::InvalidateRect(h, NULL, false);
            }
        }
        int Scroll(UINT nSBCode, UINT nPos, int lineStep) const
        {
            int delta = 0;
            switch ( nSBCode )
            {
            case SB_LEFT: // SB_TOP
                delta = -m_pos;
                break;
            case SB_LINERIGHT: // SB_LINEDOWN
            case SB_PAGERIGHT: // SB_PAGEDOWN
                if ( m_pos + m_page < m_max )
                {
                    int r = (nSBCode == SB_LINERIGHT) ? lineStep : m_page;
                    delta = min(r, m_max - (m_pos + m_page));
                }
                break;
            case SB_LINELEFT: // SB_LINEUP
            case SB_PAGELEFT: // SB_PAGEUP
                if ( m_pos > 0 )
                {
                    int r = (nSBCode == SB_LINELEFT) ? lineStep : m_page;
                    delta = -min(r, m_pos);
                }
                break;
            case SB_THUMBTRACK:
            case SB_THUMBPOSITION:
                delta = static_cast<int>(nPos) - m_pos;
                break;
            default:
                break;
            }
            if ( m_pos + delta < 0 )
            {
                delta = -m_pos;
            }
            if ( m_pos + m_page + delta > m_max )
            {
                delta = m_max - (m_pos + m_page);
            }
            return delta;
        }
        int AddPos(int delta)
        {
            m_pos += delta;
            return m_pos;
        }
    };
    CSize       m_originalSize;     
    CSize       m_offsetWinToClient;
    CBarParam   m_horizontalParam;  
    CBarParam   m_verticalParam;    
    int         m_lineStep;         
    bool        m_onThemeChanged;   
    bool        m_canSizeDisp;      
 
    void m_InitScrollInfo(void)
    {
        _super::ShowScrollBar(SB_HORZ, FALSE);
        _super::ShowScrollBar(SB_VERT, FALSE);
        CRect rect;
        _super::GetClientRect(rect);
        m_horizontalParam.SetMax(rect.Width());
        m_verticalParam.SetMax(rect.Height());
    }
    void m_OnSize(WPARAM nType, int cx, int cy)
    {
        if ( m_originalSize.cx != 0 )
        {
            CRect rect;
            _super::GetWindowRect(rect);
            bool isEnable = !! (m_originalSize + m_offsetWinToClient != rect.Size());
            if ( isEnable )
            {
                if ( (rect.Height() - m_offsetWinToClient.cy) <= ::GetSystemMetrics(SM_CYHSCROLL) )
                {
                    isEnable = false;
                }
            }
            _super::ScrollWindow(m_horizontalParam.SetPage(cx), m_verticalParam.SetPage(cy));
            m_horizontalParam.ShowBar(*this, SB_HORZ, isEnable);
            m_verticalParam.ShowBar(*this, SB_VERT, isEnable);
        }
    }
    void m_OnHScroll(UINT nSBCode, UINT nPos, HWND hScrollBar)
    {
        if ( hScrollBar == NULL )
        {
            int delta = m_horizontalParam.Scroll(nSBCode, nPos, m_lineStep);
            if ( delta != 0 )
            {
                _super::SetScrollPos(SB_HORZ, m_horizontalParam.AddPos(delta), TRUE);
                _super::ScrollWindow(-delta, 0);
            }
        }
    }
    void m_OnVScroll(UINT nSBCode, UINT nPos, HWND hScrollBar)
    {
        if ( hScrollBar == NULL )
        {
            int delta = m_verticalParam.Scroll(nSBCode, nPos, m_lineStep);
            if ( delta != 0 )
            {
                _super::SetScrollPos(SB_VERT, m_verticalParam.AddPos(delta), TRUE);
                _super::ScrollWindow(0, -delta);
            }
        }
    }
    bool m_OnMouseWheel(UINT fFlags, short delta, LPARAM lParam)
    {
        if ( ! m_verticalParam.IsEnable() ) { return false; }
        int d = 0;
        if ( delta < 0)
        {
            d = m_verticalParam.Scroll(SB_LINEDOWN, 0, (-delta) / 10 + 1);
        }
        else if ( delta > 0 )
        {
            d = m_verticalParam.Scroll(SB_LINEUP, 0, (delta) / 10 + 1);
        }
        if ( d != 0 )
        {
            _super::SetScrollPos(SB_VERT, m_verticalParam.AddPos(d), TRUE);
            _super::ScrollWindow(0, -d);
        }
        return true;
    }
};
 
 
 
}; //MFC
}; //TNB