TnbMfcLayoutDialog.h

[詳解]

#pragma once
#include "TnbLayout.h"
 
 
#define classCLayoutDialog classCDialog
 
 
 
//TNB Library
namespace TNB {
namespace MFC {
 
 
 
class CControlLayoutItem : public ILayout
{
    DEFSUPER(ILayout);
public:
 
    CControlLayoutItem(HWND hWnd) : m_hWnd(hWnd)
    {
        ms_GetSize(m_hWnd, m_size);
    }
 
    CControlLayoutItem(HWND hWnd, const SIZE& sz) : m_hWnd(hWnd), m_size(sz)
    {
    }
 
    virtual ILayout* Clone(void) const
    {
        return new CControlLayoutItem(m_hWnd);
    }
 
    virtual bool GetSize(SIZE& _size) const
    {
        return ms_GetSize(m_hWnd, _size);
    }
 
    virtual bool GetMinimumSize(SIZE& _size) const
    {
        _size = m_size;
        return true;
    }
 
    virtual bool Resize(const SIZE& size)
    {
        ::SetWindowPos(m_hWnd, NULL, 0, 0, size.cx, size.cy, SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW);
        return true;
    }
 
    virtual void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        if ( y >= 0 && wParam == 'HWND' )
        {
            //-- Zオーダー変更
            HWND* pPrevHwnd = reinterpret_cast<HWND*>(lParam);
            ASSERT( ! ::IsBadWritePtr(pPrevHwnd, sizeof(HWND)) );
            ::SetWindowPos(m_hWnd, *pPrevHwnd, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW);
            *pPrevHwnd = m_hWnd;
        }
        ms_MoveControlPos(m_hWnd, x, y);
    }
 
    friend CControlLayoutItem Li(CWnd* pWnd);
 
    friend CControlLayoutItem Li(UINT ctrlId, CWnd* pParent);
 
private:
    // コントロールのクライアント座標、サイズ取得
    static bool ms_GetControlPos(POINT& _pos, HWND hWnd)
    {
        HWND hParent = ::GetParent(hWnd);
        RECT rc;
        if ( hParent != NULL && ::GetWindowRect(hWnd, &rc) )
        {
            POINT po = { rc.left, rc.top };
            if ( ::ScreenToClient(hParent, &po) )
            {
                _pos = po;
                return true;
            }
        }
        return false; 
    }
    /*
     * コントロール位置設定.
     *      コントロールを、(親ウィンドウの)指定のクライアント座標に移動します。
     *  @param hWnd コントロール。
     *  @param x クライアント X座標。-1なら移動なし。
     *  @param y クライアント Y座標。-1なら移動なし。
     */
    static bool ms_MoveControlPos(HWND hWnd, int x, int y)
    {
        POINT po;
        if ( ms_GetControlPos(po, hWnd) )
        {
            int xx = (x < 0) ? po.x : x;
            int yy = (y < 0) ? po.y : y;
            ::SetWindowPos(hWnd, NULL, xx, yy, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOREDRAW);
            return true;
        }
        return false;
    }
    static bool ms_GetSize(HWND hWnd, SIZE& _size)
    {
        RECT rc;
        if ( ::GetWindowRect(hWnd, &rc) )
        {
            _size.cx = rc.right - rc.left;
            _size.cy = rc.bottom - rc.top;
            return true;
        }
        _size.cx = 0;
        _size.cy = 0;
        return false;
    }
    HWND    m_hWnd;     
    SIZE    m_size;     
};
 
 
 
// レイアウトアイテム作成
inline CControlLayoutItem Li(CWnd* pWnd)
{
    ASSERT( pWnd != NULL );
    return CControlLayoutItem(pWnd->GetSafeHwnd());
}
 
// レイアウトアイテム作成
inline CControlLayoutItem Li(UINT ctrlId, CWnd* pParent)
{
    return Li(pParent->GetDlgItem(ctrlId));
}
 
 
 
class CLayoutDialog : public CDialog
{
    DEFSUPER(CDialog);
public:
 
    CLayoutDialog(void) : _super()
    {
    }
 
    CLayoutDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL) 
        : _super(lpszTemplateName, pParentWnd)
    {
    }
 
    CLayoutDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL) 
        : _super(nIDTemplate, pParentWnd)
    {
    }
 
    void SetResizeMode(bool canHorizontalResize = true, bool canVerticalResize = true)
    {
        m_param.canHorizontalResize = canHorizontalResize;
        m_param.canVerticalResize = canVerticalResize;
    }
 
    bool SetLayout(ILayout& lay, HWND zorderTop = HWND_TOP)
    {
        m_pLayout = lay.Clone();
        if ( ! m_pLayout.IsNull() && Decide(this, *m_pLayout, zorderTop) )
        {
            CRect winRc;
            _super::GetWindowRect(winRc);
            return !! _super::SetWindowPos(NULL, 0, 0, winRc.Width(), winRc.Height(), SWP_NOMOVE | SWP_NOZORDER);
        }
        return false;
    }
 
    bool ChangeClientSize(const SIZE& sz)
    {
        CRect winRc;
        CRect cliRc;
        _super::GetWindowRect(winRc);
        _super::GetClientRect(cliRc);
        CSize s = winRc.Size() - cliRc.Size();
        return !! _super::SetWindowPos(NULL, 0, 0, sz.cx + s.cx, sz.cy + s.cy, SWP_NOMOVE | SWP_NOZORDER);
    }
 
    bool ChangeMinimumSize(void)
    {
        if ( ! m_pLayout.IsNull() )
        {
            CSize sz;
            if ( m_pLayout->GetMinimumSize(sz) )
            {
                return ChangeClientSize(sz);
            }
        }
        return false;
    }
 
    void Decide(int x, int y, WPARAM wParam, LPARAM lParam)
    {
        if ( ! m_pLayout.IsNull() )
        {
            m_pLayout->Decide(x, y, wParam, lParam);
        }
    }
 
    static bool Decide(const RECT& rect, ILayout& lay, HWND zorderTop = HWND_TOP)
    {
        WPARAM wParam = 0;
        LPARAM lParam = 0;
        if ( zorderTop != HWND_NOTOPMOST && zorderTop != HWND_BOTTOM && zorderTop != HWND_TOPMOST)
        {
            wParam = 'HWND';
            lParam = reinterpret_cast<LPARAM>(&zorderTop);
        }
        SIZE sz = { rect.right - rect.left, rect.bottom - rect.top };
        bool r = lay.Resize(sz);
        lay.Decide(rect.left, rect.top, wParam, lParam);
        return r;
    }
 
    static bool Decide(CWnd* pWnd, ILayout& lay, HWND zorderTop = HWND_TOP)
    {
        bool r = false;
        if ( ::IsWindow(pWnd->GetSafeHwnd()) )
        {
            CRect rc;
            pWnd->GetClientRect(&rc);
            r = Decide(rc, lay, zorderTop);
            pWnd->Invalidate(FALSE);
        }
        return r;
    }
 
protected:
 
    virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
    {
        if ( ! m_pLayout.IsNull() )
        {
            if ( message == WM_SIZE )
            {
                int h = HIWORD(lParam);
                int w = LOWORD(lParam);
                m_pLayout->Resize(CSize(w, h));
                m_pLayout->Decide(0, 0, 0, 0);
                _super::RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN);
            }
            #ifndef _WIN32_WCE
            {
                if ( message == WM_GETMINMAXINFO )
                {
                    MINMAXINFO* P = reinterpret_cast<MINMAXINFO*>(lParam);
                    CRect winRc;
                    CRect cliRc;
                    _super::GetWindowRect(winRc);
                    _super::GetClientRect(cliRc);
                    CSize sz;
                    if ( m_pLayout->GetMinimumSize(sz) )
                    {
                        CSize s = winRc.Size() - cliRc.Size();
                        P->ptMinTrackSize.x = sz.cx + s.cx;
                        P->ptMinTrackSize.y = sz.cy + s.cy;
                        if ( ! m_param.canHorizontalResize )
                        {
                            P->ptMaxTrackSize.x = P->ptMinTrackSize.x;
                        }
                        if ( ! m_param.canVerticalResize )
                        {
                            P->ptMaxTrackSize.y = P->ptMinTrackSize.y;
                        }
                    }
                }
            }
            #endif
        }
        return _super::WindowProc(message, wParam, lParam);
    }
 
private:
 
    struct TParam
    {
        bool    canHorizontalResize;        
        bool    canVerticalResize;          
        TParam(void) : canHorizontalResize(true), canVerticalResize(true)
        {}
    };
    TParam          m_param;                
    ILayout::Ptr    m_pLayout;              
};
 
 
 
}; // MFC
}; // TNB