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

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

界面编程

开发平台：

Visual C++

ExtTempl.h：源码内容
  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. #if (!defined __EXT_TEMPL_H)
  23. #define __EXT_TEMPL_H
  25. #if (!defined __EXT_MFC_DEF_H)
  26. #include <ExtMfcDef.h>
  27. #endif // __EXT_MFC_DEF_H
  29. #if (!defined __EXT_MEMORY_DC_H)
  30. #include <../Src/ExtMemoryDC.h>
  31. #endif
  33. #if (!defined __EXT_PAINT_MANAGER_H)
  34. #include <ExtPaintManager.h>
  35. #endif
  37. #if (!defined __EXT_POPUP_MENU_WND_H)
  38. #include <ExtPopupMenuWnd.h>
  39. #endif
  41. #if (!defined __EXT_TOOLCONTROLBAR_H)
  42. #include <ExtToolControlBar.h>
  43. #endif
  45. #if (!defined __EXT_CONTROLS_H)
  46. #include <ExtControls.h>
  47. #endif
  49. #if (!defined _AFX_NO_OCC_SUPPORT )
  51. #if (!defined __PROF_UIS_OCC_IMPL_INCLUDED )
  52. #define __PROF_UIS_OCC_IMPL_INCLUDED
  54. #if _MFC_VER < 0x700
  55. #if (!defined __PROF_UIS_AUTOMATION_PACK_IMPL__) && (!defined __PROF_SKIN_IMPL__)
  56. #include <../Src/occimpl.h>
  57. #define __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED
  58. #endif
  59. #else
  60. #include <ocdb.h>
  61. #include <afxocc.h>
  62. #include <../src/mfc/occimpl.h>
  63. #define __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED
  64. #endif
  66. #endif // (!defined __PROF_UIS_OCC_IMPL_INCLUDED )
  68. #endif // (!defined _AFX_NO_OCC_SUPPORT )
  70. /////////////////////////////////////////////////////////////////////////////
  71. // CExtWFF template window extension (flicker free window)
  72. //
  73. // removes flicker effect caused by WM_ERASEBKGND or
  74. // non-buffered painting, useful for new win32 (not old win16)
  75. // common controls such as list-view or tree-view
  76. //
  78. template <
  79. class CExtWFFBase = CWnd,
  80. bool _bExludeChildAreas = true,
  81. bool _bEat_WM_ERASEBKGND = true,
  82. bool _bEmulate_WM_ERASEBKGND = true
  83. >
  84. class CExtWFF : public CExtWFFBase
  85. {
  86. protected:
  87. virtual LRESULT WindowProc( 
  88. UINT message, 
  89. WPARAM wParam, 
  90. LPARAM lParam
  91. )
  92. {
  93. switch( message )
  94. {
  95. case WM_ERASEBKGND:
  96. {
  97. bool bValEat_WM_ERASEBKGND = _bEat_WM_ERASEBKGND;
  98. if( bValEat_WM_ERASEBKGND )
  99. return FALSE;
  100. }
  101. break;
  102. case WM_PAINT:
  103. {
  104. CPaintDC dcPaint( this );
  105. bool bValExludeChildAreas = _bExludeChildAreas;
  106. if( bValExludeChildAreas )
  107. {
  108. CExtPaintManager::stat_ExcludeChildAreas(
  109. dcPaint.GetSafeHdc(),
  110. GetSafeHwnd()
  111. );
  112. }
  113. CRect rcClient;
  114. GetClientRect( &rcClient );
  115. CExtMemoryDC dc(
  116. &dcPaint,
  117. &rcClient
  118. );
  119. bool bValEmulate_WM_ERASEBKGND = _bEmulate_WM_ERASEBKGND;
  120. if( bValEmulate_WM_ERASEBKGND )
  121. DefWindowProc(
  122. WM_ERASEBKGND,
  123. WPARAM( dc.GetSafeHdc() ),
  124. LPARAM(0)
  125. );
  126. DefWindowProc(
  127. WM_PAINT,
  128. WPARAM( dc.GetSafeHdc() ),
  129. LPARAM(0)
  130. );
  131. }
  132. return TRUE;
  133. }
  134. return CExtWFFBase::WindowProc( message, wParam, lParam );
  135. }
  136. }; // class CExtWFF
  138. /////////////////////////////////////////////////////////////////////////////
  139. // CExtWRB template window extension (window in resizable bar)
  140. //
  141. // adds thin nonclient area border according to paint manager;
  142. // useful for windows inserted into resizable control bar
  143. //
  145. template <
  146. class CExtWRBBase = CWnd
  147. >
  148. class CExtWRB : public CExtWRBBase
  149. {
  150. public:
  151. virtual CExtPaintManager * PmBridge_GetPM() const
  152. {
  153. ASSERT_VALID( this );
  154. return g_PaintManager.GetPM();
  155. }
  156. protected:
  157. virtual LRESULT WindowProc( 
  158. UINT message, 
  159. WPARAM wParam, 
  160. LPARAM lParam
  161. )
  162. {
  163. switch( message )
  164. {
  165. case WM_NCCALCSIZE:
  166. {
  167. NCCALCSIZE_PARAMS * pNCCSP =
  168. reinterpret_cast < NCCALCSIZE_PARAMS * > ( lParam );
  169. ASSERT( pNCCSP != NULL );
  171. CRect rcInBarWnd( pNCCSP->rgrc[0] );
  172. rcInBarWnd.DeflateRect(
  173. 1, 1, 1, 1
  174. );
  175. ::CopyRect( &(pNCCSP->rgrc[0]), rcInBarWnd );
  177. return 0;
  178. } // case WM_NCCALCSIZE
  179. case WM_NCPAINT:
  180. {
  181. CRect rcInBarWnd, rcInBarClient;
  182. GetWindowRect( &rcInBarWnd );
  183. GetClientRect( &rcInBarClient );
  184. ClientToScreen( &rcInBarClient );
  185. if( rcInBarWnd == rcInBarClient )
  186. return 0;
  187. CPoint ptDevOffset = -rcInBarWnd.TopLeft();
  188. rcInBarWnd.OffsetRect( ptDevOffset );
  189. rcInBarClient.OffsetRect( ptDevOffset );
  191. CWindowDC dc( this );
  192. ASSERT( dc.GetSafeHdc() != NULL );
  193. dc.ExcludeClipRect( &rcInBarClient );
  195. PmBridge_GetPM()->PaintResizableBarChildNcAreaRect(
  196. dc,
  197. rcInBarWnd,
  198. this
  199. );
  201. return 0;
  202. } // case WM_NCPAINT
  203. } // switch( message )
  204. return CExtWRBBase::WindowProc( message, wParam, lParam );
  205. }
  206. }; // class CExtWRB
  208. /////////////////////////////////////////////////////////////////////////////
  209. // CExtWS template window extension (styled window)
  210. //
  211. // adds current PaintManager's background style,
  212. // load/save window position feature,
  213. // right-bottom resizing gripper (default is off)
  214. // and cool system menu for WS_POPUP windows
  215. //
  217. #ifdef GET_WM_CTLCOLOR_HDC
  218. #define __EXT_GET_WM_CTLCOLOR_HDC(wp,lp,msg) GET_WM_CTLCOLOR_HDC(wp,lp,msg)
  219. #else
  220. #define __EXT_GET_WM_CTLCOLOR_HDC(wp,lp,msg) (HDC)(wp)
  221. #endif
  222. #ifdef GET_WM_CTLCOLOR_HWND
  223. #define __EXT_GET_WM_CTLCOLOR_HWND(wp,lp,msg) GET_WM_CTLCOLOR_HWND(wp,lp,msg)
  224. #else
  225. #define __EXT_GET_WM_CTLCOLOR_HWND(wp,lp,msg) (HWND)(lp)
  226. #endif
  227. #ifdef GET_WM_CTLCOLOR_TYPE
  228. #define __EXT_GET_WM_CTLCOLOR_TYPE(wp,lp,msg) GET_WM_CTLCOLOR_TYPE(wp,lp,msg)
  229. #else
  230. #define __EXT_GET_WM_CTLCOLOR_TYPE(wp,lp,msg) (WORD)(msg - WM_CTLCOLORMSGBOX)
  231. #endif
  233. template <
  234. class CExtWSBase
  235. , UINT nIdTimerSysMenuTracking = UINT(301)
  236. >
  237. class CExtWS : public CExtWSBase
  238. {
  239. protected:
  240. CExtSafeString m_sSection; // section name and
  241. CExtSafeString m_sEntry;   // entry for save/restore
  242. bool m_bStyledWndInitDone : 1;
  243. bool m_bEnableSaveRestore : 1;
  244. bool m_bSysMenuTracking : 1;
  245. bool m_bShowResizingGripper : 1;
  246. bool m_bAutoSubclassChildControls : 1;
  247. COLORREF m_clrBackground;
  248. bool m_bGripperRTL : 1;
  249. public:
  250. CExtWSGripper m_wndGripper;
  252. CExtWS()
  253. : m_bStyledWndInitDone( false )
  254. , m_bSysMenuTracking( false )
  255. , m_bEnableSaveRestore( false )
  256. , m_bShowResizingGripper( false )
  257. , m_bAutoSubclassChildControls( false )
  258. , m_bGripperRTL( false )
  259. , m_clrBackground( COLORREF(-1L) )
  260. {
  261. }
  263. CExtWS(
  264. UINT nIDTemplate,
  265. CWnd * pParentWnd
  266. )
  267. : CExtWSBase( nIDTemplate, pParentWnd )
  268. , m_bStyledWndInitDone( false )
  269. , m_bSysMenuTracking( false )
  270. , m_bEnableSaveRestore( false )
  271. , m_bShowResizingGripper( false )
  272. , m_bAutoSubclassChildControls( false )
  273. , m_bGripperRTL( false )
  274. , m_clrBackground( COLORREF(-1L) )
  275. {
  276. }
  278. CExtWS(
  279. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  280. CWnd * pParentWnd
  281. )
  282. : CExtWSBase( lpszTemplateName, pParentWnd )
  283. , m_bStyledWndInitDone( false )
  284. , m_bSysMenuTracking( false )
  285. , m_bEnableSaveRestore( false )
  286. , m_bShowResizingGripper( false )
  287. , m_bAutoSubclassChildControls( false )
  288. , m_bGripperRTL( false )
  289. , m_clrBackground( COLORREF(-1L) )
  290. {
  291. }
  293. CExtWS(
  294. UINT nIDTemplate,
  295. UINT nIDCaption = 0
  296. )
  297. : CExtWSBase( nIDTemplate, nIDCaption )
  298. , m_bStyledWndInitDone( false )
  299. , m_bSysMenuTracking( false )
  300. , m_bEnableSaveRestore( false )
  301. , m_bShowResizingGripper( false )
  302. , m_bAutoSubclassChildControls( false )
  303. , m_bGripperRTL( false )
  304. , m_clrBackground( COLORREF(-1L) )
  305. {
  306. }
  308. CExtWS(
  309. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  310. UINT nIDCaption = 0
  311. )
  312. : CExtWSBase( lpszTemplateName, nIDCaption )
  313. , m_bStyledWndInitDone( false )
  314. , m_bSysMenuTracking( false )
  315. , m_bEnableSaveRestore( false )
  316. , m_bShowResizingGripper( false )
  317. , m_bAutoSubclassChildControls( false )
  318. , m_bGripperRTL( false )
  319. , m_clrBackground( COLORREF(-1L) )
  320. {
  321. }
  323. CExtWS(
  324. UINT nIDCaption,
  325. CWnd *pParentWnd,
  326. UINT iSelectPage
  327. )
  328. : CExtWSBase( nIDCaption, pParentWnd, iSelectPage )
  329. , m_bStyledWndInitDone( false )
  330. , m_bSysMenuTracking( false )
  331. , m_bEnableSaveRestore( false )
  332. , m_bShowResizingGripper( false )
  333. , m_bAutoSubclassChildControls( false )
  334. , m_bGripperRTL( false )
  335. , m_clrBackground( COLORREF(-1L) )
  336. {
  337. }
  339. CExtWS(
  340. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  341. CWnd *pParentWnd,
  342. UINT iSelectPage
  343. )
  344. : CExtWSBase( pszCaption, pParentWnd, iSelectPage )
  345. , m_bStyledWndInitDone( false )
  346. , m_bSysMenuTracking( false )
  347. , m_bEnableSaveRestore( false )
  348. , m_bShowResizingGripper( false )
  349. , m_bAutoSubclassChildControls( false )
  350. , m_bGripperRTL( false )
  351. , m_clrBackground( COLORREF(-1L) )
  352. {
  353. }
  355. virtual CExtPaintManager * PmBridge_GetPM() const
  356. {
  357. ASSERT_VALID( this );
  358. return g_PaintManager.GetPM();
  359. }
  361. COLORREF SetBkColor( COLORREF clrBk )
  362. {
  363. COLORREF clrBkOld = m_clrBackground;
  364. m_clrBackground = clrBk; 
  365. if( GetSafeHwnd() != NULL )
  366. {
  367. Invalidate();
  368. UpdateWindow();
  369. }
  370. return clrBkOld;
  371. }
  373. COLORREF GetBkColor() const
  374. {
  375. return m_clrBackground; 
  376. }
  378. void SetAutoSubclassChildControls( 
  379. bool bSet = true
  380. )
  381. {
  382. m_bAutoSubclassChildControls = bSet;
  383. }
  385. bool GetAutoSubclassChildControls() const
  386. {
  387. return m_bAutoSubclassChildControls;
  388. }
  390. void SubclassChildControls()
  391. {
  392. if( m_hWnd != NULL 
  393. && ::IsWindow( m_hWnd )
  394. )
  395. {
  396. ::SubclassChildControls( m_hWnd );
  397. //if( ::IsWindowVisible( m_hWnd ) )
  398. // RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_ALLCHILDREN );
  399. }
  400. }
  402. virtual void ShowSizeGrip( BOOL bShow = TRUE )
  403. {
  404. bool _bShow = bShow ? true : false;
  405. if( m_bShowResizingGripper != _bShow )
  406. {
  407. m_bShowResizingGripper = _bShow;
  408. if( m_wndGripper.GetSafeHwnd() != NULL )
  409. {
  410. m_wndGripper.ShowWindow( 
  411. m_bShowResizingGripper ? SW_SHOW : SW_HIDE 
  412. );
  413. if( (!m_bShowResizingGripper)
  414. && m_hWnd != NULL
  415. && ::IsWindow( m_hWnd ) )
  416. {
  417. CRect rcGripper;
  418. m_wndGripper.GetWindowRect( &rcGripper );
  419. ScreenToClient( &rcGripper );
  420. InvalidateRect( &rcGripper );
  421. }
  422. }
  423. }
  424. }
  426. virtual void SaveWindowRect() const
  427. {
  428. VERIFY(
  429. CExtControlBar::stat_SaveWindowRect(
  430. GetSafeHwnd(),
  431. __EXT_MFC_SAFE_LPCTSTR( m_sSection ),
  432. __EXT_MFC_SAFE_LPCTSTR( m_sEntry )
  433. )
  434. );
  435. }
  437. virtual void LoadWindowRect(
  438. bool bForceHideWindow = false
  439. )
  440. {
  441. CExtControlBar::stat_LoadWindowRect(
  442. GetSafeHwnd(),
  443. __EXT_MFC_SAFE_LPCTSTR( m_sSection ),
  444. __EXT_MFC_SAFE_LPCTSTR( m_sEntry ),
  445. bForceHideWindow
  446. );
  447. }
  449. virtual void EnableSaveRestore(
  450. __EXT_MFC_SAFE_LPCTSTR pszSection,
  451. __EXT_MFC_SAFE_LPCTSTR pszEntry,
  452. bool bForceHideWindow = false
  453. )
  454. {
  455. m_sSection = pszSection;
  456. m_sEntry = pszEntry;
  457. m_bEnableSaveRestore = true;
  458. LoadWindowRect( bForceHideWindow );
  459. }
  461. virtual void DisableSaveRestore()
  462. {
  463. m_bEnableSaveRestore = false;
  464. }
  466. virtual BOOL _TrackWndSystemPopupMenu(
  467. CPoint * pPoint,
  468. BOOL bSelectAny
  469. )
  470. {
  471. if( (GetStyle() & WS_POPUP) == 0 )
  472. return FALSE;
  473. if( CExtPopupMenuWnd::IsMenuTracking() )
  474. CExtPopupMenuWnd::CancelMenuTracking();
  475. m_bSysMenuTracking = false;
  477. CMenu * pSysMenu =
  478. GetSystemMenu( FALSE );
  479. if( pSysMenu == NULL )
  480. return FALSE;
  481. ASSERT( ::IsMenu(pSysMenu->GetSafeHmenu()) );
  482. CExtPopupMenuWnd * pPopup =
  483. CExtPopupMenuWnd::InstantiatePopupMenu(
  484. GetSafeHwnd(),
  485. RUNTIME_CLASS(CExtPopupMenuWnd),
  486. this
  487. );
  488. if( ! pPopup->CreatePopupMenu( GetSafeHwnd() ) )
  489. {
  490. ASSERT( FALSE );
  491. delete pPopup;
  492. return FALSE;
  493. }
  494. if( ! pPopup->UpdateFromMenu(
  495. GetSafeHwnd(),
  496. pSysMenu,
  497. false
  498. )
  499. )
  500. {
  501. ASSERT( FALSE );
  502. delete pPopup;
  503. return FALSE;
  504. }
  506. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( GetSafeHwnd(), GWL_EXSTYLE );
  507. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  509. CPoint point;
  510. if( pPoint != NULL)
  511. point = *pPoint;
  512. else
  513. {
  514. CRect rcWnd, rcClient, rcHelper;
  515. GetWindowRect( &rcWnd );
  516. GetClientRect( &rcClient );
  517. rcHelper = rcWnd;
  518. ScreenToClient( &rcHelper );
  519. ASSERT( rcHelper.top <= rcClient.top );
  520. int yDiff = rcClient.top - rcHelper.top;
  521. int n = 0;
  523. WINDOWPLACEMENT _wp;
  524. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  525. _wp.length = sizeof(WINDOWPLACEMENT);
  526. VERIFY(
  527. CExtControlBar::stat_GetWindowPlacement(
  528. GetSafeHwnd(),
  529. _wp
  530. )
  531. );
  532. if( _wp.showCmd != SW_SHOWMAXIMIZED ) 
  533. n = ::GetSystemMetrics( SM_CXFRAME );
  535. point = rcWnd.TopLeft();
  536. if( bRTL )
  537. {
  538. point = CPoint( rcWnd.right, rcWnd.top );
  539. n = -n;
  540. }
  541. point.x += n;
  542. point.y += yDiff;
  543. }
  544. DWORD dwTrackFlags = (bRTL ? TPMX_RIGHTALIGN : TPMX_TOPALIGN);
  545. if( bSelectAny )
  546. dwTrackFlags |= TPMX_SELECT_ANY;
  547. HWND hWndFocus = ::GetFocus();
  548. if( hWndFocus != NULL
  549. && (! ( hWndFocus == m_hWnd
  550. || ::IsChild( m_hWnd, hWndFocus )
  551. ) )
  552. )
  553. SetFocus();
  554. if( bRTL )
  555. point.x += pPopup->OnQueryMenuShadowSize();
  556. CRect rcExclude( point, point );
  557. m_bSysMenuTracking =
  558. pPopup->TrackPopupMenu(
  559. dwTrackFlags | TPMX_SYSMENU,
  560. point.x,point.y,
  561. rcExclude
  562. ) ? true : false;
  564. if( m_bSysMenuTracking )
  565. SetTimer( nIdTimerSysMenuTracking, 20, NULL );
  566. //else
  567. // delete pPopup;
  568. return m_bSysMenuTracking; //TRUE;
  569. }
  571. virtual BOOL PreTranslateMessage( MSG* pMsg )
  572. {
  573. if( GetSafeHwnd() != NULL
  574. && ::IsWindow( GetSafeHwnd() )
  575. && ( pMsg->message == WM_SYSKEYDOWN
  576. || pMsg->message == WM_SYSKEYUP
  577. || pMsg->message == WM_KEYDOWN
  578. //|| pMsg->message == WM_KEYUP
  579. )
  580. )
  581. {
  582. BOOL bSuccessRetVal = TRUE;
  583. if( ( GetStyle() & WS_POPUP ) == 0 )
  584. {
  585. //return FALSE;
  586. //return CExtWSBase::PreTranslateMessage(pMsg);
  587. bSuccessRetVal = FALSE;
  588. }
  589. bool bKeyUp =
  590. ( //pMsg->message == WM_KEYUP ||
  591. pMsg->message == WM_SYSKEYUP)
  592. ? true
  593. : false
  594. ;
  595. //BOOL bCtrl = GetKeyState(VK_CONTROL) & 0x80000000;
  596. //BOOL bShift = GetKeyState(VK_SHIFT) & 0x80000000;
  597. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN;
  598. __EXT_MFC_SAFE_TCHAR vkTCHAR = (TCHAR)pMsg->wParam;
  599. if( bAlt && vkTCHAR == ((TCHAR)VK_SPACE) )
  600. {
  601. if( bKeyUp )
  602. return bSuccessRetVal; // TRUE;
  603. // allow child popup track it's system menu
  604. CWnd * pWnd = CWnd::GetActiveWindow();
  605. if( pWnd == NULL
  606. || (! ::IsWindow(pWnd->GetSafeHwnd()))
  607. )
  608. return bSuccessRetVal; // TRUE;
  609. if( pWnd->GetSafeHwnd() != GetSafeHwnd()
  610. && (pWnd->GetStyle() & WS_POPUP) != 0
  611. )
  612. return bSuccessRetVal; // TRUE;
  613. // track dialog system menu
  614. if( (GetStyle() & WS_POPUP) != 0
  615. && CExtWSBase::GetSystemMenu( FALSE ) != NULL
  616. )
  617. {
  618. VERIFY( _TrackWndSystemPopupMenu( NULL, TRUE ) );
  619. }
  620. return bSuccessRetVal; // TRUE;
  621. } // if( bAlt && vkTCHAR == ((TCHAR)VK_SPACE) )
  622. }
  624. return CExtWSBase::PreTranslateMessage(pMsg);
  625. }
  627. protected:
  629. virtual void _InitSizeGripper()
  630. {
  631. if( m_wndGripper.m_hWnd != NULL 
  632. && ::IsWindow( m_wndGripper.m_hWnd )
  633. )
  634. {
  635. m_wndGripper.DestroyWindow();
  636. m_wndGripper.m_hWnd = NULL;
  637. }
  639. CRect rcGripper;
  640. GetClientRect( &rcGripper );
  642. CSize szGripperSize = 
  643. PmBridge_GetPM()->GetResizingGriperSize( this );
  645. rcGripper.left = rcGripper.right - szGripperSize.cx;
  646. rcGripper.top = rcGripper.bottom - szGripperSize.cy;
  648. WNDCLASS _wndClassInfo;
  649. HINSTANCE hInst = ::AfxGetInstanceHandle();
  650. if( ! ::GetClassInfo(
  651. hInst,
  652. __EXT_SIZE_GRIPPER_CLASS_NAME,
  653. &_wndClassInfo
  654. )
  655. )
  656. {
  657. _wndClassInfo.style = CS_GLOBALCLASS|CS_DBLCLKS;
  658. _wndClassInfo.lpfnWndProc = ::DefWindowProc;
  659. _wndClassInfo.cbClsExtra = _wndClassInfo.cbWndExtra = 0;
  660. _wndClassInfo.hInstance = hInst;
  661. _wndClassInfo.hIcon = NULL;
  662. _wndClassInfo.hCursor = ::LoadCursor( NULL, IDC_ARROW );
  663. ASSERT( _wndClassInfo.hCursor != NULL );
  664. _wndClassInfo.hbrBackground = NULL; 
  665. _wndClassInfo.lpszMenuName = NULL;
  666. _wndClassInfo.lpszClassName = __EXT_SIZE_GRIPPER_CLASS_NAME;
  667. if( !::AfxRegisterClass( & _wndClassInfo ) )
  668. {
  669. ASSERT( FALSE );
  670. return;
  671. }
  672. }
  674. if( ! m_wndGripper.Create(
  675. __EXT_SIZE_GRIPPER_CLASS_NAME, 
  676. NULL,
  677. WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN,
  678. rcGripper, 
  679. this, 
  680. UINT( __EXT_MFC_IDC_STATIC )
  681. )
  682. )
  683. return;
  685. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( GetSafeHwnd(), GWL_EXSTYLE );
  686. m_bGripperRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  688. // show the sizing gripper only if it is really needed
  689. m_bShowResizingGripper = 
  690. ( ( GetStyle() & WS_THICKFRAME ) == WS_THICKFRAME )
  691. ? true
  692. : false;
  694. m_wndGripper.SetWindowPos(
  695. &CWnd::wndTop, 
  696. 0, 0, 
  697. 0, 0,
  698. SWP_NOSIZE | SWP_NOMOVE | SWP_FRAMECHANGED
  699. | ( m_bShowResizingGripper ? SWP_SHOWWINDOW : SWP_HIDEWINDOW )
  700. );
  701. }
  703. const AFX_MSGMAP_ENTRY * _FindMessageMapHandler(
  704. UINT nMsg, 
  705. UINT nCode, 
  706. UINT nID
  707. )
  708. {
  709. ASSERT_VALID( this );
  710. const AFX_MSGMAP * pMessageMap = GetMessageMap(); 
  711. if( pMessageMap != NULL )
  712. {
  713. UINT nEntry = 0;
  714. const AFX_MSGMAP_ENTRY * lpEntry = NULL;
  715. while( (lpEntry = (pMessageMap->lpEntries + nEntry))->nSig != AfxSig_end )
  716. {
  717. if( lpEntry->nMessage == nMsg 
  718. && lpEntry->nCode == nCode 
  719. && nID >= lpEntry->nID 
  720. && nID <= lpEntry->nLastID
  721. )
  722. return lpEntry;
  723. nEntry++;
  724. }
  725. } // if( pMessageMap != NULL )
  726. return NULL;
  727. }
  729. virtual LRESULT WindowProc(
  730. UINT message,
  731. WPARAM wParam,
  732. LPARAM lParam
  733. ) 
  734. {
  735. if( ( message == WM_CREATE 
  736. && (!( IsKindOf( RUNTIME_CLASS(CDialog) )
  737. || IsKindOf( RUNTIME_CLASS(CPropertyPage) )
  738. || IsKindOf( RUNTIME_CLASS(CPropertySheet) )
  739. ))
  740. )
  741. || message == WM_INITDIALOG
  742. )
  743. {
  744. LRESULT lResult = CExtWSBase::WindowProc( message, wParam, lParam );
  745. _InitSizeGripper();
  746. if( m_bAutoSubclassChildControls )
  747. SubclassChildControls();
  748. return lResult;
  749. }
  751. if( message == WM_WINDOWPOSCHANGED )
  752. {
  753. LRESULT lResult = CExtWSBase::WindowProc( message, wParam, lParam );
  755. LPWINDOWPOS lpWindowPos = 
  756. reinterpret_cast < LPWINDOWPOS > (lParam);
  757. ASSERT( lpWindowPos != NULL );
  759. if( m_wndGripper.m_hWnd != NULL 
  760. && ::IsWindow( m_wndGripper.m_hWnd )
  761. )
  762. {
  764. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( GetSafeHwnd(), GWL_EXSTYLE );
  765. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  766. if( m_bGripperRTL != bRTL )
  767. _InitSizeGripper();
  769. CRect rcClient;
  770. GetClientRect( &rcClient );
  772. CSize szGripperSize = 
  773. PmBridge_GetPM()->GetResizingGriperSize( this );
  775. m_wndGripper.SetWindowPos(
  776. NULL,
  777. rcClient.right - szGripperSize.cx,
  778. rcClient.bottom - szGripperSize.cy,
  779. 0, 
  780. 0,
  781. SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOACTIVATE
  782. );
  784. m_wndGripper.Invalidate();
  785. m_wndGripper.UpdateWindow();
  786. }
  788. if( (lpWindowPos->flags&SWP_NOSIZE) != 0 )
  789. return lResult;
  791. if( ::IsWindowVisible( m_hWnd ) 
  792. // - 2.64
  793. // && PmBridge_GetPM()->GetCb2DbTransparentMode( this )
  794. )
  795. {
  796. // if m_hWnd is dialog, then redraw all child controls
  797. bool bDlg = false;
  798. TCHAR strClassName[ _MAX_PATH + 1 ] = _T("");
  799. ::GetClassName( m_hWnd, strClassName, _MAX_PATH );
  800. if( _tcscmp( strClassName, _T("#32770") ) == 0 )
  801. bDlg = true;
  802. if( bDlg )
  803. {
  804. RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW| RDW_NOCHILDREN|RDW_NOFRAME );
  805. for( CWnd * pWnd = this->GetWindow(GW_CHILD); pWnd != NULL; pWnd = pWnd->GetWindow(GW_HWNDNEXT) )
  806. {
  807. if( (pWnd->GetStyle() & WS_VISIBLE) == 0 )
  808. continue;
  809. pWnd->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_NOFRAME );
  810. }
  811. } // if( bDlg )
  812. }
  814. return lResult;
  815. } // if( message == WM_WINDOWPOSCHANGED )
  817. if( message == WM_PRINT 
  818. || message == WM_PRINTCLIENT
  819. )
  820. {
  821. CExtWSBase::WindowProc( message, wParam, lParam );
  823. CDC dc;
  824. dc.Attach( (HDC)wParam );
  826. CRect rcRgnWnd, rcRgnClient;
  827. GetWindowRect( &rcRgnWnd );
  828. GetClientRect( &rcRgnClient );
  830. if( (lParam&(PRF_CLIENT|PRF_ERASEBKGND)) != 0 )
  831. {
  832. CPoint ptVpOffset( 0, 0 );
  833. if( (lParam&PRF_NONCLIENT) != 0 )
  834. {
  835. CRect rcWnd = rcRgnWnd, rcClient = rcRgnClient;
  836. ClientToScreen( &rcClient );
  837. ptVpOffset.x = rcWnd.left - rcClient.left;
  838. ptVpOffset.y = rcWnd.top - rcClient.top;
  839. }
  841. if( ptVpOffset.x != 0
  842. || ptVpOffset.y != 0
  843. )
  844. dc.OffsetViewportOrg(
  845. -ptVpOffset.x,
  846. -ptVpOffset.y
  847. );
  849. for( CWnd * pWnd = GetWindow( GW_CHILD );
  850. pWnd != NULL && pWnd != this;
  851. pWnd = pWnd->GetWindow( GW_HWNDNEXT )
  852. )
  853. {
  854. if( (pWnd->GetStyle() & WS_VISIBLE) == 0 )
  855. continue;
  856. CRect rcChild;
  857. pWnd->GetWindowRect( &rcChild );
  858. ScreenToClient( &rcChild );
  859. dc.ExcludeClipRect( &rcChild );
  860. }
  862. COLORREF clrBackground = GetBkColor();
  863. bool bTransparent = false;
  864. if( PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  865. && ( clrBackground == COLORREF(-1L) )
  866. )
  867. {
  868. CExtPaintManager::stat_ExcludeChildAreas(
  869. dc,
  870. GetSafeHwnd(),
  871. CExtPaintManager::stat_DefExcludeChildAreaCallback
  872. );
  873. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  874. bTransparent = true;
  875. }
  876. if( (! bTransparent)
  877. && clrBackground != COLORREF(-1L)
  878. )
  879. dc.FillSolidRect(
  880. &rcRgnClient,
  881. clrBackground
  882. );
  884. dc.SelectClipRgn( NULL );
  886. PmBridge_GetPM()->OnPaintSessionComplete( this );
  888. if( ptVpOffset.x != 0
  889. || ptVpOffset.y != 0
  890. )
  891. dc.OffsetViewportOrg(
  892. ptVpOffset.x,
  893. ptVpOffset.y
  894. );
  895. } // if( (lParam&(PRF_CLIENT|PRF_ERASEBKGND)) != 0 )
  897. if( (lParam&PRF_CHILDREN) != 0 )
  898. CExtPaintManager::stat_PrintChildren(
  899. m_hWnd,
  900. message,
  901. dc.GetSafeHdc(),
  902. lParam,
  903. false
  904. );
  905. dc.Detach();
  906. return (!0);
  907. }
  909. if( message == WM_PAINT )
  910. {
  911. ASSERT_VALID( this );
  913. bool bDlg = IsKindOf(RUNTIME_CLASS(CDialog)) ? true : false;
  914. if( !bDlg )
  915. {
  916. TCHAR strClassName[ _MAX_PATH + 1 ] = _T("");
  917. ::GetClassName( m_hWnd, strClassName, _MAX_PATH );
  918. __EXT_MFC_STRLWR( strClassName, _MAX_PATH + 1 );
  919. if( _tcsstr( strClassName, _T("#") ) != NULL )
  920. bDlg = true;
  921. }
  923. // look through the message map to see 
  924. // if this message is handled by user
  925. const AFX_MSGMAP_ENTRY * lpEntry = 
  926. _FindMessageMapHandler(
  927. message,
  928. 0, 0
  929. );
  931. bool bPainted = false;
  932. //if( !(bDlg && GetParent() == NULL) ) 
  933. if( !bDlg ) 
  934. {
  935. if( lpEntry != NULL )
  936. {
  937. // invoke the user defined message handler
  938. union 
  939. {
  940. AFX_PMSG pfn;
  941. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  942. } mmf;
  943. mmf.pfn = lpEntry->pfn;
  944. (this->*mmf.pfn_COMMAND)();
  945. // return 0L;
  946. bPainted = true;
  947. } // if( lpEntry != NULL )
  948. }
  950. if( !bPainted )
  951. {
  952. CPaintDC dc( this );
  953. COLORREF clrBackground = GetBkColor();
  954. bool bTransparent = false;
  955. if( PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  956. && ( clrBackground == COLORREF(-1L) )
  957. )
  958. {
  959. CExtPaintManager::stat_ExcludeChildAreas(
  960. dc,
  961. GetSafeHwnd(),
  962. CExtPaintManager::stat_DefExcludeChildAreaCallback
  963. );
  964. if( PmBridge_GetPM()->PaintDockerBkgnd( true, dc, this ) )
  965. bTransparent = true;
  966. }
  967. if( (! bTransparent)
  968. && clrBackground != COLORREF(-1L)
  969. )
  970. {
  971. CRect rcClient;
  972. GetClientRect( &rcClient );
  973. dc.FillSolidRect(
  974. &rcClient,
  975. clrBackground
  976. );
  977. }
  978. PmBridge_GetPM()->OnPaintSessionComplete( this );
  979. }
  981. // if( bDlg && GetParent() == NULL ) 
  982. if( bDlg ) 
  983. {
  984. if( lpEntry != NULL )
  985. {
  986. // invoke the user defined message handler
  987. union 
  988. {
  989. AFX_PMSG pfn;
  990. void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
  991. } mmf;
  992. mmf.pfn = lpEntry->pfn;
  993. (this->*mmf.pfn_COMMAND)();
  994. return 0L;
  995. } // if( lpEntry != NULL )
  996. }
  998. return 0L;
  999. } // if( message == WM_PAINT )
  1001. if( message == WM_ERASEBKGND )
  1002. {
  1003. ASSERT_VALID( this );
  1005. // look through the message map to see 
  1006. // if this message is handled by user
  1007. const AFX_MSGMAP_ENTRY * lpEntry = 
  1008. _FindMessageMapHandler(
  1009. message,
  1010. 0, 0
  1011. );
  1012. if( lpEntry != NULL )
  1013. {
  1014. // invoke the user defined message handler
  1015. union 
  1016. {
  1017. AFX_PMSG pfn;
  1018. BOOL (AFX_MSG_CALL CWnd::*pfn_bD)( CDC* );
  1019. } mmf;
  1020. mmf.pfn = lpEntry->pfn;
  1021. LRESULT lResult = 
  1022. (this->*mmf.pfn_bD)( CDC::FromHandle( ( HDC ) wParam ) );
  1023. return lResult;
  1024. } // if( lpEntry != NULL )
  1026. HDC hDC = reinterpret_cast < HDC > (wParam);
  1027. ASSERT( hDC != NULL );
  1028. HWND hWnd = ::WindowFromDC( hDC );
  1029. if( hWnd != NULL
  1030. && hWnd != m_hWnd
  1031. )
  1032. return CExtWSBase::WindowProc( message, wParam, lParam );
  1034. if( (GetStyle() & WS_CLIPCHILDREN) != 0
  1035. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  1036. )
  1037. return (!0L);
  1039. // HDC hDC = reinterpret_cast < HDC > (wParam);
  1040. // ASSERT( hDC != NULL );
  1041. CExtPaintManager::stat_ExcludeChildAreas(
  1042. hDC,
  1043. GetSafeHwnd(),
  1044. CExtPaintManager::stat_DefExcludeChildAreaCallback
  1045. );
  1047. return CExtWSBase::WindowProc( message, wParam, lParam );
  1049. } // if( message == WM_ERASEBKGND )
  1051. if( message >= WM_CTLCOLORMSGBOX && message <= WM_CTLCOLORSTATIC )
  1052. {
  1053. HBRUSH hBrush = (HBRUSH) CExtWSBase::WindowProc( message, wParam, lParam );
  1054. HDC hDC = __EXT_GET_WM_CTLCOLOR_HDC( wParam, lParam, message );
  1055. HWND hWnd = __EXT_GET_WM_CTLCOLOR_HWND( wParam, lParam, message );
  1056. ASSERT( hWnd != NULL );
  1057. INT nCtlColor = __EXT_GET_WM_CTLCOLOR_TYPE( wParam, lParam, message );
  1058. if( nCtlColor == CTLCOLOR_DLG
  1059. || nCtlColor == CTLCOLOR_STATIC
  1060. || nCtlColor == CTLCOLOR_MSGBOX
  1061. )
  1062. {
  1063. if( nCtlColor == CTLCOLOR_STATIC )
  1064. {
  1065. bool bDefaultProcessing = false;
  1066. if( hWnd == NULL || (! ::IsWindow( hWnd ) ) )
  1067. bDefaultProcessing = true;
  1068. else
  1069. {
  1070. CExtSafeString sClassName;
  1071. ::GetClassName( hWnd, LPTSTR( sClassName.GetBuffer( _MAX_PATH + 1 ) ), _MAX_PATH );
  1072. sClassName.ReleaseBuffer();
  1073. sClassName.MakeLower();
  1074. if( sClassName != LPCTSTR( _T("static") ) )
  1075. bDefaultProcessing = true;
  1076. if( bDefaultProcessing )
  1077. return (LRESULT)hBrush;
  1078. } // else from if( hWnd == NULL || (! ::IsWindow(hWnd) ) )
  1079. ::SetBkMode( hDC, TRANSPARENT );
  1080. // (+ v.2.22) corrected by the Dmitry Yakovlev's advice
  1081. if( (GetStyle()&WS_CHILD) != 0
  1082. && PmBridge_GetPM()->GetCb2DbTransparentMode(this)
  1083. )
  1084. return (LRESULT)::GetStockObject( NULL_BRUSH );
  1085. }
  1086. static CBrush brBackground;
  1087. static COLORREF clrLast = (COLORREF)(-1L);
  1088. COLORREF clrNew = PmBridge_GetPM()->GetColor( CExtPaintManager::CLR_3DFACE_OUT, this );
  1089. if( clrLast != clrNew )
  1090. {
  1091. if( brBackground.GetSafeHandle() != NULL )
  1092. brBackground.DeleteObject();
  1093. }
  1094. if( brBackground.GetSafeHandle() == NULL )
  1095. {
  1096. clrLast = clrNew;
  1097. VERIFY( brBackground.CreateSolidBrush( clrLast ) );
  1098. } // if( brBackground.GetSafeHandle() == NULL )
  1099. return (LRESULT)brBackground.GetSafeHandle();
  1100. }
  1101. return (LRESULT)hBrush;
  1102. } // if( message >= WM_CTLCOLORMSGBOX && message <= WM_CTLCOLORSTATIC )
  1104. if( message == WM_TIMER )
  1105. {
  1106. if( wParam == nIdTimerSysMenuTracking )
  1107. {
  1108. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  1109. {
  1110. m_bSysMenuTracking = false;
  1111. KillTimer( nIdTimerSysMenuTracking );
  1112. }
  1113. return 0;
  1114. }
  1115. return CExtWSBase::WindowProc( message, wParam, lParam );
  1116. } // if( message == WM_TIMER )
  1118. if( message == WM_DESTROY )
  1119. {
  1120. if( m_bEnableSaveRestore )
  1121. SaveWindowRect();
  1122. return CExtWSBase::WindowProc( message, wParam, lParam );
  1123. }
  1125. if( (message == WM_NCLBUTTONDOWN && wParam == HTSYSMENU)
  1126. || (message == WM_NCRBUTTONUP && (wParam == HTCAPTION || wParam == HTSYSMENU))
  1127. )
  1128. {
  1129. if( wParam == HTCAPTION )
  1130. {
  1131. CPoint point;
  1132. if( ::GetCursorPos( &point ) )
  1133. _TrackWndSystemPopupMenu(
  1134. &point,
  1135. FALSE
  1136. );
  1137. } // if( wParam == HTCAPTION )
  1138. else
  1139. {
  1140. _TrackWndSystemPopupMenu(
  1141. NULL,
  1142. FALSE
  1143. );
  1144. } // else if if( wParam == HTCAPTION )
  1145. return 0;
  1146. }
  1147. if( (message == WM_NCLBUTTONDOWN || message == WM_NCRBUTTONDOWN )
  1148. && wParam == HTSYSMENU
  1149. )
  1150. return 0;
  1151. if( (message == WM_NCLBUTTONDBLCLK )
  1152. && wParam == HTSYSMENU
  1153. )
  1154. CExtPopupMenuWnd::CancelMenuTracking();
  1155. if( message == WM_NCRBUTTONDOWN && wParam == HTCAPTION )
  1156. {
  1157. CPoint point;
  1158. if( ::GetCursorPos( &point ) )
  1159. _TrackWndSystemPopupMenu(
  1160. &point,
  1161. FALSE
  1162. );
  1163. return 0;
  1164. }
  1166. return CExtWSBase::WindowProc( message, wParam, lParam );
  1167. }
  1169. virtual void PostNcDestroy()
  1170. {
  1171. m_bStyledWndInitDone = false;
  1172. CExtWSBase::PostNcDestroy();
  1173. }
  1175. }; // class CExtWS
  1177. /////////////////////////////////////////////////////////////////////////////
  1178. // CExtWA template window extension
  1179. //
  1180. // adds child anchoring support to any window;
  1181. // anchoring idea by Paolo Messina, copyright provided:
  1182. //
  1183. //
  1184. // Copyright (C) 2000 by Paolo Messina
  1185. // (ppescher@yahoo.com)
  1186. //
  1188. const SIZE __RDA_NONE = {  -1,  -1 };
  1189. const SIZE __RDA_LT = {   0,   0 };
  1190. const SIZE __RDA_RT = { 100,   0 };
  1191. const SIZE __RDA_LB = {   0, 100 };
  1192. const SIZE __RDA_RB = { 100, 100 };
  1194. const SIZE __RDA_KEEP = __RDA_LT;
  1195. const SIZE __RDA_X = __RDA_RT;
  1196. const SIZE __RDA_Y = __RDA_LB;
  1197. const SIZE __RDA_XY = __RDA_RB;
  1198. const SIZE __RDA_BOTH = __RDA_RB;
  1201. template < class CExtWABase >
  1202. class CExtWA : public CExtWABase
  1203. {
  1204. protected:
  1205. bool m_bAnchoringInitDone : 1;
  1206. bool m_bUseMaxTrack : 1;
  1207. bool m_bUseMinTrack : 1;
  1208. bool m_bUseMaxRect : 1;
  1210. CPoint m_ptMinTrackSize; // min tracking size
  1211. CPoint m_ptMaxTrackSize; // max tracking size
  1212. CPoint m_ptMaxPos; // maximized position
  1213. CPoint m_ptMaxSize; // maximized size
  1215. struct RDI_t
  1216. {
  1217. // upper-left corner
  1218. SIZE m_AnchLT;
  1219. SIZE m_MargLT;
  1220. // bottom-right corner
  1221. SIZE m_AnchRB;
  1222. SIZE m_MargRB;
  1224. RDI_t(
  1225. SIZE AnchLT = __RDA_LT,
  1226. SIZE MargLT = CSize(0,0), 
  1227. SIZE AnchRB = __RDA_LT,
  1228. SIZE MargRB = CSize(0,0)
  1229. )
  1230. : m_AnchLT( AnchLT )
  1231. , m_MargLT( MargLT )
  1232. , m_AnchRB( AnchRB )
  1233. , m_MargRB( MargRB )
  1234. {
  1235. }
  1237. RDI_t(
  1238. const RDI_t & other
  1239. )
  1240. : m_AnchLT( other.m_AnchLT )
  1241. , m_MargLT( other.m_MargLT )
  1242. , m_AnchRB( other.m_AnchRB )
  1243. , m_MargRB( other.m_MargRB )
  1244. {
  1245. }
  1247. RDI_t & operator = (
  1248. const RDI_t & other
  1249. )
  1250. {
  1251. m_AnchLT = other.m_AnchLT;
  1252. m_MargLT = other.m_MargLT;
  1253. m_AnchRB = other.m_AnchRB;
  1254. m_MargRB = other.m_MargRB;
  1255. return *this;
  1256. }
  1258. }; // struct RDI_t
  1260. // map of repositionable controls
  1261. CMap < HWND, HWND, RDI_t, RDI_t > m_mapRDI;
  1263. public:
  1264. CExtWA()
  1265. : m_bAnchoringInitDone( false )
  1266. , m_bUseMinTrack( false )
  1267. , m_bUseMaxTrack( false )
  1268. , m_bUseMaxRect( false )
  1269. , m_ptMinTrackSize( 0, 0 )
  1270. , m_ptMaxTrackSize( 0, 0 )
  1271. , m_ptMaxPos( 0, 0 )
  1272. , m_ptMaxSize( 0, 0 )
  1273. {
  1274. }
  1276. CExtWA(
  1277. UINT nIDTemplate,
  1278. CWnd * pParentWnd
  1279. )
  1280. : CExtWABase( nIDTemplate, pParentWnd )
  1281. , m_bAnchoringInitDone( false )
  1282. , m_bUseMinTrack( false )
  1283. , m_bUseMaxTrack( false )
  1284. , m_bUseMaxRect( false )
  1285. , m_ptMinTrackSize( 0, 0 )
  1286. , m_ptMaxTrackSize( 0, 0 )
  1287. , m_ptMaxPos( 0, 0 )
  1288. , m_ptMaxSize( 0, 0 )
  1289. {
  1290. }
  1292. CExtWA(
  1293. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1294. CWnd * pParentWnd
  1295. )
  1296. : CExtWABase( lpszTemplateName, pParentWnd )
  1297. , m_bAnchoringInitDone( false )
  1298. , m_bUseMinTrack( false )
  1299. , m_bUseMaxTrack( false )
  1300. , m_bUseMaxRect( false )
  1301. , m_ptMinTrackSize( 0, 0 )
  1302. , m_ptMaxTrackSize( 0, 0 )
  1303. , m_ptMaxPos( 0, 0 )
  1304. , m_ptMaxSize( 0, 0 )
  1305. {
  1306. }
  1308. CExtWA(
  1309. UINT nIDTemplate,
  1310. UINT nIDCaption = 0
  1311. )
  1312. : CExtWABase( nIDTemplate, nIDCaption )
  1313. , m_bAnchoringInitDone( false )
  1314. , m_bUseMinTrack( false )
  1315. , m_bUseMaxTrack( false )
  1316. , m_bUseMaxRect( false )
  1317. , m_ptMinTrackSize( 0, 0 )
  1318. , m_ptMaxTrackSize( 0, 0 )
  1319. , m_ptMaxPos( 0, 0 )
  1320. , m_ptMaxSize( 0, 0 )
  1321. {
  1322. }
  1324. CExtWA(
  1325. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1326. UINT nIDCaption = 0
  1327. )
  1328. : CExtWABase( lpszTemplateName, nIDCaption )
  1329. , m_bAnchoringInitDone( false )
  1330. , m_bUseMinTrack( false )
  1331. , m_bUseMaxTrack( false )
  1332. , m_bUseMaxRect( false )
  1333. , m_ptMinTrackSize( 0, 0 )
  1334. , m_ptMaxTrackSize( 0, 0 )
  1335. , m_ptMaxPos( 0, 0 )
  1336. , m_ptMaxSize( 0, 0 )
  1337. {
  1338. }
  1340. CExtWA(
  1341. UINT nIDCaption,
  1342. CWnd *pParentWnd,
  1343. UINT iSelectPage
  1344. )
  1345. : CExtWABase( nIDCaption, pParentWnd, iSelectPage )
  1346. , m_bAnchoringInitDone( false )
  1347. , m_bUseMinTrack( false )
  1348. , m_bUseMaxTrack( false )
  1349. , m_bUseMaxRect( false )
  1350. , m_ptMinTrackSize( 0, 0 )
  1351. , m_ptMaxTrackSize( 0, 0 )
  1352. , m_ptMaxPos( 0, 0 )
  1353. , m_ptMaxSize( 0, 0 )
  1354. {
  1355. }
  1357. CExtWA(
  1358. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  1359. CWnd *pParentWnd,
  1360. UINT iSelectPage
  1361. )
  1362. : CExtWABase( pszCaption, pParentWnd, iSelectPage )
  1363. , m_bAnchoringInitDone( false )
  1364. , m_bUseMinTrack( false )
  1365. , m_bUseMaxTrack( false )
  1366. , m_bUseMaxRect( false )
  1367. , m_ptMinTrackSize( 0, 0 )
  1368. , m_ptMaxTrackSize( 0, 0 )
  1369. , m_ptMaxPos( 0, 0 )
  1370. , m_ptMaxSize( 0, 0 )
  1371. {
  1372. }
  1374. virtual ~CExtWA()
  1375. {
  1376. RemoveAllAnchors();
  1377. }
  1379. virtual CExtPaintManager * PmBridge_GetPM() const
  1380. {
  1381. ASSERT_VALID( this );
  1382. return g_PaintManager.GetPM();
  1383. }
  1385. bool RemoveAnchor(
  1386. UINT nDlgCtrlID
  1387. )
  1388. {
  1389. if( GetSafeHwnd() == NULL
  1390. || (! ::IsWindow(GetSafeHwnd()) )
  1391. )
  1392. {
  1393. ASSERT( FALSE );
  1394. return false;
  1395. }
  1396. HWND hWnd = NULL;
  1397. #if (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1398. if( m_pCtrlCont != NULL )
  1399. m_pCtrlCont->GetDlgItem( nDlgCtrlID, &hWnd );
  1400. else
  1401. #endif // (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1402. hWnd = ::GetDlgItem( GetSafeHwnd(), nDlgCtrlID );
  1403. if( hWnd == NULL
  1404. || (! ::IsWindow(hWnd) )
  1405. )
  1406. {
  1407. ASSERT( FALSE );
  1408. return false;
  1409. }
  1410. return RemoveAnchor( hWnd );
  1411. }
  1413. bool RemoveAnchor(
  1414. HWND hWnd
  1415. )
  1416. {
  1417. bool bRetVal =
  1418. m_mapRDI.RemoveKey( hWnd ) ? true : false;
  1419. return bRetVal;
  1420. }
  1422. void RemoveAllAnchors()
  1423. {
  1424. m_mapRDI.RemoveAll();
  1425. }
  1427. bool AddAnchor(
  1428. UINT nDlgCtrlID,
  1429. const CRect & rcAnch
  1430. )
  1431. {
  1432. if( GetSafeHwnd() == NULL
  1433. || (! ::IsWindow(GetSafeHwnd()) )
  1434. )
  1435. {
  1436. ASSERT( FALSE );
  1437. return false;
  1438. }
  1439. HWND hWnd = NULL;
  1440. #if (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1441. if( m_pCtrlCont != NULL )
  1442. m_pCtrlCont->GetDlgItem( nDlgCtrlID, &hWnd );
  1443. else
  1444. #endif // (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1445. hWnd = ::GetDlgItem( GetSafeHwnd(), nDlgCtrlID );
  1446. if( hWnd == NULL
  1447. || (! ::IsWindow(hWnd) )
  1448. )
  1449. {
  1450. ASSERT( FALSE );
  1451. return false;
  1452. }
  1453. return AddAnchor( hWnd, rcAnch );
  1454. }
  1456. bool AddAnchor(
  1457. HWND hWnd,
  1458. const CRect & rcAnch
  1459. )
  1460. {
  1461. if( GetSafeHwnd() == NULL
  1462. || (! ::IsWindow( GetSafeHwnd() ) )
  1463. )
  1464. {
  1465. ASSERT( FALSE );
  1466. return false;
  1467. }
  1468. return
  1469. AddAnchor(
  1470. hWnd,
  1471. CSize( rcAnch.left, rcAnch.top ),
  1472. CSize( rcAnch.right, rcAnch.bottom )
  1473. );
  1474. }
  1476. bool AddAnchor(
  1477. UINT nDlgCtrlID,
  1478. CSize AnchLT,
  1479. CSize AnchRB = __RDA_NONE
  1480. )
  1481. {
  1482. if( AnchLT == __RDA_NONE
  1483. || GetSafeHwnd() == NULL
  1484. || (! ::IsWindow( GetSafeHwnd() ) )
  1485. )
  1486. {
  1487. ASSERT( FALSE );
  1488. return false;
  1489. }
  1490. HWND hWnd = NULL;
  1491. #if (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1492. if( m_pCtrlCont != NULL )
  1493. m_pCtrlCont->GetDlgItem( nDlgCtrlID, &hWnd );
  1494. else
  1495. #endif // (defined __EXT_TEMPL_OCC_SUPPORT_IMPLEMENTED)
  1496. hWnd = ::GetDlgItem( GetSafeHwnd(), nDlgCtrlID );
  1497. if( hWnd == NULL
  1498. || (! ::IsWindow(hWnd) )
  1499. )
  1500. {
  1501. ASSERT( FALSE );
  1502. return false;
  1503. }
  1504. return AddAnchor( hWnd, AnchLT, AnchRB );
  1505. }
  1507. virtual bool AddAnchor(
  1508. HWND hWnd,
  1509. CSize AnchLT,
  1510. CSize AnchRB = __RDA_NONE
  1511. )
  1512. {
  1513. if( AnchLT == __RDA_NONE
  1514. || GetSafeHwnd() == NULL
  1515. || (! ::IsWindow( GetSafeHwnd() ) )
  1516. || (! ::IsWindow( hWnd ) )
  1517. || (! ::IsChild( GetSafeHwnd(), hWnd ) )
  1518. )
  1519. {
  1520. ASSERT( FALSE );
  1521. return false;
  1522. }
  1523. CRect rcClient, rcItem;
  1524. GetClientRect( &rcClient );
  1525. int cx = rcClient.Width();
  1526. int cy = rcClient.Height();
  1527. ::GetWindowRect( hWnd, &rcItem );
  1528. ScreenToClient( &rcItem );
  1529. CSize MargLT, MargRB;
  1530. if( AnchRB == __RDA_NONE )
  1531. AnchRB = AnchLT;
  1532. MargLT.cx = rcItem.left - cx*AnchLT.cx/100;
  1533. MargLT.cy = rcItem.top - cy*AnchLT.cy/100;
  1534. MargRB.cx = rcItem.right - cx*AnchRB.cx/100;
  1535. MargRB.cy = rcItem.bottom - cy*AnchRB.cy/100;
  1536. m_mapRDI.SetAt(
  1537. hWnd,
  1538. RDI_t( AnchLT, MargLT, AnchRB, MargRB )
  1539. );
  1540. return true;
  1541. }
  1543. virtual void ArrangeLayout(
  1544. int cx = -1,
  1545. int cy = -1
  1546. )
  1547. {
  1548. INT nCount = INT( m_mapRDI.GetCount() );
  1549. if( nCount <= 0 )
  1550. return;
  1552. if( cx < 0 || cy < 0 )
  1553. {
  1554. CRect rcClient;
  1555. GetClientRect( &rcClient );
  1556. cx = rcClient.Width();
  1557. cy = rcClient.Height();
  1558. } // if( cx < 0 || cy < 0 )
  1560. HDWP _hDWP = ::BeginDeferWindowPos( nCount );
  1561. ASSERT( _hDWP != NULL );
  1563. CList < HWND, HWND > listInvalidHWNDs;
  1564. POSITION pos = m_mapRDI.GetStartPosition();
  1565. for( ; pos != NULL; )
  1566. {
  1567. HWND _hWnd;
  1568. RDI_t _rdi;
  1569. m_mapRDI.GetNextAssoc( pos, _hWnd, _rdi );
  1570. if( ! ::IsWindow( _hWnd ) )
  1571. {
  1572. listInvalidHWNDs.AddTail(_hWnd);
  1573. continue;
  1574. }
  1576. int x  = _rdi.m_MargLT.cx + ::MulDiv(cx,_rdi.m_AnchLT.cx,100);
  1577. int y  = _rdi.m_MargLT.cy + ::MulDiv(cy,_rdi.m_AnchLT.cy,100);
  1578. int dx = _rdi.m_MargRB.cx + ::MulDiv(cx,_rdi.m_AnchRB.cx,100) - x;
  1579. int dy = _rdi.m_MargRB.cy + ::MulDiv(cy,_rdi.m_AnchRB.cy,100) - y;
  1581. RECT rcWnd;
  1582. ::GetWindowRect( _hWnd, &rcWnd );
  1583. ::ScreenToClient( m_hWnd, ((LPPOINT)(&rcWnd))+0 );
  1584. ::ScreenToClient( m_hWnd, ((LPPOINT)(&rcWnd))+1 );
  1586. UINT uFlags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER;
  1588. if( rcWnd.left == x
  1589. && rcWnd.top == y
  1590. )
  1591. uFlags |= SWP_NOMOVE;
  1593. if( (rcWnd.right - rcWnd.left) == dx
  1594. && (rcWnd.bottom - rcWnd.top) == dy
  1595. )
  1596. uFlags |= SWP_NOSIZE;
  1598. if( (uFlags&SWP_NOMOVE) != 0
  1599. && (uFlags&SWP_NOSIZE) != 0
  1600. )
  1601. continue;
  1603. _hDWP =
  1604. ::DeferWindowPos(
  1605. _hDWP, _hWnd, NULL, 
  1606. x, y, 
  1607. dx, dy,
  1608. uFlags
  1609. );
  1610. ASSERT( _hDWP != NULL );
  1612. } // for( ; pos != NULL; )
  1614. VERIFY( ::EndDeferWindowPos( _hDWP ) );
  1616. if( listInvalidHWNDs.GetCount() > 0 )
  1617. {
  1618. pos = listInvalidHWNDs.GetHeadPosition();
  1619. for( ; pos != NULL; )
  1620. {
  1621. HWND hWnd = listInvalidHWNDs.GetNext(pos);
  1622. m_mapRDI.RemoveKey( hWnd );
  1623. } // for( ; pos != NULL; )
  1624. } // if( listInvalidHWNDs.GetCount() > 0 )
  1626. if( (m_nFlags&WF_OLECTLCONTAINER) != 0 )
  1627. {
  1628. for( pos = m_mapRDI.GetStartPosition(); pos != NULL; )
  1629. {
  1630. HWND _hWnd;
  1631. RDI_t _rdi;
  1632. m_mapRDI.GetNextAssoc( pos, _hWnd, _rdi );
  1633. ASSERT( ::IsWindow( _hWnd ) );
  1634. if( ! ::IsWindow( _hWnd ) )
  1635. continue;
  1636. CWnd * pWnd = CWnd::FromHandlePermanent( _hWnd );
  1637. if( pWnd == NULL )
  1638. continue;
  1639. LPUNKNOWN pUnknown = pWnd->GetControlUnknown();
  1640. if( pUnknown != NULL )
  1641. {
  1642. IOleObject * pOleObject = NULL;
  1643. HRESULT hr =
  1644. pUnknown->QueryInterface(
  1645. __uuidof(IOleObject),
  1646. (LPVOID*)(&pOleObject)
  1647. );
  1648. if( hr == S_OK )
  1649. {
  1650. ASSERT( pOleObject != NULL );
  1651. IOleInPlaceObject * pOleInPlaceObject = NULL;
  1652. hr =
  1653. pUnknown->QueryInterface(
  1654. __uuidof(IOleInPlaceObject),
  1655. (LPVOID*)(&pOleInPlaceObject)
  1656. );
  1657. if( hr == S_OK )
  1658. {
  1659. ASSERT( pOleInPlaceObject != NULL );
  1661. CRect rcClient;
  1662. GetClientRect( &rcClient );
  1663. CRect rc;
  1664. pWnd->GetWindowRect( &rc );
  1665. ScreenToClient( &rc );
  1667. SIZEL _sizeL;
  1668. _sizeL.cx = rc.Width();
  1669. _sizeL.cy = rc.Height();
  1670. CClientDC dc(pWnd);
  1671. dc.DPtoHIMETRIC(&_sizeL);
  1673. hr = pOleObject->SetExtent( DVASPECT_CONTENT, &_sizeL );
  1674.   ASSERT( SUCCEEDED( hr ) );
  1675. hr;
  1677. hr = pOleInPlaceObject->SetObjectRects( &rc, &rcClient );
  1678.   ASSERT( SUCCEEDED( hr ) );
  1679. hr;
  1681. IOleClientSite * pOleClientSite = NULL;
  1682. hr = pOleObject->GetClientSite( &pOleClientSite );
  1683. if( hr == S_OK )
  1684. { // ActiveX resizing fix by Jean-Yves Tremblay
  1685. ASSERT( pOleClientSite != NULL );
  1686. IOleInPlaceSite * pOleInPlaceSite = NULL;
  1687. hr = pOleClientSite->QueryInterface( __uuidof(IOleInPlaceSite), (LPVOID*)(&pOleInPlaceSite) );
  1688. if( hr == S_OK )
  1689. {
  1690. ASSERT( pOleInPlaceSite != NULL );
  1691. hr = pOleInPlaceSite->OnPosRectChange( &rc );
  1692. ASSERT( SUCCEEDED( hr ) );
  1693. pOleInPlaceSite->Release();
  1694. }
  1695. pOleClientSite->Release();
  1696. } // ActiveX resizing fix by Jean-Yves Tremblay
  1698. pOleInPlaceObject->Release();
  1699. } // if( hr == S_OK )
  1700. pOleObject->Release();
  1701. } // if( hr == S_OK )
  1702. } // if( pUnknown != NULL )
  1703. } // for( pos = m_mapRDI.GetStartPosition(); pos != NULL; )
  1704. } // if( (m_nFlags&WF_OLECTLCONTAINER) != 0 )
  1706. }
  1708. void SetMaximizedRect(const CRect& rc)
  1709. {
  1710. m_bUseMaxRect = true;
  1711. m_ptMaxPos = rc.TopLeft();
  1712. m_ptMaxSize.x = rc.Width();
  1713. m_ptMaxSize.y = rc.Height();
  1714. }
  1716. void ResetMaximizedRect()
  1717. {
  1718. m_bUseMaxRect = false;
  1719. }
  1721. void SetMinTrackSize(const CSize& size)
  1722. {
  1723. m_bUseMinTrack = true;
  1724. m_ptMinTrackSize.x = size.cx;
  1725. m_ptMinTrackSize.y = size.cy;
  1726. }
  1728. void ResetMinTrackSize()
  1729. {
  1730. m_bUseMinTrack = false;
  1731. }
  1733. void SetMaxTrackSize(const CSize& size)
  1734. {
  1735. m_bUseMaxTrack = true;
  1736. m_ptMaxTrackSize.x = size.cx;
  1737. m_ptMaxTrackSize.y = size.cy;
  1738. }
  1740. void ResetMaxTrackSize()
  1741. {
  1742. m_bUseMaxTrack = false;
  1743. }
  1745. protected:
  1747. virtual bool NcFrameImpl_GetMinMaxInfo(
  1748. LPMINMAXINFO pMMI
  1749. ) const
  1750. {
  1751. if( m_bUseMinTrack )
  1752. pMMI->ptMinTrackSize = m_ptMinTrackSize;
  1753. if( m_bUseMaxTrack )
  1754. pMMI->ptMaxTrackSize = m_ptMaxTrackSize;
  1755. if( m_bUseMaxRect )
  1756. {
  1757. pMMI->ptMaxPosition = m_ptMaxPos;
  1758. pMMI->ptMaxSize = m_ptMaxSize;
  1759. }
  1760. return true;
  1761. }
  1763. virtual LRESULT WindowProc(
  1764. UINT message,
  1765. WPARAM wParam,
  1766. LPARAM lParam
  1767. ) 
  1768. {
  1770. if( message == WM_GETMINMAXINFO )
  1771. {
  1772. if( ! m_bAnchoringInitDone )
  1773. return 0;
  1774. LPMINMAXINFO pMMI =
  1775. reinterpret_cast < LPMINMAXINFO > ( lParam );
  1776. NcFrameImpl_GetMinMaxInfo( pMMI );
  1777. return 0;
  1778. } // if( message == WM_GETMINMAXINFO )
  1780. if( message == WM_SIZE )
  1781. {
  1782. LRESULT lResult = CExtWABase::WindowProc( message, wParam, lParam );
  1784. if( wParam == SIZE_MINIMIZED )
  1785. return lResult;
  1787. if( ! m_bAnchoringInitDone )
  1788. {
  1789. // gets the template size as the min track size
  1790. CRect rc;
  1791. GetWindowRect( &rc );
  1792. m_ptMinTrackSize.x = rc.Width();
  1793. m_ptMinTrackSize.y = rc.Height();
  1794. m_bUseMinTrack = true;
  1796. m_bAnchoringInitDone = true;
  1798. ArrangeLayout();
  1799. return lResult;
  1800. } // if( !m_bAnchoringInitDone )
  1803. if( wParam == SIZE_MAXHIDE || wParam == SIZE_MAXSHOW )
  1804. return lResult; // arrangement not needed
  1806. if( m_bAnchoringInitDone )
  1807. ArrangeLayout( LOWORD(lParam), HIWORD(lParam) );
  1808. return lResult;
  1809. } // if( message == WM_SIZE )
  1811. CWnd * pWndThis = this;
  1812. HWND hWndOwn = m_hWnd;
  1813. LRESULT lResult =
  1814. CExtWABase::WindowProc(message, wParam, lParam);
  1816. if( message == WM_DESTROY
  1817. || message == WM_NCDESTROY
  1818. )
  1819. {
  1820. if( hWndOwn != NULL
  1821. && ::IsWindow( hWndOwn )
  1822. && CWnd::FromHandlePermanent( hWndOwn ) == pWndThis
  1823. )
  1824. RemoveAllAnchors();
  1825. }
  1827. return lResult;
  1828. }
  1830. }; // class CExtWA
  1832. /////////////////////////////////////////////////////////////////////////////
  1833. // CExtADLG template adaptor for CDialog
  1835. template < class CExtADLGBase >
  1836. class CExtADLG : public CExtADLGBase
  1837. {
  1838. public:
  1839. CExtADLG()
  1840. {
  1841. }
  1843. CExtADLG(
  1844. UINT nIDTemplate,
  1845. CWnd * pParentWnd
  1846. )
  1847. : CExtADLGBase( nIDTemplate, pParentWnd )
  1848. {
  1849. }
  1851. CExtADLG(
  1852. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1853. CWnd * pParentWnd
  1854. )
  1855. : CExtADLGBase( lpszTemplateName, pParentWnd )
  1856. {
  1857. }
  1859. CExtADLG(
  1860. UINT nIDTemplate,
  1861. UINT nIDCaption = 0
  1862. )
  1863. {
  1864. // no such constructor in CDialog
  1865. nIDTemplate;
  1866. nIDCaption;
  1867. ASSERT( FALSE );
  1868. }
  1870. CExtADLG(
  1871. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1872. UINT nIDCaption = 0
  1873. )
  1874. {
  1875. // no such constructor in CDialog
  1876. lpszTemplateName;
  1877. nIDCaption;
  1878. ASSERT( FALSE );
  1879. }
  1881. CExtADLG(
  1882. UINT nIDCaption,
  1883. CWnd *pParentWnd,
  1884. UINT iSelectPage
  1885. )
  1886. {
  1887. // no such constructor in CDialog
  1888. nIDCaption;
  1889. pParentWnd;
  1890. iSelectPage;
  1891. ASSERT( FALSE );
  1892. }
  1894. CExtADLG(
  1895. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  1896. CWnd *pParentWnd,
  1897. UINT iSelectPage
  1898. )
  1899. {
  1900. // no such constructor in CDialog
  1901. pszCaption;
  1902. pParentWnd;
  1903. iSelectPage;
  1904. ASSERT( FALSE );
  1905. }
  1906. }; // class CExtADLG
  1908. /////////////////////////////////////////////////////////////////////////////
  1909. // CExtAPSH template adaptor for CPropertySheet
  1911. template < class CExtAPSHBase >
  1912. class CExtAPSH : public CExtAPSHBase
  1913. {
  1914. public:
  1915. CExtAPSH()
  1916. {
  1917. }
  1919. CExtAPSH(
  1920. UINT nIDTemplate,
  1921. CWnd * pParentWnd
  1922. )
  1923. {
  1924. // no such constructor in CPropertySheet
  1925. nIDTemplate;
  1926. pParentWnd;
  1927. ASSERT( FALSE );
  1928. }
  1930. CExtAPSH(
  1931. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1932. CWnd * pParentWnd
  1933. )
  1934. {
  1935. // no such constructor in CPropertySheet
  1936. lpszTemplateName;
  1937. pParentWnd;
  1938. ASSERT( FALSE );
  1939. }
  1941. CExtAPSH(
  1942. UINT nIDTemplate,
  1943. UINT nIDCaption = 0
  1944. )
  1945. {
  1946. // no such constructor in CPropertySheet
  1947. nIDTemplate;
  1948. nIDCaption;
  1949. ASSERT( FALSE );
  1950. }
  1952. CExtAPSH(
  1953. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  1954. UINT nIDCaption = 0
  1955. )
  1956. {
  1957. // no such constructor in CPropertySheet
  1958. lpszTemplateName;
  1959. nIDCaption;
  1960. ASSERT( FALSE );
  1961. }
  1963. CExtAPSH(
  1964. UINT nIDCaption,
  1965. CWnd *pParentWnd,
  1966. UINT iSelectPage
  1967. )
  1968. : CExtAPSHBase( nIDCaption, pParentWnd, iSelectPage )
  1969. {
  1970. }
  1972. CExtAPSH(
  1973. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  1974. CWnd *pParentWnd,
  1975. UINT iSelectPage
  1976. )
  1977. : CExtAPSHBase( pszCaption, pParentWnd, iSelectPage )
  1978. {
  1979. }
  1980. }; // class CExtAPSH
  1982. /////////////////////////////////////////////////////////////////////////////
  1983. // CExtAPPG template adaptor for CPropertyPage
  1985. template < class CExtAPPGBase >
  1986. class CExtAPPG : public CExtAPPGBase
  1987. {
  1988. public:
  1989. CExtAPPG()
  1990. {
  1991. }
  1993. CExtAPPG(
  1994. UINT nIDTemplate,
  1995. CWnd * pParentWnd
  1996. )
  1997. {
  1998. // no such constructor in CPropertyPage
  1999. nIDTemplate;
  2000. pParentWnd;
  2001. ASSERT( FALSE );
  2002. }
  2004. CExtAPPG(
  2005. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  2006. CWnd * pParentWnd
  2007. )
  2008. {
  2009. // no such constructor in CPropertyPage
  2010. lpszTemplateName;
  2011. pParentWnd;
  2012. ASSERT( FALSE );
  2013. }
  2015. CExtAPPG(
  2016. UINT nIDTemplate,
  2017. UINT nIDCaption = 0
  2018. )
  2019. : CExtAPPGBase( nIDTemplate, nIDCaption )
  2020. {
  2021. }
  2023. CExtAPPG(
  2024. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  2025. UINT nIDCaption = 0
  2026. )
  2027. : CExtAPPGBase( lpszTemplateName, nIDCaption )
  2028. {
  2029. }
  2031. CExtAPPG(
  2032. UINT nIDCaption,
  2033. CWnd *pParentWnd,
  2034. UINT iSelectPage
  2035. )
  2036. {
  2037. // no such constructor in CPropertyPage
  2038. nIDCaption;
  2039. pParentWnd;
  2040. iSelectPage;
  2041. ASSERT( FALSE );
  2042. }
  2044. CExtAPPG(
  2045. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  2046. CWnd *pParentWnd,
  2047. UINT iSelectPage
  2048. )
  2049. {
  2050. // no such constructor in CPropertyPage
  2051. pszCaption;
  2052. pParentWnd;
  2053. iSelectPage;
  2054. ASSERT( FALSE );
  2055. }
  2056. }; // class CExtAPPG
  2058. /////////////////////////////////////////////////////////////////////////////
  2059. // CExtAGW template adaptor for generic window classes
  2061. template < class CExtAGWBase >
  2062. class CExtAGW : public CExtAGWBase
  2063. {
  2064. public:
  2065. CExtAGW()
  2066. {
  2067. }
  2069. CExtAGW(
  2070. UINT nIDTemplate,
  2071. CWnd * pParentWnd
  2072. )
  2073. {
  2074. // should not have such constructor
  2075. nIDTemplate;
  2076. pParentWnd;
  2077. ASSERT( FALSE );
  2078. }
  2080. CExtAGW(
  2081. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  2082. CWnd * pParentWnd
  2083. )
  2084. {
  2085. // should not have such constructor
  2086. lpszTemplateName;
  2087. pParentWnd;
  2088. ASSERT( FALSE );
  2089. }
  2091. CExtAGW(
  2092. UINT nIDTemplate,
  2093. UINT nIDCaption = 0
  2094. )
  2095. : CExtAGWBase( nIDTemplate, nIDCaption )
  2096. {
  2097. // should not have such constructor
  2098. nIDTemplate;
  2099. nIDCaption;
  2100. ASSERT( FALSE );
  2101. }
  2103. CExtAGW(
  2104. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  2105. UINT nIDCaption = 0
  2106. )
  2107. : CExtAGWBase( lpszTemplateName, nIDCaption )
  2108. {
  2109. // should not have such constructor
  2110. lpszTemplateName;
  2111. nIDCaption;
  2112. ASSERT( FALSE );
  2113. }
  2115. CExtAGW(
  2116. UINT nIDCaption,
  2117. CWnd *pParentWnd,
  2118. UINT iSelectPage
  2119. )
  2120. {
  2121. // should not have such constructor
  2122. nIDCaption;
  2123. pParentWnd;
  2124. iSelectPage;
  2125. ASSERT( FALSE );
  2126. }
  2128. CExtAGW(
  2129. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  2130. CWnd *pParentWnd,
  2131. UINT iSelectPage
  2132. )
  2133. {
  2134. // should not have such constructor
  2135. pszCaption;
  2136. pParentWnd;
  2137. iSelectPage;
  2138. ASSERT( FALSE );
  2139. }
  2140. }; // class CExtAGW
  2142. /////////////////////////////////////////////////////////////////////////////
  2143. // CExtAFV template adaptor for CFormView
  2145. template < class CExtAFVBase >
  2146. class CExtAFV : public CExtAFVBase
  2147. {
  2148. public:    
  2149. CExtAFV()
  2150. : CExtAFVBase( (UINT) 0 )
  2151. {
  2152. }    
  2153. CExtAFV(
  2154. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  2155. CWnd * pParentWnd
  2156. )
  2157. : CExtAFVBase( lpszTemplateName )
  2158. {        
  2159. pParentWnd;    
  2160. }    
  2161. CExtAFV(
  2162. UINT nIDTemplate,
  2163. CWnd * pParentWnd
  2164. )
  2165. : CExtAFVBase( nIDTemplate )
  2166. {        
  2167. pParentWnd;    
  2168. }
  2169. }; // class CExtAFV
  2171. /////////////////////////////////////////////////////////////////////////////
  2172. // CExtCTA template (cool tip able)
  2174. #define __EXT_MFC_TIMER_ID_COOL_TIP_TEMPLATE 7654
  2176. template < class _CTA_BASE >
  2177. class CExtCTA : public _CTA_BASE
  2178. {
  2179. protected:
  2180. mutable CExtPopupMenuTipWnd m_wndCoolTip;
  2181. mutable __EXT_MFC_INT_PTR m_nLastToolHitID;
  2182. mutable CRect m_rcLastToolHit;
  2183. void _CancelTip() const
  2184. {
  2185. if( GetSafeHwnd() != NULL )
  2186. ((CWnd*)this)->KillTimer( __EXT_MFC_TIMER_ID_COOL_TIP_TEMPLATE );
  2187. m_nLastToolHitID = -1;
  2188. m_rcLastToolHit.SetRectEmpty();
  2189. if( m_wndCoolTip.GetSafeHwnd() != NULL )
  2190. m_wndCoolTip.Hide();
  2191. CWnd::CancelToolTips();
  2192. }
  2193. protected:
  2194. virtual __EXT_MFC_INT_PTR OnToolHitTest(
  2195. CPoint point,
  2196. TOOLINFO * pTI
  2197. ) const
  2198. {
  2199. ASSERT_VALID( this );
  2200. __EXT_MFC_INT_PTR nToolTipHit =
  2201. _CTA_BASE::OnToolHitTest( point, pTI );
  2202. bool bHide = true;
  2203. if( nToolTipHit >= 0 )
  2204. {
  2205. if( m_nLastToolHitID != nToolTipHit )
  2206. {
  2207. if( pTI->lpszText != NULL )
  2208. {
  2209. if( pTI->lpszText != LPSTR_TEXTCALLBACK )
  2210. {
  2211. bHide = false;
  2212. m_nLastToolHitID = nToolTipHit;
  2213. m_rcLastToolHit = pTI->rect;
  2214. ClientToScreen( &m_rcLastToolHit );
  2215. m_wndCoolTip.SetText(
  2216. LPCTSTR(LPVOID(pTI->lpszText))
  2217. );
  2218. ((CWnd*)this)->SetTimer(
  2219. __EXT_MFC_TIMER_ID_COOL_TIP_TEMPLATE,
  2220. 50,
  2221. NULL
  2222. );
  2223. m_wndCoolTip.Show(
  2224. (CWnd*)this,
  2225. m_rcLastToolHit
  2226. );
  2227. ::free( pTI->lpszText );
  2228. } // if( pTI->lpszText != LPSTR_TEXTCALLBACK )
  2229. pTI->lpszText = NULL;
  2230. } // if( pTI->lpszText != NULL )
  2231. } // if( nToolTipHit >= 0 )
  2232. else
  2233. bHide = false;
  2234. nToolTipHit = -1;
  2235. }
  2236. if( bHide )
  2237. _CancelTip();
  2238. return nToolTipHit;
  2239. }
  2240. LRESULT WindowProc(
  2241. UINT message,
  2242. WPARAM wParam,
  2243. LPARAM lParam
  2244. )
  2245. {
  2246. if( message == WM_DESTROY || message == WM_NCDESTROY )
  2247. _CancelTip();
  2248. else if(
  2249. message == WM_TIMER
  2250. && wParam == __EXT_MFC_TIMER_ID_COOL_TIP_TEMPLATE
  2251. )
  2252. {
  2253. if( m_nLastToolHitID < 0
  2254. || m_rcLastToolHit.IsRectEmpty()
  2255. )
  2256. {
  2257. _CancelTip();
  2258. return 0;
  2259. }
  2260. POINT ptCursor;
  2261. if( ! ::GetCursorPos( &ptCursor ) )
  2262. {
  2263. _CancelTip();
  2264. return 0;
  2265. }
  2266. if( ! m_rcLastToolHit.PtInRect(ptCursor) )
  2267. {
  2268. _CancelTip();
  2269. return 0;
  2270. }
  2271. return 0; 
  2272. }
  2273. LRESULT lResult = 
  2274. _CTA_BASE::WindowProc( message, wParam, lParam );
  2275. return lResult;
  2276. }
  2277. virtual void PreSubclassWindow()
  2278. {
  2279. _CancelTip();
  2280. _CTA_BASE::PreSubclassWindow();
  2281. }
  2282. }; // class CExtCTA
  2284. #endif // __EXT_TEMPL_H