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

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

界面编程

开发平台：

Visual C++

ExtMenuControlBar.cpp：源码内容
  1. return rc;
  2. }
  4. CRect CExtMenuControlBar::_GetMainFrameSysIconRect()
  5. {
  6. CRect rc;
  7. CRect rcWnd,rcClient,rcHelper;
  8. CFrameWnd * pFrame =
  9. _GetDockingFrameImpl();
  10. ASSERT_VALID( pFrame );
  11. pFrame->GetWindowRect( &rcWnd );
  12. pFrame->GetClientRect( &rcClient );
  13. rcHelper = rcWnd;
  14. pFrame->ScreenToClient( &rcHelper );
  15. ASSERT( rcHelper.top <= rcClient.top );
  16. int yDiff = rcClient.top - rcHelper.top;
  17. rc.SetRect(
  18. rcWnd.left + GetSystemMetrics(SM_CYFRAME),
  19. rcWnd.top + GetSystemMetrics(SM_CXFRAME),
  20. rcWnd.left + yDiff,
  21. rcWnd.top + yDiff
  22. );
  23. return rc;
  24. }
  26. BOOL CExtMenuControlBar::_TrackFrameSystemMenu(
  27. CWnd * pFrame,
  28. CPoint * pPoint, // = NULL, // NULL means calc menu track area automatically
  29. BOOL bSelectAny, // = FALSE
  30. LPCRECT rcExcludeArea, // = NULL
  31. UINT nTrackFlags, // = (UINT)(-1)
  32. BOOL bCombinedMode // = FALSE
  33. )
  34. {
  35. _CancelFlatTracking();
  37. /// if( nTrackFlags == (UINT)(-1) )
  38. /// nTrackFlags = TPMX_BOTTOMALIGN;
  39. ASSERT_VALID( pFrame );
  41. bool bPrevTBMT = CExtToolControlBar::g_bMenuTracking;
  42. int nTrackingIdxOld = m_nBtnIdxMenuTracking;
  44. // if( g_bMenuTracking )
  45. CExtToolControlBar::_CloseTrackingMenus();
  46. // if( CExtPopupMenuWnd::IsMenuTracking() )
  47. // CExtPopupMenuWnd::CancelMenuTracking();
  48. CMenu * pSysMenu = pFrame->GetSystemMenu( FALSE );
  49. if( pSysMenu == NULL )
  50. return FALSE;
  51. ASSERT( ::IsMenu(pSysMenu->GetSafeHmenu()) );
  53. CExtPopupMenuWnd * pPopup =
  54. CExtPopupMenuWnd::InstantiatePopupMenu(
  55. GetSafeHwnd(),
  56. RUNTIME_CLASS(CExtPopupMenuWnd),
  57. this
  58. );
  59. if( ! pPopup->CreatePopupMenu(
  60. pFrame->GetSafeHwnd()
  61. )
  62. )
  63. {
  64. ASSERT( FALSE );
  65. return FALSE;
  66. }
  67. if( ! pPopup->UpdateFromMenu(
  68. pFrame->GetSafeHwnd(),
  69. pSysMenu,
  70. false,
  71. true,
  72. true
  73. )
  74. )
  75. {
  76. ASSERT( FALSE );
  77. return FALSE;
  78. }
  80. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( pFrame->GetSafeHwnd(), GWL_EXSTYLE );
  81. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  83. CPoint point;
  84. if( pPoint != NULL)
  85. point = *pPoint;
  86. else
  87. {
  88. CRect rcWnd,rcClient,rcHelper;
  89. pFrame->GetWindowRect( &rcWnd );
  90. pFrame->GetClientRect( &rcClient );
  91. rcHelper = rcWnd;
  92. pFrame->ScreenToClient( &rcHelper );
  93. //ASSERT( rcHelper.top <= rcClient.top );
  94. int yDiff = rcClient.top - rcHelper.top;
  95. int n = 0;
  97. WINDOWPLACEMENT _wp;
  98. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  99. _wp.length = sizeof(WINDOWPLACEMENT);
  100. VERIFY(
  101. ::GetWindowPlacement(
  102. GetSafeHwnd(),
  103. &_wp
  104. )
  105. );
  106. if( _wp.showCmd != SW_SHOWMAXIMIZED ) 
  107. n = ::GetSystemMetrics( SM_CXFRAME );
  109. point = rcWnd.TopLeft();
  110. if( bRTL )
  111. {
  112. point = CPoint( rcWnd.right, rcWnd.top );
  113. n = -n;
  114. }
  115. point.x += n;
  116. point.y += yDiff;
  117. }
  118. if( nTrackFlags == (UINT)(-1) )
  119. nTrackFlags = 0;
  120. if( (nTrackFlags & TPMX_ALIGN_MASK ) == 0 )
  121. nTrackFlags = bRTL ? TPMX_RIGHTALIGN : TPMX_TOPALIGN;
  123. if( bSelectAny )
  124. nTrackFlags |= TPMX_SELECT_ANY;
  125. if( bPrevTBMT )
  126. nTrackFlags |= TPMX_NO_HIDE_RARELY;
  127. pFrame->SetFocus();
  129. CExtToolControlBar::g_bMenuTracking =
  130. bSelectAny ? bPrevTBMT : false; // (+ v.2.23)
  131. if( nTrackingIdxOld >= 0 )
  132. _SwitchMenuTrackingIndex( nTrackingIdxOld );
  134. CWnd * pWndNotify = m_pDockSite;
  135. if( pWndNotify == NULL )
  136. pWndNotify = GetParent();
  137. if( pWndNotify != NULL )
  138. pWndNotify->SendMessage(
  139. g_nMsgPrepareSystemMenu,
  140. WPARAM(pPopup),
  141. LPARAM(pFrame)
  142. );
  144. if( bRTL && !bCombinedMode )
  145. point.x += pPopup->OnQueryMenuShadowSize();
  147. CRect rcExclude( rcExcludeArea );
  148. if( rcExcludeArea == NULL )
  149. rcExclude.SetRect( point, point );
  151. pPopup->m_hWndNotifyMenuClosed = GetSafeHwnd();
  152. if( ! pPopup->TrackPopupMenu(
  153. nTrackFlags 
  154. | ( bCombinedMode ? TPMX_COMBINE_DEFAULT : 0) 
  155. | TPMX_OWNERDRAW_FIXED
  156. | TPMX_SYSMENU,
  157. point.x,point.y,
  158. rcExclude,
  159. bCombinedMode ?
  160. this : NULL,
  161. bCombinedMode ?
  162. CExtToolControlBar::_CbPaintCombinedContent : NULL,
  163. NULL,
  164. bCombinedMode ? true : false
  165. )
  166. )
  167. {
  168. //delete pPopup;
  169. CExtToolControlBar::_CloseTrackingMenus();
  170. return FALSE;
  171. }
  173. g_bMenuTracking = true;
  175. return TRUE;
  176. }
  178. BOOL CExtMenuControlBar::TrackChildFrameSystemMenu(
  179. CPoint * pPoint, // = NULL, // NULL means calc any track area automatically
  180. BOOL bSelectAny // = FALSE
  181. )
  182. {
  183. if( ! m_bAllowProfChildFrameSysmenu )
  184. return FALSE;
  185. if( ! _IsMdiApp() )
  186. {
  187. ASSERT( FALSE );
  188. return FALSE;
  189. } // if( ! _IsMdiApp() )
  191. if( GetButtonsCount() > 0 )
  192. {
  193. CExtBarButton * pTBB = _GetButtonPtr( 0 );
  194. ASSERT_VALID( pTBB );
  195. if( pTBB->IsKindOf(RUNTIME_CLASS(CExtBarMdiDocButton)) )
  196. {
  197. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  198. {
  199. HWND hWndFocus = ::GetFocus();
  200. if( hWndFocus != NULL )
  201. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  202. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  203. if( ! TrackButtonMenu( 0 ) )
  204. {
  205. ASSERT( FALSE );
  206. return FALSE;
  207. } // if( ! TrackButtonMenu( 0 ) )
  208. return TRUE;
  209. } // if( pTBB->IsKindOf(RUNTIME_CLASS(CExtBarMdiDocButton)) )
  210. } // if( GetButtonsCount() > 0 )
  212. BOOL bMax = FALSE;
  213. HWND hWndActiveChild = _GetActiveMdiChildWnd( bMax );
  214. if( hWndActiveChild == NULL )
  215. return FALSE;
  216. ASSERT( ::IsWindow(hWndActiveChild) );
  217. CWnd * pWnd = CWnd::FromHandlePermanent(hWndActiveChild);
  218. if( pWnd == NULL )
  219. {
  220. ASSERT( FALSE );
  221. return FALSE;
  222. }
  223. ASSERT_VALID( pWnd );
  225. // FrameFeatures does not use CMDIChildWnd
  226. // ASSERT( pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) );
  227. //CFrameWnd * pFrame = 
  228. // DYNAMIC_DOWNCAST(
  229. // CFrameWnd,
  230. // pWnd
  231. // );
  232. // ASSERT( pFrame != NULL );
  233. // if( pFrame == NULL )
  234. // {
  235. // ASSERT( FALSE );
  236. // return FALSE;
  237. // }
  238. // ASSERT_VALID( pFrame );
  240. g_bMenuTracking = true;
  241. _SwitchMenuTrackingIndex();
  242. m_bSysMenuTracking =
  243. _TrackFrameSystemMenu(
  244. pWnd,
  245. pPoint,
  246. bSelectAny
  247. ) ? true : false;
  248. return m_bSysMenuTracking ? TRUE : FALSE;
  249. }
  251. BOOL CExtMenuControlBar::TrackMainFrameSystemMenu(
  252. CPoint * pPoint, // = NULL // NULL means calc menu track area automatically
  253. BOOL bSelectAny // = FALSE
  254. )
  255. {
  256. if( ! m_bAllowProfMainFrameSysmenu )
  257. return FALSE;
  258. CFrameWnd * pFrame = _GetDockingFrameImpl();
  259. ASSERT_VALID( pFrame );
  260. CWnd * pWndForPlacement = stat_GetWndForPlacement( pFrame );
  261. // if( pWndForPlacement->m_hWnd != pFrame->m_hWnd )
  262. // return FALSE;
  263. g_bMenuTracking = true;
  264. _SwitchMenuTrackingIndex();
  265. m_bSysMenuTracking =
  266. _TrackFrameSystemMenu(
  267. pWndForPlacement, // pFrame
  268. pPoint,
  269. bSelectAny
  270. ) ? true : false;
  271. return m_bSysMenuTracking ? TRUE : FALSE;
  272. }
  274. BOOL CExtMenuControlBar::TrackButtonMenu(
  275. int nIndex,
  276. BOOL bSelectAny, // = FALSE
  277. BOOL bDelayedTracking, // = FALSE
  278. BOOL bNoAnimation // = FALSE
  279. )
  280. {
  281. bSelectAny;
  282. bDelayedTracking;
  284. if( g_bMenuTracking
  285. && m_nBtnIdxMenuTracking == nIndex
  286. )
  287. return TRUE;
  289. if( ! SafeDisplayBar() )
  290. return FALSE;
  292. _CancelFlatTracking();
  294. if( m_bMenuBarUsesDelayedButtonMenuTracking )
  295. PostMessage(
  296. g_nMsgTrackButtonMenu,
  297. (WPARAM)nIndex,
  298. (LPARAM)bNoAnimation
  299. );
  300. else
  301. SendMessage(
  302. g_nMsgTrackButtonMenu,
  303. (WPARAM)nIndex,
  304. (LPARAM)bNoAnimation
  305. );
  306. return TRUE;
  307. }
  309. LRESULT CExtMenuControlBar::OnTrackButtonMenu(WPARAM wParam,LPARAM lParam)
  310. {
  311. if( !( ::IsWindowEnabled(
  312. m_bPresubclassDialogMode
  313. ? GetOwner()->GetSafeHwnd()
  314. : _GetDockingFrameImpl()->GetSafeHwnd()
  315. )
  316. )
  317. ) 
  318. return 0;
  319. int nCountOfButtons = GetButtonsCount();
  320. ASSERT( nCountOfButtons >= 0 );
  321. if( nCountOfButtons == 0 )
  322. return 0;
  323. int nIndex = int(wParam);
  324. if( nIndex < 0 || nIndex>=nCountOfButtons )
  325. {
  326. _CancelFlatTracking();
  327. _CloseTrackingMenus();
  328. return 0;
  329. }
  330. CExtBarButton * pTBB = _GetButtonPtr(nIndex);
  331. ASSERT_VALID( pTBB );
  332. BOOL bDroppedMode =
  333. CExtPopupMenuWnd::IsMenuTracking();
  334. if( !pTBB->IsAbleToTrackMenu() )
  335. bDroppedMode = FALSE;
  336. if( bDroppedMode )
  337. {
  338. CExtToolControlBar::TrackButtonMenu(
  339. nIndex,
  340. true,
  341. false,
  342. (lParam != 0) ? true : false
  343. );
  344. return 0;
  345. }
  346. _CloseTrackingMenus();
  347. if( CExtMouseCaptureSink::GetCapture() == GetSafeHwnd() )
  348. CExtMouseCaptureSink::ReleaseCapture();
  350. if( ! m_bFlatTracking )
  351. {
  352. HWND hWndFocus = ::GetFocus();
  353. if( hWndFocus != NULL )
  354. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  355. } // if( ! m_bFlatTracking )
  357. m_nFlatTrackingIndex = nIndex;
  358. if( ! m_bFlatTracking )
  359. {
  360. m_bFlatTracking = true;
  361. HDWP hPassiveModeDWP = NULL;
  362. OnFlatTrackingStart( hPassiveModeDWP );
  363. } // if( ! m_bFlatTracking )
  364. _UpdateFlatTracking();
  366. return 0;
  367. }
  369. int CExtMenuControlBar::_FlatTrackingGet() const
  370. {
  371. ASSERT_VALID( this );
  372. return m_bFlatTracking;
  373. }
  375. void CExtMenuControlBar::_FlatTrackingSet( bool bFlatTracking )
  376. {
  377. ASSERT_VALID( this );
  378. m_bFlatTracking = bFlatTracking;
  379. }
  381. int CExtMenuControlBar::_FlatTrackingIndexGet() const
  382. {
  383. ASSERT_VALID( this );
  384. return m_nFlatTrackingIndex;
  385. }
  387. void CExtMenuControlBar::_FlatTrackingIndexSet( int nFlatTrackingIndex )
  388. {
  389. ASSERT_VALID( this );
  390. m_nFlatTrackingIndex = nFlatTrackingIndex;
  391. }
  393. void CExtMenuControlBar::_CancelFlatTracking(
  394. BOOL bRepaint // = TRUE
  395. )
  396. {
  397. ASSERT_VALID( this );
  398. if( ! m_bFlatTracking )
  399. return;
  400. m_bFlatTracking = false;
  401. OnFlatTrackingStop();
  402. _UpdateFlatTracking( bRepaint );
  403. }
  405. void CExtMenuControlBar::OnFlatTrackingStart(
  406. HDWP & hPassiveModeDWP
  407. )
  408. {
  409. ASSERT_VALID( this );
  410. CExtToolControlBar::OnFlatTrackingStart( hPassiveModeDWP );
  411. }
  413. void CExtMenuControlBar::OnFlatTrackingStop()
  414. {
  415. ASSERT_VALID( this );
  416. CExtToolControlBar::OnFlatTrackingStop();
  417. }
  419. void CExtMenuControlBar::_UpdateFlatTracking(
  420. BOOL bRepaint // = TRUE
  421. )
  422. {
  423. ASSERT_VALID( this );
  424. if( m_nFlatTrackingIndex < 0
  425. && m_nOldTrackingIndex < 0
  426. )
  427. {
  428. if( m_bFlatTracking )
  429. {
  430. m_bFlatTracking = false;
  431. OnFlatTrackingStop();
  432. } // if( m_bFlatTracking )
  433. return;
  434. }
  436. HWND hWndCurrentFocus = ::GetFocus();
  437. if( hWndCurrentFocus != NULL )
  438. {
  439. CWnd * pWndTest = CWnd::FromHandlePermanent( hWndCurrentFocus );
  440. if( pWndTest == NULL )
  441. {
  442. HWND hWnd = ::GetParent( hWndCurrentFocus );
  443. if( hWnd != NULL )
  444. pWndTest = CWnd::FromHandlePermanent( hWnd );
  445. } // if( pWndTest == NULL )
  446. if( pWndTest != NULL )
  447. {
  448. CComboBox * pComboTest =
  449. DYNAMIC_DOWNCAST(
  450. CComboBox,
  451. pWndTest
  452. );
  453. if( pComboTest == NULL )
  454. {
  455. pWndTest = pWndTest->GetParent();
  456. if( pWndTest != NULL )
  457. {
  458. pComboTest =
  459. DYNAMIC_DOWNCAST(
  460. CComboBox,
  461. pWndTest
  462. );
  463. }
  464. } // if( pComboTest == NULL )
  465. if( pComboTest != NULL
  466. && (pComboTest->GetStyle() & (CBS_DROPDOWN|CBS_DROPDOWNLIST)) != 0
  467. && pComboTest->GetDroppedState()
  468. )
  469. pComboTest->ShowDropDown( FALSE );
  470. } // if( pWndTest != NULL )
  471. } // if( hWndCurrentFocus != NULL )
  473. int nCountOfButtons = GetButtonsCount();
  474. if( !m_bFlatTracking )
  475. {
  476. if( m_nFlatTrackingIndex >= 0 )
  477. {
  478. ASSERT( m_nFlatTrackingIndex < nCountOfButtons );
  479. CExtBarButton * pTBB =
  480. _GetButtonPtr(m_nFlatTrackingIndex);
  481. ASSERT_VALID( pTBB );
  482. pTBB->ModifyStyle(0,TBBS_PRESSED);
  483. INT nIndexRepaint = m_nFlatTrackingIndex;
  484. m_nFlatTrackingIndex = m_nOldTrackingIndex = -1;
  485. if( bRepaint )
  486. {
  487. _InvalidateButton( nIndexRepaint );
  488. ///UpdateWindow();
  489. }
  490. }
  491. // if( g_bMenuTracking )
  492. // _CloseTrackingMenus();
  493. return;
  494. } // if( !m_bFlatTracking )
  495. if( m_nFlatTrackingIndex != m_nOldTrackingIndex )
  496. {
  497. if( m_nOldTrackingIndex >= 0 && m_nOldTrackingIndex < nCountOfButtons )
  498. {
  499. CExtBarButton * pTBB =
  500. _GetButtonPtr(m_nOldTrackingIndex);
  501. ASSERT_VALID( pTBB );
  502. pTBB->ModifyStyle(0,TBBS_PRESSED|TBBS_CHECKED);
  503. if( bRepaint )
  504. _InvalidateButton(m_nOldTrackingIndex);
  505. } // if( m_nOldTrackingIndex >= 0 && m_nOldTrackingIndex < nCountOfButtons )
  506. if( m_nFlatTrackingIndex >= 0 )
  507. {
  508. ASSERT( m_nFlatTrackingIndex < nCountOfButtons );
  509. CExtBarButton * pTBB =
  510. _GetButtonPtr(m_nFlatTrackingIndex);
  511. ASSERT_VALID( pTBB );
  512. pTBB->ModifyStyle(TBBS_PRESSED);
  513. if( bRepaint )
  514. _InvalidateButton(m_nFlatTrackingIndex);
  515. }
  516. m_nOldTrackingIndex = m_nFlatTrackingIndex;
  517. AnimationSite_PassAnimationEvents();
  518. ///UpdateWindow();
  519. } // if( m_nFlatTrackingIndex != m_nOldTrackingIndex )
  520. }
  522. void CExtMenuControlBar::_DelaySyncActiveMdiChild()
  523. {
  524. ASSERT_VALID( this );
  525. if( m_bDelayedSyncActiveMdiChild
  526. || m_bDelayedUpdateMenuBar
  527. || m_hWnd == NULL
  528. || (! ::IsWindow(m_hWnd) )
  529. )
  530. return;
  531. m_bDelayedSyncActiveMdiChild = true;
  532. PostMessage( WM_TIMER, 13, 0 );
  533. }
  535. void CExtMenuControlBar::_DelayUpdateMenuBar()
  536. {
  537. ASSERT_VALID( this );
  538. if( m_bDelayedUpdateMenuBar
  539. || m_hWnd == NULL
  540. || (! ::IsWindow(m_hWnd) )
  541. )
  542. return;
  543. m_bDelayedSyncActiveMdiChild = false;
  544. m_bDelayedUpdateMenuBar = true;
  545. PostMessage( WM_TIMER, 14, 0 );
  546. }
  548. void CExtMenuControlBar::OnTimer(__EXT_MFC_UINT_PTR nIDEvent) 
  549. {
  550. __PROF_UIS_MANAGE_STATE;
  552. if( nIDEvent == 13 )
  553. {
  554. KillTimer( nIDEvent );
  555. if( m_bDelayedSyncActiveMdiChild )
  556. {
  557. m_bDelayedSyncActiveMdiChild = false;
  558. _SyncActiveMdiChild();
  559. }
  560. return;
  561. } // if( nIDEvent == 13 )
  563. if( nIDEvent == 14 )
  564. {
  565. KillTimer( nIDEvent );
  566. if( m_bDelayedUpdateMenuBar )
  567. {
  568. m_bDelayedUpdateMenuBar = false;
  569. VERIFY( UpdateMenuBar( TRUE ) );
  570. } // if( m_bDelayedUpdateMenuBar )
  571. return;
  572. } // if( nIDEvent == 14 )
  574. if( nIDEvent == 15 )
  575. {
  576. KillTimer( nIDEvent );
  577. ASSERT( m_bMdiApp );
  578. HWND hWndMdiClient = _GetHwndMdiArea();
  579. if( hWndMdiClient != NULL )
  580. {
  581. KillTimer( nIDEvent );
  582. VERIFY( _InitMdiChildHook( hWndMdiClient ) );
  583. } // if( hWndMdiClient != NULL )
  584. return;
  585. } // if( nIDEvent == 15 )
  587. if( nIDEvent == 16 )
  588. {
  589. KillTimer( nIDEvent );
  590. _KillFrameMenu();
  591. return;
  592. } // if( nIDEvent == 16 )
  594. CExtToolControlBar::OnTimer(nIDEvent);
  595. }
  597. bool CExtMenuControlBar::_InitMdiChildHook( HWND hWndMdiClient )
  598. {
  599. ASSERT( m_bMdiApp );
  600. ASSERT( ::IsWindow(hWndMdiClient) );
  601. if( ! SetupHookWndSink( hWndMdiClient ) )
  602. {
  603. ASSERT( FALSE );
  604. return false;
  605. } // if( ! SetupHookWndSink( hWndMdiClient ) )
  606. ::SetWindowPos(
  607. hWndMdiClient, NULL, 0, 0, 0, 0,
  608. SWP_FRAMECHANGED
  609. |SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOCOPYBITS
  610. |SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE
  611. );
  612. VERIFY( _SyncActiveMdiChild() );
  613. return true;
  614. }
  617. bool CExtMenuControlBar::_IsSimplifiedDropDownButtons() const
  618. {
  619. ASSERT_VALID( this );
  620. return true;
  621. }
  623. bool CExtMenuControlBar::_OnMouseMoveMsg(UINT nFlags, CPoint point) 
  624. {
  625. if( ! m_bFlatTracking )
  626. return CExtToolControlBar::_OnMouseMoveMsg(nFlags, point);
  627. int nIndex = HitTest( point );
  628. if( nIndex == m_nFlatTrackingIndex
  629. || nIndex < 0
  630. )
  631. return true;
  632. TrackButtonMenu( nIndex );
  633. return true;
  634. }
  636. void CExtMenuControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
  637. {
  638. if( !m_bFlatTracking )
  639. {
  640. int nIndex = HitTest(point);
  641. if( nIndex >= 0 )
  642. {
  643. int nMenuIndex = GetMenuTrackingButton();
  644. if( nIndex == nMenuIndex )
  645. return;
  646. }
  647. }
  649. CExtToolControlBar::OnLButtonDown(nFlags, point);
  650. }
  652. void CExtMenuControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
  653. {
  654. BOOL bRepaint = FALSE;
  655. if( m_bFlatTracking )
  656. {
  657. m_bFlatTracking = false;
  658. OnFlatTrackingStop();
  659. _UpdateFlatTracking( FALSE );
  660. bRepaint = TRUE;
  661. }
  662. CExtToolControlBar::OnLButtonUp(nFlags, point);
  663. if( bRepaint )
  664. Invalidate();
  665. }
  667. void CExtMenuControlBar::_RecalcLayoutImpl()
  668. {
  669. CExtToolControlBar::_RecalcLayoutImpl();
  670. if( m_pDockSite != NULL
  671. && IsFloating()
  672. && ( ! ((InternalFriendlyFrameWnd*)m_pDockSite)->IsInRecalcLayout() )
  673. && (! CExtControlBar::ProfileBarStateIsSerializing( m_pDockSite ) )
  674. && (m_pDockSite->GetStyle()&WS_VISIBLE) != 0
  675. )
  676. {
  677. WINDOWPLACEMENT _wp;
  678. ZeroMemory( &_wp, sizeof(WINDOWPLACEMENT) );
  679. _wp.length = sizeof(WINDOWPLACEMENT);
  680. CWnd * pWndPlacement = stat_GetWndForPlacement( m_pDockSite );
  681. ASSERT_VALID( pWndPlacement );
  682. pWndPlacement->GetWindowPlacement( &_wp );
  683. if( _wp.showCmd == SW_SHOWMINIMIZED )
  684. {
  685. //m_pDockSite->DelayRecalcLayout();
  686. return;
  687. }
  688. m_pDockSite->RecalcLayout();
  689. }
  690. }
  692. bool CExtMenuControlBar::OnQueryShiftRTL() const
  693. {
  694. ASSERT_VALID( this );
  695. return ((g_ResourceManager->OnQueryLangLayout()&LAYOUT_RTL) != 0) ? true : false;
  696. }
  698. bool CExtMenuControlBar::OnQueryRevertRTL() const
  699. {
  700. ASSERT_VALID( this );
  701. return ((g_ResourceManager->OnQueryLangLayout()&LAYOUT_RTL) != 0) ? true : false;
  702. }
  704. void CExtMenuControlBar::_RecalcPositionsImpl()
  705. {
  706. CExtToolControlBar::_RecalcPositionsImpl();
  708. if( g_bHideMenuBarExpandContentButton
  709. && m_pRightBtn != NULL
  710. )
  711. {
  712. ASSERT_VALID( m_pRightBtn );
  713. if( m_pRightBtn->GetButtons().GetSize() == 0 )
  714. m_pRightBtn->Show( FALSE );
  715. }
  717. CWnd * pWndParent = GetParent();
  718. ASSERT_VALID( pWndParent );
  719. BOOL bInDockBar = pWndParent->IsKindOf(RUNTIME_CLASS(CDockBar));
  720. if( IsFloating() && bInDockBar )
  721. return;
  722. int nCountOfButtons = GetButtonsCount();
  723. if( nCountOfButtons <= 1 )
  724. return;
  725. int nRightIndex = nCountOfButtons - 1;
  726. CExtBarMdiRightButton * pRightTBB =
  727. DYNAMIC_DOWNCAST(
  728. CExtBarMdiRightButton,
  729. _GetButtonPtr( nRightIndex )
  730. );
  731. if( pRightTBB == NULL && nCountOfButtons > 1 )
  732. {
  733. nRightIndex--;
  734. pRightTBB =
  735. DYNAMIC_DOWNCAST(
  736. CExtBarMdiRightButton,
  737. _GetButtonPtr( nRightIndex )
  738. );
  739. } // if( pRightTBB == NULL && nCountOfButtons > 1 )
  740. if( pRightTBB == NULL )
  741. return;
  742. if( !pRightTBB->IsVisible() )
  743. return;
  744. ASSERT( nRightIndex >= 1 );
  746. #ifdef _DEBUG
  747. CExtBarButton * pPrevTBB =
  748. _GetButtonPtr( nRightIndex - 1 );
  749. ASSERT_VALID( pPrevTBB );
  750. /// ASSERT( pPrevTBB->IsVisible() );
  751. #endif // _DEBUG
  753. CExtBarButton * pExpandTBB = NULL;
  754. CRect rcBtnExpand(0,0,0,0);
  755. int nAlignMargin = 0;
  756. BOOL bHorz = 
  757. bInDockBar
  758. ? IsDockedHorizontally()
  759. : ( (m_dwStyle & (CBRS_ALIGN_TOP|CBRS_ALIGN_BOTTOM))
  760. ? true
  761. : false
  762. )
  763. ;
  764. CRect rcClient;
  765. GetClientRect( &rcClient );
  767. if( nRightIndex < (nCountOfButtons-1) )
  768. {
  769. pExpandTBB = _GetButtonPtr( nRightIndex + 1 );
  770. ASSERT_VALID( pExpandTBB );
  771. if( ! pExpandTBB->IsKindOf( RUNTIME_CLASS(CExtBarContentExpandButton)) )
  772. pExpandTBB = NULL;
  773. } // if( nRightIndex < (nCountOfButtons-1) )
  775. if( pExpandTBB != NULL )
  776. { // if content-expand button exists
  777. if( pExpandTBB->IsVisible() )
  778. {
  779. rcBtnExpand = pExpandTBB->Rect();
  780. nAlignMargin =
  781. bHorz ? rcBtnExpand.left : rcBtnExpand.top;
  782. } // if( pExpandTBB->IsVisible() )
  783. else
  784. {
  785. pExpandTBB = NULL;
  786. nAlignMargin =
  787. bHorz ? rcClient.right : rcClient.bottom;
  788. } // else from if( pExpandTBB->IsVisible() )
  789. nAlignMargin -= __MENUBAR_RIGHT_ADJUST_GAP;
  790. } // if content-expand button exists
  791. else
  792. {  // if content-expand button DOES NOT exists
  793. nAlignMargin =
  794. bHorz ? rcClient.right : rcClient.bottom;
  795. nAlignMargin -= __MENUBAR_RIGHT_ADJUST_GAP;
  796. }  // if content-expand button DOES NOT exists
  797. CRect rcBtnRight = pRightTBB->Rect();
  798. if( bHorz && rcBtnRight.right >= nAlignMargin )
  799. return;
  800. if( (!bHorz) && rcBtnRight.bottom >= nAlignMargin )
  801. return;
  802. if( bHorz )
  803. rcBtnRight.OffsetRect(
  804. nAlignMargin - rcBtnRight.right,
  805. 0
  806. );
  807. else
  808. rcBtnRight.OffsetRect(
  809. 0,
  810. nAlignMargin - rcBtnRight.bottom
  811. );
  813. if( pExpandTBB == NULL )
  814. {
  815. pRightTBB->SetRect(rcBtnRight);
  816. return;
  817. }
  819. ASSERT( !rcBtnExpand.IsRectEmpty() );
  820. CRect rcBtnExpand2(
  821. bHorz ? rcBtnRight.left : rcBtnExpand.left,
  822. bHorz ? rcBtnExpand.top : rcBtnRight.top,
  823. bHorz ?
  824. rcBtnRight.left + rcBtnExpand.Width()
  825. :
  826. rcBtnExpand.left + rcBtnExpand.Width()
  827. ,
  828. bHorz ?
  829. rcBtnExpand.top + rcBtnExpand.Height()
  830. :
  831. rcBtnRight.top + rcBtnExpand.Height()
  832. );
  833. rcBtnRight.OffsetRect(
  834. bHorz ? rcBtnExpand.right - rcBtnRight.right : 0,
  835. bHorz ? 0 : rcBtnExpand.bottom - rcBtnRight.bottom
  836. );
  837. pRightTBB->SetRect(rcBtnRight);
  838. pExpandTBB->SetRect(rcBtnExpand2);
  840. if( g_bHideMenuBarExpandContentButton )
  841. pExpandTBB->Show( FALSE );
  842. }
  844. bool CExtMenuControlBar::_GetFullRowMode() const
  845. {
  846. ASSERT_VALID( this );
  847. return true;
  848. }
  850. bool CExtMenuControlBar::OnQueryMultiRowLayout() const
  851. {
  852. ASSERT_VALID( this );
  853. if( m_bPresubclassDialogMode
  854. // || m_pDockSite == NULL
  855. )
  856. return false;
  857. if( m_pDockBar != NULL )
  858. {
  859. if( IsFloating() )
  860. return false;
  861. if( _IsDockSiteCustomizeMode() )
  862. return true;
  863. } // if( m_pDockBar != NULL )
  864. return m_bMultiRowLayout;
  865. }
  867. CExtBarContentExpandButton * CExtMenuControlBar::OnCreateBarRightBtn()
  868. {
  869. ASSERT_VALID( this );
  870. if( m_bMultiRowLayout )
  871. return NULL;
  872. return CExtToolControlBar::OnCreateBarRightBtn();
  873. }
  875. void CExtMenuControlBar::_Dragging_OnStart()
  876. {
  877. _CancelFlatTracking();
  878. if( g_bMenuTracking )
  879. _CloseTrackingMenus();
  880. CExtToolControlBar::_Dragging_OnStart();
  881. }
  883. void CExtMenuControlBar::_Dragging_OnStop(
  884. CExtControlBar::InternalDraggingState_t & _dsOld,
  885. CExtControlBar::InternalDraggingState_t & _dsNew,
  886. bool bCancel
  887. )
  888. {
  889. CExtToolControlBar::_Dragging_OnStop(
  890. _dsOld,
  891. _dsNew,
  892. bCancel
  893. );
  894. if( _IsMdiApp() )
  895. {
  896. _InstallMdiDocButtons();
  897. _RecalcPositionsImpl();
  898. } // if( _IsMdiApp() )
  899. }
  901. HWND CExtMenuControlBar::_GetHwndMainFrame()
  902. {
  903. if( m_bPresubclassDialogMode )
  904. return NULL;
  906. CFrameWnd * pFrame = _GetDockingFrameImpl();
  907. ASSERT_VALID( pFrame );
  908. ASSERT( ::IsWindow(pFrame->GetSafeHwnd()) );
  909. return pFrame->GetSafeHwnd();
  910. }
  912. HWND CExtMenuControlBar::_GetHwndPlacement()
  913. {
  914. if( !m_bPresubclassDialogMode )
  915. return NULL;
  916. return m_hWndHelper;
  917. }
  919. HWND CExtMenuControlBar::_GetHwndChildFrame()
  920. {
  921. if( m_bPresubclassDialogMode )
  922. return NULL;
  923. return m_hWndHelper;
  924. }
  926. HWND CExtMenuControlBar::_GetHwndMdiArea()
  927. {
  928. if( m_bPresubclassDialogMode )
  929. return NULL;
  931. ASSERT( _IsMdiApp() );
  933. CFrameWnd * pFrame = _GetDockingFrameImpl();
  934. ASSERT_VALID( pFrame );
  935. ASSERT( ::IsWindow(pFrame->GetSafeHwnd()) );
  937. // FrameFeatures does not use CMDIFrameWnd
  938. // ASSERT_KINDOF( CMDIFrameWnd, pFrame );
  939. CMDIFrameWnd * pMdiFrame =
  940. DYNAMIC_DOWNCAST(
  941. CMDIFrameWnd,
  942. pFrame
  943. );
  944. if( pMdiFrame == NULL )
  945. {
  946. for( HWND hWnd = ::GetWindow( pFrame->GetSafeHwnd(), GW_CHILD );
  947. hWnd != NULL;
  948. hWnd = ::GetWindow( hWnd, GW_HWNDNEXT )
  949. )
  950. {
  951. ASSERT( ::IsWindow( hWnd ) );
  952. TCHAR strClassName[ 512 ];
  953. ::memset( strClassName, 0, sizeof(strClassName) );
  954. ::GetClassName( hWnd, strClassName, 512 );
  955. if( _tcslen( strClassName ) == 0 )
  956. continue;
  957. __EXT_MFC_STRLWR( strClassName, 512 );
  958. //if( _tcscmp( strClassName, _T("mdiclient") ) == 0 )
  959. if( _tcsstr( strClassName, _T("mdiclient") ) != NULL )
  960. return hWnd;
  961. }
  962. return NULL;
  963. } // if( pMdiFrame == NULL )
  964. //ASSERT_VALID( pMdiFrame );
  966. ASSERT( pMdiFrame->m_hWndMDIClient != NULL );
  967. ASSERT( ::IsWindow( pMdiFrame->m_hWndMDIClient ) );
  968. return pMdiFrame->m_hWndMDIClient;
  969. }
  971. int CExtMenuControlBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  972. {
  973. if (CExtToolControlBar::OnCreate(lpCreateStruct) == -1)
  974. return -1;
  976. CFrameWnd * pFrame = _GetDockingFrameImpl();
  977. if( pFrame == NULL )
  978. {
  979. m_bPresubclassDialogMode = true;
  980. if( m_hWndHelper == NULL )
  981. {
  982. m_hWndHelper = ::GetParent( m_hWnd );
  983. ASSERT( m_hWndHelper != NULL );
  984. ASSERT( ::IsWindow( m_hWndHelper ) );
  985. if( !IsHookedWindow( m_hWndHelper ) )
  986. SetupHookWndSink( m_hWndHelper );
  987. } // if( m_hWndHelper == NULL )
  988. return 0;
  989. }
  991. ASSERT_VALID( pFrame );
  992. ASSERT( ::IsWindow(pFrame->GetSafeHwnd()) );
  994. ASSERT( m_menuFrame.GetSafeHmenu() == NULL );
  995. ASSERT( m_menuDoc.GetSafeHmenu() == NULL );
  997. if( (pFrame->GetStyle()&WS_CHILD) == 0 )
  998. {
  999. HMENU hFrameMenu = pFrame->GetMenu()->GetSafeHmenu();
  1000. if( hFrameMenu != NULL )
  1001. {
  1002. m_menuFrame.Attach( hFrameMenu );
  1003. _UpdateMenuBar( FALSE );
  1004. pFrame->SetMenu( NULL );
  1005. }
  1006. } // if( (pFrame->GetStyle()&WS_CHILD) == 0 )
  1008. HWND hWndMainFrame = _GetHwndMainFrame();
  1009. if( hWndMainFrame != NULL )
  1010. {
  1011. CWnd * pWndForPlacement = stat_GetWndForPlacement( CWnd::FromHandle(hWndMainFrame) );
  1012. if( ! SetupHookWndSink( pWndForPlacement->m_hWnd ) )
  1013. {
  1014. ASSERT( FALSE );
  1015. return FALSE;
  1016. }
  1017. if( pWndForPlacement->m_hWnd != hWndMainFrame )
  1018. {
  1019. if( ! SetupHookWndSink( hWndMainFrame ) )
  1020. {
  1021. ASSERT( FALSE );
  1022. return FALSE;
  1023. }
  1024. }
  1026. // FrameFeatures does not use CMDIFrameWnd
  1027. if( pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd))
  1028. || _IsMdiApp()
  1029. )
  1030. { // if MDI App
  1031. m_bMdiApp = true;
  1032. HWND hWndMdiClient = _GetHwndMdiArea();
  1033. if( hWndMdiClient != NULL )
  1034. {
  1035. VERIFY( _InitMdiChildHook( hWndMdiClient ) );
  1036. }
  1037. else
  1038. SetTimer( 15, 10, NULL );
  1040. // // pass message loop for smooth MDI client area update reasons
  1041. // //CExtPopupMenuWnd::PassMsgLoop( CExtControlBar::g_bEnableOnIdleCalls );
  1042. // MSG msg;
  1043. // int i = 0;
  1044. // for( ; PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) && i < 1000; i++ )
  1045. // {
  1046. // if( !AfxGetThread()->PumpMessage() )
  1047. // break;
  1048. // if( msg.message == WM_TIMER && msg.wParam == 15 )
  1049. // break;
  1050. // } // while( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) )
  1051. } // if( pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd)) ...
  1053. } // if( hWndMainFrame != NULL )
  1056. return 0;
  1057. }
  1059. /////////////////////////////////////////////////////////////////////////////
  1060. // CExtBarMdiDocButton
  1062. IMPLEMENT_DYNCREATE(CExtBarMdiDocButton,CExtBarButton)
  1064. CExtBarMdiDocButton::CExtBarMdiDocButton(
  1065. CExtToolControlBar * pBar, // = NULL
  1066. UINT nCmdID, // = ID_SEPARATOR
  1067. UINT nStyle // = 0
  1068. )
  1069. : CExtBarButton( pBar, nCmdID, nStyle )
  1070. , m_hWndActiveMdiChild( NULL )
  1071. , m_bHandleDblClickAsCloseCmd( true )
  1072. {
  1073. }
  1075. CExtBarMdiDocButton::~CExtBarMdiDocButton()
  1076. {
  1077. }
  1079. #if (!defined __EXT_MFC_NO_RIBBON_BAR)
  1081. bool CExtBarMdiDocButton::IsRibbonPaintingMode() const
  1082. {
  1083. ASSERT_VALID( this );
  1084. return false;
  1085. }
  1087. CSize CExtBarMdiDocButton::RibbonILV_CalcSize(
  1088. CDC & dc,
  1089. INT nILV // = -1 // -1 use current visual level
  1090. ) const
  1091. {
  1092. ASSERT_VALID( this );
  1093. nILV;
  1094. return
  1095. ( const_cast < CExtBarMdiDocButton * > ( this ) )
  1096. -> CalculateLayout( dc, CSize(0,0), IsHorzBarOrientation() );
  1097. }
  1099. #endif //  (!defined __EXT_MFC_NO_RIBBON_BAR)
  1101. CSize CExtBarMdiDocButton::CalculateLayout(
  1102. CDC & dc,
  1103. CSize sizePreCalc,
  1104. BOOL bHorz
  1105. )
  1106. {
  1107. ASSERT_VALID( this );
  1108. ASSERT_VALID( GetBar() );
  1109. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  1110. ASSERT_VALID( (&dc) );
  1111. ASSERT( CtrlGet() == NULL );
  1112. ASSERT( ! IsSeparator() );
  1113. dc;
  1114. sizePreCalc;
  1115. bHorz;
  1116. CSize _size( 16, 16 );
  1117. CExtCmdIcon * pIcon = GetIconPtr();
  1118. if( pIcon != NULL
  1119. && (! pIcon->IsEmpty() )
  1120. )
  1121. _size = pIcon->GetSize();
  1122. _size.cx += 3;
  1123. _size.cy += 3;
  1124. return _size;
  1125. }
  1127. bool CExtBarMdiDocButton::CanStartCommandDrag()
  1128. {
  1129. ASSERT_VALID( this );
  1130. return false;
  1131. }
  1133. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1134. CExtCustomizeCmdTreeNode * CExtBarMdiDocButton::GetCmdNode(
  1135. bool bInitial // = false
  1136. )
  1137. {
  1138. ASSERT_VALID( this );
  1139. // ASSERT_VALID( GetBar() );
  1140. // bInitial;
  1141. // ASSERT( m_pCmdNodeI == NULL );
  1142. // ASSERT( m_pCmdNodeC == NULL );
  1143. // return NULL;
  1144. return CExtBarButton::GetCmdNode( bInitial );
  1145. }
  1146. void CExtBarMdiDocButton::SetBasicCmdNode(
  1147. CExtCustomizeCmdTreeNode * pNode
  1148. )
  1149. {
  1150. ASSERT_VALID( this );
  1151. // ASSERT_VALID( GetBar() );
  1152. // ASSERT( m_pCmdNodeI == NULL );
  1153. // ASSERT( m_pCmdNodeC == NULL );
  1154. // ASSERT( FALSE ); // should be never called
  1155. // pNode;
  1156. CExtBarButton::SetBasicCmdNode( pNode );
  1157. }
  1158. void CExtBarMdiDocButton::SetCustomizedCmdNode(
  1159. CExtCustomizeCmdTreeNode * pNode
  1160. )
  1161. {
  1162. ASSERT_VALID( this );
  1163. // ASSERT_VALID( GetBar() );
  1164. // ASSERT( m_pCmdNodeI == NULL );
  1165. // ASSERT( m_pCmdNodeC == NULL );
  1166. // ASSERT( FALSE ); // should be never called
  1167. // pNode;
  1168. CExtBarButton::SetCustomizedCmdNode( pNode );
  1169. }
  1170. CExtCustomizeCmdTreeNode * CExtBarMdiDocButton::OnCustomizeNodeInit(
  1171. CExtCustomizeSite * pSite,
  1172. CExtCustomizeCmdTreeNode * pParentNode // toolbar node
  1173. )
  1174. {
  1175. ASSERT_VALID( this );
  1176. // ASSERT_VALID( GetBar() );
  1177. // ASSERT( pSite != NULL );
  1178. // ASSERT_VALID( pParentNode );
  1179. // pSite;
  1180. // pParentNode;
  1181. // return NULL; // no customization support
  1182. return CExtBarButton::OnCustomizeNodeInit( pSite, pParentNode );
  1183. }
  1184. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1186. BOOL CExtBarMdiDocButton::PutToPopupMenu(
  1187. CExtPopupMenuWnd * pPopup
  1188. )
  1189. {
  1190. ASSERT( pPopup != NULL );
  1191. ASSERT( pPopup->GetSafeHwnd() == NULL );
  1193. ASSERT_VALID( GetBar() );
  1194. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  1195. ASSERT( CtrlGet() == NULL );
  1196. ASSERT( ! IsSeparator() );
  1198. HWND hWndActiveChild = _ActiveMdiChildWndGet();
  1199. ASSERT( ::IsWindow( hWndActiveChild ) );
  1201. //CFrameWnd * pFrame =
  1202. // DYNAMIC_DOWNCAST(
  1203. // CFrameWnd,
  1204. // CWnd::FromHandle(hWndActiveChild)
  1205. // );
  1206. CMenu * pSysMenu =
  1207. CWnd::FromHandle(hWndActiveChild) ->
  1208. GetSystemMenu( FALSE );
  1209. if( pSysMenu == NULL )
  1210. {
  1211. ASSERT( FALSE );
  1212. return FALSE;
  1213. }
  1214. ASSERT( ::IsMenu(pSysMenu->GetSafeHmenu()) );
  1215. CExtCmdIcon & _icon = GetIcon();
  1217. CExtSafeString sActiveDocument;
  1218. if( ! g_ResourceManager->LoadString( sActiveDocument, IDS_ACTIVE_DOCUMENT ) )
  1219. sActiveDocument = _T("Active document");
  1221. if( ! pPopup->ItemInsert(
  1222. (UINT)CExtPopupMenuWnd::TYPE_POPUP,
  1223. -1,
  1224. sActiveDocument,
  1225. _icon
  1226. )
  1227. )
  1228. {
  1229. ASSERT( FALSE );
  1230. return FALSE;
  1231. }
  1232. CExtPopupMenuWnd * pChildPopup =
  1233. pPopup->ItemGetPopup(
  1234. pPopup->ItemGetCount() - 1
  1235. );
  1236. ASSERT( pChildPopup != NULL );
  1237. if( ! pChildPopup->UpdateFromMenu(
  1238. GetBar()->GetSafeHwnd(),
  1239. pSysMenu,
  1240. false,
  1241. false
  1242. )
  1243. )
  1244. {
  1245. ASSERT( FALSE );
  1246. return FALSE;
  1247. }
  1248. pChildPopup->
  1249. SetCmdTargetToAllItems(
  1250. hWndActiveChild
  1251. );
  1252. if( (pPopup->TrackFlagsGet()&TPMX_PALETTE) != 0 )
  1253. pPopup->ItemGetInfo(pPopup->ItemGetCount()-1).SetChildCombine();
  1255. VERIFY(
  1256. pPopup->ItemInsert(
  1257. CExtPopupMenuWnd::TYPE_SEPARATOR,
  1258. -1
  1259. )
  1260. );
  1262. return TRUE;
  1263. }
  1265. HWND CExtBarMdiDocButton::_ActiveMdiChildWndGet()
  1266. {
  1267. ASSERT_VALID( this );
  1268. if( m_hWndActiveMdiChild != NULL
  1269. && ::IsWindow( m_hWndActiveMdiChild )
  1270. )
  1271. return m_hWndActiveMdiChild;
  1272. /// if( p_bMaximized != NULL )
  1273. /// (*p_bMaximized) = false;
  1274. CMDIFrameWnd * pMdiFrame = DYNAMIC_DOWNCAST( CMDIFrameWnd, GetBar()->_GetDockingFrameImpl() );
  1275. HWND hWndMdiClient = NULL;
  1276. if( pMdiFrame == NULL )
  1277. hWndMdiClient = ((CExtMenuControlBar*)GetBar())->_GetHwndMdiArea();
  1278. else
  1279. {
  1280. ASSERT_VALID( pMdiFrame );
  1281. hWndMdiClient = pMdiFrame->m_hWndMDIClient;
  1282. } // else from if( pMdiFrame == NULL )
  1283. if( hWndMdiClient == NULL )
  1284. return NULL;
  1285. ASSERT( ::IsWindow( hWndMdiClient ) );
  1286. BOOL bMax = FALSE;
  1287. HWND hWndActiveChildFrame = (HWND) ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMax );
  1288. if( hWndActiveChildFrame == NULL )
  1289. {
  1290. /// bMax = FALSE;
  1291. }
  1292. else
  1293. {
  1294. ASSERT( ::IsWindow( hWndActiveChildFrame ) );
  1295. __EXT_MFC_LONG_PTR dwActiveChildFrameStyle =
  1296. ::__EXT_MFC_GetWindowLong( hWndActiveChildFrame, GWL_STYLE );
  1297. if( pMdiFrame == NULL )
  1298. {
  1299. if( (dwActiveChildFrameStyle&WS_VISIBLE) == 0 )
  1300. {
  1301. hWndActiveChildFrame = NULL;
  1302. ///bMax = FALSE;
  1303. } // if( (dwActiveChildFrameStyle&WS_VISIBLE) == 0 )
  1304. } // if( pMdiFrame == NULL )
  1305. else
  1306. {
  1307. CWnd * pWndTempAnalyze = CWnd::FromHandlePermanent( hWndActiveChildFrame );
  1308. if( pWndTempAnalyze != NULL )
  1309. {
  1310. ASSERT_VALID( pWndTempAnalyze );
  1311. CMDIChildWnd * pWndTempMDIChild = DYNAMIC_DOWNCAST( CMDIChildWnd, pWndTempAnalyze );
  1312. if( pWndTempMDIChild != NULL
  1313. && pWndTempMDIChild->m_bPseudoInactive
  1314. && (dwActiveChildFrameStyle&WS_VISIBLE) == 0
  1315. )
  1316. {
  1317. hWndActiveChildFrame = NULL;
  1318. ///bMax = FALSE;
  1319. }
  1320. } // if( pWndTempAnalyze != NULL )
  1321. } // else from if( pMdiFrame == NULL )
  1322. } // else from if( hWndActiveChildFrame == NULL )
  1323. /// if( p_bMaximized != NULL )
  1324. /// (*p_bMaximized) = bMax ? true : false;
  1325. return hWndActiveChildFrame;
  1326. }
  1328. HWND CExtBarMdiDocButton::_ActiveMdiChildWndAttach(
  1329. HWND hWndActiveMdiChildNew
  1330. )
  1331. {
  1332. ASSERT_VALID( this );
  1333. if( hWndActiveMdiChildNew == m_hWndActiveMdiChild )
  1334. return m_hWndActiveMdiChild;
  1335. HWND hWndActiveMdiChildOld = m_hWndActiveMdiChild;
  1336. m_hWndActiveMdiChild = hWndActiveMdiChildNew;
  1337. m_iconCache.Empty();
  1338. return hWndActiveMdiChildOld;
  1339. }
  1341. HWND CExtBarMdiDocButton::_ActiveMdiChildWndDetach()
  1342. {
  1343. ASSERT_VALID( this );
  1344. return _ActiveMdiChildWndAttach( NULL );
  1345. }
  1347. CExtCmdIcon * CExtBarMdiDocButton::GetIconPtr()
  1348. {
  1349. ASSERT_VALID( this );
  1350. ASSERT_VALID( GetBar() );
  1351. if( m_hWndActiveMdiChild != NULL
  1352. && ::IsWindow( m_hWndActiveMdiChild )
  1353. && ( ! m_iconCache.IsEmpty() )
  1354. )
  1355. return (&m_iconCache);
  1356. HWND hWndActiveChild = _ActiveMdiChildWndGet();
  1357. if( hWndActiveChild == NULL )
  1358. return NULL;
  1359. if( m_hWndActiveMdiChild != hWndActiveChild )
  1360. m_hWndActiveMdiChild = NULL;
  1361. ASSERT( ::IsWindow(hWndActiveChild) );
  1362. _ExtractWndIcon( hWndActiveChild, m_iconCache );
  1363. if( m_iconCache.IsEmpty() )
  1364. return NULL;
  1365. return (&m_iconCache);
  1366. }
  1368. void CExtBarMdiDocButton::_ExtractWndIcon(
  1369. HWND hWnd,
  1370. CExtCmdIcon & _Icon
  1371. )
  1372. {
  1373. _Icon.Empty();
  1374. if( hWnd == NULL
  1375. || ( ! ::IsWindow( hWnd ) )
  1376. )
  1377. return;
  1378. HICON hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::SendMessage( hWnd, CExtControlBar::g_nMsgQueryIcon, 0, 0 );
  1379. if( hIcon == NULL )
  1380. {
  1381. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::SendMessage( hWnd, WM_GETICON, ICON_SMALL, 0 );
  1382. if( hIcon == NULL )
  1383. {
  1384. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::SendMessage( hWnd, WM_GETICON, ICON_BIG, 0 );
  1385. if( hIcon == NULL )
  1386. {
  1387. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::__EXT_MFC_GetClassLong( hWnd, __EXT_MFC_GCL_HICONSM );
  1388. if( hIcon == NULL )
  1389. {
  1390. hIcon = (HICON)(__EXT_MFC_DWORD_PTR) ::__EXT_MFC_GetClassLong( hWnd, __EXT_MFC_GCL_HICON );
  1391. if( hIcon == NULL )
  1392. return;
  1393. } // if( hIcon == NULL )
  1394. } // if( hIcon == NULL )
  1395. } // if( hIcon == NULL )
  1396. } // if( hIcon == NULL )
  1397. ASSERT( hIcon != NULL );
  1398. // _Icon.AssignFromHICON( hIcon, true );
  1399. CExtCmdIcon _iconBig;
  1400. _iconBig.AssignFromHICON( hIcon, true );
  1401. VERIFY(
  1402. _Icon.CreateScaledCopy(
  1403. _iconBig,
  1404. CSize( 16, 16 )
  1405. )
  1406. );
  1407. }
  1409. void CExtBarMdiDocButton::OnUpdateCmdUI(
  1410. CWnd * pTarget,
  1411. BOOL bDisableIfNoHndler,
  1412. int nIndex
  1413. )
  1414. {
  1415. ASSERT_VALID( this );
  1416. pTarget;
  1417. bDisableIfNoHndler;
  1418. nIndex;
  1419. }
  1421. bool CExtBarMdiDocButton::OnDblClick(
  1422. CPoint point
  1423. )
  1424. {
  1425. ASSERT_VALID( this );
  1426. ASSERT_VALID( GetBar() );
  1427. if( ! IsEnabled() )
  1428. return false;
  1429. if( ! m_bHandleDblClickAsCloseCmd )
  1430. return false;
  1431. CWnd * pWndMdiChildFrame = GetCmdTargetWnd();
  1432. if( pWndMdiChildFrame->GetSafeHwnd() == NULL )
  1433. return true;
  1434. bool bAllowClose = false;
  1435. CMenu * pSysMenu = pWndMdiChildFrame->GetSystemMenu( FALSE );
  1436. if( pSysMenu != NULL )
  1437. {
  1438. INT nCount = pSysMenu->GetMenuItemCount();
  1439. for( INT nItem = 0; nItem < nCount; nItem++ )
  1440. {
  1441. UINT nID = pSysMenu->GetMenuItemID( nItem );
  1442. if( nID != SC_CLOSE )
  1443. continue;
  1444. MENUITEMINFO mii;
  1445. ::memset(&mii,0,sizeof(MENUITEMINFO));
  1446. mii.cbSize = sizeof(MENUITEMINFO);
  1447. mii.fMask = MIIM_STATE;
  1448. if( !pSysMenu->GetMenuItemInfo(
  1449. nItem,
  1450. &mii,
  1451. TRUE
  1452. )
  1453. )
  1454. break;
  1455. if( ( mii.fState & (MFS_DISABLED|MFS_GRAYED) ) == 0 )
  1456. bAllowClose = true;
  1457. break;
  1458. } // for( INT nItem = 0; nItem < nCount; nItem++ )
  1459. } // if( pSysMenu != NULL )
  1460. if( ! bAllowClose )
  1461. return true;
  1462. GetBar()->ClientToScreen( &point );
  1463. pWndMdiChildFrame->PostMessage(
  1464. WM_SYSCOMMAND,
  1465. SC_CLOSE,
  1466. MAKELONG( point.x, point.y )
  1467. );
  1468. return true;
  1469. }
  1471. CWnd * CExtBarMdiDocButton::GetCmdTargetWnd()
  1472. {
  1473. ASSERT_VALID( GetBar() );
  1474. HWND hWndActiveChild = _ActiveMdiChildWndGet();
  1475. if( hWndActiveChild == NULL )
  1476. return NULL;
  1477. ASSERT( ::IsWindow(hWndActiveChild) );
  1478. CWnd * pWnd = CWnd::FromHandlePermanent(hWndActiveChild);
  1479. if( pWnd == NULL )
  1480. {
  1481. pWnd = CWnd::FromHandle(hWndActiveChild);
  1482. ASSERT_VALID( pWnd );
  1483. } // if( pWnd == NULL )
  1484. #ifdef _DEBUG
  1485. else
  1486. {
  1487. ASSERT_VALID( pWnd );
  1488. // FrameFeatures specifics
  1489. //ASSERT( pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) );
  1490. } // else from if( pWnd == NULL )
  1491. #endif // _DEBUG
  1492. return pWnd;
  1493. }
  1495. UINT CExtBarMdiDocButton::OnTrackPopup(
  1496. CPoint point,
  1497. bool bSelectAny,
  1498. bool bForceNoAnimation
  1499. )
  1500. {
  1501. ASSERT_VALID( GetBar() );
  1503. bool bDockSiteCustomizeMode =
  1504. GetBar()->_IsDockSiteCustomizeMode();
  1505. if( bDockSiteCustomizeMode )
  1506. return UINT(-1L);
  1508. CExtMenuControlBar * pBar =
  1509. DYNAMIC_DOWNCAST(
  1510. CExtMenuControlBar,
  1511. GetBar()
  1512. );
  1513. CWnd * pWnd = CExtBarMdiDocButton::GetCmdTargetWnd();
  1514. //CFrameWnd * pFrame = 
  1515. // DYNAMIC_DOWNCAST(
  1516. // CFrameWnd,
  1517. // pWnd
  1518. // );
  1519. // ASSERT( pFrame != NULL );
  1520. if( pBar == NULL
  1521. //|| pFrame == NULL
  1522. )
  1523. {
  1524. CExtBarButton::OnTrackPopup( point, bSelectAny, bForceNoAnimation );
  1525. return UINT(-1L);
  1526. }
  1528. bool bPrevTBMT = CExtToolControlBar::g_bMenuTracking;
  1529. if( CExtToolControlBar::g_bMenuTracking
  1530. //&& CExtPopupMenuWnd::IsMenuTracking()
  1531. && pBar->_GetIndexOf(this) ==
  1532. pBar->m_nBtnIdxMenuTracking
  1533. )
  1534. return UINT(-1L);
  1536. CExtToolControlBar::_CloseTrackingMenus();
  1538. if( pBar->IsFloating() )
  1539. {
  1540. pBar->ActivateTopParent();
  1541. CFrameWnd * pFrame =
  1542. pBar->GetDockingFrame();
  1543. ASSERT_VALID( pFrame );
  1544. pFrame->BringWindowToTop();
  1545. }
  1547. __EXT_MFC_LONG_PTR dwExStyle = ::__EXT_MFC_GetWindowLong( pWnd->GetSafeHwnd(), GWL_EXSTYLE );
  1548. bool bRTL = ( (dwExStyle & WS_EX_LAYOUTRTL) != 0 ) ? true : false;
  1550. UINT nTrackFlags = TPMX_TOPALIGN;
  1551. CRect rcBtn = Rect();
  1552. // point.x = rcBtn.left;
  1553. // point.y = rcBtn.bottom;
  1554. switch( GetBar()->GetSafeDockBarDlgCtrlID() )
  1555. {
  1556. case AFX_IDW_DOCKBAR_BOTTOM:
  1557. nTrackFlags = TPMX_BOTTOMALIGN;
  1558. // point.x = rcBtn.left;
  1559. // point.y = rcBtn.bottom;
  1560. break;
  1561. case AFX_IDW_DOCKBAR_LEFT:
  1562. nTrackFlags = bRTL ? TPMX_RIGHTALIGN : TPMX_LEFTALIGN;
  1563. // point.x = rcBtn.right;
  1564. // point.y = rcBtn.top;
  1565. break;
  1566. case AFX_IDW_DOCKBAR_RIGHT:
  1567. nTrackFlags = bRTL ? TPMX_LEFTALIGN : TPMX_RIGHTALIGN;
  1568. // point.x = rcBtn.left;
  1569. // point.y = rcBtn.top;
  1570. break;
  1571. } // switch( GetBar()->GetSafeDockBarDlgCtrlID() )
  1572. pBar->ClientToScreen( &rcBtn );
  1573. // pBar->ClientToScreen( &point );
  1574. point = rcBtn.CenterPoint();
  1576. CExtToolControlBar::g_bMenuTracking = bPrevTBMT;
  1578. GetBar()->_SwitchMenuTrackingIndex(
  1579. GetBar()->_GetIndexOf( this )
  1580. );
  1582. if( bForceNoAnimation )
  1583. nTrackFlags |= TPMX_FORCE_NO_ANIMATION;
  1585. g_pTrackingMenuTBB = this;
  1586. pBar->m_bSysMenuTracking =
  1587. pBar->
  1588. _TrackFrameSystemMenu(
  1589. pWnd,
  1590. &point, // NULL,
  1591. TRUE,
  1592. &rcBtn,
  1593. nTrackFlags,
  1594. m_bHandleDblClickAsCloseCmd ? FALSE : TRUE
  1595. ) ? true : false;
  1597. CExtToolControlBar::g_bMenuTracking = true;
  1599. return UINT(-1L);
  1600. }
  1602. /////////////////////////////////////////////////////////////////////////////
  1603. // CExtBarMdiRightButton
  1605. IMPLEMENT_DYNCREATE(CExtBarMdiRightButton,CExtBarMdiDocButton)
  1607. CExtBarMdiRightButton::CExtBarMdiRightButton(
  1608. CExtToolControlBar * pBar, // = NULL
  1609. UINT nCmdID, // = ID_SEPARATOR
  1610. UINT nStyle // = 0
  1611. ) :
  1612. CExtBarMdiDocButton(
  1613. pBar,
  1614. nCmdID,
  1615. nStyle
  1616. )
  1617. {
  1618. }
  1620. CExtBarMdiRightButton::~CExtBarMdiRightButton()
  1621. {
  1622. }
  1624. BOOL CExtBarMdiRightButton::PutToPopupMenu(
  1625. CExtPopupMenuWnd * pPopup
  1626. )
  1627. {
  1628. ASSERT( pPopup != NULL );
  1629. ASSERT( pPopup->GetSafeHwnd() == NULL );
  1631. ASSERT_VALID( GetBar() );
  1632. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  1633. ASSERT( CtrlGet() == NULL );
  1634. ASSERT( ! IsSeparator() );
  1636. CExtMenuControlBar * pBar =
  1637. DYNAMIC_DOWNCAST(
  1638. CExtMenuControlBar,
  1639. GetBar()
  1640. );
  1641. ASSERT_VALID( pBar );
  1642. BOOL bHorz = !pBar->IsDockedVertically();
  1643. MdiMenuBarRightButtonsInfo_t _info;
  1644. pBar->_GetMdiMenuBarRightButtonsInfo( _info, this, bHorz );
  1645. if( !_info.m_bInitialized )
  1646. return FALSE;
  1648. HWND hWndActiveChild = _ActiveMdiChildWndGet();
  1649. ASSERT( ::IsWindow( hWndActiveChild ) );
  1651. int nCount = pPopup->ItemGetCount();
  1652. if( nCount > 0 )
  1653. {
  1654. if( pPopup->ItemGetCmdID(nCount-1) !=
  1655. CExtPopupMenuWnd::TYPE_SEPARATOR
  1656. )
  1657. {
  1658. VERIFY(
  1659. pPopup->ItemInsert(
  1660. CExtPopupMenuWnd::TYPE_SEPARATOR,
  1661. -1
  1662. )
  1663. );
  1664. }
  1665. }
  1667. if( _info.m_bBtnHelp )
  1668. {
  1669. VERIFY(
  1670. pPopup->ItemInsert(
  1671. SC_CONTEXTHELP,
  1672. -1,NULL,NULL,hWndActiveChild
  1673. )
  1674. );
  1675. }
  1676. if( _info.m_bBtnMinimize )
  1677. {
  1678. VERIFY(
  1679. pPopup->ItemInsert(
  1680. SC_MINIMIZE,
  1681. -1,NULL,NULL,hWndActiveChild
  1682. )
  1683. );
  1684. VERIFY(
  1685. pPopup->ItemInsert(
  1686. SC_RESTORE,
  1687. -1,NULL,NULL,hWndActiveChild
  1688. )
  1689. );
  1690. }
  1691. // if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize )
  1692. // {
  1693. // VERIFY(
  1694. // pPopup->ItemInsert(
  1695. // SC_MAXIMIZE,
  1696. // -1,NULL,NULL,hWndActiveChild
  1697. // )
  1698. // );
  1699. // }
  1700. if( _info.m_bBtnMaximize )
  1701. {
  1702. VERIFY(
  1703. pPopup->ItemInsert(
  1704. _info.m_bBtnMinimize ? SC_MAXIMIZE : SC_RESTORE,
  1705. -1,NULL,NULL,hWndActiveChild
  1706. )
  1707. );
  1708. }
  1709. if( _info.m_bBtnClose )
  1710. {
  1711. VERIFY(
  1712. pPopup->ItemInsert(
  1713. SC_CLOSE,
  1714. -1,NULL,NULL,hWndActiveChild
  1715. )
  1716. );
  1717. }
  1719. return TRUE;
  1720. }
  1722. CExtCmdIcon * CExtBarMdiRightButton::GetIconPtr()
  1723. {
  1724. return NULL;
  1725. }
  1727. void CExtMenuControlBar::_GetMdiMenuBarRightButtonsInfo(
  1728. CExtBarMdiRightButton::MdiMenuBarRightButtonsInfo_t & _info,
  1729. CExtBarMdiRightButton * pTBB,
  1730. BOOL bHorz
  1731. )
  1732. {
  1733. ASSERT_VALID( this );
  1734. ASSERT_VALID( pTBB );
  1735. _info.m_pWndMdiChildFrame = pTBB->GetCmdTargetWnd();
  1736. if( _info.m_pWndMdiChildFrame == NULL )
  1737. return;
  1738. //ASSERT( _info.m_pWndMdiChildFrame->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) );
  1739. ASSERT_VALID( _info.m_pWndMdiChildFrame );
  1740. _info.m_pBar = this;
  1741. DWORD dwFrameStyle = _info.m_pWndMdiChildFrame->GetStyle();
  1742. _info.m_bBtnClose = false;
  1743. CMenu * pSysMenu = _info.m_pWndMdiChildFrame->GetSystemMenu( FALSE );
  1744. if( pSysMenu != NULL )
  1745. {
  1746. INT nCount = pSysMenu->GetMenuItemCount();
  1747. for( INT nItem = 0; nItem < nCount; nItem++ )
  1748. {
  1749. UINT nID = pSysMenu->GetMenuItemID( nItem );
  1750. if( nID != SC_CLOSE )
  1751. continue;
  1752. MENUITEMINFO mii;
  1753. ::memset(&mii,0,sizeof(MENUITEMINFO));
  1754. mii.cbSize = sizeof(MENUITEMINFO);
  1755. mii.fMask = MIIM_STATE;
  1756. if( !pSysMenu->GetMenuItemInfo(
  1757. nItem,
  1758. &mii,
  1759. TRUE
  1760. )
  1761. )
  1762. break;
  1763. if( ( mii.fState & (MFS_DISABLED|MFS_GRAYED) ) == 0 )
  1764. _info.m_bBtnClose = true;
  1765. break;
  1766. } // for( INT nItem = 0; nItem < nCount; nItem++ )
  1767. } // if( pSysMenu != NULL )
  1768. _info.m_bBtnMaximize =
  1769. (dwFrameStyle & WS_MAXIMIZEBOX) ?
  1770. true : false;
  1771. _info.m_bBtnMinimize =
  1772. (dwFrameStyle & WS_MINIMIZEBOX) ?
  1773. true : false;
  1774. _info.m_bBtnHelp =
  1775. (_info.m_bBtnMaximize && (_info.m_pWndMdiChildFrame->GetExStyle()&WS_EX_CONTEXTHELP)) ?
  1776. true : false;
  1777. if( bHorz )
  1778. {
  1779. _info.m_calcSize.cx = __GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1780. _info.m_calcSize.cy = _info.m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1781. if( _info.m_bBtnMinimize )
  1782. _info.m_calcSize.cx +=
  1783. (_info.m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS)*2;
  1784. if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize )
  1785. _info.m_calcSize.cx +=
  1786. _info.m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1787. if( _info.m_bBtnHelp )
  1788. _info.m_calcSize.cx +=
  1789. _info.m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1790. if( _info.m_bBtnClose )
  1791. _info.m_calcSize.cx +=
  1792. _info.m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1793. } // if( bHorz )
  1794. else
  1795. {
  1796. _info.m_calcSize.cx = _info.m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1797. _info.m_calcSize.cy = __GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1798. if( _info.m_bBtnMinimize )
  1799. _info.m_calcSize.cy +=
  1800. (_info.m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS)*2;
  1801. if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize )
  1802. _info.m_calcSize.cy +=
  1803. _info.m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1804. if( _info.m_bBtnHelp )
  1805. _info.m_calcSize.cy +=
  1806. _info.m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1807. if( _info.m_bBtnClose )
  1808. _info.m_calcSize.cy +=
  1809. _info.m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1810. } // else from if( bHorz )
  1812. _info.m_bInitialized = true;
  1813. }
  1815. CExtBarMdiRightButton::MdiMenuBarRightButtonsInfo_t::
  1816. MdiMenuBarRightButtonsInfo_t()
  1817. {
  1818. m_bInitialized
  1819. = m_bBtnClose
  1820. = m_bBtnMaximize
  1821. = m_bBtnMinimize
  1822. = m_bBtnHelp
  1823. = false;
  1824. m_pBar = NULL;
  1825. m_pWndMdiChildFrame = NULL;
  1826. if( g_PaintManager.m_bIsWinXPorLater )
  1827. {
  1828. CSize _sizeTmp( // (+ v.2.22)
  1829. ::GetSystemMetrics(SM_CXSMSIZE),
  1830. ::GetSystemMetrics(SM_CYSMSIZE)
  1831. );
  1832. int nMetric =
  1833. max( _sizeTmp.cx, _sizeTmp.cy ) + 1;
  1834. m_cxIcon = max( nMetric, 18 ); // 16->18 (+ v.2.23)
  1835. m_cyIcon = max( nMetric, 18 ); // 16->18 (+ v.2.23)
  1836. } // if( g_PaintManager.m_bIsWinXPorLater )
  1837. else
  1838. {
  1839. m_cxIcon = ::GetSystemMetrics(SM_CXSIZE);
  1840. m_cyIcon = ::GetSystemMetrics(SM_CYSIZE);
  1841. } // else from if( g_PaintManager.m_bIsWinXPorLater )
  1842. ASSERT(
  1843. m_cxIcon > __GAP_BETWEEN_WND_RIGHT_BUTTONS
  1844. &&
  1845. m_cyIcon > __GAP_BETWEEN_WND_RIGHT_BUTTONS
  1846. );
  1847. m_cxIcon -= __GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1848. m_cyIcon -= __GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1849. m_calcSize.cx = m_calcSize.cy = 0;
  1850. EmptyLocations();
  1851. }
  1853. void CExtBarMdiRightButton::MdiMenuBarRightButtonsInfo_t::
  1854. EmptyLocations()
  1855. {
  1856. m_rcBtnClose.SetRectEmpty();
  1857. m_rcBtnMaximize.SetRectEmpty();
  1858. m_rcBtnRestore.SetRectEmpty();
  1859. m_rcBtnMinimize.SetRectEmpty();
  1860. m_rcBtnHelp.SetRectEmpty();
  1861. }
  1863. void CExtBarMdiRightButton::MdiMenuBarRightButtonsInfo_t::
  1864. InitLocations(
  1865. const CRect & rcBtn,
  1866. BOOL bHorz
  1867. )
  1868. {
  1869. ASSERT( m_bInitialized );
  1870. EmptyLocations();
  1871. if( rcBtn.IsRectEmpty() )
  1872. return;
  1873. CRect rcStart(0,0,0,0);
  1874. CSize sizeOffset(0,0);
  1875. if( bHorz )
  1876. {
  1877. int nOffset = (rcBtn.Height() - m_cyIcon) / 2;
  1878. rcStart.SetRect(
  1879. rcBtn.left + __GAP_BETWEEN_WND_RIGHT_BUTTONS,
  1880. rcBtn.top + nOffset,
  1881. rcBtn.left + __GAP_BETWEEN_WND_RIGHT_BUTTONS
  1882. + m_cxIcon,
  1883. rcBtn.top + nOffset + m_cyIcon
  1884. );
  1885. sizeOffset.cx = m_cxIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1886. } // if( bHorz )
  1887. else
  1888. {
  1889. int nOffset = (rcBtn.Width() - m_cxIcon) / 2;
  1890. rcStart.SetRect(
  1891. rcBtn.left + nOffset,
  1892. rcBtn.top + __GAP_BETWEEN_WND_RIGHT_BUTTONS,
  1893. rcBtn.left + nOffset + m_cxIcon,
  1894. rcBtn.top + __GAP_BETWEEN_WND_RIGHT_BUTTONS
  1895. + m_cxIcon
  1896. );
  1897. sizeOffset.cy = m_cyIcon+__GAP_BETWEEN_WND_RIGHT_BUTTONS;
  1898. } // else from if( bHorz )
  1899. if( m_bBtnHelp )
  1900. {
  1901. m_rcBtnHelp = rcStart;
  1902. rcStart.OffsetRect(sizeOffset);
  1903. }
  1904. if( m_bBtnMinimize )
  1905. {
  1906. m_rcBtnMinimize = rcStart;
  1907. rcStart.OffsetRect(sizeOffset);
  1908. m_rcBtnRestore = rcStart;
  1909. rcStart.OffsetRect(sizeOffset);
  1910. }
  1911. if( m_bBtnMaximize && (! m_bBtnMinimize ) )
  1912. {
  1913. m_rcBtnMaximize = rcStart;
  1914. rcStart.OffsetRect(sizeOffset);
  1915. }
  1916. if( m_bBtnClose )
  1917. m_rcBtnClose = rcStart;
  1918. }
  1920. CSize CExtBarMdiRightButton::CalculateLayout(
  1921. CDC & dc,
  1922. CSize sizePreCalc,
  1923. BOOL bHorz
  1924. )
  1925. {
  1926. ASSERT_VALID( this );
  1927. dc;
  1928. ASSERT_VALID( GetBar() );
  1929. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  1930. ASSERT_VALID( (&dc) );
  1931. ASSERT( CtrlGet() == NULL );
  1932. // ASSERT( ! IsSeparator() );
  1934. if( ( ! IsVisible() )
  1935. || ( GetStyle() & TBBS_HIDDEN ) != 0
  1936. )
  1937. {
  1938. m_ActiveSize.cx = m_ActiveSize.cy = 0;
  1939. return m_ActiveSize;
  1940. }
  1942. CExtMenuControlBar * pBar =
  1943. STATIC_DOWNCAST(
  1944. CExtMenuControlBar,
  1945. GetBar()
  1946. );
  1947. ASSERT_VALID( pBar );
  1948. MdiMenuBarRightButtonsInfo_t _info;
  1949. pBar->_GetMdiMenuBarRightButtonsInfo( _info, this, bHorz );
  1951. //ASSERT( _info.m_bInitialized );
  1952. if( !_info.m_bInitialized )
  1953. return CSize( 1, 1 );
  1955. CSize _size( _info.m_calcSize );
  1956. if( bHorz )
  1957. {
  1958. if( _size.cy < sizePreCalc.cy )
  1959. _size.cy = sizePreCalc.cy;
  1960. }
  1961. else
  1962. {
  1963. if( _size.cx < sizePreCalc.cx )
  1964. _size.cx = sizePreCalc.cx;
  1965. }
  1967. m_ActiveSize = _size;
  1969. return _size;
  1970. }
  1972. void CExtBarMdiRightButton::PaintCompound(
  1973. CDC & dc,
  1974. bool bPaintParentChain,
  1975. bool bPaintChildren,
  1976. bool bPaintOneNearestChildrenLevelOnly
  1977. )
  1978. {
  1979. ASSERT_VALID( GetBar() );
  1980. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  1981. ASSERT_VALID( (&dc) );
  1982. ASSERT( CtrlGet() == NULL );
  1983. // ASSERT( ! IsSeparator() );
  1985. if( ! IsPaintAble( dc ) )
  1986. return;
  1987. if( AnimationClient_StatePaint( dc ) )
  1988. return;
  1989. if( bPaintParentChain )
  1990. PaintParentChain( dc );
  1992. CExtMenuControlBar * pBar =
  1993. DYNAMIC_DOWNCAST(
  1994. CExtMenuControlBar,
  1995. GetBar()
  1996. );
  1997. ASSERT_VALID( pBar );
  1998. MdiMenuBarRightButtonsInfo_t _info;
  1999. bool bHorz = IsHorzBarOrientation();
  2000. pBar->_GetMdiMenuBarRightButtonsInfo( _info, this, bHorz );
  2001. if( ! _info.m_bInitialized )
  2002. return;
  2003. CRect rcTBB = Rect();
  2004. _info.InitLocations( rcTBB, bHorz );
  2006. CPoint ptCursor( 0, 0 );
  2007. ::GetCursorPos(&ptCursor);
  2008. pBar->ScreenToClient( &ptCursor );
  2009. bool bFlat = true;
  2010. bool bDrawBorder = true;
  2011. int eAlign =
  2012. CExtPaintManager::__ALIGN_HORIZ_CENTER
  2013. | CExtPaintManager::__ALIGN_VERT_CENTER;
  2014. bool bEnabled = IsEnabled() ? true : false;
  2015. bool bChecked =
  2016. ( (GetStyle()&TBBS_CHECKED) != 0 ) 
  2017. ? true 
  2018. : false;
  2019. if( _info.m_bBtnHelp )
  2020. {
  2021. bool bHover =
  2022. (IsHover() && _info.m_rcBtnHelp.PtInRect(ptCursor))
  2023. ? true : false;
  2024. bool bPushed =
  2025. (IsPressed() && _info.m_rcBtnHelp.PtInRect(ptCursor))
  2026. ? true : false;
  2027. CExtPaintManager::PAINTPUSHBUTTONDATA _ppbdCtxHelp(
  2028. this,
  2029. bHorz ? true : false,
  2030. _info.m_rcBtnHelp,_T(""),NULL,bFlat,
  2031. bHover, bPushed, false, bEnabled,
  2032. bDrawBorder,false,false,eAlign,
  2033. NULL, false, SC_CONTEXTHELP,
  2034. (!bEnabled) || ( bEnabled && (!bHover) && (!bPushed) )
  2035. );
  2036. _ppbdCtxHelp.m_bChecked = bChecked;
  2037. _ppbdCtxHelp.m_nIconAlignment = CExtPaintManager::__ALIGN_HORIZ_CENTER | CExtPaintManager::__ALIGN_VERT_CENTER;
  2038. pBar->PmBridge_GetPM()->PaintPushButtonMdiRight( dc, _ppbdCtxHelp );
  2039. }
  2040. if( _info.m_bBtnMinimize )
  2041. {
  2042. bool bHover =
  2043. (IsHover() && _info.m_rcBtnRestore.PtInRect(ptCursor))
  2044. ? true : false;
  2045. bool bPushed =
  2046. (IsPressed() && _info.m_rcBtnRestore.PtInRect(ptCursor))
  2047. ? true : false;
  2048. CExtPaintManager::PAINTPUSHBUTTONDATA _ppbdRestore(
  2049. this,
  2050. bHorz ? true : false,
  2051. _info.m_rcBtnRestore,_T(""),NULL,bFlat,
  2052. bHover, bPushed, false, bEnabled,
  2053. bDrawBorder,false,false,eAlign,
  2054. NULL, false, SC_RESTORE,
  2055. (!bEnabled) || ( bEnabled && (!bHover) && (!bPushed) )
  2056. );
  2057. _ppbdRestore.m_bChecked = bChecked;
  2058. pBar->PmBridge_GetPM()->PaintPushButtonMdiRight( dc, _ppbdRestore );
  2059. bHover =
  2060. (IsHover() && _info.m_rcBtnMinimize.PtInRect(ptCursor))
  2061. ? true : false;
  2062. bPushed =
  2063. (IsPressed() && _info.m_rcBtnMinimize.PtInRect(ptCursor))
  2064. ? true : false;
  2065. CExtPaintManager::PAINTPUSHBUTTONDATA _ppbdMinimize(
  2066. this,
  2067. bHorz ? true : false,
  2068. _info.m_rcBtnMinimize,_T(""),NULL,bFlat,
  2069. bHover, bPushed, false, bEnabled,
  2070. bDrawBorder,false,false,eAlign,
  2071. NULL, false, SC_MINIMIZE,
  2072. (!bEnabled) || ( bEnabled && (!bHover) && (!bPushed) )
  2073. );
  2074. _ppbdMinimize.m_bChecked = bChecked;
  2075. pBar->PmBridge_GetPM()->PaintPushButtonMdiRight( dc, _ppbdMinimize );
  2076. }
  2077. if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize )
  2078. {
  2079. bool bHover =
  2080. (IsHover() && _info.m_rcBtnMaximize.PtInRect(ptCursor))
  2081. ? true : false;
  2082. bool bPushed =
  2083. (IsPressed() && _info.m_rcBtnMaximize.PtInRect(ptCursor))
  2084. ? true : false;
  2085. CExtPaintManager::PAINTPUSHBUTTONDATA _ppbdMaximize(
  2086. this,
  2087. bHorz ? true : false,
  2088. _info.m_rcBtnMaximize,_T(""),NULL,bFlat,
  2089. bHover, bPushed, false, bEnabled,
  2090. bDrawBorder,false,false,eAlign,
  2091. NULL, false, SC_MAXIMIZE,
  2092. (!bEnabled) || ( bEnabled && (!bHover) && (!bPushed) )
  2093. );
  2094. _ppbdMaximize.m_bChecked = bChecked;
  2095. pBar->PmBridge_GetPM()->PaintPushButtonMdiRight( dc, _ppbdMaximize );
  2096. }
  2097. if( _info.m_bBtnClose )
  2098. {
  2099. bool bHover =
  2100. (IsHover() && _info.m_rcBtnClose.PtInRect(ptCursor))
  2101. ? true : false;
  2102. bool bPushed =
  2103. (IsPressed() && _info.m_rcBtnClose.PtInRect(ptCursor))
  2104. ? true : false;
  2105. CExtPaintManager::PAINTPUSHBUTTONDATA _ppbdClose(
  2106. this,
  2107. bHorz ? true : false,
  2108. _info.m_rcBtnClose,_T(""),NULL,bFlat,
  2109. bHover, bPushed, false, bEnabled,
  2110. bDrawBorder,false,false,eAlign,
  2111. NULL, false, SC_CLOSE,
  2112. (!bEnabled) || ( bEnabled && (!bHover) && (!bPushed) )
  2113. );
  2114. _ppbdClose.m_bChecked = bChecked;
  2115. pBar->PmBridge_GetPM()->PaintPushButtonMdiRight( dc, _ppbdClose );
  2116. }
  2118. if( bPaintChildren )
  2119. PaintChildren( dc, bPaintOneNearestChildrenLevelOnly );
  2120. }
  2122. UINT CExtBarMdiRightButton::OnTrackPopup(
  2123. CPoint point,
  2124. bool bSelectAny,
  2125. bool bForceNoAnimation
  2126. )
  2127. {
  2128. point;
  2129. bSelectAny;
  2130. bForceNoAnimation;
  2131. return UINT( -1L );
  2132. }
  2134. void CExtBarMdiRightButton::OnClick(
  2135. CPoint point,
  2136. bool bDown
  2137. )
  2138. {
  2139. bool bDockSiteCustomizeMode =
  2140. GetBar()->_IsDockSiteCustomizeMode();
  2141. if( bDockSiteCustomizeMode )
  2142. return;
  2144. if( bDown )
  2145. return;
  2147. // CExtMouseCaptureSink::ReleaseCapture();
  2149. ASSERT_VALID( GetBar() );
  2150. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  2151. ASSERT( CtrlGet() == NULL );
  2152. ASSERT( ! IsSeparator() );
  2154. CExtMenuControlBar * pBar =
  2155. DYNAMIC_DOWNCAST(
  2156. CExtMenuControlBar,
  2157. GetBar()
  2158. );
  2159. ASSERT_VALID( pBar );
  2160. BOOL bHorz = !pBar->IsDockedVertically();
  2161. MdiMenuBarRightButtonsInfo_t _info;
  2162. pBar->_GetMdiMenuBarRightButtonsInfo( _info, this, bHorz );
  2163. if( !_info.m_bInitialized )
  2164. return;
  2165. _info.InitLocations( Rect(), bHorz );
  2167. bool bInstallHideFlag = false;
  2168. UINT nHelperSysCmdID = 0;
  2169. if( _info.m_bBtnHelp
  2170. && _info.m_rcBtnHelp.PtInRect(point)
  2171. )
  2172. nHelperSysCmdID = SC_CONTEXTHELP;
  2173. else if( _info.m_bBtnMinimize
  2174. && _info.m_rcBtnRestore.PtInRect(point)
  2175. )
  2176. {
  2177. nHelperSysCmdID = SC_RESTORE;
  2178. bInstallHideFlag = true;
  2179. }
  2180. else if( _info.m_bBtnMinimize
  2181. && _info.m_rcBtnMinimize.PtInRect(point)
  2182. )
  2183. {
  2184. nHelperSysCmdID = SC_MINIMIZE;
  2185. bInstallHideFlag = true;
  2186. }
  2187. else if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize
  2188. && _info.m_rcBtnMaximize.PtInRect(point)
  2189. )
  2190. nHelperSysCmdID = SC_MAXIMIZE;
  2191. else if( _info.m_bBtnClose
  2192. && _info.m_rcBtnClose.PtInRect(point)
  2193. )
  2194. nHelperSysCmdID = SC_CLOSE;
  2196. if( nHelperSysCmdID == 0 )
  2197. return;
  2199. HWND hWndActiveChild = _ActiveMdiChildWndGet();
  2200. if( hWndActiveChild == NULL )
  2201. return;
  2202. ASSERT( ::IsWindow( hWndActiveChild ) );
  2204. if( bInstallHideFlag )
  2205. {
  2206. Show( FALSE );
  2207. ASSERT( GetBar()->GetButtonsCount() > 0 );
  2208. CExtBarButton * pTBB = GetBar()->GetButton( 0 );
  2209. ASSERT_VALID( pTBB );
  2210. if( pTBB->IsVisible()
  2211. && pTBB->IsKindOf( RUNTIME_CLASS(CExtBarMdiDocButton) )
  2212. )
  2213. {
  2214. pTBB->Show( FALSE );
  2215. }
  2216. // GetBar()->Invalidate();
  2217. // GetBar()->UpdateWindow();
  2218. // GetBar()->GetParentFrame()->DelayRecalcLayout();
  2219. }
  2221. if( nHelperSysCmdID == SC_MAXIMIZE )
  2222. {
  2223. HWND hWndMdiClientArea =
  2224. ::GetParent( hWndActiveChild );
  2225. ASSERT( hWndMdiClientArea != NULL );
  2226. ASSERT( ::IsWindow( hWndMdiClientArea ) );
  2227. ::PostMessage(
  2228. hWndMdiClientArea,
  2229. WM_MDIRESTORE,
  2230. (WPARAM)hWndActiveChild,
  2231. 0
  2232. );
  2233. } // if( nHelperSysCmdID == SC_MAXIMIZE )
  2234. else
  2235. {
  2236. pBar->ClientToScreen( &point );
  2237. pBar->_DelayUpdateMenuBar();
  2238. ::SendMessage(
  2239. hWndActiveChild,
  2240. WM_SYSCOMMAND,
  2241. nHelperSysCmdID,
  2242. MAKELONG( point.x, point.y )
  2243. );
  2244. } // else
  2245. }
  2247. bool CExtBarMdiRightButton::OnDblClick(
  2248. CPoint point
  2249. )
  2250. {
  2251. ASSERT_VALID( this );
  2252. ASSERT_VALID( GetBar() );
  2253. point;
  2254. return false;
  2255. }
  2257. __EXT_MFC_INT_PTR CExtBarMdiRightButton::OnToolHitTest(
  2258. CPoint point,
  2259. TOOLINFO * pTI
  2260. )
  2261. {
  2262. ASSERT_VALID( this );
  2263. ASSERT_VALID( GetBar() );
  2264. ASSERT( GetBar()->IsKindOf(RUNTIME_CLASS(CExtMenuControlBar)) );
  2265. ASSERT( CtrlGet() == NULL );
  2266. ASSERT( ! IsSeparator() );
  2268. CExtMenuControlBar * pBar =
  2269. DYNAMIC_DOWNCAST(
  2270. CExtMenuControlBar,
  2271. GetBar()
  2272. );
  2273. ASSERT_VALID( pBar );
  2274. BOOL bHorz = !pBar->IsDockedVertically();
  2275. MdiMenuBarRightButtonsInfo_t _info;
  2276. pBar->_GetMdiMenuBarRightButtonsInfo( _info, this, bHorz );
  2277. if( !_info.m_bInitialized )
  2278. return -1;
  2279. _info.InitLocations( Rect(), bHorz );
  2281. if( _info.m_bBtnHelp
  2282. && _info.m_rcBtnHelp.PtInRect(point)
  2283. )
  2284. {
  2285. if( pTI != NULL )
  2286. {
  2287. ::CopyRect(
  2288. &(pTI->rect),
  2289. &_info.m_rcBtnHelp
  2290. );
  2291. CExtSafeString str;
  2292. if( g_ResourceManager->LoadString( str, ID_CONTEXT_HELP ) )
  2293. pTI->lpszText = (LPTSTR)
  2294. ::calloc( (str.GetLength() + 1), sizeof(TCHAR) );
  2295. if( pTI->lpszText != NULL )
  2296. __EXT_MFC_STRCPY( pTI->lpszText, str.GetLength() + 1, str );
  2297. else
  2298. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2299. }
  2300. return ((__EXT_MFC_INT_PTR)ID_CONTEXT_HELP);
  2301. }
  2302. if( _info.m_bBtnMinimize
  2303. && _info.m_rcBtnRestore.PtInRect(point)
  2304. )
  2305. {
  2306. if( pTI != NULL )
  2307. {
  2308. ::CopyRect(
  2309. &(pTI->rect),
  2310. &_info.m_rcBtnRestore
  2311. );
  2312. CExtSafeString str;
  2313. if( g_ResourceManager->LoadString( str, AFX_IDS_SCRESTORE ) )
  2314. pTI->lpszText = (LPTSTR)
  2315. ::calloc( (str.GetLength() + 1), sizeof(TCHAR) );
  2316. if( pTI->lpszText != NULL )
  2317. __EXT_MFC_STRCPY( pTI->lpszText, str.GetLength() + 1, str );
  2318. else
  2319. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2320. }
  2321. return ((int)AFX_IDS_SCRESTORE);
  2322. }
  2323. if( _info.m_bBtnMinimize
  2324. && _info.m_rcBtnMinimize.PtInRect(point)
  2325. )
  2326. {
  2327. if( pTI != NULL )
  2328. {
  2329. ::CopyRect(
  2330. &(pTI->rect),
  2331. &_info.m_rcBtnMinimize
  2332. );
  2333. CExtSafeString str;
  2334. if( g_ResourceManager->LoadString( str, AFX_IDS_SCMINIMIZE ) )
  2335. pTI->lpszText = (LPTSTR)
  2336. ::calloc( (str.GetLength() + 1), sizeof(TCHAR) );
  2337. if( pTI->lpszText != NULL )
  2338. __EXT_MFC_STRCPY( pTI->lpszText, str.GetLength() + 1, str );
  2339. else
  2340. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2341. }
  2342. return ((__EXT_MFC_INT_PTR)AFX_IDS_SCMINIMIZE);
  2343. }
  2344. if( _info.m_bBtnMaximize && !_info.m_bBtnMinimize
  2345. && _info.m_rcBtnMaximize.PtInRect(point)
  2346. )
  2347. {
  2348. if( pTI != NULL )
  2349. {
  2350. ::CopyRect(
  2351. &(pTI->rect),
  2352. &_info.m_rcBtnMaximize
  2353. );
  2354. CExtSafeString str;
  2355. if( g_ResourceManager->LoadString( str, AFX_IDS_SCMAXIMIZE ) )
  2356. pTI->lpszText = (LPTSTR)
  2357. ::calloc( (str.GetLength() + 1), sizeof(TCHAR) );
  2358. if( pTI->lpszText != NULL )
  2359. __EXT_MFC_STRCPY( pTI->lpszText, str.GetLength() + 1, str );
  2360. else
  2361. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2362. }
  2363. return ((__EXT_MFC_INT_PTR)AFX_IDS_SCMAXIMIZE);
  2364. }
  2365. if( _info.m_bBtnClose
  2366. && _info.m_rcBtnClose.PtInRect(point)
  2367. )
  2368. {
  2369. if( pTI != NULL )
  2370. {
  2371. ::CopyRect(
  2372. &(pTI->rect),
  2373. &_info.m_rcBtnClose
  2374. );
  2375. CExtSafeString str;
  2376. if( g_ResourceManager->LoadString( str, AFX_IDS_SCCLOSE ) )
  2377. pTI->lpszText = (LPTSTR)
  2378. ::calloc( (str.GetLength() + 1), sizeof(TCHAR) );
  2379. if( pTI->lpszText != NULL )
  2380. __EXT_MFC_STRCPY( pTI->lpszText, str.GetLength() + 1, str );
  2381. else
  2382. pTI->lpszText = LPSTR_TEXTCALLBACK;
  2383. }
  2384. return ((__EXT_MFC_INT_PTR)AFX_IDS_SCCLOSE);
  2385. }
  2386. return -1;
  2387. }
  2389. bool CExtBarMdiRightButton::CanStartCommandDrag()
  2390. {
  2391. ASSERT_VALID( this );
  2392. return false;
  2393. }
  2395. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  2396. CExtCustomizeCmdTreeNode * CExtBarMdiRightButton::GetCmdNode(
  2397. bool bInitial // = false
  2398. )
  2399. {
  2400. ASSERT_VALID( this );
  2401. // ASSERT_VALID( GetBar() );
  2402. // bInitial;
  2403. // ASSERT( m_pCmdNodeI == NULL );
  2404. // ASSERT( m_pCmdNodeC == NULL );
  2405. // return NULL;
  2406. return CExtBarMdiDocButton::GetCmdNode( bInitial );
  2407. }
  2408. void CExtBarMdiRightButton::SetBasicCmdNode(
  2409. CExtCustomizeCmdTreeNode * pNode
  2410. )
  2411. {
  2412. ASSERT_VALID( this );
  2413. // ASSERT_VALID( GetBar() );
  2414. // ASSERT( m_pCmdNodeI == NULL );
  2415. // ASSERT( m_pCmdNodeC == NULL );
  2416. // ASSERT( FALSE ); // should be never called
  2417. // pNode;
  2418. CExtBarMdiDocButton::SetBasicCmdNode( pNode );
  2419. }
  2420. void CExtBarMdiRightButton::SetCustomizedCmdNode(
  2421. CExtCustomizeCmdTreeNode * pNode
  2422. )
  2423. {
  2424. ASSERT_VALID( this );
  2425. // ASSERT_VALID( GetBar() );
  2426. // ASSERT( m_pCmdNodeI == NULL );
  2427. // ASSERT( m_pCmdNodeC == NULL );
  2428. // ASSERT( FALSE ); // should be never called
  2429. // pNode;
  2430. CExtBarMdiDocButton::SetCustomizedCmdNode( pNode );
  2431. }
  2433. CExtCustomizeCmdTreeNode * CExtBarMdiRightButton::OnCustomizeNodeInit(
  2434. CExtCustomizeSite * pSite,
  2435. CExtCustomizeCmdTreeNode * pParentNode // toolbar node
  2436. )
  2437. {
  2438. ASSERT_VALID( this );
  2439. // ASSERT_VALID( GetBar() );
  2440. // ASSERT( pSite != NULL );
  2441. // ASSERT_VALID( pParentNode );
  2442. // pSite;
  2443. // pParentNode;
  2444. // return NULL; // no customization support
  2445. return CExtBarMdiDocButton::OnCustomizeNodeInit( pSite, pParentNode );
  2446. }
  2447. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  2449. bool CExtBarMdiRightButton::OnQueryFlatTrackingEnabled() const
  2450. {
  2451. ASSERT_VALID( this );
  2452. return false;
  2453. }
  2455. LRESULT CExtBarMdiRightButton::OnHelpHitTest(
  2456. CPoint point
  2457. )
  2458. {
  2459. ASSERT_VALID( this );
  2460. return (LRESULT)OnToolHitTest(point,NULL);
  2461. }
  2463. void CExtMenuControlBar::_KillFrameMenu()
  2464. {
  2465. if( m_bPresubclassDialogMode )
  2466. return;
  2467. if( IsOleIpObjActive() )
  2468. return;
  2469. CFrameWnd * pFrame = _GetDockingFrameImpl();
  2470. ASSERT_VALID( pFrame );
  2471. HWND hWndFrame = pFrame->GetSafeHwnd();
  2472. ASSERT( hWndFrame != NULL );
  2473. ASSERT( ::IsWindow(hWndFrame) );
  2474. HMENU hFrameRealMenu = ::GetMenu( hWndFrame );
  2475. if( hFrameRealMenu == NULL )
  2476. return;
  2477. ::SetMenu( hWndFrame, NULL );
  2478. _DelayUpdateMenuBar();
  2479. }
  2481. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  2482. void CExtMenuControlBar::OnCustomizeModeEnter()
  2483. {
  2484. ASSERT_VALID( this );
  2485. CExtToolControlBar::OnCustomizeModeEnter();
  2486. }
  2487. void CExtMenuControlBar::OnCustomizeModeLeave()
  2488. {
  2489. ASSERT_VALID( this );
  2490. CExtToolControlBar::OnCustomizeModeLeave();
  2491. }
  2492. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  2494. void CExtMenuControlBar::PreSubclassWindow() 
  2495. {
  2496. CExtToolControlBar::PreSubclassWindow();
  2497. m_bHelperTrackingCharCode = false;
  2498. if( m_bPresubclassDialogMode && m_hWndHelper == NULL )
  2499. {
  2500. m_hWndHelper = ::GetParent( m_hWnd );
  2501. if( m_hWndHelper != NULL )
  2502. {
  2503. ASSERT( ::IsWindow( m_hWndHelper ) );
  2504. if( !IsHookedWindow( m_hWndHelper ) )
  2505. SetupHookWndSink( m_hWndHelper );
  2506. }
  2507. } // if( m_bPresubclassDialogMode && m_hWndHelper == NULL )
  2508. }
  2510. BOOL CExtMenuControlBar::PreTranslateMessage(MSG* pMsg) 
  2511. {
  2512. if( m_bPresubclassDialogMode )
  2513. {
  2514. if( TranslateMainFrameMessage(pMsg) )
  2515. return TRUE;
  2516. }
  2518. return CExtToolControlBar::PreTranslateMessage(pMsg);
  2519. }
  2521. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  2523. CExtCustomizeSite::CCmdMenuInfo * CExtMenuControlBar::MenuInfoGet()
  2524. {
  2525. ASSERT_VALID( this );
  2526. return m_pMenuInfo;
  2527. }
  2529. CExtCustomizeSite::CCmdMenuInfo * CExtMenuControlBar::MenuInfoDetach()
  2530. {
  2531. ASSERT_VALID( this );
  2532. CExtCustomizeSite::CCmdMenuInfo * pMenuInfo = m_pMenuInfo;
  2533. m_pMenuInfo = NULL;
  2534. return pMenuInfo;
  2535. }
  2537. CExtCustomizeSite::CCmdMenuInfo * CExtMenuControlBar::MenuInfoAttach(
  2538. CExtCustomizeSite::CCmdMenuInfo * pMenuInfo
  2539. )
  2540. {
  2541. ASSERT_VALID( this );
  2542. CExtCustomizeSite::CCmdMenuInfo * pMenuInfoOld = m_pMenuInfo;
  2543. m_pMenuInfo = pMenuInfo;
  2544. return pMenuInfoOld;
  2545. }
  2547. void CExtMenuControlBar::MenuInfoUpdate()
  2548. {
  2549. ASSERT_VALID( this );
  2550. CExtCustomizeSite * pSite =
  2551. GetCustomizeSite();
  2552. if( pSite == NULL )
  2553. return;
  2554. CExtCustomizeSite::CCmdMenuInfo * pMenuInfo =
  2555. pSite->MenuInfoFindForMenuBar();
  2556. if( ((LPVOID)pMenuInfo) != ((LPVOID)MenuInfoGet()) )
  2557. MenuInfoAttach( pMenuInfo );
  2558. }
  2560. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  2562. void CExtMenuControlBar::SetMdiWindowPopupName(
  2563. __EXT_MFC_SAFE_LPCTSTR sMdiWindowPopupName // = NULL
  2564. )
  2565. {
  2566. ASSERT_VALID( this );
  2568. m_sMdiWindowPopupName =
  2569. ( sMdiWindowPopupName != NULL )
  2570. ? sMdiWindowPopupName
  2571. : _T("")
  2572. ;
  2573. m_sMdiWindowPopupName.TrimLeft();
  2574. m_sMdiWindowPopupName.TrimRight();
  2575. while( m_sMdiWindowPopupName.Replace( _T("&"), _T("") ) > 0 )
  2576. {
  2577. m_sMdiWindowPopupName.TrimLeft();
  2578. m_sMdiWindowPopupName.TrimRight();
  2579. }
  2580. }