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

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

界面编程

开发平台：

Visual C++

ExtMenuControlBar.cpp：源码内容
  1. // This is part of the Professional User Interface Suite library.
  2. // Copyright (C) 2001-2009 FOSS Software, Inc.
  3. // All rights reserved.
  4. //
  5. // http://www.prof-uis.com
  6. // mailto:support@prof-uis.com
  7. //
  8. // This source code can be used, modified and redistributed
  9. // under the terms of the license agreement that is included
  10. // in the Professional User Interface Suite package.
  11. //
  12. // Warranties and Disclaimers:
  13. // THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND
  14. // INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY,
  15. // FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  16. // IN NO EVENT WILL FOSS SOFTWARE INC. BE LIABLE FOR ANY DIRECT,
  17. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES,
  18. // INCLUDING DAMAGES FOR LOSS OF PROFITS, LOSS OR INACCURACY OF DATA,
  19. // INCURRED BY ANY PERSON FROM SUCH PERSON'S USAGE OF THIS SOFTWARE
  20. // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  22. #include "stdafx.h"
  24. #if _MFC_VER < 0x700
  25. #include <../src/AfxImpl.h>
  26. #else
  27. #include <../src/mfc/AfxImpl.h>
  28. #endif
  30. #if (!defined __EXT_MENUCONTROLBAR_H)
  31. #include <ExtMenuControlBar.h>
  32. #endif
  34. #if (!defined __EXT_POPUP_MENU_WND_H)
  35. #include <ExtPopupMenuWnd.h>
  36. #endif
  38. #if (!defined __EXT_PAINT_MANAGER_H)
  39. #include <ExtPaintManager.h>
  40. #endif
  42. #if (!defined __EXTDOCKBAR_H)
  43. #include "ExtDockBar.h"
  44. #endif
  46. #if( !defined __EXTMINIDOCKFRAMEWND_H)
  47. #include "ExtMiniDockFrameWnd.h"
  48. #endif
  50. #if (!defined __ExtCmdManager_H)
  51. #include <ExtCmdManager.h>
  52. #endif
  54. #if (!defined __EXT_MEMORY_DC_H)
  55. #include <../Src/ExtMemoryDC.h>
  56. #endif
  58. #if (!defined __EXT_LOCALIZATION_H)
  59. #include <../Src/ExtLocalization.h>
  60. #endif
  62. //#if (!defined __EXT_MFC_NO_RIBBON_BAR)
  63. // #if (!defined __EXT_RIBBON_BAR_H)
  64. // #include <ExtRibbonBar.h>
  65. // #endif // (!defined __EXT_RIBBON_BAR_H)
  66. //#endif
  68. #include <Resources/Resource.h>
  70. #ifdef _DEBUG
  71. #define new DEBUG_NEW
  72. #undef THIS_FILE
  73. static char THIS_FILE[] = __FILE__;
  74. #endif
  76. #define __MENUBAR_RIGHT_ADJUST_GAP 1
  78. bool CExtMenuControlBar::g_bHideMenuBarExpandContentButton = false;
  79. bool CExtMenuControlBar::g_bCancelNearestAltUp = false;
  80. bool CExtMenuControlBar::g_bKeyCodeTracking = false;
  81. const UINT CExtMenuControlBar::g_nMsgPrepareSystemMenu =
  82. ::RegisterWindowMessage(
  83. _T("CExtMenuControlBar::g_nMsgPrepareSystemMenu")
  84. );
  85. bool CExtMenuControlBar::g_bTranslateContextHelpCmd = false;
  86. ACCEL CExtMenuControlBar::g_accelContextHelp = { FVIRTKEY, VK_F1, ID_HELP };
  88. /////////////////////////////////////////////////////////////////////////////
  89. // CExtMenuControlBar hook sink
  91. bool CExtMenuControlBar::OnHookWndMsg(
  92. LRESULT & lResult,
  93. HWND hWndHooked,
  94. UINT nMessage,
  95. WPARAM & wParam,
  96. LPARAM & lParam
  97. )
  98. {
  99. __PROF_UIS_MANAGE_STATE;
  100. if( GetSafeHwnd() == NULL
  101. || CWnd::FromHandlePermanent(GetSafeHwnd()) == NULL
  102. || _DraggingGetBar() != NULL
  103. )
  104. return 
  105. CExtHookSink::OnHookWndMsg(
  106. lResult,
  107. hWndHooked,
  108. nMessage,
  109. wParam,
  110. lParam
  111. );
  112. HWND hWndMainFrame = NULL;
  113. CWnd * pWndForPlacement = NULL;
  114. if( ! m_bPresubclassDialogMode )
  115. {
  116. hWndMainFrame = _GetHwndMainFrame();
  117. if( hWndMainFrame != NULL )
  118. pWndForPlacement = stat_GetWndForPlacement( CWnd::FromHandle(hWndMainFrame) );
  119. } // if( ! m_bPresubclassDialogMode )
  120. if( ( (!m_bPresubclassDialogMode)
  121. && ( ( hWndMainFrame != NULL
  122. && hWndHooked == hWndMainFrame
  123. )
  124. || ( pWndForPlacement != NULL
  125. && hWndHooked == pWndForPlacement->m_hWnd
  126. )
  127. )
  128. )
  129. || ( m_bPresubclassDialogMode
  130. && hWndHooked == _GetHwndPlacement()
  131. )
  132. )
  133. { // if window is a main frame or parent dialog-like
  134. if( nMessage == WM_PARENTNOTIFY
  135. &&
  136. CExtPopupMenuWnd::IsMenuTracking()
  137. )
  138. {
  139. lResult = 0;
  140. return true;
  141. }
  143. // if( nMessage == WM_INITMENU )
  144. // {
  145. // CFrameWnd * pFrame = _GetDockingFrameImpl();
  146. // if( pFrame != NULL )
  147. // {
  148. // HMENU hSysMenu = ::GetSystemMenu( hWndHooked, FALSE );
  149. // HMENU hCurMenu = GetSubMenu( (HMENU)wParam, 0 );
  150. // CPoint ptCursor;
  151. // if( hCurMenu == hSysMenu
  152. // && hCurMenu != NULL
  153. // && ::GetCursorPos(&ptCursor)
  154. // )
  155. // {
  156. // ::SetForegroundWindow( hWndHooked ); 
  157. // if( TrackMainFrameSystemMenu( &ptCursor, FALSE ) )
  158. // return true;
  159. // }
  160. // } // if( pFrame != NULL )
  161. // } // if( nMessage == WM_INITMENU )
  163. // if( nMessage == WM_INITMENU )
  164. // {
  165. // CFrameWnd * pFrame = _GetDockingFrameImpl();
  166. // if( pFrame != NULL )
  167. // {
  168. // HMENU hSysMenu = ::GetSystemMenu( hWndHooked, FALSE );
  169. // HMENU hCurMenu = GetSubMenu( (HMENU)wParam, 0 );
  170. // if( hCurMenu == hSysMenu
  171. // && hCurMenu != NULL
  172. // )
  173. // {
  174. // CMenu * pSysMenu = CMenu::FromHandle( hSysMenu );
  175. // UINT nEnable = 
  176. // CExtPopupMenuWnd::g_bFullScreenMode
  177. // ? MF_GRAYED
  178. // : MF_ENABLED
  179. // ;
  180. // pSysMenu->EnableMenuItem( 
  181. // SC_MOVE,
  182. // nEnable|MF_BYCOMMAND
  183. // ); 
  184. // pSysMenu->EnableMenuItem( 
  185. // SC_SIZE,
  186. // nEnable|MF_BYCOMMAND
  187. // ); 
  188. // pSysMenu->EnableMenuItem( 
  189. // SC_MAXIMIZE,
  190. // nEnable|MF_BYCOMMAND
  191. // ); 
  192. // }
  193. // } // if( pFrame != NULL )
  194. // } // if( nMessage == WM_INITMENU )
  196. if( nMessage == WM_SIZE
  197. || nMessage == WM_ACTIVATEAPP
  198. || ( nMessage == WM_COMMAND
  199. && ( ((HIWORD(wParam))==0)
  200. || ((HIWORD(wParam))==1)
  201. )
  202. )
  203. || nMessage == WM_SYSCOMMAND
  204. )
  205. {
  206. m_bHelperTrackingCharCode = false;
  207. if( _IsNonCommandButtonMode() )
  208. return
  209. CExtHookSink::OnHookWndMsg(
  210. lResult,
  211. hWndHooked,
  212. nMessage,
  213. wParam,
  214. lParam
  215. );
  216. HWND hWndCapture = CExtMouseCaptureSink::GetCapture();
  217. if( hWndCapture == GetSafeHwnd() )
  218. CExtMouseCaptureSink::ReleaseCapture();
  219. else if( hWndCapture != NULL )
  220. {
  221. CWnd * pWnd = FromHandlePermanent(hWndCapture);
  222. if( pWnd != NULL
  223. && pWnd->GetSafeHwnd() != NULL
  224. && ::IsWindow( pWnd->GetSafeHwnd() )
  225. && pWnd->IsKindOf(RUNTIME_CLASS(CExtControlBar))
  226. )
  227. CExtMouseCaptureSink::ReleaseCapture();
  228. }
  230. _CancelFlatTracking();
  231. if( CExtMenuControlBar::g_bMenuTracking )
  232. CExtMenuControlBar::_CloseTrackingMenus();
  233. //if( CExtPopupMenuWnd::IsMenuTracking() )
  234. // CExtPopupMenuWnd::CancelMenuTracking();
  235. return CExtHookSink::OnHookWndMsg( lResult, hWndHooked, nMessage, wParam, lParam );
  236. }
  238. if( ! m_bPresubclassDialogMode )
  239. {
  240. // if( nMessage == WM_NCLBUTTONDBLCLK && wParam == HTSYSMENU )
  241. // {
  242. // if( hWndHooked == _GetHwndMainFrame() )
  243. // {
  244. // ::SendMessage( hWndHooked, WM_SYSCOMMAND, SC_CLOSE, lParam );
  245. // if( ::IsWindow( hWndHooked ) )
  246. // ::SendMessage( hWndHooked, WM_NCPAINT, 0, 0L );
  247. // lResult = 0L;
  248. // return true;
  249. // }
  250. // }
  251. // if( nMessage == WM_NCLBUTTONDOWN && wParam == HTSYSMENU )
  252. // {
  253. // if( hWndHooked == _GetHwndMainFrame() )
  254. // {
  255. // CExtPopupMenuWnd::CancelMenuTracking();
  256. // bool bDblClick = false;
  257. // static clock_t g_nLastClock = 0;
  258. // static HWND g_hWndLastClick = NULL;
  259. // clock_t nCurrClock = ::clock();
  260. // if( g_hWndLastClick == hWndHooked )
  261. // {
  262. // clock_t nDiff = (clock_t)::abs( nCurrClock - g_nLastClock );
  263. // clock_t nDoubleClickTime = (clock_t)::GetDoubleClickTime();
  264. // if( nDiff <= nDoubleClickTime )
  265. // bDblClick = true;
  266. // }
  267. // g_hWndLastClick = hWndHooked;
  268. // g_nLastClock = nCurrClock;
  269. // if( bDblClick )
  270. // {
  271. // ::SendMessage( hWndHooked, WM_NCLBUTTONDBLCLK, wParam, lParam );
  272. // lResult = 0;
  273. // return true;
  274. // }
  275. // if( ! m_bAllowProfMainFrameSysmenu )
  276. // return false;
  277. // }
  278. // }
  279. if( ( nMessage == WM_NCLBUTTONUP && wParam == HTSYSMENU )
  280. || ( nMessage == WM_NCRBUTTONUP && ( wParam == HTCAPTION || wParam == HTSYSMENU ) )
  281. )
  282. {
  283. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  284. CPoint * pPoint = NULL, ptCursor;
  285. if( nMessage == WM_NCRBUTTONUP )
  286. {
  287. if( ! ::GetCursorPos(&ptCursor) )
  288. {
  289. lResult = 0;
  290. return true;
  291. }
  292. pPoint = &ptCursor;
  293. }
  294. if( !_IsDockSiteCustomizeMode() )
  295. {
  296. if( ! TrackMainFrameSystemMenu( pPoint, FALSE ) )
  297. return false;
  298. } // if( !_IsDockSiteCustomizeMode() )
  299. lResult = 0L;
  300. return true;
  301. }
  302. if( ( nMessage == WM_NCLBUTTONDOWN || nMessage == WM_NCRBUTTONDOWN )
  303. && wParam == HTSYSMENU
  304. )
  305. {
  306. lResult = 0;
  307. if( ( ! m_bAllowProfMainFrameSysmenu )
  308. && hWndHooked == _GetHwndMainFrame()
  309. )
  310. return false;
  311. if( (! m_bAllowProfChildFrameSysmenu )
  312. && _IsMdiApp()
  313. && hWndHooked == _GetHwndChildFrame()
  314. )
  315. return false;
  316. return true;
  317. }
  318. if( nMessage == WM_NCRBUTTONDOWN && wParam == HTCAPTION )
  319. {
  320. if( !_IsDockSiteCustomizeMode() )
  321. {
  322. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  323. CPoint ptCursor;
  324. if( ::GetCursorPos(&ptCursor) )
  325. if( ! TrackMainFrameSystemMenu( &ptCursor, FALSE ) )
  326. return false;
  327. } // if( !_IsDockSiteCustomizeMode() )
  328. lResult = 0;
  329. return true;
  330. }
  332. if( nMessage == CExtPopupMenuWnd::g_nMsgNotifyMenuClosed )
  333. {
  334. m_bSysMenuTracking = false;
  335. return false;
  336. }
  337. } // if( !m_bPresubclassDialogMode )
  339. bool bPrintPreviewMode = false;
  340. if( (!m_bPresubclassDialogMode)
  341. && m_pDockSite->GetSafeHwnd() != NULL
  342. && FindPrintPreviewMode(m_pDockSite)
  343. )
  344. bPrintPreviewMode = true;
  346. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupNext
  347. || nMessage == CExtPopupMenuWnd::g_nMsgPopupPrev
  348. )
  349. { // if menu next/prev popup activation messages
  350. BOOL bDummyMax = FALSE;
  351. HWND hWndMdiChild = _GetActiveMdiChildWnd(bDummyMax);
  353. int iTrackingIndex =
  354. GetMenuTrackingButton();
  355. if( (!bPrintPreviewMode) && iTrackingIndex < 0 ) // menu tracked on other bar
  356. {
  357. if( m_bSysMenuTracking )
  358. {
  359. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupNext
  360. && _IsMdiApp()
  361. && hWndMdiChild != NULL
  362. && IsDisplayMdiDocumentButtons()
  363. )
  364. {
  365. ASSERT( !m_bPresubclassDialogMode );
  366. if( ! TrackChildFrameSystemMenu( NULL, TRUE ) )
  367. {
  368. if( m_bAllowProfChildFrameSysmenu )
  369. return false;
  370. int iNewTrackIndex =
  371. GetVisibleButton(
  372. iTrackingIndex,
  373. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  374. TRUE : FALSE
  375. );
  376. if( iNewTrackIndex == iTrackingIndex )
  377. {
  378. lResult = 0; // same as tracking now
  379. return true;
  380. }
  381. TrackButtonMenu(iNewTrackIndex);
  382. }
  383. } // if( _IsMdiApp() && hWndMdiChild != NULL )
  384. else
  385. {
  386. int iNewTrackIndex =
  387. GetVisibleButton(
  388. iTrackingIndex,
  389. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  390. TRUE : FALSE
  391. );
  392. if( iNewTrackIndex == iTrackingIndex )
  393. {
  394. lResult = 0; // same as tracking now
  395. return true;
  396. }
  397. TrackButtonMenu(iNewTrackIndex);
  398. } // else from if( _IsMdiApp() && hWndMdiChild != NULL )
  399. } // if( m_bSysMenuTracking )
  400. lResult = 0;
  401. return true;
  402. }
  404. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupNext
  405. && ( !m_bPresubclassDialogMode )
  406. && iTrackingIndex == GetVisibleButton(-1,FALSE)
  407. )
  408. {
  409. if( ! _IsDockSiteCustomizeMode() )
  410. {
  411. if( (! TrackMainFrameSystemMenu( NULL, TRUE ) ) )
  412. {
  413. if( m_bAllowProfMainFrameSysmenu )
  414. return false;
  415. //int iNewTrackIndex = 0;
  416. int iNewTrackIndex =
  417. GetVisibleButton(
  418. iTrackingIndex,
  419. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  420. TRUE : FALSE
  421. );
  422. if( bPrintPreviewMode
  423. || iNewTrackIndex == iTrackingIndex
  424. )
  425. {
  426. lResult = 0; // same as tracking now
  427. return true;
  428. }
  429. TrackButtonMenu(iNewTrackIndex);
  430. lResult = 0;
  431. return true;
  432. }
  433. } // if( ! _IsDockSiteCustomizeMode() )
  434. lResult = 0;
  435. return true;
  436. }
  438. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupPrev
  439. && ( !m_bPresubclassDialogMode )
  440. && iTrackingIndex == 0
  441. && IsDisplayMdiDocumentButtons()
  442. )
  443. {
  444. if( ! _IsDockSiteCustomizeMode() )
  445. {
  446. if( (! (_IsMdiApp() && hWndMdiChild != NULL ) )
  447. || bPrintPreviewMode
  448. || (! TrackChildFrameSystemMenu( NULL, TRUE ) )
  449. )
  450. {
  451. if( ! TrackMainFrameSystemMenu( NULL, TRUE ) )
  452. {
  453. if( m_bAllowProfMainFrameSysmenu )
  454. return false;
  455. int iNewTrackIndex =
  456. GetVisibleButton(
  457. iTrackingIndex,
  458. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  459. TRUE : FALSE
  460. );
  461. if( bPrintPreviewMode
  462. || iNewTrackIndex == iTrackingIndex
  463. )
  464. {
  465. lResult = 0; // same as tracking now
  466. return true;
  467. }
  468. TrackButtonMenu(iNewTrackIndex);
  469. lResult = 0;
  470. return true;
  471. }
  472. }
  473. } // if( ! _IsDockSiteCustomizeMode() )
  474. lResult = 0;
  475. return true;
  476. }
  478. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupNext
  479. && (!m_bPresubclassDialogMode)
  480. && _IsMdiApp()
  481. && m_bSysMenuTracking
  482. && iTrackingIndex < 0
  483. && hWndMdiChild != NULL
  484. && IsDisplayMdiDocumentButtons()
  485. && (!bPrintPreviewMode)
  486. )
  487. {
  488. if( !_IsDockSiteCustomizeMode() )
  489. if( ! TrackChildFrameSystemMenu( NULL, TRUE ) )
  490. return false;
  491. lResult = 0;
  492. return true;
  493. }
  495. int iNewTrackIndex =
  496. GetVisibleButton(
  497. iTrackingIndex,
  498. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  499. TRUE : FALSE
  500. );
  501. if( (! IsDisplayMdiDocumentButtons() )
  502. && nMessage == CExtPopupMenuWnd::g_nMsgPopupPrev
  503. && iTrackingIndex == 0
  504. && iNewTrackIndex > 0
  505. )
  506. {
  507. if( !_IsDockSiteCustomizeMode() )
  508. if( ! TrackMainFrameSystemMenu( NULL, TRUE ) )
  509. return false;
  510. lResult = 0;
  511. return true;
  512. }
  514. if( bPrintPreviewMode
  515. || iNewTrackIndex == iTrackingIndex
  516. )
  517. {
  518. lResult = 0; // same as tracking now
  519. return true;
  520. }
  521. TrackButtonMenu(iNewTrackIndex);
  522. lResult = 0;
  523. return true;
  524. } // if menu next/prev popup activation messages
  526. if( nMessage == CExtPopupMenuWnd::g_nMsgNotifyMenuExpanded )
  527. { // if menu rarely used items was expanded
  528. CExtToolControlBar::g_bMenuTrackingExpanded = true;
  529. lResult = 0;
  530. return true;
  531. } // if menu rarely used items was expanded
  533. if( ! m_bPresubclassDialogMode )
  534. {
  535. if( nMessage == WM_STYLECHANGING
  536. || nMessage == WM_STYLECHANGED
  537. )
  538. return false;
  539. _KillFrameMenu();
  540. }
  541. } // if window is a main frame or parent dialog-like
  542. else if( (!m_bPresubclassDialogMode) && hWndHooked == _GetHwndChildFrame() )
  543. {
  545. if( nMessage == WM_PARENTNOTIFY
  546. && CExtPopupMenuWnd::IsMenuTracking()
  547. )
  548. {
  549. lResult = 0;
  550. return true;
  551. }
  553. if( nMessage == WM_SIZE
  554. || nMessage == WM_WINDOWPOSCHANGED
  555. || nMessage == WM_ACTIVATEAPP
  556. || ( nMessage == WM_COMMAND && (((HIWORD(wParam))==0)||((HIWORD(wParam))==1)) )
  557. || nMessage == WM_SYSCOMMAND
  558. )
  559. {
  560. m_bHelperTrackingCharCode = false;
  561. bool bSizePos = false;
  562. if( nMessage == WM_SIZE )
  563. bSizePos = true;
  564. else if( nMessage == WM_WINDOWPOSCHANGED )
  565. {
  566. LPWINDOWPOS lpWP = (LPWINDOWPOS)lParam;
  567. ASSERT( lpWP != NULL );
  568. if( (lpWP->flags & SWP_FRAMECHANGED) == 0 )
  569. bSizePos = true;
  570. } // else if( nMessage == WM_WINDOWPOSCHANGED )
  572. HWND hWndCapture = CExtMouseCaptureSink::GetCapture();
  573. if( hWndCapture == GetSafeHwnd() )
  574. CExtMouseCaptureSink::ReleaseCapture();
  575. else if( hWndCapture != NULL )
  576. {
  577. CWnd * pWnd = FromHandlePermanent(hWndCapture);
  578. if( pWnd != NULL
  579. && pWnd->GetSafeHwnd() != NULL
  580. && ::IsWindow( pWnd->GetSafeHwnd() )
  581. && pWnd->IsKindOf(RUNTIME_CLASS(CExtControlBar))
  582. && (! (((CExtControlBar*)pWnd)->_RowResizingGet() ) )
  583. && (! (((CExtControlBar*)pWnd)->_RowRecalcingGet() ) )
  584. )
  585. CExtMouseCaptureSink::ReleaseCapture();
  586. }
  588. _CancelFlatTracking();
  589. if( CExtMenuControlBar::g_bMenuTracking )
  590. CExtMenuControlBar::_CloseTrackingMenus();
  591. if( CExtPopupMenuWnd::IsMenuTracking() )
  592. CExtPopupMenuWnd::CancelMenuTracking();
  594. if( !bSizePos )
  595. {
  596. _KillFrameMenu();
  598. if( ( nMessage == WM_SIZE
  599. || nMessage == WM_WINDOWPOSCHANGED
  600. )
  601. && (! _IsDockSiteCustomizeMode() )
  602. )
  603. {
  604. WINDOWPLACEMENT _wp;
  605. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  606. _wp.length = sizeof(WINDOWPLACEMENT);
  607. ::GetWindowPlacement( _GetHwndChildFrame(), &_wp );
  608. if( _wp.showCmd != SW_SHOWMAXIMIZED
  609. || ( _GetButtonsCountImpl() > 0
  610. && (! _GetButtonPtr(0)->IsKindOf(RUNTIME_CLASS(CExtBarMdiDocButton)) )
  611. && ( IsDisplayMdiDocumentButtons() )
  612. ) // MDI doc buttons not installed, but should be displayed
  613. )
  614. _DelayUpdateMenuBar();
  615. }
  616. } // if( !bSizePos )
  618. return 
  619. CExtHookSink::OnHookWndMsg(
  620. lResult,
  621. hWndHooked,
  622. nMessage,
  623. wParam,
  624. lParam
  625. );
  626. }
  628. bool bPrintPreviewMode = false;
  629. if( (!m_bPresubclassDialogMode)
  630. && m_pDockSite->GetSafeHwnd() != NULL
  631. && FindPrintPreviewMode(m_pDockSite)
  632. )
  633. bPrintPreviewMode = true;
  635. if( bPrintPreviewMode )
  636. {
  637. lResult = 0;
  638. return true;
  639. }
  641. bool bMinFrameNcLbDown = false;
  642. bool bMinFrameNcLbUp = false;
  643. if( nMessage == WM_NCLBUTTONDOWN
  644. || nMessage == WM_NCLBUTTONUP
  645. )
  646. {
  647. WINDOWPLACEMENT _wp;
  648. ::memset( &_wp, 0, sizeof(WINDOWPLACEMENT) );
  649. _wp.length = sizeof(WINDOWPLACEMENT);
  650. ::GetWindowPlacement( hWndHooked, &_wp );
  651. if( _wp.showCmd == SW_SHOWMINIMIZED )
  652. {
  653. if( nMessage == WM_NCLBUTTONDOWN )
  654. bMinFrameNcLbDown = true;
  655. else if( nMessage == WM_NCLBUTTONUP )
  656. bMinFrameNcLbUp = true;
  657. }
  658. }
  660. if( bMinFrameNcLbUp && wParam == HTCAPTION )
  661. return true;
  663. if( ( bMinFrameNcLbDown && wParam == HTCAPTION )
  664. || ( nMessage == WM_NCLBUTTONUP && wParam == HTSYSMENU )
  665. || ( nMessage == WM_NCRBUTTONUP && ( wParam == HTCAPTION || wParam == HTSYSMENU ) )
  666. )
  667. {
  668. if( wParam == HTCAPTION
  669. && ::IsIconic( hWndHooked )
  670. )
  671. return false;
  672. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  673. CPoint * pPoint = NULL, ptCursor;
  674. if( nMessage == WM_NCRBUTTONUP )
  675. {
  676. if( ! ::GetCursorPos(&ptCursor) )
  677. {
  678. lResult = 0;
  679. return true;
  680. }
  681. pPoint = &ptCursor;
  682. }
  683. if( !_IsDockSiteCustomizeMode() )
  684. if( ! TrackChildFrameSystemMenu(
  685. pPoint,
  686. FALSE
  687. )
  688. )
  689. return false;
  690. lResult = 0;
  691. return true;
  692. }
  693. if( ( nMessage == WM_NCLBUTTONDOWN || nMessage == WM_NCRBUTTONDOWN )
  694. && wParam == HTSYSMENU
  695. )
  696. {
  697. if( ! m_bAllowProfChildFrameSysmenu )
  698. return false;
  699. lResult = 0;
  700. return true;
  701. }
  702. if( nMessage == WM_NCRBUTTONDOWN && wParam == HTCAPTION )
  703. {
  704. if( !_IsDockSiteCustomizeMode() )
  705. {
  706. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  707. CPoint ptCursor;
  708. if( ::GetCursorPos(&ptCursor) )
  709. if( ! TrackChildFrameSystemMenu(
  710. &ptCursor,
  711. FALSE
  712. )
  713. )
  714. return false;
  715. } // if( !_IsDockSiteCustomizeMode() )
  716. lResult = 0;
  717. return true;
  718. }
  720. if( nMessage == CExtPopupMenuWnd::g_nMsgNotifyMenuClosed )
  721. {
  722. m_bSysMenuTracking = false;
  723. return true;
  724. }
  726. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupNext
  727. || nMessage == CExtPopupMenuWnd::g_nMsgPopupPrev
  728. )
  729. { // if menu next/prev popup activation messages
  730. int iTrackingIndex =
  731. GetMenuTrackingButton();
  732. if( nMessage == CExtPopupMenuWnd::g_nMsgPopupPrev )
  733. {
  734. if( ! _IsDockSiteCustomizeMode() )
  735. {
  736. if( ! TrackMainFrameSystemMenu(
  737. NULL,
  738. TRUE
  739. )
  740. )
  741. {
  742. if( m_bAllowProfMainFrameSysmenu )
  743. return false;
  744. int iNewTrackIndex =
  745. GetVisibleButton(
  746. iTrackingIndex,
  747. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  748. TRUE : FALSE
  749. );
  750. if( iNewTrackIndex == iTrackingIndex )
  751. {
  752. lResult = 0; // same as tracking now
  753. return true;
  754. }
  755. TrackButtonMenu(iNewTrackIndex);
  756. }
  757. }
  758. lResult = 0;
  759. return true;
  760. }
  761. if( iTrackingIndex < 0 ) // menu tracked on other bar
  762. {
  763. if( m_bSysMenuTracking )
  764. {
  765. int iNewTrackIndex =
  766. GetVisibleButton(
  767. iTrackingIndex,
  768. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  769. TRUE : FALSE
  770. );
  771. if( iNewTrackIndex == iTrackingIndex )
  772. {
  773. lResult = 0; // same as tracking now
  774. return true;
  775. }
  776. TrackButtonMenu(iNewTrackIndex);
  777. } // if( m_bSysMenuTracking )
  778. lResult = 0;
  779. return true;
  780. }
  782. int iNewTrackIndex =
  783. GetVisibleButton(
  784. iTrackingIndex,
  785. (nMessage == CExtPopupMenuWnd::g_nMsgPopupNext) ?
  786. TRUE : FALSE
  787. );
  788. if( iNewTrackIndex == iTrackingIndex )
  789. {
  790. lResult = 0; // same as tracking now
  791. return true;
  792. }
  793. TrackButtonMenu(iNewTrackIndex);
  794. lResult = 0;
  795. return true;
  796. } // if menu next/prev popup activation messages
  798. } // else else if( (!m_bPresubclassDialogMode) && hWndHooked == _GetHwndChildFrame() )
  799. else if( (!m_bPresubclassDialogMode) && hWndHooked == _GetHwndMdiArea() )
  800. {
  801. if( nMessage == WM_PARENTNOTIFY
  802. &&
  803. CExtPopupMenuWnd::IsMenuTracking()
  804. )
  805. {
  806. lResult = 0;
  807. return true;
  808. }
  810. if( nMessage == WM_MDISETMENU )
  811. {
  812. CFrameWnd * pFrame = _GetDockingFrameImpl();
  813. ASSERT_VALID( pFrame );
  814. HWND hWndFrame = pFrame->GetSafeHwnd();
  815. ASSERT( hWndFrame != NULL );
  816. ASSERT( ::IsWindow(hWndFrame) );
  818. bool bOle = IsOleIpObjActive();
  820. HMENU hOldMdiMenu = m_menuDoc.Detach();
  821. HMENU hNewMdiMenu = (HMENU)wParam;
  822. m_menuDoc.Attach( hNewMdiMenu );
  824. if( bOle )
  825. {
  826. ::SetMenu( hWndFrame, hNewMdiMenu );
  827. } // if( bOle )
  828. else
  829. {
  830. HMENU hFrameRealMenu = ::GetMenu( hWndFrame );
  831. if( hFrameRealMenu != NULL )
  832. ::SetMenu( hWndFrame, NULL );
  833. _DelayUpdateMenuBar();
  834. } // else from if( bOle )
  835. CExtHookSink::OnHookWndMsgNextProcCurrent( 0L, 0L );
  836. lResult = (LRESULT)hOldMdiMenu;
  837. //_DelaySyncActiveMdiChild(); // (- v.2.23)
  838. _SyncActiveMdiChild(); // (+ v.2.23)
  839. m_bDelayedSyncActiveMdiChild = false; // (+ v.2.23)
  840. return true;
  841. }
  842. if( nMessage == WM_MDIREFRESHMENU )
  843. {
  844. CExtHookSink::OnHookWndMsgNextProcCurrent( 0L, 0L );
  845. //_DelaySyncActiveMdiChild(); // (- v.2.23)
  846. _SyncActiveMdiChild(); // (+ v.2.23)
  847. m_bDelayedSyncActiveMdiChild = false; // (+ v.2.23)
  848. lResult = 0;
  849. return true;
  850. }
  852. if( nMessage == WM_CONTEXTMENU )
  853. {
  854. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  855. CExtCustomizeSite * pSite =
  856. CExtCustomizeSite::GetCustomizeSite( m_hWnd );
  857. if( pSite != NULL
  858. && pSite->IsCustomizeMode()
  859. )
  860. {
  861. lResult = 0;
  862. return true;
  863. }
  864. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  865. if( !CExtControlBar::FindHelpMode(this) )
  866. {
  867. CFrameWnd * pFrame = _GetDockingFrameImpl();
  868. ASSERT_VALID( pFrame );
  870. CPoint ptCursor;
  871. if( ! ::GetCursorPos(&ptCursor) )
  872. {
  873. lResult = 0;
  874. return true;
  875. }
  876. HWND hWndTrack = GetOwner()->GetSafeHwnd();
  877. ASSERT( hWndTrack != NULL && ::IsWindow(hWndTrack) );
  878. CExtPopupMenuWnd * pPopup =
  879. CExtPopupMenuWnd::InstantiatePopupMenu(
  880. GetSafeHwnd(),
  881. RUNTIME_CLASS(CExtPopupMenuWnd),
  882. this
  883. );
  884. VERIFY( pPopup->CreatePopupMenu(hWndTrack) );
  885. if( ! CExtDockBar::_ConstructDockSiteControlBarPopupMenu(
  886. pFrame,
  887. pPopup,
  888. CExtControlBar::POPUP_MENU_EVENT_DATA::__PMED_MDICLIAREA_CTX,
  889. this,
  890. WM_CONTEXTMENU,
  891. NULL
  892. )
  893. )
  894. {
  895. delete pPopup;
  896. }
  897. else
  898. {
  899. if( pPopup->ItemGetCount() == 0 )
  900. {
  901. delete pPopup;
  902. }
  903. else
  904. {
  905. ::SetFocus( hWndTrack );
  906. pPopup->m_hWndNotifyMenuClosed = GetSafeHwnd();
  907. if( ! pPopup->TrackPopupMenu(
  908. TPMX_OWNERDRAW_FIXED,
  909. ptCursor.x,
  910. ptCursor.y,
  911. NULL,
  912. this,
  913. NULL,
  914. NULL,
  915. true
  916. )
  917. )
  918. {
  919. //delete pPopup;
  920. }
  921. }
  922. }
  923. } // if( !CExtControlBar::FindHelpMode(this) )
  924. lResult = 0;
  925. return true;
  926. } // if( nMessage == WM_CONTEXTMENU )
  928. if( nMessage == WM_MDIACTIVATE
  929. || nMessage == WM_MDIDESTROY
  930. || nMessage == WM_MDINEXT
  931. )
  932. {
  933. if( nMessage == WM_MDINEXT
  934. && IsOleIpObjActive()
  935. )
  936. {
  937. lResult = 0;
  938. return true;
  939. }
  940. _DelaySyncActiveMdiChild();
  941. _DelayUpdateMenuBar();
  942. }
  945. if( g_PaintManager.m_bIsWinXPorLater )
  946. {
  947. // this implements Windows XP or later MDI flicker fix
  948. // suggested by Mr. Raffaele Cappelli
  949. HWND hWndMdiClient = _GetHwndMdiArea();
  950. if( nMessage == WM_MDIACTIVATE )
  951. {
  952. HWND hWndNew = (HWND)wParam;
  953. BOOL bOldWasMaximized = FALSE;
  954. HWND hWndOld = (HWND)
  955. ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bOldWasMaximized );
  956. // hWndOld;
  957. // if( bOldWasMaximized )
  958. // {
  959. // if( ! ::IsZoomed( hWndOld ) )
  960. // ::SendMessage( hWndNew, WM_SYSCOMMAND, SC_MAXIMIZE, 0L );
  961. // ::SendMessage( hWndMdiClient, WM_SETREDRAW, FALSE, 0 );
  962. // }
  963. // if( ::IsIconic( hWndNew ) )
  964. // ::SendMessage(
  965. // hWndMdiClient,
  966. // bOldWasMaximized ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
  967. // (WPARAM)hWndNew,
  968. // 0L
  969. // );
  970. LRESULT _lResult = CExtHookSink::OnHookWndMsgDefault();
  971. _lResult;
  972. // if( bOldWasMaximized )
  973. // {
  974. // ::SendMessage( hWndMdiClient, WM_SETREDRAW, TRUE, 0 );
  975. // ::RedrawWindow( hWndMdiClient, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN );
  976. // }
  977. if( hWndOld != NULL && bOldWasMaximized )
  978. {
  979. ::SetWindowPos(
  980. hWndNew, NULL, 0, 0, 0, 0,
  981. SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE
  982. |SWP_NOZORDER|SWP_NOOWNERZORDER
  983. |SWP_FRAMECHANGED
  984. );
  985. //CRect rcClient;
  986. //::GetClientRect( hWndMdiClient, &rcClient );
  987. //::PostMessage( hWndMdiClient, WM_SIZE, SIZE_RESTORED, MAKELPARAM( rcClient.Width(), rcClient.Height() ) );
  988. }
  989. return true;
  990. }
  991. return 
  992. CExtHookSink::OnHookWndMsg(
  993. lResult,
  994. hWndHooked,
  995. nMessage,
  996. wParam,
  997. lParam
  998. );
  999. } // if( g_PaintManager.m_bIsWinXPorLater )
  1001. } // else if( (!m_bPresubclassDialogMode) && hWndHooked == _GetHwndMdiArea() )
  1002. else
  1003. {
  1004. ASSERT( FALSE );
  1005. }
  1007. MSG msg;
  1008. ::memset( &msg, 0, sizeof(MSG) );
  1009. msg.hwnd = hWndHooked;
  1010. msg.message = nMessage;
  1011. msg.wParam = wParam;
  1012. msg.lParam = lParam;
  1013. if( TranslateMainFrameMessage(&msg) )
  1014. return true;
  1016. return 
  1017. CExtHookSink::OnHookWndMsg(
  1018. lResult,
  1019. hWndHooked,
  1020. nMessage,
  1021. wParam,
  1022. lParam
  1023. );
  1024. }
  1026. bool CExtMenuControlBar::_IsNonCommandButtonMode() const
  1027. {
  1028. ASSERT_VALID( this );
  1029. return m_bNonCommandButtonMode;
  1030. }
  1033. /////////////////////////////////////////////////////////////////////////////
  1034. // CExtMenuControlBar
  1036. IMPLEMENT_DYNCREATE(CExtMenuControlBar, CExtToolControlBar)
  1038. CExtMenuControlBar::CExtMenuControlBar()
  1039. : m_bUseFastKeyboardMenuTracking( true )
  1040. , m_bAllowProfMainFrameSysmenu( true )
  1041. , m_bAllowProfChildFrameSysmenu( true )
  1042. , m_bHandleDblClickAsCloseCmd( true )
  1043. , m_bFlatTracking( false )
  1044. , m_bSysMenuTracking( false )
  1045. , m_bMdiApp( false )
  1046. , m_bMultiRowLayout( true )
  1047. , m_nFlatTrackingIndex( -1 )
  1048. , m_nOldTrackingIndex( -1 )
  1049. , m_sMdiWindowPopupName( _T("") )
  1050. , m_nMdiDocButtonCmdID( 0 )
  1051. , m_hWndHelper( NULL )
  1052. , m_bDelayedSyncActiveMdiChild( false )
  1053. , m_bDelayedUpdateMenuBar( false )
  1054. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1055. , m_pMenuInfo( NULL )
  1056. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1057. , m_bNonCommandButtonMode( false )
  1058. , m_bMenuBarUsesDelayedButtonMenuTracking( true )
  1059. , m_bAdaptiveCmdAllocMode( false )
  1060. , m_bHelperTrackingCharCode( false )
  1061. {
  1062. }
  1064. CExtMenuControlBar::~CExtMenuControlBar()
  1065. {
  1066. _RemoveAllButtonsImpl();
  1067. //CSingleLock _slCsCB( &g_csCB );
  1068. // _slCsCB.Lock();
  1069. int nCountOfBars = (int)g_AllBars.GetSize();
  1070. for( int i=0; i<nCountOfBars; i++ )
  1071. {
  1072. CExtControlBar * pBar = g_AllBars[i];
  1073. ASSERT( pBar != NULL );
  1074. if( pBar == this )
  1075. {
  1076. g_AllBars.RemoveAt( i );
  1077. break;
  1078. }
  1079. }
  1080. // _slCsCB.Unlock();
  1081. }
  1083. BEGIN_MESSAGE_MAP(CExtMenuControlBar, CExtToolControlBar)
  1084.     //{{AFX_MSG_MAP(CExtMenuControlBar)
  1085. ON_WM_DESTROY()
  1086. ON_WM_TIMER()
  1087. ON_WM_LBUTTONDOWN()
  1088. ON_WM_LBUTTONUP()
  1089. ON_WM_CREATE()
  1090. //}}AFX_MSG_MAP
  1091. ON_REGISTERED_MESSAGE(CExtToolControlBar::g_nMsgTrackButtonMenu, OnTrackButtonMenu)
  1092. END_MESSAGE_MAP()
  1094. // LoadMenuBar() required only for CFrameWnd
  1095. // based windows principally without menu
  1096. BOOL CExtMenuControlBar::LoadMenuBar(
  1097. UINT nResourceID
  1098. )
  1099. {
  1100. if( m_menuDoc.GetSafeHmenu() != NULL )
  1101. {
  1102. VERIFY( m_menuDoc.DestroyMenu() );
  1103. }
  1104. if( m_menuFrame.GetSafeHmenu() != NULL )
  1105. {
  1106. VERIFY( m_menuFrame.DestroyMenu() );
  1107. }
  1109. if( m_pDockSite != NULL )
  1110. {
  1111. if( GetSafeHwnd() == NULL
  1112. || (! ::IsWindow( GetSafeHwnd() ) )
  1113. || m_menuFrame.GetSafeHmenu() != NULL
  1114. )
  1115. {
  1116. ASSERT( FALSE );
  1117. return FALSE;
  1118. }
  1119. }
  1121. if( ! g_ResourceManager->LoadMenu( m_menuFrame, nResourceID ) )
  1122. {
  1123. ASSERT( FALSE );
  1124. return FALSE;
  1125. }
  1126. ASSERT( ::IsMenu(m_menuFrame.GetSafeHmenu()) );
  1127. if( !g_CmdManager->UpdateFromMenu(
  1128. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1129. m_menuFrame.GetSafeHmenu()
  1130. )
  1131. )
  1132. {
  1133. ASSERT( FALSE );
  1134. return FALSE;
  1135. }
  1137. return _UpdateMenuBar();
  1138. }
  1140. CMenu * CExtMenuControlBar::_GetMenu()
  1141. {
  1142. if( m_menuDoc.GetSafeHmenu() != NULL )
  1143. {
  1144. ASSERT( ::IsMenu(m_menuDoc.GetSafeHmenu()) );
  1145. return &m_menuDoc;
  1146. }
  1147. if( m_menuFrame.GetSafeHmenu() != NULL )
  1148. {
  1149. ASSERT( ::IsMenu(m_menuFrame.GetSafeHmenu()) );
  1150. return &m_menuFrame;
  1151. }
  1152. return NULL;
  1153. }
  1155. CMenu * CExtMenuControlBar::GetMenu()
  1156. {
  1157. return _GetMenu();
  1158. }
  1160. BOOL CExtMenuControlBar::UpdateMenuBar( // update after menu changed
  1161. BOOL bDoRecalcLayout // = TRUE
  1162. )
  1163. {
  1164. return _UpdateMenuBar( bDoRecalcLayout );
  1165. }
  1167. BOOL CExtMenuControlBar::_UpdateMenuBar(
  1168. BOOL bDoRecalcLayout // = TRUE
  1169. )
  1170. {
  1171. SetButtons(); // remove all buttons
  1173. VERIFY(
  1174. g_CmdManager->CmdRemoveByMask(
  1175. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1176. (DWORD)CExtCmdItem::STATE_MENUBAR_TMP
  1177. )
  1178. );
  1180. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1181. MenuInfoUpdate();
  1182. CExtCustomizeSite::CCmdMenuInfo * pMenuInfo = MenuInfoGet();
  1183. if( pMenuInfo != NULL )
  1184. {
  1185. ASSERT_VALID( pMenuInfo->GetNode() );
  1186. SetButtons( pMenuInfo->GetNode() );
  1187. } // if( pMenuInfo != NULL )
  1188. else
  1189. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1190. {
  1191. CMenu * pMenu = GetMenu();
  1192. if( pMenu != NULL && pMenu->GetSafeHmenu() != NULL )
  1193. {
  1194. ASSERT( ::IsMenu(pMenu->GetSafeHmenu()) );
  1195. bool bRevertRTL = OnQueryRevertRTL();
  1196. UINT nMenuItemCount = pMenu->GetMenuItemCount();
  1197. for( UINT nMenuItemIndex = 0; nMenuItemIndex < nMenuItemCount; nMenuItemIndex++ )
  1198. {
  1199. UINT nInsertButtonLocation =
  1200. bRevertRTL
  1201. ? 0
  1202. : nMenuItemIndex
  1203. ;
  1204. MENUITEMINFO mii;
  1205. ::memset( &mii, 0, sizeof(MENUITEMINFO) );
  1206. mii.cbSize = sizeof(MENUITEMINFO);
  1207. mii.fMask =
  1208. MIIM_CHECKMARKS
  1209. |MIIM_DATA
  1210. |MIIM_ID
  1211. |MIIM_STATE
  1212. |MIIM_SUBMENU
  1213. |MIIM_TYPE
  1214. ;
  1215. mii.cch = __MAX_UI_ITEM_TEXT;
  1216. CExtSafeString sText;
  1217. mii.dwTypeData =
  1218. sText.GetBuffer( __MAX_UI_ITEM_TEXT );
  1219. ASSERT( mii.dwTypeData != NULL );
  1220. if( mii.dwTypeData == NULL )
  1221. {
  1222. ASSERT( FALSE );
  1223. return FALSE;
  1224. }
  1225. if( ! pMenu->GetMenuItemInfo(
  1226. nMenuItemIndex,
  1227. &mii,
  1228. TRUE
  1229. )
  1230. )
  1231. {
  1232. sText.ReleaseBuffer();
  1233. ASSERT( FALSE );
  1234. return false;
  1235. }
  1236. sText.ReleaseBuffer();
  1238. BOOL bAppendMdiWindowsMenu = FALSE;
  1239. UINT nCmdID = 0;
  1240. CExtCmdItem * pCmdItem = NULL;
  1241. bool bAllocCmd = false;
  1242. bool bStateEnable = false;
  1243. if( mii.hSubMenu == NULL )
  1244. {
  1245. nCmdID = mii.wID;
  1246. if( nCmdID == ID_SEPARATOR )
  1247. {
  1248. if( ! InsertButton(
  1249. nInsertButtonLocation,
  1250. nCmdID,
  1251. FALSE
  1252. )
  1253. )
  1254. {
  1255. ASSERT( FALSE );
  1256. return FALSE;
  1257. }
  1258. continue;
  1259. } // if( nCmdID == ID_SEPARATOR )
  1260. ASSERT( CExtCmdManager::IsCommand(nCmdID) );
  1261. pCmdItem =
  1262. g_CmdManager->CmdGetPtr(
  1263. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1264. nCmdID
  1265. );
  1266. if( m_bAdaptiveCmdAllocMode )
  1267. {
  1268. if( pCmdItem == NULL )
  1269. {
  1270. bAllocCmd = true;
  1271. bStateEnable = true;
  1272. } 
  1273. }
  1274. #ifdef _DEBUG
  1275. else
  1276. {
  1277. ASSERT( pCmdItem != NULL );
  1278. }
  1279. #endif
  1280. } // if( mii.hSubMenu == NULL )
  1281. else
  1282. {
  1283. bAllocCmd = true;
  1284. } // else from if( mii.hSubMenu == NULL )
  1285. if( bAllocCmd )
  1286. {
  1287. pCmdItem =
  1288. g_CmdManager->CmdAllocPtr(
  1289. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() )
  1290. );
  1291. if( pCmdItem == NULL )
  1292. {
  1293. ASSERT( FALSE );
  1294. return FALSE;
  1295. } // if( pCmdItem == NULL )
  1296. nCmdID = pCmdItem->m_nCmdID;
  1297. ASSERT( CExtCmdManager::IsCommand(nCmdID) );
  1298. pCmdItem->StateSetMenubarTemp();
  1299. pCmdItem->StateSetBasic();
  1300. if( bStateEnable )
  1301. pCmdItem->StateEnable(TRUE);
  1303. if( _IsMdiApp() && (! m_sMdiWindowPopupName.IsEmpty() ) )
  1304. {
  1305. CExtSafeString _sText(sText);
  1306. _sText.TrimLeft();
  1307. _sText.TrimRight();
  1308. while( _sText.Replace(_T("&"),_T("")) > 0 )
  1309. {
  1310. _sText.TrimLeft();
  1311. _sText.TrimRight();
  1312. } // while( _sText.Replace(_T("&"),_T("")) > 0 )
  1313. if( _sText == m_sMdiWindowPopupName )
  1314. bAppendMdiWindowsMenu = TRUE;
  1315. } // if( _IsMdiApp() && (! m_sMdiWindowPopupName.IsEmpty() ) )
  1316. } // else from if( mii.hSubMenu == NULL )
  1317. ASSERT( pCmdItem != NULL );
  1318. if( pCmdItem->m_sToolbarText.IsEmpty() )
  1319. pCmdItem->m_sToolbarText = sText;
  1320. if( pCmdItem->m_sMenuText.IsEmpty() )
  1321. pCmdItem->m_sMenuText = sText;
  1323. if( ! InsertButton(
  1324. nInsertButtonLocation,
  1325. nCmdID,
  1326. FALSE
  1327. )
  1328. )
  1329. {
  1330. ASSERT( FALSE );
  1331. return FALSE;
  1332. }
  1334. if( mii.hSubMenu != NULL )
  1335. {
  1336. ASSERT( ::IsMenu(mii.hSubMenu) );
  1337. SetButtonMenu(
  1338. nInsertButtonLocation,
  1339. mii.hSubMenu,
  1340. FALSE,
  1341. FALSE,
  1342. FALSE
  1343. );
  1344. } // if( mii.hSubMenu != NULL )
  1345. if( bAppendMdiWindowsMenu )
  1346. {
  1347. VERIFY(
  1348. MarkButtonAsMdiWindowsMenu(
  1349. nInsertButtonLocation,
  1350. TRUE
  1351. )
  1352. );
  1353. } // if( bAppendMdiWindowsMenu )
  1354. } // for( UINT nMenuItemIndex = 0; nMenuItemIndex < nMenuItemCount; nMenuItemIndex++ )
  1356. ASSERT( m_pRightBtn == NULL );
  1357. m_pRightBtn = OnCreateBarRightBtn();
  1358. if( m_pRightBtn != NULL )
  1359. {
  1360. ASSERT_VALID( m_pRightBtn );
  1361. ASSERT_KINDOF( CExtBarContentExpandButton, m_pRightBtn );
  1362. m_buttons.Add( m_pRightBtn );
  1363. } // if( m_pRightBtn != NULL )
  1364. } // if( pMenu != NULL && pMenu->GetSafeHmenu() != NULL )
  1365. } // else from if( pMenuInfo != NULL )
  1367. if( _IsMdiApp() )
  1368. {
  1369. if( ! IsOleIpObjActive() )
  1370. if( _InstallMdiDocButtons( FALSE ) )
  1371. bDoRecalcLayout = TRUE;
  1372. VERIFY( _SyncActiveMdiChild() );
  1373. }
  1375. if( bDoRecalcLayout && m_pDockSite != NULL )
  1376. {
  1377. CFrameWnd * pFrame = GetParentFrame();
  1378. ASSERT_VALID( pFrame );
  1379. pFrame->RecalcLayout();
  1380. if( pFrame->IsKindOf(RUNTIME_CLASS(CExtMiniDockFrameWnd)) )
  1381. pFrame->SetWindowPos(
  1382. NULL, 0, 0, 0, 0,
  1383. SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE
  1384. |SWP_NOZORDER|SWP_NOOWNERZORDER
  1385. |SWP_FRAMECHANGED
  1386. );
  1387. Invalidate();
  1388. _RecalcLayoutImpl();
  1389. UpdateWindow();
  1390. } // if( bDoRecalcLayout && m_pDockSite != NULL )
  1391. return TRUE;
  1392. }
  1394. HWND CExtMenuControlBar::_GetActiveMdiChildWnd(
  1395. BOOL & bMaximized
  1396. )
  1397. {
  1398. bMaximized = FALSE;
  1399. if( ! _IsMdiApp() )
  1400. return NULL;
  1402.  // FrameFeatures does not use CMDIFrameWnd
  1403. CMDIFrameWnd * pMdiFrame = DYNAMIC_DOWNCAST( CMDIFrameWnd, _GetDockingFrameImpl() );
  1404. HWND hWndMdiClient = NULL;
  1405. if( pMdiFrame == NULL )
  1406. hWndMdiClient = _GetHwndMdiArea();
  1407. else
  1408. {
  1409. ASSERT_VALID( pMdiFrame );
  1410. hWndMdiClient = pMdiFrame->m_hWndMDIClient;
  1411. } // else from if( pMdiFrame == NULL )
  1412. if( hWndMdiClient == NULL )
  1413. return NULL;
  1414. ASSERT( ::IsWindow( hWndMdiClient ) );
  1415. BOOL bMax = FALSE;
  1416. HWND hWndActiveChildFrame = (HWND) ::SendMessage( hWndMdiClient, WM_MDIGETACTIVE, 0, (LPARAM)&bMax );
  1417. if( hWndActiveChildFrame == NULL )
  1418. bMax = FALSE;
  1419. else
  1420. {
  1421. if( ! ::IsWindow( hWndActiveChildFrame ) )
  1422. return NULL;
  1423. __EXT_MFC_LONG_PTR dwActiveChildFrameStyle = :: __EXT_MFC_GetWindowLong( hWndActiveChildFrame, GWL_STYLE );
  1424. if( pMdiFrame == NULL )
  1425. {
  1426. if( (dwActiveChildFrameStyle&WS_VISIBLE) == 0 )
  1427. {
  1428. hWndActiveChildFrame = NULL;
  1429. bMax = FALSE;
  1430. } // if( (dwActiveChildFrameStyle&WS_VISIBLE) == 0 )
  1431. } // if( pMdiFrame == NULL )
  1432. else
  1433. {
  1434. CWnd * pWndTempAnalyze =
  1435. CWnd::FromHandlePermanent( hWndActiveChildFrame );
  1436. if( pWndTempAnalyze != NULL )
  1437. {
  1438. ASSERT_VALID( pWndTempAnalyze );
  1439. CMDIChildWnd * pWndTempMDIChild = DYNAMIC_DOWNCAST( CMDIChildWnd, pWndTempAnalyze );
  1440. if( pWndTempMDIChild != NULL
  1441. && pWndTempMDIChild->m_bPseudoInactive
  1442. && (dwActiveChildFrameStyle&WS_VISIBLE) == 0
  1443. )
  1444. {
  1445. hWndActiveChildFrame = NULL;
  1446. bMax = FALSE;
  1447. }
  1448. else
  1449. {
  1450. if( ! bMax )
  1451. {
  1452. if( (dwActiveChildFrameStyle&WS_MAXIMIZE) != 0 )
  1453. bMax = true;
  1454. }
  1455. }
  1456. } // if( pWndTempAnalyze != NULL )
  1457. } // else from if( pMdiFrame == NULL )
  1458. } // else from if( hWndActiveChildFrame == NULL )
  1459. bMaximized = bMax;
  1460. return hWndActiveChildFrame;
  1461. }
  1463. void CExtMenuControlBar::OnUpdateCmdUI(
  1464. CFrameWnd * pTarget,
  1465. BOOL bDisableIfNoHndler
  1466. )
  1467. {
  1468. CExtToolControlBar::OnUpdateCmdUI(
  1469. pTarget,
  1470. bDisableIfNoHndler
  1471. );
  1472. }
  1474. BOOL CExtMenuControlBar::_SyncActiveMdiChild()
  1475. {
  1476. if( m_bPresubclassDialogMode )
  1477. return TRUE;
  1478. if( _DraggingGetBar() != NULL )
  1479. return TRUE;
  1481. // if( (GetStyle() & WS_VISIBLE) == 0 )
  1482. // return TRUE;
  1484. BOOL bMax = FALSE;
  1485. HWND hWndActiveChild =
  1486. _GetActiveMdiChildWnd( bMax );
  1487. if( m_hWndHelper == hWndActiveChild )
  1488. return TRUE;
  1489. if( m_hWndHelper != NULL )
  1490. SetupHookWndSink( m_hWndHelper, true );
  1491. m_hWndHelper = hWndActiveChild;
  1492. if( m_hWndHelper != NULL )
  1493. SetupHookWndSink( m_hWndHelper );
  1494. _RecalcLayoutImpl();
  1495. return TRUE;
  1496. }
  1498. LRESULT CExtMenuControlBar::DoHelpHitTest( CPoint ptHelpHitTest )
  1499. {
  1500. ASSERT_VALID( this );
  1501. return CExtToolControlBar::DoHelpHitTest( ptHelpHitTest );
  1502. }
  1504. bool CExtMenuControlBar::_IsMdiApp() const
  1505. {
  1506. ASSERT_VALID( this );
  1507. return m_bMdiApp;
  1508. }
  1510. bool CExtMenuControlBar::IsDisplayMdiDocumentButtons() const
  1511. {
  1512. ASSERT_VALID( this );
  1513. return true;
  1514. }
  1516. BOOL CExtMenuControlBar::_InstallMdiDocButtons(
  1517. BOOL bDoRecalcLayout // = TRUE
  1518. )
  1519. {
  1520. ASSERT( _IsMdiApp() );
  1521. if( ! IsDisplayMdiDocumentButtons() )
  1522. {
  1523. if( bDoRecalcLayout )
  1524. _RecalcLayoutImpl();
  1525. return TRUE;
  1526. }
  1527. if( _DraggingGetBar() != NULL )
  1528. return FALSE;
  1529. BOOL bMax = FALSE;
  1530. HWND hWndActiveChild =
  1531. _GetActiveMdiChildWnd( bMax );
  1532. int nCountOfButtons = GetButtonsCount();
  1533. if( nCountOfButtons == 0
  1534. && hWndActiveChild == NULL
  1535. )
  1536. return FALSE;
  1537. CExtBarMdiDocButton * pDocTBB = NULL;
  1538. if( nCountOfButtons > 0 )
  1539. pDocTBB = 
  1540. DYNAMIC_DOWNCAST(
  1541. CExtBarMdiDocButton,
  1542. _GetButtonPtr(0)
  1543. );
  1544. int nRightIndex = nCountOfButtons - 1;
  1545. CExtBarMdiRightButton * pRightTBB = NULL;
  1546. if( nCountOfButtons > 0 )
  1547. pRightTBB =
  1548. DYNAMIC_DOWNCAST(
  1549. CExtBarMdiRightButton,
  1550. _GetButtonPtr(nRightIndex)
  1551. );
  1552. if( pRightTBB == NULL
  1553. && nCountOfButtons > 1
  1554. )
  1555. {
  1556. if( !m_bMultiRowLayout )
  1557. nRightIndex--;
  1558. pRightTBB =
  1559. DYNAMIC_DOWNCAST(
  1560. CExtBarMdiRightButton,
  1561. _GetButtonPtr(nRightIndex)
  1562. );
  1563. }
  1564. BOOL bRetVal = FALSE;
  1565. if( hWndActiveChild == NULL || (!bMax) )
  1566. { // if no active MDI doc or not maximized
  1567. if( pRightTBB != NULL )
  1568. {
  1569. ASSERT_VALID( pRightTBB );
  1570. VERIFY( RemoveButton(nRightIndex,FALSE) );
  1571. bRetVal = TRUE;
  1572. pRightTBB = NULL;
  1573. }
  1574. if( pDocTBB != NULL )
  1575. {
  1576. ASSERT_VALID( pDocTBB );
  1577. VERIFY( RemoveButton(0,FALSE) );
  1578. bRetVal = TRUE;
  1579. pDocTBB = NULL;
  1580. }
  1581. } // if no active MDI doc or not maximized
  1582. else
  1583. { // if active MDI doc is maximized
  1584. ASSERT( hWndActiveChild != NULL );
  1585. ASSERT( ::IsWindow(hWndActiveChild) );
  1586. if( m_nMdiDocButtonCmdID == 0 )
  1587. {
  1588. CExtCmdItem * pCmdItem =
  1589. g_CmdManager->CmdAllocPtr(
  1590. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() )
  1591. );
  1592. ASSERT( pCmdItem != NULL );
  1593. if( pCmdItem == NULL )
  1594. return FALSE;
  1595. m_nMdiDocButtonCmdID = pCmdItem->m_nCmdID;
  1596. ASSERT(
  1597. CExtCmdManager::IsCommand(
  1598. m_nMdiDocButtonCmdID
  1599. )
  1600. );
  1601. //pCmdItem->StateSetMenubarTemp();
  1602. pCmdItem->StateSetBasic();
  1603. } // if( m_nMdiDocButtonCmdID == 0 )
  1604. if( pRightTBB == NULL )
  1605. {
  1606. pRightTBB =
  1607. new CExtBarMdiRightButton(
  1608. this,
  1609. m_nMdiDocButtonCmdID
  1610. );
  1611. ASSERT_VALID( pRightTBB );
  1612. m_buttons.InsertAt( nRightIndex + 1, pRightTBB );
  1613. bRetVal = TRUE;
  1614. } // if( pRightTBB == NULL )
  1615. if( pDocTBB == NULL )
  1616. {
  1617. HMENU hDocMenu =
  1618. ::GetSystemMenu(hWndActiveChild,FALSE);
  1619. if( hDocMenu != NULL
  1620. && ::IsMenu(hDocMenu)
  1621. )
  1622. {
  1623. pDocTBB =
  1624. new CExtBarMdiDocButton(
  1625. this,
  1626. m_nMdiDocButtonCmdID
  1627. );
  1628. ASSERT_VALID( pDocTBB );
  1629. pDocTBB->m_bHandleDblClickAsCloseCmd =
  1630. m_bHandleDblClickAsCloseCmd;
  1631. pDocTBB->SetMenu( hDocMenu, FALSE, FALSE );
  1632. m_buttons.InsertAt( 0, pDocTBB );
  1633. bRetVal = TRUE;
  1634. }
  1635. } // if( pDocTBB == NULL )
  1636. } // if active MDI doc is maximized
  1638. if( pRightTBB != NULL )
  1639. {
  1640. ASSERT_VALID( pRightTBB );
  1641. pRightTBB->_ActiveMdiChildWndAttach( hWndActiveChild );
  1642. }
  1643. if( pDocTBB != NULL )
  1644. {
  1645. ASSERT_VALID( pDocTBB );
  1646. pDocTBB->_ActiveMdiChildWndAttach( hWndActiveChild );
  1647. }
  1648. if( bDoRecalcLayout )
  1649. {
  1650. _RecalcLayoutImpl();
  1651. bRetVal = FALSE;
  1652. }
  1653. return bRetVal;
  1654. }
  1656. void CExtMenuControlBar::OnDestroy() 
  1657. {
  1658. if( m_nMdiDocButtonCmdID != 0 )
  1659. {
  1660. VERIFY(
  1661. g_CmdManager->CmdRemove(
  1662. g_CmdManager->ProfileNameFromWnd( GetSafeHwnd() ),
  1663. m_nMdiDocButtonCmdID
  1664. )
  1665. );
  1666. m_nMdiDocButtonCmdID = 0;
  1667. }
  1668. RemoveAllWndHooks();
  1669. CExtToolControlBar::OnDestroy();
  1670. }
  1672. CSize CExtMenuControlBar::_GetDefButtonSize() const
  1673. {
  1674. ASSERT_VALID( this );
  1675. return 
  1676. IsDockedHorizontally()
  1677. ? CSize( 22, 19 )
  1678. : CSize( 19, 22 );
  1679. }
  1681. const ACCEL * CExtMenuControlBar::_GetTranslatedContextHelpAccel() const
  1682. {
  1683. if( ! g_bTranslateContextHelpCmd )
  1684. return NULL;
  1685. return &g_accelContextHelp;
  1686. }
  1688. BOOL CExtMenuControlBar::TranslateMainFrameMessage(MSG* pMsg) 
  1689. {
  1690. __PROF_UIS_MANAGE_STATE;
  1691. if( GetSafeHwnd() == NULL
  1692. || (!::IsWindow(GetSafeHwnd()))
  1693. )
  1694. return  FALSE;
  1695. ASSERT( pMsg != NULL );
  1697. if( pMsg->message == WM_TIMER
  1698. && pMsg->hwnd == m_hWndHelper
  1699. && AnimationSite_OnHookTimer( UINT(pMsg->wParam) )
  1700. )
  1701. return TRUE;
  1703. if( pMsg->message == WM_QUERYOPEN )
  1704. {
  1705. if( m_pDockSite != NULL )
  1706. {
  1707. _DelayUpdateMenuBar();
  1708. // m_bDelayedUpdateMenuBar = true;
  1709. // SetWindowPos(
  1710. // NULL, 0, 0, 0, 0,
  1711. // SWP_FRAMECHANGED
  1712. // |SWP_NOMOVE|SWP_NOSIZE|SWP_NOCOPYBITS
  1713. // |SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOACTIVATE
  1714. // );
  1715. // SetTimer( 14, 100, NULL );
  1716. }
  1717. return FALSE;
  1718. } // if( pMsg->message == WM_QUERYOPEN )
  1720. // BEGIN: fix for the bug reported by Vitaly Murashev
  1721. HWND hWndMainFrame = _GetHwndMainFrame();
  1722. if( (! m_bPresubclassDialogMode )
  1723. && ( hWndMainFrame == NULL
  1724. || (! ::IsWindow( hWndMainFrame ) )
  1725. || (! ::IsWindowEnabled( hWndMainFrame ) )
  1726. )
  1727. )
  1728. return FALSE;
  1729. // END: fix for the bug reported by Vitaly Murashev
  1731. if( pMsg->message == WM_ACTIVATE
  1732. || pMsg->message == WM_ACTIVATEAPP
  1733. || pMsg->message == WM_SETFOCUS
  1734. || pMsg->message == WM_KILLFOCUS
  1735. )
  1736. {
  1737. m_bHelperTrackingCharCode = false;
  1738. g_bCancelNearestAltUp = true;
  1739. return FALSE;
  1740. } // if( pMsg->message == WM_ACTIVATE ...
  1742. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1743. CExtCustomizeSite * pSite = GetCustomizeSite();
  1744. if( pSite != NULL )
  1745. {
  1746. if( pSite->GetCustomizeDropSource() != NULL )
  1747. return FALSE;
  1748. if( WM_KEYFIRST <= pMsg->message
  1749. && pMsg->message <= WM_KEYLAST
  1750. && pSite->IsCustomizeMode()
  1751. && (! CExtPopupMenuWnd::IsMenuTracking() )
  1752. )
  1753. return TRUE;
  1754. } // if( pSite != NULL )
  1755. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  1757. bool bDockSiteCustomizeMode =
  1758. _IsDockSiteCustomizeMode();
  1760. if( _IsMdiApp() )
  1761. {
  1762. if( ( pMsg->message == WM_COMMAND
  1763. && ( (LOWORD(pMsg->wParam)) == ID_NEXT_PANE
  1764. || (LOWORD(pMsg->wParam)) == ID_PREV_PANE
  1765. || (LOWORD(pMsg->wParam)) == ID_WINDOW_NEW
  1766. || (LOWORD(pMsg->wParam)) == ID_WINDOW_ARRANGE
  1767. || (LOWORD(pMsg->wParam)) == ID_WINDOW_CASCADE
  1768. || (LOWORD(pMsg->wParam)) == ID_WINDOW_TILE_HORZ
  1769. || (LOWORD(pMsg->wParam)) == ID_WINDOW_TILE_VERT
  1770. || (LOWORD(pMsg->wParam)) == ID_WINDOW_SPLIT
  1771. )
  1772. )
  1773. || pMsg->message == WM_MDIACTIVATE
  1774. || pMsg->message == WM_MDINEXT
  1775. || pMsg->message == WM_MDIRESTORE
  1776. || pMsg->message == WM_MDIMAXIMIZE
  1777. || pMsg->message == WM_MDITILE
  1778. || pMsg->message == WM_MDICASCADE
  1779. || pMsg->message == WM_MDIICONARRANGE
  1780. )
  1781. {
  1782. if( bDockSiteCustomizeMode )
  1783. return TRUE;
  1784. if( IsOleIpObjActive() )
  1785. return TRUE;
  1786. }
  1787. } // if( _IsMdiApp() )
  1790. bool bPrintPreviewMode = false;
  1791. if( (!m_bPresubclassDialogMode)
  1792. && (!bDockSiteCustomizeMode)
  1793. && m_pDockSite->GetSafeHwnd() != NULL
  1794. && FindPrintPreviewMode(m_pDockSite)
  1795. )
  1796. bPrintPreviewMode = true;
  1797. bool bComboDropDownTracking = false;
  1798. CWnd * pWndCurrFocus = CWnd::GetFocus();
  1799. if( pWndCurrFocus != NULL )
  1800. {
  1801. if( pWndCurrFocus->IsKindOf(RUNTIME_CLASS(CComboBox)) )
  1802. {
  1803. if( (pWndCurrFocus->GetStyle() & (CBS_DROPDOWN|CBS_DROPDOWNLIST)) != 0
  1804. && ((CComboBox *)pWndCurrFocus)->GetDroppedState()
  1805. )
  1806. bComboDropDownTracking = true;
  1807. }
  1808. else
  1809. {
  1810. pWndCurrFocus = pWndCurrFocus->GetParent();
  1811. if( pWndCurrFocus != NULL )
  1812. {
  1813. if( pWndCurrFocus->IsKindOf(RUNTIME_CLASS(CComboBox)) )
  1814. {
  1815. if( (pWndCurrFocus->GetStyle() & (CBS_DROPDOWN|CBS_DROPDOWNLIST)) != 0
  1816. && ((CComboBox *)pWndCurrFocus)->GetDroppedState()
  1817. )
  1818. bComboDropDownTracking = true;
  1819. }
  1820. }
  1821. }
  1822. }
  1824. UINT nMsg = pMsg->message;
  1826. if( nMsg == WM_COMMAND
  1827. && HIWORD( pMsg->wParam ) == 0
  1828. ) // (+ v.2.24)
  1829. {
  1830. bool bAlt = ( (::GetAsyncKeyState(VK_MENU)&0x8000) != 0 ) ? true : false;
  1831. g_bCancelNearestAltUp = bAlt;
  1832. }
  1834. if(    nMsg == WM_SYSKEYDOWN
  1835. || nMsg == WM_SYSKEYUP
  1836. || nMsg == WM_KEYDOWN
  1837. || nMsg == WM_KEYUP
  1838. )
  1839. {
  1840. BOOL bKeyUp = ( nMsg == WM_KEYUP || nMsg == WM_SYSKEYUP) ? TRUE : FALSE;
  1841. BOOL bCtrl = ::GetKeyState(VK_CONTROL) & 0x80000000;
  1842. BOOL bShift = ::GetKeyState(VK_SHIFT) & 0x80000000;
  1843. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN;
  1844. TCHAR vkTCHAR = (TCHAR)pMsg->wParam;
  1846. if( pMsg->wParam == VK_MENU && m_bHelperTrackingCharCode && bKeyUp )
  1847. {
  1848. m_bHelperTrackingCharCode = false;
  1849. return FALSE;
  1850. }
  1851. if( bAlt && pMsg->wParam != VK_MENU )
  1852. {
  1853. if( ( VK_NUMPAD0 <= pMsg->wParam && pMsg->wParam <= VK_NUMPAD9 )
  1854. || pMsg->wParam == VK_INSERT // 0
  1855. || pMsg->wParam == VK_END    // 1
  1856. || pMsg->wParam == VK_DOWN   // 2
  1857. || pMsg->wParam == VK_NEXT   // 3
  1858. || pMsg->wParam == VK_LEFT   // 4
  1859. || pMsg->wParam == 0x0C      // 5, VK_CLEAR
  1860. || pMsg->wParam == VK_RIGHT  // 8
  1861. || pMsg->wParam == VK_HOME   // 7
  1862. || pMsg->wParam == VK_UP     // 8
  1863. || pMsg->wParam == VK_PRIOR  // 9
  1864. )
  1865. m_bHelperTrackingCharCode = g_bCancelNearestAltUp = true;
  1866. else
  1867. m_bHelperTrackingCharCode = false;
  1868. }
  1869. if( m_bHelperTrackingCharCode )
  1870. return FALSE;
  1872. if( ( ! bDockSiteCustomizeMode ) && GetSafeHwnd() != NULL )
  1873. { // help key processing
  1874. const ACCEL * pAccel = _GetTranslatedContextHelpAccel();
  1875. CPoint ptCursor( LONG_MAX, LONG_MAX );
  1876. HWND hWndFromPoint = NULL;
  1877. CWnd * pWndFromPointPermanent = NULL;
  1878. CExtToolControlBar * pToolBarFromPoint = NULL;
  1879. int nHitTestButtonIndex = -1;
  1880. CExtBarButton * pHitTestTBB = NULL;
  1881. UINT nHitTestCmdID = ID_SEPARATOR;
  1882. LPCTSTR strBarCmdProfileName = NULL;
  1883. CExtCmdItem * pHitTestCmdItem = NULL;
  1884. if( pAccel != NULL
  1885. && pMsg->wParam == WPARAM(pAccel->key)
  1886. && (pAccel->fVirt&(FSHIFT|FCONTROL|FALT)) ==
  1887. ( 0
  1888. | ( bShift ? (FSHIFT) : 0 )
  1889. | ( bCtrl ? (FCONTROL) : 0 )
  1890. | ( bAlt ? (FALT) : 0 )
  1891. )
  1892. && ::GetCursorPos( &ptCursor )
  1893. && ( hWndFromPoint = ::WindowFromPoint( ptCursor ) ) != NULL
  1894. && ( pWndFromPointPermanent = CWnd::FromHandlePermanent( hWndFromPoint ) ) != NULL
  1895. && ( pToolBarFromPoint = DYNAMIC_DOWNCAST( CExtToolControlBar, pWndFromPointPermanent ) ) != NULL
  1896. && ( ( m_pDockSite != NULL )
  1897. ? ( m_pDockSite == pToolBarFromPoint->m_pDockSite )
  1898. : ( GetParent() == pToolBarFromPoint->GetParent() )
  1899. )
  1900. && ( strBarCmdProfileName = g_CmdManager->ProfileNameFromWnd( hWndFromPoint ) ) != NULL
  1901. //&& _tcscmp( g_CmdManager->ProfileNameFromWnd( hWndFromPoint ), g_CmdManager->ProfileNameFromWnd( m_hWnd ) ) == NULL
  1902. && ::ScreenToClient( hWndFromPoint, &ptCursor )
  1903. && ( nHitTestButtonIndex = pToolBarFromPoint->HitTest( ptCursor ) ) >= 0
  1904. && ( pHitTestTBB = pToolBarFromPoint->GetButton( nHitTestButtonIndex ) ) != NULL
  1905. && ( ! pHitTestTBB->IsKindOf( RUNTIME_CLASS( CExtBarMdiDocButton ) ) )
  1906. //&& ( ! pHitTestTBB->IsKindOf( RUNTIME_CLASS( CExtBarContentExpandButton ) ) )
  1907. && ( nHitTestCmdID = pHitTestTBB->GetCmdID( false ) ) != ID_SEPARATOR
  1908. && ( pHitTestCmdItem = g_CmdManager->CmdGetPtr( strBarCmdProfileName, nHitTestCmdID ) ) != NULL
  1909. && ( ! pHitTestCmdItem->StateIsMenubarTemp() )
  1910. )
  1911. {
  1912. if( ! bKeyUp )
  1913. ::AfxGetApp()->WinHelp( nHitTestCmdID, HELP_CONTEXT );
  1914. return TRUE;
  1915. } // if( pAccel != NULL ...
  1916. } // help key processing
  1918. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  1919. if( m_bFlatTracking
  1920. && KeyTipsDisplayedGet()
  1921. && ( ( _T('A') <= vkTCHAR && vkTCHAR <= _T('Z') )
  1922. || ( _T('0') <= vkTCHAR && vkTCHAR <= _T('9') )
  1923. )
  1924. )
  1925. {
  1926. if( bKeyUp )
  1927. return TRUE;
  1928. bool bActionInvoked = false;
  1929. bool bContinueKeyTipMode = false;
  1930. CExtCustomizeCmdKeyTip & keyTipChain = KeyTipChainGet();
  1931. if( KeyTipTranslate(
  1932. (DWORD)pMsg->wParam,
  1933. &keyTipChain,
  1934. true,
  1935. bActionInvoked,
  1936. bContinueKeyTipMode
  1937. ) >= 0
  1938. )
  1939. {
  1940. if( bActionInvoked
  1941. && ( ! bContinueKeyTipMode )
  1942. //&& ( ! CExtPopupMenuWnd::IsMenuTracking() )
  1943. )
  1944. {
  1945. if( m_bFlatTracking )
  1946. {
  1947. m_bFlatTracking = false;
  1948. OnFlatTrackingStop();
  1949. } // if( m_bFlatTracking )
  1950. _UpdateFlatTracking( FALSE );
  1951. }
  1952. else
  1953. KeyTipDisplay( keyTipChain );
  1954. //return TRUE;
  1955. }
  1956. return TRUE;
  1957. }
  1958. #endif // from (!defined __EXT_MFC_NO_CUSTOMIZE)
  1960. if( bAlt
  1961. && (! m_bFlatTracking )
  1962. && ( nMsg != WM_SYSKEYDOWN
  1963. && nMsg != WM_SYSKEYUP
  1964. )
  1965. && ( vkTCHAR == VK_NUMPAD0
  1966. || vkTCHAR == VK_NUMPAD1
  1967. || vkTCHAR == VK_NUMPAD2
  1968. || vkTCHAR == VK_NUMPAD3
  1969. || vkTCHAR == VK_NUMPAD4
  1970. || vkTCHAR == VK_NUMPAD5
  1971. || vkTCHAR == VK_NUMPAD6
  1972. || vkTCHAR == VK_NUMPAD7
  1973. || vkTCHAR == VK_NUMPAD8
  1974. || vkTCHAR == VK_NUMPAD9
  1975. || vkTCHAR == 0x2D
  1976. || vkTCHAR == 0x22
  1977. || vkTCHAR == 0x28
  1978. || vkTCHAR == 0x22
  1979. || vkTCHAR == 0x25
  1980. || vkTCHAR == 0x0C
  1981. || vkTCHAR == 0x27
  1982. || vkTCHAR == 0x24
  1983. || vkTCHAR == 0x26
  1984. || vkTCHAR == 0x21
  1985. )
  1986. )
  1987. {
  1988. g_bKeyCodeTracking = true;
  1989. g_bCancelNearestAltUp = false;
  1990. return FALSE;
  1991. }
  1992. if( g_bKeyCodeTracking )
  1993. {
  1994. g_bKeyCodeTracking = false;
  1995. return FALSE;
  1996. }
  1998. if( vkTCHAR == VK_MENU && (!bCtrl) && (!bShift) )
  1999. { // only VK_MENU pressed
  2000. if( bDockSiteCustomizeMode )
  2001. return TRUE;
  2002. if( bPrintPreviewMode
  2003. || bComboDropDownTracking
  2004. )
  2005. return FALSE;
  2007. if( m_bFlatTracking ) // (+ v.2.23)
  2008. {
  2009. if( ! bKeyUp )
  2010. return TRUE;
  2011. _CancelFlatTracking();
  2012. return TRUE;
  2013. } // if( m_bFlatTracking )
  2015. if( !bKeyUp )
  2016. {
  2017. g_bCancelNearestAltUp = false;
  2018. return FALSE; // (+ v.2.23)
  2019. }
  2020. if( g_bCancelNearestAltUp
  2021. || g_bMenuTracking
  2022. || GetButtonsCount() == 0
  2023. )
  2024. {
  2025. if( g_bCancelNearestAltUp ) // (+ v.2.23)
  2026. return FALSE;
  2027. return TRUE;
  2028. }
  2029. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2030. {
  2031. HWND hWndFocus = ::GetFocus();
  2032. if( hWndFocus != NULL )
  2033. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  2034. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2035. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  2037. if( hWndMainFrame != NULL )
  2038. {
  2039. CWnd * pWndForPlacement = stat_GetWndForPlacement( CWnd::FromHandle(hWndMainFrame) );
  2040. HWND hWndForeground = ::GetForegroundWindow();
  2041. bool bCancelButtonTracking = true;
  2042. if( hWndMainFrame == hWndForeground
  2043. || hWndMainFrame == pWndForPlacement->m_hWnd
  2044. )
  2045. bCancelButtonTracking = false;
  2046. else if(
  2047. (::__EXT_MFC_GetWindowLong(hWndMainFrame,GWL_STYLE)&WS_CHILD) != 0
  2048. && ::IsChild( hWndForeground, hWndMainFrame )
  2049. )
  2050. bCancelButtonTracking = false;
  2051. else
  2052. {
  2053. for( HWND hWnd = ::GetParent( hWndForeground );
  2054. hWnd != NULL;
  2055. hWnd = ::GetParent( hWnd )
  2056. )
  2057. {
  2058. if( hWnd == hWndMainFrame
  2059. || hWnd == pWndForPlacement->m_hWnd
  2060. )
  2061. {
  2062. bCancelButtonTracking = false;
  2063. break;
  2064. } // if( hWnd == hWndMainFrame ...
  2065. }
  2066. }
  2067. if( bCancelButtonTracking )
  2068. return TRUE;
  2069. } // if( hWndMainFrame != NULL )
  2071. INT nStartFlatIndex = OnCalcFlatTrackingIndex( vkTCHAR, -1 );
  2072. if( nStartFlatIndex < 0 )
  2073. {
  2074. INT nIndex, nCount = GetButtonsCount();
  2075. for( nIndex = 0; nIndex < nCount; nIndex ++ )
  2076. {
  2077. CExtBarButton * pTBB = GetButton( nIndex );
  2078. ASSERT_VALID( pTBB );
  2079. if( pTBB->OnQueryFlatTrackingEnabled() )
  2080. {
  2081. nStartFlatIndex = nIndex;
  2082. break;
  2083. }
  2084. }
  2085. } // if( nStartFlatIndex < 0 )
  2086. if( nStartFlatIndex >= 0 )
  2087. {
  2088. TrackButtonMenu( nStartFlatIndex );
  2089. return TRUE;
  2090. } // if( nStartFlatIndex >= 0 )
  2091. else
  2092. return FALSE;
  2093. } // only VK_MENU pressed
  2095. if( (! m_bPresubclassDialogMode )
  2096. && bAlt
  2097. && (  vkTCHAR == VK_SPACE
  2098. || ( _IsMdiApp() // (+ v.2.23)
  2099. && ( vkTCHAR == VK_SUBTRACT
  2100. // disable warning C4310: cast truncates constant value
  2101. #pragma warning( push )
  2102. #pragma warning( disable : 4310 )
  2103. || vkTCHAR == ((TCHAR)0xbd) // '-' near '0'
  2104. // rollback warning C4310: cast truncates constant value
  2105. #pragma warning( pop )
  2106. )
  2107. )
  2108. )
  2109. )
  2110. {
  2111. if( bDockSiteCustomizeMode )
  2112. return TRUE;
  2113. if( bKeyUp )
  2114. return TRUE;
  2115. // allow child popup track it's system menu
  2116. CWnd * pWnd = CWnd::GetActiveWindow();
  2117. if( pWnd == NULL
  2118. || (!(::IsWindow(pWnd->GetSafeHwnd())))
  2119. )
  2120. return TRUE;
  2121. if( pWnd->GetSafeHwnd() != _GetDockingFrameImpl()->GetSafeHwnd()
  2122. && (pWnd->GetStyle() & WS_POPUP) != 0
  2123. )
  2124. return TRUE;
  2126. // track frame system menu
  2127. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  2128. if( !_IsDockSiteCustomizeMode() )
  2129. {
  2130. _CancelFlatTracking();
  2131. if( vkTCHAR == VK_SPACE )
  2132. {
  2133. if( ! TrackMainFrameSystemMenu( NULL, TRUE ) )
  2134. return FALSE;
  2135. } // if( vkTCHAR == VK_SPACE )
  2136. else
  2137. {
  2138. ASSERT( _IsMdiApp() ); // (+ v.2.23)
  2139. if(    nMsg == WM_KEYDOWN
  2140. || nMsg == WM_KEYUP
  2141. )
  2142. return TRUE;
  2143. BOOL bMax = FALSE;
  2144. HWND hWndActiveChild = _GetActiveMdiChildWnd( bMax );
  2145. if( hWndActiveChild == NULL )
  2146. {
  2147. if( !bKeyUp )
  2148. g_bCancelNearestAltUp = true;
  2149. return TRUE;
  2150. }
  2151. bool bExplicitTrackChildFrameSystemMenu = true;
  2152. if( GetButtonsCount() > 0 )
  2153. {
  2154. CExtBarButton * pTBB = _GetButtonPtr( 0 );
  2155. ASSERT_VALID( pTBB );
  2156. if( pTBB->IsKindOf(RUNTIME_CLASS(CExtBarMdiDocButton)) )
  2157. {
  2158. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2159. {
  2160. HWND hWndFocus = ::GetFocus();
  2161. if( hWndFocus != NULL )
  2162. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  2163. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2164. VERIFY( CExtToolControlBar::TrackButtonMenu( 0 ) );
  2165. bExplicitTrackChildFrameSystemMenu = false;
  2166. } // if( pTBB->IsKindOf(RUNTIME_CLASS(CExtBarMdiDocButton)) )
  2167. } // if( GetButtonsCount() > 0 )
  2168. if( bExplicitTrackChildFrameSystemMenu )
  2169. if( ! TrackChildFrameSystemMenu( NULL, TRUE ) )
  2170. return FALSE;
  2171. } // else from if( vkTCHAR == VK_SPACE )
  2172. }
  2173. return TRUE;
  2174. } // if( ( !m_bPresubclassDialogMode ) && bAlt && vkTCHAR == VK_SPACE )
  2176. if( ( bPrintPreviewMode || bComboDropDownTracking )
  2177. && (! bDockSiteCustomizeMode )
  2178. )
  2179. return FALSE;
  2181. if( ( bAlt
  2182. || ( m_bFlatTracking
  2183. && vkTCHAR != VK_LEFT
  2184. && vkTCHAR != VK_RIGHT
  2185. && vkTCHAR != VK_UP
  2186. && vkTCHAR != VK_DOWN
  2187. && vkTCHAR != VK_F4
  2188. && vkTCHAR != VK_RETURN
  2189. && vkTCHAR != VK_SPACE
  2190. && vkTCHAR != VK_ESCAPE
  2191. && vkTCHAR != VK_TAB
  2192. )
  2193. )
  2194. && (!bDockSiteCustomizeMode)
  2195. )
  2196. { // if VK_ALT + VK_... pressed
  2197. // if( g_bCancelNearestAltUp ) // (+ v.2.23)
  2198. // return FALSE;
  2199. if( bKeyUp )
  2200. {
  2201. if( m_bHelperTrackingCharCode )
  2202. return FALSE;
  2203. return TRUE;
  2204. }
  2205. BYTE lpKeyState[256];
  2206. ::GetKeyboardState( lpKeyState );
  2207. UINT wScanCode = ::MapVirtualKey( vkTCHAR, 0 );
  2208. HKL hKeyboardLayout =
  2209. ::GetKeyboardLayout(
  2210. ( ::AfxGetThread() ) -> m_nThreadID
  2211. );
  2212. #if (defined _UNICODE)
  2213. TCHAR szChar[2] = { _T(''), _T('') };
  2214. ::ToUnicodeEx( vkTCHAR, wScanCode, lpKeyState, szChar, 1, 1, hKeyboardLayout );
  2215. #else
  2216. WORD nMapped = 0;
  2217. ::ToAsciiEx( vkTCHAR, wScanCode, lpKeyState, &nMapped, 1, hKeyboardLayout );
  2218. TCHAR szChar[2] = { (TCHAR)nMapped, _T('') };
  2219. #endif
  2220. ::CharUpper( szChar );
  2222. int nBtnIdx = -1;
  2223. if( szChar[0] != 0 )
  2224. {
  2225. nBtnIdx = GetButtonByAccessKey( szChar[0] );
  2226. if( nBtnIdx < 0 )
  2227. {
  2228. CPtrList _listVisibleToolBars;
  2229. CFrameWnd * pDockSite = m_pDockSite;
  2230. if( pDockSite == NULL )
  2231. pDockSite =
  2232. DYNAMIC_DOWNCAST(
  2233. CFrameWnd,
  2234. GetParent()
  2235. );
  2236. if( pDockSite != NULL )
  2237. {
  2238. ExtControlBarVector_t vBars;
  2239. ((const CExtControlBar *)this)->_GetFrameControlBars(
  2240. false,
  2241. vBars,
  2242. __GFECB_FIXED|__GFECB_NONFIXED|__GFECB_DOCKED|__GFECB_FLOATED|__GFECB_VIS_ALL
  2243. );
  2244. for( int i = 0; i < vBars.GetSize(); i++ )
  2245. {
  2246. CExtToolControlBar * pToolBar =
  2247. DYNAMIC_DOWNCAST(
  2248. CExtToolControlBar,
  2249. vBars[i]
  2250. );
  2251. if( pToolBar->GetSafeHwnd() == NULL
  2252. || pToolBar == this
  2253. )
  2254. continue;
  2255. ASSERT_VALID( pToolBar );
  2256. ASSERT( pToolBar->IsVisible() );
  2257. _listVisibleToolBars.AddTail( pToolBar );
  2258. }
  2259. } // if( pDockSite != NULL )
  2260. else
  2261. {
  2262. for( CWnd * pWnd = GetParent()->GetWindow( GW_CHILD );
  2263. pWnd != NULL;
  2264. pWnd = pWnd->GetWindow( GW_HWNDNEXT )
  2265. )
  2266. {
  2267. CExtToolControlBar * pToolBar =
  2268. DYNAMIC_DOWNCAST(
  2269. CExtToolControlBar,
  2270. pWnd
  2271. );
  2272. if( pToolBar->GetSafeHwnd() == NULL
  2273. || pToolBar == this
  2274. )
  2275. continue;
  2276. ASSERT_VALID( pToolBar );
  2277. if( ! pToolBar->IsVisible() )
  2278. continue;
  2279. _listVisibleToolBars.AddTail( pToolBar );
  2280. }
  2281. } // else from if( pDockSite != NULL )
  2282. for( POSITION pos = _listVisibleToolBars.GetHeadPosition();
  2283. pos != NULL;
  2284. )
  2285. {
  2286. CExtToolControlBar * pToolBar = (CExtToolControlBar *)
  2287. _listVisibleToolBars.GetNext( pos );
  2288. int nBtnIdx = pToolBar->GetButtonByAccessKey( szChar[0] );
  2289. if( nBtnIdx < 0 )
  2290. continue;
  2291. CExtBarButton * pTBB = pToolBar->GetButton( nBtnIdx );
  2292. ASSERT_VALID( pTBB );
  2293. ASSERT( !pTBB->IsSeparator() );
  2294. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2295. {
  2296. HWND hWndFocus = ::GetFocus();
  2297. if( hWndFocus != NULL )
  2298. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  2299. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2300. _CancelFlatTracking();
  2301. if( pTBB->IsAbleToTrackMenu() )
  2302. {
  2303. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  2304. pToolBar->TrackButtonMenu(
  2305. nBtnIdx,
  2306. true,
  2307. false,
  2308. m_bUseFastKeyboardMenuTracking
  2309. );
  2310. } // if( pTBB->IsAbleToTrackMenu() )
  2311. else
  2312. {
  2313. g_bCancelNearestAltUp =
  2314. CExtPopupMenuWnd::IsKeyPressed( VK_MENU )
  2315. ? true : false;
  2316. pTBB->OnDeliverCmd();
  2317. } // else from if( pTBB->IsAbleToTrackMenu() )
  2318. return TRUE;
  2319. }
  2320. g_bCancelNearestAltUp = true; // (+ v.2.24)
  2321. return FALSE;
  2322. } // if( nBtnIdx < 0 )
  2323. else
  2324. {
  2325. CExtBarButton * pTBB = CExtToolControlBar::GetButton( nBtnIdx );
  2326. ASSERT_VALID( pTBB );
  2327. ASSERT( !pTBB->IsSeparator() );
  2328. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2329. {
  2330. HWND hWndFocus = ::GetFocus();
  2331. if( hWndFocus != NULL )
  2332. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  2333. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2334. _CancelFlatTracking();
  2335. if( pTBB->IsAbleToTrackMenu() )
  2336. {
  2337. CExtToolControlBar::g_bMenuTrackingExpanded = false;
  2338. CExtToolControlBar::TrackButtonMenu(
  2339. nBtnIdx,
  2340. true,
  2341. false,
  2342. m_bUseFastKeyboardMenuTracking
  2343. );
  2344. } // if( pTBB->IsAbleToTrackMenu() )
  2345. else
  2346. {
  2347. g_bCancelNearestAltUp =
  2348. CExtPopupMenuWnd::IsKeyPressed( VK_MENU )
  2349. ? true : false;
  2350. pTBB->OnDeliverCmd();
  2351. } // else from if( pTBB->IsAbleToTrackMenu() )
  2352. return TRUE;
  2353. } // else from if( nBtnIdx < 0 )
  2354. } // if( szChar[0] != 0 )
  2355. g_bCancelNearestAltUp = true; // (+ v.2.23)
  2356. if( m_bFlatTracking ) // (+ v.2.25)
  2357. {
  2358. if( bAlt && m_bFlatTracking && ( vkTCHAR == VK_DOWN || vkTCHAR == VK_UP ) )
  2359. {
  2360. }
  2361. else
  2362. return TRUE;
  2363. }
  2364. else
  2365. return FALSE;
  2366. } // if( (bAlt || m_bFlatTracking) && (!bDockSiteCustomizeMode) )
  2368. if( m_bFlatTracking && (!bDockSiteCustomizeMode) )
  2369. {
  2370. if( bKeyUp )
  2371. return TRUE;
  2372. #if (!defined __EXT_MFC_NO_CUSTOMIZE)
  2373. if( vkTCHAR == VK_LEFT
  2374. || vkTCHAR == VK_RIGHT
  2375. || vkTCHAR == VK_UP
  2376. || vkTCHAR == VK_DOWN
  2377. || vkTCHAR == VK_TAB
  2378. || vkTCHAR == VK_SPACE
  2379. || vkTCHAR == VK_ESCAPE
  2380. || vkTCHAR == VK_RETURN
  2381. || ( VK_F1 <= vkTCHAR && vkTCHAR <= VK_F24 )
  2382. )
  2383. {
  2384. HDWP hPassiveModeDWP = NULL;
  2385. int nBtnIdx, nCountOfButtons = _GetButtonsCountImpl();
  2386. for( nBtnIdx = 0; nBtnIdx < nCountOfButtons; nBtnIdx++ )
  2387. {
  2388. CExtBarButton * pTBB = _GetButtonPtr( nBtnIdx );
  2389. ASSERT_VALID( pTBB );
  2390. pTBB->OnKeyTipTrackingQuery( false, NULL, hPassiveModeDWP );
  2391. }
  2392. }
  2393. #endif // (!defined __EXT_MFC_NO_CUSTOMIZE)
  2394. bool bUpdateIndex = false;
  2395. TCHAR _vkTCHAR = vkTCHAR;
  2396. if( ( vkTCHAR == VK_DOWN || vkTCHAR == VK_UP )
  2397. && bAlt
  2398. )
  2399. _vkTCHAR = VK_F4;
  2400. int nNewCustomFlatTrackingIndex =
  2401. OnCalcFlatTrackingIndex(
  2402. INT(_vkTCHAR ),
  2403. INT( TCHAR( m_nFlatTrackingIndex ) )
  2404. );
  2405. if( nNewCustomFlatTrackingIndex >= 0 )
  2406. {
  2407. m_nFlatTrackingIndex = nNewCustomFlatTrackingIndex;
  2408. bUpdateIndex = true;
  2409. } // if( nNewCustomFlatTrackingIndex >= 0 )
  2410. else
  2411. {
  2412. if( _vkTCHAR == VK_TAB )
  2413. {
  2414. if( bShift )
  2415. _vkTCHAR = VK_LEFT;
  2416. else
  2417. _vkTCHAR = VK_RIGHT;
  2418. } // if( _vkTCHAR == VK_TAB )
  2419. switch( _vkTCHAR )
  2420. {
  2421. case VK_LEFT:
  2422. bUpdateIndex = true;
  2423. m_nFlatTrackingIndex =
  2424. GetVisibleButton(
  2425. m_nFlatTrackingIndex,
  2426. FALSE
  2427. );
  2428. break;
  2429. case VK_RIGHT:
  2430. bUpdateIndex = true;
  2431. m_nFlatTrackingIndex =
  2432. GetVisibleButton(
  2433. m_nFlatTrackingIndex,
  2434. TRUE
  2435. );
  2436. break;
  2437. case VK_SPACE:
  2438. case VK_RETURN:
  2439. case VK_F4:
  2440. case VK_UP:
  2441. case VK_DOWN:
  2442. {
  2443. if( CExtPopupMenuWnd::IsMenuTracking()
  2444. || m_nFlatTrackingIndex < 0
  2445. )
  2446. return TRUE;
  2447. ASSERT( m_nFlatTrackingIndex < GetButtonsCount() );
  2448. CExtBarButton * pTBB =
  2449. _GetButtonPtr(m_nFlatTrackingIndex);
  2450. ASSERT_VALID( pTBB );
  2451. if( pTBB->IsAbleToTrackMenu() )
  2452. {
  2453. if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2454. {
  2455. HWND hWndFocus = ::GetFocus();
  2456. if( hWndFocus != NULL )
  2457. ::SendMessage( hWndFocus, WM_CANCELMODE, 0L, 0L );
  2458. } // if( ! CExtPopupMenuWnd::IsMenuTracking() )
  2459. int nIndex = m_nFlatTrackingIndex;
  2460. if( m_bFlatTracking )
  2461. {
  2462. m_bFlatTracking = false;
  2463. OnFlatTrackingStop();
  2464. } // if( m_bFlatTracking )
  2465. _UpdateFlatTracking( FALSE );
  2466. CExtToolControlBar::TrackButtonMenu(
  2467. nIndex,
  2468. true,
  2469. false,
  2470. m_bUseFastKeyboardMenuTracking
  2471. );
  2472. }
  2473. else
  2474. {
  2475. if( ( vkTCHAR == VK_RETURN || vkTCHAR == VK_SPACE )
  2476. // && CExtCmdManager::IsCommand(
  2477. // pTBB->GetCmdID(true)
  2478. // )
  2479. )
  2480. {
  2481. pTBB->OnClick( CPoint(0,0), false );
  2482. }
  2483. if( m_bFlatTracking )
  2484. {
  2485. m_bFlatTracking = false;
  2486. OnFlatTrackingStop();
  2487. } // if( m_bFlatTracking )
  2488. _UpdateFlatTracking();
  2489. }
  2490. return TRUE;
  2491. }
  2492. break;
  2493. case VK_ESCAPE:
  2494. if( m_bFlatTracking )
  2495. {
  2496. m_bFlatTracking = false;
  2497. OnFlatTrackingStop();
  2498. } // if( m_bFlatTracking )
  2499. _UpdateFlatTracking();
  2500. return TRUE;
  2501. } // switch( _vkTCHAR )
  2502. } // else from if( nNewCustomFlatTrackingIndex >= 0 )
  2503. if( bUpdateIndex )
  2504. {
  2505. int nCountOfButtons = GetButtonsCount();
  2506. ASSERT( nCountOfButtons > 0 );
  2507. if( m_nFlatTrackingIndex < 0 )
  2508. m_nFlatTrackingIndex = nCountOfButtons - 1;
  2509. else if(m_nFlatTrackingIndex >= nCountOfButtons)
  2510. m_nFlatTrackingIndex = 0;
  2511. }
  2512. _UpdateFlatTracking();
  2513. return TRUE;
  2514. } // if( m_bFlatTracking && (!bDockSiteCustomizeMode) )
  2516. }
  2518. if( nMsg == WM_CONTEXTMENU )
  2519. {
  2520. if( g_bMenuTracking || m_bFlatTracking || bDockSiteCustomizeMode )
  2521. return TRUE;
  2522. }
  2524. if( m_bFlatTracking && (!bDockSiteCustomizeMode) )
  2525. {
  2526. if( (nMsg >= __EXT_MFC_WM_MOUSEFIRST && nMsg <= __EXT_MFC_WM_MOUSELAST)
  2527. && nMsg != WM_MOUSEMOVE
  2528. )
  2529. _CancelFlatTracking();
  2530. } // if( m_bFlatTracking && (!bDockSiteCustomizeMode) )
  2532. return FALSE;
  2533. }
  2535. CRect CExtMenuControlBar::_GetChildFrameSysIconRect()
  2536. {
  2537. CRect rc;
  2538. rc.SetRectEmpty();
  2539. BOOL bMax = FALSE;
  2540. HWND hWndActiveChild =
  2541. _GetActiveMdiChildWnd( bMax );
  2542. if( hWndActiveChild == NULL )
  2543. return rc;
  2544. ASSERT( ::IsWindow(hWndActiveChild) );
  2545. if( bMax )
  2546. return rc;
  2547. CWnd * pWnd = CWnd::FromHandlePermanent(hWndActiveChild);
  2548. if( pWnd == NULL )
  2549. {
  2550. ASSERT( FALSE );
  2551. return rc;
  2552. }
  2553. ASSERT_VALID( pWnd );
  2555. // FrameFeatures does not use CMDIChildWnd
  2556. // ASSERT( pWnd->IsKindOf(RUNTIME_CLASS(CMDIChildWnd)) );
  2557. //CFrameWnd * pFrame = 
  2558. // DYNAMIC_DOWNCAST(
  2559. // CFrameWnd,
  2560. // pWnd
  2561. // );
  2562. // ASSERT( pFrame != NULL );
  2563. // if( pFrame == NULL )
  2564. // {
  2565. // ASSERT( FALSE );
  2566. // return rc;
  2567. // }
  2568. // ASSERT_VALID( pFrame );
  2570. CRect rcWnd,rcClient,rcHelper;
  2571. pWnd->GetWindowRect( &rcWnd );
  2572. pWnd->GetClientRect( &rcClient );
  2573. rcHelper = rcWnd;
  2574. pWnd->ScreenToClient( &rcHelper );
  2575. ASSERT( rcHelper.top <= rcClient.top );
  2576. int yDiff = rcClient.top - rcHelper.top;
  2577. rc.SetRect(
  2578. rcWnd.left + GetSystemMetrics(SM_CYFRAME),
  2579. rcWnd.top + GetSystemMetrics(SM_CXFRAME),
  2580. rcWnd.left + yDiff,
  2581. rcWnd.top + yDiff
  2582. );