开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtResizableDialog.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：54k
源码类别：

界面编程

开发平台：

Visual C++

ExtResizableDialog.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "stdafx.h"
  24. #if (!defined __EXT_RESIZABLE_DIALOG_H)
  25. #include <ExtResizableDialog.h>
  26. #endif
  28. #if (!defined __EXT_CONTROLBAR_H)
  29. #include <ExtControlBar.h>
  30. #endif
  32. #if (!defined __ExtCmdManager_H)
  33. #include <ExtCmdManager.h>
  34. #endif
  36. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  37. #if (!defined __EXT_CONTROLBAR_TABBED_FEATURES_H)
  38. #include "ExtControlBarTabbedFeatures.h"
  39. #endif // __EXT_CONTROLBAR_TABBED_FEATURES_H
  40. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  42. #if (!defined __EXT_MFC_NO_TAB_PAGECONTAINER_CTRL)
  43. #if (! defined __EXT_TAB_PAGE_CONTAINER_WND_H)
  44. #include <ExtTabPageContainerWnd.h>
  45. #endif
  46. #endif // (!defined __EXT_MFC_NO_TAB_PAGECONTAINER_CTRL)
  48. #if (!defined __EXT_SCROLLWND_H)
  49. #include <ExtScrollWnd.h>
  50. #endif 
  52. #if (!defined __EXT_MFC_NO_TAB_CTRL)
  53. #if (!defined __EXT_TABWND_H)
  54. #include <ExtTabWnd.h>
  55. #endif
  56. #endif // (!defined __EXT_MFC_NO_TAB_CTRL)
  58. #ifdef _DEBUG
  59. #define new DEBUG_NEW
  60. #undef THIS_FILE
  61. static char THIS_FILE[] = __FILE__;
  62. #endif
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CExtResizableDialog
  67. IMPLEMENT_DYNCREATE( CExtResizableDialog, CExtResDlg )
  69. bool CExtResizableDialog::g_bAllowLongFocusJumpFix = true;
  71. CExtResizableDialog::CExtResizableDialog()
  72. : m_bEnabledControlBarUpdate( false )
  73. , m_bInConrolBarUpdate( false )
  74. , m_hWndFocus( NULL )
  75. , m_bHelperSizingMoving( false )
  76. , m_bAllowLongFocusJumpFix( g_bAllowLongFocusJumpFix )
  77. {
  78. m_bShowResizingGripper = true;
  79. }
  81. CExtResizableDialog::CExtResizableDialog(
  82. UINT nIDTemplate,
  83. CWnd * pParentWnd
  84. )
  85. : CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > > ( nIDTemplate, pParentWnd )
  86. , m_bEnabledControlBarUpdate( false )
  87. , m_bInConrolBarUpdate( false )
  88. , m_hWndFocus( NULL )
  89. , m_bHelperSizingMoving( false )
  90. , m_bAllowLongFocusJumpFix( g_bAllowLongFocusJumpFix )
  91. {
  92. m_bShowResizingGripper = true;
  93. }
  95. CExtResizableDialog::CExtResizableDialog(
  96. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  97. CWnd * pParentWnd
  98. )
  99. : CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > > ( lpszTemplateName, pParentWnd )
  100. , m_bEnabledControlBarUpdate( false )
  101. , m_bInConrolBarUpdate( false )
  102. , m_hWndFocus( NULL )
  103. , m_bHelperSizingMoving( false )
  104. , m_bAllowLongFocusJumpFix( g_bAllowLongFocusJumpFix )
  105. {
  106. m_bShowResizingGripper = true;
  107. }
  109. CExtResizableDialog::~CExtResizableDialog()
  110. {
  111. }
  113. bool CExtResizableDialog::_SaveFocusControl()
  114. {
  115. if( GetSafeHwnd() == NULL )
  116. return false;
  117. HWND hWndFocus = ::GetFocus();
  118. if( hWndFocus != NULL
  119. && ::IsChild( m_hWnd, hWndFocus )
  120. )
  121. {
  122. m_hWndFocus = hWndFocus;
  123. return true;
  124. }
  125. return false;
  126. }
  128. __EXT_MFC_SAFE_LPCTSTR CExtResizableDialog::OnQuerySkinnedFontParmName() const
  129. {
  130. ASSERT_VALID( this );
  131. return _T("Dialog");
  132. }
  134. BEGIN_MESSAGE_MAP( CExtResizableDialog, CExtResDlg )
  135. //{{AFX_MSG_MAP(CExtResizableDialog)
  136. //}}AFX_MSG_MAP
  137. END_MESSAGE_MAP()
  139. /////////////////////////////////////////////////////////////////////////////
  140. // CExtResizableDialog message handlers
  142. void CExtResizableDialog::OnOK()
  143. {
  144. DWORD dwStyle = GetStyle();
  145. if( (dwStyle & WS_CHILD) == 0 )
  146. CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::OnOK();
  147. }
  149. void CExtResizableDialog::OnCancel()
  150. {
  151. DWORD dwStyle = GetStyle();
  152. if( (dwStyle & WS_CHILD) == 0 )
  153. CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::OnCancel();
  154. }
  156. bool CExtResizableDialog::g_bProcessingLongFocusJump = false;
  157. bool CExtResizableDialog::g_bProcessingLongFocusJumpToPrevDir = false;
  159. HWND CExtResizableDialog::stat_GetNextItemZ( HWND hWndMain, HWND hWndDialog, HWND hWndControl, BOOL bPrevious )
  160. {
  161. LONG nStyle, nStyleEx;
  162. UINT nSearchCode = bPrevious ? GW_HWNDPREV : GW_HWNDNEXT;
  163. HWND hWndRetVal = NULL, hWndFirstChild = NULL;
  164. if( hWndControl == NULL )
  165. {
  166. hWndFirstChild = ::GetWindow( hWndDialog, GW_CHILD );
  167. if( bPrevious )
  168. hWndFirstChild = ::GetWindow( hWndFirstChild, GW_HWNDLAST );
  169. }
  170. else if( ::IsChild( hWndMain, hWndControl ) )
  171. {
  172. hWndFirstChild = ::GetWindow( hWndControl, nSearchCode );
  173. if( hWndFirstChild == NULL )
  174. {
  175. if( ::GetParent( hWndControl ) != hWndMain )
  176. hWndFirstChild = ::GetWindow( ::GetParent( hWndControl ), nSearchCode );
  177. else
  178. {
  179. if( bPrevious )
  180. hWndFirstChild = ::GetWindow( hWndControl, GW_HWNDLAST );
  181. else
  182. hWndFirstChild = ::GetWindow( hWndControl, GW_HWNDFIRST );
  183. }
  184. }
  185. }
  186. for( ; hWndFirstChild != NULL ; )
  187. {
  188. BOOL bCtrl = FALSE;
  189. for( ; hWndFirstChild != NULL;  )
  190. {
  191. nStyle = (LONG)__EXT_MFC_GetWindowLong( hWndFirstChild, GWL_STYLE );
  192. nStyleEx = (LONG)__EXT_MFC_GetWindowLong( hWndFirstChild, GWL_EXSTYLE );
  193. if( ( nStyle & DS_CONTROL || nStyleEx & WS_EX_CONTROLPARENT ) && ( nStyle & WS_VISIBLE ) && (!( nStyle & WS_DISABLED )) )
  194. {
  195. bCtrl = TRUE;
  196. break;
  197. }
  198. else if( ( nStyle & WS_TABSTOP ) && ( nStyle & WS_VISIBLE ) && (!( nStyle & WS_DISABLED )) )
  199. break;
  200. hWndFirstChild = ::GetWindow( hWndFirstChild, nSearchCode );
  201. }
  202. if( hWndFirstChild != NULL )
  203. {
  204. if( bCtrl )
  205. hWndRetVal = stat_GetNextItemZ( hWndMain, hWndFirstChild, NULL, bPrevious );
  206. else
  207. hWndRetVal = hWndFirstChild;
  208. }
  209. if( hWndRetVal )
  210. break;
  211. hWndFirstChild = ::GetWindow( hWndFirstChild, nSearchCode );
  212. }
  213. if( hWndRetVal == NULL && hWndControl )
  214. {
  215. HWND hWndParent = ::GetParent( hWndControl );
  216. for( ; hWndParent != NULL; )
  217. {
  218. if( hWndParent == hWndMain )
  219. break;
  220. hWndRetVal = stat_GetNextItemZ( hWndMain, ::GetParent( hWndParent ), hWndParent , bPrevious );
  221. if( hWndRetVal )
  222. break;
  223. hWndParent = ::GetParent( hWndParent );
  224. }
  225. if( hWndRetVal == NULL )
  226. hWndRetVal = stat_GetNextItemZ(hWndMain,hWndMain,NULL,bPrevious );
  227. }
  228. return hWndRetVal;
  229. }
  231. bool CExtResizableDialog::OnHookSpyPreTranslateMessage(
  232. MSG * pMSG
  233. )
  234. {
  235. __PROF_UIS_MANAGE_STATE;
  236. if( m_bHelperSizingMoving )
  237. return CExtHookSpy::OnHookSpyPreTranslateMessage( pMSG );
  239. if( pMSG->message == WM_ENTERSIZEMOVE )
  240. m_bHelperSizingMoving = true;
  241. else if( pMSG->message == WM_EXITSIZEMOVE )
  242. m_bHelperSizingMoving = false;
  244. // if( pMSG->message == WM_ACTIVATE && pMSG->wParam == WA_INACTIVE  )
  245. // _SaveFocusControl();
  246. if( pMSG->message == WM_KILLFOCUS )
  247. _SaveFocusControl();
  249. #if (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  250. if( pMSG->message == WM_SETFOCUS
  251. && GetSafeHwnd() != NULL
  252. && ( GetStyle() & (WS_DISABLED|WS_VISIBLE) ) == (WS_VISIBLE)
  253. )
  254. {
  255. HWND hWndFocus = ::GetFocus();
  256. if( hWndFocus != NULL )
  257. {
  258. HWND hWndParentOfFocus = ::GetParent( hWndFocus );
  259. if( hWndParentOfFocus != NULL )
  260. {
  261. CWnd * pWndFocusParent = CWnd::FromHandlePermanent( hWndParentOfFocus );
  262. if( pWndFocusParent != NULL && pWndFocusParent->IsKindOf( RUNTIME_CLASS(CExtResizableDialog) ) )
  263. {
  264. CWnd * pWndParent = pWndFocusParent->GetParent();
  265. if( pWndParent != NULL )
  266. {
  267. CExtScrollContainerWnd * pWndScrollContainer = DYNAMIC_DOWNCAST( CExtScrollContainerWnd, pWndParent );
  268. if( pWndScrollContainer != NULL )
  269. {
  270. CRect rcCheck, rcBounds = pWndScrollContainer->OnSwGetClientRect();
  271. //rcBounds.OffsetRect( pWndScrollContainer->OnSwGetScrollPos() );
  272. ::GetWindowRect( hWndFocus, &rcCheck );
  273. pWndScrollContainer->ScreenToClient( &rcCheck );
  274. rcCheck.InflateRect( ::GetSystemMetrics(SM_CXVSCROLL) + 2, ::GetSystemMetrics(SM_CYHSCROLL) + 2 );
  275. CPoint ptLT = rcCheck.TopLeft(), ptRB = rcCheck.BottomRight();
  276. if( ! ( rcBounds.PtInRect( ptLT ) && rcBounds.PtInRect( ptRB ) ) )
  277. {
  278. pWndScrollContainer->OnSwEnsurePointAvail( ptRB );
  279. pWndScrollContainer->OnSwEnsurePointAvail( ptLT );
  280. pWndScrollContainer->OnSwRecalcLayout( true );
  281. }
  282. }
  283. }
  284. }
  285. }
  286. }
  287. }
  288. #endif // (!defined __EXT_MFC_NO_SCROLLCONAINERWND)
  290. return CExtHookSpy::OnHookSpyPreTranslateMessage( pMSG );
  291. }
  293. bool CExtResizableDialog::OnHookSpyKeyMsg(
  294. MSG * pMSG
  295. )
  296. {
  297. __PROF_UIS_MANAGE_STATE;
  298. if( m_bHelperSizingMoving )
  299. return CExtHookSpy::OnHookSpyKeyMsg( pMSG );
  300. if( WM_KEYFIRST <= pMSG->message
  301. && pMSG->message <= WM_KEYLAST
  302. && ( pMSG->wParam == VK_UP
  303. || pMSG->wParam == VK_DOWN
  304. || pMSG->wParam == VK_LEFT
  305. || pMSG->wParam == VK_RIGHT
  306. || pMSG->wParam == VK_RETURN
  307. || pMSG->wParam == VK_ESCAPE
  308. || pMSG->wParam == VK_MENU
  309. || ( ( HIWORD(pMSG->lParam) & KF_ALTDOWN ) != 0 // CExtPopupMenuWnd::IsKeyPressed( VK_MENU )
  310. && ( ( VK_NUMPAD0 <= pMSG->wParam && pMSG->wParam <= VK_NUMPAD9 )
  311. || pMSG->wParam == VK_INSERT // 0
  312. || pMSG->wParam == VK_END    // 1
  313. || pMSG->wParam == VK_DOWN   // 2
  314. || pMSG->wParam == VK_NEXT   // 3
  315. || pMSG->wParam == VK_LEFT   // 4
  316. || pMSG->wParam == 0x0C      // 5, VK_CLEAR
  317. || pMSG->wParam == VK_RIGHT  // 8
  318. || pMSG->wParam == VK_HOME   // 7
  319. || pMSG->wParam == VK_UP     // 8
  320. || pMSG->wParam == VK_PRIOR  // 9
  321. )
  322. )
  323. )
  324. && ( GetStyle() & (WS_CHILD|WS_VISIBLE) ) == WS_VISIBLE
  325. && PreTranslateMessage( pMSG )
  326. )
  327. return true;
  328. return CExtHookSpy::OnHookSpyKeyMsg( pMSG );
  329. }
  331. LRESULT CExtResizableDialog::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  332. {
  333. if( message == WM_ENTERSIZEMOVE )
  334. m_bHelperSizingMoving = true;
  335. else if( message == WM_EXITSIZEMOVE )
  336. m_bHelperSizingMoving = false;
  337. else if( message == WM_SETFOCUS && GetSafeHwnd() != NULL)
  338. {
  339. if( m_bAllowLongFocusJumpFix
  340. && g_bProcessingLongFocusJump
  341. )
  342. {
  343. HWND hWnd = stat_GetNextItemZ( m_hWnd, m_hWnd, NULL, g_bProcessingLongFocusJumpToPrevDir ? TRUE : FALSE );
  344. if( hWnd != NULL )
  345. {
  346. //CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  347. ::SetFocus( hWnd );
  348. //pWnd;
  349. }
  350. return 0;
  351. }
  352. if( m_hWndFocus == NULL
  353. || ( ! ::IsWindow( m_hWndFocus ) )
  354. || ( ! ::IsChild( m_hWnd, m_hWndFocus ) )
  355. || ::GetFocus() == m_hWndFocus
  356. )
  357. m_hWndFocus = NULL;
  358. else
  359. {
  360. ::SetFocus( m_hWndFocus );
  361. m_hWndFocus = NULL;
  362. return 0;
  363. }
  364. }
  365. else if( message == WM_DESTROY )
  366. m_bEnabledControlBarUpdate = false;
  368. bool bUpdateBarsOnThisMsg = false;
  369. if( m_bEnabledControlBarUpdate )
  370. {
  371. CWinApp * pApp = AfxGetApp();
  372. ASSERT( pApp != NULL );
  373. BOOL bIdleMsg = pApp->IsIdleMessage(
  374. #if _MFC_VER < 0x700
  375. &pApp->m_msgCur
  376. #else
  377. &(::AfxGetThreadState()->m_msgCur)
  378. #endif
  379. );
  380. if( bIdleMsg )
  381. bUpdateBarsOnThisMsg = true;
  382. }
  384. HWND hWndThis = m_hWnd;
  385. LRESULT lResult =
  386. CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::WindowProc(message, wParam, lParam);
  388. if( hWndThis == NULL
  389. || ( ! ::IsWindow(hWndThis) )
  390. )
  391. bUpdateBarsOnThisMsg = false;
  393. if( bUpdateBarsOnThisMsg
  394. && ( ! m_bInConrolBarUpdate )
  395. )
  396. {
  397. m_bInConrolBarUpdate = true;
  398. CExtControlBar::DoCustomModeUpdateControlBars( this );
  399. m_bInConrolBarUpdate = false;
  400. }
  402. return lResult;
  403. }
  405. void CExtResizableDialog::PreSubclassWindow() 
  406. {
  407. m_bHelperSizingMoving = false;
  408. CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::PreSubclassWindow();
  409. HookSpyRegister( __EHSEF_MOUSE_ALL_WITHOUT_WHEEL|__EHSEF_WND_PROC_IN|__EHSEF_WND_PROC_IN|__EHSEF_PRE_TRANSLATION );
  410. m_bEnabledControlBarUpdate = true;
  411. EnableToolTips();
  412. }
  414. void CExtResizableDialog::PostNcDestroy()
  415. {
  416. m_bHelperSizingMoving = false;
  417. HookSpyUnregister();
  418. CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::PostNcDestroy();
  419. }
  421. BOOL CExtResizableDialog::PreTranslateMessage(MSG* pMsg) 
  422. {
  423. if( WM_KEYFIRST <= pMsg->message
  424. && pMsg->message <= WM_KEYLAST
  425. && GetSafeHwnd() != NULL
  426. && ( pMsg->hwnd == m_hWnd || ::IsChild( m_hWnd, pMsg->hwnd ) )
  427. && (GetStyle()&(WS_VISIBLE|WS_DISABLED)) == WS_VISIBLE
  428. )
  429. { // pre translating keyboard input (if enabled/visible dialog)
  430. if( pMsg->wParam == VK_TAB )
  431. {
  432. if( m_bAllowLongFocusJumpFix )
  433. {
  434. if( pMsg->message == WM_KEYDOWN )
  435. {
  436. HWND hWnd = ::GetFocus();
  437. if( hWnd != NULL )
  438. {
  439. bool bWantsTab = ( ( ::SendMessage( hWnd, WM_GETDLGCODE, VK_TAB, 0 ) & DLGC_WANTTAB ) != 0 ) ? true : false;
  440. if( bWantsTab )
  441. {
  442. CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  443. if( pWnd != NULL
  444. && ( pWnd->IsKindOf( RUNTIME_CLASS(CDialog) )
  445. #if (!defined __EXT_MFC_NO_TAB_PAGECONTAINER_CTRL)
  446. || pWnd->IsKindOf( RUNTIME_CLASS(CExtTabPageContainerWnd) )
  447. #endif // (!defined __EXT_MFC_NO_TAB_PAGECONTAINER_CTRL)
  448. )
  449. )
  450. bWantsTab = false;
  451. } // if( bWantsTab )
  452. if( ! bWantsTab )
  453. {
  454. HWND hWndMain = m_hWnd;
  455. if( ( __EXT_MFC_GetWindowLong( hWndMain, GWL_STYLE ) & WS_CHILD ) != 0 )
  456. hWndMain = ::GetParent( m_hWnd );
  457. for( ; ( __EXT_MFC_GetWindowLong( hWndMain, GWL_STYLE ) & WS_CHILD ) != 0 ; )
  458. hWndMain = ::GetParent( hWndMain );
  459. if( hWndMain != NULL )
  460. {
  461. BOOL bPrevious = CExtPopupMenuWnd::IsKeyPressed( VK_SHIFT );
  462. hWnd = stat_GetNextItemZ( hWndMain, m_hWnd, hWnd, bPrevious );
  463. //hWnd = ::GetNextDlgTabItem( m_hWnd, hWnd, CExtPopupMenuWnd::IsKeyPressed( VK_SHIFT ) );
  464. if( hWnd != NULL )
  465. {
  466. //CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  467. g_bProcessingLongFocusJump = true;
  468. g_bProcessingLongFocusJumpToPrevDir = bPrevious ? true : false;
  469. ::SetFocus( hWnd );
  470. if( ::SendMessage( hWnd, WM_GETDLGCODE, WPARAM(VK_TAB), LPARAM(pMsg) ) )
  471. ::SendMessage( hWnd, EM_SETSEL, WPARAM(0L), LPARAM(-1L) );
  472. g_bProcessingLongFocusJump = false;
  473. //pWnd;
  474. }
  475. }
  476. } // if( ! bWantsTab )
  477. else
  478. return FALSE;
  479. } // if( hWnd != NULL )
  480. } // if( pMsg->message == WM_KEYDOWN )
  481. return TRUE;
  482. } // if( m_bAllowLongFocusJumpFix )
  483. } // if( pMsg->wParam == VK_TAB )
  484. else
  485. {
  486. if( (GetStyle()&(WS_VISIBLE|WS_CHILD)) == (WS_VISIBLE|WS_CHILD) )
  487. { // if child/visible dialog
  488. HWND hWndParent = ::GetParent( m_hWnd );
  489. CWnd * pWndParentPermanent = CWnd::FromHandlePermanent( hWndParent );
  490. if( pWndParentPermanent != NULL
  491. && ( pWndParentPermanent->IsKindOf( RUNTIME_CLASS(CExtControlBar) )
  492. #if (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  493. || pWndParentPermanent->IsKindOf( RUNTIME_CLASS(CExtDynAutoHideSlider) )
  494. #endif // (!defined __EXT_MFC_NO_TAB_CONTROLBARS)
  495. )
  496. && pWndParentPermanent->PreTranslateMessage(pMsg)
  497. )
  498. return TRUE;
  499. } // if child/visible dialog
  500. } // else from if( pMsg->wParam == VK_TAB )
  502. HWND hWndFocus = ::GetFocus();
  503. if( hWndFocus != NULL
  504. && ::GetParent( hWndFocus ) == m_hWnd
  505. //&& ( ::SendMessage( hWndFocus, WM_GETDLGCODE, 0L, 0L ) & (DLGC_WANTCHARS|DLGC_WANTALLKEYS) == 0 )
  506. )
  507. {
  508. bool bProcessKey = false;
  509. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN;
  510. LRESULT lRDC = ::SendMessage( hWndFocus, WM_GETDLGCODE, pMsg->wParam, 0L );
  511. if( ( lRDC & DLGC_WANTALLKEYS ) == 0
  512. && ( ( lRDC & DLGC_WANTCHARS ) == 0
  513. || bAlt
  514. )
  515. )
  516. {
  517. bProcessKey = true;
  518. }
  519. if( bProcessKey )
  520. {
  521. //BOOL bKeyUp = ( pMsg->message == WM_KEYUP || pMsg->message == WM_SYSKEYUP) ? TRUE : FALSE;
  522. BOOL bCtrl = GetKeyState(VK_CONTROL) & 0x80000000;
  523. BOOL bShift = GetKeyState(VK_SHIFT) & 0x80000000;
  524. if( ! ( bCtrl || bShift ) )
  525. {
  526. TCHAR vkTCHAR = (TCHAR)pMsg->wParam;
  527. BYTE lpKeyState[256];
  528. ::GetKeyboardState( lpKeyState );
  529. UINT wScanCode = ::MapVirtualKey( vkTCHAR, 0 );
  530. HKL hKeyboardLayout =
  531. ::GetKeyboardLayout(
  532. ( ::AfxGetThread() ) -> m_nThreadID
  533. );
  534. #if (defined _UNICODE)
  535. TCHAR szChar[2] = { _T(''), _T('') };
  536. ::ToUnicodeEx(
  537. vkTCHAR,
  538. wScanCode,
  539. lpKeyState,
  540. szChar, 1,
  541. 1,
  542. hKeyboardLayout
  543. );
  544. #else
  545. WORD nMapped = 0;
  546. ::ToAsciiEx(
  547. vkTCHAR,
  548. wScanCode,
  549. lpKeyState,
  550. &nMapped,
  551. 1,
  552. hKeyboardLayout
  553. );
  554. TCHAR szChar[2] = { (TCHAR)nMapped, _T('') };
  555. #endif
  556. ::CharUpper( szChar );
  557. if( szChar[0] != 0 )
  558. {
  559. HWND hWnd = ::GetWindow( m_hWnd, GW_CHILD );
  560. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  561. {
  562. CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  563. if( pWnd == NULL )
  564. continue;
  565. if( (pWnd->GetStyle()&(WS_VISIBLE|WS_DISABLED)) != WS_VISIBLE )
  566. continue;
  567. CExtButton * pExtButton = DYNAMIC_DOWNCAST( CExtButton, pWnd );
  568. if( pExtButton == NULL )
  569. continue;
  570. if( pExtButton->m_bQuickActivationEnabled
  571. && pExtButton->_QuickActivationCheck( DWORD(vkTCHAR) )
  572. )
  573. {
  574. if( pMsg->message == WM_KEYDOWN
  575. || pMsg->message == WM_SYSKEYDOWN
  576. )
  577. {
  578. if( hWndFocus != pExtButton->m_hWnd )
  579. pExtButton->SetFocus();
  580. }
  581. if( pMsg->message == WM_KEYUP
  582. || pMsg->message == WM_SYSKEYUP
  583. )
  584. {
  585. if( pExtButton->PreTranslateMessage( pMsg ) )
  586. return TRUE;
  587. }
  588. //break;
  589. return TRUE;
  590. }
  591. }
  592. }
  593. } // if( ! ( bCtrl || bShift ) )
  594. } // if( bProcessKey )
  595. } // if( hWndFocus != NULL && ::GetParent( hWndFocus ) == m_hWnd ...
  596. } // pre translating keyboard input (if enabled/visible dialog)
  598. if( ( GetStyle() & WS_VISIBLE ) != 0
  599. && CExtControlBar::DoCustomModePreTranslateMessage( this, pMsg )
  600. )
  601. return TRUE;
  603. if( pMsg->message == WM_LBUTTONDOWN )
  604. return FALSE;
  606. return CExtWA < CExtWS < __BASEOF_CExtResizableDialog__ > >::PreTranslateMessage(pMsg);
  607. }
  609. //////////////////////////////////////////////////////////////////////////
  610. // CExtResizablePropertyPage
  612. IMPLEMENT_DYNCREATE( CExtResizablePropertyPage, CExtResPP )
  614. CExtResizablePropertyPage::CExtResizablePropertyPage()
  615. : m_bEnabledControlBarUpdate( false )
  616. , m_bInConrolBarUpdate( false )
  617. {
  618. m_bShowResizingGripper = false;
  619. }
  621. CExtResizablePropertyPage::CExtResizablePropertyPage(
  622. UINT nIDTemplate,
  623. UINT nIDCaption // = 0 
  624. )
  625. : CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > > ( nIDTemplate, nIDCaption )
  626. , m_bEnabledControlBarUpdate( false )
  627. , m_bInConrolBarUpdate( false )
  628. {
  629. m_bShowResizingGripper = false;
  630. }
  632. CExtResizablePropertyPage::CExtResizablePropertyPage(
  633. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  634. UINT nIDCaption // = 0 
  635. )
  636. : CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > > ( lpszTemplateName, nIDCaption )
  637. , m_bEnabledControlBarUpdate( false )
  638. , m_bInConrolBarUpdate( false )
  639. {
  640. m_bShowResizingGripper = false;
  641. }
  643. CExtResizablePropertyPage::~CExtResizablePropertyPage()
  644. {
  645. }
  647. __EXT_MFC_SAFE_LPCTSTR CExtResizablePropertyPage::OnQuerySkinnedFontParmName() const
  648. {
  649. ASSERT_VALID( this );
  650. return _T("Dialog");
  651. }
  653. BEGIN_MESSAGE_MAP( CExtResizablePropertyPage, CExtResPP )
  654. //{{AFX_MSG_MAP(CExtResizablePropertyPage)
  655. //}}AFX_MSG_MAP
  656. END_MESSAGE_MAP()
  658. /////////////////////////////////////////////////////////////////////////////
  659. // CExtResizablePropertyPage message handlers
  661. void CExtResizablePropertyPage::OnOK()
  662. {
  663. DWORD dwStyle = GetStyle();
  664. if( (dwStyle & WS_CHILD) == 0 )
  665. CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > >::OnOK();
  666. }
  668. void CExtResizablePropertyPage::OnCancel()
  669. {
  670. DWORD dwStyle = GetStyle();
  671. if( (dwStyle & WS_CHILD) == 0 )
  672. CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > >::OnCancel();
  673. }
  675. bool CExtResizablePropertyPage::OnHookWndMsg(
  676. LRESULT & lResult,
  677. HWND hWndHooked,
  678. UINT nMessage,
  679. WPARAM & wParam,
  680. LPARAM & lParam
  681. )
  682. {
  683. __PROF_UIS_MANAGE_STATE;
  684. if( GetSafeHwnd() != NULL
  685. && hWndHooked == m_hWnd
  686. )
  687. {
  688. //if( (m_psh.dwFlags&(__EXT_MFC_PSH_WIZARD97_MASK)) != 0 )
  689. {
  690. switch( nMessage )
  691. {
  692. case WM_ERASEBKGND:
  693. {
  694. ASSERT_VALID( this );
  696. // look through the message map to see 
  697. // if this message is handled by user
  698. const AFX_MSGMAP_ENTRY * lpEntry = 
  699. _FindMessageMapHandler(
  700. nMessage,
  701. 0, 0
  702. );
  703. if( lpEntry != NULL )
  704. {
  705. // invoke the user defined message handler
  706. union 
  707. {
  708. AFX_PMSG pfn;
  709. BOOL (AFX_MSG_CALL CWnd::*pfn_bD)( CDC* );
  710. } mmf;
  711. mmf.pfn = lpEntry->pfn;
  712. LRESULT lResult = 
  713. (this->*mmf.pfn_bD)( CDC::FromHandle( ( HDC ) wParam ) );
  714. return lResult > 0L ? true : false;
  715. } // if( lpEntry != NULL )
  717. HDC hDC = reinterpret_cast < HDC > (wParam);
  718. ASSERT( hDC != NULL );
  719. HWND hWnd = ::WindowFromDC( hDC );
  720. if( hWnd != NULL
  721. && hWnd != m_hWnd
  722. )
  723. return 
  724. CExtHookSink::OnHookWndMsg(
  725. lResult,
  726. hWndHooked,
  727. nMessage,
  728. wParam,
  729. lParam
  730. );
  732. if( (GetStyle() & WS_CLIPCHILDREN) != 0
  733. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  734. )
  735. return (!0L);
  737. CExtPaintManager::stat_ExcludeChildAreas(
  738. hDC,
  739. GetSafeHwnd(),
  740. CExtPaintManager::stat_DefExcludeChildAreaCallback
  741. );
  743. return (!0L);
  745. } // case WM_ERASEBKGND
  747. case WM_PAINT:
  748. {
  749. ASSERT_VALID( this );
  751. bool bDlg = IsKindOf(RUNTIME_CLASS(CDialog)) ? true : false;
  752. if( !bDlg )
  753. {
  754. TCHAR strClassName[ _MAX_PATH + 1 ] = _T("");
  755. ::GetClassName( m_hWnd, strClassName, _MAX_PATH );
  756. __EXT_MFC_STRLWR( strClassName, _MAX_PATH + 1 );
  757. if( _tcsstr( strClassName, _T("#") ) != NULL )
  758. bDlg = true;
  759. }
  761. // look through the message map to see 
  762. // if this message is handled by user
  763. const AFX_MSGMAP_ENTRY * lpEntry = 
  764. _FindMessageMapHandler(
  765. nMessage,
  766. 0, 0
  767. );
  769. bool bPainted = false;
  770. if( !bDlg ) 
  771. {
  772. if( lpEntry != NULL )
  773. {
  774. // invoke the user defined message handler
  775. union 
  776. {
  777. AFX_PMSG pfn;
  778. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  779. } mmf;
  780. mmf.pfn = lpEntry->pfn;
  781. (this->*mmf.pfn_COMMAND)();
  782. // return 0L;
  783. bPainted = true;
  784. } // if( lpEntry != NULL )
  785. }
  787. if( !bPainted )
  788. {
  789. CPaintDC dc( this );
  790. COLORREF clrBackground = GetBkColor();
  791. bool bTransparent = false;
  792. if( PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  793. && ( clrBackground == COLORREF(-1L) )
  794. )
  795. {
  796. CExtPaintManager::stat_ExcludeChildAreas(
  797. dc,
  798. GetSafeHwnd(),
  799. CExtPaintManager::stat_DefExcludeChildAreaCallback
  800. );
  801. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  802. bTransparent = true;
  803. }
  804. if( ! bTransparent )
  805. {
  806. CRect rcClient;
  807. GetClientRect( &rcClient );
  808. dc.FillSolidRect(
  809. &rcClient,
  810. clrBackground != COLORREF(-1L)
  811. ? clrBackground
  812. : PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this )
  813. );
  814. }
  816. #if _MFC_VER >= 0x700
  817. if( (m_psp.dwFlags&PSP_HIDEHEADER) != 0 )
  818. {
  819. CWnd * pWnd = GetParent();
  820. ASSERT_VALID( pWnd );
  821. ASSERT( pWnd->GetSafeHwnd() != NULL );
  822. CExtResizablePropertySheet * pRPS =
  823. DYNAMIC_DOWNCAST( CExtResizablePropertySheet, pWnd );
  824. if( pRPS != NULL
  825. && (pRPS->m_psh.dwFlags&PSH_HEADER) != 0
  826. && pRPS->m_psh.pszbmWatermark != NULL
  827. )
  828. {
  829. CExtBitmap _bmp;
  830. if( g_ResourceManager->LoadBitmap(
  831. _bmp,
  832. pRPS->m_psh.pszbmWatermark
  833. )
  834. )
  835. {
  836. CSize _size = _bmp.GetSize();
  837.   CRect rcDraw( 0, 0, _size.cx, _size.cy );
  838. _bmp.Draw( dc.m_hDC, rcDraw );
  839. }
  840. }
  841. } // if( (m_psp.dwFlags&PSP_HIDEHEADER) != 0 )
  842. #endif // #if _MFC_VER >= 0x700
  844. PmBridge_GetPM()->OnPaintSessionComplete( this );
  845. }
  847. if( bDlg ) 
  848. {
  849. if( lpEntry != NULL )
  850. {
  851. // invoke the user defined message handler
  852. union 
  853. {
  854. AFX_PMSG pfn;
  855. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  856. } mmf;
  857. mmf.pfn = lpEntry->pfn;
  858. (this->*mmf.pfn_COMMAND)();
  859. return 0L;
  860. } // if( lpEntry != NULL )
  861. }
  863. return TRUE;
  865. } // case WM_PAINT
  867. } // switch( nMessage )
  868. } // if( (m_psh.dwFlags&(__EXT_MFC_PSH_WIZARD97_MASK)) != 0 )
  869. }
  870. return
  871. CExtHookSink::OnHookWndMsg(
  872. lResult,
  873. hWndHooked,
  874. nMessage,
  875. wParam,
  876. lParam
  877. );
  878. }
  880. LRESULT CExtResizablePropertyPage::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  881. {
  882. //TRACE1( "--CExtResizablePropertyPage::WindowProc(0x%08X)n", message );
  883. if( message == WM_DESTROY )
  884. m_bEnabledControlBarUpdate = false;
  886. bool bUpdateBarsOnThisMsg = false;
  887. if( m_bEnabledControlBarUpdate )
  888. {
  889. CWinApp * pApp = AfxGetApp();
  890. ASSERT( pApp != NULL );
  891. BOOL bIdleMsg = pApp->IsIdleMessage(
  892. #if _MFC_VER < 0x700
  893. &pApp->m_msgCur
  894. #else
  895. &(::AfxGetThreadState()->m_msgCur)
  896. #endif
  897. );
  898. if( bIdleMsg )
  899. bUpdateBarsOnThisMsg = true;
  900. }
  903. LRESULT lResult =
  904. CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > >::WindowProc(message, wParam, lParam);
  906. switch( message )
  907. {
  908. /*
  909. #if _MFC_VER >= 0x700
  910. case WM_PAINT:
  911. {
  912. CWnd * pWnd = GetParent();
  913. ASSERT_VALID( pWnd );
  914. ASSERT( pWnd->GetSafeHwnd() != NULL );
  915. CExtResizablePropertySheet * pRPS =
  916. DYNAMIC_DOWNCAST( CExtResizablePropertySheet, pWnd );
  917. if( pRPS != NULL
  918. && (pRPS->m_psh.dwFlags&PSH_HEADER) != 0
  919. && pRPS->m_psh.pszbmHeader != NULL
  920. )
  921. {
  922. HBITMAP hBmpHeader =
  923. g_ResourceManager->LoadBitmap(
  924. pRPS->m_psh.pszbmHeader
  925. );
  926. if( hBmpHeader != NULL )
  927. {
  928. CExtBitmap bmp;
  929. if( bmp.FromBitmap( hBmpHeader ) )
  930. {
  931. CSize _size = bmp.GetSize();
  932.   CRect rcDraw( 0, 0, _size.cx, _size.cy );
  933. CClientDC dc( this );
  934. bmp.Draw( dc.m_hDC, rcDraw );
  935. }
  936. ::DeleteObject( hBmpHeader );
  937. }
  938. }
  939. }
  940. break;
  941. #endif
  942. */
  943. //case WM_NCCREATE:
  944. case WM_INITDIALOG:
  945. {
  946. CWnd * pWndParent = GetParent();
  947. ASSERT_VALID( pWndParent );
  948. CExtResizablePropertySheet * pRPS =
  949. DYNAMIC_DOWNCAST( CExtResizablePropertySheet, pWndParent );
  950. if( pRPS != NULL
  951. && pRPS->GetActiveIndex() != 0
  952. )
  953. {
  954. pRPS->_SyncActivePage( this );
  955. }
  956. ::PostMessage( m_hWnd, (WM_USER+10), 0, 0 );
  957. }
  958. break;
  959. case (WM_USER+10):
  960. SetupHookWndSink( m_hWnd );
  961. break;
  962. case WM_DESTROY:
  963. RemoveAllWndHooks();
  964. break;
  965. case WM_SHOWWINDOW:
  966. case WM_WINDOWPOSCHANGED:
  967. if( GetStyle() & WS_VISIBLE )
  968. {
  969. CWnd * pWndParent = GetParent();
  970. if( pWndParent != NULL
  971. && pWndParent->IsKindOf(
  972. RUNTIME_CLASS(CExtResizablePropertySheet)
  973. )
  974. )
  975. {
  976. //((CExtResizablePropertySheet*)pWndParent)->ArrangeLayout();
  977. ((CExtResizablePropertySheet*)pWndParent)->_SyncActivePage();
  978. }
  979. ArrangeLayout();
  980. }
  981. break;
  982. } // switch( message )
  984. if( bUpdateBarsOnThisMsg && (!m_bInConrolBarUpdate) )
  985. {
  986. m_bInConrolBarUpdate = true;
  987. CExtControlBar::DoCustomModeUpdateControlBars( this );
  988. m_bInConrolBarUpdate = false;
  989. }
  991. return lResult;
  992. }
  994. void CExtResizablePropertyPage::PreSubclassWindow() 
  995. {
  996. CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > >::PreSubclassWindow();
  997. m_bEnabledControlBarUpdate = true;
  998. EnableToolTips();
  999. }
  1001. BOOL CExtResizablePropertyPage::PreTranslateMessage(MSG* pMsg) 
  1002. {
  1003. if( ( GetStyle() & WS_VISIBLE ) != 0
  1004. && CExtControlBar::DoCustomModePreTranslateMessage( this, pMsg )
  1005. )
  1006. return TRUE;
  1007. return CExtWA < CExtWS < __BASEOF_CExtResizablePropertyPage__ > >::PreTranslateMessage(pMsg);
  1008. }
  1010. /////////////////////////////////////////////////////////////////////////////
  1011. // CExtResizablePropertySheet
  1013. IMPLEMENT_DYNCREATE( CExtResizablePropertySheet, CExtResPS )
  1015. CExtResizablePropertySheet::CExtResizablePropertySheet()
  1016. : m_bSheetInitialized( false )
  1017. //, m_bAllowTabSwitchingLoop( false )
  1018. {
  1019. m_bShowResizingGripper = true;
  1020. }
  1022. CExtResizablePropertySheet::CExtResizablePropertySheet(
  1023. UINT nIDCaption,
  1024. CWnd *pParentWnd, // = NULL
  1025. UINT iSelectPage  // = 0
  1026. )
  1027. : CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > ( nIDCaption, pParentWnd, iSelectPage  )
  1028. , m_bSheetInitialized( false )
  1029. //, m_bAllowTabSwitchingLoop( false )
  1030. {
  1031. m_bShowResizingGripper = true;
  1032. }
  1034. CExtResizablePropertySheet::CExtResizablePropertySheet(
  1035. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  1036. CWnd *pParentWnd, // = NULL
  1037. UINT iSelectPage  // = 0
  1038. )
  1039. : CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > ( pszCaption, pParentWnd, iSelectPage  )
  1040. , m_bSheetInitialized( false )
  1041. //, m_bAllowTabSwitchingLoop( false )
  1042. {
  1043. m_bShowResizingGripper = true;
  1044. }
  1046. CExtResizablePropertySheet::~CExtResizablePropertySheet()
  1047. {
  1048. }
  1050. __EXT_MFC_SAFE_LPCTSTR CExtResizablePropertySheet::OnQuerySkinnedFontParmName() const
  1051. {
  1052. ASSERT_VALID( this );
  1053. return _T("Dialog");
  1054. }
  1056. BEGIN_MESSAGE_MAP( CExtResizablePropertySheet, CExtResPS )
  1057. //{{AFX_MSG_MAP(CExtResizablePropertySheet)
  1058. ON_WM_SIZE()
  1059. ON_WM_WINDOWPOSCHANGED()
  1060. //}}AFX_MSG_MAP
  1061. END_MESSAGE_MAP()
  1063. /////////////////////////////////////////////////////////////////////////////
  1064. // CExtResizablePropertySheet message handlers
  1066. void CExtResizablePropertySheet::PreSubclassWindow() 
  1067. {
  1068. CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > >::PreSubclassWindow();
  1069. EnableToolTips();
  1070. }
  1072. void CExtResizablePropertySheet::_SyncActivePage(
  1073. CPropertyPage * pActivePage // = NULL
  1074. )
  1075. {
  1076. CTabCtrl * pTabCtrl = NULL;
  1077. if( (m_psh.dwFlags&(__EXT_MFC_PSH_WIZARD97_MASK)) == 0 && ( (m_psh.dwFlags&PSH_WIZARD) == 0 ) )
  1078. pTabCtrl = GetTabControl();
  1079. if( pTabCtrl != NULL )
  1080. {
  1081. RECT rcMove;
  1082. pTabCtrl->GetWindowRect( &rcMove );
  1083. ScreenToClient( &rcMove );
  1084. pTabCtrl->AdjustRect( FALSE, &rcMove );
  1085. CWnd * pWnd = GetWindow( GW_CHILD );
  1086. for( ; pWnd != NULL; pWnd = pWnd->GetWindow( GW_HWNDNEXT ) )
  1087. {
  1088. if( ! pWnd->IsKindOf( RUNTIME_CLASS( CPropertyPage ) ) )
  1089. continue;
  1090. RemoveAnchor( pWnd->m_hWnd );
  1091. pWnd->MoveWindow( &rcMove );
  1092. AddAnchor( pWnd->m_hWnd, __RDA_LT, __RDA_RB );
  1093. }
  1094. }
  1095. else
  1096. {
  1097. CPropertyPage * pWnd = ( pActivePage->GetSafeHwnd() != NULL ) ? pActivePage : CExtResPS::GetActivePage();
  1098. if( pWnd->GetSafeHwnd() != NULL )
  1099. {
  1100. RDI_t _val;
  1101. if( ! m_mapRDI.Lookup( pWnd->GetSafeHwnd(), _val ) )
  1102. {
  1103. POSITION pos;
  1104. for( pos = m_mapRDI.GetStartPosition(); pos != NULL; )
  1105. {
  1106. HWND _hWnd;
  1107. RDI_t _rdi;
  1108. m_mapRDI.GetNextAssoc( pos, _hWnd, _rdi );
  1109. ASSERT( _hWnd != NULL );
  1110. if( ! ::IsWindow( _hWnd ) )
  1111. continue;
  1112. CWnd * _pWnd = CWnd::FromHandlePermanent( _hWnd );
  1113. if( _pWnd == NULL )
  1114. continue;
  1115. if( _pWnd->IsKindOf(RUNTIME_CLASS(CPropertyPage)) )
  1116. {
  1117. RECT rcMove;
  1118. _pWnd->GetWindowRect( &rcMove );
  1119. ScreenToClient( &rcMove );
  1120. //RemoveAnchor( pWnd->m_hWnd );
  1121. pWnd->MoveWindow( &rcMove );
  1122. //AddAnchor( pWnd->m_hWnd, __RDA_LT, __RDA_RB );
  1123. break;
  1124. } // if( _pWnd->IsKindOf(RUNTIME_CLASS(CPropertyPage)) )
  1125. } // for( POSITION pos = m_mapRDI.GetStartPosition(); pos != NULL; )
  1126. AddAnchor( pWnd->GetSafeHwnd(), __RDA_LT, __RDA_RB );
  1127. }
  1128. }
  1129. }
  1130. ArrangeLayout();
  1131. }
  1133. void CExtResizablePropertySheet::OnRenderWizardWatermarkArea(
  1134. CDC & dc,
  1135. const RECT & rcWaterMark,
  1136. const CExtBitmap & _bitmapWatermark // can be empty
  1137. )
  1138. {
  1139. __PROF_UIS_MANAGE_STATE;
  1140. ASSERT_VALID( this );
  1141. //
  1142. // STEP 1: draw tiled watermark bitmap
  1143. //
  1144. if( ! _bitmapWatermark.IsEmpty() )
  1145. {
  1146. CSize _size = _bitmapWatermark.GetSize();
  1147. CRect rcWalkStart(
  1148. rcWaterMark.left,
  1149. rcWaterMark.top,
  1150. rcWaterMark.left + _size.cx,
  1151. rcWaterMark.top + _size.cy
  1152. );
  1153. for( ; rcWalkStart.top < rcWaterMark.bottom; rcWalkStart.OffsetRect( 0, _size.cy ) )
  1154. {
  1155. CRect rcWalk = rcWalkStart;
  1156. for( ; rcWalk.left < rcWaterMark.right; rcWalk.OffsetRect( _size.cx, 0 ) )
  1157. {
  1158. _bitmapWatermark.Draw(
  1159. dc.GetSafeHdc(),
  1160. rcWalk.left,
  1161. rcWalk.top,
  1162. _size.cx,
  1163. _size.cy
  1164. );
  1165. }
  1166. }
  1167. } // if( ! _bitmapWatermark.IsEmpty() )
  1168. #if _MFC_VER >= 0x700
  1169. //
  1170. // STEP 2: draw title and subtitle
  1171. //
  1172. int nActiveIndex = GetActiveIndex();
  1173. CPropertyPage * pPP = ( nActiveIndex >= 0 ) ? GetPage( nActiveIndex ) : NULL;
  1174. if( pPP != NULL )
  1175. {
  1176. LPCTSTR strTitle = pPP->m_psp.pszHeaderTitle;
  1177. int nLenTitle = 0;
  1178. if( strTitle != NULL )
  1179. {
  1180. nLenTitle = int( _tcslen( strTitle ) );
  1181. if( nLenTitle == 0 )
  1182. strTitle = NULL;
  1183. }
  1184. LPCTSTR strSubTitle = pPP->m_psp.pszHeaderSubTitle;
  1185. int nLenSubTitle = 0;
  1186. if( strSubTitle != NULL )
  1187. {
  1188. nLenSubTitle = int( _tcslen( strSubTitle ) );
  1189. if( nLenSubTitle == 0 )
  1190. strSubTitle = NULL;
  1191. }
  1192. if( strTitle != NULL && strSubTitle != NULL )
  1193. {
  1194. int nOldBkMode = dc.SetBkMode( TRANSPARENT );
  1195. COLORREF clrOldTextColor =
  1196. dc.SetTextColor( PmBridge_GetPM()->GetColor( COLOR_BTNTEXT ) );
  1197. CFont * pFontTitle = &(PmBridge_GetPM()->m_FontBold);
  1198. CFont * pFontSubTitle = &(PmBridge_GetPM()->m_FontNormal);
  1199. TEXTMETRIC _tmTitle, _tmSubTitle;
  1200. ::memset( &_tmTitle, 0, sizeof(TEXTMETRIC) );
  1201. ::memset( &_tmSubTitle, 0, sizeof(TEXTMETRIC) );
  1202. CFont * pOldFont = dc.SelectObject( pFontTitle );
  1203. dc.GetTextMetrics( &_tmTitle );
  1204. dc.SelectObject( pFontSubTitle );
  1205. dc.GetTextMetrics( &_tmSubTitle );
  1206. static const int nPxDistanceBetweenTitleAndSubTitle = 4;
  1207. static const int nPxLeftOffsetTitle = 23;
  1208. static const int nPxLeftOffsetSubTitle = 22;
  1209. int nSummaryHieght =
  1210. int(_tmTitle.tmHeight)
  1211. + nPxDistanceBetweenTitleAndSubTitle
  1212. + int(_tmSubTitle.tmHeight);
  1213. CRect rcTitle(
  1214. rcWaterMark.left + nPxLeftOffsetTitle,
  1215. rcWaterMark.top,
  1216. rcWaterMark.right,
  1217. rcWaterMark.top + _tmTitle.tmHeight
  1218. );
  1219. rcTitle.OffsetRect(
  1220. 0,
  1221. ( rcWaterMark.bottom - rcWaterMark.top - nSummaryHieght ) / 2
  1222. );
  1223. CRect rcSubTitle(
  1224. rcTitle.left + nPxLeftOffsetSubTitle,
  1225. rcTitle.bottom + nPxDistanceBetweenTitleAndSubTitle,
  1226. rcWaterMark.right,
  1227. rcTitle.bottom + nPxDistanceBetweenTitleAndSubTitle + _tmSubTitle.tmHeight
  1228. );
  1229. if( strTitle != NULL )
  1230. {
  1231. ASSERT( nLenTitle > 0 );
  1232. dc.SelectObject( pFontTitle );
  1233. dc.DrawText(
  1234. strTitle,
  1235. nLenTitle,
  1236. &rcTitle,
  1237. DT_SINGLELINE|DT_LEFT|DT_TOP|DT_END_ELLIPSIS
  1238. );
  1239. } // if( strTitle != NULL )
  1240. if( strSubTitle != NULL )
  1241. {
  1242. ASSERT( nLenSubTitle > 0 );
  1243. dc.SelectObject( pFontSubTitle );
  1244. dc.DrawText(
  1245. strSubTitle,
  1246. nLenSubTitle,
  1247. &rcSubTitle,
  1248. DT_SINGLELINE|DT_LEFT|DT_TOP|DT_END_ELLIPSIS
  1249. );
  1250. } // if( strSubTitle != NULL )
  1251. dc.SelectObject( pOldFont );
  1252. dc.SetBkMode( nOldBkMode );
  1253. dc.SetTextColor( clrOldTextColor );
  1254. } // if( strTitle != NULL && strSubTitle != NULL )
  1255. } // if( pPP != NULL )
  1256. #endif // #if _MFC_VER >= 0x700
  1257. }
  1259. bool CExtResizablePropertySheet::OnHookWndMsg(
  1260. LRESULT & lResult,
  1261. HWND hWndHooked,
  1262. UINT nMessage,
  1263. WPARAM & wParam,
  1264. LPARAM & lParam
  1265. )
  1266. {
  1267. __PROF_UIS_MANAGE_STATE;
  1268. if( GetSafeHwnd() != NULL
  1269. && hWndHooked == m_hWnd
  1270. )
  1271. {
  1272. if( (m_psh.dwFlags&(__EXT_MFC_PSH_WIZARD97_MASK)) != 0 )
  1273. {
  1274. switch( nMessage )
  1275. {
  1276. case WM_ERASEBKGND:
  1277. {
  1278. ASSERT_VALID( this );
  1280. // look through the message map to see 
  1281. // if this message is handled by user
  1282. const AFX_MSGMAP_ENTRY * lpEntry = 
  1283. _FindMessageMapHandler(
  1284. nMessage,
  1285. 0, 0
  1286. );
  1287. if( lpEntry != NULL )
  1288. {
  1289. // invoke the user defined message handler
  1290. union 
  1291. {
  1292. AFX_PMSG pfn;
  1293. BOOL (AFX_MSG_CALL CWnd::*pfn_bD)( CDC* );
  1294. } mmf;
  1295. mmf.pfn = lpEntry->pfn;
  1296. LRESULT lResult = 
  1297. (this->*mmf.pfn_bD)( CDC::FromHandle( ( HDC ) wParam ) );
  1298. return lResult > 0L ? true : false;
  1299. } // if( lpEntry != NULL )
  1301. if( (GetStyle() & WS_CLIPCHILDREN) != 0
  1302. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  1303. )
  1304. return (!0L);
  1306. HDC hDC = reinterpret_cast < HDC > (wParam);
  1307. ASSERT( hDC != NULL );
  1308. CExtPaintManager::stat_ExcludeChildAreas(
  1309. hDC,
  1310. GetSafeHwnd(),
  1311. CExtPaintManager::stat_DefExcludeChildAreaCallback
  1312. );
  1314. return (!0L);
  1316. } // case WM_ERASEBKGND
  1318. case WM_PAINT:
  1319. {
  1320. ASSERT_VALID( this );
  1322. bool bDlg = IsKindOf(RUNTIME_CLASS(CDialog)) ? true : false;
  1323. if( !bDlg )
  1324. {
  1325. TCHAR strClassName[ _MAX_PATH + 1 ] = _T("");
  1326. ::GetClassName( m_hWnd, strClassName, _MAX_PATH );
  1327. __EXT_MFC_STRLWR( strClassName, _MAX_PATH + 1 );
  1328. if( _tcsstr( strClassName, _T("#") ) != NULL )
  1329. bDlg = true;
  1330. }
  1332. // look through the message map to see 
  1333. // if this message is handled by user
  1334. const AFX_MSGMAP_ENTRY * lpEntry = 
  1335. _FindMessageMapHandler(
  1336. nMessage,
  1337. 0, 0
  1338. );
  1340. bool bPainted = false;
  1341. if( !bDlg ) 
  1342. {
  1343. if( lpEntry != NULL )
  1344. {
  1345. // invoke the user defined message handler
  1346. union 
  1347. {
  1348. AFX_PMSG pfn;
  1349. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  1350. } mmf;
  1351. mmf.pfn = lpEntry->pfn;
  1352. (this->*mmf.pfn_COMMAND)();
  1353. // return 0L;
  1354. bPainted = true;
  1355. } // if( lpEntry != NULL )
  1356. }
  1358. if( !bPainted )
  1359. {
  1360. CPaintDC dc( this );
  1361. COLORREF clrBackground = GetBkColor();
  1362. bool bTransparent = false;
  1363. if( PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  1364. && ( clrBackground == COLORREF(-1L) )
  1365. )
  1366. {
  1367. CExtPaintManager::stat_ExcludeChildAreas(
  1368. dc,
  1369. GetSafeHwnd(),
  1370. CExtPaintManager::stat_DefExcludeChildAreaCallback
  1371. );
  1372. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  1373. bTransparent = true;
  1374. }
  1376. CRect rcClient;
  1377. GetClientRect( &rcClient );
  1379. if( ! bTransparent )
  1380. {
  1381. dc.FillSolidRect(
  1382. &rcClient,
  1383. clrBackground != COLORREF(-1L)
  1384. ? clrBackground
  1385. : PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this )
  1386. );
  1387. }
  1389. CExtBitmap _bitmapWatermark;
  1390. #if _MFC_VER >= 0x700
  1391. if( (m_psh.dwFlags&(PSH_WATERMARK)) == (PSH_WATERMARK) )
  1392. g_ResourceManager->LoadBitmap(
  1393. _bitmapWatermark,
  1394. m_psh.pszbmWatermark
  1395. );
  1396. #endif // #if _MFC_VER >= 0x700
  1397. CRect rcWaterMark = rcClient;
  1398. HWND hWndChild = ::GetWindow( m_hWnd, GW_CHILD );
  1399. for( ; hWndChild != NULL; hWndChild = ::GetWindow( hWndChild, GW_HWNDNEXT ) )
  1400. {
  1401. CRect rcTemp;
  1402. ::GetWindowRect( hWndChild, &rcTemp );
  1403. ScreenToClient( &rcTemp );
  1404. rcWaterMark.bottom = min( rcWaterMark.bottom, rcTemp.top );
  1405. } // for( ; hWndChild != NULL; hWndChild = ::GetWindow( hWndChild, GW_HWNDNEXT ) )
  1406. CRgn _rgn;
  1407. if( _rgn.CreateRectRgnIndirect( &rcWaterMark ) )
  1408. dc.SelectClipRgn( &_rgn );
  1409. OnRenderWizardWatermarkArea(
  1410. dc,
  1411. rcWaterMark,
  1412. _bitmapWatermark
  1413. );
  1414. dc.SelectClipRgn( NULL );
  1416. PmBridge_GetPM()->OnPaintSessionComplete( this );
  1417. }
  1419. if( bDlg ) 
  1420. {
  1421. if( lpEntry != NULL )
  1422. {
  1423. // invoke the user defined message handler
  1424. union 
  1425. {
  1426. AFX_PMSG pfn;
  1427. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  1428. } mmf;
  1429. mmf.pfn = lpEntry->pfn;
  1430. (this->*mmf.pfn_COMMAND)();
  1431. return 0L;
  1432. } // if( lpEntry != NULL )
  1433. }
  1435. return TRUE;
  1437. } // case WM_PAINT
  1439. } // switch( nMessage )
  1440. } // if( (m_psh.dwFlags&(__EXT_MFC_PSH_WIZARD97_MASK)) != 0 )
  1441. }
  1442. return
  1443. CExtHookSink::OnHookWndMsg(
  1444. lResult,
  1445. hWndHooked,
  1446. nMessage,
  1447. wParam,
  1448. lParam
  1449. );
  1450. }
  1452. LRESULT CExtResizablePropertySheet::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  1453. {
  1454. CPropertyPage * pWndPrevActivePage = NULL;
  1455. switch( message )
  1456. {
  1457. case WM_CLOSE:
  1458. if( m_bEnableSaveRestore )
  1459. SaveWindowRect();
  1460. break;
  1461. case WM_SYSCOMMAND:
  1462. if( wParam == SC_CLOSE )
  1463. {
  1464. if( m_bEnableSaveRestore )
  1465. SaveWindowRect();
  1466. }
  1467. break;
  1468. case WM_COMMAND:
  1469. if( wParam == IDOK || wParam == IDCANCEL )
  1470. {
  1471. if( m_bEnableSaveRestore )
  1472. SaveWindowRect();
  1473. }
  1474. else if( wParam == ID_WIZBACK || wParam == ID_WIZNEXT )
  1475. {
  1476. pWndPrevActivePage = CExtResPS::GetActivePage();
  1477. }
  1478. break;
  1479. case WM_DESTROY:
  1480. RemoveAllWndHooks();
  1481. case WM_NCDESTROY:
  1482. m_bSheetInitialized = false;
  1483. break;
  1484. //  case WM_SIZE:
  1485. //  _SyncActivePage();
  1486. //  break;
  1487. } // switch( message )
  1489. LRESULT lResult =
  1490. m_bSheetInitialized
  1491. ? CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > :: WindowProc(message,wParam,lParam)
  1492. : CExtResPS :: WindowProc(message,wParam,lParam)
  1493. ;
  1495. switch( message )
  1496. {
  1497. case WM_SIZE:
  1498. _SyncActivePage();
  1499. break;
  1500. case WM_CREATE:
  1501. {
  1502. // window should be resizable
  1503. ModifyStyle(
  1504. 0,
  1505. WS_THICKFRAME | WS_CLIPCHILDREN
  1506. );
  1507. ::PostMessage( m_hWnd, (WM_USER+10), 0, 0 );
  1508. }
  1509. break;
  1510. case (WM_USER+10):
  1511. {
  1512. if( m_bSheetInitialized )
  1513. break;
  1514. CWnd * pTabCtrl = NULL; // GetTabControl();
  1515. CWnd * pWnd = GetWindow( GW_CHILD );
  1516. for( ; pWnd != NULL; pWnd = pWnd->GetWindow( GW_HWNDNEXT ) )
  1517. {
  1518. CExtSafeString sClassName;
  1519. ::GetClassName(
  1520. pWnd->GetSafeHwnd(),
  1521. sClassName.GetBuffer( _MAX_PATH+1 ),
  1522. _MAX_PATH
  1523. );
  1524. sClassName.ReleaseBuffer();
  1525. sClassName.MakeLower();
  1526. if( sClassName == WC_TABCONTROL )
  1527. {
  1528. pTabCtrl = pWnd;
  1529. break;
  1530. }
  1531. }
  1532. if( GetActiveIndex() > 0 )
  1533. {
  1534. CRect rcAlignPages( 0, 0, 0, 0 );
  1535. if( pTabCtrl != NULL && (m_psh.dwFlags&PSH_WIZARD) == 0 )
  1536. {
  1537. pTabCtrl->GetWindowRect( &rcAlignPages );
  1538. ScreenToClient( &rcAlignPages );
  1539. CExtPaintManager * pPM = PmBridge_GetPM();
  1540. ASSERT_VALID( pPM );
  1541. rcAlignPages.DeflateRect(
  1542. pPM->UiScalingDo(  3, CExtPaintManager::__EUIST_X ),
  1543. pPM->UiScalingDo( 22, CExtPaintManager::__EUIST_Y ),
  1544. pPM->UiScalingDo(  4, CExtPaintManager::__EUIST_X ),
  1545. pPM->UiScalingDo(  4, CExtPaintManager::__EUIST_Y )
  1546. );
  1547. // pTabCtrl->SendMessage( TCM_ADJUSTRECT, FALSE, (LPARAM)&rcAlignPages );
  1548. } // if( pTabCtrl != NULL && (m_psh.dwFlags&PSH_WIZARD) == 0 )
  1549. else if( (m_psh.dwFlags&PSH_WIZARD) != 0 )
  1550. {
  1551. GetClientRect( &rcAlignPages );
  1552. CExtPaintManager * pPM = PmBridge_GetPM();
  1553. ASSERT_VALID( pPM );
  1554. rcAlignPages.DeflateRect(
  1555. pPM->UiScalingDo( 11, CExtPaintManager::__EUIST_X ),
  1556. pPM->UiScalingDo( 11, CExtPaintManager::__EUIST_Y ),
  1557. 0, //pPM->UiScalingDo(  8, CExtPaintManager::__EUIST_X ),
  1558. pPM->UiScalingDo( 57, CExtPaintManager::__EUIST_Y )
  1559. );
  1560. } // else if( (m_psh.dwFlags&PSH_WIZARD) != 0 )
  1561. if( ! rcAlignPages.IsRectEmpty() )
  1562. {
  1563. pWnd = GetWindow( GW_CHILD );
  1564. for( ; pWnd != NULL; pWnd = pWnd->GetWindow( GW_HWNDNEXT ) )
  1565. {
  1566. if( ! pWnd->IsKindOf( RUNTIME_CLASS(CExtResizablePropertyPage) ) )
  1567. continue;
  1568. CRect rcFoundPage;
  1569. pWnd->GetWindowRect( &rcFoundPage );
  1570. ScreenToClient( &rcFoundPage );
  1571. if( rcFoundPage == rcAlignPages )
  1572. continue;
  1573. RemoveAnchor( pWnd->m_hWnd );
  1574. pWnd->MoveWindow( &rcAlignPages );
  1575. AddAnchor( pWnd->m_hWnd, __RDA_LT, __RDA_RB );
  1576. }
  1577. } // if( ! rcAlignPages.IsRectEmpty() )
  1578. } // if( GetActiveIndex() > 0 )
  1580. m_bSheetInitialized = true;
  1581. SetupHookWndSink( m_hWnd );
  1582. Invalidate();
  1583. CRect rcWnd;
  1584. GetWindowRect( &rcWnd );
  1585. CSize sizeWnd = rcWnd.Size();
  1586. SetMinTrackSize( sizeWnd );
  1587. ::SetWindowPos(
  1588. m_hWnd, NULL, 0,0,0,0,
  1589. SWP_NOSIZE|SWP_NOMOVE
  1590. |SWP_NOZORDER|SWP_NOOWNERZORDER
  1591. |SWP_NOREPOSITION
  1592. |SWP_FRAMECHANGED
  1593. );
  1595. // CTabCtrl * pTabCtrl = CExtResPS::GetTabControl();
  1596. pWnd = GetWindow( GW_CHILD );
  1597. for( ; pWnd != NULL; pWnd = pWnd->GetWindow(GW_HWNDNEXT)  )
  1598. {
  1599. if( pTabCtrl == pWnd )
  1600. {
  1601. pTabCtrl->ModifyStyle( 0, WS_CLIPSIBLINGS );
  1602. AddAnchor( pTabCtrl->GetSafeHwnd(), __RDA_LT, __RDA_RB );
  1603. continue;
  1604. }
  1606. CExtSafeString sClassName;
  1607. ::GetClassName( pWnd->GetSafeHwnd(), sClassName.GetBuffer( _MAX_PATH+1 ), _MAX_PATH );
  1608. sClassName.ReleaseBuffer();
  1609. sClassName.MakeLower();
  1610. if( sClassName == LPCTSTR( _T("static") ) )
  1611. {
  1612. pWnd->ModifyStyle( 0, WS_CLIPSIBLINGS );
  1614. #if _MFC_VER >= 0x700
  1615. if( (m_psh.dwFlags&__EXT_MFC_PSH_WIZARD97_MASK) != 0 )
  1616. {
  1617. if( pWnd->GetDlgCtrlID() == 0x3027 )
  1618. {
  1619. AddAnchor( pWnd->GetSafeHwnd(), __RDA_LT, __RDA_RT );
  1620. continue;
  1621. }
  1622. }
  1623. #endif // #if _MFC_VER >= 0x700
  1624. AddAnchor( pWnd->GetSafeHwnd(), __RDA_LB, __RDA_RB );
  1625. continue;
  1626. }
  1627. if( sClassName == LPCTSTR( _T("button") ) )
  1628. {
  1629. CRect rcWndButton;
  1630. pWnd->GetWindowRect( &rcWndButton );
  1631. ScreenToClient( &rcWndButton );
  1632. if( g_PaintManager.m_bIsWinVistaOrLater
  1633. && g_PaintManager.m_UxTheme.IsControlsThemed()
  1634. )
  1635. rcWndButton.OffsetRect( -14, -5 );
  1636. else
  1637. rcWndButton.OffsetRect( -10, 0 );
  1638. pWnd->MoveWindow( &rcWndButton );
  1640. pWnd->ModifyStyle( 0, WS_CLIPSIBLINGS );
  1641. AddAnchor( pWnd->GetSafeHwnd(), __RDA_RB );
  1643. if( this->FromHandlePermanent( pWnd->GetSafeHwnd() ) == NULL )
  1644. {
  1645. CButtonInSheetHook * pBtn = new CButtonInSheetHook;
  1646. VERIFY( pBtn->SubclassWindow( pWnd->GetSafeHwnd() ) );
  1647. }
  1648. continue;
  1649. }
  1650. if( sClassName == LPCTSTR( _T("systabcontrol32") ) )
  1651. {
  1652. #if (!defined __EXT_MFC_NO_TAB_CTRL)
  1653. CExtThemedTabCtrl * pTabs = new CExtThemedTabCtrl;
  1654. pTabs->m_bAutoDestroyWindow = true;
  1655. VERIFY( pTabs->SubclassWindow( pWnd->GetSafeHwnd() ) );
  1656. #endif // (!defined __EXT_MFC_NO_TAB_CTRL)
  1657. AddAnchor( pWnd->GetSafeHwnd(), __RDA_LT, __RDA_RB );
  1658. continue;
  1659. }
  1661. } // for( ; pWnd != NULL; pWnd = pWnd->GetWindow(GW_HWNDNEXT)  )
  1663. _SyncActivePage();
  1665. CExtPaintManager::monitor_parms_t _mp;
  1666. CExtPaintManager::stat_GetMonitorParms( _mp, this );
  1668. SetMaximizedRect( &_mp.m_rcWorkArea );
  1669. SetMaxTrackSize( _mp.m_rcWorkArea.Size() );
  1671. CRect _rcWnd;
  1672. GetWindowRect( &_rcWnd );;
  1673. CSize _size = _rcWnd.Size();
  1674. ::SendMessage(
  1675. m_hWnd, WM_SIZE,
  1676. WPARAM(SIZE_RESTORED),
  1677. MAKELPARAM( _size.cx, _size.cy )
  1678. );
  1679. if( GetStyle() & WS_VISIBLE )
  1680. RedrawWindow();
  1682. OnResizablePropertySheetInitialized();
  1683. }
  1684. break;
  1685. case WM_COMMAND:
  1686. if( wParam == ID_WIZBACK || wParam == ID_WIZNEXT )
  1687. {
  1688. if( !m_bSheetInitialized )
  1689. break;
  1691. if( pWndPrevActivePage != NULL )
  1692. {
  1693. CPropertyPage * pWndNewActivePage = CExtResPS::GetActivePage();
  1694. if( pWndPrevActivePage != pWndNewActivePage )
  1695. {
  1696. CRect rcWndPage;
  1697. pWndPrevActivePage->GetWindowRect( &rcWndPage );
  1698. ScreenToClient( &rcWndPage );
  1699. pWndNewActivePage->MoveWindow( &rcWndPage );
  1700. }
  1701. }
  1702. _SyncActivePage();
  1703. //ArrangeLayout();
  1704. }
  1705. break;
  1706. } // switch( message )
  1708. return lResult;
  1709. }
  1711. BOOL CExtResizablePropertySheet::PreCreateWindow(CREATESTRUCT& cs)
  1712. {
  1713. if( ! ( CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > :: PreCreateWindow(cs) ) )
  1714. {
  1715. ASSERT( FALSE );
  1716. return FALSE;
  1717. }
  1719. return TRUE;
  1720. }
  1722. BOOL CExtResizablePropertySheet::PreTranslateMessage(MSG* pMsg)
  1723. {
  1724. if( GetSafeHwnd() != NULL
  1725. && ::IsWindow( GetSafeHwnd() )
  1726. //&& ( GetStyle() & WS_CHILD ) != 0
  1727. )
  1728. { // if valid sheet
  1729. if( pMsg->message == WM_KEYDOWN
  1730. && pMsg->wParam == VK_TAB
  1731. )
  1732. { // if WM_KEYDOWN with VK_TAB
  1733. HWND hWndFocus = ::GetFocus();
  1734. if( hWndFocus != NULL
  1735. && GetSafeHwnd() != NULL
  1736. && ( hWndFocus == m_hWnd || ::IsChild( m_hWnd, hWndFocus ) )
  1737. )
  1738. {
  1739. BOOL bShift = CExtPopupMenuWnd::IsKeyPressed(VK_SHIFT);
  1740. BOOL bCtrl = CExtPopupMenuWnd::IsKeyPressed(VK_CONTROL);
  1741. if( !bCtrl )
  1742. {
  1743. SendMessage( WM_NEXTDLGCTL, bShift, 0 );
  1744. return TRUE;
  1745. }
  1746. // + (2.25)
  1747. if( bShift )
  1748. {
  1749. if( GetActiveIndex() == 0 )
  1750. return TRUE;
  1751. SendMessage( WM_COMMAND, ID_WIZBACK );
  1752. } // if( bShift )
  1753. else
  1754. {
  1755. if( GetActiveIndex() == (GetPageCount() - 1) )
  1756. return TRUE;
  1757. SendMessage( WM_COMMAND, ID_WIZNEXT );
  1758. } // else from if( bShift )
  1759. return TRUE;
  1760. // - (2.25)
  1761. // CTabCtrl * pTabCtrl = CExtResPS::GetTabControl();
  1762. // if( pTabCtrl != NULL )
  1763. // {
  1764. // int nItemCount = pTabCtrl->GetItemCount();
  1765. // if( nItemCount > 1 )
  1766. // {
  1767. // int nCurSel = pTabCtrl->GetCurSel();
  1768. // nCurSel += bShift ? -1 : 1;
  1769. // if( nCurSel < 0 || nCurSel == nItemCount )
  1770. // {
  1771. // if( ! m_bAllowTabSwitchingLoop )
  1772. // return TRUE;
  1773. // if( nCurSel < 0 )
  1774. // nCurSel = nItemCount - 1;
  1775. // else
  1776. // {
  1777. // ASSERT( nCurSel == nItemCount );
  1778. // nCurSel = 0;
  1779. // }
  1780. // } // if( nCurSel == nItemCount )
  1781. // if( (pTabCtrl->GetStyle()&WS_VISIBLE) != 0 )
  1782. // {
  1783. // //pTabCtrl->SetCurSel( nCurSel );
  1784. // pTabCtrl->SetFocus();
  1785. // } // if( (pTabCtrl->GetStyle()&WS_VISIBLE) != 0 )
  1786. // SetActivePage( nCurSel );
  1787. // _SyncActivePage();
  1788. // }
  1789. // _TrickSyncActviveChild();
  1790. // } // valid sheet
  1791. // return TRUE;
  1792. }
  1793. } // if WM_KEYDOWN with VK_TAB
  1794. } // if valid sheet
  1795. return CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > :: PreTranslateMessage(pMsg);
  1796. }
  1798. BOOL CExtResizablePropertySheet::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
  1799. {
  1800. if( GetSafeHwnd() != NULL
  1801. && ::IsWindow( GetSafeHwnd() )
  1802. )
  1803. { // if valid sheet
  1804. if( nID == ID_WIZNEXT || nID == ID_WIZBACK )
  1805. {
  1806. BOOL bRetVal =
  1807. CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > >
  1808. :: OnCmdMsg( nID, nCode, pExtra, pHandlerInfo );
  1809. if( nCode == CN_COMMAND )
  1810. _SyncActivePage();
  1811. return bRetVal;
  1812. } // if( nID == ID_WIZNEXT || nID == ID_WIZBACK )
  1813. if( ( GetStyle() & WS_CHILD ) != 0 )
  1814. { // if valid child sheet
  1815. if( CWnd::OnCmdMsg( nID, nCode, pExtra, pHandlerInfo ) )
  1816. return TRUE;
  1817. if( ( nCode != CN_COMMAND
  1818. && nCode != CN_UPDATE_COMMAND_UI
  1819. )
  1820. || ( ((nID) & 0x8000) == 0 )
  1821. || nID >= 0xf000
  1822. )
  1823. return FALSE;
  1824. // last crack goes to the current CWinThread object
  1825. CWinThread* pThread = AfxGetThread();
  1826. if( pThread != NULL )
  1827. {
  1828. #ifdef _DEBUG
  1829. if (afxTraceFlags & traceCmdRouting)
  1830. TRACE1("Routing command id 0x%04X to app.n", nID);
  1831. #endif
  1832. if (pThread->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
  1833. return TRUE;
  1834. }
  1835. #ifdef _DEBUG
  1836. if (afxTraceFlags & traceCmdRouting)
  1837. {
  1838. TRACE2("IGNORING command id 0x%04X sent to %hs dialog.n", nID,
  1839. GetRuntimeClass()->m_lpszClassName);
  1840. }
  1841. #endif
  1842. return FALSE;
  1843. } // if valid child sheet
  1844. } // if valid sheet
  1845. return
  1846. CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > >
  1847. :: OnCmdMsg( nID, nCode, pExtra, pHandlerInfo );
  1848. }
  1850. void CExtResizablePropertySheet::OnSize(UINT nType, int cx, int cy) 
  1851. {
  1852. CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > >
  1853. :: OnSize( nType, cx, cy );
  1854. if( GetSafeHwnd() != NULL
  1855. && ::IsWindow( GetSafeHwnd() )
  1856. )
  1857. { // if valid window
  1858. DWORD dwStyle = GetStyle();
  1859. if( (dwStyle&WS_CHILD) != 0 )
  1860. { // if child sheet window
  1861. CTabCtrl * pTabCtrl = GetTabControl();
  1862. if( pTabCtrl != NULL )
  1863. {
  1864. int nAdjustTabWndDY =
  1865. ( (dwStyle&WS_CAPTION) == 0 )
  1866. ? ( ::GetSystemMetrics( SM_CYCAPTION )
  1867. + ::GetSystemMetrics( SM_CYDLGFRAME )
  1868.   * 2
  1869.   )
  1870. : 0
  1871. ;
  1872. pTabCtrl->MoveWindow(
  1873. 0,
  1874. 0,
  1875. cx,
  1876. cy - nAdjustTabWndDY,
  1877. FALSE
  1878. );
  1880. //ArrangeLayout();
  1881. _SyncActivePage();
  1882. _TrickSyncActviveChild();
  1883. } // if( pTabCtrl != NULL )
  1884. } // if child sheet window
  1885. } // if valid window
  1886. }
  1888. void CExtResizablePropertySheet::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos) 
  1889. {
  1890. CExtWA < CExtWS < __BASEOF_CExtResizablePropertySheet__ > > :: OnWindowPosChanged(lpwndpos);
  1891. // if( GetSafeHwnd() != NULL
  1892. // && ( GetStyle() & (WS_CHILD|WS_VISIBLE) ) == (WS_CHILD|WS_VISIBLE)
  1893. // )
  1894. // { // if valid visible sheet
  1895. // CTabCtrl * pTabCtrl = GetTabControl();
  1896. // if( pTabCtrl != NULL )
  1897. // {
  1898. // CRect rcClient;
  1899. // GetClientRect( &rcClient );
  1900. // pTabCtrl->MoveWindow( 0, 0, rcClient.Width(), rcClient.Height(), FALSE );
  1901. // //ArrangeLayout();
  1902. // //_TrickSyncActviveChild();
  1903. // } // if( pTabCtrl != NULL )
  1904. _SyncActivePage();
  1905. _TrickSyncActviveChild();
  1906. // } // if valid visible sheet
  1907. }
  1909. void CExtResizablePropertySheet::OnResizablePropertySheetInitialized()
  1910. {
  1911. _InitSizeGripper();
  1912. if( ( GetStyle() & WS_CHILD ) != 0 )
  1913. {
  1914. _TrickSyncActviveChild();
  1915. } // if( ( GetStyle() & WS_CHILD ) != 0 )
  1916. else
  1917. {
  1918. // + (2.25)
  1919. ModifyStyle( 0, WS_CLIPCHILDREN );
  1920. if( m_bEnableSaveRestore )
  1921. LoadWindowRect();
  1922. } // else from if( ( GetStyle() & WS_CHILD ) != 0 )
  1923. SetWindowPos(
  1924. NULL, 0, 0, 0, 0,
  1925. SWP_NOSIZE|SWP_NOMOVE
  1926. |SWP_NOCOPYBITS
  1927. |SWP_NOZORDER|SWP_NOOWNERZORDER
  1928. |SWP_FRAMECHANGED
  1929. );
  1930. //CTabCtrl * pTabCtrl = CPropertySheet::GetTabControl();
  1931. // if( pTabCtrl != NULL
  1932. // && pTabCtrl->GetSafeHwnd() != NULL
  1933. // )
  1934. // pTabCtrl->ModifyStyle( TCS_MULTILINE, 0, SWP_FRAMECHANGED );
  1935. //ArrangeLayout();
  1936. _SyncActivePage();
  1937. }
  1939. void CExtResizablePropertySheet::_TrickSyncActviveChild()
  1940. {
  1941. }