ResizableSheet.cpp

// ResizableSheet.cpp : implementation file
//
//
// Copyright (C) 2000-2002 by Paolo Messina
// (http://www.geocities.com/ppescher - [email protected])
//
// The contents of this file are subject to the Artistic License (the "License").
// You may not use this file except in compliance with the License. 
// You may obtain a copy of the License at:
// http://www.opensource.org/licenses/artistic-license.html
//
// If you find this code useful, credits would be nice!
//

#include "stdafx.h"
#include "ResizableSheet.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CResizableSheet

IMPLEMENT_DYNAMIC(CResizableSheet, CPropertySheet)

inline void CResizableSheet::PrivateConstruct()
{
        m_bEnableSaveRestore = FALSE;
        m_bSavePage = FALSE;
        m_dwGripTempState = 1;
}


CResizableSheet::CResizableSheet()
{
        PrivateConstruct();
}

CResizableSheet::CResizableSheet(UINT nIDCaption, CWnd *pParentWnd, UINT iSelectPage)
         : CPropertySheet(nIDCaption, pParentWnd, iSelectPage)
{
        PrivateConstruct();
}

CResizableSheet::CResizableSheet(LPCTSTR pszCaption, CWnd *pParentWnd, UINT iSelectPage)
         : CPropertySheet(pszCaption, pParentWnd, iSelectPage)
{
        PrivateConstruct();
}

CResizableSheet::~CResizableSheet()
{
}

BEGIN_MESSAGE_MAP(CResizableSheet, CPropertySheet)
        //{{AFX_MSG_MAP(CResizableSheet)
        ON_WM_GETMINMAXINFO()
        ON_WM_SIZE()
        ON_WM_DESTROY()
        ON_WM_CREATE()
        ON_WM_ERASEBKGND()
        //}}AFX_MSG_MAP
        ON_NOTIFY_REFLECT_EX(PSN_SETACTIVE, OnPageChanging)
END_MESSAGE_MAP()

// CResizableSheet message handlers

int CResizableSheet::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
        if (CPropertySheet::OnCreate(lpCreateStruct) == -1)
                return -1;
        
        // keep client area
        CRect rect;
        GetClientRect(&rect);
        // set resizable style
        ModifyStyle(DS_MODALFRAME, WS_POPUP | WS_THICKFRAME);
        // adjust size to reflect new style
        ::AdjustWindowRectEx(&rect, GetStyle(),
                ::IsMenu(GetMenu()->GetSafeHmenu()), GetExStyle());
        SetWindowPos(NULL, 0, 0, rect.Width(), rect.Height(), SWP_FRAMECHANGED|
                SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOREPOSITION);

        // create and init the size-grip
        if (!CreateSizeGrip())
                return -1;

        return 0;
}

BOOL CResizableSheet::OnInitDialog() 
{
        BOOL bResult = CPropertySheet::OnInitDialog();
        
        // set the initial size as the min track size
        CRect rc;
        GetWindowRect(&rc);
        SetMinTrackSize(rc.Size());

        // initialize layout
        PresetLayout();

        // prevent flickering
        GetTabControl()->ModifyStyle(0, WS_CLIPSIBLINGS);

        return bResult;
}

void CResizableSheet::OnDestroy() 
{
        if (m_bEnableSaveRestore)
        {
                SaveWindowRect(m_sSection, m_bRectOnly);
                SavePage();
        }

        RemoveAllAnchors();

        CPropertySheet::OnDestroy();
}

// maps an index to a button ID and vice-versa
static UINT _propButtons[] =
{
        IDOK, IDCANCEL, ID_APPLY_NOW, IDHELP,
        ID_WIZBACK, ID_WIZNEXT, ID_WIZFINISH
};
const int _propButtonsCount = sizeof(_propButtons)/sizeof(UINT);

// horizontal line in wizard mode
#define ID_WIZLINE      ID_WIZFINISH+1

void CResizableSheet::PresetLayout()
{
        if (IsWizard()) // wizard mode
        {
                // hide tab control
                GetTabControl()->ShowWindow(SW_HIDE);

                AddAnchor(ID_WIZLINE, BOTTOM_LEFT, BOTTOM_RIGHT);
        }
        else    // tab mode
        {
                AddAnchor(AFX_IDC_TAB_CONTROL, TOP_LEFT, BOTTOM_RIGHT);
        }

        // add a callback for active page (which can change at run-time)
        AddAnchorCallback(1);

        // use *total* parent size to have correct margins
        CRect rectPage, rectSheet;
        GetTotalClientRect(&rectSheet);

        GetActivePage()->GetWindowRect(&rectPage);
        ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectPage, 2);

        // pre-calculate margins
        m_sizePageTL = rectPage.TopLeft() - rectSheet.TopLeft();
        m_sizePageBR = rectPage.BottomRight() - rectSheet.BottomRight();

        // add all possible buttons, if they exist
        for (int i = 0; i < _propButtonsCount; i++)
        {
                if (NULL != GetDlgItem(_propButtons[i]))
                        AddAnchor(_propButtons[i], BOTTOM_RIGHT);
        }
}

