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

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

界面编程

开发平台：

Visual C++

ExtNcFrame.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_NC_FRAME_H)
  23. #define __EXT_NC_FRAME_H
  25. #if (!defined __EXT_MFC_DEF_H)
  26. #include <ExtMfcDef.h>
  27. #endif
  29. #if (!defined __EXT_RESIZABLE_DIALOG_H)
  30. #include <ExtResizableDialog.h>
  31. #endif
  33. #if (!defined __EXT_POPUP_MENU_WND_H)
  34. #include <ExtPopupMenuWnd.h>
  35. #endif
  37. #if (!defined __EXT_CONTROLBAR_H)
  38. #include <ExtControlBar.h>
  39. #endif
  41. #if (!defined __EXT_HOOK_H)
  42. #include "../Src/ExtHook.h"
  43. #endif
  45. #if _MSC_VER > 1000
  46. #pragma once
  47. #endif
  49. #if (!defined __EXT_MFC_NO_NC_FRAME )
  51. class CExtPmBridgeNC;
  52. class CExtNcFrameImpl;
  53. class CExtPaintManager;
  55. class __PROF_UIS_API CExtPmBridgeNC
  56. : public CExtPmBridge
  57. {
  58. CExtNcFrameImpl * m_pNcFrameImpl;
  59. public:
  60. DECLARE_CExtPmBridge_MEMBERS( CExtPmBridgeNC );
  61. CExtPmBridgeNC(
  62. CExtNcFrameImpl * pNcFrameImpl = NULL
  63. );
  64. virtual ~CExtPmBridgeNC();
  65. const CExtNcFrameImpl * NcFrameImpl_Get() const;
  66. CExtNcFrameImpl * NcFrameImpl_Get();
  67. void NcFrameImpl_Set(
  68. CExtNcFrameImpl * pNcFrameImpl
  69. );
  70. virtual void PmBridge_OnPaintManagerChanged(
  71. CExtPaintManager * pGlobalPM
  72. );
  73. virtual void PmBridge_OnDisplayChange(
  74. CExtPaintManager * pGlobalPM,
  75. CWnd * pWndNotifySrc,
  76. INT nDepthBPP,
  77. CPoint ptSizes
  78. );
  79. virtual void PmBridge_OnThemeChanged(
  80. CExtPaintManager * pGlobalPM,
  81. CWnd * pWndNotifySrc,
  82. WPARAM wParam,
  83. LPARAM lParam
  84. );
  85. virtual void _AdjustThemeSettings();
  86. }; // class CExtPmBridgeNC
  88. class __PROF_UIS_API CExtNcFrameImpl
  89. {
  90. protected:
  91. mutable CMapPtrToPtr m_mapNcFrameImpl_HtRects;
  92. mutable bool m_bNcFrameImpl_HelperInsideNcHitTest:1;
  93. MINMAXINFO m_NcFrameImpl_MinMaxInfo_Cache;
  94. public:
  95. CExtPmBridgeNC m_BridgeNC;
  96. bool m_bNcFrameImpl_PivotPmSyncMode:1;
  97. protected:
  98. bool m_bNcFrameImpl_IsActive:1, m_bNcFrameImpl_RgnSet:1,
  99. m_bNcFrameImpl_RestoreBorder:1, m_bNcFrameImpl_DelatayedFrameRecalc:1,
  100. m_bNcFrameImpl_QuickWindowPlacement:1,
  101. m_bNcFrameImpl_AssigningRGN:1,
  102. m_bNcFrameImpl_InAdjustAdjustThemeSettings:1;
  103. __EXT_MFC_LONG_PTR m_dwNcFrameImpl_StyleInitial, m_dwNcFrameImpl_StyleExInitial;
  104. mutable INT m_nNcFrameImpl_Lock;
  105. UINT m_nNcFrameImpl_LastShowCmd;
  106. LPARAM m_nNcFrameImpl_LastCheckCursorHT;
  107. CPoint m_ptNcFrameImpl_LastCheckCursor;
  108. mutable CExtCmdIcon m_iconNcFrameImpl_QueryCache;
  109. void NcFrameImpl_MapHtRects_Clean();
  110. void NcFrameImpl_MapHtRects_SetAt( LONG nHT, const RECT & rc ) const;
  111. bool NcFrameImpl_MapHtRects_GetAt( LONG nHT, RECT & rc ) const;
  112. bool m_bNcFrameImpl_NcInitPassed:1, m_bNcFrameImpl_CreatePassed:1;
  113. public:
  114. bool m_bNcFrameImpl_RestoreEnabledState:1, m_bNcFrameImpl_DwmSurfaceInitializationComplete:1;
  115. static const UINT g_nMsgFindExtNcFrameImpl;
  116. UINT m_nNcFrameImpl_LastExternalNcHT;
  117. CRect m_rcNcFrameImpl_LastExternalNcHT;
  119. struct __PROF_UIS_API IExtNcFrameImplBridge
  120. {
  121. virtual HWND NcFrameImplBridge_GetSafeHwnd() const = 0;
  122. virtual bool NcFrameImplBridge_OnQueryCaptionMergeMode() const = 0;
  123. virtual void NcFrameImplBridge_OnOverPaint(
  124. CDC & dc,
  125. CRect rcWnd,
  126. CRect rcClient
  127. ) const = 0;
  128. virtual bool NcFrameImplBridge_OnOverPaint_IsEnabled() const = 0;
  129. virtual void NcFrameImplBridge_OnDrawCaptionText(
  130. CDC & dc,
  131. __EXT_MFC_SAFE_LPCTSTR strCaption,
  132. CRect rcDrawText
  133. ) const = 0;
  134. virtual HRGN NcFrameImplBridge_GetNcExcludeHRGN() const = 0;
  135. virtual HRGN NcFrameImplBridge_GetNcResizingHRGN() const = 0;
  136. virtual bool NcFrameImplBridge_GetNcScRect( UINT nSC, CRect & rc ) const = 0;
  137. virtual bool NcFrameImpl_GetNcHtRect(
  138. CRect & rc,
  139. UINT nHT,
  140. bool bScreenMapping = true,
  141. bool bLayoutBordersH = false,
  142. bool bLayoutBordersV = false,
  143. LPMINMAXINFO pMinMaxInfo = NULL,
  144. LPCRECT pRectWnd = NULL
  145. ) const = 0;
  146. virtual bool NcFrameImplBridge_OnQueryDrawIcon(
  147. CRect & rcAdjustLocation
  148. ) const = 0;
  149. virtual bool NcFrameImplBridge_OnQueryDrawCaptionText(
  150. CRect & rcAdjustLocation,
  151. UINT & nAdjustDrawTextFlags
  152. ) const = 0;
  153. virtual void NcFrameImpl_PreSetWindowPlacement( const WINDOWPLACEMENT & _wp ) = 0;
  154. virtual void NcFrameImpl_PostSetWindowPlacement( const WINDOWPLACEMENT & _wp ) = 0;
  155. virtual void NcFrameImpl_AdjustDwmArea( CExtUxTheme::__EXT_UX_MARGINS & _margins ) = 0;
  156. }; // struct IExtNcFrameImplBridge
  158. IExtNcFrameImplBridge * m_pNcFrameImplBridge;
  159. public:
  161. class __PROF_UIS_API NcLock
  162. {
  163. const CExtNcFrameImpl & m_NcFrameImpl;
  164. bool m_bLocked:1;
  165. public:
  166. NcLock( const CExtNcFrameImpl & _NcFrameImpl );
  167. ~NcLock();
  168. void UnlockNow();
  169. }; // class NcLock
  170. bool m_bNcFrameImpl_IsEnabled:1, m_bNcFrameImpl_IsDwmBased:1,
  171. m_bNcFrameImpl_Resizing:1, m_bNcFrameImpl_Moving:1;
  172. protected:
  173. bool m_bNcFrameImpl_ResizingLoopTracking:1, m_bNcFrameImpl_MovingLoopTracking:1;
  174. public:
  175. mutable CRect
  176. m_rcNcFrameImpl_Icon,
  177. m_rcNcFrameImpl_Text,
  178. m_rcNcFrameImpl_ScHelp,
  179. m_rcNcFrameImpl_ScClose,
  180. m_rcNcFrameImpl_ScMaximize,
  181. m_rcNcFrameImpl_ScMinimize;
  182. enum e_StateIndex_t
  183. {
  184. __ESI_NORMAL   = 0,
  185. __ESI_HOVER    = 1,
  186. __ESI_PRESSED  = 2,
  187. };
  188. UINT m_nNcFrameImpl_ScTrackedButtonHover,
  189. m_nNcFrameImpl_ScTrackedButtonPressed;
  190. CExtPopupMenuTipWnd m_wndNcFrameImpl_Tip;
  191. mutable CExtSafeString
  192. m_strNcFrameImpl_TipMinimize,
  193. m_strNcFrameImpl_TipMaximize,
  194. m_strNcFrameImpl_TipRestore,
  195. m_strNcFrameImpl_TipClose,
  196. m_strNcFrameImpl_TipHelp;
  197. CExtNcFrameImpl();
  198. virtual ~CExtNcFrameImpl();
  199. virtual bool NcFrameImpl_IsNcLocked() const;
  200. virtual void NcFrameImpl_NcLock( bool bLock ) const;
  201. virtual DWORD NcFrameImpl_GetInitialStyle() const;
  202. virtual DWORD NcFrameImpl_GetInitialStyleEx() const;
  203. virtual HWND NcFrameImpl_OnQueryHWND() = 0;
  204. HWND NcFrameImpl_OnQueryHWND() const;
  205. virtual CWnd * NcFrameImpl_GetFrameWindow();
  206. const CWnd * NcFrameImpl_GetFrameWindow() const;
  207. CRect NcFrameImpl_GetNcHtRect(
  208. UINT nHT,
  209. LPMINMAXINFO pMinMaxInfo,
  210. LPCRECT pRectWnd = NULL
  211. ) const;
  212. virtual CRect NcFrameImpl_GetNcHtRect(
  213. UINT nHT,
  214. bool bScreenMapping = true,
  215. bool bLayoutBordersH = false,
  216. bool bLayoutBordersV = false,
  217. LPMINMAXINFO pMinMaxInfo = NULL,
  218. LPCRECT pRectWnd = NULL
  219. ) const;
  220. virtual CRect NcFrameImpl_GetNcScRect( UINT nSC ) const;
  221. virtual void NcFrameImpl_GetIcon( CExtCmdIcon & _icon ) const;
  222. virtual void NcFrameImpl_ReCacheScButtonRects() const;
  223. virtual void NcFrameImpl_DelayRgnAdjustment();
  224. virtual void NcFrameImpl_SetupRgn(
  225. WINDOWPOS * pWndPos = NULL
  226. );
  227. virtual bool NcFrameImpl_GetMinMaxInfo(
  228. LPMINMAXINFO pMMI
  229. ) const;
  230. static void NcFrameImpl_ExtractScTipText( const CWnd * pWnd, UINT nSC, CExtSafeString & strTipText );
  231. virtual __EXT_MFC_SAFE_LPCTSTR NcFrameImpl_GetScTipText( UINT nSC ) const;
  232. virtual bool NcFrameImpl_IsSupported() const;
  233. virtual bool NcFrameImpl_IsDwmBased() const;
  234. virtual bool NcFrameImpl_IsDwmCaptionReplacement() const;
  235. virtual bool NcFrameImpl_IsForceEmpty() const;
  236. virtual CRect NcFrameImpl_GetForceEmptyNcBorder() const;
  237. bool NcFrameImpl_IsForceEmptyNcBorderEmpty() const;
  238. virtual bool NcFrameImpl_IsActive();
  239. virtual bool NcFrameImpl_FilterWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam );
  240. virtual bool NcFrameImpl_PreWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam );
  241. virtual void NcFrameImpl_PostWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam );
  242. virtual bool NcFrameImpl_OnQueryQuickWindowPlacement() const;
  243. virtual bool NcFrameImpl_RecalcNcFrame();
  244. virtual void PreSubclassWindow();
  245. virtual void PostNcDestroy();
  246. virtual bool NcFrameImpl_OnQuerySystemCommandEnabled(
  247. UINT nSystemCommandID
  248. );
  249. virtual void NcFrameImpl_CheckCursor(
  250. CPoint pointScreen,
  251. LPARAM nHT,
  252. bool bCheckWindowFromPoint = true
  253. );
  254. static CExtNcFrameImpl * NcFrameImpl_FindInstance(
  255. HWND hWnd,
  256. IExtNcFrameImplBridge * pNcFrameImplBridge = NULL
  257. );
  258. virtual CExtPaintManager * NcFrameImpl_GetPM();
  259. CExtPaintManager * NcFrameImpl_GetPM() const;
  260. virtual void NcFrameImpl_OnNcPaint(
  261. CDC & dcPaint,
  262. bool bOuterEmulationMode = false
  263. );
  264. virtual void NcFrameImpl_AdjustVistaDwmCompatibilityIssues();
  266. virtual bool NcFrameImpl_GetWindowPlacement( WINDOWPLACEMENT & _wp ) const;
  267. virtual bool NcFrameImpl_SetWindowPlacement( const WINDOWPLACEMENT & _wp );
  268. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const;
  269. BOOL GetWindowPlacement( WINDOWPLACEMENT & _wp ) const;
  270. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP );
  271. BOOL SetWindowPlacement( const WINDOWPLACEMENT & _wp );
  272. static bool stat_GetWindowPlacement( HWND hWnd, WINDOWPLACEMENT & _wp );
  273. static bool stat_SetWindowPlacement( HWND hWnd, const WINDOWPLACEMENT & _wp );
  274. static bool stat_SaveWindowRect(
  275. HWND hWnd,
  276. __EXT_MFC_SAFE_LPCTSTR strSection,
  277. __EXT_MFC_SAFE_LPCTSTR strEntry
  278. );
  279. static bool stat_LoadWindowRect(
  280. HWND hWnd,
  281. __EXT_MFC_SAFE_LPCTSTR strSection,
  282. __EXT_MFC_SAFE_LPCTSTR strEntry,
  283. bool bForceHideWindow = false
  284. );
  286. virtual void NcFrameImpl_CalcWindowRect(
  287. LPRECT lpClientRect,
  288. UINT nAdjustType = CWnd::adjustBorder
  289. );
  291. static void stat_MDI_GetWindowList(
  292. HWND hWndMdiClient,
  293. CList < HWND, HWND > & _list,
  294. CList < HWND, HWND > & _listWindowsToSkip,
  295. bool bAddActiveToTail,
  296. bool bIncludeEnabled,
  297. bool bIncludeDisabled,
  298. bool bIncludeIconic,
  299. bool bIncludeNonIconic,
  300. bool bIncludeWithOwner,
  301. bool bIncludeWithoutOwner,
  302. bool bIncludeVisible = true,
  303. bool bIncludeHidden = false
  304. );
  305. static INT stat_MDI_ArrangeIconic(
  306. HWND hWndMdiClient,
  307. CList < HWND, HWND > & _listWindowsToSkip
  308. );
  309. static INT stat_MDI_ArrangeIconicEWL( // explicit window list based version
  310. HWND hWndMdiClient,
  311. CList < HWND, HWND > & _list
  312. );
  313. static void stat_MDI_Cascade(
  314. HWND hWndMdiClient,
  315. CList < HWND, HWND > & _listWindowsToSkip,
  316. WPARAM nActionFlags,
  317. INT nStairWindowCount = 0 // zero or negative - compute automatically
  318. );
  319. static void stat_MDI_CascadeEWL( // explicit window list based version
  320. HWND hWndMdiClient,
  321. CList < HWND, HWND > & _list,
  322. INT nStairWindowCount = 0 // zero or negative - compute automatically
  323. );
  324. static void stat_MDI_Tile(
  325. HWND hWndMdiClient,
  326. CList < HWND, HWND > & _listWindowsToSkip,
  327. WPARAM nActionFlags
  328. );
  329. static void stat_MDI_TileEWL( // explicit window list based version
  330. HWND hWndMdiClient,
  331. CList < HWND, HWND > & _list,
  332. bool bHorizontal
  333. );
  334. virtual void NcFrameImpl_SyncThemeSettings( CExtPaintManager * pPM, bool bPostNotification );
  336. friend class CExtPmBridgeNC;
  337. }; // class CExtNcFrameImpl
  339. template < class _BTNCW >
  340. class CExtNCW
  341. : public _BTNCW
  342. , public CExtNcFrameImpl
  343. {
  344. public:
  345. CExtNCW()
  346. {
  347. }
  348. virtual ~CExtNCW()
  349. {
  350. }
  351. virtual HWND NcFrameImpl_OnQueryHWND()
  352. {
  353. return GetSafeHwnd();
  354. }
  355. protected:
  356. virtual void PreSubclassWindow()
  357. {
  358. _BTNCW::PreSubclassWindow();
  359. CExtNcFrameImpl::PreSubclassWindow();
  360. }
  361. virtual void PostNcDestroy()
  362. {
  363. CExtNcFrameImpl::PostNcDestroy();
  364. _BTNCW::PostNcDestroy();
  365. }
  366. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  367. {
  368. HWND hWndOwn = m_hWnd;
  369. LRESULT lResult = 0;
  370. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  371. return lResult;
  372. if( ! ::IsWindow( hWndOwn ) )
  373. return lResult;
  374. if( ! NcFrameImpl_IsSupported() )
  375. return _BTNCW::WindowProc( message, wParam, lParam );
  376. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  377. return lResult;
  378. lResult = _BTNCW::WindowProc( message, wParam, lParam );
  379. if( ! ::IsWindow( hWndOwn ) )
  380. return lResult;
  381. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  382. return lResult;
  383. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  384. return lResult;
  385. }
  386. public:
  387. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  388. {
  389. ASSERT_VALID( this );
  390. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  391. }
  392. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  393. {
  394. ASSERT_VALID( this );
  395. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  396. }
  397. virtual void CalcWindowRect(
  398. LPRECT lpClientRect,
  399. UINT nAdjustType = CWnd::adjustBorder
  400. )
  401. {
  402. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  403. }
  404. }; // class CExtNCW
  406. class __PROF_UIS_API CExtNcFrameWatchMDIMF
  407. : public CExtHookSink
  408. , public CExtPmBridge
  409. {
  410. public:
  411. DECLARE_CExtPmBridge_MEMBERS( CExtNcFrameWatchMDIMF );
  412. static UINT g_nMsgSurface;
  413. HWND m_hWndSurface;
  414. CExtNcFrameImpl * m_pNcFrameImpl;
  415. CExtNcFrameWatchMDIMF();
  416. virtual ~CExtNcFrameWatchMDIMF();
  417. void _Surface( bool bForward );
  418. virtual bool OnHookWndMsg(
  419. LRESULT & lResult,
  420. HWND hWndHooked,
  421. UINT nMessage,
  422. WPARAM & wParam,
  423. LPARAM & lParam
  424. );
  425. virtual void OnPostHookWndMsg(
  426. LRESULT lResult,
  427. HWND hWndHooked,
  428. UINT nMessage,
  429. WPARAM wParam,
  430. LPARAM lParam
  431. );
  432. }; // class CExtNcFrameWatchMDIMF
  434. template < >
  435. class CExtNCW < CMDIFrameWnd >
  436. : public CMDIFrameWnd
  437. , public CExtNcFrameImpl
  438. {
  439. protected:
  440. CExtNcFrameWatchMDIMF m_hookWatchMDI;
  441. public:
  442. CExtNCW()
  443. {
  444. m_hookWatchMDI.m_pNcFrameImpl = this;
  445. }
  446. virtual ~CExtNCW()
  447. {
  448. }
  449. virtual HWND NcFrameImpl_OnQueryHWND()
  450. {
  451. return GetSafeHwnd();
  452. }
  453. protected:
  454. virtual void PreSubclassWindow()
  455. {
  456. CMDIFrameWnd::PreSubclassWindow();
  457. CExtNcFrameImpl::PreSubclassWindow();
  458. }
  459. virtual void PostNcDestroy()
  460. {
  461. CExtNcFrameImpl::PostNcDestroy();
  462. CMDIFrameWnd::PostNcDestroy();
  463. }
  464. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  465. {
  466. HWND hWndOwn = m_hWnd;
  467. LRESULT lResult = 0;
  468. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  469. return lResult;
  470. if( ! ::IsWindow( hWndOwn ) )
  471. return lResult;
  472. if( ! NcFrameImpl_IsSupported() )
  473. return CMDIFrameWnd::WindowProc( message, wParam, lParam );
  474. if( message == WM_DESTROY )
  475. m_hookWatchMDI.RemoveAllWndHooks();
  476. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  477. return lResult;
  478. lResult = CMDIFrameWnd::WindowProc( message, wParam, lParam );
  479. if( ! ::IsWindow( hWndOwn ) )
  480. return lResult;
  481. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  482. return lResult;
  483. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  484. if( message == WM_CREATE )
  485. {
  486. HWND hWndMdiClient = CExtControlBar::stat_FindMdiClientHWND( m_hWnd );
  487. ASSERT( hWndMdiClient != NULL );
  488. m_hookWatchMDI.SetupHookWndSink( hWndMdiClient );
  489. }
  490. return lResult;
  491. } 
  492. public:
  493. virtual void OnUpdateFrameTitle( BOOL bAddToTitle )
  494. {
  495. HWND hWndOwn = GetSafeHwnd();
  496. CMDIFrameWnd::OnUpdateFrameTitle( bAddToTitle );
  497. if( hWndOwn != NULL && ::IsWindow( hWndOwn ) )
  498. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  499. }
  500. virtual void OnUpdateFrameMenu( HMENU hMenuAlt )
  501. {
  502. HWND hWndOwn = GetSafeHwnd();
  503. CMDIFrameWnd::OnUpdateFrameMenu( hMenuAlt );
  504. if( hWndOwn != NULL && ::IsWindow( hWndOwn ) )
  505. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  506. }
  507. virtual BOOL DestroyWindow()
  508. {
  509. m_hookWatchMDI.RemoveAllWndHooks();
  510. return CMDIFrameWnd::DestroyWindow();
  511. }
  512. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  513. {
  514. ASSERT_VALID( this );
  515. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  516. }
  517. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  518. {
  519. ASSERT_VALID( this );
  520. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  521. }
  522. virtual void CalcWindowRect(
  523. LPRECT lpClientRect,
  524. UINT nAdjustType = CWnd::adjustBorder
  525. )
  526. {
  527. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  528. }
  529. protected:
  530. virtual BOOL OnCommand( WPARAM wParam, LPARAM lParam )
  531. {
  532. // BOOL bRetVal = CMDIFrameWnd :: OnCommand( wParam, lParam );
  533. // return bRetVal;
  535. CMDIChildWnd * pActiveChild = MDIGetActive();
  536. if (pActiveChild != NULL && AfxCallWndProc( pActiveChild, pActiveChild->m_hWnd, WM_COMMAND, wParam, lParam) != 0)
  537. return TRUE;
  539. if( CFrameWnd::OnCommand( wParam, lParam ) )
  540. return TRUE;
  542. HWND hWndCtrl = (HWND)lParam;
  544. //ASSERT( AFX_IDM_FIRST_MDICHILD == 0xFF00 );
  545. if (hWndCtrl == NULL && (LOWORD(wParam) & 0xf000) == 0xf000)
  546. {
  547. m_hookWatchMDI._Surface( true );
  548. ::SendMessage( m_hWndMDIClient, WM_SETREDRAW, 0, 0 );
  549. DefWindowProc( WM_COMMAND, wParam, lParam );
  550. ::SendMessage( m_hWndMDIClient, WM_SETREDRAW, 1, 0 );
  551. m_hookWatchMDI._Surface( false );
  552. return TRUE;
  553. }
  554. return FALSE;
  555. }
  556. }; // class CExtNCW
  558. template < >
  559. class CExtNCW < CExtResizableDialog >
  560. : public CExtResizableDialog
  561. , public CExtNcFrameImpl
  562. {
  563. public:
  564. CExtNCW()
  565. {
  566. }
  567. CExtNCW(
  568. UINT nIDTemplate,
  569. CWnd * pParentWnd = NULL
  570. )
  571. : CExtResizableDialog( nIDTemplate, pParentWnd )
  572. {
  573. }
  574. CExtNCW(
  575. __EXT_MFC_SAFE_LPCTSTR lpszTemplateName,
  576. CWnd * pParentWnd = NULL
  577. )
  578. : CExtResizableDialog( lpszTemplateName, pParentWnd )
  579. {
  580. }
  581. virtual ~CExtNCW()
  582. {
  583. }
  584. virtual HWND NcFrameImpl_OnQueryHWND()
  585. {
  586. return GetSafeHwnd();
  587. }
  588. protected:
  589. virtual void PreSubclassWindow()
  590. {
  591. CExtResizableDialog::PreSubclassWindow();
  592. CExtNcFrameImpl::PreSubclassWindow();
  593. }
  594. virtual void PostNcDestroy()
  595. {
  596. CExtNcFrameImpl::PostNcDestroy();
  597. CExtResizableDialog::PostNcDestroy();
  598. }
  599. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  600. {
  601. HWND hWndOwn = m_hWnd;
  602. LRESULT lResult = 0;
  603. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  604. return lResult;
  605. if( ! ::IsWindow( hWndOwn ) )
  606. return lResult;
  607. if( ! NcFrameImpl_IsSupported() )
  608. return CExtResizableDialog::WindowProc( message, wParam, lParam );
  609. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  610. return lResult;
  611. lResult = CExtResizableDialog::WindowProc( message, wParam, lParam );
  612. if( ! ::IsWindow( hWndOwn ) )
  613. return lResult;
  614. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  615. return lResult;
  616. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  617. return lResult;
  618. }
  619. public:
  620. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  621. {
  622. ASSERT_VALID( this );
  623. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  624. }
  625. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  626. {
  627. ASSERT_VALID( this );
  628. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  629. }
  630. virtual void CalcWindowRect(
  631. LPRECT lpClientRect,
  632. UINT nAdjustType = CWnd::adjustBorder
  633. )
  634. {
  635. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  636. }
  638. virtual bool NcFrameImpl_GetMinMaxInfo(
  639. LPMINMAXINFO pMMI
  640. ) const
  641. {
  642. return CExtResizableDialog::NcFrameImpl_GetMinMaxInfo( pMMI );
  643. }
  644. }; // class CExtNCW
  646. template < >
  647. class CExtNCW < CExtResizablePropertySheet >
  648. : public CExtResizablePropertySheet
  649. , public CExtNcFrameImpl
  650. {
  651. public:
  652. CExtNCW()
  653. {
  654. }
  655. CExtNCW(
  656. UINT nIDCaption,
  657. CWnd *pParentWnd = NULL,
  658. UINT iSelectPage = 0
  659. )
  660. : CExtResizablePropertySheet( nIDCaption, pParentWnd, iSelectPage )
  661. {
  662. }
  663. CExtNCW(
  664. __EXT_MFC_SAFE_LPCTSTR pszCaption,
  665. CWnd *pParentWnd = NULL,
  666. UINT iSelectPage = 0
  667. )
  668. : CExtResizablePropertySheet( pszCaption, pParentWnd, iSelectPage )
  669. {
  670. }
  671. virtual ~CExtNCW()
  672. {
  673. }
  674. virtual HWND NcFrameImpl_OnQueryHWND()
  675. {
  676. return GetSafeHwnd();
  677. }
  678. protected:
  679. virtual void PreSubclassWindow()
  680. {
  681. CExtResizablePropertySheet::PreSubclassWindow();
  682. CExtNcFrameImpl::PreSubclassWindow();
  683. }
  684. virtual void PostNcDestroy()
  685. {
  686. CExtNcFrameImpl::PostNcDestroy();
  687. CExtResizablePropertySheet::PostNcDestroy();
  688. }
  689. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  690. {
  691. HWND hWndOwn = m_hWnd;
  692. LRESULT lResult = 0;
  693. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  694. return lResult;
  695. if( ! ::IsWindow( hWndOwn ) )
  696. return lResult;
  697. if( ! NcFrameImpl_IsSupported() )
  698. return CExtResizablePropertySheet::WindowProc( message, wParam, lParam );
  699. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  700. return lResult;
  701. lResult = CExtResizablePropertySheet::WindowProc( message, wParam, lParam );
  702. if( ! ::IsWindow( hWndOwn ) )
  703. return lResult;
  704. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  705. return lResult;
  706. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  707. return lResult;
  708. }
  709. public:
  710. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  711. {
  712. ASSERT_VALID( this );
  713. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  714. }
  715. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  716. {
  717. ASSERT_VALID( this );
  718. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  719. }
  720. virtual void CalcWindowRect(
  721. LPRECT lpClientRect,
  722. UINT nAdjustType = CWnd::adjustBorder
  723. )
  724. {
  725. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  726. }
  728. virtual bool NcFrameImpl_GetMinMaxInfo(
  729. LPMINMAXINFO pMMI
  730. ) const
  731. {
  732. return CExtResizablePropertySheet::NcFrameImpl_GetMinMaxInfo( pMMI );
  733. }
  734. }; // class CExtNCW
  736. template < >
  737. class CExtNCW < CFileDialog >
  738. : public CFileDialog
  739. , public CExtNcFrameImpl
  740. {
  741. public:
  742. CExtNCW(
  743. BOOL bOpenFileDialog,
  744. __EXT_MFC_SAFE_LPCTSTR lpszDefExt = NULL,
  745. __EXT_MFC_SAFE_LPCTSTR lpszFileName = NULL,
  746. DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
  747. __EXT_MFC_SAFE_LPCTSTR lpszFilter = NULL,
  748. CWnd* pParentWnd = NULL
  749. )
  750. : CFileDialog( 
  751. bOpenFileDialog, 
  752. lpszDefExt, 
  753. lpszFileName, 
  754. dwFlags, 
  755. lpszFilter, 
  756. pParentWnd 
  757. )
  758. {
  759. }
  760. virtual ~CExtNCW()
  761. {
  762. }
  763. virtual HWND NcFrameImpl_OnQueryHWND()
  764. {
  765. return GetSafeHwnd();
  766. }
  767. protected:
  768. virtual void PreSubclassWindow()
  769. {
  770. CFileDialog::PreSubclassWindow();
  771. CExtNcFrameImpl::PreSubclassWindow();
  772. }
  773. virtual void PostNcDestroy()
  774. {
  775. CExtNcFrameImpl::PostNcDestroy();
  776. CFileDialog::PostNcDestroy();
  777. }
  778. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  779. {
  780. HWND hWndOwn = m_hWnd;
  781. LRESULT lResult = 0;
  782. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  783. return lResult;
  784. if( ! ::IsWindow( hWndOwn ) )
  785. return lResult;
  786. if( ! NcFrameImpl_IsSupported() )
  787. return CFileDialog::WindowProc( message, wParam, lParam );
  788. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  789. return lResult;
  790. lResult = CFileDialog::WindowProc( message, wParam, lParam );
  791. if( ! ::IsWindow( hWndOwn ) )
  792. return lResult;
  793. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  794. return lResult;
  795. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  796. return lResult;
  797. }
  798. public:
  799. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  800. {
  801. ASSERT_VALID( this );
  802. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  803. }
  804. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  805. {
  806. ASSERT_VALID( this );
  807. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  808. }
  809. virtual void CalcWindowRect(
  810. LPRECT lpClientRect,
  811. UINT nAdjustType = CWnd::adjustBorder
  812. )
  813. {
  814. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  815. }
  816. }; // class CExtNCW
  818. template < >
  819. class CExtNCW < CPrintDialog >
  820. : public CPrintDialog
  821. , public CExtNcFrameImpl
  822. {
  823. public:
  824. CExtNCW(
  825. BOOL bPrintSetupOnly,
  826. DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_HIDEPRINTTOFILE | PD_NOSELECTION,
  827. CWnd* pParentWnd = NULL
  828. )
  829. : CPrintDialog(
  830. bPrintSetupOnly,
  831. dwFlags,
  832. pParentWnd
  833. )
  834. {
  835. }
  836. virtual ~CExtNCW()
  837. {
  838. }
  839. virtual HWND NcFrameImpl_OnQueryHWND()
  840. {
  841. return GetSafeHwnd();
  842. }
  843. protected:
  844. virtual void PreSubclassWindow()
  845. {
  846. CPrintDialog::PreSubclassWindow();
  847. CExtNcFrameImpl::PreSubclassWindow();
  848. }
  849. virtual void PostNcDestroy()
  850. {
  851. CExtNcFrameImpl::PostNcDestroy();
  852. CPrintDialog::PostNcDestroy();
  853. }
  854. virtual LRESULT WindowProc( UINT message, WPARAM wParam, LPARAM lParam )
  855. {
  856. HWND hWndOwn = m_hWnd;
  857. LRESULT lResult = 0;
  858. if( NcFrameImpl_FilterWindowProc( lResult, message, wParam, lParam ) )
  859. return lResult;
  860. if( ! ::IsWindow( hWndOwn ) )
  861. return lResult;
  862. if( ! NcFrameImpl_IsSupported() )
  863. return CPrintDialog::WindowProc( message, wParam, lParam );
  864. if( NcFrameImpl_PreWindowProc( lResult, message, wParam, lParam ) )
  865. return lResult;
  866. lResult = CPrintDialog::WindowProc( message, wParam, lParam );
  867. if( ! ::IsWindow( hWndOwn ) )
  868. return lResult;
  869. if( CWnd::FromHandlePermanent(hWndOwn) == NULL )
  870. return lResult;
  871. NcFrameImpl_PostWindowProc( lResult, message, wParam, lParam );
  872. return lResult;
  873. }
  874. public:
  875. BOOL GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  876. {
  877. ASSERT_VALID( this );
  878. return CExtNcFrameImpl::GetWindowPlacement( pWP );
  879. }
  880. BOOL SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  881. {
  882. ASSERT_VALID( this );
  883. return CExtNcFrameImpl::SetWindowPlacement( pWP );
  884. }
  885. virtual void CalcWindowRect(
  886. LPRECT lpClientRect,
  887. UINT nAdjustType = CWnd::adjustBorder
  888. )
  889. {
  890. NcFrameImpl_CalcWindowRect( lpClientRect, nAdjustType );
  891. }
  892. }; // class CExtNCW
  894. #endif // (!defined __EXT_MFC_NO_NC_FRAME )
  896. #endif // __EXT_NC_FRAME_H