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

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

界面编程

开发平台：

Visual C++

ExtNcFrame.cpp：源码内容
  1. }
  2. }
  3. if( pWndFrameImpl->IsWindowEnabled()
  4. && ( (! NcFrameImpl_IsForceEmpty() )
  5. || (! NcFrameImpl_IsForceEmptyNcBorderEmpty() )
  6. )
  7. )
  8. {
  9. NcFrameImpl_DelayRgnAdjustment();
  10. NcFrameImpl_SetupRgn();
  11. }
  12. else
  13. {
  14. if( NcFrameImpl_IsDwmCaptionReplacement() )
  15. {
  16. if( m_pNcFrameImplBridge != NULL )
  17. {
  18. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  19. if( hWnd != NULL && ::IsWindow( hWnd ) )
  20. ::RedrawWindow(
  21. hWnd,
  22. NULL,
  23. NULL,
  24. RDW_INVALIDATE|RDW_UPDATENOW|RDW_ERASE|RDW_ERASENOW|RDW_ALLCHILDREN
  25. );
  26. }
  27. } // if( NcFrameImpl_IsDwmCaptionReplacement() )
  28. }
  29. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  30. ASSERT( hWndOwn != NULL && ::IsWindow(hWndOwn) );
  31. ::SendMessage( hWndOwn, WM_NCPAINT, 0L, 0L );
  32. if( m_pNcFrameImplBridge != NULL )
  33. {
  34. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  35. if( hWnd != NULL )
  36. {
  37. ::InvalidateRect( hWnd, NULL, TRUE );
  38. ::UpdateWindow( hWnd );
  39. }
  40. }
  41. }
  42. break;
  43. case WM_NCLBUTTONDBLCLK:
  44. if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  45. {
  46. if( wParam == HTCAPTION || wParam == HTSYSMENU || wParam == HTTOP )
  47. {
  48. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  49. if( hWnd != NULL && ::IsWindow( hWnd ) )
  50. {
  51. CPoint ptCursor;
  52. ::GetCursorPos( &ptCursor );
  53. ::ScreenToClient( hWnd, &ptCursor );
  54. CExtToolControlBar * pBar = DYNAMIC_DOWNCAST( CExtToolControlBar, CWnd::FromHandlePermanent( hWnd ) );
  55. if( pBar != NULL )
  56. {
  57. INT nToolBarButtonHT = pBar->HitTest( ptCursor );
  58. if( nToolBarButtonHT >= 0 )
  59. {
  60. lResult = ::SendMessage( hWnd, WM_LBUTTONDBLCLK, 0, MAKELPARAM( ptCursor.x, ptCursor.y ) );
  61. return true;
  62. }
  63. }
  64. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  65. } // if( wParam == ...
  66. break;
  67. } // if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  68. if( NcFrameImpl_IsForceEmpty() )
  69. break;
  70. if( wParam == HTCAPTION )
  71. {
  72. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  73. ASSERT( hWndOwn != NULL && ::IsWindow(hWndOwn) );
  74. bool bZoomed = ( ::IsZoomed( hWndOwn ) ) ? true : false;
  75. UINT nSC = bZoomed ? SC_RESTORE : SC_MAXIMIZE;
  76. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_RESTORE )
  77. || NcFrameImpl_OnQuerySystemCommandEnabled( SC_MAXIMIZE )
  78. )
  79. ::SendMessage( hWndOwn, WM_SYSCOMMAND, WPARAM(nSC), lParam );
  80. lResult = 0L;
  81. return true;
  82. } // if( wParam == HTCAPTION )
  83. else if( wParam == HTSYSMENU )
  84. {
  85. if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_CLOSE ) )
  86. {
  87. HWND hWndOwn = pWndFrameImpl->GetSafeHwnd();
  88. ::SendMessage( hWndOwn, WM_SYSCOMMAND, SC_CLOSE, lParam );
  89. if( ::IsWindow( hWndOwn ) )
  90. pWndFrameImpl->SendMessage( WM_NCPAINT );
  91. lResult = 0L;
  92. return true;
  93. } // if( NcFrameImpl_OnQuerySystemCommandEnabled( SC_CLOSE ) )
  94. } // else if( wParam == HTSYSMENU )
  95. break;
  96. case WM_NCHITTEST:
  97. if( ! NcFrameImpl_IsSupported() )
  98. break;
  99. if( NcFrameImpl_IsDwmCaptionReplacement() )
  100. {
  101. if( g_PaintManager.m_DWM.DwmDefWindowProc(
  102. pWndFrameImpl->m_hWnd,
  103. message,
  104. wParam,
  105. lParam,
  106. &lResult
  107. )
  108. )
  109. return true;
  110. INT nV = ::GetSystemMetrics( SM_CYFRAME );
  111. INT nCV = nV + ::GetSystemMetrics( SM_CYCAPTION );
  112. if( pWndFrameImpl->IsZoomed() )
  113. nCV += nV;
  114. CPoint pointScreen;
  115. if( ::GetCursorPos( &pointScreen ) )
  116. {
  117. CRect rc;
  118. pWndFrameImpl->GetWindowRect( &rc );
  119. rc.bottom = rc.top + nV;
  120. if( rc.PtInRect( pointScreen ) )
  121. {
  122. lResult = HTTOP;
  123. return true;
  124. }
  125. rc.bottom = rc.top + nCV;
  126. rc.DeflateRect( ::GetSystemMetrics(SM_CXFRAME), 0 );
  127. if( rc.PtInRect( pointScreen ) )
  128. {
  129. lResult = HTCAPTION;
  130. return true;
  131. }
  132. }
  133. }
  134. if( NcFrameImpl_IsDwmBased() )
  135. break;
  136. if( ! NcFrameImpl_IsForceEmpty() )
  137. {
  138. if( m_bNcFrameImpl_HelperInsideNcHitTest )
  139. {
  140. lResult = HTNOWHERE;
  141. return true;
  142. }
  143. m_bNcFrameImpl_HelperInsideNcHitTest = true;
  144. CRect rcWnd;
  145. pWndFrameImpl->GetWindowRect( &rcWnd );
  146. CPoint pointScreen, pointWnd( -32767, -32767 );
  147. if( ::GetCursorPos( &pointScreen ) )
  148. {
  149. pointWnd = pointScreen;
  150. pointWnd -= rcWnd.TopLeft();
  151. }
  152. if( m_pNcFrameImplBridge != NULL )
  153. {
  154. HRGN hRgn = m_pNcFrameImplBridge->NcFrameImplBridge_GetNcResizingHRGN();
  155. if( hRgn != NULL
  156. && ::PtInRegion( hRgn, pointWnd.x, pointWnd.y )
  157. )
  158. {
  159. m_nNcFrameImpl_LastExternalNcHT = HTTOPLEFT;
  160. lResult = HTTOPLEFT;
  161. //NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  162. ::SetCursor( ::LoadCursor( NULL, IDC_SIZENWSE ) );
  163. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  164. return true;
  165. }
  166. }
  167. CRect rcTmp = NcFrameImpl_GetNcScRect( SC_CLOSE );
  168. if( rcTmp.PtInRect(pointWnd) )
  169. {
  170. m_nNcFrameImpl_LastExternalNcHT = HTCLOSE;
  171. lResult = HTCAPTION;
  172. NcFrameImpl_CheckCursor( pointScreen, LPARAM(HTCLOSE) );
  173. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  174. if( m_pNcFrameImplBridge != NULL )
  175. {
  176. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  177. if( hWnd != NULL && ::IsWindow( hWnd ) )
  178. {
  179. rcTmp.OffsetRect( rcWnd.TopLeft() );
  180. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+0 );
  181. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+1 );
  182. ::InvalidateRect( hWnd, &rcTmp, TRUE );
  183. if( m_rcNcFrameImpl_LastExternalNcHT != rcTmp )
  184. {
  185. ::InvalidateRect( hWnd, &m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  186. m_rcNcFrameImpl_LastExternalNcHT = rcTmp;
  187. }
  188. //::UpdateWindow( hWnd );
  189. }
  190. }
  191. return true;
  192. }
  193. rcTmp = NcFrameImpl_GetNcScRect( SC_MINIMIZE );
  194. if( rcTmp.PtInRect(pointWnd) )
  195. {
  196. m_nNcFrameImpl_LastExternalNcHT = HTMINBUTTON;
  197. lResult = HTCAPTION;
  198. NcFrameImpl_CheckCursor( pointScreen, LPARAM(HTMINBUTTON) );
  199. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  200. if( m_pNcFrameImplBridge != NULL )
  201. {
  202. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  203. if( hWnd != NULL && ::IsWindow( hWnd ) )
  204. {
  205. rcTmp.OffsetRect( rcWnd.TopLeft() );
  206. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+0 );
  207. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+1 );
  208. ::InvalidateRect( hWnd, &rcTmp, TRUE );
  209. if( m_rcNcFrameImpl_LastExternalNcHT != rcTmp )
  210. {
  211. ::InvalidateRect( hWnd, &m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  212. m_rcNcFrameImpl_LastExternalNcHT = rcTmp;
  213. }
  214. //::UpdateWindow( hWnd );
  215. }
  216. }
  217. return true;
  218. }
  219. rcTmp = NcFrameImpl_GetNcScRect( SC_MAXIMIZE );
  220. if( rcTmp.PtInRect(pointWnd) )
  221. {
  222. m_nNcFrameImpl_LastExternalNcHT = HTMAXBUTTON;
  223. lResult = HTCAPTION;
  224. NcFrameImpl_CheckCursor( pointScreen, LPARAM(HTMAXBUTTON) );
  225. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  226. if( m_pNcFrameImplBridge != NULL )
  227. {
  228. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  229. if( hWnd != NULL && ::IsWindow( hWnd ) )
  230. {
  231. rcTmp.OffsetRect( rcWnd.TopLeft() );
  232. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+0 );
  233. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+1 );
  234. ::InvalidateRect( hWnd, &rcTmp, TRUE );
  235. if( m_rcNcFrameImpl_LastExternalNcHT != rcTmp )
  236. {
  237. ::InvalidateRect( hWnd, &m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  238. m_rcNcFrameImpl_LastExternalNcHT = rcTmp;
  239. }
  240. }
  241. }
  242. return true;
  243. }
  244. rcTmp = NcFrameImpl_GetNcScRect( SC_CONTEXTHELP );
  245. if( rcTmp.PtInRect(pointWnd) )
  246. {
  247. m_nNcFrameImpl_LastExternalNcHT = HTHELP;
  248. lResult = HTCAPTION;
  249. NcFrameImpl_CheckCursor( pointScreen, LPARAM(HTHELP) );
  250. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  251. if( m_pNcFrameImplBridge != NULL )
  252. {
  253. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  254. if( hWnd != NULL && ::IsWindow( hWnd ) )
  255. {
  256. rcTmp.OffsetRect( rcWnd.TopLeft() );
  257. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+0 );
  258. ::ScreenToClient( hWnd, ((LPPOINT)(&rcTmp))+1 );
  259. ::InvalidateRect( hWnd, &rcTmp, TRUE );
  260. if( m_rcNcFrameImpl_LastExternalNcHT != rcTmp )
  261. {
  262. ::InvalidateRect( hWnd, &m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  263. m_rcNcFrameImpl_LastExternalNcHT = rcTmp;
  264. }
  265. }
  266. }
  267. return true;
  268. }
  270. // MINMAXINFO _mmi, * pMinMaxInfo = NULL;
  271. // ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  272. // CExtPaintManager::monitor_parms_t _mp;
  273. // CExtPaintManager::stat_GetMonitorParms( _mp, pWndFrameImpl );
  274. // _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  275. // _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  276. // _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  277. // _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  278. // _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  279. // _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  280. // _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  281. // _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  282. // if( pWndFrameImpl->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  283. // pMinMaxInfo = &_mmi;
  284. MINMAXINFO * pMinMaxInfo = &m_NcFrameImpl_MinMaxInfo_Cache;
  286. pWndFrameImpl->ModifyStyle( WS_CAPTION|WS_BORDER, 0, 0 );
  287. Sleep( 1 ); // this line of code magically fixes 50-100% CPU eating problem when moving mouse over skinable NC areas
  288. if( NcFrameImpl_GetNcHtRect(HTTOPLEFT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  289. {
  290. m_nNcFrameImpl_LastExternalNcHT = HTTOPLEFT;
  291. lResult = HTTOPLEFT;
  292. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  293. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  294. return true;
  295. }
  296. if( NcFrameImpl_GetNcHtRect(HTTOPRIGHT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  297. {
  298. m_nNcFrameImpl_LastExternalNcHT = HTTOPRIGHT;
  299. lResult = HTTOPRIGHT;
  300. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  301. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  302. return true;
  303. }
  304. if( NcFrameImpl_GetNcHtRect(HTBOTTOMLEFT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  305. {
  306. m_nNcFrameImpl_LastExternalNcHT = HTBOTTOMLEFT;
  307. lResult = HTBOTTOMLEFT;
  308. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  309. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  310. return true;
  311. }
  312. if( NcFrameImpl_GetNcHtRect(HTBOTTOMRIGHT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  313. {
  314. m_nNcFrameImpl_LastExternalNcHT = HTBOTTOMRIGHT;
  315. lResult = HTBOTTOMRIGHT;
  316. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  317. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  318. return true;
  319. }
  320. if( NcFrameImpl_GetNcHtRect(HTTOP,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  321. {
  322. m_nNcFrameImpl_LastExternalNcHT = HTTOP;
  323. lResult = HTTOP;
  324. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  325. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  326. return true;
  327. }
  328. if( NcFrameImpl_GetNcHtRect(HTBOTTOM,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  329. {
  330. m_nNcFrameImpl_LastExternalNcHT = HTBOTTOM;
  331. lResult = HTBOTTOM;
  332. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  333. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  334. return true;
  335. }
  336. if( NcFrameImpl_GetNcHtRect(HTLEFT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  337. {
  338. m_nNcFrameImpl_LastExternalNcHT = HTLEFT;
  339. lResult = HTLEFT;
  340. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  341. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  342. return true;
  343. }
  344. if( NcFrameImpl_GetNcHtRect(HTRIGHT,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  345. {
  346. m_nNcFrameImpl_LastExternalNcHT = HTRIGHT;
  347. lResult = HTRIGHT;
  348. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  349. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  350. return true;
  351. }
  352. if( NcFrameImpl_GetNcHtRect(HTSYSMENU,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  353. {
  354. m_nNcFrameImpl_LastExternalNcHT = HTSYSMENU;
  355. lResult = HTSYSMENU;
  356. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  357. // if( pWndFrameImpl->IsIconic() && (! CExtPopupMenuWnd::IsKeyPressed( VK_LBUTTON) ) )
  358. // lResult = HTNOWHERE;
  359. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  360. return true;
  361. }
  362. if( NcFrameImpl_GetNcHtRect(HTCAPTION,false,false,false,pMinMaxInfo,&rcWnd).PtInRect(pointWnd) )
  363. {
  364. m_nNcFrameImpl_LastExternalNcHT = HTCAPTION;
  365. lResult = HTCAPTION;
  366. NcFrameImpl_CheckCursor( pointScreen, LPARAM(lResult) );
  367. // if( pWndFrameImpl->IsIconic() && (! CExtPopupMenuWnd::IsKeyPressed( VK_LBUTTON) ) )
  368. // lResult = HTNOWHERE;
  369. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  370. return true;
  371. }
  372. m_bNcFrameImpl_HelperInsideNcHitTest = false;
  373. } // if( ! NcFrameImpl_IsForceEmpty() )
  374. lResult = HTCLIENT;
  375. return true;
  376. //break;
  377. case WM_NCCALCSIZE:
  378. if( pWndFrameImpl->IsIconic() )
  379. break;
  380. { // BLOCK: adjust MDI client area styles
  381. HWND hWndMdiClient = CExtControlBar::stat_FindMdiClientHWND( pWndFrameImpl->m_hWnd );
  382. if( hWndMdiClient != NULL )
  383. {
  384. __EXT_MFC_LONG_PTR dwStyle = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_STYLE );
  385. if( (dwStyle&WS_BORDER) != 0 )
  386. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_STYLE, dwStyle&(~(WS_BORDER)) );
  387. __EXT_MFC_LONG_PTR dwStyleEx = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_EXSTYLE );
  388. if( (dwStyleEx&(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) != 0 )
  389. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_EXSTYLE, (dwStyleEx&(~(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)))|WS_EX_CLIENTEDGE );
  390. }
  391. } // BLOCK: adjust MDI client area styles
  392. if( pWndFrameImpl->IsKindOf( RUNTIME_CLASS( CMDIChildWnd ) )
  393. && m_bNcFrameImpl_IsActive
  394. && (pWndFrameImpl->GetStyle()&WS_MAXIMIZE) != 0
  395. )
  396. break;
  397. else
  398. {
  399. bool bNcCaptionMerging = false;
  400. if( m_pNcFrameImplBridge != NULL )
  401. {
  402. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  403. if( hWnd != NULL
  404. && m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryCaptionMergeMode()
  405. )
  406. {
  407. bNcCaptionMerging = true;
  408. if( ! m_bNcFrameImpl_CreatePassed )
  409. return false;
  410. if( NcFrameImpl_IsNcLocked() )
  411. return false;
  412. CFrameWnd * pFrame = DYNAMIC_DOWNCAST( CFrameWnd, pWndFrameImpl );
  413. if( pFrame != NULL )
  414. {
  415. bool bIsLoading = false;
  416. if( CExtControlBar::ProfileBarStateIsSerializing( pFrame, &bIsLoading ) )
  417. {
  418. if( bIsLoading )
  419. return false;
  420. }
  421. }
  422. }
  423. }
  424. CExtUxTheme::__EXT_UX_MARGINS _margins = { 0, 0, 0, 0 };
  425. bool bDwmMode = NcFrameImpl_IsDwmBased();
  426. if( bDwmMode && ( ! bNcCaptionMerging ) )
  427. {
  428. m_bNcFrameImpl_DwmSurfaceInitializationComplete = false;
  429. g_PaintManager.m_DWM.DwmExtendFrameIntoClientArea( pWndFrameImpl->m_hWnd, &_margins );
  430. return false;
  431. }
  432. if( ! NcFrameImpl_IsNcLocked() )
  433. {
  434. NCCALCSIZE_PARAMS * pNCCSP =
  435. reinterpret_cast < NCCALCSIZE_PARAMS * > ( lParam );
  436. ASSERT( pNCCSP != NULL );
  437. if( bNcCaptionMerging && bDwmMode )
  438. {
  439. INT nV = ::GetSystemMetrics( SM_CYFRAME );
  440. INT nCV = nV + ::GetSystemMetrics( SM_CYCAPTION );
  441. INT nLeftRight = ::GetSystemMetrics( SM_CXFRAME ), nTopBottom = nV;
  442. if( pWndFrameImpl->IsZoomed() )
  443. nCV += nV;
  444. _margins.cyTopHeight = nCV;
  445. pNCCSP->rgrc[0].left += nLeftRight;
  446. pNCCSP->rgrc[0].right -= nLeftRight;
  447. pNCCSP->rgrc[0].bottom -= nTopBottom;
  448. } // if( bNcCaptionMerging && bDwmMode )
  449. else if( NcFrameImpl_IsForceEmpty() )
  450. {
  451. if( ! NcFrameImpl_IsForceEmptyNcBorderEmpty() )
  452. {
  453. CRect rc = NcFrameImpl_GetForceEmptyNcBorder();
  454. if( ! bNcCaptionMerging )
  455. pNCCSP->rgrc[0].top += rc.top;
  456. pNCCSP->rgrc[0].left += rc.left;
  457. pNCCSP->rgrc[0].right -= rc.right;
  458. pNCCSP->rgrc[0].bottom -= rc.bottom;
  459. } // if( ! NcFrameImpl_IsForceEmptyNcBorderEmpty() )
  460. } // else if( NcFrameImpl_IsForceEmpty() )
  461. else
  462. {
  463. CRect rcNcBorders, rcThemePadding;
  464. NcFrameImpl_GetPM()->NcFrame_GetMetrics(
  465. rcNcBorders,
  466. rcThemePadding,
  467. pWndFrameImpl
  468. );
  470. if( ! bNcCaptionMerging )
  471. pNCCSP->rgrc[0].top += rcThemePadding.top;
  472. pNCCSP->rgrc[0].left    += rcThemePadding.left;
  473. pNCCSP->rgrc[0].right   -= rcThemePadding.right;
  474. pNCCSP->rgrc[0].bottom  -= rcThemePadding.bottom;
  475. // bool bMaximized = ( ( pWndFrameImpl->GetStyle() & WS_MAXIMIZE ) != 0 ) ? true : false;
  476. // if( bMaximized )
  477. // {
  478. // pNCCSP->rgrc[0].left   -= rcNcBorders.left;
  479. // pNCCSP->rgrc[0].right  += rcNcBorders.right;
  480. // pNCCSP->rgrc[0].top    -= rcNcBorders.top;
  481. // pNCCSP->rgrc[0].bottom += rcNcBorders.bottom;
  482. // }
  483. if( m_pNcFrameImplBridge != NULL
  484. && m_pNcFrameImplBridge->NcFrameImplBridge_OnQueryCaptionMergeMode()
  485. )
  486. pNCCSP->rgrc[0].top -=
  487. NcFrameImpl_GetPM() -> 
  488. NcFrame_GetCaptionHeight(
  489. NcFrameImpl_IsActive(),
  490. NcFrameImpl_GetFrameWindow()
  491. );
  492. }
  493. WINDOWPLACEMENT _wp;
  494. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  495. if( bDwmMode )
  496. GetWindowPlacement( &_wp );
  497. if( m_pNcFrameImplBridge != NULL && NcFrameImpl_IsDwmCaptionReplacement()  )
  498. {
  499. m_pNcFrameImplBridge->NcFrameImpl_PreSetWindowPlacement( _wp );
  500. m_pNcFrameImplBridge->NcFrameImpl_AdjustDwmArea( _margins );
  501. }
  502. m_bNcFrameImpl_DwmSurfaceInitializationComplete = true;
  503. g_PaintManager.m_DWM.DwmExtendFrameIntoClientArea( pWndFrameImpl->m_hWnd, &_margins );
  504. if( m_pNcFrameImplBridge != NULL && NcFrameImpl_IsDwmCaptionReplacement()  )
  505. m_pNcFrameImplBridge->NcFrameImpl_PostSetWindowPlacement( _wp );
  506. } // if( ! NcFrameImpl_IsNcLocked() )
  507. lResult = 0;
  508. return true;
  509. }
  511. case WM_NCPAINT:
  512. if( ! NcFrameImpl_IsDwmBased() )
  513. {
  514. if( (! NcFrameImpl_IsForceEmpty() )
  515. // || m_bNcFrameImpl_RestoreEnabledState
  516. )
  517. {
  518. CMDIChildWnd * pWndMdiChild = DYNAMIC_DOWNCAST( CMDIChildWnd, pWndFrameImpl );
  519. if( pWndMdiChild != NULL )
  520. {
  521. HWND hWndMDIClient = ::GetParent( pWndMdiChild->m_hWnd );
  522. HWND hWndActiveChildFrame = (HWND) ::SendMessage( hWndMDIClient, WM_MDIGETACTIVE, 0, NULL );
  523. if( hWndActiveChildFrame != NULL )
  524. m_bNcFrameImpl_IsActive = ( hWndActiveChildFrame == pWndMdiChild->m_hWnd ) ? true : false;
  525. }
  526. CWindowDC dcPaint( pWndFrameImpl );
  527. NcFrameImpl_OnNcPaint( dcPaint );
  528. lResult = 0;
  529. return true;
  530. }
  531. } //if( ! NcFrameImpl_IsDwmBased() )
  532. break;
  533. case WM_NCLBUTTONUP:
  534. if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  535. {
  536. if( wParam == HTCAPTION || wParam == HTSYSMENU || wParam == HTTOP )
  537. {
  538. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  539. if( hWnd != NULL && ::IsWindow( hWnd ) )
  540. {
  541. CPoint ptCursor;
  542. ::GetCursorPos( &ptCursor );
  543. ::ScreenToClient( hWnd, &ptCursor );
  544. CExtToolControlBar * pBar = DYNAMIC_DOWNCAST( CExtToolControlBar, CWnd::FromHandlePermanent( hWnd ) );
  545. if( pBar != NULL )
  546. {
  547. INT nToolBarButtonHT = pBar->HitTest( ptCursor );
  548. if( nToolBarButtonHT >= 0 )
  549. {
  550. lResult = ::SendMessage( hWnd, WM_LBUTTONUP, 0, MAKELPARAM( ptCursor.x, ptCursor.y ) );
  551. return true;
  552. }
  553. }
  554. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  555. } // if( wParam == ...
  556. break;
  557. } // if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  558. if( ! NcFrameImpl_IsSupported() )
  559. break;
  560. return true;
  561. // break;
  562. case WM_NCLBUTTONDOWN:
  563. {
  564. if( ! NcFrameImpl_IsSupported() )
  565. break;
  566. #if (!defined __EXT_MFC_NO_RIBBON_BAR)
  567. if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  568. {
  569. if( wParam == HTCAPTION || wParam == HTSYSMENU || wParam == HTTOP )
  570. {
  571. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  572. if( hWnd != NULL && ::IsWindow( hWnd ) )
  573. {
  574. CPoint ptCursor;
  575. ::GetCursorPos( &ptCursor );
  576. ::ScreenToClient( hWnd, &ptCursor );
  577. CExtToolControlBar * pBar = DYNAMIC_DOWNCAST( CExtToolControlBar, CWnd::FromHandlePermanent( hWnd ) );
  578. if( pBar != NULL )
  579. {
  580. CExtPaintManager * pPM = NcFrameImpl_GetPM();
  581. ASSERT_VALID( pPM );
  582. if( ( (! pPM->Ribbon_FileButtonIsItegrationSupported() )
  583. || pPM->Ribbon_IsSystemMenuIconPresent()
  584. )
  585. && pBar->IsKindOf( RUNTIME_CLASS(CExtMenuControlBar) )
  586. )
  587. {
  588. CRect rc;
  589. pBar->GetClientRect( &rc );
  590. rc.right = rc.left + ::GetSystemMetrics(SM_CXICON) / 2;
  591. rc.bottom = rc.top + ::GetSystemMetrics(SM_CYICON) / 2;
  592. rc.OffsetRect( 0, ::GetSystemMetrics(SM_CXFRAME) );
  593. if( rc.PtInRect( ptCursor ) )
  594. {
  595. ((CExtMenuControlBar*)pBar)->TrackMainFrameSystemMenu();
  596. return true;
  597. }
  598. }
  599. INT nToolBarButtonHT = pBar->HitTest( ptCursor );
  600. if( nToolBarButtonHT >= 0 )
  601. {
  602. lResult = ::SendMessage( hWnd, WM_LBUTTONDOWN, 0, MAKELPARAM( ptCursor.x, ptCursor.y ) );
  603. return true;
  604. }
  605. }
  606. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  607. } // if( wParam == ...
  608. break;
  609. } // if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  610. #endif // #if (!defined __EXT_MFC_NO_RIBBON_BAR)
  611. if( NcFrameImpl_IsForceEmpty() )
  612. break;
  614. if( ( ! ( m_bNcFrameImpl_Resizing || m_bNcFrameImpl_Moving ) )
  615. && ( ! NcFrameImpl_IsDwmBased() )
  616. )
  617. m_bNcFrameImpl_Resizing = m_bNcFrameImpl_Moving = true;
  618. if( m_bNcFrameImpl_Resizing || m_bNcFrameImpl_Moving )
  619. {
  620. if( NcFrameImpl_IsDwmBased() )
  621. m_bNcFrameImpl_Resizing = m_bNcFrameImpl_Moving = false;
  622. if( ::GetActiveWindow() != pWndFrameImpl->m_hWnd )
  623. pWndFrameImpl->SetActiveWindow();
  624. }
  626. m_nNcFrameImpl_ScTrackedButtonPressed = 0;
  627. CRect rcWnd;
  628. pWndFrameImpl->GetWindowRect( &rcWnd );
  629. CPoint pointWnd;
  630. ::GetCursorPos( &pointWnd );
  631. pointWnd -= rcWnd.TopLeft();
  632. if( m_rcNcFrameImpl_ScClose.PtInRect( pointWnd ) )
  633. m_nNcFrameImpl_ScTrackedButtonPressed = SC_CLOSE;
  634. else if( m_rcNcFrameImpl_ScMaximize.PtInRect( pointWnd ) )
  635. m_nNcFrameImpl_ScTrackedButtonPressed = SC_MAXIMIZE;
  636. else if( m_rcNcFrameImpl_ScMinimize.PtInRect( pointWnd ) )
  637. m_nNcFrameImpl_ScTrackedButtonPressed = SC_MINIMIZE;
  638. else if( m_rcNcFrameImpl_ScHelp.PtInRect( pointWnd ) )
  639. m_nNcFrameImpl_ScTrackedButtonPressed = SC_CONTEXTHELP;
  640. if( m_nNcFrameImpl_ScTrackedButtonPressed != 0 )
  641. {
  642. HWND hWnd = NULL;
  643. if( m_pNcFrameImplBridge != NULL
  644. && ( hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() ) != NULL
  645. && (! m_rcNcFrameImpl_LastExternalNcHT.IsRectEmpty() )
  646. )
  647. ::InvalidateRect( hWnd, m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  648. pWndFrameImpl->SendMessage( WM_NCPAINT );
  649. if( m_nNcFrameImpl_ScTrackedButtonPressed != 0
  650. && CWnd::GetCapture() != pWndFrameImpl
  651. )
  652. pWndFrameImpl->SetCapture();
  653. } // if( m_nNcFrameImpl_ScTrackedButtonPressed != 0 )
  654. if( /*
  655. m_bNcFrameImpl_Moving
  656. &&*/
  657. wParam == HTSYSMENU
  658. )
  659. { // system menu tracking code
  660. lResult = 0;
  661. return false;
  662. } // system menu tracking code
  663. else if(
  664. m_bNcFrameImpl_Moving
  665. && wParam == HTCAPTION
  666. )
  667. { // track moving loop
  668. DWORD dwStyle = pWndFrameImpl->GetStyle();
  669. static const DWORD dwCheckMask = WS_MAXIMIZE|WS_VISIBLE|WS_DISABLED;
  670. DWORD dwCheckResult = dwStyle&dwCheckMask;
  671. if( dwCheckResult != WS_VISIBLE )
  672. {
  673. lResult = 0;
  674. return true;
  675. }
  676. m_bNcFrameImpl_MovingLoopTracking = true;
  677. HWND hWnd = pWndFrameImpl->GetSafeHwnd();
  678. ::SendMessage( hWnd, WM_ENTERSIZEMOVE, 0L, 0L );
  679. ::SetCapture( hWnd );
  680. CPoint ptStart( short(LOWORD(lParam)), short(HIWORD(lParam)) );
  681. CRect rcWndStart;
  682. ::GetWindowRect( hWnd, rcWndStart );
  683. HANDLE hCurrentThread = ::GetCurrentThread();
  684. int nOldCurrentThreadPriority = ::GetThreadPriority( hCurrentThread );
  685. ::SetThreadPriority( hCurrentThread, THREAD_PRIORITY_ABOVE_NORMAL );
  686. HANDLE hProcess = ::GetCurrentProcess();
  687. DWORD dwOldProcessPriorityClass = ::GetPriorityClass( hProcess );
  688. ::SetPriorityClass( hProcess, HIGH_PRIORITY_CLASS );
  689. bool bStop = false, bStartDetected = false;
  690. for( ; ! bStop ; )
  691. {
  692. ::WaitMessage();
  693. MSG msg;
  694. // Process all the messages in the message queue
  695. while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  696. {
  697. switch( msg.message )
  698. {
  699. case WM_ACTIVATEAPP:
  700. case WM_CANCELMODE:
  701. case WM_LBUTTONDOWN:
  702. case WM_LBUTTONUP:
  703. case WM_LBUTTONDBLCLK:
  704. case WM_MBUTTONDOWN:
  705. case WM_MBUTTONUP:
  706. case WM_MBUTTONDBLCLK:
  707. case WM_RBUTTONDOWN:
  708. case WM_RBUTTONUP:
  709. case WM_RBUTTONDBLCLK:
  710. case WM_NCLBUTTONDOWN:
  711. case WM_NCLBUTTONUP:
  712. case WM_NCLBUTTONDBLCLK:
  713. case WM_NCRBUTTONDOWN:
  714. case WM_NCRBUTTONUP:
  715. case WM_NCRBUTTONDBLCLK:
  716. case WM_NCMBUTTONDOWN:
  717. case WM_NCMBUTTONUP:
  718. case WM_NCMBUTTONDBLCLK:
  719. case WM_CONTEXTMENU:
  720. bStop = true;
  721. break;
  722. case WM_CAPTURECHANGED:
  723. if( hWnd != ((HWND)lParam) )
  724. bStop = true;
  725. break;
  726. case WM_SIZE:
  727. case WM_WINDOWPOSCHANGING:
  728. case WM_WINDOWPOSCHANGED:
  729. case WM_ERASEBKGND:
  730. case WM_NCHITTEST:
  731. case WM_NCMOUSEMOVE:
  732. if( ::IsWindow( hWnd ) )
  733. {
  734. ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE );
  735. continue;
  736. }
  737. bStop = true;
  738. break;
  739. case WM_MOUSEMOVE:
  740. ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE );
  741. if( msg.hwnd == hWnd )
  742. {
  743. // while( ::PeekMessage( &msg, hWnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE ) )
  744. // {
  745. // if( ::PeekMessage( &msg, hWnd, WM_NCLBUTTONUP, WM_NCLBUTTONUP, PM_NOREMOVE ) )
  746. // break;
  747. // }
  748. CPoint pt;
  749. if( ! ::GetCursorPos( &pt ) )
  750. {
  751. bStop = true;
  752. break;
  753. }
  754. if( ( ::__EXT_MFC_GetWindowLong(hWnd,GWL_STYLE) & WS_CHILD ) != 0 )
  755. {
  756. HWND hWndParent = ::GetParent( hWnd );
  757. ASSERT( hWndParent != NULL );
  758. CRect rcWndParent;
  759. ::GetWindowRect( hWndParent, &rcWndParent );
  760. pt.x = max( pt.x, rcWndParent.left );
  761. pt.x = min( pt.x, rcWndParent.right );
  762. pt.y = max( pt.y, rcWndParent.top );
  763. pt.y = min( pt.y, rcWndParent.bottom );
  764. }
  765. CPoint ptOffset(
  766. pt.x - ptStart.x,
  767. pt.y - ptStart.y
  768. );
  769. if( (! bStartDetected )
  770. && abs( ptOffset.x ) < 5
  771. && abs( ptOffset.y ) < 5
  772. )
  773. continue;
  774. bStartDetected = true;
  775. CRect rcWnd = rcWndStart;
  776. rcWnd.OffsetRect( ptOffset );
  777. CRect rcWndCurrent;
  778. ::GetWindowRect( hWnd, &rcWndCurrent );
  779. if( rcWndCurrent != rcWnd )
  780. {
  781. if( ( ::__EXT_MFC_GetWindowLong(hWnd,GWL_STYLE) & WS_CHILD ) != 0 )
  782. {
  783. HWND hWndParent = ::GetParent( hWnd );
  784. ASSERT( hWndParent != NULL );
  785. ::ScreenToClient( hWndParent, ((LPPOINT)&rcWnd) );
  786. ::ScreenToClient( hWndParent, ((LPPOINT)&rcWnd)+1 );
  787. }
  788. CRect rcWndAdjusted = rcWnd;
  789. if( ::SendMessage( hWnd, WM_MOVING, 0L, LPARAM(&rcWndAdjusted) ) != 0L )
  790. rcWnd = rcWndAdjusted;
  791. ::MoveWindow( hWnd, rcWnd.left, rcWnd.top, rcWnd.Width(), rcWnd.Height(), TRUE );
  792. SendMessage( hWnd, WM_NCPAINT, 0, 0 );
  793. CExtPaintManager::stat_PassPaintMessages();
  794. ::Sleep(1);
  795. } // if( rcWndCurrent != rcWnd )
  796. } // if( msg.hwnd == hWnd )
  797.   if( ::IsWindow( hWnd ) )
  798.   continue;
  799. bStop = true;
  800. break;
  801. default:
  802. if( WM_KEYFIRST <= msg.message
  803. && msg.message <= WM_KEYLAST
  804. )
  805. bStop = true;
  806. break;
  807. } // switch( msg.message )
  808. if( ! ::IsWindow( hWnd ) )
  809. bStop = true;
  810. if( bStop )
  811. break;
  812. CWinThread * pThread = AfxGetThread();
  813. if( pThread == NULL )
  814. ::DispatchMessage( &msg );
  815. else
  816. if( ! pThread->PumpMessage() )
  817. {
  818. PostQuitMessage(0);
  819. break; // Signal WM_QUIT received
  820. } // if( !AfxGetThread()->PumpMessage() )
  821. } // while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  822. if( bStop )
  823. break;
  824. for( LONG nIdleCounter = 0L;
  825. true; // ::AfxGetThread()->OnIdle(nIdleCounter);
  826. nIdleCounter ++
  827. )
  828. {
  829. CWinThread * pThread = AfxGetThread();
  830. if( pThread == NULL )
  831. break;
  832. if( ! pThread->OnIdle( nIdleCounter ) )
  833. break;
  834. }
  835. } // for( ; ! bStop ; )
  836. ::SetThreadPriority( hCurrentThread, nOldCurrentThreadPriority );
  837. ::CloseHandle( hCurrentThread );
  838. ::SetPriorityClass( hProcess, dwOldProcessPriorityClass );
  839. ::CloseHandle( hProcess );
  840. if( ::IsWindow( hWnd ) )
  841. {
  842. m_bNcFrameImpl_MovingLoopTracking = false;
  843. if( ::GetCapture() == hWnd )
  844. ::ReleaseCapture();
  845. }
  846. ::SendMessage( hWnd, WM_EXITSIZEMOVE, 0L, 0L );
  847. lResult = 0;
  848. return true;
  849. } // track moving loop
  850. else if(
  851. m_bNcFrameImpl_Resizing
  852. && ( wParam == HTLEFT
  853. || wParam == HTRIGHT
  854. || wParam == HTTOP
  855. || wParam == HTBOTTOM
  856. || wParam == HTTOPLEFT
  857. || wParam == HTBOTTOMLEFT
  858. || wParam == HTTOPRIGHT
  859. || wParam == HTBOTTOMRIGHT
  860. )
  861. )
  862. { // track resizing loop
  863. DWORD dwStyle = pWndFrameImpl->GetStyle();
  864. static const DWORD dwCheckMask = WS_MAXIMIZE|WS_MINIMIZE|WS_VISIBLE|WS_DISABLED;
  865. DWORD dwCheckResult = dwStyle&dwCheckMask;
  866. if( dwCheckResult != WS_VISIBLE )
  867. {
  868. lResult = 0;
  869. return true;
  870. }
  871. WPARAM wParamSizingCode = 0L;
  872. switch( wParam )
  873. {
  874. case HTTOP:           wParamSizingCode = WMSZ_TOP;           break;
  875. case HTBOTTOM:        wParamSizingCode = WMSZ_BOTTOM;        break;
  876. case HTLEFT:          wParamSizingCode = WMSZ_LEFT;          break;
  877. case HTRIGHT:         wParamSizingCode = WMSZ_RIGHT;         break;
  878. case HTTOPLEFT:       wParamSizingCode = WMSZ_TOPLEFT;       break;
  879. case HTTOPRIGHT:      wParamSizingCode = WMSZ_TOPRIGHT;      break;
  880. case HTBOTTOMLEFT:    wParamSizingCode = WMSZ_BOTTOMLEFT;    break;
  881. case HTBOTTOMRIGHT:   wParamSizingCode = WMSZ_BOTTOMRIGHT;   break;
  882. } // switch( wParam )
  883. ASSERT( wParamSizingCode != 0L );
  884. HWND hWnd = pWndFrameImpl->GetSafeHwnd();
  885. ::SendMessage( hWnd, WM_ENTERSIZEMOVE, 0L, 0L );
  886. ::SetCapture( hWnd );
  887. CPoint ptStart( short(LOWORD(lParam)), short(HIWORD(lParam)) );
  888. CRect rcWndStart;
  889. ::GetWindowRect( hWnd, rcWndStart );
  890. HANDLE hCurrentThread = ::GetCurrentThread();
  891. int nOldCurrentThreadPriority = ::GetThreadPriority( hCurrentThread );
  892. ::SetThreadPriority( hCurrentThread, THREAD_PRIORITY_ABOVE_NORMAL );
  893. HANDLE hProcess = ::GetCurrentProcess();
  894. DWORD dwOldProcessPriorityClass = ::GetPriorityClass( hProcess );
  895. ::SetPriorityClass( hProcess, HIGH_PRIORITY_CLASS );
  897. m_bNcFrameImpl_ResizingLoopTracking = true;
  898. MINMAXINFO _mmi;
  899. // ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  900. // CExtPaintManager::monitor_parms_t _mp;
  901. // CExtPaintManager::stat_GetMonitorParms( _mp, (CWnd*)pWndFrameImpl );
  902. // _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  903. // _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  904. // _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  905. // _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  906. // _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  907. // _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  908. // _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  909. // _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  910. // pWndFrameImpl->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) );
  912. ::memcpy( &_mmi, &m_NcFrameImpl_MinMaxInfo_Cache, sizeof(MINMAXINFO) );
  913. NcFrameImpl_GetMinMaxInfo( &_mmi );
  915. bool bStop = false;
  916. for( ; ! bStop ; )
  917. {
  918. ::WaitMessage();
  919. MSG msg;
  920. // Process all the messages in the message queue
  921. while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  922. {
  923. switch( msg.message )
  924. {
  925. case WM_ACTIVATEAPP:
  926. case WM_CANCELMODE:
  927. case WM_LBUTTONDOWN:
  928. case WM_LBUTTONUP:
  929. case WM_LBUTTONDBLCLK:
  930. case WM_MBUTTONDOWN:
  931. case WM_MBUTTONUP:
  932. case WM_MBUTTONDBLCLK:
  933. case WM_RBUTTONDOWN:
  934. case WM_RBUTTONUP:
  935. case WM_RBUTTONDBLCLK:
  936. case WM_NCLBUTTONDOWN:
  937. case WM_NCLBUTTONUP:
  938. case WM_NCLBUTTONDBLCLK:
  939. case WM_NCRBUTTONDOWN:
  940. case WM_NCRBUTTONUP:
  941. case WM_NCRBUTTONDBLCLK:
  942. case WM_NCMBUTTONDOWN:
  943. case WM_NCMBUTTONUP:
  944. case WM_NCMBUTTONDBLCLK:
  945. case WM_CONTEXTMENU:
  946. bStop = true;
  947. break;
  948. case WM_CAPTURECHANGED:
  949. if( hWnd != ((HWND)lParam) )
  950. bStop = true;
  951. break;
  952. case WM_SIZE:
  953. case WM_WINDOWPOSCHANGING:
  954. case WM_WINDOWPOSCHANGED:
  955. case WM_ERASEBKGND:
  956. case WM_NCHITTEST:
  957. case WM_NCMOUSEMOVE:
  958. if( ::IsWindow( hWnd ) )
  959. {
  960. ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE );
  961. continue;
  962. }
  963. bStop = true;
  964. break;
  965. case WM_MOUSEMOVE:
  966. ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE );
  967. if( msg.hwnd == hWnd )
  968. {
  969. // while( ::PeekMessage( &msg, hWnd, WM_MOUSEMOVE, WM_MOUSEMOVE, PM_REMOVE ) )
  970. // {
  971. // if( ::PeekMessage( &msg, hWnd, WM_NCLBUTTONUP, WM_NCLBUTTONUP, PM_NOREMOVE ) )
  972. // break;
  973. // }
  974. CPoint pt;
  975. if( ! ::GetCursorPos( &pt ) )
  976. {
  977. bStop = true;
  978. break;
  979. }
  980. CRect rcWnd = rcWndStart;
  981. if( wParam == HTLEFT
  982. || wParam == HTTOPLEFT
  983. || wParam == HTBOTTOMLEFT
  984. )
  985. {
  986. rcWnd.left = rcWndStart.left + pt.x - ptStart.x;
  987. if( rcWnd.Width() < _mmi.ptMinTrackSize.x )
  988. rcWnd.left = rcWnd.right - _mmi.ptMinTrackSize.x;
  989. if( rcWnd.Width() > _mmi.ptMaxTrackSize.x )
  990. rcWnd.left = rcWnd.right - _mmi.ptMaxTrackSize.x;
  991. //if( rcWnd.left > rcWndStart.left )
  992. // rcWnd.left = rcWndStart.left;
  993. }
  994. if( wParam == HTRIGHT
  995. || wParam == HTTOPRIGHT
  996. || wParam == HTBOTTOMRIGHT
  997. )
  998. {
  999. rcWnd.right = rcWndStart.right + pt.x - ptStart.x;
  1000. if( rcWnd.Width() < _mmi.ptMinTrackSize.x )
  1001. rcWnd.right = rcWnd.left + _mmi.ptMinTrackSize.x;
  1002. if( rcWnd.Width() > _mmi.ptMaxTrackSize.x )
  1003. rcWnd.right = rcWnd.left + _mmi.ptMaxTrackSize.x;
  1004. //if( rcWnd.right < rcWndStart.right )
  1005. // rcWnd.right = rcWndStart.right;
  1006. }
  1007. if( wParam == HTTOP
  1008. || wParam == HTTOPLEFT
  1009. || wParam == HTTOPRIGHT
  1010. )
  1011. {
  1012. rcWnd.top = rcWndStart.top + pt.y - ptStart.y;
  1013. if( rcWnd.Height() < _mmi.ptMinTrackSize.y )
  1014. rcWnd.top = rcWnd.bottom - _mmi.ptMinTrackSize.y;
  1015. if( rcWnd.Height() > _mmi.ptMaxTrackSize.y )
  1016. rcWnd.top = rcWnd.bottom - _mmi.ptMaxTrackSize.y;
  1017. //if( rcWnd.top > rcWndStart.top )
  1018. // rcWnd.top = rcWndStart.top;
  1019. }
  1020. if( wParam == HTBOTTOM
  1021. || wParam == HTBOTTOMLEFT
  1022. || wParam == HTBOTTOMRIGHT
  1023. )
  1024. {
  1025. rcWnd.bottom = rcWndStart.bottom + pt.y - ptStart.y;
  1026. if( rcWnd.Height() < _mmi.ptMinTrackSize.y )
  1027. rcWnd.bottom = rcWnd.top + _mmi.ptMinTrackSize.y;
  1028. if( rcWnd.Height() > _mmi.ptMaxTrackSize.y )
  1029. rcWnd.bottom = rcWnd.top + _mmi.ptMaxTrackSize.y;
  1030. //if( rcWnd.bottom < rcWndStart.bottom )
  1031. // rcWnd.bottom = rcWndStart.bottom;
  1032. }
  1033. CRect rcWndCurrent;
  1034. ::GetWindowRect( hWnd, &rcWndCurrent );
  1035. if( rcWndCurrent != rcWnd )
  1036. {
  1037. UINT nIDFirst = 0, nIDLast = 0xFFFF, nIDLeftOver = AFX_IDW_PANE_FIRST;
  1038. AFX_SIZEPARENTPARAMS layout = { NULL, { 0, 0, 0, 0 }, { 0, 0 }, FALSE };
  1039. HWND hWndLeftOver = NULL;
  1040. layout.bStretch = TRUE;
  1041. CRect rcClientCurrent;
  1042. ::GetClientRect( hWnd, &rcClientCurrent );
  1043. layout.rect.right = rcClientCurrent.right + rcWnd.Width() - rcWndCurrent.Width();
  1044. layout.rect.bottom = rcClientCurrent.bottom + rcWnd.Height() - rcWndCurrent.Height();
  1045. layout.hDWP = ::BeginDeferWindowPos( 8 );
  1046. HWND hWndChild = ::GetTopWindow( hWnd );
  1047. for( ; hWndChild != NULL; hWndChild = ::GetNextWindow( hWndChild, GW_HWNDNEXT ) )
  1048. {
  1049. UINT nIDC = _AfxGetDlgCtrlID( hWndChild );
  1050. if( nIDC == nIDLeftOver )
  1051. hWndLeftOver = hWndChild;
  1052. else
  1053. if( nIDC >= nIDFirst
  1054. && nIDC <= nIDLast
  1055. )
  1056. ::SendMessage( hWndChild, WM_SIZEPARENT, 0, (LPARAM)&layout );
  1057. }
  1058. if( nIDLeftOver != 0 && hWndLeftOver != NULL )
  1059. {
  1060. CWnd * pLeftOver = CWnd::FromHandle( hWndLeftOver );
  1061. pLeftOver->CalcWindowRect( &layout.rect );
  1062. ::AfxRepositionWindow( &layout, hWndLeftOver, &layout.rect );
  1063. }
  1064. if( layout.hDWP == NULL
  1065. || ( ! ::EndDeferWindowPos( layout.hDWP ) )
  1066. )
  1067. {
  1068. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  1069. }
  1070. if( ( ::__EXT_MFC_GetWindowLong(hWnd,GWL_STYLE) & WS_CHILD ) != 0 )
  1071. {
  1072. HWND hWndParent = ::GetParent( hWnd );
  1073. ASSERT( hWndParent != NULL );
  1074. ::ScreenToClient( hWndParent, ((LPPOINT)&rcWnd) );
  1075. ::ScreenToClient( hWndParent, ((LPPOINT)&rcWnd)+1 );
  1076. }
  1077. CRect rcWndAdjusted = rcWnd;
  1078. if( ::SendMessage( hWnd, WM_SIZING, wParamSizingCode, LPARAM(&rcWndAdjusted) ) != 0L )
  1079. rcWnd = rcWndAdjusted;
  1080. ::MoveWindow( hWnd, rcWnd.left, rcWnd.top, rcWnd.Width(), rcWnd.Height(), TRUE );
  1081. SendMessage( hWnd, WM_NCPAINT, 0, 0 );
  1082. CExtPaintManager::stat_PassPaintMessages();
  1083. ::Sleep(1);
  1084. } // if( rcWndCurrent != rcWnd )
  1085. } // if( msg.hwnd == hWnd )
  1086.   if( ::IsWindow( hWnd ) )
  1087.   continue;
  1088. bStop = true;
  1089. break;
  1090. default:
  1091. if( WM_KEYFIRST <= msg.message
  1092. && msg.message <= WM_KEYLAST
  1093. )
  1094. bStop = true;
  1095. break;
  1096. } // switch( msg.message )
  1097. if( ! ::IsWindow( hWnd ) )
  1098. bStop = true;
  1099. if( bStop )
  1100. break;
  1101. if( ! AfxGetThread()->PumpMessage() )
  1102. {
  1103. PostQuitMessage(0);
  1104. break; // Signal WM_QUIT received
  1105. } // if( !AfxGetThread()->PumpMessage() )
  1106. } // while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  1107. if( bStop )
  1108. break;
  1109. for( LONG nIdleCounter = 0L;
  1110. ::AfxGetThread()->OnIdle(nIdleCounter);
  1111. nIdleCounter ++
  1112. );
  1113. } // for( ; ! bStop ; )
  1114. ::SetThreadPriority( hCurrentThread, nOldCurrentThreadPriority );
  1115. ::CloseHandle( hCurrentThread );
  1116. ::SetPriorityClass( hProcess, dwOldProcessPriorityClass );
  1117. ::CloseHandle( hProcess );
  1118. if( ::IsWindow( hWnd ) )
  1119. {
  1120. m_bNcFrameImpl_ResizingLoopTracking = false;
  1121. if( ::GetCapture() == hWnd )
  1122. ::ReleaseCapture();
  1123. }
  1124. ::SendMessage( hWnd, WM_EXITSIZEMOVE, 0L, 0L );
  1125. lResult = 0;
  1126. return true;
  1127. } // track resizing loop
  1129. DWORD dw = 0 ;
  1130. if( dw != 0 )
  1131. pWndFrameImpl->ModifyStyle( WS_CAPTION, 0 );
  1132. struct friendly_wnd_t : public CWnd { friend class CExtNcFrameImpl; };
  1133. lResult = ((friendly_wnd_t*)pWndFrameImpl)->DefWindowProc( message, wParam, lParam );
  1134. if( dw != 0 )
  1135. pWndFrameImpl->ModifyStyle( 0, dw );
  1136. return true;
  1138. }
  1139. break;
  1140. case WM_LBUTTONDOWN:
  1141. {
  1142. if( NcFrameImpl_IsForceEmpty() )
  1143. break;
  1144. if( pWndFrameImpl->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) )
  1145. pWndFrameImpl->GetParent()->SendMessage( WM_MDIACTIVATE, (WPARAM)pWndFrameImpl->m_hWnd );
  1146. m_nNcFrameImpl_ScTrackedButtonPressed = 0;
  1147. CRect rcWnd;
  1148. pWndFrameImpl->GetWindowRect( &rcWnd );
  1149. CPoint pointWnd;
  1150. ::GetCursorPos( &pointWnd );
  1151. pointWnd -= rcWnd.TopLeft();
  1152. m_rcNcFrameImpl_ScClose    = NcFrameImpl_GetNcScRect( SC_CLOSE );
  1153. m_rcNcFrameImpl_ScMaximize = NcFrameImpl_GetNcScRect( SC_MAXIMIZE );
  1154. m_rcNcFrameImpl_ScMinimize = NcFrameImpl_GetNcScRect( SC_MINIMIZE );
  1155. m_rcNcFrameImpl_ScHelp     = NcFrameImpl_GetNcScRect( SC_CONTEXTHELP );
  1156. if( m_rcNcFrameImpl_ScClose.PtInRect( pointWnd ) )
  1157. m_nNcFrameImpl_ScTrackedButtonPressed = SC_CLOSE;
  1158. else if( m_rcNcFrameImpl_ScMaximize.PtInRect( pointWnd ) )
  1159. m_nNcFrameImpl_ScTrackedButtonPressed = SC_MAXIMIZE;
  1160. else if( m_rcNcFrameImpl_ScMinimize.PtInRect( pointWnd ) )
  1161. m_nNcFrameImpl_ScTrackedButtonPressed = SC_MINIMIZE;
  1162. else if( m_rcNcFrameImpl_ScHelp.PtInRect( pointWnd ) )
  1163. m_nNcFrameImpl_ScTrackedButtonPressed = SC_CONTEXTHELP;
  1164. if( m_nNcFrameImpl_ScTrackedButtonPressed != 0 )
  1165. {
  1166. if( ::GetActiveWindow() != pWndFrameImpl->m_hWnd )
  1167. pWndFrameImpl->SetActiveWindow();
  1168. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1169. HWND hWnd = NULL;
  1170. if( m_pNcFrameImplBridge != NULL
  1171. && ( hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() ) != NULL
  1172. && (! m_rcNcFrameImpl_LastExternalNcHT.IsRectEmpty() )
  1173. )
  1174. ::InvalidateRect( hWnd, m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  1175. if( m_nNcFrameImpl_ScTrackedButtonPressed != 0
  1176. && CWnd::GetCapture() != pWndFrameImpl
  1177. )
  1178. pWndFrameImpl->SetCapture();
  1179. } // if( m_nNcFrameImpl_ScTrackedButtonPressed != 0 )
  1180. }
  1181. break;
  1182. case WM_LBUTTONUP:
  1183. {
  1184. HWND hWnd = NULL;
  1185. if( m_pNcFrameImplBridge != NULL
  1186. && ( hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() ) != NULL
  1187. && (! m_rcNcFrameImpl_LastExternalNcHT.IsRectEmpty() )
  1188. )
  1189. {
  1190. m_nNcFrameImpl_LastExternalNcHT = UINT(-1);
  1191. ::InvalidateRect( hWnd, m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  1192. //::UpdateWindow( hWnd );
  1193. m_rcNcFrameImpl_LastExternalNcHT.SetRect( -1, -1, -1, -1 );
  1194. }
  1196. if( NcFrameImpl_IsForceEmpty() )
  1197. break;
  1198. if( m_nNcFrameImpl_ScTrackedButtonPressed == 0 )
  1199. break;
  1200. UINT nSC = m_nNcFrameImpl_ScTrackedButtonPressed;
  1201. if( nSC == SC_MAXIMIZE && pWndFrameImpl->IsZoomed() )
  1202. nSC = SC_RESTORE;
  1203. else if( nSC == SC_MINIMIZE && pWndFrameImpl->IsIconic() )
  1204. nSC = SC_RESTORE;
  1205. m_nNcFrameImpl_ScTrackedButtonHover = m_nNcFrameImpl_ScTrackedButtonPressed = 0;
  1206. m_wndNcFrameImpl_Tip.Hide();
  1207. if( CWnd::GetCapture() == pWndFrameImpl )
  1208. ::ReleaseCapture();
  1209. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1210. CRect rcButton = NcFrameImpl_GetNcScRect( nSC );
  1211. CRect rcWnd;
  1212. pWndFrameImpl->GetWindowRect( &rcWnd );
  1213. CPoint pointWnd;
  1214. ::GetCursorPos( &pointWnd );
  1215. pointWnd -= rcWnd.TopLeft();
  1216. if( rcButton.PtInRect(pointWnd) )
  1217. {
  1218. HWND hWndOwn = pWndFrameImpl->GetSafeHwnd();
  1219. ASSERT( hWndOwn != NULL && ::IsWindow(hWndOwn) );
  1220. bool bEnabled = NcFrameImpl_OnQuerySystemCommandEnabled( nSC );
  1221. if( ! bEnabled )
  1222. {
  1223. if( nSC == SC_MAXIMIZE )
  1224. bEnabled = NcFrameImpl_OnQuerySystemCommandEnabled( SC_RESTORE );
  1225. else if( nSC == SC_RESTORE )
  1226. bEnabled = NcFrameImpl_OnQuerySystemCommandEnabled( SC_MAXIMIZE );
  1227. }
  1228. if( bEnabled )
  1229. {
  1230. pWndFrameImpl->SendMessage( WM_SYSCOMMAND, nSC );
  1231. if( ::IsWindow( hWndOwn ) )
  1232. {
  1233. if( nSC == SC_CLOSE )
  1234. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1235. } // if( ::IsWindow( hWndOwn ) )
  1236. }
  1237. } // if( rcButton.PtInRect(pointWnd) )
  1238. }
  1239. lResult = 0;
  1240. return true;
  1241. case WM_MOUSEMOVE:
  1242. {
  1243. HWND hWnd = NULL;
  1244. if( m_pNcFrameImplBridge != NULL
  1245. && ( hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() ) != NULL
  1246. && (! m_rcNcFrameImpl_LastExternalNcHT.IsRectEmpty() )
  1247. )
  1248. ::InvalidateRect( hWnd, m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  1250. if( NcFrameImpl_IsForceEmpty() )
  1251. break;
  1252. if( m_nNcFrameImpl_ScTrackedButtonHover == 0 )
  1253. break;
  1254. CRect rcWnd;
  1255. pWndFrameImpl->GetWindowRect( &rcWnd );
  1256. CPoint pointWnd;
  1257. if( ::GetCursorPos( &pointWnd ) )
  1258. {
  1259. pWndFrameImpl->PostMessage( WM_NCHITTEST, 0, MAKELPARAM( pointWnd.x, pointWnd.y ) );
  1260. pointWnd -= rcWnd.TopLeft();
  1261. }
  1262. else
  1263. pointWnd.x = pointWnd.y = -32767;
  1264. UINT nScTrackedButtonHover = 0;
  1265. if( m_rcNcFrameImpl_ScClose.PtInRect( pointWnd ) )
  1266. nScTrackedButtonHover = SC_CLOSE;
  1267. else if( m_rcNcFrameImpl_ScMaximize.PtInRect( pointWnd ) )
  1268. nScTrackedButtonHover = SC_MAXIMIZE;
  1269. else if( m_rcNcFrameImpl_ScMinimize.PtInRect( pointWnd ) )
  1270. nScTrackedButtonHover = SC_MINIMIZE;
  1271. else if( m_rcNcFrameImpl_ScHelp.PtInRect( pointWnd ) )
  1272. nScTrackedButtonHover = SC_CONTEXTHELP;
  1273. if( m_nNcFrameImpl_ScTrackedButtonHover != nScTrackedButtonHover )
  1274. {
  1275. m_nNcFrameImpl_ScTrackedButtonHover = nScTrackedButtonHover;
  1276. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1277. if( m_nNcFrameImpl_ScTrackedButtonHover == 0
  1278. && m_nNcFrameImpl_ScTrackedButtonPressed == 0
  1279. )
  1280. {
  1281. if( CWnd::GetCapture() == pWndFrameImpl )
  1282. ::ReleaseCapture();
  1283. m_wndNcFrameImpl_Tip.Hide();
  1284. }
  1285. else
  1286. {
  1287. LPCTSTR strTipText = NcFrameImpl_GetScTipText( m_nNcFrameImpl_ScTrackedButtonHover );
  1288. if( strTipText == NULL || _tcslen(strTipText) == 0 )
  1289. m_wndNcFrameImpl_Tip.Hide();
  1290. else
  1291. {
  1292. CRect rcItem = NcFrameImpl_GetNcScRect( m_nNcFrameImpl_ScTrackedButtonHover );
  1293. rcItem.OffsetRect( rcWnd.TopLeft() );
  1294. m_wndNcFrameImpl_Tip.SetText( strTipText );
  1295. m_wndNcFrameImpl_Tip.Show( pWndFrameImpl, rcItem );
  1296. }
  1297. }
  1298. lResult = 0;
  1299. return true;
  1300. } // if( m_nNcFrameImpl_ScTrackedButtonHover != nScTrackedButtonHover )
  1301. }
  1302. lResult = 0;
  1303. return true;
  1304. case WM_NCMOUSEMOVE:
  1305. if( ! NcFrameImpl_IsSupported() )
  1306. break;
  1307. else
  1308. {
  1310. HWND hWnd = NULL;
  1311. if( m_pNcFrameImplBridge != NULL
  1312. && ( hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() ) != NULL
  1313. && (! m_rcNcFrameImpl_LastExternalNcHT.IsRectEmpty() )
  1314. )
  1315. ::InvalidateRect( hWnd, m_rcNcFrameImpl_LastExternalNcHT, TRUE );
  1317. if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  1318. {
  1319. if( wParam == HTCAPTION || wParam == HTSYSMENU )
  1320. {
  1321. hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1322. if( hWnd != NULL && ::IsWindow( hWnd ) )
  1323. {
  1324. CPoint ptCursor;
  1325. ::GetCursorPos( &ptCursor );
  1326. ::ScreenToClient( hWnd, &ptCursor );
  1327. CExtControlBar * pBar = DYNAMIC_DOWNCAST( CExtControlBar, CWnd::FromHandlePermanent( hWnd ) );
  1328. if( pBar != NULL )
  1329. {
  1330. if( pBar->_OnMouseMoveMsg( 0, ptCursor ) )
  1331. {
  1332. lResult = 0L;
  1333. return true;
  1334. }
  1335. }
  1336. else
  1337. {
  1338. lResult = ::SendMessage( hWnd, WM_MOUSEMOVE, 0, MAKELPARAM( ptCursor.x, ptCursor.y ) );
  1339. return true;
  1340. }
  1341. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  1342. } // if( wParam == HTCAPTION || wParam == HTSYSMENU )
  1343. break;
  1344. } // if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  1345. if( NcFrameImpl_IsForceEmpty() )
  1346. break;
  1347. if( m_rcNcFrameImpl_ScClose.IsRectEmpty() )
  1348. NcFrameImpl_ReCacheScButtonRects();
  1349. CRect rcWnd;
  1350. pWndFrameImpl->GetWindowRect( &rcWnd );
  1351. CPoint pointWnd;
  1352. if( ::GetCursorPos( &pointWnd ) )
  1353. {
  1354. pWndFrameImpl->PostMessage( WM_NCHITTEST, 0, MAKELPARAM( pointWnd.x, pointWnd.y ) );
  1355. pointWnd -= rcWnd.TopLeft();
  1356. }
  1357. else
  1358. pointWnd.x = pointWnd.y = -32767;
  1359. UINT nScTrackedButtonHover = 0;
  1360. if( m_rcNcFrameImpl_ScClose.PtInRect( pointWnd ) )
  1361. nScTrackedButtonHover = SC_CLOSE;
  1362. else if( m_rcNcFrameImpl_ScMaximize.PtInRect( pointWnd ) )
  1363. nScTrackedButtonHover = SC_MAXIMIZE;
  1364. else if( m_rcNcFrameImpl_ScMinimize.PtInRect( pointWnd ) )
  1365. nScTrackedButtonHover = SC_MINIMIZE;
  1366. else if( m_rcNcFrameImpl_ScHelp.PtInRect( pointWnd ) )
  1367. nScTrackedButtonHover = SC_CONTEXTHELP;
  1368. if( m_nNcFrameImpl_ScTrackedButtonHover != nScTrackedButtonHover )
  1369. {
  1370. m_nNcFrameImpl_ScTrackedButtonHover = nScTrackedButtonHover;
  1371. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1372. if( m_nNcFrameImpl_ScTrackedButtonHover != 0 )
  1373. {
  1374. if( CWnd::GetCapture() != pWndFrameImpl )
  1375. pWndFrameImpl->SetCapture();
  1376. LPCTSTR strTipText = NcFrameImpl_GetScTipText( m_nNcFrameImpl_ScTrackedButtonHover );
  1377. if( strTipText == NULL || _tcslen(strTipText) == 0 )
  1378. m_wndNcFrameImpl_Tip.Hide();
  1379. else
  1380. {
  1381. CRect rcItem = NcFrameImpl_GetNcScRect( m_nNcFrameImpl_ScTrackedButtonHover );
  1382. rcItem.OffsetRect( rcWnd.TopLeft() );
  1383. m_wndNcFrameImpl_Tip.SetText( strTipText );
  1384. m_wndNcFrameImpl_Tip.Show( pWndFrameImpl, rcItem );
  1385. }
  1386. }
  1387. else
  1388. m_wndNcFrameImpl_Tip.Hide();
  1389. } // if( m_nNcFrameImpl_ScTrackedButtonHover != nScTrackedButtonHover )
  1390. }
  1391. lResult = 0;
  1392. return true;
  1393. case WM_SYSCOMMAND:
  1394. {
  1395. if( ! NcFrameImpl_IsSupported() )
  1396. break;
  1397. if( NcFrameImpl_IsDwmBased() )
  1398. break;
  1399. CExtPopupMenuWnd::CancelMenuTracking();
  1400. CWnd::CancelToolTips();
  1401. CExtPopupMenuSite::g_DefPopupMenuSite.GetTip().Hide();
  1402. m_wndNcFrameImpl_Tip.Hide();
  1403. if( m_wndNcFrameImpl_Tip.GetSafeHwnd() != NULL )
  1404. m_wndNcFrameImpl_Tip.DestroyWindow();
  1405. UINT nSC = UINT( wParam );
  1406. if( nSC == SC_SIZE || nSC == SC_NEXTWINDOW || nSC == SC_PREVWINDOW )
  1407. break;
  1408. if( ! NcFrameImpl_OnQuerySystemCommandEnabled( nSC ) )
  1409. {
  1410. lResult = 0;
  1411. return true;
  1412. }
  1413. pWndFrameImpl->ModifyStyle( 0, WS_CAPTION|WS_BORDER, 0 );
  1414. if( NcFrameImpl_OnQueryQuickWindowPlacement() )
  1415. {
  1416. if( nSC == SC_MAXIMIZE
  1417. || nSC == SC_MINIMIZE
  1418. || nSC == SC_RESTORE
  1419. )
  1420. {
  1421. WINDOWPLACEMENT _wp;
  1422. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  1423. if( GetWindowPlacement( &_wp ) )
  1424. {
  1425. switch( nSC )
  1426. {
  1427. case SC_MAXIMIZE:
  1428. _wp.showCmd = SW_SHOWMAXIMIZED;
  1429. break;
  1430. case SC_MINIMIZE:
  1431. m_nNcFrameImpl_LastShowCmd = _wp.showCmd;
  1432. _wp.showCmd = SW_SHOWMINIMIZED;
  1433. break;
  1434. case SC_RESTORE:
  1435. _wp.showCmd =
  1436. ( m_nNcFrameImpl_LastShowCmd != SW_HIDE )
  1437. ? m_nNcFrameImpl_LastShowCmd
  1438. : SW_RESTORE // SW_SHOWNORMAL
  1439. ;
  1440. m_nNcFrameImpl_LastShowCmd = SW_HIDE;
  1441. if( _wp.showCmd == SW_SHOWMAXIMIZED && pWndFrameImpl->IsZoomed() )
  1442. _wp.showCmd = SW_RESTORE;
  1443. break;
  1444. #ifdef _DEBUG
  1445. default:
  1446. ASSERT( FALSE );
  1447. break;
  1448. #endif // _DEBUG
  1449. } // switch( nSC )
  1450. SetWindowPlacement( &_wp );
  1451. } // if( GetWindowPlacement( hWndOwn, &_wp ) )
  1452. lResult = 0;
  1453. return true;
  1454. }
  1455. } // if( NcFrameImpl_OnQueryQuickWindowPlacement() )
  1456. if( message == WM_SYSCOMMAND && nSC == SC_MINIMIZE && pWndFrameImpl->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) )
  1457. { // fix for minimizing of maximized MDI child frame
  1458. HWND hWndMdiClient = ::GetParent( pWndFrameImpl->m_hWnd );
  1459. BOOL bMax = FALSE;
  1460. HWND hWndActiveMdiChildFrame = (HWND) ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMax );
  1461. if( hWndActiveMdiChildFrame != NULL && bMax )
  1462. {
  1463. bool bNextAvailable = false;
  1464. HWND hWnd = ::GetWindow( hWndActiveMdiChildFrame, GW_HWNDNEXT );
  1465. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDNEXT ) )
  1466. {
  1467. __EXT_MFC_LONG_PTR dwWndStyle = ::__EXT_MFC_GetWindowLong( hWnd, GWL_STYLE );
  1468. if( ( dwWndStyle & WS_VISIBLE ) == 0 )
  1469. continue;
  1470. if( IsIconic( hWnd ) )
  1471. continue;
  1472. bNextAvailable = true;
  1473. break;
  1474. }
  1475. if( ! bNextAvailable )
  1476. {
  1477. hWnd = ::GetWindow( hWndActiveMdiChildFrame, GW_HWNDPREV );
  1478. for( ; hWnd != NULL; hWnd = ::GetWindow( hWnd, GW_HWNDPREV ) )
  1479. {
  1480. __EXT_MFC_LONG_PTR dwWndStyle = ::__EXT_MFC_GetWindowLong( hWnd, GWL_STYLE );
  1481. if( ( dwWndStyle & WS_VISIBLE ) == 0 )
  1482. continue;
  1483. if( IsIconic( hWnd ) )
  1484. continue;
  1485. bNextAvailable = true;
  1486. break;
  1487. }
  1488. }
  1489. if( bNextAvailable )
  1490. {
  1491. CRect rcSurface;
  1492. ::GetClientRect( hWndMdiClient, &rcSurface );
  1493. HWND hWndSurface =
  1494. ::CreateWindowEx(
  1495. 0, _T("Static"), _T(""), WS_CHILD, rcSurface.left, rcSurface.top, rcSurface.Width(), rcSurface.Height(),
  1496. hWndMdiClient, (HMENU)NULL, ::AfxGetInstanceHandle(), NULL
  1497. );
  1498. if( hWndSurface != NULL )
  1499. {
  1500. ::EnableWindow( hWndSurface, FALSE );
  1501. ::ShowWindow( hWndSurface, SW_SHOWNOACTIVATE );
  1502. }
  1503. ::SendMessage( hWndMdiClient, WM_MDINEXT, WPARAM(pWndFrameImpl->m_hWnd), 0L );
  1504. struct friendly_wnd_t : public CWnd { friend class CExtNcFrameImpl; };
  1505. lResult = ((friendly_wnd_t*)pWndFrameImpl)->DefWindowProc( message, wParam, lParam );
  1506. hWndActiveMdiChildFrame = (HWND) ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMax );
  1507. if( hWndActiveMdiChildFrame != NULL )
  1508. {
  1509. ::SendMessage( hWndMdiClient, WM_MDIMAXIMIZE, WPARAM(hWndActiveMdiChildFrame), 0L );
  1510. ::SendMessage( hWndMdiClient, WM_MDIACTIVATE, WPARAM(hWndActiveMdiChildFrame), 0L );
  1511. }
  1512. ::DestroyWindow( hWndSurface );
  1513. return true;
  1514. } // if( bNextAvailable )
  1515. } // if( hWndActiveMdiChildFrame != NULL && bMax )
  1516. } // fix for minimizing of maximized MDI child frame
  1517. if( m_bNcFrameImpl_IsEnabled
  1518. && ( ! m_bNcFrameImpl_RestoreEnabledState )
  1519. && nSC != SC_MOVE
  1520. && nSC != SC_SIZE
  1521. && pWndFrameImpl->IsKindOf( RUNTIME_CLASS( CMDIChildWnd ) )
  1522. )
  1523. m_bNcFrameImpl_RestoreEnabledState = true;
  1524. if( nSC != SC_CLOSE )
  1525. NcFrameImpl_NcLock( true );
  1526. }
  1527. break;
  1528. case WM_DESTROY:
  1529. case WM_NCDESTROY:
  1530. m_bNcFrameImpl_DwmSurfaceInitializationComplete = false;
  1531. m_bNcFrameImpl_CreatePassed = false;
  1532. case WM_SETTINGCHANGE:
  1533. NcFrameImpl_MapHtRects_Clean();
  1534. if( ! NcFrameImpl_IsSupported() )
  1535. break;
  1536. if( NcFrameImpl_IsDwmBased() )
  1537. break;
  1538. if( wParam == SPI_SETWORKAREA )
  1539. {
  1540. WINDOWPLACEMENT _wp;
  1541. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  1542. _wp.length = sizeof(WINDOWPLACEMENT);
  1543. if( GetWindowPlacement( _wp ) && _wp.showCmd == SW_SHOWMAXIMIZED )
  1544. {
  1545. CExtPaintManager::monitor_parms_t _mp;
  1546. CExtPaintManager::stat_GetMonitorParms( _mp, pWndFrameImpl );
  1547. WINDOWPLACEMENT _wpAdjust;
  1548. ::memcpy( &_wpAdjust, &_wp, sizeof(WINDOWPLACEMENT) );
  1549. _wpAdjust.showCmd = SW_SHOWNORMAL; // SW_RESTORE;
  1550. // pWndFrameImpl->GetWindowRect( &_wpAdjust.rcNormalPosition );
  1551. ::CopyRect( &_wpAdjust.rcNormalPosition, &_mp.m_rcWorkArea );
  1552. _wpAdjust.ptMaxPosition.x = _wpAdjust.ptMaxPosition.x = _wpAdjust.rcNormalPosition.left;
  1553. _wpAdjust.ptMaxPosition.y = _wpAdjust.ptMaxPosition.y = _wpAdjust.rcNormalPosition.top;
  1554. SetWindowPlacement( _wpAdjust );
  1555. SetWindowPlacement( _wp );
  1556. //NcFrameImpl_RecalcNcFrame();
  1557. }
  1558. }
  1559. break;
  1560. case WM_DISPLAYCHANGE:
  1561. NcFrameImpl_MapHtRects_Clean();
  1562. break;
  1563. case WM_GETMINMAXINFO:
  1564. if( m_bNcFrameImpl_ResizingLoopTracking || m_bNcFrameImpl_MovingLoopTracking )
  1565.  break;
  1566. if( NcFrameImpl_IsSupported() )
  1567. {
  1568. LPMINMAXINFO pMMI = (LPMINMAXINFO)lParam;
  1569. ASSERT( pMMI != NULL );
  1570. struct friendly_wnd_t : public CWnd { friend class CExtNcFrameImpl; };
  1571. ((friendly_wnd_t*)pWndFrameImpl)->DefWindowProc( message, wParam, lParam );
  1572. bool bOK = NcFrameImpl_GetMinMaxInfo( pMMI );
  1573. ::memcpy( &m_NcFrameImpl_MinMaxInfo_Cache, pMMI, sizeof(MINMAXINFO) );
  1574. if( bOK )
  1575. return true;
  1576. } // if( NcFrameImpl_IsSupported() )
  1577. break;
  1578. } // switch( message )
  1579. return false;
  1580. }
  1582. bool CExtNcFrameImpl::NcFrameImpl_OnQuerySystemCommandEnabled(
  1583. UINT nSystemCommandID
  1584. )
  1585. {
  1586. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1587. if( pWndFrameImpl == NULL )
  1588. return false;
  1589. if( nSystemCommandID == SC_CLOSE )
  1590. {
  1591. CMenu * pSysMenu = pWndFrameImpl->GetSystemMenu( FALSE );
  1592. if( pSysMenu == NULL )
  1593. return false;
  1594. UINT _nSystemCommandID = nSystemCommandID;
  1595. UINT nMenuItemState =
  1596. pSysMenu->GetMenuState( _nSystemCommandID, MF_BYCOMMAND );
  1597. if( nMenuItemState == 0xFFFFFFFF )
  1598. return false;
  1599. if( (nMenuItemState&(MF_DISABLED|MF_GRAYED)) != 0 )
  1600. return false;
  1601. }
  1602. DWORD dwStyle = pWndFrameImpl->GetStyle();
  1603. if( nSystemCommandID == SC_MINIMIZE )
  1604. {
  1605. if( (dwStyle&WS_MINIMIZEBOX) == 0 )
  1606. return false;
  1607. }
  1608. if( nSystemCommandID == SC_MAXIMIZE )
  1609. {
  1610. if( (dwStyle&WS_MAXIMIZEBOX) == 0 )
  1611. return false;
  1612. }
  1613. if( nSystemCommandID == SC_RESTORE || nSystemCommandID == SC_MAXIMIZE )
  1614. {
  1615. MINMAXINFO _mmi;
  1616. // ::memset( &_mmi, 0, sizeof(MINMAXINFO) );
  1617. // CExtPaintManager::monitor_parms_t _mp;
  1618. // CExtPaintManager::stat_GetMonitorParms( _mp, pWndFrameImpl );
  1619. // _mmi.ptMaxPosition.x = _mp.m_rcWorkArea.left;
  1620. // _mmi.ptMaxPosition.y = _mp.m_rcWorkArea.top;
  1621. // _mmi.ptMaxTrackSize.x = _mp.m_rcWorkArea.Width(); // ::GetSystemMetrics( SM_CXMAXTRACK );
  1622. // _mmi.ptMaxTrackSize.y = _mp.m_rcWorkArea.Height(); // ::GetSystemMetrics( SM_CYMAXTRACK );
  1623. // _mmi.ptMinTrackSize.x = ::GetSystemMetrics( SM_CXMINTRACK );
  1624. // _mmi.ptMinTrackSize.y = ::GetSystemMetrics( SM_CYMINTRACK );
  1625. // _mmi.ptMaxSize.x = _mmi.ptMaxTrackSize.x;
  1626. // _mmi.ptMaxSize.y = _mmi.ptMaxTrackSize.y;
  1627. // if( pWndFrameImpl->SendMessage( WM_GETMINMAXINFO, 0, LPARAM(&_mmi) ) == 0 )
  1629. ::memcpy( &_mmi, &m_NcFrameImpl_MinMaxInfo_Cache, sizeof(MINMAXINFO) );
  1630. NcFrameImpl_GetMinMaxInfo( &_mmi );
  1632. {
  1633. if( nSystemCommandID == SC_RESTORE )
  1634. {
  1635. WINDOWPLACEMENT _wp;
  1636. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  1637. _wp.length = sizeof(WINDOWPLACEMENT);
  1638. GetWindowPlacement( &_wp );
  1639. if( _wp.showCmd == SW_SHOWMINIMIZED
  1640. || _wp.showCmd == SW_SHOWMINNOACTIVE
  1641. || _wp.showCmd == SW_RESTORE
  1642. || _wp.showCmd == SW_SHOWMAXIMIZED
  1643. )
  1644. return true;
  1645. }
  1646. if( _mmi.ptMinTrackSize.x >= _mmi.ptMaxTrackSize.x
  1647. || _mmi.ptMinTrackSize.y >= _mmi.ptMaxTrackSize.y
  1648. )
  1649. return false;
  1650. }
  1651. }
  1652. return true;
  1653. }
  1655. CExtPaintManager * CExtNcFrameImpl::NcFrameImpl_GetPM()
  1656. {
  1657. return m_BridgeNC.PmBridge_GetPM();
  1658. }
  1660. CExtPaintManager * CExtNcFrameImpl::NcFrameImpl_GetPM() const
  1661. {
  1662. return
  1663. ( const_cast < CExtNcFrameImpl * > ( this ) )
  1664. -> NcFrameImpl_GetPM();
  1665. }
  1667. CExtNcFrameImpl * CExtNcFrameImpl::NcFrameImpl_FindInstance(
  1668. HWND hWnd,
  1669. IExtNcFrameImplBridge * pNcFrameImplBridge // = NULL
  1670. )
  1671. {
  1672. for( ; hWnd != NULL && ::IsWindow( hWnd ); hWnd = ::GetParent( hWnd ) )
  1673. {
  1674. if( ( ::__EXT_MFC_GetWindowLong( hWnd, GWL_STYLE ) & WS_CHILD ) != 0 )
  1675. continue;
  1676. CExtNcFrameImpl * pExtNcFrameImpl = NULL;
  1677. ::SendMessage(
  1678. hWnd,
  1679. g_nMsgFindExtNcFrameImpl,
  1680. WPARAM(&pExtNcFrameImpl),
  1681. LPARAM(pNcFrameImplBridge)
  1682. );
  1683. if( pExtNcFrameImpl != NULL )
  1684. return pExtNcFrameImpl;
  1685. } // for( ; hWnd != NULL && ::IsWindow( hWnd ); hWnd = ::GetParent( hWnd ) )
  1686. return NULL;
  1687. }
  1689. void CExtNcFrameImpl::NcFrameImpl_CheckCursor(
  1690. CPoint pointScreen,
  1691. LPARAM nHT,
  1692. bool bCheckWindowFromPoint // = true
  1693. )
  1694. {
  1695. if( (! NcFrameImpl_IsSupported() )
  1696. || NcFrameImpl_IsDwmBased()
  1697. || (! ::GetCursorPos(&pointScreen) ) // reset
  1698. )
  1699. {
  1700. m_nNcFrameImpl_LastCheckCursorHT = HTNOWHERE;
  1701. m_ptNcFrameImpl_LastCheckCursor.x = m_ptNcFrameImpl_LastCheckCursor.y = -32767;
  1702. return;
  1703. }
  1704. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  1705. if( hWndOwn == NULL
  1706. || ( bCheckWindowFromPoint
  1707. && ::WindowFromPoint( pointScreen ) != hWndOwn
  1708. )
  1709. )
  1710. {
  1711. m_nNcFrameImpl_LastCheckCursorHT = HTNOWHERE;
  1712. m_ptNcFrameImpl_LastCheckCursor.x = m_ptNcFrameImpl_LastCheckCursor.y = -32767;
  1713. return;
  1714. }
  1715. if( m_ptNcFrameImpl_LastCheckCursor == pointScreen
  1716. && m_nNcFrameImpl_LastCheckCursorHT == nHT
  1717. )
  1718. return;
  1719. m_ptNcFrameImpl_LastCheckCursor = pointScreen;
  1720. m_nNcFrameImpl_LastCheckCursorHT = nHT;
  1721. ::SendMessage( hWndOwn, WM_SETCURSOR, WPARAM(hWndOwn), nHT );
  1722. }
  1724. void CExtNcFrameImpl::NcFrameImpl_PostWindowProc( LRESULT & lResult, UINT message, WPARAM wParam, LPARAM lParam )
  1725. {
  1726. lResult;
  1727. switch( message )
  1728. {
  1729. case WM_CAPTURECHANGED:
  1730. {
  1731. if( ! NcFrameImpl_IsSupported() )
  1732. break;
  1733. if( NcFrameImpl_IsDwmBased() )
  1734. break;
  1735.   CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1736. if( ((HWND)lParam) != pWndFrameImpl->m_hWnd )
  1737. pWndFrameImpl->ModifyStyle( 0, WS_CAPTION|WS_BORDER, 0 );
  1738. }
  1739. break;
  1740.   case WM_NCPAINT:
  1741. if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  1742. {
  1743. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1744. if( hWnd != NULL && ::IsWindow( hWnd ) )
  1745. {
  1746.   CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1747.   ASSERT_VALID( pWndFrameImpl );
  1748.   CWindowDC dcWnd( pWndFrameImpl );
  1749. CRect rcWnd, rcClient;
  1750. pWndFrameImpl->GetWindowRect( &rcWnd );
  1751. pWndFrameImpl->GetClientRect( &rcClient );
  1752. pWndFrameImpl->ClientToScreen( &rcClient );
  1753. rcClient.OffsetRect( -rcWnd.TopLeft() );
  1754. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  1755. dcWnd.ExcludeClipRect( &rcClient );
  1756. CExtMemoryDC dc( &dcWnd, &rcWnd );
  1757. dc.FillSolidRect( &rcWnd, RGB(0,0,0) );
  1758. CPoint ptViewPortOffset(
  1759. ::GetSystemMetrics( SM_CXSIZEFRAME ),
  1760. ::GetSystemMetrics( SM_CYCAPTION )
  1761. - NcFrameImpl_GetPM()->NcFrame_GetCaptionHeight( true, pWndFrameImpl )
  1762. + ::GetSystemMetrics( SM_CYSIZEFRAME )
  1763. );
  1764. dc.OffsetViewportOrg( ptViewPortOffset.x, ptViewPortOffset.y );
  1765. ::SendMessage( hWnd, WM_PRINTCLIENT, WPARAM(dc.m_hDC), PRF_CLIENT );
  1766. dc.OffsetViewportOrg( -ptViewPortOffset.x, -ptViewPortOffset.y );
  1767. } // if( hWnd != NULL && ::IsWindow( hWnd ) )
  1768. } // if( NcFrameImpl_IsDwmCaptionReplacement() && m_pNcFrameImplBridge != NULL )
  1769.   break;
  1770. case 0x031E: // WM_DWMCOMPOSITIONCHANGED
  1771. {
  1772. CExtPaintManager * pPM = NcFrameImpl_GetPM();
  1773. ASSERT_VALID( pPM );
  1774. m_BridgeNC.PmBridge_OnPaintManagerChanged( pPM );
  1775. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1776. if( pWndFrameImpl->GetSafeHwnd() != NULL )
  1777. {
  1778. if( pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CFrameWnd) ) )
  1779. ((CFrameWnd*)pWndFrameImpl)->RecalcLayout();
  1780. BOOL bDwmIsCompositionEnabled = FALSE;
  1781. if( m_pNcFrameImplBridge != NULL
  1782. && m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd() != NULL
  1783. && ( ! pWndFrameImpl->IsZoomed() )
  1784. && g_PaintManager.m_DWM.DwmIsCompositionEnabled( & bDwmIsCompositionEnabled ) == S_OK
  1785. && ( ! bDwmIsCompositionEnabled )
  1786. )
  1787. CWnd::GetDesktopWindow()->RedrawWindow(
  1788. NULL, NULL,
  1789. RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN
  1790. );
  1791. }
  1792. }
  1793. break;
  1794. case WM_CREATE:
  1795. m_bNcFrameImpl_CreatePassed = true;
  1796. break;
  1797. case WM_PRINT:
  1798. case WM_PRINTCLIENT:
  1799. {
  1800. CWnd * pWndFrameImpl = (CWnd *)NcFrameImpl_GetFrameWindow();
  1801. ASSERT_VALID( pWndFrameImpl );
  1803. CDC dc;
  1804. dc.Attach( (HDC)wParam );
  1806. CRect rcRgnWnd, rcRgnClient;
  1807. pWndFrameImpl->GetWindowRect( &rcRgnWnd );
  1808. pWndFrameImpl->GetClientRect( &rcRgnClient );
  1810. if( (lParam&PRF_NONCLIENT) != 0
  1811. && NcFrameImpl_IsSupported()
  1812. && ( ! NcFrameImpl_IsDwmBased() )
  1813. )
  1814. {
  1815. CRect rcWnd = rcRgnWnd, rcClient = rcRgnClient;
  1816. pWndFrameImpl->ClientToScreen( &rcClient );
  1817. rcClient.OffsetRect( -rcWnd.TopLeft() );
  1818. rcWnd.OffsetRect( -rcWnd.TopLeft() );
  1819. CRgn rgnWnd;
  1820. if( rgnWnd.CreateRectRgnIndirect(&rcWnd) )
  1821. dc.SelectClipRgn( &rgnWnd );
  1822. dc.ExcludeClipRect( &rcClient );
  1823. NcFrameImpl_OnNcPaint( dc );
  1824. dc.SelectClipRgn( NULL );
  1825. }
  1826. if( (lParam&PRF_CHILDREN) != 0 )
  1827. CExtPaintManager::stat_PrintChildren(
  1828. pWndFrameImpl->m_hWnd,
  1829. message,
  1830. dc.GetSafeHdc(),
  1831. lParam,
  1832. false
  1833. );
  1834. dc.Detach();
  1835. } // if( NcFrameImpl_IsSupported() && ( ! NcFrameImpl_IsDwmBased() ) )
  1836. break;
  1837. case WM_NCLBUTTONDBLCLK:
  1838. if( NcFrameImpl_IsDwmBased() )
  1839. break;
  1840. m_bNcFrameImpl_RestoreBorder = false;
  1841. break;
  1842. case WM_SIZE:
  1843. if( ! NcFrameImpl_IsSupported() )
  1844. break;
  1845. m_nNcFrameImpl_ScTrackedButtonPressed = 0;
  1846. m_nNcFrameImpl_ScTrackedButtonHover = 0;
  1847. NcFrameImpl_MapHtRects_Clean();
  1848. if( ! NcFrameImpl_IsDwmBased() )
  1849. {
  1850. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1851. if( (pWndFrameImpl->GetExStyle()&WS_EX_LAYOUTRTL) != 0 )
  1852. {
  1853. m_bNcFrameImpl_DelatayedFrameRecalc = false;
  1854. NcFrameImpl_SetupRgn( NULL );
  1855. }
  1856. }
  1857. break;
  1858. case WM_WINDOWPOSCHANGING:
  1859. if( ! NcFrameImpl_IsSupported() )
  1860. break;
  1861. if( NcFrameImpl_IsDwmBased() )
  1862. break;
  1863. if( ! NcFrameImpl_IsForceEmpty() )
  1864. {
  1865. if( m_bNcFrameImpl_AssigningRGN )
  1866. break;
  1867. LPWINDOWPOS lpWindowPos = 
  1868. reinterpret_cast < LPWINDOWPOS > (lParam);
  1869. ASSERT( lpWindowPos != NULL );
  1870. //lpWindowPos->flags |= SWP_FRAMECHANGED;
  1871. m_bNcFrameImpl_DelatayedFrameRecalc =
  1872. ( ( lpWindowPos->flags & SWP_FRAMECHANGED ) == 0 )
  1873. ? true : false;
  1874. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1875. if( pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) )
  1876. && (pWndFrameImpl->GetStyle()&WS_MAXIMIZE) != 0
  1877. )
  1878. {
  1879. m_bNcFrameImpl_AssigningRGN = true;
  1880. pWndFrameImpl->SetWindowRgn( NULL, FALSE );
  1881. m_bNcFrameImpl_AssigningRGN = false;
  1882. }
  1883. else
  1884. NcFrameImpl_SetupRgn( (WINDOWPOS *)lParam );
  1885. }
  1886. break;
  1887. case WM_WINDOWPOSCHANGED:
  1888. {
  1889. if( ! NcFrameImpl_IsSupported() )
  1890. break;
  1891. if( NcFrameImpl_IsDwmBased() )
  1892. break;
  1893. m_bNcFrameImpl_DelatayedFrameRecalc = false;
  1894. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1895. if( pWndFrameImpl->IsKindOf(RUNTIME_CLASS(CMDIChildWnd))
  1896. && pWndFrameImpl->IsZoomed()
  1897. )
  1898. {
  1899. HWND hWndMdiClient = ::GetParent( pWndFrameImpl->m_hWnd );
  1900. CRect rcClient;
  1901. ::GetClientRect( hWndMdiClient, &rcClient );
  1902. ::SendMessage( hWndMdiClient, WM_SIZE, SIZE_RESTORED, MAKELPARAM( rcClient.Width(), rcClient.Height() ) );
  1903. //NcFrameImpl_SetupRgn();
  1904. }
  1905. if( ! m_bNcFrameImpl_RestoreEnabledState )
  1906. break;
  1907. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1908. if( m_pNcFrameImplBridge != NULL )
  1909. {
  1910. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1911. if( hWnd != NULL )
  1912. {
  1913. ::InvalidateRect( hWnd, NULL, TRUE );
  1914. ::UpdateWindow( hWnd );
  1915. }
  1916. }
  1917. }
  1918. // continuing switch ...
  1919. case WM_SYSCOMMAND:
  1920. {
  1921. if( ! NcFrameImpl_IsSupported() )
  1922. break;
  1923. if( NcFrameImpl_IsDwmBased() )
  1924. break;
  1925. UINT nSC = UINT( wParam );
  1926. if( nSC == SC_SIZE || nSC == SC_NEXTWINDOW || nSC == SC_PREVWINDOW )
  1927. break;
  1928. CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  1929. if( pWndFrameImpl->GetSafeHwnd() != NULL
  1930. && m_bNcFrameImpl_RestoreEnabledState
  1931. )
  1932. m_bNcFrameImpl_IsEnabled = true;
  1933. m_bNcFrameImpl_RestoreEnabledState = false;
  1934. if( message == WM_SYSCOMMAND && nSC != SC_CLOSE )
  1935. NcFrameImpl_NcLock( false );
  1936. if( pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) )
  1937. && (pWndFrameImpl->GetStyle()&WS_MAXIMIZE) != 0
  1938. )
  1939. {
  1940. m_bNcFrameImpl_AssigningRGN = true;
  1941. pWndFrameImpl->SetWindowRgn( NULL, TRUE );
  1942. m_bNcFrameImpl_AssigningRGN = false;
  1943. ((CMDIChildWnd*)pWndFrameImpl)->RecalcLayout();
  1944. pWndFrameImpl->GetParent()->PostMessage( WM_MDIREFRESHMENU );
  1945. }
  1946. else
  1947. NcFrameImpl_SetupRgn();
  1948. if( pWndFrameImpl->IsWindowVisible() )
  1949. {
  1950. if( message == WM_SYSCOMMAND && ( nSC == SC_MAXIMIZE || nSC == SC_RESTORE ) )
  1951. {
  1952. if( nSC == SC_MAXIMIZE )
  1953. {
  1954. CMDIChildWnd * pWndMdiChild = DYNAMIC_DOWNCAST( CMDIChildWnd, pWndFrameImpl );
  1955. if( pWndMdiChild != NULL )
  1956. {
  1957. CRect rcWnd;
  1958. pWndMdiChild->GetWindowRect( &rcWnd );
  1959. pWndMdiChild->SendMessage( WM_NCHITTEST, MAKELPARAM( rcWnd.left, rcWnd.top ) );
  1960. CWnd * pWndMC = pWndFrameImpl->GetParent();
  1961. CRect rcMC;
  1962. pWndMC->GetWindowRect( &rcMC );
  1963. pWndMC->SendMessage( WM_SIZE, SIZE_RESTORED, MAKELPARAM(rcMC.Width(),rcMC.Height()) );
  1964. pWndMC->SendMessage( WM_MDIACTIVATE, (WPARAM)pWndFrameImpl->m_hWnd );
  1965. }
  1966. }
  1967. pWndFrameImpl->RedrawWindow( NULL, NULL, RDW_INVALIDATE|RDW_ERASE|RDW_FRAME|RDW_ALLCHILDREN );
  1968. }
  1969. else
  1970. pWndFrameImpl->SendMessage( WM_NCPAINT );
  1971. }
  1972. if( message == WM_SYSCOMMAND
  1973. && nSC == SC_RESTORE
  1974. && m_pNcFrameImplBridge != NULL
  1975. )
  1976. {
  1977. HWND hWnd = m_pNcFrameImplBridge->NcFrameImplBridge_GetSafeHwnd();
  1978. if( hWnd != NULL )
  1979. {
  1980. CWnd * pWndPermanent = CWnd::FromHandlePermanent( hWnd );
  1981. if( pWndPermanent != NULL )
  1982. {
  1983. CExtToolControlBar * pBar = DYNAMIC_DOWNCAST( CExtToolControlBar, pWndPermanent );
  1984. if( pBar != NULL )
  1985. {
  1986. pBar->_RibbonPageRslaResetStateData();
  1987. pBar->_RecalcLayoutImpl();
  1988. }
  1989. }
  1990. }
  1991. }
  1992. } // case WM_SYSCOMMAND
  1993. break;
  1994. } // switch( message )
  1995. }
  1997. bool CExtNcFrameImpl::NcFrameImpl_OnQueryQuickWindowPlacement() const
  1998. {
  1999. if( ! NcFrameImpl_IsSupported() )
  2000. return false;
  2001. if( g_PaintManager.m_DWM.IsCompositionEnabled() )
  2002. return false;
  2003. if( m_bNcFrameImpl_QuickWindowPlacement )
  2004. return true;
  2005. const CWnd * pWndFrameImpl = NcFrameImpl_GetFrameWindow();
  2006. if( pWndFrameImpl != NULL && pWndFrameImpl->IsKindOf( RUNTIME_CLASS(CMDIChildWnd) ) )
  2007. return true;
  2008. return false;
  2009. }
  2011. bool CExtNcFrameImpl::NcFrameImpl_RecalcNcFrame()
  2012. {
  2013. if( NcFrameImpl_IsNcLocked() )
  2014. return false;
  2015. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  2016. if( hWndOwn == NULL )
  2017. return false;
  2018. ASSERT( ::IsWindow( hWndOwn ) );
  2019. ::SetWindowPos(
  2020. hWndOwn, NULL, 0, 0, 0, 0,
  2021. SWP_FRAMECHANGED
  2022. |SWP_NOACTIVATE
  2023. |SWP_NOZORDER
  2024. |SWP_NOOWNERZORDER
  2025. |SWP_NOMOVE
  2026. |SWP_NOSIZE
  2027. );
  2028. return true;
  2029. }
  2031. void CExtNcFrameImpl::PreSubclassWindow()
  2032. {
  2033. ::memset( &m_NcFrameImpl_MinMaxInfo_Cache, 0, sizeof(MINMAXINFO) );
  2034. HWND hWndOwn = NcFrameImpl_OnQueryHWND();
  2035. ASSERT( hWndOwn != NULL && ::IsWindow( hWndOwn ) );
  2036. m_dwNcFrameImpl_StyleInitial = ::__EXT_MFC_GetWindowLong( hWndOwn, GWL_STYLE );
  2037. m_dwNcFrameImpl_StyleExInitial = ::__EXT_MFC_GetWindowLong( hWndOwn, GWL_EXSTYLE );
  2038. if( m_bNcFrameImpl_IsDwmBased && (m_dwNcFrameImpl_StyleInitial&WS_CHILD) != 0 )
  2039. m_bNcFrameImpl_IsDwmBased = false;
  2040. if( m_bNcFrameImpl_IsDwmBased )
  2041. m_bNcFrameImpl_Moving = m_bNcFrameImpl_Resizing = false;
  2042. if( (m_dwNcFrameImpl_StyleInitial&(WS_BORDER|WS_CAPTION)) != 0
  2043. && NcFrameImpl_IsSupported()
  2044. )
  2045. NcFrameImpl_DelayRgnAdjustment();
  2046. NcFrameImpl_MapHtRects_Clean();
  2047. NcFrameImpl_RecalcNcFrame();
  2048. { // BLOCK: adjust MDI client area styles
  2049. HWND hWndMdiClient = CExtControlBar::stat_FindMdiClientHWND( hWndOwn );
  2050. if( hWndMdiClient != NULL )
  2051. {
  2052. __EXT_MFC_LONG_PTR dwStyle = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_STYLE );
  2053. if( (dwStyle&WS_BORDER) != 0 )
  2054. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_STYLE, dwStyle&(~(WS_BORDER)) );
  2055. __EXT_MFC_LONG_PTR dwStyleEx = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_EXSTYLE );
  2056. if( (dwStyleEx&(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) != 0 )
  2057. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_EXSTYLE, (dwStyleEx&(~(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)))|WS_EX_CLIENTEDGE );
  2058. }
  2059. } // BLOCK: adjust MDI client area styles
  2060. m_bNcFrameImpl_ResizingLoopTracking = m_bNcFrameImpl_MovingLoopTracking = false;
  2061. }
  2063. void CExtNcFrameImpl::PostNcDestroy()
  2064. {
  2065. ::memset( &m_NcFrameImpl_MinMaxInfo_Cache, 0, sizeof(MINMAXINFO) );
  2066. m_pNcFrameImplBridge = NULL;
  2067. NcFrameImpl_DelayRgnAdjustment();
  2068. m_nNcFrameImpl_LastCheckCursorHT = HTNOWHERE;
  2069. m_ptNcFrameImpl_LastCheckCursor.x = m_ptNcFrameImpl_LastCheckCursor.y = -32767;
  2070. m_iconNcFrameImpl_QueryCache.Empty();
  2071. m_bNcFrameImpl_NcInitPassed = false;
  2072. m_bNcFrameImpl_ResizingLoopTracking = m_bNcFrameImpl_MovingLoopTracking = false;
  2073. }
  2075. IMPLEMENT_CExtPmBridge_MEMBERS( CExtNcFrameWatchMDIMF );
  2077. UINT CExtNcFrameWatchMDIMF::g_nMsgSurface =
  2078. ::RegisterWindowMessage( _T("CExtNcFrameWatchMDIMF::g_nMsgSurface") );
  2080. CExtNcFrameWatchMDIMF::CExtNcFrameWatchMDIMF()
  2081. : m_pNcFrameImpl( NULL )
  2082. , m_hWndSurface( NULL )
  2083. {
  2084. PmBridge_Install();
  2085. }
  2087. CExtNcFrameWatchMDIMF::~CExtNcFrameWatchMDIMF()
  2088. {
  2089. PmBridge_Uninstall();
  2090. if( m_hWndSurface != NULL )
  2091. ::DestroyWindow( m_hWndSurface );
  2092. }
  2094. void CExtNcFrameWatchMDIMF::_Surface( bool bForward )
  2095. {
  2096. CWnd * pWndFrameImpl = m_pNcFrameImpl->NcFrameImpl_GetFrameWindow();
  2097. if( bForward )
  2098. {
  2099. if( pWndFrameImpl->GetSafeHwnd() == NULL )
  2100. return;
  2101. if( m_hWndSurface == NULL )
  2102. {
  2103. HWND hWndParent = pWndFrameImpl->GetSafeHwnd();
  2104. ASSERT( hWndParent != NULL );
  2105. hWndParent = CExtControlBar::stat_FindMdiClientHWND( hWndParent );
  2106. ASSERT( hWndParent != NULL );
  2107. CRect rcSurface;
  2108. ::GetClientRect( hWndParent, &rcSurface );
  2109. m_hWndSurface =
  2110. ::CreateWindowEx(
  2111. 0, _T("Static"), _T(""), WS_CHILD, rcSurface.left, rcSurface.top, rcSurface.Width(), rcSurface.Height(),
  2112. hWndParent, (HMENU)NULL, ::AfxGetInstanceHandle(), NULL
  2113. );
  2114. if( m_hWndSurface != NULL )
  2115. {
  2116. ::EnableWindow( m_hWndSurface, FALSE );
  2117. ::ShowWindow( m_hWndSurface, SW_SHOWNOACTIVATE );
  2118. } // if( m_hWndSurface != NULL )
  2119. } // if( m_hWndSurface == NULL )
  2120. } // if( bForward )
  2121. else
  2122. {
  2123. if( m_hWndSurface != NULL )
  2124. {
  2125. ::DestroyWindow( m_hWndSurface );
  2126. m_hWndSurface = NULL;
  2127. } // if( m_hWndSurface != NULL )
  2128. } // else from if( bForward )
  2129. }
  2131. static CWnd * stat_pWndInit = NULL;
  2132. bool CExtNcFrameWatchMDIMF::OnHookWndMsg(
  2133. LRESULT & lResult,
  2134. HWND hWndHooked,
  2135. UINT nMessage,
  2136. WPARAM & wParam,
  2137. LPARAM & lParam
  2138. )
  2139. {
  2140. if( m_pNcFrameImpl != NULL )
  2141. {
  2142. switch( nMessage )
  2143. {
  2144. case WM_MDIDESTROY:
  2145. case WM_MDINEXT:
  2146. case WM_MDIICONARRANGE:
  2147. case WM_MDITILE:
  2148. case WM_MDICASCADE:
  2149. case WM_MDIACTIVATE:
  2150. //case WM_MDICREATE:
  2151. {
  2152. _Surface( true );
  2153. __EXT_MFC_LONG_PTR dwStyle = ::__EXT_MFC_GetWindowLong( hWndHooked, GWL_STYLE );
  2154. if( (dwStyle&WS_CLIPCHILDREN|WS_CLIPCHILDREN) == 0 )
  2155. ::__EXT_MFC_SetWindowLong( hWndHooked, GWL_STYLE, dwStyle|WS_CLIPCHILDREN||WS_CLIPCHILDREN );
  2156. { // BLOCK: adjust MDI client area styles
  2157. HWND hWndMdiClient = CExtControlBar::stat_FindMdiClientHWND( hWndHooked );
  2158. if( hWndMdiClient != NULL )
  2159. {
  2160. __EXT_MFC_LONG_PTR dwStyle = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_STYLE );
  2161. if( (dwStyle&WS_BORDER) != 0 )
  2162. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_STYLE, dwStyle&(~(WS_BORDER)) );
  2163. __EXT_MFC_LONG_PTR dwStyleEx = ::__EXT_MFC_GetWindowLong( hWndMdiClient, GWL_EXSTYLE );
  2164. if( (dwStyleEx&(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) != 0 )
  2165. ::__EXT_MFC_SetWindowLong( hWndMdiClient, GWL_EXSTYLE, (dwStyleEx&(~(WS_EX_CLIENTEDGE|WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)))|WS_EX_CLIENTEDGE );
  2166. }
  2167. } // BLOCK: adjust MDI client area styles
  2168. if( nMessage == WM_MDICASCADE || nMessage == WM_MDITILE )
  2169. {
  2170. BOOL bMax = FALSE;
  2171. HWND hWndActiveMdiChildFrame = (HWND)
  2172. ::SendMessage(
  2173. hWndHooked,
  2174. WM_MDIGETACTIVE,
  2175. 0,
  2176. (LPARAM)&bMax
  2177. );
  2178. if( hWndActiveMdiChildFrame != NULL && bMax )
  2179. ::SendMessage(
  2180. hWndHooked,
  2181. WM_MDIRESTORE,
  2182. (WPARAM)hWndActiveMdiChildFrame,
  2183. 0
  2184. );
  2185. } // if( nMessage == WM_MDICASCADE || nMessage == WM_MDITILE )
  2187. switch( nMessage )
  2188. {
  2189. case WM_MDIICONARRANGE:
  2190. {
  2191. CList < HWND, HWND > _listWindowsToSkip;
  2192. if( m_hWndSurface != NULL )
  2193. _listWindowsToSkip.AddTail( m_hWndSurface );
  2194. CExtNcFrameImpl::stat_MDI_ArrangeIconic( hWndHooked, _listWindowsToSkip );
  2195. _Surface( false );
  2196. lResult = TRUE;
  2197. }
  2198. return true;
  2199. case WM_MDITILE:
  2200. {
  2201. CList < HWND, HWND > _listWindowsToSkip;
  2202. if( m_hWndSurface != NULL )
  2203. _listWindowsToSkip.AddTail( m_hWndSurface );
  2204. CExtNcFrameImpl::stat_MDI_Tile( hWndHooked, _listWindowsToSkip, wParam );
  2205. _Surface( false );
  2206. lResult = TRUE;
  2207. }
  2208. return true;
  2209. case WM_MDICASCADE:
  2210. {
  2211. CList < HWND, HWND > _listWindowsToSkip;
  2212. if( m_hWndSurface != NULL )
  2213. _listWindowsToSkip.AddTail( m_hWndSurface );
  2214. CExtNcFrameImpl::stat_MDI_Cascade( hWndHooked, _listWindowsToSkip, wParam );
  2215. _Surface( false );
  2216. lResult = TRUE;
  2217. }
  2218. return true;
  2219. } // switch( nMessage )
  2220. }
  2221. break;
  2222. default:
  2223. if( nMessage == CExtNcFrameWatchMDIMF::g_nMsgSurface )
  2224. {
  2225. _Surface( wParam ? true : false );
  2226. lResult = 1L;
  2227. return true;
  2228. }
  2229. break;
  2230. } // switch( nMessage )
  2231. } // if( m_pNcFrameImpl != NULL )
  2232. return
  2233. CExtHookSink::OnHookWndMsg(
  2234. lResult,
  2235. hWndHooked,
  2236. nMessage,
  2237. wParam,
  2238. lParam
  2239. );
  2240. }
  2242. void CExtNcFrameWatchMDIMF::OnPostHookWndMsg(
  2243. LRESULT lResult,
  2244. HWND hWndHooked,
  2245. UINT nMessage,
  2246. WPARAM wParam,
  2247. LPARAM lParam
  2248. )
  2249. {
  2250. if( m_pNcFrameImpl != NULL )
  2251. {
  2252. switch( nMessage )
  2253. {
  2254. case WM_MDIDESTROY:
  2255. case WM_MDINEXT:
  2256. case WM_MDIICONARRANGE:
  2257. case WM_MDITILE:
  2258. case WM_MDICASCADE:
  2259. case WM_MDIACTIVATE:
  2260. //case WM_MDICREATE:
  2261. {
  2262. CRect rcMC;
  2263. ::GetWindowRect( hWndHooked, &rcMC );
  2264. ::SendMessage( hWndHooked, WM_SIZE, SIZE_RESTORED, MAKELPARAM(rcMC.Width(),rcMC.Height()) );
  2265. _Surface( false );
  2266. ::RedrawWindow( hWndHooked, NULL, NULL,
  2267. RDW_INVALIDATE|RDW_ERASE|RDW_FRAME|RDW_ALLCHILDREN
  2268. );
  2269. }
  2270. break;
  2271. } // switch( nMessage )
  2272. } // if( m_pNcFrameImpl != NULL )
  2273. CExtHookSink::OnPostHookWndMsg(
  2274. lResult,
  2275. hWndHooked,
  2276. nMessage,
  2277. wParam,
  2278. lParam
  2279. );
  2280. }
  2282. #endif // (!defined __EXT_MFC_NO_NC_FRAME )