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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 菜单 > 查看源码
MenuBar.cpp
资源名称：dockmenubar_demo.zip　[点击查看]
上传用户：liudazhe
上传日期：2007-01-02
资源大小：51k
文件大小：58k
源码类别：

菜单

开发平台：

Visual C++

MenuBar.cpp：源码内容
  1. // MenuBar.cpp : 
  2. //
  4. #include "stdafx.h"
  5. #include "MenuBar.h"
  6. #include "resource.h"
  8. #include <afxpriv.h>
  10. // pasted from MFC source
  11. #define _AfxGetDlgCtrlID(hWnd)          ((UINT)(WORD)::GetDlgCtrlID(hWnd))
  13. #define HORZF(dw) (dw & CBRS_ORIENT_HORZ)
  14. #define VERTF(dw) (dw & CBRS_ORIENT_VERT)
  16. static void AdjustRectangle(CRect& rect, CPoint pt)
  17. {
  18. int nXOffset = (pt.x < rect.left) ? (pt.x - rect.left) :
  19. (pt.x > rect.right) ? (pt.x - rect.right) : 0;
  20. int nYOffset = (pt.y < rect.top) ? (pt.y - rect.top) :
  21. (pt.y > rect.bottom) ? (pt.y - rect.bottom) : 0;
  22. rect.OffsetRect(nXOffset, nYOffset);
  23. }
  25. #include <math.h>
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CMenuBar 
  37. // I want overide EndDrag, but it's not virtual.
  38. // So I have to overide StartDrag!
  39. class CMenuBarDockContext : public CDockContext
  40. {
  41. public:
  42. CMenuBarDockContext(CControlBar* pBar) : CDockContext(pBar) { }
  44. virtual void StartDrag(CPoint pt);
  46. private:
  47. BOOL _Track();
  48. void _EndDrag();
  49. };
  51. namespace {
  53. // hook
  54. CMenuBar* g_pMenuBar = NULL;
  55. HHOOK   g_hMsgHook = NULL;
  57. // message
  58. const UINT MB_SET_MENU_NULL = WM_USER + 1100;
  60. // layout
  61. const int CXGAP    = 5;
  62. const int CYGAP    = 5;
  63. const int CYGAPVERT    = 3;
  64. const int CXGRIPPER    = 7;
  66. int cyMenuButton = 0;
  68. int cxBorder2 = ::GetSystemMetrics(SM_CXBORDER) * 2;//bWin4 ? CX_BORDER*2 : CX_BORDER;
  69. int cyBorder2 = ::GetSystemMetrics(SM_CYBORDER) * 2;//bWin4 ? CY_BORDER*2 : CY_BORDER;
  71. #ifdef _DEBUG
  72. // if you won't output TRACE in debug mode, make it FALSE;
  73. BOOL bTraceOn = TRUE;
  74. #endif
  76. }
  78. #ifdef _DEBUG
  79. #define LTRACE if (bTraceOn) TRACE
  80. #else
  81. #define LTRACE
  82. #endif
  84. BOOL CMenuBar::m_bMDIApp = FALSE;
  86. BEGIN_MESSAGE_MAP(CMenuBar, CControlBar)
  87. //{{AFX_MSG_MAP(CMenuBar)
  88. ON_WM_LBUTTONDOWN()
  89. ON_WM_MOUSEMOVE()
  90. ON_WM_TIMER()
  91. ON_WM_KILLFOCUS()
  92. ON_WM_CREATE()
  93. ON_WM_LBUTTONUP()
  94. ON_WM_DESTROY()
  95. ON_MESSAGE(MB_SET_MENU_NULL, OnSetMenuNull)
  96. ON_MESSAGE(WM_SYSCOLORCHANGE, OnSettingChange)
  97. //}}AFX_MSG_MAP
  98. ON_MESSAGE(WM_SETTINGCHANGE, OnSettingChange)
  99. END_MESSAGE_MAP()
  101. CMenuBar::CMenuBar()
  102. {
  103. m_nCurIndex  = -1;
  104. m_nTrackingState = none;
  105. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  106. m_bIgnoreAlt = FALSE;
  107. m_bDown  = FALSE;
  108. m_hMenu  = NULL;
  109. m_nIDEvent  = NULL;
  111. m_bIcon  = FALSE;
  112. m_bMDIMaximized = FALSE;
  113. m_hWndMDIClient = NULL;
  114. m_hWndActiveChild = NULL;
  116. m_pMenuIcon = NULL;
  117. m_pMenuControl = NULL;
  119. m_nCmdShow = SW_SHOW;
  120. }
  122. BOOL CMenuBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
  123. {
  124. ASSERT_VALID(pParentWnd); // must have a parent
  125. ASSERT (!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  127. // save the style
  128. m_dwStyle = dwStyle & CBRS_ALL;   // fixed by Mark Gentry, thanx!
  129. m_dwStyle |= CBRS_SIZE_DYNAMIC;
  131. CString strClass = AfxRegisterWndClass(
  132. CS_HREDRAW | CS_VREDRAW |
  133. CS_DBLCLKS, // don't forget!
  134. AfxGetApp()->LoadStandardCursor(IDC_ARROW),
  135. (HBRUSH)(COLOR_BTNFACE + 1));
  137. return CWnd::Create(strClass, _T("MenuBar"), dwStyle, CRect(), pParentWnd, nID);
  138. }
  140. int CMenuBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  141. {
  142. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  143. return -1;
  145. CWnd* pFrame = GetOwner();
  146. ASSERT_VALID(pFrame);
  148. // hook frame window to trap WM_MENUSELECT
  149. m_hookFrame.Install(this, pFrame->GetSafeHwnd());
  151. // If this is an MDI app, hook client window to trap WM_MDISETMENU
  152. if (pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd))) {
  153. CMenuBar::m_bMDIApp = TRUE;
  154. m_hWndMDIClient = ((CMDIFrameWnd*)pFrame)->m_hWndMDIClient;
  155. ASSERT(m_hWndMDIClient);
  156. m_hookMDIClient.Install(this, m_hWndMDIClient);
  157. }
  159. // my own DockContext!
  160. m_pDockContext = new CMenuBarDockContext(this);
  162. return 0;
  163. }
  165. BOOL CMenuBar::InitItems()
  166. {
  167. ASSERT(m_hMenu);
  169. // clean up all items
  170. DeleteItems();
  172. // a little suitable
  173. int nCount = ::GetMenuItemCount(m_hMenu);
  174. ASSERT(nCount > 0);
  175. m_arrItem.SetSize(nCount);
  177. if (!CMenuButton::InitCommonResource()) {
  178. TRACE("Failed to create bar resourcen");
  179. return FALSE;
  180. }
  182. // buttons
  183. for (int i = 0; i < nCount; ++i) {
  184. m_arrItem[i] = new CMenuButton(m_hMenu, i);
  185. }
  186. cyMenuButton = m_arrItem[0]->m_sizeHorz.cy;
  188. // icon
  189. m_pMenuIcon = new CMenuIcon(this);
  190. m_arrItem.InsertAt(0, m_pMenuIcon);
  191. // frame control
  192. m_pMenuControl = new CMenuControl(this);
  193. m_arrItem.Add(m_pMenuControl);
  196. // reinitializing
  197. m_hWndActiveChild = GetActiveChildWnd(m_bMDIMaximized);
  198. if (m_hWndActiveChild) {// re set 
  199. m_pMenuIcon->OnActivateChildWnd(m_hWndActiveChild);
  200. }
  201. if (m_bMDIMaximized) {
  202. m_pMenuIcon->Validate(TRUE);
  203. m_pMenuControl->Validate(TRUE);
  204. }
  206. return TRUE;
  207. }
  209. BOOL CMenuBar::LoadMenuBar(UINT nIDResource)
  210. {
  211. if (m_hMenu) {
  212. ::DestroyMenu(m_hMenu);
  213. m_hMenu = NULL;
  214. }
  216. ASSERT_VALID(m_pDockSite);
  217. if (m_pDockSite->GetMenu()) {
  218. PostMessage(MB_SET_MENU_NULL, (WPARAM)m_pDockSite->GetSafeHwnd());
  219. }
  221. m_hMenu = ::LoadMenu(AfxGetInstanceHandle(), MAKEINTRESOURCE(nIDResource));
  222. if (m_hMenu == NULL) {
  223. TRACE("Failed to load menun");
  224. return FALSE;
  225. }
  227. return InitItems();
  228. }
  230. void CMenuBar::RefreshBar()
  231. {
  232. InvalidateRect(NULL);
  234. CFrameWnd* pFrame = (CFrameWnd*)GetOwner();
  235. ASSERT_VALID(pFrame);
  236. ASSERT(pFrame->IsFrameWnd());
  237. pFrame->RecalcLayout();
  239. // floating frame
  240. pFrame = GetParentFrame();
  241. if (pFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd)))
  242. pFrame->RecalcLayout();
  243. }
  246. HMENU CMenuBar::LoadMenu(HMENU hMenu, HMENU hWindowMenu)
  247. {
  248. LTRACE("CMenuBar::LoadMenun");
  249. UINT iPrevID=(UINT)-1;
  250. ASSERT(::IsMenu(hMenu));
  251. ASSERT_VALID(this);
  254. CFrameWnd* pFrame = GetParentFrame();
  255. if (::GetMenu(pFrame->GetSafeHwnd()) != NULL) {
  256. // not to make MFC ignore SetMenu(NULL), post it.
  257. PostMessage(MB_SET_MENU_NULL, (WPARAM)pFrame->GetSafeHwnd());
  258. }
  261. HMENU hOldMenu = m_hMenu;
  262. m_hMenu = hMenu; // menu is shared with MFC
  264. // initialize Items 
  265. VERIFY(InitItems());
  267. if (hMenu) {
  268. m_hWindowMenu = hWindowMenu;
  269. RefreshBar(); // and menubar itself
  270. }
  272. return hOldMenu;
  273. }
  276. CMenuBar::~CMenuBar()
  277. {
  278. if (m_bMDIApp == FALSE && m_hMenu != NULL)
  279. ::DestroyMenu(m_hMenu);
  280. }
  282. /////////////////////////////////////////////////////////////////////////////
  283. // CMenuBar 傾僀僥儉偺忣曬
  286. /////////////////////////////////////////////////////////////////////////////
  287. // CMenuBar 傾僀僥儉昤夋
  289. void CMenuBar::UpdateBar(TrackingState nState, int nNewIndex)
  290. {
  291. if (m_nTrackingState == buttonmouse)
  292. m_bIgnoreAlt = FALSE; // if prev state is BUTTONMOUSE, always should be FALSE!
  294. m_nTrackingState = nState;
  296. #ifdef _DEBUG
  297. // static LPCTSTR lpszStates[] = { _T("NONE"), _T("BUTTON"), _T("POPUP"), _T("BUTTONMOUSE") };
  298. // LTRACE(_T("CMenuBar::UpdateBar state to %s, button=%dn"),
  299. // lpszStates[nState], nNewIndex);
  300. #endif
  302. // clean up
  303. if (IsValidIndex(m_nCurIndex)) {
  304. CDC* pDC = GetDC();
  305. m_arrItem[m_nCurIndex]->SetState(CMenuButton::none);
  306. m_arrItem[m_nCurIndex]->Update(pDC);
  308. CRect rcCross = m_pMenuControl->m_rcItem & m_arrItem[m_nCurIndex]->m_rcItem;
  309. if (!rcCross.IsRectEmpty()) {
  310. m_pMenuControl->ForceDrawControl(pDC);
  311. }
  313. ReleaseDC(pDC);
  314. m_nCurIndex = -1;
  315. }
  317. if (nState != none) {
  318. ASSERT(IsValidIndex(nNewIndex));
  319. m_nCurIndex = nNewIndex;
  320. CDC* pDC = GetDC();
  322. if (nState == button || nState == buttonmouse) {
  323. m_arrItem[m_nCurIndex]->SetState(CMenuButton::hot);
  324. m_arrItem[m_nCurIndex]->Update(pDC);
  325. }
  326. else if (nState == popup) {
  327. m_arrItem[m_nCurIndex]->SetState(CMenuButton::select);
  328. m_arrItem[m_nCurIndex]->Update(pDC);
  329. }
  331. CRect rcCross = m_pMenuControl->m_rcItem & m_arrItem[m_nCurIndex]->m_rcItem;
  332. if (!rcCross.IsRectEmpty()) {
  333. m_pMenuControl->ForceDrawControl(pDC);
  334. }
  336. ReleaseDC(pDC);
  337. }
  338. else {
  339. // must be default parameter
  340. ASSERT(nNewIndex == -1);
  341. }
  343. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  344. }
  346. /////////////////////////////////////////////////////////////////////////////
  347. // CMenuBar 儊僢僙乕僕 僴儞僪儔
  349. int CMenuBar::HitTestOnTrack(CPoint point)
  350. {
  351. for (int i = 0; i < GetItemCount(); ++i) {
  352. CMenuItem* pItem = m_arrItem[i];
  353. CRect rcItem = pItem->GetItemRect();
  355. if (pItem->IsValid() && pItem->CanTrack() &&
  356. rcItem.PtInRect(point))
  357. return i;
  358. }
  360. return -1;
  361. }
  363. void CMenuBar::OnLButtonDown(UINT nFlags, CPoint point) 
  364. {
  365. // LTRACE("CMenuBar::OnLButtonDownn");
  367. ASSERT(m_pMenuControl);
  368. if (m_pMenuControl->OnMouseMsg(WM_LBUTTONDOWN, nFlags, point)) {
  369. return; // eat it!
  370. }
  372. int nIndex = HitTestOnTrack(point);
  373. if (IsValidIndex(nIndex) && m_arrItem[nIndex]->CanTrack()) {
  374. /* HMENU hSubMenu = ::GetSubMenu(m_hMenu, nIndex);
  375. if (hSubMenu == NULL) {
  376. UpdateWindow(); // force to repaint
  377. CDC* pDC = GetDC();
  378. m_arrItem[m_nCurIndex]->SetState(CMenuButton::select);
  379. m_arrItem[nIndex]->Update(pDC);
  380. ReleaseDC(pDC);
  381. m_bDown = TRUE;
  382. }
  383. else {
  384. TrackPopup(nIndex);
  385. }
  386. */
  387. TrackPopup(nIndex);
  389. return; // eat it!
  390. }
  392. CControlBar::OnLButtonDown(nFlags, point);
  393. }
  395. void CMenuBar::OnMouseMove(UINT nFlags, CPoint point) 
  396. {
  397. // TRACE("CMenuBar::OnMouseMoven");
  399. if (!IsTopParentActive() || !GetTopLevelParent()->IsWindowEnabled()) {
  400. // window is not active, ignore
  401. CControlBar::OnMouseMove(nFlags, point);
  402. return;
  403. }
  405. ASSERT(m_pMenuControl);
  406. if (m_pMenuControl->OnMouseMsg(WM_MOUSEMOVE, nFlags, point)) {
  407. CControlBar::OnMouseMove(nFlags, point);
  408. return;
  409. }
  411. int nIndex = HitTestOnTrack(point);
  412. if (IsValidIndex(nIndex)) {
  413. if (m_nCurIndex == -1 || m_nCurIndex != nIndex) { // other button
  414. UpdateBar(buttonmouse, nIndex); // button tracked with mouse
  415. // I wanna know when mouse is away,
  416. // but SetCapture makes ALT+F4 uncatchable
  417. // and WM_CAPTURECHANGED is never sent(why?), so we have to set timer
  418. _KillTimer();
  419. m_nIDEvent = SetTimer(1, 250, 0);
  420. }
  421. }
  422. else {
  423. UpdateBar();
  424. }
  426. CControlBar::OnMouseMove(nFlags, point);
  427. }
  429. void CMenuBar::OnTimer(UINT nIDEvent) 
  430. {
  431. if( nIDEvent == m_nIDEvent && m_nTrackingState == buttonmouse) {
  432. CPoint pt; ::GetCursorPos(&pt);
  433. CRect rect;
  434. GetWindowRect(&rect);
  435. if (!rect.PtInRect(pt)) {
  436. UpdateBar();
  437. _KillTimer();
  438. }
  439. }
  441. CControlBar::OnTimer(nIDEvent);
  442. }
  444. void CMenuBar::OnKillFocus(CWnd* pNewWnd) 
  445. {
  446. CControlBar::OnKillFocus(pNewWnd);
  448. // TODO: 
  449. UpdateBar();
  450. }
  452. LRESULT CMenuBar::OnSetMenuNull(WPARAM wParam, LPARAM)
  453. {
  454. HWND hWnd = (HWND)wParam;
  455. ASSERT(::IsWindow(hWnd));
  456. ::SetMenu(hWnd, NULL);
  458. return 0;
  459. }
  461. LRESULT CMenuBar::OnSettingChange(WPARAM wParam, LPARAM lParam)
  462. {
  463. InitItems();
  465. CFrameWnd* pFrame = GetParentFrame();
  466. ASSERT_VALID(pFrame);
  467. pFrame->RecalcLayout();
  468. return 0;
  469. }
  471. /////////////////////////////////////////////////////////////////////////////
  472. // CMenuBar
  474. void CMenuBar::OnMenuSelect(HMENU hMenu, UINT nIndex)
  475. {
  476. if (m_nTrackingState == popup) {
  477. m_bProcessRightArrow = (::GetSubMenu(hMenu, nIndex) == NULL);
  478. HMENU hSubMenu = ::GetSubMenu(hMenu, m_nCurIndex);
  479. if (hSubMenu == NULL)
  480. return;
  481. m_bProcessLeftArrow = (hMenu == hSubMenu);
  482. }
  483. }
  485. LRESULT CALLBACK CMenuBar::MenuInputFilter(int code, WPARAM wParam, LPARAM lParam)
  486. {
  487. return (
  488. code == MSGF_MENU &&
  489. g_pMenuBar &&
  490. g_pMenuBar->OnMenuInput( *((MSG*)lParam) )
  491. ) ? TRUE : CallNextHookEx(g_hMsgHook, code, wParam, lParam);
  492. }
  494. void CMenuBar::TrackPopup(int nIndex)
  495. {
  496. ASSERT_VALID(this);
  498. m_nCurIndex = nIndex;
  499. m_bLoop = TRUE;
  500. while (m_bLoop == TRUE) {
  501. UpdateWindow(); // force to repaint when button hidden by other window
  502. UpdateBar(popup, m_nCurIndex);
  504. // install hook
  505. ASSERT(g_pMenuBar == NULL);
  506. g_pMenuBar = this;
  507. ASSERT(g_hMsgHook == NULL);
  509. m_bLoop = FALSE;
  510. g_hMsgHook = ::SetWindowsHookEx(WH_MSGFILTER,
  511. MenuInputFilter, NULL, AfxGetApp()->m_nThreadID);// m_bLoop may become TRUE
  513. // popup!!
  514. m_nTrackingState = popup;
  515. m_arrItem[m_nCurIndex]->TrackPopup(this);
  517. // uninstall hook
  518. ::UnhookWindowsHookEx(g_hMsgHook);
  519. g_hMsgHook = NULL;
  520. g_pMenuBar = NULL;
  521. }
  523. UpdateBar();
  524. }
  526. BOOL CMenuBar::OnMenuInput(MSG& m)
  527. {
  528. ASSERT_VALID(this);
  529. int nMsg = m.message;
  530. CPoint pt = m.lParam;
  531. ScreenToClient(&pt);
  533. switch (nMsg) {
  534. case WM_MOUSEMOVE:
  535. if (pt != m_ptMouse) {
  536. int nIndex = HitTestOnTrack(pt);
  537. if (IsValidIndex(nIndex) && nIndex != m_nCurIndex) {
  538. // defferent button clicked
  539. GetOwner()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  540. UpdateBar(); // clean up
  541. m_nCurIndex = nIndex;
  542. m_bLoop = TRUE; // continue loop
  543. }
  544. m_ptMouse = pt;
  545. }
  546. break;
  548. case WM_LBUTTONDOWN:
  549. if (HitTestOnTrack(pt) != -1 && HitTestOnTrack(pt) == m_nCurIndex) {
  550. // same button clicked
  551. GetOwner()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  552. UpdateBar(button, m_nCurIndex);
  553. return TRUE; // eat it!
  554. }
  555. break;
  557. case WM_KEYDOWN: {
  558. TCHAR vKey = m.wParam;
  559. if (m_dwStyle & CBRS_ORIENT_VERT) { // if vertical
  560. break; // do nothing
  561. }
  563. if ((vKey == VK_LEFT  && m_bProcessLeftArrow) ||
  564. (vKey == VK_RIGHT && m_bProcessRightArrow)) {
  565. // no submenu
  566. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vKey==VK_LEFT);
  567. GetOwner()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  568. UpdateBar();
  569. m_nCurIndex = nNewIndex;
  570. m_bLoop = TRUE; // continue loop
  571. return TRUE; // eat it!
  572. }
  573. }
  574. break;
  576. case WM_SYSKEYDOWN:
  577. // LTRACE("    m_bIgnore = TRUEn");
  578. m_bIgnoreAlt = TRUE; // next SysKeyUp will be ignored
  579. break;
  580. }
  582. return FALSE; // pass along...
  583. }
  585. BOOL CMenuBar::TranslateFrameMessage(MSG* pMsg)
  586. {
  587. ASSERT_VALID(this);
  588. ASSERT(pMsg);
  590. UINT nMsg = pMsg->message;
  591. if (WM_LBUTTONDOWN <= nMsg && nMsg <= WM_MOUSELAST) {
  592. if (pMsg->hwnd != m_hWnd && m_nTrackingState > 0) {
  593. // clicked outside
  594. UpdateBar();
  595. }
  596. }
  597. else if (nMsg == WM_SYSKEYDOWN || nMsg == WM_SYSKEYUP || nMsg == WM_KEYDOWN) {
  598. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN; // Alt key presed?
  599. TCHAR vkey = pMsg->wParam; // + X key
  600. if (vkey == VK_MENU ||
  601. (vkey == VK_F10 && !((GetKeyState(VK_SHIFT) & 0x80000000) ||
  602.                    (GetKeyState(VK_CONTROL) & 0x80000000) || bAlt))) {
  603. // only alt key pressed
  604. if (nMsg == WM_SYSKEYUP) {
  605. switch (m_nTrackingState) {
  606. case none:
  607. if (m_bIgnoreAlt == TRUE) {
  608. // LTRACE("    ignore ALT key upn");
  609. m_bIgnoreAlt = FALSE;
  610. break;
  611. }
  613. UpdateBar(button, GetNextOrPrevButton(0, FALSE));
  615. break;
  616. case button:
  617. UpdateBar();
  618. break;
  619. case buttonmouse:
  620. break; // do nothing
  621. }
  622. }
  623. return TRUE;
  624. }
  625. else if ((nMsg == WM_SYSKEYDOWN || nMsg == WM_KEYDOWN)) {
  626. if (m_nTrackingState == button) {
  627. if (m_dwStyle & CBRS_ORIENT_HORZ) { // if horizontal
  628. switch (vkey) {
  629. case VK_LEFT:
  630. case VK_RIGHT: {
  631. int nNewIndex  = GetNextOrPrevButton(m_nCurIndex, vkey == VK_LEFT);
  632. UpdateBar(button, nNewIndex);
  633. return TRUE;
  634.    }
  635. case VK_SPACE:
  636. case VK_UP:
  637. case VK_DOWN:
  638. TrackPopup(m_nCurIndex);
  639. return TRUE;
  641. case VK_ESCAPE:
  642. UpdateBar();
  643. return TRUE;
  644. }
  645. }
  646. else { // if vertical
  647. switch (vkey) {
  648. case VK_UP:
  649. case VK_DOWN:{
  650. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vkey == VK_UP);
  651. UpdateBar(button, nNewIndex);
  652. return TRUE;
  653.    }
  654. case VK_SPACE:
  655. case VK_RIGHT:
  656. case VK_LEFT:
  657. TrackPopup(m_nCurIndex);
  658. return TRUE;
  660. case VK_ESCAPE:
  661. UpdateBar();
  662. return TRUE;
  663. }
  664. }
  665. }
  667. // Alt + X pressed
  668. if ((bAlt || m_nTrackingState == button) && isalnum(vkey)) {
  669. int nIndex;
  670. if (MapAccessKey(vkey, nIndex) == TRUE) {
  671. UpdateBar();
  672. TrackPopup(nIndex);
  673. return TRUE; // eat it!
  674. }
  675. else if (m_nTrackingState==button && !bAlt) {
  676. // MessageBeep(0); // if you want
  677. return TRUE;
  678. }
  679. }
  681. if (m_nTrackingState > 0) { // unknown key
  682. if (m_nTrackingState != buttonmouse) { // if tracked with mouse, don't update bar
  683. UpdateBar();
  684. }
  685. }
  686. }
  687. }
  688. return FALSE; // pass along...
  689. }
  691. BOOL CMenuBar::MapAccessKey(TCHAR cAccessKey, int& nIndex)
  692. {
  693. for (int i = 0; i < GetItemCount(); ++i) {
  694. TCHAR cKey;
  695. if (m_arrItem[i]->GetAccessKey(cKey) == TRUE &&
  696. cKey == cAccessKey) {
  697. nIndex = i;
  698. return TRUE;
  699. }
  700. }
  701. return FALSE;
  702. }
  704. /////////////////////////////////////////////////////////////////////////////
  705. // CMenuBar layout
  707. // calculate only layout from m_bWrapped
  708. void CMenuBar::CalcFloatingLayout()
  709. {
  710. ASSERT_VALID(this);
  711. ASSERT(::IsWindow(m_hWnd));
  713. int xStart = CXGAP;
  715. if (!IsFloating()) {
  716. xStart += CXGRIPPER;
  717. }
  719. int xOffset = xStart;
  720. int yOffset = CYGAP;
  722. for (int i = 0; i < GetItemCount(); ++i) {
  723. CMenuItem* pItem = m_arrItem[i];
  724. if (pItem->IsValid()) {
  725. CPoint ptItem(xOffset, yOffset);
  726. pItem->Layout(ptItem, TRUE); // layout by itself!
  727. if (pItem->m_bWrapped == TRUE) {
  728. xOffset = xStart; // reset xOffset
  729. yOffset += pItem->m_sizeHorz.cy;
  730. }
  731. else
  732. xOffset += pItem->m_sizeHorz.cx;
  733. }
  734. }
  735. }
  737. // calulate ordinary layout and size without m_bWrapped 
  738. CSize CMenuBar::CalcLayout(DWORD dwMode, int nLength)
  739. {
  740. ASSERT_VALID(this);
  741. ASSERT(::IsWindow(m_hWnd));
  742. if (dwMode & LM_HORZDOCK)
  743. ASSERT(dwMode & LM_HORZ);
  744. CSize sizeResult(0, 0);
  746. if (!(dwMode & LM_HORZ))  { // if vertical
  747. int yOffset = CXGAP;
  748. if (!IsFloating())
  749. yOffset += CXGRIPPER;
  751. for (int i = 0; i < GetItemCount(); ++i) {
  752. CMenuItem* pItem = m_arrItem[i];
  753. if (pItem->IsValid()) {
  754. CPoint ptItem(CYGAPVERT, yOffset);
  755. pItem->Layout(ptItem, FALSE); // layout by itself
  756. yOffset += pItem->m_rcItem.Height();
  757. }
  758. }
  759. int cxBar = max(::GetSystemMetrics(SM_CXSMICON), cyMenuButton + (CYGAPVERT)*2);
  760. sizeResult =  CSize(cxBar, yOffset+CXGAP);
  761. }
  762. else { // if horizontal
  763. int xOffset = CXGAP;
  764. if (!IsFloating())
  765. xOffset += CXGRIPPER;
  767. for (int i = 0; i < GetItemCount(); ++i) {
  768. CMenuItem* pItem = m_arrItem[i];
  769. if (pItem->IsValid()) {
  770. CPoint ptItem(xOffset, CYGAP);
  771. pItem->Layout(ptItem, TRUE); // layout by itself
  772. xOffset += pItem->m_rcItem.Width();
  773. }
  774. }
  775. int cyBar = max(::GetSystemMetrics(SM_CYSMICON), cyMenuButton + CYGAP*2);
  776. sizeResult = CSize(xOffset+CXGAP, cyBar);
  777. }
  779. return sizeResult;
  780. }
  782. // in fact, it's never called
  783. CSize CMenuBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  784. {
  785. // LTRACE("CMenuBar::CalcFixedLayoutn");
  787. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  788. dwMode |= bHorz ? LM_HORZ : 0;
  790. return CalcLayout(dwMode);
  791. }
  793. CSize CMenuBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  794. {
  795. LTRACE("CMenuBar::CalcDynamicLayoutn");
  797. // Who can understand what "dwMode" means?
  798. // 
  799. // If you want it be pricisely same as DevStudio style,
  800. // I think you have to create a "CDockContext" derived class.
  801. // This is the reason why everyone think "CControlBar class" junk ? 
  803. ASSERT_VALID(this);
  804. ASSERT_VALID(m_pDockSite);
  805. ASSERT_VALID(m_pDockBar);
  807. if (m_hMenu == NULL) // if have no menu yet, just return
  808. return CSize(0, 0);
  810. if (IsFloating()) {
  811. CFrameWnd* pFrame = GetParentFrame();
  812. ASSERT_VALID(pFrame);
  813. CMenu* pSysMenu = pFrame->GetSystemMenu(FALSE);
  814. ASSERT_VALID(pSysMenu);
  815. pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_DISABLED);
  816. }
  818. if (dwMode & LM_HORZ) { // horizontal
  819. // LTRACE("    horizontaln");
  820. if (dwMode & LM_HORZDOCK) {
  821. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_VERT)) { // if Floating->Docking, return min size
  822. // LTRACE("    return min sizen");
  823. return CalcLayout(dwMode);
  824. }
  825. else {
  826. if (m_pDockContext->m_pDC) { // now dragging
  827. // return DockBar size
  828. //LTRACE("    now dragging, so calc with DockBarn");
  829. CSize size = CalcSize(GetItemCount());//CalcLayout(dwMode);
  830. CRect rcFrame;
  831. m_pDockBar->GetWindowRect(rcFrame);
  832. CRect rcBar;
  833. GetWindowRect(rcBar);
  834. rcBar.right = rcFrame.right;
  835. return CSize(rcBar.Width() + cxBorder2, size.cy);
  836. }
  837. else {
  838. //LTRACE("    no draggin calc bigger sizen");
  839. CRect rcFrame;
  840. m_pDockSite->GetWindowRect(rcFrame);
  841. SizeMenuBar(GetItemCount(), rcFrame.Width() - cxBorder2*2, FALSE);
  842. CalcFloatingLayout();
  843. CSize size1 = CalcSize(GetItemCount());
  844. return CSize(rcFrame.Width(), size1.cy);
  845. }
  846. }
  847. }
  848. else if (dwMode & LM_MRUWIDTH) { // floating size
  849. //LTRACE("    return floating sizen");
  850. SizeMenuBar(GetItemCount(), m_nMRUWidth, FALSE); // load floating Bar Width! 
  851. CalcFloatingLayout();
  852. return CalcSize(GetItemCount());
  853. }
  854. else if (dwMode & LM_COMMIT) {
  855. //LTRACE("    commit, just calc: %dn", nLength);
  856. m_nMRUWidth = nLength; // save floating Bar Width!!! (used when SaveBarState)
  857. CalcFloatingLayout();
  858. return CSize(0, 0); // MFC does'nt use this Size
  859. }
  860. else if (dwMode & LM_LENGTHY) {
  861. //LTRACE("    nLength is height : %dn", nLength);
  862. SizeMenuBar(GetItemCount(), nLength, TRUE);
  863. return CalcSize(GetItemCount());
  864. }
  865. else {
  866. //LTRACE("    nLength is width  : %dn", nLength);
  867. SizeMenuBar(GetItemCount(), nLength, FALSE);
  868. return CalcSize(GetItemCount());
  869. }
  870. ASSERT(TRUE);
  871. }
  872. else { // vertical
  873. InvalidateRect(NULL); // force to repaint!!!
  874. //LTRACE("    verticaln");
  875. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_HORZ)) { // if Floating->Docking, return min size
  876. //LTRACE("    return min sizen");
  877. return CalcLayout(dwMode);
  878. }
  879. else { // return large size
  880. if (m_pDockContext->m_pDC) { // CDockContext::m_bDragging is not helpful :(
  881. //LTRACE("    now dragging, so calc with DockBarn");
  882. CSize size = CalcLayout(dwMode);
  883. CRect rcFrame;
  884. m_pDockBar->GetWindowRect(rcFrame);
  885. CRect rcBar;
  886. GetWindowRect(rcBar);
  887. rcBar.bottom = rcFrame.bottom;
  888. return CSize(size.cx, rcBar.Height());
  889. }
  890. else {
  891. //LTRACE("    no dragging, return biggest sizen");
  893. CSize size = CalcLayout(dwMode);
  894. CRect rcFrame;
  895. m_pDockSite->GetWindowRect(rcFrame);
  896. CRect rcBar;
  897. GetWindowRect(rcBar);
  898. rcBar.bottom = rcFrame.bottom;
  899. return CSize(size.cx, rcFrame.Height());
  900. }
  901. }
  902. }
  904. ASSERT(TRUE); // never come here
  905. return CalcLayout(dwMode, nLength);
  906. }
  908. void CMenuBar::DrawGripper(CDC* pDC)
  909. {
  910. if( (m_dwStyle & CBRS_FLOATING) || m_dwDockStyle == 0 )
  911. return;
  913. CRect rcGrip;
  914. GetClientRect(&rcGrip);
  916. if(m_dwStyle & CBRS_ORIENT_HORZ) {
  917. // gripper at left
  918. rcGrip.DeflateRect(4, 3);
  919. rcGrip.right = rcGrip.left + 3;
  920. pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  921. rcGrip.OffsetRect(4, 0);
  922.         pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  923. }
  924. else {
  925. // gripper at top
  926. rcGrip.DeflateRect(3, 4);
  927. rcGrip.bottom = rcGrip.top + 3;
  928. pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  929. rcGrip.OffsetRect(0, 4);
  930. pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  931. }
  932. }
  934. #define CX_BORDER   1
  935. #define CY_BORDER   1
  937. void CMenuBar::DrawBorder(CDC* pDC)
  938. {
  939. if( (m_dwStyle & CBRS_FLOATING) || m_dwDockStyle == 0 )
  940. return;
  942. CRect rect;
  943. GetClientRect(rect);
  945. DWORD dwStyle = m_dwStyle;
  946. if (!(dwStyle & CBRS_BORDER_ANY))
  947. return;
  949. CRect rect3 = rect;
  950. if (m_dwStyle & CBRS_ORIENT_HORZ) {
  951. rect3.left += cxBorder2;//rect.DeflateRect(2, 0);
  952. pDC->DrawEdge(rect3, BDR_RAISEDINNER,  BF_LEFT);
  953. }
  954. else {
  955. rect3.top += cyBorder2;//rect.DeflateRect(0, 2);
  956. pDC->DrawEdge(rect3, BDR_RAISEDINNER,  BF_TOP);
  957. }
  959. // prepare for dark lines
  960. ASSERT(rect.top == 0 && rect.left == 0);
  961. CRect rect1, rect2;
  962. rect1 = rect;
  963. rect2 = rect;
  964. COLORREF clr = ::GetSysColor(COLOR_BTNSHADOW);//afxData.bWin4 ? afxData.clrBtnShadow : afxData.clrWindowFrame;
  966. // draw dark line one pixel back/up
  967. if (dwStyle & CBRS_BORDER_3D)
  968. {
  969. rect1.right -= CX_BORDER;
  970. rect1.bottom -= CY_BORDER;
  971. }
  972. if (dwStyle & CBRS_BORDER_TOP)
  973. rect2.top += CY_BORDER;//cyBorder2;
  974. if (dwStyle & CBRS_BORDER_BOTTOM)
  975. rect2.bottom -= CY_BORDER;
  977. if (dwStyle & CBRS_BORDER_LEFT)
  978. rect2.left += CX_BORDER;
  980. if (dwStyle & CBRS_BORDER_RIGHT)
  981. rect2.right -= CX_BORDER;
  983. if (dwStyle & CBRS_BORDER_3D)
  984. {
  985. // draw left and top
  986. if (dwStyle & CBRS_BORDER_LEFT)
  987. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_LEFT);//pDC->FillSolidRect(1, rect2.top, CX_BORDER, rect2.Height(), clr);
  988. if (dwStyle & CBRS_BORDER_TOP)
  989. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_TOP);//pDC->FillSolidRect(0, 1, rect.right, CY_BORDER, clr);
  991. // draw right and bottom
  992. if (dwStyle & CBRS_BORDER_RIGHT)
  993. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_RIGHT);//pDC->FillSolidRect(rect.right, rect2.top, -CX_BORDER, rect2.Height(), clr);
  994. if (dwStyle & CBRS_BORDER_BOTTOM)
  995. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_BOTTOM);//pDC->FillSolidRect(0, rect.bottom, rect.right, -CY_BORDER, clr);
  996. }
  998. }
  1000. /////////////////////////////////////////////////////////////////////////////
  1001. // CMenuBarFrameHook implementation
  1002. CMenuBarFrameHook::CMenuBarFrameHook()
  1003. {
  1004. m_pMenuBar = NULL;
  1005. }
  1007. BOOL CMenuBarFrameHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  1008. {
  1009. ASSERT_VALID(pMenuBar);
  1010. ASSERT(m_pMenuBar == NULL);
  1011. m_pMenuBar = pMenuBar;
  1012. return HookWindow(hWndToHook);//CWnd::FromHandlePermanent(hWndToHook));
  1013. }
  1015. CMenuBarFrameHook::~CMenuBarFrameHook()
  1016. {
  1017. }
  1019. LRESULT CMenuBarFrameHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  1020. {
  1021. ASSERT_VALID(m_pMenuBar);
  1023. switch (nMsg) {
  1024. case WM_MENUSELECT:
  1025. m_pMenuBar->OnMenuSelect((HMENU)lParam, (UINT)LOWORD(wParam));
  1026. break;
  1028. // The following messages are trapped for the MDI client window
  1029. case WM_INITMENUPOPUP:
  1030. LTRACE("CMenuBar::WM_INITMENUPOPUPn");
  1031. if (!HIWORD(lParam) && (HMENU)wParam == m_pMenuBar->m_hWindowMenu)
  1032. m_pMenuBar->OnInitMenuPopup();
  1033. break;
  1036. case WM_MDISETMENU: // only sent to MDI client window
  1037. // Setting new frame/window menu: bypass MDI. wParam is new menu.
  1038. if (wParam) {
  1039. LTRACE("CMenuBar::WM_MDISETMENU 0x%04xn", wParam);
  1040. // HMENU hNewMenu = (HMENU)wParam;
  1041. m_pMenuBar->OnSetMenu((HMENU)wParam, (HMENU)lParam);
  1042. }
  1043. return 0;
  1045. case WM_MDIREFRESHMENU: // only sent to MDI client window
  1046. // Normally, would call DrawMenuBar, but I have the menu, so eat it.
  1047. // LTRACE("CMenuBar::WM_MDIREFRESHMENUn");
  1048. return 0;
  1050. case WM_PAINT:
  1051. // After changing the MDI maximized state, the client window gets a
  1052. // paint message. This is the most convenient place to find out; there
  1053. // is no WM_MDIMAXIMIZED message.
  1054. if (/*m_pWndHooked->*/m_hWnd == m_pMenuBar->m_hWndMDIClient)
  1055. m_pMenuBar->OnPaintMDIClient();//CheckMinMaxState();
  1056. break;
  1057. }
  1059. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  1060. }
  1062. void CMenuBar::OnLButtonUp(UINT nFlags, CPoint point) 
  1063. {
  1064. //LTRACE("CMenuBar::OnLButtonUpn");
  1065. // TODO: 
  1066. ASSERT(m_pMenuControl);
  1067. if (m_pMenuControl->OnMouseMsg(WM_LBUTTONUP, nFlags, point)) {
  1068. CControlBar::OnLButtonUp(nFlags, point);
  1069. return;
  1070. }
  1072. int nIndex = HitTestOnTrack(point);
  1073. /*
  1074. if (IsValidIndex(nIndex) && m_bDown == TRUE) {
  1075. HMENU hSubMenu = ::GetSubMenu(m_hMenu, nIndex);
  1076. if (hSubMenu == NULL) {
  1077. UINT nID = ::GetMenuItemID(m_hMenu, nIndex);
  1078. ASSERT(nID != -1);
  1079. GetOwner()->SendMessage(WM_COMMAND, (WPARAM)nID, (LPARAM)GetSafeHwnd());
  1081. UpdateBar();
  1082. }
  1083. }
  1084. */
  1085. CControlBar::OnLButtonUp(nFlags, point);
  1086. }
  1090. void CMenuBar::DoPaint(CDC* pDC)
  1091. {
  1092. //LTRACE("CMenuBar::DoPaintn");
  1093. CRect rect;
  1094. GetClientRect(rect);
  1096. // draw buttons
  1097. for (int i = 0; i < m_arrItem.GetSize(); ++i) {
  1098. CMenuItem* pItem = m_arrItem[i];
  1099. if (pItem->IsValid())
  1100. m_arrItem[i]->Update(pDC);
  1101. }
  1103. // draw decorations
  1104. DrawGripper(pDC);
  1105. DrawBorder(pDC);
  1107. // draw captions
  1108. if (m_pMenuControl) {
  1109. CRect rcDockBar;
  1110. m_pDockBar->GetClientRect(rcDockBar);
  1111. if (m_dwStyle & CBRS_ORIENT_HORZ) {
  1112. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(rcDockBar.Width() + cxBorder2, rect.Height()));
  1113. }
  1114. else {
  1115. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(rect.Width(), rcDockBar.Height()));
  1116. }
  1117. }
  1118. }
  1120. void CMenuBar::_KillTimer()
  1121. {
  1122. if (m_nIDEvent) {
  1123. KillTimer(m_nIDEvent);
  1124. m_nIDEvent = NULL;
  1125. }
  1126. }
  1129. int getPrevValidIndex(int nIndex)
  1130. {
  1131. --nIndex;
  1136. return nIndex;
  1137. }
  1139. // set only m_bWrapped by nWidth
  1140. int CMenuBar::WrapMenuBar(int nCount, int nWidth)
  1141. {
  1142. // LTRACE("CMenuBar::WrapMenuBarn");
  1143. int nResult = 0;
  1144. int xStart = CXGAP;
  1145. if (!IsFloating() && !m_pDockContext->m_pDC) // if not floating and ****not dragging!!!****
  1146. xStart += CXGRIPPER;
  1148. int x = xStart;
  1150. for (int i = 0; i < nCount; ++i) {
  1151. CMenuItem* pItem = m_arrItem[i];
  1152. if (pItem->IsValid()) {
  1154. if (i+1 == nCount)
  1155. return ++nResult;
  1157. if (x + pItem->m_sizeHorz.cx + CXGAP> nWidth) {// itself is over
  1158. if (pItem->CanWrap()) {
  1159. pItem->m_bWrapped = TRUE;
  1160. ++nResult;
  1161. x = xStart;
  1162. }
  1163. }
  1164. else if (x + pItem->m_sizeHorz.cx + m_arrItem[i+1]->m_sizeHorz.cx + CXGAP > nWidth) {
  1165. if (pItem->CanWrap()) {
  1166. pItem->m_bWrapped = TRUE;
  1167. ++nResult;
  1168. x = xStart;
  1169. }
  1170. }
  1171. else {
  1172. pItem->m_bWrapped = FALSE;
  1173. x += pItem->m_sizeHorz.cx;
  1174. }
  1175. }
  1176. }
  1177. /* //another algorithm
  1178. int dx = pItem->m_sizeHorz.cx;
  1179. if (dx + CXGAP > nWidth) { // bigger than nWidth
  1180. if (pItem->CanWrap()) {
  1181. pItem->m_bWrapped = TRUE;
  1182. // if (i != nCount - 1)
  1183. ++nResult;
  1184. }
  1185. }
  1186. else if (dx + x + CXGAP > nWidth) {
  1187. if (i > 0 && m_arrItem[i-1]->CanWrap()) {
  1188. // LTRACE("index %d is wrapn", i-1);
  1189. m_arrItem[i-1]->m_bWrapped = TRUE;
  1190. pItem->m_bWrapped = FALSE;
  1191. x = xStart;
  1192. // if (i != nCount - 1)///////////////////////////
  1193. ++nResult;
  1194. }
  1195. }
  1196. else {
  1197. pItem->m_bWrapped = FALSE;
  1198. }
  1199. x += dx;
  1201. }
  1202. }
  1203. */
  1205. return nResult + 1;
  1206. }
  1208. // calc only size, by using m_bWrapped
  1209. CSize CMenuBar::CalcSize(int nCount)
  1210. {
  1211. ASSERT(nCount > 0);
  1212. CPoint cur(CXGAP, CYGAP);
  1213. CSize sizeResult(0, 0);
  1214. int nWrap = 0;
  1215. for (int i = 0; i < nCount; ++i) {
  1216. CMenuItem* pItem = m_arrItem[i];
  1217. if (pItem->IsValid()) {
  1218. sizeResult.cx = max(cur.x + pItem->m_sizeHorz.cx, sizeResult.cx);
  1219. sizeResult.cy = max(cur.y + pItem->m_sizeHorz.cy, sizeResult.cy);
  1221. cur.x += pItem->m_sizeHorz.cx;
  1223. if (pItem->m_bWrapped == TRUE) {
  1224. LTRACE("    nIndex:%d is wrappedn", i);
  1225. cur.x = CXGAP; // reset x pos
  1226. cur.y += pItem->m_sizeHorz.cy;
  1227. ++nWrap;
  1228. }
  1230. }
  1231. }
  1233. sizeResult.cy += CYGAP;
  1234. sizeResult.cx += CXGAP;
  1235. return sizeResult;
  1236. }
  1238. void CMenuBar::SizeMenuBar(int nCount, int nLength, BOOL bVert)
  1239. {
  1240. //LTRACE("CMenuBar::SizeMenuBarn");
  1241. ASSERT(nCount > 0);
  1243. if (!bVert) { // nLength is horizontal length
  1245. if (IsFloating()) { // half size wrapping
  1247. CSize sizeMax, sizeMin, sizeMid;
  1249. // Wrap MenuBar vertically
  1250. WrapMenuBar(nCount, 0);
  1251. sizeMin = CalcSize(nCount);
  1253. // Wrap MenuBar horizontally
  1254. WrapMenuBar(nCount, 32767);
  1255. sizeMax = CalcSize(nCount);
  1257. // we can never know this algorithm :), see CToolBar implementation
  1258. while (sizeMin.cx < sizeMax.cx) {
  1259. // LTRACE("looping sizeMin.cx:%d < sizeMax.cx:%dn", sizeMin.cx, sizeMax.cx);
  1260. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1261. WrapMenuBar(nCount, sizeMid.cx);
  1262. sizeMid = CalcSize(nCount);
  1263. if (sizeMid.cx == sizeMax.cx) { // if you forget, it loops forever!
  1264. return;
  1265. }
  1266. // LTRACE("    sizeMid : %d %dn", sizeMid.cx, sizeMid.cy);
  1268. if (nLength >= sizeMax.cx) {
  1269. // LTRACE("    nLength:%d >= sizeMax.cx:%dn", nLength, sizeMax.cx);
  1270. if (sizeMin == sizeMid) {
  1271. WrapMenuBar(nCount, sizeMax.cx);
  1272. // LTRACE("out SizeMenuBarn");
  1273. return;
  1274. }
  1275. sizeMin = sizeMid;
  1276. }
  1277. else if (nLength < sizeMax.cx) {
  1278. // LTRACE("    nLength:%d < sizeMax.cx:%dn", nLength, sizeMax.cx);
  1279. sizeMax = sizeMid;
  1280. }
  1281. else {
  1282. // LTRACE("out SizeMenuBarn");
  1283. return;
  1284. }
  1285. }
  1286. }
  1287. else { // each one wrapping
  1288. LTRACE("    just each one wrappingn");
  1289. WrapMenuBar(nCount, nLength);
  1290. }
  1291. }
  1292. else { // nLength is vertical length
  1293. CSize sizeMax, sizeMin, sizeMid;
  1295. // Wrap MenuBar vertically
  1296. WrapMenuBar(nCount, 0);
  1297. sizeMin = CalcSize(nCount);
  1299. // Wrap MenuBar horizontally
  1300. WrapMenuBar(nCount, 32767);
  1301. sizeMax = CalcSize(nCount);
  1303. while (sizeMin.cx < sizeMax.cx) {
  1304. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1305. WrapMenuBar(nCount, sizeMid.cx);
  1306. sizeMid = CalcSize(nCount);
  1307. if (sizeMid.cx == sizeMax.cx) {
  1308. return;
  1309. }
  1310. if (nLength < sizeMid.cy) {
  1311. if (sizeMin == sizeMid) {
  1312. WrapMenuBar(nCount, sizeMax.cx);
  1313. //LTRACE("out SizeMenuBarn");
  1314. return;
  1315. }
  1316. sizeMin = sizeMid;
  1317. }
  1318. else if (nLength > sizeMid.cy)
  1319. sizeMax = sizeMid;
  1320. else {
  1321. //LTRACE("out SizeMenuBarn");
  1322. return;
  1323. }
  1324. }
  1325. }
  1327. //LTRACE("out SizeMenuBarn");
  1328. }
  1331. void CMenuBar::DeleteItems()
  1332. {
  1333. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  1334. CMenuItem* pItem = m_arrItem[i];
  1335. delete pItem;
  1336. }
  1338. m_arrItem.RemoveAll();
  1340. m_pMenuIcon = NULL;
  1341. m_pMenuControl = NULL;
  1342. }
  1344. void CMenuBar::OnDestroy() 
  1345. {
  1346. CControlBar::OnDestroy();
  1348. // TODO: 偙偺埵抲偵儊僢僙乕僕 僴儞僪儔梡偺僐乕僪傪捛壛偟偰偔偩偝偄
  1349. _KillTimer();
  1350. DeleteItems();
  1351. }
  1353. int CMenuBar::GetNextOrPrevButton(int nIndex, BOOL bPrev)
  1354. {
  1355. int nCount = GetItemCount();
  1356. if (bPrev) { // <-
  1357. --nIndex;
  1358. if (nIndex < 0)
  1359. nIndex = nCount - 1;
  1360. }
  1361. else { // ->
  1362. ++nIndex;
  1363. if (nIndex >= nCount)
  1364. nIndex = 0;
  1365. }
  1367. if (!m_arrItem[nIndex]->CanTrack() || !m_arrItem[nIndex]->IsValid()) {
  1368. return GetNextOrPrevButton(nIndex, bPrev);
  1369. }
  1371. return nIndex;
  1372. }
  1374. void CMenuBar::AddIcon(HICON hIcon)
  1375. {
  1376. // ASSERT(m_bIcon == FALSE);
  1378. // m_bIcon = TRUE;
  1379. }
  1381. CMenuControl::CMenuControl(CControlBar* pBar)
  1382. {
  1383. m_bValid = FALSE;
  1384. m_pBar = pBar;
  1385. m_bDown = FALSE;
  1386. m_nTracking = -1;
  1388. int cxCaption = cyMenuButton - CYGAP + 1;
  1389. m_sizeHorz = CSize(cxCaption*3 + CXGAP/2, cyMenuButton);
  1390. }
  1392. CMenuControl::~CMenuControl()
  1393. {
  1395. }
  1397. void CMenuControl::Update(CDC* pDC)
  1398. {
  1399. // do nothing
  1400. }
  1402. void CMenuControl::Layout(CPoint point, BOOL bHorz)
  1403. {
  1404. LTRACE("CMenuControl::Layout bHorz:%dn", bHorz);
  1405. m_bHorz = bHorz;
  1407. // just layout easily
  1408. if (bHorz) {
  1409. m_rcItem = CRect(point, m_sizeHorz);
  1410. }
  1411. else {
  1412. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  1413. }
  1414. }
  1416. void CMenuControl::DelayLayoutAndDraw(CDC* pDC, CSize sizeBar)
  1417. {
  1418. // if (!IsValid())
  1419. // return;
  1421. // layout
  1422. if (m_bHorz) {
  1423. int cxCaption = cyMenuButton - CYGAP + 1;
  1424. int cyCaption = cxCaption - 1;
  1425. CRect rcCaption;
  1426. rcCaption.right = sizeBar.cx;
  1427. rcCaption.bottom = sizeBar.cy - CYGAP;
  1428. rcCaption.left = rcCaption.right - cxCaption;
  1429. rcCaption.top = rcCaption.bottom - cyCaption;
  1431. m_arrCaption[0] = rcCaption;
  1433. rcCaption -= CPoint(cxCaption+CXGAP/2, 0);
  1434. m_arrCaption[1] = rcCaption;
  1436. rcCaption -= CPoint(cxCaption, 0);
  1437. m_arrCaption[2] = rcCaption;
  1439. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  1440. m_arrCaption[0].right, m_arrCaption[0].bottom);
  1441. }
  1442. else {
  1443. int cxCaption = cyMenuButton - CYGAPVERT - 1;
  1444. int cyCaption = cxCaption - 1;
  1445. CRect rcCaption;
  1446. rcCaption.left = CYGAPVERT;
  1447. rcCaption.bottom = sizeBar.cy;
  1448. rcCaption.right = rcCaption.left + cxCaption;
  1449. rcCaption.top = rcCaption.bottom - cyCaption;
  1451. m_arrCaption[0] = rcCaption;
  1453. rcCaption -= CPoint(0, cyCaption+CXGAP/2);
  1454. m_arrCaption[1] = rcCaption;
  1456. rcCaption -= CPoint(0, cyCaption);
  1457. m_arrCaption[2] = rcCaption;
  1459. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  1460. m_arrCaption[0].right, m_arrCaption[0].bottom);
  1461. }
  1463. if (!IsValid())
  1464. return;
  1466. // draw frame controls
  1467. for (int i = 0; i < 3; ++i) {
  1468. DrawControl(pDC, i, FALSE);
  1469. }
  1471. // pDC->DrawFrameControl(m_arrCaption[0], DFC_CAPTION, DFCS_CAPTIONCLOSE);
  1472. // pDC->DrawFrameControl(m_arrCaption[1], DFC_CAPTION, DFCS_CAPTIONRESTORE);
  1473. // pDC->DrawFrameControl(m_arrCaption[2], DFC_CAPTION, DFCS_CAPTIONMIN);
  1474. }
  1477. // pasted from CDockContext
  1478. void CMenuBarDockContext::StartDrag(CPoint pt)
  1479. {
  1480. ASSERT_VALID(m_pBar);
  1481. m_bDragging = TRUE;
  1483. InitLoop();
  1485. if (m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC)
  1486. {
  1487. // get TRUE bar size (including borders)
  1488. CRect rect;
  1489. m_pBar->GetWindowRect(rect);
  1490. m_ptLast = pt;
  1491. CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  1492. CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  1493. CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  1495. m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1496. m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1498. // calculate frame dragging rectangle
  1499. m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  1500. m_rectFrameDragVert = CRect(rect.TopLeft(), sizeFloat);
  1502. #ifdef _MAC
  1503. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz,
  1504. WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX);
  1505. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert,
  1506. WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX);
  1507. #else
  1508. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1509. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1510. #endif
  1511. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1512. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1513. }
  1514. else if (m_pBar->m_dwStyle & CBRS_SIZE_FIXED)
  1515. {
  1516. // get TRUE bar size (including borders)
  1517. CRect rect;
  1518. m_pBar->GetWindowRect(rect);
  1519. m_ptLast = pt;
  1520. CSize sizeHorz = m_pBar->CalcDynamicLayout(-1, LM_HORZ | LM_HORZDOCK);
  1521. CSize sizeVert = m_pBar->CalcDynamicLayout(-1, LM_VERTDOCK);
  1523. // calculate frame dragging rectangle
  1524. m_rectFrameDragHorz = m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1525. m_rectFrameDragVert = m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1527. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1528. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1529. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1530. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1531. }
  1532. else
  1533. {
  1534. // get TRUE bar size (including borders)
  1535. CRect rect;
  1536. m_pBar->GetWindowRect(rect);
  1537. m_ptLast = pt;
  1538. BOOL bHorz = HORZF(m_dwStyle);
  1539. DWORD dwMode = !bHorz ? (LM_HORZ | LM_HORZDOCK) : LM_VERTDOCK;
  1540. CSize size = m_pBar->CalcDynamicLayout(-1, dwMode);
  1542. // calculate inverted dragging rect
  1543. if (bHorz)
  1544. {
  1545. m_rectDragHorz = rect;
  1546. m_rectDragVert = CRect(CPoint(pt.x - rect.Height()/2, rect.top), size);
  1547. }
  1548. else // vertical orientation
  1549. {
  1550. m_rectDragVert = rect;
  1551. m_rectDragHorz = CRect(CPoint(rect.left, pt.y - rect.Width()/2), size);
  1552. }
  1554. // calculate frame dragging rectangle
  1555. m_rectFrameDragHorz = m_rectDragHorz;
  1556. m_rectFrameDragVert = m_rectDragVert;
  1558. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1559. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1560. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1561. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1562. }
  1564. // adjust rectangles so that point is inside
  1565. AdjustRectangle(m_rectDragHorz, pt);
  1566. AdjustRectangle(m_rectDragVert, pt);
  1567. AdjustRectangle(m_rectFrameDragHorz, pt);
  1568. AdjustRectangle(m_rectFrameDragVert, pt);
  1570. // initialize tracking state and enter tracking loop
  1571. m_dwOverDockStyle = CanDock();
  1572. Move(pt);   // call it here to handle special keys
  1573. _Track();
  1574. }
  1576. BOOL CMenuBarDockContext::_Track()
  1577. {
  1578. // don't handle if capture already set
  1579. if (::GetCapture() != NULL)
  1580. return FALSE;
  1582. // set capture to the window which received this message
  1583. m_pBar->SetCapture();
  1584. ASSERT(m_pBar == CWnd::GetCapture());
  1586. #ifndef _MAC
  1587. // get messages until capture lost or cancelled/accepted
  1588. while (CWnd::GetCapture() == m_pBar)
  1589. {
  1590. MSG msg;
  1591. if (!::GetMessage(&msg, NULL, 0, 0))
  1592. {
  1593. AfxPostQuitMessage(msg.wParam);
  1594. break;
  1595. }
  1597. switch (msg.message)
  1598. {
  1599. case WM_LBUTTONUP:
  1600. if (m_bDragging)
  1601. _EndDrag();
  1602. else
  1603. EndResize();
  1604. return TRUE;
  1605. case WM_MOUSEMOVE:
  1606. if (m_bDragging)
  1607. Move(msg.pt);
  1608. else
  1609. Stretch(msg.pt);
  1610. break;
  1611. case WM_KEYUP:
  1612. if (m_bDragging)
  1613. OnKey((int)msg.wParam, FALSE);
  1614. break;
  1615. case WM_KEYDOWN:
  1616. if (m_bDragging)
  1617. OnKey((int)msg.wParam, TRUE);
  1618. if (msg.wParam == VK_ESCAPE)
  1619. {
  1620. CancelLoop();
  1621. return FALSE;
  1622. }
  1623. break;
  1624. case WM_RBUTTONDOWN:
  1625. CancelLoop();
  1626. return FALSE;
  1628. // just dispatch rest of the messages
  1629. default:
  1630. DispatchMessage(&msg);
  1631. break;
  1632. }
  1633. }
  1634. #else
  1635. Point   ptCur = {0};
  1637. // get messages until capture lost or cancelled/accepted
  1638. while (CWnd::GetCapture() == m_pBar)
  1639. {
  1640. EventRecord     er;
  1642. if (OSEventAvail(everyEvent, &er))
  1643. {
  1644. GetNextEvent(everyEvent, &er);
  1645. switch (er.what)
  1646. {
  1647. case mouseUp:
  1648. if (m_bDragging)
  1649. EndDrag();
  1650. else
  1651. EndResize();
  1652. return TRUE;
  1654. case keyDown:
  1655. case keyUp:
  1656. case autoKey:
  1657. case app2Evt:
  1658. {
  1659. MSG     msg;
  1661. if (WrapEvent(&er, &msg, PM_REMOVE))
  1662. {
  1663. if (m_bDragging)
  1664. OnKey((int)msg.wParam, msg.message == WM_KEYDOWN);
  1665. if (msg.message == WM_KEYUP && msg.wParam == VK_ESCAPE)
  1666. {
  1667. CancelLoop();
  1668. return FALSE;
  1669. }
  1670. }
  1671. break;
  1672. }
  1674. default:
  1675. break;
  1676. }
  1677. }
  1678. else
  1679. {
  1680. if (!EqualPt(er.where, ptCur))
  1681. {
  1682. POINT pt = {er.where.h, er.where.v};
  1683. if (m_bDragging)
  1684. Move(pt);
  1685. else
  1686. Stretch(pt);
  1687. }
  1688. }
  1689. }
  1690. #endif
  1691. CancelLoop();
  1693. return FALSE;
  1694. }
  1696. void CMenuBarDockContext::_EndDrag()
  1697. {
  1698. CancelLoop();
  1700. if (m_dwOverDockStyle != 0)
  1701. {
  1702. CDockBar* pDockBar = GetDockBar(m_dwOverDockStyle);
  1703. ASSERT(pDockBar != NULL);
  1705. CRect rect = (m_dwOverDockStyle & CBRS_ORIENT_VERT) ?
  1706. m_rectDragVert : m_rectDragHorz;
  1708. UINT uID = _AfxGetDlgCtrlID(pDockBar->m_hWnd);
  1709. if (uID >= AFX_IDW_DOCKBAR_TOP &&
  1710. uID <= AFX_IDW_DOCKBAR_BOTTOM)
  1711. {
  1712. m_uMRUDockID = uID;
  1713. m_rectMRUDockPos = rect;
  1714. pDockBar->ScreenToClient(&m_rectMRUDockPos);
  1715. }
  1717. // dock it at the specified position, RecalcLayout will snap
  1719. // insisting own line trick!
  1720. CRect rcDockBar;
  1721. pDockBar->GetWindowRect(rcDockBar);
  1723. if (m_dwOverDockStyle & CBRS_ORIENT_VERT) {
  1724. rect.top = rcDockBar.top - 1;
  1725. }
  1726. else {
  1727. rect.left = rcDockBar.left - 10;
  1728. }
  1730. m_pDockSite->DockControlBar(m_pBar, pDockBar, &rect);
  1731. m_pDockSite->RecalcLayout();
  1733. }
  1734. else if ((m_dwStyle & CBRS_SIZE_DYNAMIC) || (HORZF(m_dwStyle) && !m_bFlip) ||
  1735. (VERTF(m_dwStyle) && m_bFlip))
  1736. {
  1737. m_dwMRUFloatStyle = CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  1738. m_ptMRUFloatPos = m_rectFrameDragHorz.TopLeft();
  1739. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  1740. }
  1741. else // vertical float
  1742. {
  1743. m_dwMRUFloatStyle = CBRS_ALIGN_LEFT | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  1744. m_ptMRUFloatPos = m_rectFrameDragVert.TopLeft();
  1745. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  1746. }
  1747. }
  1750. void CMenuBar::OnPaintMDIClient()
  1751. {
  1752. LTRACE("CMenuBar::OnPaintMDIClientn");
  1754. if (m_hWndMDIClient) {
  1755. BOOL bMax = FALSE;
  1756. // get active MDI child window
  1757. HWND hWndChild = (HWND)::SendMessage(m_hWndMDIClient, WM_MDIGETACTIVE, 0,
  1758. (LPARAM)&bMax);
  1759. //ASSERT(::IsWindow(hWndChild)); crash! tell me why!
  1761. if (bMax != m_bMDIMaximized) {
  1762. LTRACE("    max state changedn");
  1763. m_bMDIMaximized = bMax;
  1765. if (bMax) {
  1766. LTRACE("        maximizedn");
  1767. m_pMenuControl->Validate(TRUE);
  1768. m_pMenuIcon->Validate(TRUE);
  1769. }
  1770. else {
  1771. LTRACE("        not maximizedn");
  1772. m_pMenuControl->Validate(FALSE);
  1773. m_pMenuIcon->Validate(FALSE);
  1774. }
  1776. RefreshBar();
  1777. }
  1778. }
  1779. }
  1781. void CMenuBar::OnInitMenuPopup()
  1782. {
  1783. CMenu menu;
  1784. menu.Attach((HMENU)m_hWindowMenu);
  1786. // scan for first window command
  1787. int n = menu.GetMenuItemCount();
  1788. BOOL bAddSeperator = TRUE;
  1789. for (int iPos=0; iPos<n; iPos++) {
  1790. if (menu.GetMenuItemID(iPos) >= AFX_IDM_FIRST_MDICHILD) {
  1791. bAddSeperator = FALSE;
  1792. break;
  1793. }
  1794. }
  1796. // iPos is either first window item, or end if none found.
  1798. // delete everything after.
  1799. while (iPos < (int)menu.GetMenuItemCount())
  1800. menu.RemoveMenu(iPos, MF_BYPOSITION);
  1802. // get active window so I can check its menu item
  1803. ASSERT(m_hWndMDIClient);
  1804. HWND hwndActive = (HWND)::SendMessage(m_hWndMDIClient,
  1805. WM_MDIGETACTIVE, 0, NULL);
  1807. // append window names in the form "# title"
  1808. int iWin=1;
  1809. for (HWND hwnd=::GetWindow(m_hWndMDIClient, GW_CHILD);
  1810.   hwnd;
  1811.   hwnd = ::GetWindow(hwnd, GW_HWNDNEXT)) {
  1813. if (bAddSeperator) {
  1814. menu.InsertMenu(iPos++, MF_BYPOSITION|MF_SEPARATOR);
  1815. bAddSeperator = FALSE;
  1816. }
  1818. // build item name and add it to the menu
  1819. CString sWinName, sMenuItem;
  1820. CWnd::FromHandle(hwnd)->GetWindowText(sWinName);
  1821. sMenuItem.Format(_T("&%d  %s"), iWin++, (LPCTSTR)sWinName);
  1822. menu.InsertMenu(iPos, MF_BYPOSITION,
  1823. ::GetDlgCtrlID(hwnd), sMenuItem);
  1824. if (hwnd==hwndActive)
  1825. menu.CheckMenuItem(iPos, MF_BYPOSITION|MF_CHECKED);
  1826. iPos++;
  1827. }
  1828. menu.Detach();
  1829. }
  1831. void CMenuBar::OnSetMenu(HMENU hNewMenu, HMENU hWindowMenu)
  1832. {
  1833. // We can get active MDI child window on this message!
  1834. BOOL bMax;
  1835. HWND hWndChild = GetActiveChildWnd(bMax);
  1837. if (!m_hWndActiveChild || m_hWndActiveChild != hWndChild) {
  1838. // active child window changed
  1839. LTRACE("    active child window changedn");
  1840. m_hWndActiveChild = hWndChild;
  1841. // tell MenuIcon child window has been changed
  1842. m_pMenuIcon->OnActivateChildWnd(hWndChild);
  1843. }
  1845. LTRACE("CMenuBar::OnSetMenun");
  1847. if (!m_hMenu || m_hMenu != hNewMenu) { // menu changed
  1848. LTRACE("    menu changedn");
  1849. LoadMenu(hNewMenu, hWindowMenu); // set toolbar menu
  1850. GetOwner()->SetMenu(NULL); // clear frame menu
  1851. }
  1852. }
  1854. HWND CMenuBar::GetActiveChildWnd(BOOL& bMaximized)
  1855. {
  1856. if (!m_hWndMDIClient)
  1857. return NULL;
  1859. BOOL bMax = FALSE;
  1860. HWND hWnd = (HWND)::SendMessage(m_hWndMDIClient,
  1861. WM_MDIGETACTIVE, 0, (LPARAM)&bMax);
  1862. bMaximized = bMax;
  1864. return hWnd;
  1865. }
  1868. CMenuItem::CMenuItem()
  1869. {
  1870. m_itemState = none;
  1871. m_rcItem = CRect(0, 0, 0, 0);
  1872. m_sizeHorz = CSize(0, 0);
  1873. m_bHorz = TRUE;
  1874. m_bWrapped = FALSE;
  1875. }
  1877. CMenuItem::~CMenuItem()
  1878. {
  1880. }
  1882. CPoint CMenuItem::ComputeMenuTrackPoint(CWnd* pWnd, HMENU hSubMenu, TPMPARAMS& tpm, CFont* pFont)
  1883. {
  1884. ASSERT_VALID(pWnd);
  1885. ASSERT_VALID(pFont);
  1886. ASSERT(::IsMenu(hSubMenu));
  1888. tpm.cbSize = sizeof(tpm);
  1889. CRect& rcExclude = (CRect&)tpm.rcExclude;
  1890. CWnd::GetDesktopWindow()->GetWindowRect(&rcExclude);
  1892. CPoint pt;
  1893. CRect  rcItem = m_rcItem;
  1894. pWnd->ClientToScreen(&rcItem);
  1896. // if (hSubMenu == NULL) // it's possible no sub menu
  1897. // return CPoint();
  1899. if (m_bHorz) { // horizontal
  1900. int nCount = ::GetMenuItemCount(hSubMenu);
  1901. ASSERT(nCount != -1);
  1902. int cyPopup = nCount * rcItem.Height(); // I want it be not owner drawn but ordinary menu..
  1904. if (rcItem.bottom + cyPopup > rcExclude.bottom) {
  1905. pt = CPoint(rcItem.left, rcItem.top); // over Screen
  1906. rcExclude.top = rcItem.top;
  1907. }
  1908. else {
  1909. pt = CPoint(rcItem.left, rcItem.bottom);
  1910. }
  1912. pt += CPoint(-1, 1); // precisely same as DevStudio
  1913. }
  1914. else { // vertical
  1915. // we never get the width of popup up menu, but I will try
  1916. int nCount = ::GetMenuItemCount(hSubMenu);
  1917. ASSERT(nCount != -1);
  1919. int cxPopup = 0;
  1920. CWindowDC dc(NULL);
  1922. CFont* pOldFont = dc.SelectObject(pFont);
  1923. for (int i = 0; i < nCount; ++i) {
  1924. char szName[256];
  1925. MENUITEMINFO info;
  1926. ::ZeroMemory(&info, sizeof(MENUITEMINFO));
  1927. info.cbSize = sizeof(MENUITEMINFO);
  1928. info.fMask = MIIM_ID | MIIM_TYPE;
  1929. info.dwTypeData = szName;
  1930. info.cch = sizeof(szName);
  1931. ::GetMenuItemInfo(hSubMenu, i, TRUE, &info);
  1933. CString strItem(szName);
  1935. CRect rcText(0, 0, 0, 0);
  1936. dc.DrawText(strItem, &rcText,
  1937. DT_SINGLELINE | DT_VCENTER | DT_CALCRECT | DT_NOPREFIX);
  1938. int cxOffset = ::GetSystemMetrics(SM_CXMENUCHECK) * 2;
  1939. cxPopup = max(rcText.Width() + 4*2 + CXGAP*2 + cxOffset, cxPopup);
  1940. }
  1941. dc.SelectObject(pOldFont);
  1943. if (rcItem.right + cxPopup > rcExclude.right) { // over right-side
  1944. pt = CPoint(rcItem.left, rcItem.top);
  1945. rcExclude.left = rcItem.left;
  1946. }
  1947. else {
  1948. pt = CPoint(rcItem.right, rcItem.top);
  1949. rcExclude.right = rcItem.right;
  1950. }
  1952. pt += CPoint(1, -1); // precisely same as DevStudio
  1953. }
  1955. return pt;
  1956. }
  1958. CMenuIcon::CMenuIcon(CWnd* pWnd)
  1959. {
  1960. m_hDocIcon = NULL;//hIcon;
  1961. m_sizeHorz = CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON));
  1962. m_bValid = FALSE;
  1963. m_hSysMenu = NULL;//::GetSystemMenu(pWnd->GetSafeHwnd(), FALSE);
  1964. }
  1966. CMenuIcon::~CMenuIcon()
  1967. {
  1969. }
  1971. void CMenuIcon::Update(CDC* pDC)
  1972. {
  1973. ASSERT(m_hDocIcon);
  1974. ASSERT(m_bValid);
  1976. ::DrawIconEx(pDC->m_hDC, m_rcItem.left, m_rcItem.top, m_hDocIcon,
  1977. m_sizeHorz.cx, m_sizeHorz.cy, 0, NULL, DI_NORMAL);
  1978. }
  1980. void CMenuIcon::TrackPopup(CWnd* pWnd)
  1981. {
  1982. ASSERT(m_hDocIcon);
  1983. ASSERT(m_bValid);
  1984. ASSERT(::IsMenu(m_hSysMenu));
  1986. NONCLIENTMETRICS info;
  1987. info.cbSize = sizeof(info);
  1988. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  1989. CFont fontSys;
  1990. if (!fontSys.CreateFontIndirect(&info.lfMenuFont))
  1991. return;
  1993. TPMPARAMS tpm;
  1994. CPoint pt = ComputeMenuTrackPoint(pWnd, m_hSysMenu, tpm, &fontSys);
  1996. ::TrackPopupMenuEx(m_hSysMenu,
  1997. TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
  1998. pt.x, pt.y, pWnd->GetOwner()->GetSafeHwnd(), &tpm);
  1999. }
  2001. void CMenuIcon::Layout(CPoint point, BOOL bHorz)
  2002. {
  2003. ASSERT(m_bValid);
  2005. m_bHorz = bHorz;
  2006. m_rcItem = CRect(point, m_sizeHorz);
  2007. }
  2009. void CMenuIcon::OnActivateChildWnd(HWND hWndChild)
  2010. {
  2011. TRACE("CMenuIcon::OnActivateChildWndn");
  2012. ASSERT(::IsWindow(hWndChild));
  2013. m_hSysMenu = ::GetSystemMenu(hWndChild, FALSE);
  2014. ASSERT(::IsMenu(m_hSysMenu));
  2015. m_hDocIcon = (HICON)GetClassLong(hWndChild, GCL_HICONSM);
  2016. }
  2019. BOOL CMenuControl::OnMouseMsg(UINT msg, UINT nFlags, CPoint pt)
  2020. {
  2021. if (!IsValid())
  2022. return FALSE;
  2024. if (msg == WM_LBUTTONDOWN) {
  2025. m_nTracking = HitTest(pt);
  2026. if (m_nTracking >= 0) {
  2027. CClientDC dc(m_pBar);
  2028. DrawControl(&dc, m_nTracking, TRUE);
  2029. m_bDown = TRUE;
  2030. m_pBar->SetCapture();   // grab mouse input
  2031. return TRUE;
  2032. }
  2033. }
  2034. else if ((msg == WM_MOUSEMOVE) && m_nTracking >= 0) {
  2035. // mouse moved, and I am tracking: possibly draw button up/down
  2036. BOOL bOldDown = m_bDown;
  2037. m_bDown = m_arrCaption[m_nTracking].PtInRect(pt);
  2038. if (bOldDown != m_bDown) {
  2039. // up/down state changed: need to redraw button
  2040. CClientDC dc(m_pBar);
  2041. DrawControl(&dc, m_nTracking, m_bDown);
  2042. }
  2043. return TRUE; // handled
  2045. }
  2046. else if (msg == WM_LBUTTONUP && m_nTracking >= 0) {
  2047. // user released the mouse and I am tracking: do button command
  2048. ReleaseCapture(); // let go the mouse
  2049. if (m_bDown) {
  2050. // if button was down when released: draw button up, and do system cmd
  2051. CClientDC dc(m_pBar);
  2052. DrawControl(&dc, m_nTracking, FALSE);
  2053. CFrameWnd* pFrame = m_pBar->GetTopLevelFrame()->GetActiveFrame();
  2054. ASSERT_VALID(pFrame);
  2055. static syscmd[3] =
  2056. { /*SC_MOUSEMENU,*/ SC_CLOSE, SC_RESTORE, SC_MINIMIZE };
  2057. pFrame->SendMessage(WM_SYSCOMMAND, syscmd[m_nTracking]);
  2058. }
  2059. m_nTracking = -1; // stop tracking
  2060. return TRUE;   // handled (eat)
  2061. }
  2063. return FALSE;
  2064. }
  2066. int CMenuControl::HitTest(CPoint point)
  2067. {
  2068. for (int i = 0; i < 3; ++i) {
  2069. if (m_arrCaption[i].PtInRect(point))
  2070. return i;
  2071. }
  2073. return -1;
  2074. }
  2077. void CMenuControl::DrawControl(CDC* pDC, int nIndex, BOOL bPressed)
  2078. {
  2079. // draw frame controls
  2080. CRect& rc = m_arrCaption[nIndex];
  2081. static UINT dfcs[3] = { DFCS_CAPTIONCLOSE, DFCS_CAPTIONRESTORE, DFCS_CAPTIONMIN };
  2082. UINT uState = dfcs[nIndex];
  2083. if (bPressed)
  2084. uState |= DFCS_PUSHED;
  2085. pDC->DrawFrameControl(rc, DFC_CAPTION, uState);
  2086. }
  2088. void CMenuControl::ForceDrawControl(CDC * pDC)
  2089. {
  2090. if (!IsValid())
  2091. return;
  2093. for (int i = 0; i < 3; ++i) {
  2094. DrawControl(pDC, i, FALSE);
  2095. }
  2096. }
  2099. namespace {
  2101. const int CXTEXTMARGIN   = 5;
  2102. int CYTEXTMARGIN   = 0;
  2103. const int CYTEXTMARGINMIN = 2;
  2105. CFont fontHorz, fontVert;
  2107. // const int CXGAP = 3;
  2109. }// anonymouse namespace
  2111. CMenuButton::CMenuButton(HMENU hMenu, int nIndex)
  2112. {
  2113. ASSERT(hMenu);
  2114. InitButtonStringAndSubMenuHandle(hMenu, nIndex);
  2115. InitHorizontalButtonSize();
  2116. InitAccessKeyAndVerticalLinePoint();
  2117. }
  2119. CMenuButton::~CMenuButton()
  2120. {
  2122. }
  2124. BOOL CMenuButton::InitCommonResource()
  2125. {
  2126. // clean up
  2127. fontHorz.DeleteObject();
  2128. fontVert.DeleteObject();
  2130. // create fonts
  2131. NONCLIENTMETRICS info;
  2132. info.cbSize = sizeof(info);
  2133. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  2134. if (!fontHorz.CreateFontIndirect(&info.lfMenuFont))
  2135. return FALSE;
  2137. info.lfMenuFont.lfEscapement = -900;
  2138. info.lfMenuFont.lfOrientation = -900;
  2139. if (!fontVert.CreateFontIndirect(&info.lfMenuFont))
  2140. return FALSE;
  2143. // get font height
  2144. LOGFONT logfont;
  2145. fontHorz.GetLogFont(&logfont);
  2146. int cyFont = abs(logfont.lfHeight);
  2148. // calc Y text margin
  2149. int cyText = cyFont + CYTEXTMARGINMIN*2;
  2150. int cyMenu = ::GetSystemMetrics(SM_CYMENU);
  2151. if (cyMenu > cyText) {
  2152. CYTEXTMARGIN = (cyMenu - cyFont)/2;
  2153. }
  2154. else {
  2155. CYTEXTMARGIN = CYTEXTMARGINMIN;
  2156. }
  2158. return TRUE;
  2159. }
  2161. void CMenuButton::InitButtonStringAndSubMenuHandle(HMENU hMenu, int nIndex)
  2162. {
  2163. // get menu button Text
  2164. char szText[256];
  2165. MENUITEMINFO info; ::ZeroMemory(&info, sizeof(MENUITEMINFO));
  2166. info.cbSize = sizeof(MENUITEMINFO);
  2167. info.fMask = MIIM_ID | MIIM_TYPE;
  2168. info.dwTypeData = szText;
  2169. info.cch = sizeof(szText);
  2170. ::GetMenuItemInfo(hMenu, nIndex, TRUE, &info);
  2171. m_strBtn = CString(szText);
  2173. m_hSubMenu = ::GetSubMenu(hMenu, nIndex);
  2174. }
  2176. void CMenuButton::InitHorizontalButtonSize()
  2177. {
  2178. // get menu button Text size
  2179. ASSERT(m_strBtn.IsEmpty() == FALSE);
  2181. CWindowDC dc(NULL);
  2182. CRect rcText(0, 0, 0, 0);
  2183. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2184. dc.DrawText(m_strBtn, &rcText, DT_SINGLELINE | DT_CALCRECT);
  2185. dc.SelectObject(pOldFont);
  2186. m_sizeHorz.cx = rcText.Width() + CXTEXTMARGIN*2;
  2188. LOGFONT logfont;
  2189. fontHorz.GetLogFont(&logfont);
  2190. int cyFont = abs(logfont.lfHeight);
  2191. m_sizeHorz.cy = cyFont + CYTEXTMARGIN*2;
  2192. }
  2194. void CMenuButton::InitAccessKeyAndVerticalLinePoint()
  2195. {
  2196. int nIndex = m_strBtn.Find('&');
  2197. m_cAccessKey = m_strBtn[nIndex + 1]; // -1 + 1 = 0; it's ok
  2199. if (nIndex == -1) {
  2200. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2201. }
  2202. else if (nIndex == 0) {
  2203. CRect rcTo;
  2204. CWindowDC dc(NULL);
  2205. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2206. dc.DrawText(m_strBtn.Left(nIndex+2), &rcTo, DT_SINGLELINE | DT_CALCRECT);
  2207. dc.SelectObject(pOldFont);
  2209. m_ptLineFrom = CPoint(CYTEXTMARGIN, CXTEXTMARGIN);
  2210. m_ptLineTo  = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcTo.Width());
  2211. }
  2212. else {
  2213. CRect rcFrom, rcTo;
  2214. CWindowDC dc(NULL);
  2215. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2216. dc.DrawText(m_strBtn.Left(nIndex), &rcFrom, DT_SINGLELINE | DT_CALCRECT);
  2217. dc.DrawText(m_strBtn.Left(nIndex+2), &rcTo, DT_SINGLELINE | DT_CALCRECT);
  2218. dc.SelectObject(pOldFont);
  2220. m_ptLineFrom = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcFrom.Width());
  2221. m_ptLineTo = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcTo.Width());
  2222. }
  2223. }
  2225. void CMenuButton::Layout(CPoint point, BOOL bHorz)
  2226. {
  2227. if (bHorz == TRUE) {
  2228. m_rcItem = CRect(point, m_sizeHorz);
  2229. }
  2230. else {
  2231. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  2232. }
  2234. m_bHorz = bHorz;
  2235. }
  2237. void CMenuButton::Update(CDC* pDC)
  2238. {
  2239. // clean background
  2240. COLORREF clr = ::GetSysColor(COLOR_BTNFACE);
  2241. pDC->FillSolidRect(m_rcItem, clr);
  2243. switch (m_itemState) {
  2244. case hot:
  2245. DrawHot(pDC);
  2246. break;
  2247. case select:
  2248. DrawSelect(pDC);
  2249. break;
  2250. case none:
  2251. DrawNone(pDC);
  2252. break;
  2253. default:
  2254. ASSERT(TRUE);
  2255. }
  2256. }
  2258. void CMenuButton::TrackPopup(CWnd* pWnd)
  2259. {
  2260. TPMPARAMS tpm;
  2261. CPoint pt = ComputeMenuTrackPoint(pWnd, m_hSubMenu, tpm, &fontHorz);
  2263. ::TrackPopupMenuEx(m_hSubMenu,
  2264. TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
  2265. pt.x, pt.y, pWnd->GetOwner()->GetSafeHwnd(), &tpm);
  2266. }
  2268. void CMenuButton::DrawHorzText(CDC* pDC, CPoint ptOffset)
  2269. {
  2270. CRect rcBtn = m_rcItem;
  2271. pDC->SetBkMode(TRANSPARENT);
  2272. CFont* pOldFont = pDC->SelectObject(&fontHorz);
  2273. // I know precise text size
  2274. rcBtn.DeflateRect(CXTEXTMARGIN, CYTEXTMARGIN);
  2275. pDC->DrawText(m_strBtn, rcBtn + ptOffset,
  2276. DT_SINGLELINE);// | DT_CENTER | DT_VCENTER); no need
  2278. pDC->SelectObject(pOldFont);
  2279. }
  2281. void CMenuButton::DrawVertText(CDC* pDC, CPoint ptOffset)
  2282. {
  2283. CRect rcBtn = m_rcItem;
  2284. int nLength = m_strBtn.GetLength();
  2285. int nIndex = m_strBtn.Find('&');
  2286. CString strBtn = m_strBtn.Left(nIndex) + m_strBtn.Right(nLength - (nIndex+1));
  2288. pDC->SetBkMode(TRANSPARENT);
  2289. CFont* pOldFont = pDC->SelectObject(&fontVert);
  2290. // I must know precise text size
  2291. CRect rcString = CRect(
  2292. CPoint(rcBtn.right - CYTEXTMARGIN, rcBtn.top + CXTEXTMARGIN), m_sizeHorz);
  2293. pDC->DrawText(strBtn, rcString + ptOffset,
  2294. DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX); // don't forget DT_NOCLIP
  2296. pDC->SelectObject(pOldFont);
  2298. // DrawText is poor, so we have to draw vertical line by ourselves
  2299. pDC->MoveTo(rcBtn.TopLeft() + m_ptLineFrom + ptOffset);
  2300. pDC->LineTo(rcBtn.TopLeft() + m_ptLineTo + ptOffset);
  2301. }
  2303. void CMenuButton::DrawHot(CDC* pDC)
  2304. {
  2305. if (m_bHorz) {
  2306. // draw down button
  2307. pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2308. DrawHorzText(pDC);
  2309. }
  2310. else {
  2311. pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2312. DrawVertText(pDC);
  2313. }
  2314. }
  2316. void CMenuButton::DrawSelect(CDC* pDC)
  2317. {
  2318. if (m_bHorz) {
  2319. // draw pressed button
  2320. pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2321. DrawHorzText(pDC, CPoint(1, 1));
  2322. }
  2323. else {
  2324. pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2325. DrawVertText(pDC, CPoint(1, 1));
  2326. }
  2327. }
  2329. void CMenuButton::DrawNone(CDC* pDC)
  2330. {
  2331. if (m_bHorz) {
  2332. DrawHorzText(pDC);
  2333. }
  2334. else {
  2335. DrawVertText(pDC);
  2336. }
  2337. }
  2339. int CMenuBar::OnActivateFrame(int nCmdShow)
  2340. {
  2341. CFrameWnd* pFrame = GetParentFrame();
  2342. ASSERT_VALID(pFrame);
  2343. if (pFrame->GetMenu() != NULL) {
  2344. LTRACE(" has menun");
  2345. pFrame->SetMenu(NULL);
  2346. }
  2347. m_nCmdShow = nCmdShow;
  2348. return SW_HIDE;
  2349. }