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

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

界面编程

开发平台：

Visual C++

ExtNcFrame.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_NC_FRAME_H)
  25. #include <ExtNcFrame.h>
  26. #endif
  28. #if (!defined __EXT_PAINT_MANAGER_H)
  29. #include <ExtPaintManager.h>
  30. #endif
  32. #if (!defined __EXT_MENUCONTROLBAR_H)
  33. #include <ExtMenuControlBar.h>
  34. #endif
  36. #if (!defined __AFXPRIV_H__)
  37. #include <AfxPriv.h>
  38. #endif 
  40. #if _MFC_VER < 0x700
  41. #include <../src/AfxImpl.h>
  42. #else
  43. #ifndef __AFXSTATE_H__
  44. #include <../src/mfc/afxstat_.h>
  45. #endif
  46. #include <../src/mfc/AfxImpl.h>
  47. #endif
  49. // disable warning 4706
  50. #pragma warning( push )
  51. #pragma warning ( disable : 4706 )
  52. #include <multimon.h>
  53. // rollback warning 4706
  54. #pragma warning( pop )
  56. #ifdef _DEBUG
  57. #define new DEBUG_NEW
  58. #undef THIS_FILE
  59. static char THIS_FILE[] = __FILE__;
  60. #endif
  62. #if (!defined __EXT_MFC_NO_NC_FRAME )
  64. IMPLEMENT_CExtPmBridge_MEMBERS_GENERIC( CExtPmBridgeNC )
  66. CExtPmBridgeNC::CExtPmBridgeNC(
  67. CExtNcFrameImpl * pNcFrameImpl // = NULL
  68. )
  69. : m_pNcFrameImpl( pNcFrameImpl )
  70. {
  71. PmBridge_Install();
  72. }
  74. CExtPmBridgeNC::~CExtPmBridgeNC()
  75. {
  76. PmBridge_Uninstall();
  77. }
  79. const CExtNcFrameImpl * CExtPmBridgeNC::NcFrameImpl_Get() const
  80. {
  81. return m_pNcFrameImpl;
  82. }
  84. CExtNcFrameImpl * CExtPmBridgeNC::NcFrameImpl_Get()
  85. {
  86. return m_pNcFrameImpl;
  87. }
  89. void CExtPmBridgeNC::NcFrameImpl_Set(
  90. CExtNcFrameImpl * pNcFrameImpl
  91. )
  92. {
  93. m_pNcFrameImpl = pNcFrameImpl;
  94. }
  96. HWND CExtPmBridgeNC::PmBridge_GetSafeHwnd() const
  97. {
  98. if( m_pNcFrameImpl != NULL )
  99. {
  100. HWND hWnd =
  101. m_pNcFrameImpl->NcFrameImpl_OnQueryHWND();
  102. return hWnd;
  103. }
  104. return NULL;
  105. }
  107. void CExtPmBridgeNC::PmBridge_OnPaintManagerChanged(
  108. CExtPaintManager * pGlobalPM
  109. )
  110. {
  111. if( m_pNcFrameImpl == NULL )
  112. return;
  113. m_pNcFrameImpl->NcFrameImpl_SyncThemeSettings( pGlobalPM, false );
  114. if( ! m_pNcFrameImpl->m_bNcFrameImpl_PivotPmSyncMode )
  115. {
  116. if( g_PaintManager.m_nInsallPaintManagerCounter != 0 )
  117. {
  118. HWND hWnd = PmBridge_GetSafeHwnd();
  119. if( hWnd != NULL )
  120. ::PostMessage( hWnd, g_PaintManager.m_nMsgPaintManagerChanged, 0L, 0L );
  121. }
  122. else
  123. _AdjustThemeSettings();
  124. CExtPmBridge::PmBridge_OnPaintManagerChanged( pGlobalPM );
  125. }
  126. m_pNcFrameImpl->NcFrameImpl_SyncThemeSettings( pGlobalPM, true );
  127. }
  129. #if (! defined SPI_GETSCREENSAVERRUNNING)
  130. #define SPI_GETSCREENSAVERRUNNING 114
  131. #endif
  133. void CExtPmBridgeNC::PmBridge_OnDisplayChange(
  134. CExtPaintManager * pGlobalPM,
  135. CWnd * pWndNotifySrc,
  136. INT nDepthBPP,
  137. CPoint ptSizes
  138. )
  139. {
  140. CExtPmBridge::PmBridge_OnDisplayChange(
  141. pGlobalPM,
  142. pWndNotifySrc,
  143. nDepthBPP,
  144. ptSizes
  145. );
  146. // if( g_PaintManager.m_bIsWinVistaOrLater )
  147. // Sleep( 3000 );
  148. CExtNcFrameImpl * pNCFI = NcFrameImpl_Get();
  149. if( pNCFI == NULL )
  150. return;
  151. CWnd * pWndFrameImpl = pNCFI->NcFrameImpl_GetFrameWindow();
  152. if( pWndFrameImpl->GetSafeHwnd() == NULL )
  153. return;
  154. if( ( pWndFrameImpl->GetStyle() & WS_CHILD ) != 0 )
  155. return;
  156. if( g_PaintManager.m_bIsWin2000orLater )
  157. {
  158. BOOL bScreenSavingIsRunning = FALSE;
  159. if( ! SystemParametersInfo( SPI_GETSCREENSAVERRUNNING, 0, &bScreenSavingIsRunning, 0 ) )
  160. bScreenSavingIsRunning = FALSE;
  161. if( bScreenSavingIsRunning )
  162. return;
  163. }
  164. else
  165. {
  166. CPoint ptCursor( 0, 0 );
  167. if( ! ::GetCursorPos( &ptCursor) )
  168. return;
  169. }
  170. _AdjustThemeSettings();
  171. }
  173. void CExtPmBridgeNC::PmBridge_OnThemeChanged(
  174. CExtPaintManager * pGlobalPM,
  175. CWnd * pWndNotifySrc,
  176. WPARAM wParam,
  177. LPARAM lParam
  178. )
  179. {
  180. CExtPmBridge::PmBridge_OnThemeChanged(
  181. pGlobalPM,
  182. pWndNotifySrc,
  183. wParam,
  184. lParam
  185. );
  186. // if( g_PaintManager.m_bIsWinVistaOrLater )
  187. // Sleep( 1000 );
  188. _AdjustThemeSettings();
  189. }
  191. void CExtPmBridgeNC::_AdjustThemeSettings()
  192. {
  193. if( m_pNcFrameImpl == NULL
  194. || m_pNcFrameImpl->m_bNcFrameImpl_InAdjustAdjustThemeSettings
  195. )
  196. return;
  198. m_pNcFrameImpl->m_bNcFrameImpl_CreatePassed = true; // IMPORTANT: this may not be set earlier if frame is started as non-skinned
  199. HWND hWndOwn = PmBridge_GetSafeHwnd();
  200. if( hWndOwn == NULL )
  201. return;
  202. ASSERT( ::IsWindow( hWndOwn ) );
  204. m_pNcFrameImpl->m_bNcFrameImpl_InAdjustAdjustThemeSettings = true;
  206. WINDOWPLACEMENT _wp;
  207. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  208. _wp.length = sizeof(WINDOWPLACEMENT);
  209. CExtNcFrameImpl::stat_GetWindowPlacement(
  210. hWndOwn,
  211. _wp
  212. );
  213. if( ( ::__EXT_MFC_GetWindowLong( hWndOwn, GWL_STYLE ) & WS_VISIBLE ) == 0 )
  214. _wp.showCmd = SW_HIDE;
  216. CWnd * pWndFrameImpl = (CWnd *)m_pNcFrameImpl->NcFrameImpl_GetFrameWindow();
  217. pWndFrameImpl->ModifyStyle( 0, WS_CAPTION|WS_BORDER, 0 );
  218. m_pNcFrameImpl->m_bNcFrameImpl_IsActive = false;
  219. if( pWndFrameImpl != NULL )
  220. {
  221. HWND hWndFocus = ::GetFocus();
  222. if( hWndFocus != NULL
  223. && ( pWndFrameImpl->m_hWnd == hWndFocus
  224. || ::IsChild( pWndFrameImpl->m_hWnd, hWndFocus )
  225. )
  226. )
  227. m_pNcFrameImpl->m_bNcFrameImpl_IsActive = true;
  228. }
  230. DWORD dwInitialStyle = m_pNcFrameImpl->NcFrameImpl_GetInitialStyle();
  231. DWORD dwCurrentStyle = dwInitialStyle; // ::__EXT_MFC_GetWindowLong( hWndOwn, GWL_STYLE );
  233. HWND hWndSurface = NULL;
  234. if( (dwCurrentStyle&(WS_CHILD|WS_VISIBLE)) == WS_VISIBLE
  235. && (! m_pNcFrameImpl->m_bNcFrameImpl_PivotPmSyncMode )
  236. // && (! m_pNcFrameImpl->NcFrameImpl_IsDwmCaptionReplacement() )
  237. )
  238. {
  239. CRect rcSurface;
  240. ::GetWindowRect( hWndOwn, &rcSurface );
  241. hWndSurface =
  242. ::CreateWindowEx(
  243. 0, _T("Static"), _T(""), WS_POPUP,
  244. rcSurface.left,
  245. rcSurface.top,
  246. rcSurface.Width()
  247. + ( ( _wp.showCmd == SW_SHOWNORMAL
  248. && g_PaintManager.m_bIsWinXPorLater
  249. ) ? 1 : 0  // +1 for recomputing Window HRGN on WindowsXP or Later
  250. ),
  251. rcSurface.Height(),
  252. hWndOwn, (HMENU)NULL, ::AfxGetInstanceHandle(), NULL
  253. );
  254. if( hWndSurface != NULL )
  255. {
  256. ::EnableWindow( hWndSurface, FALSE );
  257. ::ShowWindow( hWndSurface, SW_SHOWNOACTIVATE );
  258. } // if( hWndSurface != NULL )
  259. } // if( (dwCurrentStyle&(WS_CHILD|WS_VISIBLE)) == WS_VISIBLE )
  261. CExtNcFrameImpl::NcLock _NcLock( * m_pNcFrameImpl );
  262. ::SetWindowRgn( hWndOwn, NULL, TRUE );
  263. if( ! ::IsWindow( hWndOwn ) )
  264. return;
  265. _NcLock.UnlockNow();
  266. if( m_pNcFrameImpl->NcFrameImpl_IsDwmCaptionReplacement() )
  267. m_pNcFrameImpl->NcFrameImpl_AdjustVistaDwmCompatibilityIssues();
  268. else
  269. m_pNcFrameImpl->NcFrameImpl_SetupRgn();
  270. if( pWndFrameImpl != NULL
  271. && pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) )
  272. && g_PaintManager.m_UxTheme.IsAppThemed()
  273. )
  274. {
  275. CRect rc;
  276. pWndFrameImpl->GetWindowRect( &rc );
  277. pWndFrameImpl->GetParent()->ScreenToClient( &rc );
  278. rc.left ++;
  279. pWndFrameImpl->MoveWindow( &rc, FALSE );
  280. rc.left --;
  281. pWndFrameImpl->MoveWindow( &rc, FALSE );
  282. }
  284. m_pNcFrameImpl->NcFrameImpl_RecalcNcFrame();
  285. CWnd * pWndPermanent = CWnd::FromHandlePermanent( hWndOwn );
  286. if( pWndPermanent != NULL )
  287. {
  288. CFrameWnd * pFrameWnd = DYNAMIC_DOWNCAST( CFrameWnd, pWndPermanent );
  289. if( pFrameWnd != NULL )
  290. pFrameWnd->RecalcLayout();
  291. }
  293. if( m_pNcFrameImpl->NcFrameImpl_IsSupported()
  294. && ( ! m_pNcFrameImpl->NcFrameImpl_IsDwmCaptionReplacement() )
  295. )
  296. {
  297. m_pNcFrameImpl->NcFrameImpl_SetupRgn( NULL );
  298. ::RedrawWindow(
  299. hWndOwn, NULL, NULL,
  300. RDW_INVALIDATE|RDW_ERASE
  301. |RDW_FRAME
  302. |RDW_ALLCHILDREN
  303. );
  304. } // if( m_pNcFrameImpl->NcFrameImpl_IsSupported() ...
  305. else
  306. {
  307. m_pNcFrameImpl->NcFrameImpl_RecalcNcFrame();
  308. if( (dwCurrentStyle&(WS_CHILD|WS_VISIBLE)) == WS_VISIBLE )
  309. {
  310. switch( _wp.showCmd )
  311. {
  312. case SW_SHOWNORMAL:
  313. if( g_PaintManager.m_bIsWinXPorLater )
  314. {
  315. CRect rc = _wp.rcNormalPosition;
  316. rc.right++;
  317. MoveWindow( hWndOwn, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, FALSE );
  318. rc.right--;
  319. MoveWindow( hWndOwn, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, FALSE );
  320. } // if( g_PaintManager.m_bIsWinXPorLater )
  321. break;
  322. } // switch( _wp.showCmd )
  323. } // if( (dwCurrentStyle&(WS_CHILD|WS_VISIBLE)) == WS_VISIBLE )
  324. } // else from if( m_pNcFrameImpl->NcFrameImpl_IsSupported() ...
  325. if( m_pNcFrameImpl->NcFrameImpl_IsDwmCaptionReplacement() )
  326. m_pNcFrameImpl->NcFrameImpl_RecalcNcFrame();
  327. else if( m_pNcFrameImpl->NcFrameImpl_IsSupported() )
  328. CExtNcFrameImpl::stat_SetWindowPlacement(
  329. hWndOwn,
  330. _wp
  331. );
  333. bool bContinueRecalc = true;
  334. while( bContinueRecalc )
  335. {
  336. bContinueRecalc = false;
  337. MSG _msg;
  338. while( ::PeekMessage( &_msg, NULL, WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED, PM_NOREMOVE ) )
  339. {
  340. if( ! ::GetMessage( &_msg, NULL, WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED ) )
  341. break;
  342. ::DispatchMessage( &_msg );
  343. bContinueRecalc = true;
  344. }
  345. while( ::PeekMessage( &_msg, NULL, WM_NCCALCSIZE, WM_NCCALCSIZE, PM_NOREMOVE ) )
  346. {
  347. if( ! ::GetMessage( &_msg, NULL, WM_NCCALCSIZE, WM_NCCALCSIZE ) )
  348. break;
  349. ::DispatchMessage( &_msg );
  350. bContinueRecalc = true;
  351. }
  352. while( ::PeekMessage( &_msg, NULL, WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED, PM_NOREMOVE ) )
  353. {
  354. if( ! ::GetMessage( &_msg, NULL, WM_WINDOWPOSCHANGING, WM_WINDOWPOSCHANGED ) )
  355. break;
  356. ::DispatchMessage( &_msg );
  357. bContinueRecalc = true;
  358. }
  359. while( ::PeekMessage( &_msg, NULL, WM_SIZE, WM_SIZE, PM_NOREMOVE ) )
  360. {
  361. if( ! ::GetMessage( &_msg, NULL, WM_SIZE, WM_SIZE ) )
  362. break;
  363. ::DispatchMessage( &_msg );
  364. bContinueRecalc = true;
  365. }
  366. } // while( bContinueRecalc )
  367. if( hWndSurface != NULL )
  368. {
  369. ::DestroyWindow( hWndSurface );
  370. CExtPaintManager::stat_PassPaintMessages();
  371. }
  373. if( ! m_pNcFrameImpl->NcFrameImpl_IsDwmBased() )
  374. {
  375. HWND hWndCheckZoomState = m_pNcFrameImpl->NcFrameImpl_OnQueryHWND();
  376. if( hWndCheckZoomState != NULL
  377. && ::IsWindow( hWndCheckZoomState )
  378. && ::IsZoomed( hWndCheckZoomState )
  379. && (! m_pNcFrameImpl->NcFrameImpl_IsSupported() )
  380. )
  381. {
  382. CExtPaintManager::monitor_parms_t _mp;
  383. CExtPaintManager::stat_GetMonitorParms( _mp, hWndCheckZoomState );
  384. ::SendMessage( hWndCheckZoomState, WM_SETREDRAW, 0L, 0L );
  385. MINMAXINFO _mmi;
  386. ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  387. _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  388. _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  389. _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width();
  390. _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height();
  391. _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  392. _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  393. _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  394. _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  395. ::SendMessage( hWndCheckZoomState, WM_GETMINMAXINFO, 0, LPARAM(&_mmi) );
  396. CSize maxSize(
  397. max( _mmi.ptMaxTrackSize.x, _mp.m_rcWorkArea.Width() ),
  398. max( _mmi.ptMaxTrackSize.y, _mp.m_rcWorkArea.Height() )
  399. );
  400. CRect rcMax( _mmi.ptMaxPosition, maxSize );
  401. WINDOWPLACEMENT _wp, _wp2;
  402. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  403. _wp.length = sizeof(WINDOWPLACEMENT);
  404. ::GetWindowPlacement( hWndCheckZoomState, &_wp );
  405. ::memcpy( &_wp2, &_wp, sizeof(WINDOWPLACEMENT) );
  406. ::CopyRect( &_wp2.rcNormalPosition, &rcMax );
  407. _wp2.showCmd = SW_SHOWMAXIMIZED;
  408. ::SetWindowPlacement( hWndCheckZoomState, &_wp2 );
  409. _wp.showCmd = SW_SHOWMAXIMIZED;
  410. ::SendMessage( hWndCheckZoomState, WM_SETREDRAW, 1L, 0L );
  411. ::SetWindowPlacement( hWndCheckZoomState, &_wp );
  412. }
  413. }
  415. m_pNcFrameImpl->m_bNcFrameImpl_InAdjustAdjustThemeSettings = false;
  416. }
  418. CExtNcFrameImpl::NcLock::NcLock( const CExtNcFrameImpl & _NcFrameImpl )
  419. : m_NcFrameImpl( _NcFrameImpl )
  420. , m_bLocked( true )
  421. {
  422. m_NcFrameImpl.NcFrameImpl_NcLock( true );
  423. }
  425. CExtNcFrameImpl::NcLock::~NcLock()
  426. {
  427. UnlockNow();
  428. }
  430. void CExtNcFrameImpl::NcLock::UnlockNow()
  431. {
  432. if( ! m_bLocked )
  433. return;
  434. m_bLocked = false;
  435. m_NcFrameImpl.NcFrameImpl_NcLock( false );
  436. }
  438. const UINT CExtNcFrameImpl::g_nMsgFindExtNcFrameImpl =
  439. ::RegisterWindowMessage(
  440. _T("CExtNcFrameImpl::g_nMsgFindExtNcFrameImpl")
  441. );
  443. CExtNcFrameImpl::CExtNcFrameImpl()
  444. : m_bNcFrameImpl_PivotPmSyncMode( false )
  445. , m_bNcFrameImpl_IsActive( false )
  446. , m_bNcFrameImpl_RgnSet( false )
  447. , m_bNcFrameImpl_RestoreBorder( false )
  448. , m_bNcFrameImpl_DelatayedFrameRecalc( false )
  449. , m_bNcFrameImpl_IsEnabled( true )
  450. , m_bNcFrameImpl_IsDwmBased( true )
  451. , m_bNcFrameImpl_Resizing( true )
  452. , m_bNcFrameImpl_Moving( true )
  453. , m_bNcFrameImpl_ResizingLoopTracking( false )
  454. , m_bNcFrameImpl_MovingLoopTracking( false )
  455. , m_bNcFrameImpl_QuickWindowPlacement( false )
  456. , m_rcNcFrameImpl_ScClose( 0, 0, 0, 0 )
  457. , m_rcNcFrameImpl_ScMaximize( 0, 0, 0, 0 )
  458. , m_rcNcFrameImpl_ScMinimize( 0, 0, 0, 0 )
  459. , m_rcNcFrameImpl_ScHelp( 0, 0, 0, 0 )
  460. , m_rcNcFrameImpl_Text( 0, 0, 0, 0 )
  461. , m_rcNcFrameImpl_Icon( 0, 0, 0, 0 )
  462. , m_nNcFrameImpl_ScTrackedButtonHover( 0 )
  463. , m_nNcFrameImpl_ScTrackedButtonPressed( 0 )
  464. , m_strNcFrameImpl_TipMinimize( _T("") )
  465. , m_strNcFrameImpl_TipMaximize( _T("") )
  466. , m_strNcFrameImpl_TipRestore( _T("") )
  467. , m_strNcFrameImpl_TipClose( _T("") )
  468. , m_strNcFrameImpl_TipHelp( _T("") )
  469. , m_dwNcFrameImpl_StyleInitial( 0 )
  470. , m_dwNcFrameImpl_StyleExInitial( 0 )
  471. , m_nNcFrameImpl_Lock( 0 )
  472. , m_nNcFrameImpl_LastCheckCursorHT( HTNOWHERE )
  473. , m_ptNcFrameImpl_LastCheckCursor( -32767, -32767 )
  474. , m_pNcFrameImplBridge( NULL )
  475. , m_bNcFrameImpl_HelperInsideNcHitTest( false )
  476. , m_bNcFrameImpl_RestoreEnabledState( false )
  477. , m_nNcFrameImpl_LastShowCmd( SW_HIDE )
  478. , m_bNcFrameImpl_NcInitPassed( false )
  479. , m_nNcFrameImpl_LastExternalNcHT( UINT(-1) )
  480. , m_rcNcFrameImpl_LastExternalNcHT( -1, -1, -1, -1 )
  481. , m_bNcFrameImpl_DwmSurfaceInitializationComplete( false )
  482. , m_bNcFrameImpl_CreatePassed( false )
  483. , m_bNcFrameImpl_AssigningRGN( false )
  484. , m_bNcFrameImpl_InAdjustAdjustThemeSettings( false )
  485. {
  486. ::memset( &m_NcFrameImpl_MinMaxInfo_Cache, 0, sizeof(MINMAXINFO) );
  487. m_BridgeNC.NcFrameImpl_Set( this );
  488. m_wndNcFrameImpl_Tip.SetTipStyle( CExtPopupMenuTipWnd::__ETS_RECTANGLE_NO_ICON );
  489. m_wndNcFrameImpl_Tip.SetShadowSize( 0 );
  490. }
  492. CExtNcFrameImpl::~CExtNcFrameImpl()
  493. {
  494. m_wndNcFrameImpl_Tip.Hide();
  495. if( m_wndNcFrameImpl_Tip.GetSafeHwnd() != NULL )
  496. m_wndNcFrameImpl_Tip.DestroyWindow();
  497. m_BridgeNC.NcFrameImpl_Set( NULL );
  498. NcFrameImpl_MapHtRects_Clean();
  499. }
  501. void CExtNcFrameImpl::NcFrameImpl_SyncThemeSettings( CExtPaintManager * pPM, bool bPostNotification )
  502. {
  503. ASSERT( this != NULL );
  504. pPM;
  505. bPostNotification;
  506. }
  508. bool CExtNcFrameImpl::NcFrameImpl_GetWindowPlacement( WINDOWPLACEMENT & _wp ) const
  509. {
  510. ASSERT( this != NULL );
  511. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  512. if( pWndFrameImpl->GetSafeHwnd() == NULL )
  513. return false;
  514. ASSERT_VALID( pWndFrameImpl );
  515. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  516. _wp.length = sizeof(WINDOWPLACEMENT);
  517. bool bRetVal = ::GetWindowPlacement( pWndFrameImpl->m_hWnd, &_wp ) ? true : false;
  518. return bRetVal;
  519. }
  521. bool CExtNcFrameImpl::NcFrameImpl_SetWindowPlacement( const WINDOWPLACEMENT & _wp )
  522. {
  523. ASSERT( this != NULL );
  524. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  525. if( pWndFrameImpl->GetSafeHwnd() == NULL )
  526. return false;
  527. bool bRetVal = ::SetWindowPlacement( pWndFrameImpl->m_hWnd, &_wp ) ? true : false;
  528. return bRetVal;
  529. }
  531. BOOL CExtNcFrameImpl::GetWindowPlacement( WINDOWPLACEMENT * pWP ) const
  532. {
  533. ASSERT( this != NULL );
  534. if( pWP == NULL )
  535. return FALSE;
  536. return NcFrameImpl_GetWindowPlacement( *pWP ) ? TRUE : FALSE;
  537. }
  539. BOOL CExtNcFrameImpl::GetWindowPlacement( WINDOWPLACEMENT & _wp ) const
  540. {
  541. ASSERT( this != NULL );
  542. return NcFrameImpl_GetWindowPlacement( _wp ) ? TRUE : FALSE;
  543. }
  545. BOOL CExtNcFrameImpl::SetWindowPlacement( const WINDOWPLACEMENT * pWP )
  546. {
  547. ASSERT( this != NULL );
  548. if( pWP == NULL )
  549. return FALSE;
  550. return NcFrameImpl_SetWindowPlacement( *pWP ) ? TRUE : FALSE;
  551. }
  553. BOOL CExtNcFrameImpl::SetWindowPlacement( const WINDOWPLACEMENT & _wp )
  554. {
  555. ASSERT( this != NULL );
  556. return NcFrameImpl_SetWindowPlacement( _wp ) ? TRUE : FALSE;
  557. }
  559. bool CExtNcFrameImpl::stat_GetWindowPlacement( HWND hWnd, WINDOWPLACEMENT & _wp )
  560. {
  561. if( hWnd == NULL || ( ! ::IsWindow( hWnd ) ) )
  562. return false;
  563. bool bRetVal = false;
  564. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  565. _wp.length = sizeof(WINDOWPLACEMENT);
  566. bRetVal = ::GetWindowPlacement( hWnd, &_wp ) ? true : false;
  567. return bRetVal;
  568. }
  570. bool CExtNcFrameImpl::stat_SetWindowPlacement( HWND hWnd, const WINDOWPLACEMENT & _wp )
  571. {
  572. if( hWnd == NULL || ( ! ::IsWindow( hWnd ) ) )
  573. return false;
  574. bool bRetVal = false;
  575. bRetVal = ::SetWindowPlacement( hWnd, &_wp ) ? true : false;
  576. return bRetVal;
  577. }
  579. void CExtNcFrameImpl::NcFrameImpl_CalcWindowRect(
  580. LPRECT lpClientRect,
  581. UINT nAdjustType // = UINT(CWnd::adjustBorder)
  582. )
  583. {
  584. ASSERT( this != NULL );
  585. ASSERT( lpClientRect != NULL );
  586. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  587. ASSERT_VALID( pWndFrameImpl );
  588. if( NcFrameImpl_IsSupported() && ( ! NcFrameImpl_IsDwmBased() ) )
  589. {
  590. CExtPaintManager * pPM = NcFrameImpl_GetPM();
  591. ASSERT_VALID( pPM );
  592. CRect rcInflate, rcTmp;
  593. pPM->NcFrame_GetMetrics( rcInflate, rcTmp, pWndFrameImpl );
  594. bool bFrameActive = NcFrameImpl_IsActive();
  595. INT nAdjustCaptionHeight = 0;
  596. // if( m_pNcFrameImplBridge != NULL
  597. // && m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryCaptionMergeMode()
  598. // )
  599. {
  600. nAdjustCaptionHeight =
  601. pPM->NcFrame_GetCaptionHeight(
  602. bFrameActive,
  603. pWndFrameImpl
  604. );
  605. rcInflate.top += nAdjustCaptionHeight;
  606. }
  607. lpClientRect->top     -=  rcInflate.top;
  608. lpClientRect->bottom  +=  rcInflate.bottom;
  609. lpClientRect->left    -=  rcInflate.left;
  610. lpClientRect->right   +=  rcInflate.right;
  611. }
  612. else
  613. {
  614. DWORD dwExStyle = pWndFrameImpl->GetExStyle();
  615. if( nAdjustType == 0 )
  616. dwExStyle &= ~WS_EX_CLIENTEDGE;
  617. ::AdjustWindowRectEx( lpClientRect, pWndFrameImpl->GetStyle(), FALSE, dwExStyle );
  618. }
  619. }
  621. bool CExtNcFrameImpl::stat_SaveWindowRect(
  622. HWND hWnd,
  623. __EXT_MFC_SAFE_LPCTSTR strSection,
  624. __EXT_MFC_SAFE_LPCTSTR strEntry
  625. )
  626. {
  627. if( LPCTSTR( strSection ) == NULL
  628. || LPCTSTR( strEntry ) == NULL
  629. || _tcslen( LPCTSTR( strSection ) ) == 0
  630. || _tcslen( LPCTSTR( strEntry ) ) == 0
  631. || hWnd == NULL
  632. || ( ! ::IsWindow( hWnd ) )
  633. )
  634. return false;
  635. CExtSafeString strWP;
  636. WINDOWPLACEMENT _wp;
  637. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  638. _wp.length = sizeof(WINDOWPLACEMENT);
  639. CExtControlBar::stat_GetWindowPlacement( hWnd, _wp );
  640. RECT & rc = _wp.rcNormalPosition;
  641. strWP.Format( _T("%d,%d,%d,%d,%d,%d"), rc.left, rc.top, rc.right, rc.bottom, _wp.showCmd, _wp.flags );
  642. ::AfxGetApp()->WriteProfileString( strSection, strEntry, __EXT_MFC_SAFE_LPCTSTR( strWP ) );
  643. return true;
  644. }
  646. bool CExtNcFrameImpl::stat_LoadWindowRect(
  647. HWND hWnd,
  648. __EXT_MFC_SAFE_LPCTSTR strSection,
  649. __EXT_MFC_SAFE_LPCTSTR strEntry,
  650. bool bForceHideWindow // = false
  651. )
  652. {
  653. if( LPCTSTR( strSection ) == NULL
  654. || LPCTSTR( strEntry ) == NULL
  655. || _tcslen( LPCTSTR( strSection ) ) == 0
  656. || _tcslen( LPCTSTR( strEntry ) ) == 0
  657. || hWnd == NULL
  658. || ( ! ::IsWindow( hWnd ) )
  659. )
  660. return false;
  661. CExtSafeString strWP;
  662. WINDOWPLACEMENT _wp;
  663. strWP = ::AfxGetApp()->GetProfileString( strSection, strEntry );
  664. if( strWP.IsEmpty() )
  665. return false;
  666. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  667. _wp.length = sizeof(WINDOWPLACEMENT);
  668. CExtControlBar::stat_GetWindowPlacement( hWnd, _wp );
  669. RECT & rc = _wp.rcNormalPosition;
  670. if( __EXT_MFC_STSCANF(
  671. __EXT_MFC_SAFE_LPCTSTR( strWP ),
  672. __EXT_MFC_SAFE_LPCTSTR( _T("%d,%d,%d,%d,%d,%d") ),
  673. &rc.left, 
  674. &rc.top, 
  675. &rc.right, 
  676. &rc.bottom,
  677. &_wp.showCmd,
  678. &_wp.flags
  679. ) == 6
  680. )
  681. {
  682. if( bForceHideWindow )
  683. _wp.showCmd = SW_HIDE;
  684. CExtControlBar::stat_SetWindowPlacement( hWnd, _wp );
  685. }
  686. ::RedrawWindow( hWnd, NULL, NULL, RDW_INVALIDATE|RDW_ERASE|RDW_UPDATENOW|RDW_ALLCHILDREN|RDW_FRAME );
  687. return true;
  688. }
  690. void CExtNcFrameImpl::stat_MDI_GetWindowList(
  691. HWND hWndMdiClient,
  692. CList < HWND, HWND > & _list,
  693. CList < HWND, HWND > & _listWindowsToSkip,
  694. bool bAddActiveToTail,
  695. bool bIncludeEnabled,
  696. bool bIncludeDisabled,
  697. bool bIncludeIconic,
  698. bool bIncludeNonIconic,
  699. bool bIncludeWithOwner,
  700. bool bIncludeWithoutOwner,
  701. bool bIncludeVisible, // = true
  702. bool bIncludeHidden // = false
  703. )
  704. {
  705. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  706. _list.RemoveAll();
  707. BOOL bMax = FALSE;
  708. HWND hWndActiveMdiChildFrame = (HWND) ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMax );
  709. HWND hWnd = ::GetWindow( hWndMdiClient, GW_CHILD );
  710. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  711. {
  712. bool bAdd = false;
  713. bool bEnabled = ::IsWindowEnabled( hWnd ) ? true : false;
  714. if(   bEnabled  && bIncludeEnabled )
  715. bAdd = true;
  716. else if( (!bEnabled) && bIncludeDisabled )
  717. bAdd = true;
  718. if( ! bAdd )
  719. {
  720. if( hWnd == hWndActiveMdiChildFrame )
  721. hWndActiveMdiChildFrame = NULL;
  722. continue;
  723. }
  725. bAdd = false;
  726. bool bIconic = ::IsIconic( hWnd ) ? true : false;
  727. if(   bIconic   && bIncludeIconic )
  728. bAdd = true;
  729. else if( (!bIconic)  && bIncludeNonIconic )
  730. bAdd = true;
  731. if( ! bAdd )
  732. {
  733. if( hWnd == hWndActiveMdiChildFrame )
  734. hWndActiveMdiChildFrame = NULL;
  735. continue;
  736. }
  738. bAdd = false;
  739. __EXT_MFC_LONG_PTR dwStyle = ::__EXT_MFC_GetWindowLong( hWnd, GWL_STYLE );
  740. bool bVisible = ( ( dwStyle & WS_VISIBLE ) != 0 ) ? true : false;
  741. if(   bVisible  && bIncludeVisible )
  742. bAdd = true;
  743. else if( (!bVisible) && bIncludeHidden )
  744. bAdd = true;
  745. if( ! bAdd )
  746. {
  747. if( hWnd == hWndActiveMdiChildFrame )
  748. hWndActiveMdiChildFrame = NULL;
  749. continue;
  750. }
  752. bAdd = false;
  753. HWND hWndOwner = ::GetWindow( hWnd, GW_OWNER );
  754. if(  bIncludeWithOwner    && ( hWndOwner != NULL ) )
  755. bAdd = true;
  756. else if( bIncludeWithoutOwner && ( hWndOwner == NULL ) )
  757. bAdd = true;
  758. if( ! bAdd )
  759. {
  760. if( hWnd == hWndActiveMdiChildFrame )
  761. hWndActiveMdiChildFrame = NULL;
  762. continue;
  763. }
  765. bAdd = true;
  766. if( bAddActiveToTail && hWndActiveMdiChildFrame == hWnd )
  767. {
  768. if( bAdd )
  769. bAdd = false;
  770. else
  771. hWndActiveMdiChildFrame = NULL;
  772. }
  773. if( ! bAdd )
  774. continue;
  776. if( bAdd
  777. && _listWindowsToSkip.Find( hWnd )
  778. )
  779. bAdd = false;
  780. if( ! bAdd )
  781. {
  782. if( hWnd == hWndActiveMdiChildFrame )
  783. hWndActiveMdiChildFrame = NULL;
  784. continue;
  785. }
  787. if( bAdd )
  788. {
  789. TCHAR szCompare[512] = _T("");
  790. ::GetClassName(
  791. hWnd,
  792. szCompare,
  793. sizeof( szCompare )/sizeof( szCompare[0] )
  794. );
  795. if( _tcsicmp( szCompare, _T("Static") ) == 0 )
  796. bAdd = false;
  797. }
  798. if( ! bAdd )
  799. {
  800. if( hWnd == hWndActiveMdiChildFrame )
  801. hWndActiveMdiChildFrame = NULL;
  802. continue;
  803. }
  805. _list.AddTail( hWnd );
  806. }
  807. if( bAddActiveToTail && hWndActiveMdiChildFrame != NULL )
  808. _list.AddTail( hWndActiveMdiChildFrame );
  809. }
  811. INT CExtNcFrameImpl::stat_MDI_ArrangeIconic(
  812. HWND hWndMdiClient,
  813. CList < HWND, HWND > & _listWindowsToSkip
  814. )
  815. {
  816. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  817. CList < HWND, HWND > _list;
  818. stat_MDI_GetWindowList(
  819. hWndMdiClient,
  820. _list,
  821. _listWindowsToSkip,
  822. false, // bAddActiveToTail
  823. true,  // bIncludeEnabled
  824. true,  // bIncludeDisabled
  825. true,  // bIncludeIconic
  826. false, // bIncludeNonIconic
  827. false, // bIncludeWithOwner,
  828. true   // bIncludeWithoutOwner,
  829. );
  830. INT nRetVal = stat_MDI_ArrangeIconicEWL( hWndMdiClient, _list );
  831. return nRetVal;
  832. }
  834. INT CExtNcFrameImpl::stat_MDI_ArrangeIconicEWL( // explicit window list based version
  835. HWND hWndMdiClient,
  836. CList < HWND, HWND > & _list
  837. )
  838. {
  839. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  840. INT nIndex, nCount = INT( _list.GetCount() );
  841. if( nCount == 0 )
  842. return 0;
  843. INT nCaptionHeight = -1;
  844. INT nBorderHeightX2 = -1;
  845. CExtPaintManager * pPM = g_PaintManager.GetPM();
  846. ASSERT_VALID( pPM );
  847. POSITION pos = _list.GetHeadPosition();
  848. if( pos != NULL )
  849. {
  850. HWND hWnd = _list.GetNext( pos );
  851. ASSERT( hWnd != NULL && ::IsWindow( hWnd ) );
  852. CWnd * pWnd = CWnd::FromHandle( hWnd );
  853. nCaptionHeight = pPM->NcFrame_GetCaptionHeight( true, pWnd );
  854. CRect rcNcBorders, rcThemePadding;
  855. pPM->NcFrame_GetMetrics( rcNcBorders, rcThemePadding, pWnd );
  856. nBorderHeightX2 = rcNcBorders.top + rcNcBorders.bottom;
  857. }
  858. if( nCaptionHeight <= 0 )
  859. nCaptionHeight = ::GetSystemMetrics( SM_CYCAPTION );
  860. nBorderHeightX2 = ::GetSystemMetrics( SM_CYBORDER ) * 2;
  861. CSize sizeItem(
  862. ::GetSystemMetrics( SM_CXSMICON )
  863. + ::GetSystemMetrics( SM_CXBORDER ) * 2
  864. + 142
  865. ,
  866. nCaptionHeight + nBorderHeightX2
  867. );
  868. CSize sizeSpacing( 0, 0 );
  869. CRect rcClient;
  870.     GetClientRect( hWndMdiClient, &rcClient );
  871. CSize sizeClient = rcClient.Size();
  872. INT nCountInRow = sizeClient.cx / ( sizeItem.cx + sizeSpacing.cx );
  873. HDWP hDWP = ::BeginDeferWindowPos( nCount );
  874. pos = _list.GetHeadPosition();
  875.     for( nIndex = 0; nIndex < nCount; nIndex ++ )
  876. {
  877. ASSERT( pos != NULL );
  878. HWND hWnd = _list.GetNext( pos );
  879. ASSERT( hWnd != NULL && ::IsWindow( hWnd ) );
  880. INT nRow = nIndex / nCountInRow;
  881. INT nColumn = nIndex % nCountInRow;
  882. hDWP =
  883. ::DeferWindowPos(
  884. hDWP, hWnd, NULL,
  885. nColumn * ( sizeSpacing.cx + sizeItem.cx ),
  886. sizeClient.cy - ( nRow + 1) * ( sizeSpacing.cy + sizeItem.cy ),
  887. sizeItem.cx, sizeItem.cy,
  888. SWP_NOZORDER|SWP_NOACTIVATE
  889. );
  890. }
  891. ::EndDeferWindowPos( hDWP );
  892. INT nRetVal = sizeItem.cy + sizeSpacing.cy;
  893. return nRetVal;
  894. }
  896. void CExtNcFrameImpl::stat_MDI_Cascade(
  897. HWND hWndMdiClient,
  898. CList < HWND, HWND > & _listWindowsToSkip,
  899. WPARAM nActionFlags,
  900. INT nStairWindowCount // = 0 // zero or negative - compute automatically
  901. )
  902. {
  903. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  904. CList < HWND, HWND > _list;
  905. stat_MDI_GetWindowList(
  906. hWndMdiClient,
  907. _list,
  908. _listWindowsToSkip,
  909. true,  // bAddActiveToTail
  910. true,  // bIncludeEnabled
  911. ( ( nActionFlags & MDITILE_SKIPDISABLED ) == 0 ) ? true : false, // bIncludeDisabled
  912. false, // bIncludeIconic
  913. true,  // bIncludeNonIconic
  914. false, // bIncludeWithOwner,
  915. true   // bIncludeWithoutOwner,
  916. );
  917. stat_MDI_CascadeEWL( hWndMdiClient, _list, nStairWindowCount );
  918. }
  920. void CExtNcFrameImpl::stat_MDI_CascadeEWL( // explicit window list based version
  921. HWND hWndMdiClient,
  922. CList < HWND, HWND > & _list,
  923. INT nStairWindowCount // = 0 // zero or negative - compute automatically
  924. )
  925. {
  926. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  927. INT nIndex, nCount = INT( _list.GetCount() );
  928. if( nCount == 0 )
  929. return;
  930. if( nStairWindowCount <= 0 )
  931. nStairWindowCount = 7;
  932.     ShowScrollBar( hWndMdiClient, SB_BOTH, FALSE );
  933. INT nStepX = ::GetSystemMetrics( SM_CYCAPTION ) - ::GetSystemMetrics( SM_CYFRAME );
  934. INT nStepY = ::GetSystemMetrics( SM_CYCAPTION ) + ::GetSystemMetrics( SM_CYFRAME ) - 1;
  935. CRect rcClient;
  936.     GetClientRect( hWndMdiClient, &rcClient );
  937. // rcClient.bottom -= stat_MDI_ArrangeIconicEWL( hWndMdiClient, _list );
  938. CList < HWND, HWND > _listWindowsToSkip;
  939. rcClient.bottom -= stat_MDI_ArrangeIconic( hWndMdiClient, _listWindowsToSkip );
  940. CSize sizeClient = rcClient.Size();
  941. CSize sizeChild( sizeClient.cx - nStepX * nStairWindowCount, sizeClient.cy - nStepY * nStairWindowCount );
  942. HDWP hDWP = ::BeginDeferWindowPos( nCount );
  943. POSITION pos = _list.GetHeadPosition();
  944.     for( nIndex = 0; nIndex < nCount; nIndex ++ )
  945. {
  946. ASSERT( pos != NULL );
  947. HWND hWnd = _list.GetNext( pos );
  948. ASSERT( hWnd != NULL && ::IsWindow( hWnd ) );
  949. INT nDI = nIndex % nStairWindowCount;
  950. hDWP =
  951. ::DeferWindowPos(
  952. hDWP, hWnd, HWND_TOP,
  953. nDI * nStepX, nDI * nStepY, sizeChild.cx, sizeChild.cy,
  954. SWP_NOACTIVATE|SWP_FRAMECHANGED
  955. );
  956.     }
  957. ::EndDeferWindowPos( hDWP );
  958. }
  960. void CExtNcFrameImpl::stat_MDI_Tile(
  961. HWND hWndMdiClient,
  962. CList < HWND, HWND > & _listWindowsToSkip,
  963. WPARAM nActionFlags
  964. )
  965. {
  966. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  967. CList < HWND, HWND > _list;
  968. stat_MDI_GetWindowList(
  969. hWndMdiClient,
  970. _list,
  971. _listWindowsToSkip,
  972. true,  // bAddActiveToTail
  973. true,  // bIncludeEnabled
  974. ( ( nActionFlags & MDITILE_SKIPDISABLED ) == 0 ) ? true : false, // bIncludeDisabled
  975. false, // bIncludeIconic
  976. true,  // bIncludeNonIconic
  977. false, // bIncludeWithOwner,
  978. true   // bIncludeWithoutOwner,
  979. );
  980. bool bHorizontal = ( ( nActionFlags & MDITILE_HORIZONTAL ) != 0 ) ? true : false;
  981. stat_MDI_TileEWL( hWndMdiClient, _list, bHorizontal );
  982. }
  984. void CExtNcFrameImpl::stat_MDI_TileEWL( // explicit window list based version
  985. HWND hWndMdiClient,
  986. CList < HWND, HWND > & _list,
  987. bool bHorizontal
  988. )
  989. {
  990. ASSERT( hWndMdiClient != NULL && ::IsWindow( hWndMdiClient ) );
  991. INT nCount = INT( _list.GetCount() );
  992. if( nCount == 0 )
  993. return;
  994.     ShowScrollBar( hWndMdiClient, SB_BOTH, FALSE );
  995. CRect rcClient;
  996.     GetClientRect( hWndMdiClient, &rcClient );
  997. // rcClient.bottom -= stat_MDI_ArrangeIconicEWL( hWndMdiClient, _list );
  998. CList < HWND, HWND > _listWindowsToSkip;
  999. rcClient.bottom -= stat_MDI_ArrangeIconic( hWndMdiClient, _listWindowsToSkip );
  1000. CSize sizeClient = rcClient.Size();
  1001. INT nRest = 1;
  1002. INT nIndexX = (INT)::sqrt( (double)nCount );
  1003. INT nIndexY = nIndexX;
  1004.     if( nIndexY == 1 )
  1005. {
  1006. if( bHorizontal )
  1007. nIndexY = nCount;
  1008. else
  1009. nIndexX = nCount;
  1010. }
  1011. else
  1012. {
  1013. for( ; true; )
  1014. {
  1015. nRest = nCount - nIndexY * ( nIndexX - 1 );
  1016. if( bHorizontal )
  1017. {
  1018. if( ( nRest - nIndexX ) >= nIndexY )
  1019. nIndexY ++;
  1020. else
  1021. break;
  1022. }
  1023. else
  1024. {
  1025. if( ( nRest - nIndexY ) >= nIndexX )
  1026. nIndexX ++;
  1027. else
  1028. break;
  1029. }
  1030. }
  1031.     }
  1032. CSize sizeChild( sizeClient.cx / nIndexX, sizeClient.cy / nIndexY );
  1033. HDWP hDWP = ::BeginDeferWindowPos( nCount );
  1034. POSITION pos = _list.GetHeadPosition();
  1035. INT nWalkIndex = 0, nX, nY;
  1036. for( nX = 0, nY = 0; nX < nCount; nX ++ )
  1037. {
  1038. ASSERT( pos != NULL );
  1039. HWND hWnd = _list.GetNext( pos );
  1040. ASSERT( hWnd != NULL && ::IsWindow( hWnd ) );
  1041. CPoint ptTopLeft( 0, 0 );
  1042. if( bHorizontal )
  1043. {
  1044. ptTopLeft.x = ( nWalkIndex - nY * nIndexX ) * sizeChild.cx;
  1045. ptTopLeft.y = nY * sizeChild.cy;
  1046. if( ( ( nWalkIndex % nIndexX ) == ( nIndexX - 1 ) )
  1047. && ( nY < ( nIndexY - 1 ) )
  1048. )
  1049. nY ++;
  1050. }
  1051. else
  1052. {
  1053. ptTopLeft.x = nY * sizeChild.cx;
  1054. ptTopLeft.y = ( nWalkIndex - nY * nIndexY ) * sizeChild.cy;
  1055. if( ( ( nWalkIndex % nIndexY ) == ( nIndexY - 1 ) )
  1056. && ( nY < ( nIndexX - 1 ) )
  1057. )
  1058. nY ++;
  1059. }
  1060. hDWP =
  1061. ::DeferWindowPos(
  1062. hDWP, hWnd, NULL,
  1063. ptTopLeft.x, ptTopLeft.y, sizeChild.cx, sizeChild.cy,
  1064. SWP_NOACTIVATE|SWP_NOZORDER
  1065. );
  1066. if( bHorizontal )
  1067. {
  1068. if( nY == ( nIndexY - 1 ) )
  1069. sizeChild.cx = sizeClient.cx / nRest;
  1070. }
  1071. else
  1072. {
  1073. if( nY == ( nIndexX - 1 ) )
  1074. sizeChild.cy = sizeClient.cy / nRest;
  1075. }
  1076. nWalkIndex ++;
  1077. }
  1078. ::EndDeferWindowPos( hDWP );
  1079. }
  1081. void CExtNcFrameImpl::NcFrameImpl_MapHtRects_Clean()
  1082. {
  1083. POSITION pos = m_mapNcFrameImpl_HtRects.GetStartPosition();
  1084. for( ; pos != NULL; )
  1085. {
  1086. LPVOID p1, p2;
  1087. m_mapNcFrameImpl_HtRects.GetNextAssoc( pos, p1, p2 );
  1088. ASSERT( p2 != NULL );
  1089. RECT * pRect = ( RECT * ) p2;
  1090. delete pRect;
  1091. } // for( ; pos != NULL; )
  1092. m_mapNcFrameImpl_HtRects.RemoveAll();
  1093. }
  1095. void CExtNcFrameImpl::NcFrameImpl_MapHtRects_SetAt( LONG nHT, const RECT & rc ) const
  1096. {
  1097. LPVOID p;
  1098. if( m_mapNcFrameImpl_HtRects.Lookup( LPVOID(__EXT_MFC_LONG_PTR(nHT)), p ) )
  1099. {
  1100. ASSERT( p != NULL );
  1101. RECT * pRect = ( RECT * ) p;
  1102. pRect->left = rc.left;
  1103. pRect->top = rc.top;
  1104. pRect->right = rc.right;
  1105. pRect->bottom = rc.bottom;
  1106. }
  1107. else
  1108. {
  1109. RECT * pRect = new RECT;
  1110. pRect->left = rc.left;
  1111. pRect->top = rc.top;
  1112. pRect->right = rc.right;
  1113. pRect->bottom = rc.bottom;
  1114. m_mapNcFrameImpl_HtRects.SetAt( LPVOID(__EXT_MFC_LONG_PTR(nHT)), pRect );
  1115. }
  1116. }
  1118. bool CExtNcFrameImpl::NcFrameImpl_MapHtRects_GetAt( LONG nHT, RECT & rc ) const
  1119. {
  1120. LPVOID p;
  1121. if( m_mapNcFrameImpl_HtRects.Lookup( LPVOID(__EXT_MFC_LONG_PTR(nHT)), p ) )
  1122. {
  1123. ASSERT( p != NULL );
  1124. RECT * pRect = ( RECT * ) p;
  1125. rc.left = pRect->left;
  1126. rc.top = pRect->top;
  1127. rc.right = pRect->right;
  1128. rc.bottom = pRect->bottom;
  1129. return true;
  1130. }
  1131. return false;
  1132. }
  1134. bool CExtNcFrameImpl::NcFrameImpl_IsNcLocked() const
  1135. {
  1136. ASSERT( m_nNcFrameImpl_Lock >= 0 );
  1137. if( m_nNcFrameImpl_Lock == 0 )
  1138. return false;
  1139. else
  1140. return true;
  1141. }
  1143. void CExtNcFrameImpl::NcFrameImpl_NcLock( bool bLock ) const
  1144. {
  1145. ASSERT( m_nNcFrameImpl_Lock >= 0 );
  1146. if( bLock )
  1147. m_nNcFrameImpl_Lock ++;
  1148. else
  1149. m_nNcFrameImpl_Lock --;
  1150. ASSERT( m_nNcFrameImpl_Lock >= 0 );
  1151. }
  1153. DWORD CExtNcFrameImpl::NcFrameImpl_GetInitialStyle() const
  1154. {
  1155. return (DWORD)m_dwNcFrameImpl_StyleInitial;
  1156. }
  1158. DWORD CExtNcFrameImpl::NcFrameImpl_GetInitialStyleEx() const
  1159. {
  1160. return (DWORD)m_dwNcFrameImpl_StyleExInitial;
  1161. }
  1163. HWND CExtNcFrameImpl::NcFrameImpl_OnQueryHWND() const
  1164. {
  1165. return ( const_cast < CExtNcFrameImpl * > (this) ) -> NcFrameImpl_OnQueryHWND();
  1166. }
  1168. CWnd * CExtNcFrameImpl::NcFrameImpl_GetFrameWindow()
  1169. {
  1170. HWND hWnd = NcFrameImpl_OnQueryHWND();
  1171. if( hWnd == NULL )
  1172. return NULL;
  1173. ASSERT( ::IsWindow( hWnd ) );
  1174. return CWnd::FromHandle( hWnd );
  1175. }
  1177. const CWnd * CExtNcFrameImpl::NcFrameImpl_GetFrameWindow() const
  1178. {
  1179. return ( const_cast < CExtNcFrameImpl * > (this) ) -> NcFrameImpl_GetFrameWindow();
  1180. }
  1182. CRect CExtNcFrameImpl::NcFrameImpl_GetNcHtRect(
  1183. UINT nHT,
  1184. LPMINMAXINFO pMinMaxInfo,
  1185. LPCRECT pRectWnd // = NULL
  1186. ) const
  1187. {
  1188. return
  1189. NcFrameImpl_GetNcHtRect(
  1190. nHT,
  1191. true,
  1192. false,
  1193. false,
  1194. pMinMaxInfo,
  1195. pRectWnd
  1196. );
  1197. }
  1199. CRect CExtNcFrameImpl::NcFrameImpl_GetNcHtRect(
  1200. UINT nHT,
  1201. bool bScreenMapping, // = true
  1202. bool bLayoutBordersH, // = false
  1203. bool bLayoutBordersV, // = false
  1204. LPMINMAXINFO pMinMaxInfo, // = NULL
  1205. LPCRECT pRectWnd // = NULL
  1206. ) const
  1207. {
  1208. if( m_pNcFrameImplBridge != NULL )
  1209. {
  1210. CRect rc;
  1211. if( m_pNcFrameImplBridge->
  1212. NcFrameImpl_GetNcHtRect(
  1213. rc,
  1214. nHT,
  1215. bScreenMapping,
  1216. bLayoutBordersH,
  1217. bLayoutBordersV,
  1218. pMinMaxInfo,
  1219. pRectWnd
  1220. )
  1221. )
  1222. return rc;
  1223. }
  1224. RECT rc = { 0, 0, 0, 0 };
  1225. if( NcFrameImpl_MapHtRects_GetAt( LONG(nHT), rc ) )
  1226. {
  1227. if( bScreenMapping )
  1228. {
  1229. CRect rcWnd( 0, 0, 0, 0 );
  1230. if( pRectWnd != NULL )
  1231. rcWnd = (*pRectWnd);
  1232. else
  1233. {
  1234.   CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1235.   ASSERT_VALID( pWndFrameImpl );
  1236. pWndFrameImpl->GetWindowRect( &rcWnd );
  1237. } // else from if( pRectWnd != NULL )
  1238. ::OffsetRect( &rc, rcWnd.left, rcWnd.top );
  1239. } // if( bScreenMapping )
  1240. } // if( NcFrameImpl_MapHtRects_GetAt( LONG(nHT), rc ) )
  1241. else
  1242. {
  1243. CExtCmdIcon _icon;
  1244. NcFrameImpl_GetIcon( _icon );
  1245. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1246. ASSERT_VALID( pWndFrameImpl );
  1247. rc =
  1248. NcFrameImpl_GetPM()->NcFrame_GetHtRect(
  1249. nHT,
  1250. bScreenMapping,
  1251. bLayoutBordersH,
  1252. bLayoutBordersV,
  1253. &_icon,
  1254. pWndFrameImpl,
  1255. pMinMaxInfo
  1256. );
  1257. CRect rc2 = rc;
  1258. if( bScreenMapping )
  1259. {
  1260. CRect rcWnd( 0, 0, 0, 0 );
  1261. if( pRectWnd != NULL )
  1262. rcWnd = (*pRectWnd);
  1263. else
  1264. {
  1265.   CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1266.   ASSERT_VALID( pWndFrameImpl );
  1267. pWndFrameImpl->GetWindowRect( &rcWnd );
  1268. } // else from if( pRectWnd != NULL )
  1269. ::OffsetRect( &rc, -rcWnd.left, -rcWnd.top );
  1270. } // if( bScreenMapping )
  1271. NcFrameImpl_MapHtRects_SetAt( LONG(nHT), rc2 );
  1272. } // else from if( NcFrameImpl_MapHtRects_GetAt( LONG(nHT), rc1 ) )
  1273. return rc;
  1274. }
  1276. CRect CExtNcFrameImpl::NcFrameImpl_GetNcScRect( UINT nSC ) const
  1277. {
  1278. if( m_rcNcFrameImpl_ScClose.IsRectEmpty() )
  1279. NcFrameImpl_ReCacheScButtonRects();
  1280. if( m_pNcFrameImplBridge != NULL )
  1281. {
  1282. CRect rc;
  1283. if( m_pNcFrameImplBridge->NcFrameImplBridge_GetNcScRect( nSC, rc ) )
  1284. {
  1285. switch( nSC )
  1286. {
  1287. case SC_CLOSE:
  1288. m_rcNcFrameImpl_ScClose = rc;
  1289. case SC_MAXIMIZE:
  1290. case SC_RESTORE:
  1291. m_rcNcFrameImpl_ScMaximize = rc;
  1292. case SC_MINIMIZE:
  1293. m_rcNcFrameImpl_ScMinimize = rc;
  1294. case SC_CONTEXTHELP:
  1295. m_rcNcFrameImpl_ScHelp = rc;
  1296. } // switch( nSC )
  1297. return rc;
  1298. }
  1299. }
  1300. switch( nSC )
  1301. {
  1302. case SC_CLOSE:
  1303. return m_rcNcFrameImpl_ScClose;
  1304. case SC_RESTORE:
  1305. if( NcFrameImpl_GetFrameWindow() != NULL
  1306. && NcFrameImpl_GetFrameWindow()->IsIconic()
  1307. )
  1308. return m_rcNcFrameImpl_ScMinimize;
  1309. case SC_MAXIMIZE:
  1310. return m_rcNcFrameImpl_ScMaximize;
  1311. case SC_MINIMIZE:
  1312. return m_rcNcFrameImpl_ScMinimize;
  1313. case SC_CONTEXTHELP:
  1314. return m_rcNcFrameImpl_ScHelp;
  1315. } // switch( nSC )
  1316. return CRect( 0, 0, 0, 0 );
  1317. }
  1319. void CExtNcFrameImpl::NcFrameImpl_GetIcon( CExtCmdIcon & _icon ) const
  1320. {
  1321. _icon.Empty();
  1322. if( ! m_iconNcFrameImpl_QueryCache.IsEmpty() )
  1323. {
  1324. _icon = m_iconNcFrameImpl_QueryCache;
  1325. return;
  1326. }
  1327. const CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1328. HWND hWnd = (HWND)pWndFrameImpl->GetSafeHwnd();
  1329. if( hWnd == NULL )
  1330. return;
  1331. HICON hIcon = (HICON)
  1332. ::SendMessage(
  1333. hWnd,
  1334. WM_GETICON,
  1335. WPARAM(ICON_SMALL),
  1336. 0
  1337. );
  1338. if( hIcon == NULL )
  1339. {
  1340. hIcon = (HICON)
  1341. ::SendMessage(
  1342. hWnd,
  1343. WM_GETICON,
  1344. WPARAM(ICON_BIG),
  1345. 0
  1346. );
  1347. if( hIcon == NULL )
  1348. {
  1349. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::__EXT_MFC_GetClassLong( hWnd, __EXT_MFC_GCL_HICONSM );
  1350. if( hIcon == NULL )
  1351. {
  1352. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::__EXT_MFC_GetClassLong( hWnd, __EXT_MFC_GCL_HICON );
  1353. } // if( hIcon == NULL )
  1354. } // if( hIcon == NULL )
  1355. } // if( hIcon == NULL )
  1356. if( hIcon == NULL )
  1357. return;
  1358. _icon.AssignFromHICON( hIcon, true );
  1359. CSize _sizeIcon = _icon.GetSize();
  1360. if( _sizeIcon.cx != 16 || _sizeIcon.cy != 16 )
  1361. _icon.Scale( CSize(16,16) );
  1362. m_iconNcFrameImpl_QueryCache = _icon;
  1363. }
  1365. void CExtNcFrameImpl::NcFrameImpl_ReCacheScButtonRects() const
  1366. {
  1367. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1368. ASSERT_VALID( pWndFrameImpl );
  1369. CExtCmdIcon _icon;
  1370. NcFrameImpl_GetIcon( _icon );
  1371. CString strCaption;
  1372. pWndFrameImpl->GetWindowText( strCaption );
  1373. //MINMAXINFO _mmi, * pMinMaxInfo = NULL;
  1374. // ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  1375. // CExtPaintManager::monitor_parms_t _mp;
  1376. // CExtPaintManager::stat_GetMonitorParms( _mp, pWndFrameImpl );
  1377. // _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  1378. // _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  1379. // _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  1380. // _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  1381. // _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  1382. // _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  1383. // _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  1384. // _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  1385. // if( pWndFrameImpl->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  1386. // pMinMaxInfo = &_mmi;
  1387. MINMAXINFO * pMinMaxInfo = (MINMAXINFO*)(&m_NcFrameImpl_MinMaxInfo_Cache);
  1389. NcFrameImpl_GetPM()->NcFrame_GetRects(
  1390. &_icon,
  1391. LPCTSTR(strCaption),
  1392. DT_LEFT|DT_VCENTER,
  1393. m_rcNcFrameImpl_Icon,
  1394. m_rcNcFrameImpl_Text,
  1395. m_rcNcFrameImpl_ScHelp,
  1396. m_rcNcFrameImpl_ScMinimize,
  1397. m_rcNcFrameImpl_ScMaximize,
  1398. m_rcNcFrameImpl_ScClose,
  1399. pWndFrameImpl,
  1400. pMinMaxInfo
  1401. );
  1402. if( m_pNcFrameImplBridge != NULL )
  1403. {
  1404. m_pNcFrameImplBridge->NcFrameImplBridge_GetNcScRect( SC_CLOSE, m_rcNcFrameImpl_ScClose );
  1405. m_pNcFrameImplBridge->NcFrameImplBridge_GetNcScRect( SC_MAXIMIZE, m_rcNcFrameImpl_ScMaximize );
  1406. m_pNcFrameImplBridge->NcFrameImplBridge_GetNcScRect( SC_MINIMIZE, m_rcNcFrameImpl_ScMinimize );
  1407. m_pNcFrameImplBridge->NcFrameImplBridge_GetNcScRect( SC_CONTEXTHELP, m_rcNcFrameImpl_ScHelp );
  1408. } // if( m_pNcFrameImplBridge != NULL )
  1409. }
  1411. void CExtNcFrameImpl::NcFrameImpl_DelayRgnAdjustment()
  1412. {
  1413. if( NcFrameImpl_IsDwmBased() )
  1414. return;
  1415. m_bNcFrameImpl_RgnSet = false;
  1416. }
  1418. void CExtNcFrameImpl::NcFrameImpl_SetupRgn(
  1419. WINDOWPOS * pWndPos // = NULL
  1420. )
  1421. {
  1422. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1423. ASSERT_VALID( pWndFrameImpl );
  1424. if( NcFrameImpl_IsDwmBased() )
  1425. {
  1426. m_bNcFrameImpl_AssigningRGN = true;
  1427. pWndFrameImpl->SetWindowRgn( NULL, TRUE );
  1428. m_bNcFrameImpl_AssigningRGN = false;
  1429. return;
  1430. }
  1431. if( NcFrameImpl_IsNcLocked() )
  1432. return;
  1433. m_nNcFrameImpl_LastCheckCursorHT = HTNOWHERE;
  1434. m_ptNcFrameImpl_LastCheckCursor.x = m_ptNcFrameImpl_LastCheckCursor.y = -32767;
  1435. m_bNcFrameImpl_RgnSet = true;
  1436. __EXT_MFC_LONG_PTR dwStyle = m_dwNcFrameImpl_StyleInitial; // pWndFrameImpl->GetStyle();
  1437. if( (dwStyle&WS_BORDER) == 0 )
  1438. return;
  1439. CRect rcWnd( 0, 0, 0, 0 );
  1440. if( pWndPos != NULL )
  1441. {
  1442. if( ( pWndPos->flags & SWP_NOSIZE) !=  0 )
  1443. return;
  1444. rcWnd.right = rcWnd.left + pWndPos->cx;
  1445. rcWnd.bottom = rcWnd.top + pWndPos->cy;
  1446. }
  1447. else
  1448. {
  1449. pWndFrameImpl->GetWindowRect( &rcWnd );
  1450. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  1451. }
  1452. m_rcNcFrameImpl_ScClose.SetRectEmpty();
  1453. m_rcNcFrameImpl_ScMaximize.SetRectEmpty();
  1454. m_rcNcFrameImpl_ScMinimize.SetRectEmpty();
  1455. m_rcNcFrameImpl_ScHelp.SetRectEmpty();
  1456. HRGN hRgn =
  1457. NcFrameImpl_GetPM()->NcFrame_GenerateSkinFrameRGN(
  1458. rcWnd,
  1459. pWndFrameImpl
  1460. );
  1461. if( m_pNcFrameImplBridge != NULL )
  1462. {
  1464. HRGN hRgnExclude = m_pNcFrameImplBridge->NcFrameImplBridge_GetNcExcludeHRGN();
  1465. if( hRgnExclude != NULL )
  1466. {
  1467. CRect rcBox( 0, 0, 0, 0 ); 
  1468. GetRgnBox( hRgnExclude, &rcBox );
  1469. HRGN hRgnBox = ::CreateRectRgnIndirect( &rcBox );
  1470. ::CombineRgn( hRgn, hRgn, hRgnBox, RGN_OR );
  1471. ::DeleteObject( hRgnBox );
  1472. ::CombineRgn( hRgn, hRgn, hRgnExclude, RGN_XOR );
  1473. }
  1474. }
  1475. m_bNcFrameImpl_AssigningRGN = true;
  1476. pWndFrameImpl->SetWindowRgn( hRgn, TRUE );
  1477. m_bNcFrameImpl_AssigningRGN = false;
  1478. }
  1481. BOOL CALLBACK stat_CalcMaxResizingInfo( HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData )
  1482. {
  1483. hMonitor; hdcMonitor; dwData;
  1484. ASSERT( lprcMonitor != NULL );
  1485. LPRECT pInfo = (LPRECT)dwData;
  1486. ASSERT( pInfo != NULL );
  1487. pInfo->left = min( pInfo->left, lprcMonitor->left );
  1488. pInfo->top = min( pInfo->top, lprcMonitor->top );
  1489. pInfo->right = max( pInfo->right, lprcMonitor->right );
  1490. pInfo->bottom = max( pInfo->bottom, lprcMonitor->bottom );
  1491. return TRUE;
  1492. }
  1494. bool CExtNcFrameImpl::NcFrameImpl_GetMinMaxInfo(
  1495. LPMINMAXINFO pMMI
  1496. ) const
  1497. {
  1498. ASSERT( pMMI != NULL );
  1499. if( ! NcFrameImpl_IsSupported() )
  1500. return false;
  1501. if( NcFrameImpl_IsDwmBased() )
  1502. return true;
  1503. CWnd * pWndFrameImpl = const_cast < CWnd * > ( NcFrameImpl_GetFrameWindow() );
  1504. if( ( pWndFrameImpl->GetStyle() & WS_CHILD ) == 0 )
  1505. {
  1506. CRect rcBorders( 0, 0, 0, 1 );
  1507. CExtPaintManager::monitor_parms_t _mp;
  1508. CExtPaintManager::stat_GetMonitorParms( _mp, pWndFrameImpl );
  1509. //  if( ! _mp.m_bPrimaryMonitor )
  1510. //  return false;
  1512. //  pMMI->ptMaxPosition.x = _mp.m_rcWorkArea.left + rcBorders.left;
  1513. //  pMMI->ptMaxPosition.y = _mp.m_rcWorkArea.top + rcBorders.top;
  1514. pMMI->ptMaxPosition.x = 0 + rcBorders.left;
  1515. pMMI->ptMaxPosition.y = 0 + rcBorders.top;
  1517. if( g_PaintManager.m_bIsWin98orLater || g_PaintManager.m_bIsWin2000orLater )
  1518. {
  1519. CRect rcClip( -32767, -32767, +32767, +32767 ), rcInfo( 0, 0, 0, 0 );
  1520. if( EnumDisplayMonitors( NULL, &rcClip, stat_CalcMaxResizingInfo, LPARAM(LPVOID(&rcInfo)) ) )
  1521. {
  1522. pMMI->ptMaxTrackSize.x = pMMI->ptMaxSize.x = rcInfo.Width();
  1523. pMMI->ptMaxTrackSize.y = pMMI->ptMaxSize.y = rcInfo.Height();
  1524. }
  1525. }
  1527. //  if( ! _mp.m_bPrimaryMonitor )
  1528. //  {
  1529. //  CPoint ptPrimary( 100, 100 );
  1530. //  CExtPaintManager::monitor_parms_t _mpPrimary;
  1531. //  CExtPaintManager::stat_GetMonitorParms( _mpPrimary, ptPrimary );
  1532. //  if( ! _mpPrimary.m_bPrimaryMonitor )
  1533. //  {
  1534. //  pMMI->ptMaxPosition.x = rcBorders.left;
  1535. //  pMMI->ptMaxPosition.y = rcBorders.top;
  1536. //  }
  1537. //  else
  1538. //  {
  1539. //  pMMI->ptMaxPosition.x = _mpPrimary.m_rcWorkArea.left + rcBorders.left;
  1540. //  pMMI->ptMaxPosition.y = _mpPrimary.m_rcWorkArea.top + rcBorders.top;
  1541. //  }
  1542. //  }
  1543. /*pMMI->ptMaxTrackSize.x =*/ pMMI->ptMaxSize.x = _mp.m_rcWorkArea.Width() - rcBorders.left - rcBorders.right;
  1544. /*pMMI->ptMaxTrackSize.y =*/ pMMI->ptMaxSize.y = _mp.m_rcWorkArea.Height() - rcBorders.top - rcBorders.bottom;
  1545. //TRACE2( "max-pos %d %drn", pMMI->ptMaxPosition.x, pMMI->ptMaxPosition.y );
  1546. APPBARDATA _data;
  1547. ::memset( &_data, 0, sizeof(APPBARDATA) );
  1548. _data.cbSize = sizeof(APPBARDATA);
  1549. UINT nSHR = (UINT)::SHAppBarMessage( ABM_GETSTATE, &_data );
  1550. if( nSHR == (ABS_AUTOHIDE|ABS_ALWAYSONTOP) )
  1551. {
  1552. nSHR = (UINT)::SHAppBarMessage( ABM_GETTASKBARPOS, &_data );
  1553. if( nSHR == 1 )
  1554. {
  1555. switch(_data.uEdge)
  1556. {
  1557. case ABE_TOP:
  1558. pMMI->ptMaxPosition.y ++;
  1559. pMMI->ptMaxSize.y --;
  1560. break;
  1561. case ABE_BOTTOM:
  1562. pMMI->ptMaxSize.y --;
  1563. break;
  1564. case ABE_LEFT:
  1565. pMMI->ptMaxPosition.x ++;
  1566. pMMI->ptMaxSize.x --;
  1567. break;
  1568. case ABE_RIGHT:
  1569. pMMI->ptMaxSize.x --;
  1570. break;
  1571. }
  1572. } // if( nSHR == 1 )
  1573. } // if( nSHR == (ABS_AUTOHIDE|ABS_ALWAYSONTOP) )
  1574. } // if( ( pWndFrameImpl->GetStyle() & WS_CHILD ) == 0 )
  1576. return true;
  1577. }
  1579. void CExtNcFrameImpl::NcFrameImpl_ExtractScTipText( const CWnd * pWnd, UINT nSC, CExtSafeString & strTipText )
  1580. {
  1581. if( ! strTipText.IsEmpty() )
  1582. return;
  1583. if( pWnd->GetSafeHwnd() != NULL )
  1584. {
  1585. if( pWnd->IsIconic() && nSC == SC_MINIMIZE )
  1586. nSC = SC_RESTORE;
  1587. CMenu * pMenu = pWnd->GetSystemMenu( FALSE );
  1588. if( pMenu->GetSafeHmenu() != NULL )
  1589. {
  1590. CString sTmp;
  1591. pMenu->GetMenuString( nSC, sTmp, MF_BYCOMMAND );
  1592. if( ! sTmp.IsEmpty() )
  1593. {
  1594. sTmp.Replace( _T("&"), _T("") );
  1595. INT nPos = sTmp.Find( _T("t") );
  1596. if( nPos > 0 )
  1597. sTmp = sTmp.Left( nPos );
  1598. strTipText = LPCTSTR( sTmp );
  1599. return;
  1600. }
  1601. }
  1602. }
  1603. switch( nSC )
  1604. {
  1605. case SC_MINIMIZE:
  1606. strTipText = _T("Minimize");
  1607. break;
  1608. case SC_MAXIMIZE:
  1609. strTipText = _T("Maximize");
  1610. break;
  1611. case SC_RESTORE:
  1612. strTipText = _T("Restore");
  1613. break;
  1614. case SC_CLOSE:
  1615. strTipText = _T("Close");
  1616. break;
  1617. case SC_CONTEXTHELP:
  1618. strTipText = _T("Help");
  1619. break;
  1620. }
  1621. }
  1623. __EXT_MFC_SAFE_LPCTSTR CExtNcFrameImpl::NcFrameImpl_GetScTipText( UINT nSC ) const
  1624. {
  1625. const CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1626. ASSERT_VALID( pWndFrameImpl );
  1627. if( m_rcNcFrameImpl_ScClose.IsRectEmpty() )
  1628. NcFrameImpl_ReCacheScButtonRects();
  1629. switch( nSC )
  1630. {
  1631. case SC_CLOSE:
  1632. {
  1633. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipClose );
  1634. return LPCTSTR( m_strNcFrameImpl_TipClose );
  1635. }
  1636. case SC_MAXIMIZE:
  1637. case SC_RESTORE:
  1638. {
  1639. if( pWndFrameImpl->IsZoomed() )
  1640. {
  1641. nSC = SC_RESTORE;
  1642. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipRestore );
  1643. return LPCTSTR( m_strNcFrameImpl_TipRestore );
  1644. }
  1645. else
  1646. {
  1647. nSC = SC_MAXIMIZE;
  1648. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipMaximize );
  1649. return LPCTSTR( m_strNcFrameImpl_TipMaximize );
  1650. }
  1651. }
  1652. case SC_MINIMIZE:
  1653. {
  1654. if( pWndFrameImpl->IsIconic() )
  1655. {
  1656. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipRestore );
  1657. return LPCTSTR( m_strNcFrameImpl_TipRestore );
  1658. }
  1659. else
  1660. {
  1661. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipMinimize );
  1662. return LPCTSTR( m_strNcFrameImpl_TipMinimize );
  1663. }
  1664. }
  1665. case SC_CONTEXTHELP:
  1666. {
  1667. NcFrameImpl_ExtractScTipText( pWndFrameImpl, nSC, m_strNcFrameImpl_TipHelp );
  1668. return LPCTSTR( m_strNcFrameImpl_TipHelp );
  1669. }
  1670. } // switch( nSC )
  1671. return NULL;
  1672. }
  1674. bool CExtNcFrameImpl::NcFrameImpl_IsSupported() const
  1675. {
  1676. if( ! m_bNcFrameImpl_IsEnabled )
  1677. return false;
  1678. const CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1679. if( pWndFrameImpl->GetSafeHwnd() == NULL )
  1680. return false;
  1681. if( ! NcFrameImpl_GetPM()->NcFrame_IsSupported( pWndFrameImpl ) )
  1682. return false;
  1683. CFrameWnd * pFrameWnd = DYNAMIC_DOWNCAST( CFrameWnd, pWndFrameImpl );
  1684. if( pFrameWnd != NULL
  1685. && CExtControlBar::IsOleIpObjActive( pFrameWnd )
  1686. )
  1687. {
  1688. if( m_bNcFrameImpl_RgnSet )
  1689. {
  1690. (((CExtNcFrameImpl*)this)->m_bNcFrameImpl_RgnSet) = false;
  1691. ::SetWindowRgn( pWndFrameImpl->m_hWnd, NULL, FALSE );
  1692. } // if( m_bNcFrameImpl_RgnSet )
  1693. return false;
  1694. }
  1695. return true;
  1696. }
  1698. bool CExtNcFrameImpl::NcFrameImpl_IsDwmBased() const
  1699. {
  1700. if( ! NcFrameImpl_IsSupported() )
  1701. return false;
  1702. bool bDwmMode = g_PaintManager.m_DWM.IsCompositionEnabled() ? true : false;
  1703. if( ! bDwmMode )
  1704. return false;
  1705. return m_bNcFrameImpl_IsDwmBased;
  1706. }
  1708. bool CExtNcFrameImpl::NcFrameImpl_IsDwmCaptionReplacement() const
  1709. {
  1710. if( ! NcFrameImpl_IsDwmBased() )
  1711. return false;
  1712. if( m_pNcFrameImplBridge != NULL )
  1713. {
  1714. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1715. if( hWnd != NULL
  1716. && ( ::__EXT_MFC_GetWindowLong( hWnd, GWL_STYLE ) & WS_VISIBLE ) != 0
  1717. && m_pNcFrameImplBridge->NcFrameImplBridge_OnOverPaint_IsEnabled()
  1718. )
  1719. return true;
  1720. }
  1721. return false;
  1722. }
  1724. bool CExtNcFrameImpl::NcFrameImpl_IsForceEmpty() const
  1725. {
  1726. if( NcFrameImpl_IsDwmBased() )
  1727. return true;
  1728. return false;
  1729. }
  1731. CRect CExtNcFrameImpl::NcFrameImpl_GetForceEmptyNcBorder() const
  1732. {
  1733. return CRect( 0, 0, 0, 0 );
  1734. }
  1736. bool CExtNcFrameImpl::NcFrameImpl_IsForceEmptyNcBorderEmpty() const
  1737. {
  1738. if( NcFrameImpl_IsDwmBased() )
  1739. return true;
  1740. CRect rc = NcFrameImpl_GetForceEmptyNcBorder();
  1741. ASSERT( rc.left >= 0 );
  1742. ASSERT( rc.top >= 0 );
  1743. ASSERT( rc.right >= 0 );
  1744. ASSERT( rc.bottom >= 0 );
  1745. if( rc.left > 0
  1746. || rc.top > 0
  1747. || rc.right > 0
  1748. || rc.bottom > 0
  1749. )
  1750. return false;
  1751. return true;
  1752. }
  1754. bool CExtNcFrameImpl::NcFrameImpl_IsActive()
  1755. {
  1756. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  1757. if( hWndOwn == NULL )
  1758. return false;
  1759. return m_bNcFrameImpl_IsActive;
  1760. }
  1762. void CExtNcFrameImpl::NcFrameImpl_OnNcPaint(
  1763. CDC & dcPaint,
  1764. bool bOuterEmulationMode // = false
  1765. )
  1766. {
  1767. bOuterEmulationMode;
  1768. CExtPaintManager * pPM = NcFrameImpl_GetPM();
  1769. ASSERT_VALID( pPM );
  1770. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1771. CRect rcNcBorders, rcThemePadding;
  1772. pPM->NcFrame_GetMetrics( rcNcBorders, rcThemePadding, pWndFrameImpl );
  1773. bool bFrameActive = NcFrameImpl_IsActive();
  1774. INT nAdjustCaptionHeight = 0;
  1775. if( m_pNcFrameImplBridge != NULL
  1776. && m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryCaptionMergeMode()
  1777. )
  1778. {
  1779. nAdjustCaptionHeight =
  1780. pPM->NcFrame_GetCaptionHeight(
  1781. bFrameActive,
  1782. pWndFrameImpl
  1783. );
  1784. rcNcBorders.top += nAdjustCaptionHeight;
  1785. }
  1786. CRect rcWnd, rcClient;
  1787. pWndFrameImpl->GetWindowRect( &rcWnd );
  1788. pWndFrameImpl->GetClientRect( &rcClient );
  1789. CRect rcSavedClient = rcClient;
  1790. pWndFrameImpl->ClientToScreen( &rcClient );
  1791. rcClient.OffsetRect( -rcWnd.TopLeft() );
  1792. CRect rcRealClient = rcClient;
  1793. rcClient.top += nAdjustCaptionHeight;
  1794. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  1795. DWORD dwOldLayout = dcPaint.SetLayout( LAYOUT_LTR );
  1797. if( ! bOuterEmulationMode  )
  1798. {
  1799. dcPaint.ExcludeClipRect( &rcRealClient );
  1800. if( m_pNcFrameImplBridge != NULL && nAdjustCaptionHeight > 0 )
  1801. {
  1802. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1803. if( hWnd != NULL )
  1804. {
  1805. CRect rc = rcSavedClient;
  1806. rc.bottom = rc.top + nAdjustCaptionHeight;
  1807. pWndFrameImpl->ClientToScreen( &rc );
  1808. ::ScreenToClient( hWnd, (LPPOINT)&rc );
  1809. ::ScreenToClient( hWnd, ((LPPOINT)&rc)+1 );
  1810. ::InvalidateRect( hWnd, &rc, TRUE );
  1811. ::UpdateWindow( hWnd );
  1812. }
  1813. }
  1814. } // if( ! bOuterEmulationMode  )
  1816. { // BLOCK: memory DC
  1817. CExtMemoryDC dc( &dcPaint, &rcWnd );
  1818. NcFrameImpl_ReCacheScButtonRects();
  1819. bool bFrameEnabled = pWndFrameImpl->IsWindowEnabled() ? true : false;
  1820. bool bFrameMaximized = pWndFrameImpl->IsZoomed() ? true : false;
  1821. CExtPaintManager::e_nc_button_state_t
  1822. eStateButtonHelp = CExtPaintManager::__ENCBS_DISABLED,
  1823. eStateButtonMinimize = CExtPaintManager::__ENCBS_DISABLED,
  1824. eStateButtonMaximizeRestore = CExtPaintManager::__ENCBS_DISABLED,
  1825. eStateButtonClose = CExtPaintManager::__ENCBS_DISABLED;
  1826. if( ! m_rcNcFrameImpl_ScClose.IsRectEmpty() )
  1827. {
  1828. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_CLOSE ) )
  1829. eStateButtonClose =
  1830. ( m_nNcFrameImpl_ScTrackedButtonPressed == SC_CLOSE )
  1831. ? CExtPaintManager::__ENCBS_PRESSED
  1832. : ( ( m_nNcFrameImpl_ScTrackedButtonHover == SC_CLOSE
  1833. && m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1834. ? CExtPaintManager::__ENCBS_HOVER
  1835. : CExtPaintManager::__ENCBS_NORMAL )
  1836. ;
  1837. }
  1838. if( ! m_rcNcFrameImpl_ScMaximize.IsRectEmpty() )
  1839. {
  1840. if( bFrameMaximized )
  1841. {
  1842. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_RESTORE )
  1843. || NcFrameImpl_OnQuerySystemCommandEnabled( SC_MAXIMIZE )
  1844. )
  1845. eStateButtonMaximizeRestore =
  1846. ( m_nNcFrameImpl_ScTrackedButtonPressed == SC_MAXIMIZE )
  1847. ? CExtPaintManager::__ENCBS_PRESSED
  1848. : ( ( m_nNcFrameImpl_ScTrackedButtonHover == SC_MAXIMIZE
  1849. && m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1850. ? CExtPaintManager::__ENCBS_HOVER
  1851. : CExtPaintManager::__ENCBS_NORMAL )
  1852. ;
  1853. }
  1854. else
  1855. {
  1856. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_RESTORE )
  1857. || NcFrameImpl_OnQuerySystemCommandEnabled( SC_MAXIMIZE )
  1858. )
  1859. eStateButtonMaximizeRestore =
  1860. ( m_nNcFrameImpl_ScTrackedButtonPressed == SC_MAXIMIZE )
  1861. ? CExtPaintManager::__ENCBS_PRESSED
  1862. : ( ( m_nNcFrameImpl_ScTrackedButtonHover == SC_MAXIMIZE
  1863. && m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1864. ? CExtPaintManager::__ENCBS_HOVER
  1865. : CExtPaintManager::__ENCBS_NORMAL )
  1866. ;
  1867. }
  1868. }
  1869. if( ! m_rcNcFrameImpl_ScMinimize.IsRectEmpty() )
  1870. {
  1871. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_MINIMIZE ) )
  1872. eStateButtonMinimize =
  1873. ( m_nNcFrameImpl_ScTrackedButtonPressed == SC_MINIMIZE )
  1874. ? CExtPaintManager::__ENCBS_PRESSED
  1875. : ( ( m_nNcFrameImpl_ScTrackedButtonHover == SC_MINIMIZE
  1876. && m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1877. ? CExtPaintManager::__ENCBS_HOVER
  1878. : CExtPaintManager::__ENCBS_NORMAL )
  1879. ;
  1880. }
  1881. if( ! m_rcNcFrameImpl_ScHelp.IsRectEmpty() )
  1882. {
  1883. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_CONTEXTHELP ) )
  1884. eStateButtonHelp =
  1885. ( m_nNcFrameImpl_ScTrackedButtonPressed == SC_CONTEXTHELP )
  1886. ? CExtPaintManager::__ENCBS_PRESSED
  1887. : ( ( m_nNcFrameImpl_ScTrackedButtonHover == SC_CONTEXTHELP
  1888. && m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1889. ? CExtPaintManager::__ENCBS_HOVER
  1890. : CExtPaintManager::__ENCBS_NORMAL )
  1891. ;
  1892. }
  1893. bool bDrawIcon = true, bDrawCaptionText = true;
  1894. CExtCmdIcon _icon;
  1895. CString strCaption;
  1896. CRect rcDrawIcon = m_rcNcFrameImpl_Icon;
  1897. CRect rcDrawText = m_rcNcFrameImpl_Text;
  1898. UINT nDtFlags = DT_SINGLELINE|DT_LEFT|DT_VCENTER;
  1899. if( m_pNcFrameImplBridge != NULL )
  1900. {
  1901. bDrawIcon =
  1902. m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryDrawIcon(
  1903. rcDrawIcon
  1904. );
  1905. bDrawCaptionText =
  1906. m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryDrawCaptionText(
  1907. rcDrawText,
  1908. nDtFlags
  1909. );
  1910. } // if( m_pNcFrameImplBridge != NULL )
  1911. if( bDrawIcon )
  1912. NcFrameImpl_GetIcon( _icon );
  1913. pWndFrameImpl->GetWindowText( strCaption );
  1914. pPM->NcFrame_Paint(
  1915. dc,
  1916. bDrawIcon ? (&_icon) : NULL,
  1917. bDrawCaptionText ? LPCTSTR(strCaption) : _T(""),
  1918. nDtFlags,
  1919. rcWnd,
  1920. rcClient,
  1921. rcDrawIcon,
  1922. rcDrawText,
  1923. m_rcNcFrameImpl_ScHelp,
  1924. m_rcNcFrameImpl_ScMinimize,
  1925. m_rcNcFrameImpl_ScMaximize,
  1926. m_rcNcFrameImpl_ScClose,
  1927. bFrameActive,
  1928. bFrameEnabled,
  1929. bFrameMaximized,
  1930. eStateButtonHelp,
  1931. eStateButtonMinimize,
  1932. eStateButtonMaximizeRestore,
  1933. eStateButtonClose,
  1934. pWndFrameImpl
  1935. );
  1936. if( m_pNcFrameImplBridge != NULL )
  1937. {
  1938. if( ! bOuterEmulationMode )
  1939. m_pNcFrameImplBridge->NcFrameImplBridge_OnOverPaint(
  1940. dc,
  1941. rcWnd,
  1942. rcClient
  1943. );
  1944. if( ! bDrawCaptionText )
  1945. m_pNcFrameImplBridge->NcFrameImplBridge_OnDrawCaptionText(
  1946. dc,
  1947. LPCTSTR(strCaption),
  1948. rcDrawText
  1949. );
  1950. }
  1951. } // BLOCK: memory DC
  1952. dcPaint.SetLayout( dwOldLayout );
  1953. }
  1955. void CExtNcFrameImpl::NcFrameImpl_AdjustVistaDwmCompatibilityIssues()
  1956. {
  1957. bool bDwmMode = g_PaintManager.m_DWM.IsCompositionEnabled() ? true : false;
  1958. if( ! bDwmMode )
  1959. return;
  1960. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  1961. if( hWndOwn == NULL || ( ! ::IsWindow( hWndOwn ) ) )
  1962. return;
  1964. bool bDwmArea = NcFrameImpl_IsDwmCaptionReplacement();
  1965. if( ! bDwmArea )
  1966. return;
  1967. bool bCustomNcArea = false;
  1969. CExtDWM::__EXT_DWMNCRENDERINGPOLICY ncrp =
  1970. bCustomNcArea
  1971. ? CExtDWM::__EXT_DWMNCRP_DISABLED
  1972. : CExtDWM::__EXT_DWMNCRP_ENABLED // CExtDWM::__EXT_DWMNCRP_USEWINDOWSTYLE
  1973. ;
  1974. HRESULT hr = 
  1975. g_PaintManager.m_DWM.DwmSetWindowAttribute(
  1976. hWndOwn,
  1977. CExtDWM::__EXT_DWMWA_NCRENDERING_POLICY,
  1978. &ncrp,
  1979. sizeof(ncrp)
  1980. );
  1981. // ASSERT( hr == S_OK );
  1982. BOOL bAllow = bDwmArea ? TRUE : FALSE;
  1983. hr = 
  1984. g_PaintManager.m_DWM.DwmSetWindowAttribute(
  1985. hWndOwn,
  1986. CExtDWM::__EXT_DWMWA_ALLOW_NCPAINT,
  1987. &bAllow,
  1988. sizeof(bAllow)
  1989. );
  1990. hr;
  1991. }
  1993. bool CExtNcFrameImpl::NcFrameImpl_FilterWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam )
  1994. {
  1995. wParam;
  1996. lParam;
  1997. if( message == g_PaintManager.m_nMsgPaintManagerChanged )
  1998. {
  1999. m_BridgeNC.PmBridge_OnPaintManagerChanged( m_BridgeNC.PmBridge_GetPM() );
  2000. lResult = 0L;
  2001. return true;
  2002. } // if( message == g_PaintManager.m_nMsgPaintManagerChanged )
  2003. if( message == g_nMsgFindExtNcFrameImpl )
  2004. {
  2005. CExtNcFrameImpl ** ppExtNcFrameImpl = (CExtNcFrameImpl **)wParam;
  2006. (*ppExtNcFrameImpl) = this;
  2007. m_pNcFrameImplBridge = (IExtNcFrameImplBridge*)lParam;
  2008. return true;
  2009. } // if( message == g_nMsgFindExtNcFrameImpl )
  2010. return false;
  2011. }
  2013. bool CExtNcFrameImpl::NcFrameImpl_PreWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam )
  2014. {
  2015. m_bNcFrameImpl_RestoreBorder = false;
  2016. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  2017. switch( message )
  2018. {
  2019. case __EXT_MFC_WM_NCUAHDRAWCAPTION:
  2020. case __EXT_MFC_WM_NCUAHDRAWFRAME:
  2021. if( ! NcFrameImpl_IsSupported() )
  2022. break;
  2023. if( NcFrameImpl_IsDwmBased() )
  2024. break;
  2025. lResult = 0;
  2026. return true;
  2027. case WM_SETTEXT:
  2028. {
  2029. if( ! NcFrameImpl_IsSupported() )
  2030. break;
  2031. if( NcFrameImpl_IsDwmBased() )
  2032. {
  2033. if( m_pNcFrameImplBridge != NULL )
  2034. {
  2035. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  2036. if( hWnd != NULL )
  2037. {
  2038. ::InvalidateRect( hWnd, NULL, TRUE );
  2039. //::UpdateWindow( hWnd );
  2040. }
  2041. }
  2042. break;
  2043. }
  2044. struct friendly_wnd_t : public CWnd { friend class CExtNcFrameImpl; };
  2045. DWORD dw = pWndFrameImpl->GetStyle()&WS_CAPTION;
  2046. if( dw != 0 )
  2047. pWndFrameImpl->ModifyStyle( WS_CAPTION, 0 );
  2048. lResult = ((friendly_wnd_t*)pWndFrameImpl)->DefWindowProc( message, wParam, lParam );
  2049. if( dw != 0 )
  2050. pWndFrameImpl->ModifyStyle( 0, dw );
  2051. pWndFrameImpl->SendMessage( WM_NCPAINT );
  2052. if( m_pNcFrameImplBridge != NULL )
  2053. {
  2054. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  2055. if( hWnd != NULL )
  2056. {
  2057. ::InvalidateRect( hWnd, NULL, TRUE );
  2058. //::UpdateWindow( hWnd );
  2059. }
  2060. }
  2061. }
  2062. return true;
  2063. case WM_MDIRESTORE:
  2064. case WM_MDIMAXIMIZE:
  2065. case WM_MDIACTIVATE:
  2066. {
  2067. if( ! NcFrameImpl_IsSupported() )
  2068. break;
  2069. if( NcFrameImpl_IsDwmBased() )
  2070. break;
  2071. HWND hWndMdiClient = ::GetParent( pWndFrameImpl->m_hWnd );
  2072. CRect rcClient;
  2073. ::GetClientRect( hWndMdiClient, &rcClient );
  2074. ::SendMessage( hWndMdiClient, WM_SIZE, SIZE_RESTORED, MAKELPARAM( rcClient.Width(), rcClient.Height() ) );
  2075. NcFrameImpl_SetupRgn();
  2076. if( message == WM_MDIACTIVATE )
  2077. {
  2078. CMDIChildWnd * pWndMdiChild = DYNAMIC_DOWNCAST( CMDIChildWnd, pWndFrameImpl );
  2079. if( pWndMdiChild != NULL )
  2080. {
  2081. HWND hWnd = (HWND)wParam;
  2082. if( hWnd != NULL && ::IsWindow(hWnd) )
  2083. {
  2084. MSG _msg;
  2085. for( ; ::PeekMessage( &_msg, hWnd, WM_NCPAINT, WM_NCPAINT, PM_REMOVE ); );
  2086. ::PostMessage( hWnd, WM_NCACTIVATE, FALSE, 0 );
  2087. }
  2088. hWnd = (HWND)lParam;
  2089. if( hWnd != NULL && ::IsWindow(hWnd) )
  2090. {
  2091. MSG _msg;
  2092. for( ; ::PeekMessage( &_msg, hWnd, WM_NCPAINT, WM_NCPAINT, PM_REMOVE ); );
  2093. ::PostMessage( hWnd, WM_NCACTIVATE, TRUE, 0 );
  2094. }
  2095. }
  2096. }
  2097. }
  2098. break;
  2099. case WM_WINDOWPOSCHANGED:
  2100. case WM_WINDOWPOSCHANGING:
  2101. case WM_SIZE:
  2102. if( ! NcFrameImpl_IsSupported() )
  2103. break;
  2104. if( NcFrameImpl_IsDwmBased() )
  2105. break;
  2106. if( NcFrameImpl_IsNcLocked() )
  2107. return true;
  2108. break;
  2109. case WM_SETICON:
  2110. if( wParam == ICON_SMALL && ((HICON)lParam) != NULL )
  2111. {
  2112. m_iconNcFrameImpl_QueryCache.AssignFromHICON( ((HICON)lParam), true );
  2113. m_iconNcFrameImpl_QueryCache.Scale( CSize(16,16) );
  2114. } // if( wParam == ICON_SMALL && ((HICON)lParam) != NULL )
  2115. break;
  2116. case WM_NCACTIVATE:
  2117. {
  2118. if( ! NcFrameImpl_IsSupported() )
  2119. break;
  2120. if( NcFrameImpl_IsDwmBased() )
  2121. break;
  2122. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  2123. ASSERT( hWndOwn != NULL && ::IsWindow(hWndOwn) );
  2124. if( m_pNcFrameImplBridge != NULL )
  2125. {
  2126. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  2127. if( hWnd != NULL )
  2128. {
  2129. ::InvalidateRect( hWnd, NULL, TRUE );
  2130. //::UpdateWindow( hWnd );
  2131. }
  2132. if( NcFrameImpl_IsDwmCaptionReplacement() )
  2133. {
  2134. CExtControlBar * pBar = DYNAMIC_DOWNCAST( CExtControlBar, CWnd::FromHandlePermanent( hWnd ) );
  2135. if( pBar != NULL )
  2136. {
  2137. INT nIndex, nCount = pBar->AnimationSite_ClientGetCount();
  2138. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  2139. {
  2140. CExtAnimationClient * pAC = pBar->AnimationSite_ClientGetAt( nIndex );
  2141. ASSERT( pAC != NULL );
  2142. pBar->AnimationSite_ClientProgressStop( pAC );
  2143. pAC->AnimationClient_StateGet( false ).Empty();
  2144. pAC->AnimationClient_StateGet( true ).Empty();
  2145. } // for( nIndex = 0; nIndex < nCount; nIndex ++ )
  2146. } // if( pBar != NULL )
  2147. if( m_pNcFrameImplBridge != NULL )
  2148. {
  2149. if( hWnd != NULL && ::IsWindow( hWnd ) )
  2150. ::RedrawWindow(
  2151. hWnd,
  2152. NULL,
  2153. NULL,
  2154. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_ALLCHILDREN
  2155. );
  2156. }
  2157. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  2158. break;
  2159. } // if( NcFrameImpl_IsDwmCaptionReplacement() )
  2160. }
  2161. if( NcFrameImpl_IsDwmBased() )
  2162. break;
  2163. if( pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) ) )
  2164. {
  2165. pWndFrameImpl->SetRedraw( FALSE );
  2166. struct friendly_wnd_t : public CWnd { friend class CExtNcFrameImpl; };
  2167. lResult = ((friendly_wnd_t*)pWndFrameImpl)->DefWindowProc( message, wParam, lParam );
  2168. pWndFrameImpl->SetRedraw( TRUE );
  2169. pWndFrameImpl->RedrawWindow(
  2170. NULL,
  2171. NULL,
  2172. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_ALLCHILDREN
  2173. );
  2174. }
  2175. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  2176.   lResult = 1;
  2177. }
  2178. if( ! m_bNcFrameImpl_NcInitPassed )
  2179. {
  2180. m_bNcFrameImpl_NcInitPassed = true;
  2181. break;
  2182. }
  2183. return true;
  2184. case WM_CREATE:
  2185. NcFrameImpl_MapHtRects_Clean();
  2186. NcFrameImpl_AdjustVistaDwmCompatibilityIssues();
  2187. if( NcFrameImpl_IsSupported() )
  2188. NcFrameImpl_RecalcNcFrame();
  2189. break;
  2190. case WM_INITDIALOG:
  2191. NcFrameImpl_AdjustVistaDwmCompatibilityIssues();
  2192. if( NcFrameImpl_IsSupported()
  2193. && ( ! NcFrameImpl_IsDwmBased() )
  2194. )
  2195. {
  2196. CExtPaintManager * pPM = NcFrameImpl_GetPM();
  2197. ASSERT_VALID( pPM );
  2198. INT nCaptionHeightSkinned = pPM->NcFrame_GetCaptionHeight( true, pWndFrameImpl );
  2199. if( nCaptionHeightSkinned > 0 )
  2200. {
  2201. INT nCaptionHeightDefault = ::GetSystemMetrics( SM_CYCAPTION );
  2202. INT nCaptionHeightDifference = nCaptionHeightSkinned - nCaptionHeightDefault;
  2203. if( nCaptionHeightDifference != 0 )
  2204. {
  2205. WINDOWPLACEMENT _wp;
  2206. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  2207. _wp.length = sizeof(WINDOWPLACEMENT);
  2208. if( ::GetWindowPlacement( pWndFrameImpl->m_hWnd, &_wp ) )
  2209. {
  2210. _wp.rcNormalPosition.bottom += nCaptionHeightDifference;
  2211. // ::SetWindowPlacement( pWndFrameImpl->m_hWnd, &_wp );
  2212. if( _wp.showCmd == SW_SHOWNORMAL || _wp.showCmd == SW_RESTORE )
  2213. pWndFrameImpl->SetWindowPos(
  2214. NULL,
  2215. 0,
  2216. 0,
  2217. _wp.rcNormalPosition.right - _wp.rcNormalPosition.left,
  2218. _wp.rcNormalPosition.bottom - _wp.rcNormalPosition.top,
  2219. SWP_NOMOVE|SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOREDRAW
  2220. );
  2221. }
  2222. }
  2223. }
  2224. }
  2225. NcFrameImpl_SetupRgn();
  2226. break;
  2227. case WM_ACTIVATEAPP:
  2228. if( wParam == 0 )
  2229. m_bNcFrameImpl_IsActive = false;
  2230. else
  2231. m_bNcFrameImpl_IsActive = NcFrameImpl_IsActive();
  2233. if( NcFrameImpl_IsSupported()
  2234. && ( ! NcFrameImpl_IsDwmBased() )
  2235. && m_pNcFrameImplBridge != NULL
  2236. )
  2237. {
  2238. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  2239. if( hWnd != NULL )
  2240. {
  2241. ::InvalidateRect( hWnd, NULL, TRUE );
  2242. //::UpdateWindow( hWnd );
  2243. }
  2244. }
  2246. if( (! NcFrameImpl_IsForceEmpty() )
  2247. || (! NcFrameImpl_IsForceEmptyNcBorderEmpty() )
  2248. )
  2249. pWndFrameImpl->SendMessage( WM_NCPAINT );
  2250. else
  2251. {
  2252. if( NcFrameImpl_IsDwmCaptionReplacement() )
  2253. {
  2254. if( m_pNcFrameImplBridge != NULL )
  2255. {
  2256. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  2257. if( hWnd != NULL && ::IsWindow( hWnd ) )
  2258. ::RedrawWindow(
  2259. hWnd,
  2260. NULL,
  2261. NULL,
  2262. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_ALLCHILDREN
  2263. );
  2264. }
  2265. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  2266. ASSERT( hWndOwn != NULL && ::IsWindow(hWndOwn) );
  2267. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  2268. break;
  2269. } // if( NcFrameImpl_IsDwmCaptionReplacement() )
  2270. }
  2271. break;
  2272. case WM_ACTIVATE:
  2273. {
  2274. m_bNcFrameImpl_IsActive = ( LOWORD(wParam) == WA_INACTIVE ) ? false : true;
  2275. if( ! m_bNcFrameImpl_IsActive )
  2276. {
  2277. HWND hWnd = ::GetActiveWindow();
  2278. if( hWnd != NULL )
  2279. {
  2280. CWnd * pWnd = CWnd::FromHandlePermanent( hWnd );
  2281. if( pWnd != NULL
  2282. && ( pWnd == pWndFrameImpl
  2283. || pWnd->IsKindOf( RUNTIME_CLASS(CMiniFrameWnd) )
  2284. )
  2285. )
  2286. m_bNcFrameImpl_IsActive = true;