ext/ResizableLib/ResizableSheet.cpp

   1 // ResizableSheet.cpp : implementation file
   2 //
   3 /////////////////////////////////////////////////////////////////////////////
   4 //
   5 // This file is part of ResizableLib
   6 // http://sourceforge.net/projects/resizablelib
   7 //
   8 // Copyright (C) 2000-2004 by Paolo Messina
   9 // http://www.geocities.com/ppescher - mailto:ppescher@hotmail.com
  10 //
  11 // The contents of this file are subject to the Artistic License (the "License").
  12 // You may not use this file except in compliance with the License.
  13 // You may obtain a copy of the License at:
  14 // http://www.opensource.org/licenses/artistic-license.html
  15 //
  16 // If you find this code useful, credits would be nice!
  17 //
  18 /////////////////////////////////////////////////////////////////////////////
  19
  20 #include "stdafx.h"
  21 #include "ResizableSheet.h"
  22
  23 #ifdef _DEBUG
  24 #define new DEBUG_NEW
  25 #undef THIS_FILE
  26 static char THIS_FILE[] = __FILE__;
  27 #endif
  28
  29 /////////////////////////////////////////////////////////////////////////////
  30 // CResizableSheet
  31
  32 IMPLEMENT_DYNAMIC(CResizableSheet, CPropertySheet)
  33
  34 inline void CResizableSheet::PrivateConstruct()
  35 {
  36         m_bEnableSaveRestore = FALSE;
  37         m_bSavePage = FALSE;
  38         m_dwGripTempState = 1;
  39         m_bLayoutDone = FALSE;
  40         m_bRectOnly = FALSE;
  41         m_nCallbackID = 0;
  42 }
  43
  44 inline BOOL CResizableSheet::IsWizard() const
  45 {
  46         return (m_psh.dwFlags & PSH_WIZARD);
  47 }
  48
  49 CResizableSheet::CResizableSheet()
  50 {
  51         PrivateConstruct();
  52 }
  53
  54 CResizableSheet::CResizableSheet(UINT nIDCaption, CWnd *pParentWnd, UINT iSelectPage)
  55          : CPropertySheet(nIDCaption, pParentWnd, iSelectPage)
  56 {
  57         PrivateConstruct();
  58 }
  59
  60 CResizableSheet::CResizableSheet(LPCTSTR pszCaption, CWnd *pParentWnd, UINT iSelectPage)
  61          : CPropertySheet(pszCaption, pParentWnd, iSelectPage)
  62 {
  63         PrivateConstruct();
  64 }
  65
  66 CResizableSheet::~CResizableSheet()
  67 {
  68 }
  69
  70 BEGIN_MESSAGE_MAP(CResizableSheet, CPropertySheet)
  71         //{{AFX_MSG_MAP(CResizableSheet)
  72         ON_WM_GETMINMAXINFO()
  73         ON_WM_SIZE()
  74         ON_WM_DESTROY()
  75         ON_WM_ERASEBKGND()
  76         ON_WM_NCCREATE()
  77         //}}AFX_MSG_MAP
  78         ON_NOTIFY_REFLECT_EX(PSN_SETACTIVE, OnPageChanging)
  79 END_MESSAGE_MAP()
  80
  81 /////////////////////////////////////////////////////////////////////////////
  82 // CResizableSheet message handlers
  83
  84 BOOL CResizableSheet::OnNcCreate(LPCREATESTRUCT lpCreateStruct)
  85 {
  86         if (!CPropertySheet::OnNcCreate(lpCreateStruct))
  87                 return FALSE;
  88
  89         // child dialogs don't want resizable border or size grip,
  90         // nor they can handle the min/max size constraints
  91         BOOL bChild = lpCreateStruct->style & WS_CHILD;
  92
  93         // create and init the size-grip
  94         if (!CreateSizeGrip(!bChild))
  95                 return FALSE;
  96
  97         MakeResizable(lpCreateStruct);
  98
  99         return TRUE;
 100 }
 101
 102 BOOL CResizableSheet::OnInitDialog()
 103 {
 104         BOOL bResult = CPropertySheet::OnInitDialog();
 105
 106         // set the initial size as the min track size
 107         CRect rc;
 108         GetWindowRect(&rc);
 109         SetMinTrackSize(rc.Size());
 110
 111         // initialize layout
 112         PresetLayout();
 113         m_bLayoutDone = TRUE;
 114
 115         return bResult;
 116 }
 117
 118 void CResizableSheet::OnDestroy()
 119 {
 120         if (m_bEnableSaveRestore)
 121         {
 122                 SaveWindowRect(m_sSection, m_bRectOnly);
 123                 if (m_bSavePage)
 124                         SavePage(m_sSection);
 125         }
 126
 127         RemoveAllAnchors();
 128
 129         CPropertySheet::OnDestroy();
 130 }
 131
 132 // maps an index to a button ID and vice-versa
 133 static UINT _propButtons[] =
 134 {
 135         IDOK, IDCANCEL, ID_APPLY_NOW, IDHELP,
 136         ID_WIZBACK, ID_WIZNEXT, ID_WIZFINISH
 137 };
 138 const int _propButtonsCount = sizeof(_propButtons)/sizeof(UINT);
 139
 140 // horizontal line in wizard mode
 141 #define ID_WIZLINE      ID_WIZFINISH+1
 142
 143 void CResizableSheet::PresetLayout()
 144 {
 145         // set the initial size as the min track size
 146         CRect rc;
 147         GetWindowRect(&rc);
 148         SetMinTrackSize(rc.Size());
 149
 150         if (GetStyle() & WS_CHILD)
 151         {
 152                 GetClientRect(&rc);
 153                 GetTabControl()->MoveWindow(&rc);
 154         }
 155
 156         if (IsWizard()) // wizard mode
 157         {
 158                 // hide tab control
 159                 GetTabControl()->ShowWindow(SW_HIDE);
 160
 161                 AddAnchor(ID_WIZLINE, BOTTOM_LEFT, BOTTOM_RIGHT);
 162         }
 163         else    // tab mode
 164         {
 165                 AddAnchor(AFX_IDC_TAB_CONTROL, TOP_LEFT, BOTTOM_RIGHT);
 166         }
 167
 168         // add a callback for active page (which can change at run-time)
 169         m_nCallbackID = AddAnchorCallback();
 170
 171         // use *total* parent size to have correct margins
 172         CRect rectPage, rectSheet;
 173         GetTotalClientRect(&rectSheet);
 174
 175         GetActivePage()->GetWindowRect(&rectPage);
 176         ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectPage, 2);
 177
 178         // pre-calculate margins
 179         m_sizePageTL = rectPage.TopLeft() - rectSheet.TopLeft();
 180         m_sizePageBR = rectPage.BottomRight() - rectSheet.BottomRight();
 181
 182         // add all possible buttons, if they exist
 183         for (int i = 0; i < _propButtonsCount; i++)
 184         {
 185                 if (NULL != GetDlgItem(_propButtons[i]))
 186                         AddAnchor(_propButtons[i], BOTTOM_RIGHT);
 187         }
 188
 189         // prevent flickering
 190         GetTabControl()->ModifyStyle(0, WS_CLIPSIBLINGS);
 191 }
 192
 193 BOOL CResizableSheet::ArrangeLayoutCallback(LAYOUTINFO &layout) const
 194 {
 195         if (layout.nCallbackID != m_nCallbackID)        // we only added 1 callback
 196                 return CResizableLayout::ArrangeLayoutCallback(layout);
 197
 198         // set layout info for active page
 199         layout.hWnd = (HWND)::SendMessage(m_hWnd, PSM_GETCURRENTPAGEHWND, 0, 0);
 200         if (!::IsWindow(layout.hWnd))
 201                 return FALSE;
 202
 203         // set margins
 204         if (IsWizard()) // wizard mode
 205         {
 206                 // use pre-calculated margins
 207                 layout.marginTopLeft = m_sizePageTL;
 208                 layout.marginBottomRight = m_sizePageBR;
 209         }
 210         else    // tab mode
 211         {
 212                 CTabCtrl* pTab = GetTabControl();
 213                 ASSERT(pTab != NULL);
 214
 215                 // get tab position after resizing and calc page rect
 216                 CRect rectPage, rectSheet;
 217                 GetTotalClientRect(&rectSheet);
 218
 219                 if (!GetAnchorPosition(pTab->m_hWnd, rectSheet, rectPage))
 220                         return FALSE; // no page yet
 221
 222                 // temporarily resize the tab control to calc page size
 223                 CRect rectSave;
 224                 pTab->GetWindowRect(rectSave);
 225                 ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectSave, 2);
 226                 pTab->SetRedraw(FALSE);
 227                 pTab->MoveWindow(rectPage, FALSE);
 228                 pTab->AdjustRect(FALSE, &rectPage);
 229                 pTab->MoveWindow(rectSave, FALSE);
 230                 pTab->SetRedraw(TRUE);
 231
 232                 // set margins
 233                 layout.marginTopLeft = rectPage.TopLeft() - rectSheet.TopLeft();
 234                 layout.marginBottomRight = rectPage.BottomRight() - rectSheet.BottomRight();
 235         }
 236
 237         // set anchor types
 238         layout.anchorTopLeft = TOP_LEFT;
 239         layout.anchorBottomRight = BOTTOM_RIGHT;
 240
 241         // use this layout info
 242         return TRUE;
 243 }
 244
 245 void CResizableSheet::OnSize(UINT nType, int cx, int cy)
 246 {
 247         CWnd::OnSize(nType, cx, cy);
 248
 249         if (nType == SIZE_MAXHIDE || nType == SIZE_MAXSHOW)
 250                 return;         // arrangement not needed
 251
 252         if (nType == SIZE_MAXIMIZED)
 253                 HideSizeGrip(&m_dwGripTempState);
 254         else
 255                 ShowSizeGrip(&m_dwGripTempState);
 256
 257         // update grip and layout
 258         UpdateSizeGrip();
 259         ArrangeLayout();
 260 }
 261
 262 BOOL CResizableSheet::OnPageChanging(NMHDR* /*pNotifyStruct*/, LRESULT* /*pResult*/)
 263 {
 264         // update new wizard page
 265         // active page changes after this notification
 266         PostMessage(WM_SIZE);
 267
 268         return FALSE;   // continue routing
 269 }
 270
 271 BOOL CResizableSheet::OnEraseBkgnd(CDC* pDC)
 272 {
 273         ClipChildren(pDC, FALSE);
 274
 275         BOOL bRet = CPropertySheet::OnEraseBkgnd(pDC);
 276
 277         ClipChildren(pDC, TRUE);
 278
 279         return bRet;
 280 }
 281
 282 BOOL CResizableSheet::CalcSizeExtra(HWND /*hWndChild*/, CSize sizeChild, CSize &sizeExtra)
 283 {
 284         CTabCtrl* pTab = GetTabControl();
 285         if (!pTab)
 286                 return FALSE;
 287
 288         // get margins of tabcontrol
 289         CRect rectMargins;
 290         if (!GetAnchorMargins(pTab->m_hWnd, sizeChild, rectMargins))
 291                 return FALSE;
 292
 293         // get margin caused by tabcontrol
 294         CRect rectTabMargins(0,0,0,0);
 295
 296         // get tab position after resizing and calc page rect
 297         CRect rectPage, rectSheet;
 298         GetTotalClientRect(&rectSheet);
 299
 300         if (!GetAnchorPosition(pTab->m_hWnd, rectSheet, rectPage))
 301                 return FALSE; // no page yet
 302
 303         // temporarily resize the tab control to calc page size
 304         CRect rectSave;
 305         pTab->GetWindowRect(rectSave);
 306         ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectSave, 2);
 307         pTab->SetRedraw(FALSE);
 308         pTab->MoveWindow(rectPage, FALSE);
 309         pTab->AdjustRect(TRUE, &rectTabMargins);
 310         pTab->MoveWindow(rectSave, FALSE);
 311         pTab->SetRedraw(TRUE);
 312
 313         // add non-client size
 314         ::AdjustWindowRectEx(&rectTabMargins, GetStyle(), !(GetStyle() & WS_CHILD) &&
 315                 ::IsMenu(GetMenu()->GetSafeHmenu()), GetExStyle());
 316
 317         // compute extra size
 318         sizeExtra = rectMargins.TopLeft() + rectMargins.BottomRight() +
 319                 rectTabMargins.Size();
 320         return TRUE;
 321 }
 322
 323 void CResizableSheet::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
 324 {
 325         MinMaxInfo(lpMMI);
 326
 327         CTabCtrl* pTab = GetTabControl();
 328         if (!pTab)
 329                 return;
 330
 331         int nCount = GetPageCount();
 332         for (int idx = 0; idx < nCount; ++idx)
 333         {
 334                 if (IsWizard()) // wizard mode
 335                 {
 336                         // use pre-calculated margins
 337                         CRect rectExtra(-CPoint(m_sizePageTL), -CPoint(m_sizePageBR));
 338                         // add non-client size
 339                         ::AdjustWindowRectEx(&rectExtra, GetStyle(), !(GetStyle() & WS_CHILD) &&
 340                                 ::IsMenu(GetMenu()->GetSafeHmenu()), GetExStyle());
 341                         ChainMinMaxInfo(lpMMI, *GetPage(idx), rectExtra.Size());
 342                 }
 343                 else    // tab mode
 344                 {
 345                         ChainMinMaxInfoCB(lpMMI, *GetPage(idx));
 346                 }
 347         }
 348 }
 349
 350 // protected members
 351
 352 int CResizableSheet::GetMinWidth()
 353 {
 354         CWnd* pWnd = NULL;
 355         CRect rectWnd, rectSheet;
 356         GetTotalClientRect(&rectSheet);
 357
 358         int max = 0, min = rectSheet.Width();
 359         // search for leftmost and rightmost button margins
 360         for (int i = 0; i < 7; i++)
 361         {
 362                 pWnd = GetDlgItem(_propButtons[i]);
 363                 // exclude not present or hidden buttons
 364                 if (pWnd == NULL || !(pWnd->GetStyle() & WS_VISIBLE))
 365                         continue;
 366
 367                 // left position is relative to the right border
 368                 // of the parent window (negative value)
 369                 pWnd->GetWindowRect(&rectWnd);
 370                 ::MapWindowPoints(NULL, m_hWnd, (LPPOINT)&rectWnd, 2);
 371                 int left = rectSheet.right - rectWnd.left;
 372                 int right = rectSheet.right - rectWnd.right;
 373
 374                 if (left > max)
 375                         max = left;
 376                 if (right < min)
 377                         min = right;
 378         }
 379
 380         // sizing border width
 381         int border = GetSystemMetrics(SM_CXSIZEFRAME);
 382
 383         // compute total width
 384         return max + min + 2*border;
 385 }
 386
 387
 388 // NOTE: this must be called after all the other settings
 389 //       to have the window and its controls displayed properly
 390 void CResizableSheet::EnableSaveRestore(LPCTSTR pszSection, BOOL bRectOnly, BOOL bWithPage)
 391 {
 392         m_sSection = pszSection;
 393         m_bSavePage = bWithPage;
 394
 395         m_bEnableSaveRestore = TRUE;
 396         m_bRectOnly = bRectOnly;
 397
 398         // restore immediately
 399         LoadWindowRect(pszSection, bRectOnly);
 400         {
 401                 LoadPage(pszSection);
 402                 ArrangeLayout();        // needs refresh
 403         }
 404 }
 405
 406 void CResizableSheet::RefreshLayout()
 407 {
 408         SendMessage(WM_SIZE);
 409 }
 410
 411 LRESULT CResizableSheet::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
 412 {
 413         if (message != WM_NCCALCSIZE || wParam == 0 || !m_bLayoutDone)
 414                 return CPropertySheet::WindowProc(message, wParam, lParam);
 415
 416         // specifying valid rects needs controls already anchored
 417         LRESULT lResult = 0;
 418         HandleNcCalcSize(FALSE, (LPNCCALCSIZE_PARAMS)lParam, lResult);
 419         lResult = CPropertySheet::WindowProc(message, wParam, lParam);
 420         HandleNcCalcSize(TRUE, (LPNCCALCSIZE_PARAMS)lParam, lResult);
 421         return lResult;
 422 }