BOOL CResizableSheet::ArrangeLayoutCallback(LayoutInfo &layout)
{
        if (layout.nCallbackID != 1)    // we only added 1 callback
                return CResizableLayout::ArrangeLayoutCallback(layout);

        // set layout info for active page
        layout.hWnd = (HWND)::SendMessage(m_hWnd, PSM_GETCURRENTPAGEHWND, 0, 0);
        if (!::IsWindow(layout.hWnd))
                return FALSE;

        // set margins
        if (IsWizard()) // wizard mode
        {
                // use pre-calculated margins
                layout.sizeMarginTL = m_sizePageTL;
                layout.sizeMarginBR = m_sizePageBR;
        }
        else    // tab mode
        {
                CTabCtrl* pTab = GetTabControl();
                ASSERT(pTab != NULL);

                // get tab position after resizing and calc page rect
                CRect rectPage, rectSheet;
                GetTotalClientRect(&rectSheet);

                VERIFY(GetAnchorPosition(pTab->m_hWnd, rectSheet, rectPage));
                pTab->AdjustRect(FALSE, &rectPage);

                // set margins
                layout.sizeMarginTL = rectPage.TopLeft() - rectSheet.TopLeft();
                layout.sizeMarginBR = rectPage.BottomRight() - rectSheet.BottomRight();
        }

        // set anchor types
        layout.sizeTypeTL = TOP_LEFT;
        layout.sizeTypeBR = BOTTOM_RIGHT;

        // use this layout info
        return TRUE;
}

void CResizableSheet::OnSize(UINT nType, int cx, int cy) 
{
        CWnd::OnSize(nType, cx, cy);
        
        if (nType == SIZE_MAXHIDE || nType == SIZE_MAXSHOW)
                return;         // arrangement not needed

        if (nType == SIZE_MAXIMIZED)
                HideSizeGrip(&m_dwGripTempState);
        else
                ShowSizeGrip(&m_dwGripTempState);

        // update grip and layout
        UpdateSizeGrip();
        ArrangeLayout();
}

BOOL CResizableSheet::OnPageChanging(NMHDR* /*pNotifyStruct*/, LRESULT* /*pResult*/)
{
        // update new wizard page
        // active page changes after this notification
        PostMessage(WM_SIZE);

        return FALSE;   // continue routing
}

BOOL CResizableSheet::OnEraseBkgnd(CDC* pDC) 
{
        // Windows XP doesn't like clipping regions ...try this!
        EraseBackground(pDC);
        return TRUE;

/*      ClipChildren(pDC);      // old-method (for safety)

        return CPropertySheet::OnEraseBkgnd(pDC);
*/
}

void CResizableSheet::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) 
{
        MinMaxInfo(lpMMI);
}

// protected members

int CResizableSheet::GetMinWidth()
{
        CWnd* pWnd = NULL;
        CRect rectWnd, rectSheet;
        GetTotalClientRect(&rectSheet);

        int max = 0, min = rectSheet.Width();
        // search for leftmost and rightmost button margins
        for (int i = 0; i < 7; i++)
        {
                pWnd = GetDlgItem(_propButtons[i]);
                // exclude not present or hidden buttons
                if (pWnd == NULL || !(pWnd->GetStyle() & WS_VISIBLE))
                        continue;

                // left position is relative to the right border
                // of the parent window (negative value)
                pWnd->GetWindowRect(&rectWnd);
                ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectWnd, 2);
                int left = rectSheet.right - rectWnd.left;
                int right = rectSheet.right - rectWnd.right;

                if (left > max)
                        max = left;
                if (right < min)
                        min = right;
        }

        // sizing border width
        int border = GetSystemMetrics(SM_CXSIZEFRAME);
        
        // compute total width
        return max + min + 2*border;
}


// NOTE: this must be called after all the other settings
//       to have the window and its controls displayed properly
void CResizableSheet::EnableSaveRestore(LPCTSTR pszSection, BOOL bRectOnly, BOOL bWithPage)
{
        m_sSection = pszSection;
        m_bSavePage = bWithPage;

        m_bEnableSaveRestore = TRUE;
        m_bRectOnly = bRectOnly;

        // restore immediately
        LoadWindowRect(pszSection, bRectOnly);
        LoadPage();
}

// private memebers

// used to save/restore active page
// either in the registry or a private .INI file
// depending on your application settings

#define ACTIVEPAGE      _T("ActivePage")

void CResizableSheet::SavePage()
{
        if (!m_bSavePage)
                return;

        // saves active page index, zero (the first) if problems
        // cannot use GetActivePage, because it always fails

        CTabCtrl *pTab = GetTabControl();
        int page = 0;

        if (pTab != NULL) 
                page = pTab->GetCurSel();
        if (page < 0)
                page = 0;

        AfxGetApp()->WriteProfileInt(m_sSection, ACTIVEPAGE, page);
}

void CResizableSheet::LoadPage()
{
        // restore active page, zero (the first) if not found
        int page = AfxGetApp()->GetProfileInt(m_sSection, ACTIVEPAGE, 0);
        
        if (m_bSavePage)
        {
                SetActivePage(page);
                ArrangeLayout();        // needs refresh
        }
}

void CResizableSheet::RefreshLayout()
{
        SendMessage(WM_SIZE);
}

---