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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 查看源码
MenuBar.cpp
资源名称：GPRS开发包.rar　[点击查看]
上传用户：lmzg333
上传日期：2013-04-15
资源大小：376k
文件大小：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 , this will change the height of menubar
  61. const int CXGAP    = 5;
  62. const int CYGAP    = 6;
  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);
  192. // frame control
  193. m_pMenuControl = new CMenuControl(this);
  194. m_arrItem.Add(m_pMenuControl);
  195.     
  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. //return CSize(400,100);
  781. }
  783. // in fact, it's never called
  784. CSize CMenuBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  785. {
  786. // LTRACE("CMenuBar::CalcFixedLayoutn");
  788. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  789. dwMode |= bHorz ? LM_HORZ : 0;
  791. return CalcLayout(dwMode);
  792. }
  794. CSize CMenuBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  795. {
  796. LTRACE("CMenuBar::CalcDynamicLayoutn");
  798. // Who can understand what "dwMode" means?
  799. // 
  800. // If you want it be pricisely same as DevStudio style,
  801. // I think you have to create a "CDockContext" derived class.
  802. // This is the reason why everyone think "CControlBar class" junk ? 
  804. ASSERT_VALID(this);
  805. ASSERT_VALID(m_pDockSite);
  806. ASSERT_VALID(m_pDockBar);
  808. if (m_hMenu == NULL) // if have no menu yet, just return
  809. return CSize(0, 0);
  811. if (IsFloating()) {
  812. CFrameWnd* pFrame = GetParentFrame();
  813. ASSERT_VALID(pFrame);
  814. CMenu* pSysMenu = pFrame->GetSystemMenu(FALSE);
  815. ASSERT_VALID(pSysMenu);
  816. pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_DISABLED);
  817. }
  819. if (dwMode & LM_HORZ) { // horizontal
  820. // LTRACE("    horizontaln");
  821. if (dwMode & LM_HORZDOCK) {
  822. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_VERT)) { // if Floating->Docking, return min size
  823. // LTRACE("    return min sizen");
  824. return CalcLayout(dwMode);
  825. //return CalcSize(GetItemCount()); //Modify by xhs
  826. }
  827. else {
  828. if (m_pDockContext->m_pDC) { // now dragging
  829. // return DockBar size
  830. //LTRACE("    now dragging, so calc with DockBarn");
  831. CSize size = CalcSize(GetItemCount());//CalcLayout(dwMode);
  832. CRect rcFrame;
  833. m_pDockBar->GetWindowRect(rcFrame);
  834. CRect rcBar;
  835. GetWindowRect(rcBar);
  836. rcBar.right = rcFrame.right;
  837. return CSize(rcBar.Width() + cxBorder2, size.cy);
  838. //return CalcSize(GetItemCount()); //Modify by xhs
  839. }
  840. else {
  841. //LTRACE("    no draggin calc bigger sizen");
  842. CRect rcFrame;
  843. m_pDockSite->GetWindowRect(rcFrame);
  844. SizeMenuBar(GetItemCount(), rcFrame.Width() - cxBorder2*2, FALSE);
  845. CalcFloatingLayout();
  846. CSize size1 = CalcSize(GetItemCount());
  847. return CSize(rcFrame.Width(), size1.cy);
  848.     //return CalcSize(GetItemCount()); //Modify by xhs
  849. }
  850. }
  851. }
  852. else if (dwMode & LM_MRUWIDTH) { // floating size
  853. //LTRACE("    return floating sizen");
  854. SizeMenuBar(GetItemCount(), m_nMRUWidth, FALSE); // load floating Bar Width! 
  855. CalcFloatingLayout();
  856. return CalcSize(GetItemCount());
  857. }
  858. else if (dwMode & LM_COMMIT) {
  859. //LTRACE("    commit, just calc: %dn", nLength);
  860. m_nMRUWidth = nLength; // save floating Bar Width!!! (used when SaveBarState)
  861. CalcFloatingLayout();
  862. return CSize(0, 0); // MFC does'nt use this Size
  863. }
  864. else if (dwMode & LM_LENGTHY) {
  865. //LTRACE("    nLength is height : %dn", nLength);
  866. SizeMenuBar(GetItemCount(), nLength, TRUE);
  867. return CalcSize(GetItemCount());
  868. }
  869. else {
  870. //LTRACE("    nLength is width  : %dn", nLength);
  871. SizeMenuBar(GetItemCount(), nLength, FALSE);
  872. return CalcSize(GetItemCount());
  873. }
  874. ASSERT(TRUE);
  875. }
  876. else { // vertical
  877. InvalidateRect(NULL); // force to repaint!!!
  878. //LTRACE("    verticaln");
  879. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_HORZ)) { // if Floating->Docking, return min size
  880. //LTRACE("    return min sizen");
  881. return CalcLayout(dwMode);
  882. }
  883. else { // return large size
  884. if (m_pDockContext->m_pDC) { // CDockContext::m_bDragging is not helpful :(
  885. //LTRACE("    now dragging, so calc with DockBarn");
  886. CSize size = CalcLayout(dwMode);
  887. CRect rcFrame;
  888. m_pDockBar->GetWindowRect(rcFrame);
  889. CRect rcBar;
  890. GetWindowRect(rcBar);
  891. rcBar.bottom = rcFrame.bottom;
  892. return CSize(size.cx, rcBar.Height());
  893. }
  894. else {
  895. //LTRACE("    no dragging, return biggest sizen");
  897. CSize size = CalcLayout(dwMode);
  898. CRect rcFrame;
  899. m_pDockSite->GetWindowRect(rcFrame);
  900. CRect rcBar;
  901. GetWindowRect(rcBar);
  902. rcBar.bottom = rcFrame.bottom;
  903. return CSize(size.cx, rcFrame.Height());
  904. }
  905. }
  906. }
  908. ASSERT(TRUE); // never come here
  909. return CalcLayout(dwMode, nLength);
  910. }
  912. void CMenuBar::DrawGripper(CDC* pDC)
  913. {
  914. if( (m_dwStyle & CBRS_FLOATING) || m_dwDockStyle == 0 )
  915. return;
  917. CRect rcGrip;
  918. GetClientRect(&rcGrip);
  920. if(m_dwStyle & CBRS_ORIENT_HORZ) {
  921. // gripper at left
  922. //rcGrip.DeflateRect(4, 3);
  923. rcGrip.right = rcGrip.left + 3;
  924. //pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  925. rcGrip.OffsetRect(4, 0);
  926.         pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  927. }
  928. else {
  929. // gripper at top
  930. rcGrip.DeflateRect(3, 4);
  931. rcGrip.bottom = rcGrip.top + 3;
  932. pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  933. //rcGrip.OffsetRect(0, 4);
  934. //pDC->DrawEdge(rcGrip, BDR_RAISEDINNER, BF_RECT);
  935. }
  936. }
  938. #define CX_BORDER   1
  939. #define CY_BORDER   1
  941. void CMenuBar::DrawBorder(CDC* pDC)
  942. {
  943. if( (m_dwStyle & CBRS_FLOATING) || m_dwDockStyle == 0 )
  944. return;
  946. CRect rect;
  947. GetClientRect(rect);
  949. DWORD dwStyle = m_dwStyle;
  950. if (!(dwStyle & CBRS_BORDER_ANY))
  951. return;
  953. CRect rect3 = rect;
  954. if (m_dwStyle & CBRS_ORIENT_HORZ) {
  955. rect3.left += cxBorder2;//rect.DeflateRect(2, 0);
  956. pDC->DrawEdge(rect3, BDR_RAISEDINNER ,BF_LEFT);
  957. }
  958. else {
  959. rect3.top += cyBorder2;//rect.DeflateRect(0, 2);
  960. pDC->DrawEdge(rect3,BDR_RAISEDINNER ,  BF_TOP);
  961. }
  963. // prepare for dark lines
  964. ASSERT(rect.top == 0 && rect.left == 0);
  965. CRect rect1, rect2;
  966. rect1 = rect;
  967. rect2 = rect;
  968. COLORREF clr = ::GetSysColor(COLOR_BTNSHADOW);//afxData.bWin4 ? afxData.clrBtnShadow : afxData.clrWindowFrame;
  970. // draw dark line one pixel back/up
  971. if (dwStyle & CBRS_BORDER_3D)
  972. {
  973. rect1.right -= CX_BORDER;
  974. rect1.bottom -= CY_BORDER;
  975. }
  976. if (dwStyle & CBRS_BORDER_TOP)
  977. rect2.top += CY_BORDER;//cyBorder2;
  979. if (dwStyle & CBRS_BORDER_BOTTOM)
  980. rect2.bottom -= CY_BORDER;
  982. if (dwStyle & CBRS_BORDER_LEFT)
  983. rect2.left += CX_BORDER;
  985. if (dwStyle & CBRS_BORDER_RIGHT)
  986. rect2.right -= CX_BORDER;
  988. if (dwStyle & CBRS_BORDER_3D)
  989. {
  990. // draw left and top
  991. if (dwStyle & CBRS_BORDER_LEFT)
  992. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_LEFT);//pDC->FillSolidRect(1, rect2.top, CX_BORDER, rect2.Height(), clr);
  993. if (dwStyle & CBRS_BORDER_TOP)
  994. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_TOP);//pDC->FillSolidRect(0, 1, rect.right, CY_BORDER, clr);
  996. // draw right and bottom
  997. if (dwStyle & CBRS_BORDER_RIGHT)
  998. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_RIGHT);//pDC->FillSolidRect(rect.right, rect2.top, -CX_BORDER, rect2.Height(), clr);
  999. if (dwStyle & CBRS_BORDER_BOTTOM)
  1000. pDC->DrawEdge(rect2, BDR_RAISEDINNER, BF_BOTTOM);//pDC->FillSolidRect(0, rect.bottom, rect.right, -CY_BORDER, clr);
  1001. }
  1003. }
  1005. /////////////////////////////////////////////////////////////////////////////
  1006. // CMenuBarFrameHook implementation
  1007. CMenuBarFrameHook::CMenuBarFrameHook()
  1008. {
  1009. m_pMenuBar = NULL;
  1010. }
  1012. BOOL CMenuBarFrameHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  1013. {
  1014. ASSERT_VALID(pMenuBar);
  1015. ASSERT(m_pMenuBar == NULL);
  1016. m_pMenuBar = pMenuBar;
  1017. return HookWindow(hWndToHook);//CWnd::FromHandlePermanent(hWndToHook));
  1018. }
  1020. CMenuBarFrameHook::~CMenuBarFrameHook()
  1021. {
  1022. }
  1024. LRESULT CMenuBarFrameHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  1025. {
  1026. ASSERT_VALID(m_pMenuBar);
  1028. switch (nMsg) {
  1029. case WM_MENUSELECT:
  1030. m_pMenuBar->OnMenuSelect((HMENU)lParam, (UINT)LOWORD(wParam));
  1031. break;
  1033. // The following messages are trapped for the MDI client window
  1034. case WM_INITMENUPOPUP:
  1035. LTRACE("CMenuBar::WM_INITMENUPOPUPn");
  1036. if (!HIWORD(lParam) && (HMENU)wParam == m_pMenuBar->m_hWindowMenu)
  1037. m_pMenuBar->OnInitMenuPopup();
  1038. break;
  1041. case WM_MDISETMENU: // only sent to MDI client window
  1042. // Setting new frame/window menu: bypass MDI. wParam is new menu.
  1043. if (wParam) {
  1044. LTRACE("CMenuBar::WM_MDISETMENU 0x%04xn", wParam);
  1045. // HMENU hNewMenu = (HMENU)wParam;
  1046. m_pMenuBar->OnSetMenu((HMENU)wParam, (HMENU)lParam);
  1047. }
  1048. return 0;
  1050. case WM_MDIREFRESHMENU: // only sent to MDI client window
  1051. // Normally, would call DrawMenuBar, but I have the menu, so eat it.
  1052. // LTRACE("CMenuBar::WM_MDIREFRESHMENUn");
  1053. return 0;
  1055. case WM_PAINT:
  1056. // After changing the MDI maximized state, the client window gets a
  1057. // paint message. This is the most convenient place to find out; there
  1058. // is no WM_MDIMAXIMIZED message.
  1059. if (/*m_pWndHooked->*/m_hWnd == m_pMenuBar->m_hWndMDIClient)
  1060. m_pMenuBar->OnPaintMDIClient();//CheckMinMaxState();
  1061. break;
  1062. }
  1064. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  1065. }
  1067. void CMenuBar::OnLButtonUp(UINT nFlags, CPoint point) 
  1068. {
  1069. //LTRACE("CMenuBar::OnLButtonUpn");
  1070. // TODO: 
  1071. ASSERT(m_pMenuControl);
  1072. if (m_pMenuControl->OnMouseMsg(WM_LBUTTONUP, nFlags, point)) {
  1073. CControlBar::OnLButtonUp(nFlags, point);
  1074. return;
  1075. }
  1077. int nIndex = HitTestOnTrack(point);
  1078. /*
  1079. if (IsValidIndex(nIndex) && m_bDown == TRUE) {
  1080. HMENU hSubMenu = ::GetSubMenu(m_hMenu, nIndex);
  1081. if (hSubMenu == NULL) {
  1082. UINT nID = ::GetMenuItemID(m_hMenu, nIndex);
  1083. ASSERT(nID != -1);
  1084. GetOwner()->SendMessage(WM_COMMAND, (WPARAM)nID, (LPARAM)GetSafeHwnd());
  1086. UpdateBar();
  1087. }
  1088. }
  1089. */
  1090. CControlBar::OnLButtonUp(nFlags, point);
  1091. }
  1095. void CMenuBar::DoPaint(CDC* pDC)
  1096. {
  1097. //LTRACE("CMenuBar::DoPaintn");
  1098. CRect rect;
  1099. GetClientRect(rect);
  1101. // draw buttons
  1102. for (int i = 0; i < m_arrItem.GetSize(); ++i) {
  1103. CMenuItem* pItem = m_arrItem[i];
  1104. if (pItem->IsValid())
  1105. m_arrItem[i]->Update(pDC);
  1106. }
  1108. // draw decorations
  1109. DrawGripper(pDC);
  1110. DrawBorder(pDC);
  1112. // draw captions
  1113. if (m_pMenuControl) {
  1114. CRect rcDockBar;
  1115. m_pDockBar->GetClientRect(rcDockBar);
  1116. if (m_dwStyle & CBRS_ORIENT_HORZ) {
  1117. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(rcDockBar.Width() + cxBorder2, rect.Height()));
  1118. }
  1119. else {
  1120. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(rect.Width(), rcDockBar.Height()));
  1121. }
  1122. }
  1123. }
  1125. HMENU CMenuBar::GetMyMenu()
  1126. {
  1127. return m_hMenu;
  1128. }
  1130. void CMenuBar::_KillTimer()
  1131. {
  1132. if (m_nIDEvent) {
  1133. KillTimer(m_nIDEvent);
  1134. m_nIDEvent = NULL;
  1135. }
  1136. }
  1139. int getPrevValidIndex(int nIndex)
  1140. {
  1141. --nIndex;
  1146. return nIndex;
  1147. }
  1149. // set only m_bWrapped by nWidth
  1150. int CMenuBar::WrapMenuBar(int nCount, int nWidth)
  1151. {
  1152. // LTRACE("CMenuBar::WrapMenuBarn");
  1153. int nResult = 0;
  1154. int xStart = CXGAP;
  1155. if (!IsFloating() && !m_pDockContext->m_pDC) // if not floating and ****not dragging!!!****
  1156. xStart += CXGRIPPER;
  1158. int x = xStart;
  1160. for (int i = 0; i < nCount; ++i) {
  1161. CMenuItem* pItem = m_arrItem[i];
  1162. if (pItem->IsValid()) {
  1164. if (i+1 == nCount)
  1165. return ++nResult;
  1167. if (x + pItem->m_sizeHorz.cx + CXGAP> nWidth) {// itself is over
  1168. if (pItem->CanWrap()) {
  1169. pItem->m_bWrapped = TRUE;
  1170. ++nResult;
  1171. x = xStart;
  1172. }
  1173. }
  1174. else if (x + pItem->m_sizeHorz.cx + m_arrItem[i+1]->m_sizeHorz.cx + CXGAP > nWidth) {
  1175. if (pItem->CanWrap()) {
  1176. pItem->m_bWrapped = TRUE;
  1177. ++nResult;
  1178. x = xStart;
  1179. }
  1180. }
  1181. else {
  1182. pItem->m_bWrapped = FALSE;
  1183. x += pItem->m_sizeHorz.cx;
  1184. }
  1185. }
  1186. }
  1187. /* //another algorithm
  1188. int dx = pItem->m_sizeHorz.cx;
  1189. if (dx + CXGAP > nWidth) { // bigger than nWidth
  1190. if (pItem->CanWrap()) {
  1191. pItem->m_bWrapped = TRUE;
  1192. // if (i != nCount - 1)
  1193. ++nResult;
  1194. }
  1195. }
  1196. else if (dx + x + CXGAP > nWidth) {
  1197. if (i > 0 && m_arrItem[i-1]->CanWrap()) {
  1198. // LTRACE("index %d is wrapn", i-1);
  1199. m_arrItem[i-1]->m_bWrapped = TRUE;
  1200. pItem->m_bWrapped = FALSE;
  1201. x = xStart;
  1202. // if (i != nCount - 1)///////////////////////////
  1203. ++nResult;
  1204. }
  1205. }
  1206. else {
  1207. pItem->m_bWrapped = FALSE;
  1208. }
  1209. x += dx;
  1211. }
  1212. }
  1213. */
  1215. return nResult + 1;
  1216. }
  1218. // calc only size, by using m_bWrapped
  1219. CSize CMenuBar::CalcSize(int nCount)
  1220. {
  1221. ASSERT(nCount > 0);
  1222. CPoint cur(CXGAP, CYGAP);
  1223. CSize sizeResult(0, 0);
  1224. int nWrap = 0;
  1225. for (int i = 0; i < nCount; ++i) {
  1226. CMenuItem* pItem = m_arrItem[i];
  1227. if (pItem->IsValid()) {
  1228. sizeResult.cx = max(cur.x + pItem->m_sizeHorz.cx, sizeResult.cx);
  1229. sizeResult.cy = max(cur.y + pItem->m_sizeHorz.cy, sizeResult.cy);
  1231. cur.x += pItem->m_sizeHorz.cx;
  1233. if (pItem->m_bWrapped == TRUE) {
  1234. LTRACE("    nIndex:%d is wrappedn", i);
  1235. cur.x = CXGAP; // reset x pos
  1236. cur.y += pItem->m_sizeHorz.cy;
  1237. ++nWrap;
  1238. }
  1240. }
  1241. }
  1243. //sizeResult.cy += CYGAP;
  1244. //sizeResult.cx += CXGAP;
  1245. // Modify by xhs , and the width of menubar will be shorter
  1246. sizeResult.cy += (CYGAP-4);
  1247. sizeResult.cx += (CXGAP+2);  
  1249. return sizeResult;
  1250. }
  1252. void CMenuBar::SizeMenuBar(int nCount, int nLength, BOOL bVert)
  1253. {
  1254. //LTRACE("CMenuBar::SizeMenuBarn");
  1255. ASSERT(nCount > 0);
  1257. if (!bVert) { // nLength is horizontal length
  1259. if (IsFloating()) { // half size wrapping
  1261. CSize sizeMax, sizeMin, sizeMid;
  1263. // Wrap MenuBar vertically
  1264. WrapMenuBar(nCount, 0);
  1265. sizeMin = CalcSize(nCount);
  1267. // Wrap MenuBar horizontally
  1268. WrapMenuBar(nCount, 32767);
  1269. sizeMax = CalcSize(nCount);
  1271. // we can never know this algorithm :), see CToolBar implementation
  1272. while (sizeMin.cx < sizeMax.cx) {
  1273. // LTRACE("looping sizeMin.cx:%d < sizeMax.cx:%dn", sizeMin.cx, sizeMax.cx);
  1274. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1275. WrapMenuBar(nCount, sizeMid.cx);
  1276. sizeMid = CalcSize(nCount);
  1277. if (sizeMid.cx == sizeMax.cx) { // if you forget, it loops forever!
  1278. return;
  1279. }
  1280. // LTRACE("    sizeMid : %d %dn", sizeMid.cx, sizeMid.cy);
  1282. if (nLength >= sizeMax.cx) {
  1283. // LTRACE("    nLength:%d >= sizeMax.cx:%dn", nLength, sizeMax.cx);
  1284. if (sizeMin == sizeMid) {
  1285. WrapMenuBar(nCount, sizeMax.cx);
  1286. // LTRACE("out SizeMenuBarn");
  1287. return;
  1288. }
  1289. sizeMin = sizeMid;
  1290. }
  1291. else if (nLength < sizeMax.cx) {
  1292. // LTRACE("    nLength:%d < sizeMax.cx:%dn", nLength, sizeMax.cx);
  1293. sizeMax = sizeMid;
  1294. }
  1295. else {
  1296. // LTRACE("out SizeMenuBarn");
  1297. return;
  1298. }
  1299. }
  1300. }
  1301. else { // each one wrapping
  1302. LTRACE("    just each one wrappingn");
  1303. WrapMenuBar(nCount, nLength);
  1304. }
  1305. }
  1306. else { // nLength is vertical length
  1307. CSize sizeMax, sizeMin, sizeMid;
  1309. // Wrap MenuBar vertically
  1310. WrapMenuBar(nCount, 0);
  1311. sizeMin = CalcSize(nCount);
  1313. // Wrap MenuBar horizontally
  1314. WrapMenuBar(nCount, 32767);
  1315. sizeMax = CalcSize(nCount);
  1317. while (sizeMin.cx < sizeMax.cx) {
  1318. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1319. WrapMenuBar(nCount, sizeMid.cx);
  1320. sizeMid = CalcSize(nCount);
  1321. if (sizeMid.cx == sizeMax.cx) {
  1322. return;
  1323. }
  1324. if (nLength < sizeMid.cy) {
  1325. if (sizeMin == sizeMid) {
  1326. WrapMenuBar(nCount, sizeMax.cx);
  1327. //LTRACE("out SizeMenuBarn");
  1328. return;
  1329. }
  1330. sizeMin = sizeMid;
  1331. }
  1332. else if (nLength > sizeMid.cy)
  1333. sizeMax = sizeMid;
  1334. else {
  1335. //LTRACE("out SizeMenuBarn");
  1336. return;
  1337. }
  1338. }
  1339. }
  1341. //LTRACE("out SizeMenuBarn");
  1342. }
  1345. void CMenuBar::DeleteItems()
  1346. {
  1347. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  1348. CMenuItem* pItem = m_arrItem[i];
  1349. delete pItem;
  1350. }
  1352. m_arrItem.RemoveAll();
  1354. m_pMenuIcon = NULL;
  1355. m_pMenuControl = NULL;
  1356. }
  1358. void CMenuBar::OnDestroy() 
  1359. {
  1360. CControlBar::OnDestroy();
  1362. _KillTimer();
  1363. DeleteItems();
  1364. }
  1366. int CMenuBar::GetNextOrPrevButton(int nIndex, BOOL bPrev)
  1367. {
  1368. int nCount = GetItemCount();
  1369. if (bPrev) { // <-
  1370. --nIndex;
  1371. if (nIndex < 0)
  1372. nIndex = nCount - 1;
  1373. }
  1374. else { // ->
  1375. ++nIndex;
  1376. if (nIndex >= nCount)
  1377. nIndex = 0;
  1378. }
  1380. if (!m_arrItem[nIndex]->CanTrack() || !m_arrItem[nIndex]->IsValid()) {
  1381. return GetNextOrPrevButton(nIndex, bPrev);
  1382. }
  1384. return nIndex;
  1385. }
  1387. void CMenuBar::AddIcon(HICON hIcon)
  1388. {
  1389. // ASSERT(m_bIcon == FALSE);
  1391. // m_bIcon = TRUE;
  1392. }
  1394. CMenuControl::CMenuControl(CControlBar* pBar)
  1395. {
  1396. m_bValid = FALSE;
  1397. m_pBar = pBar;
  1398. m_bDown = FALSE;
  1399. m_nTracking = -1;
  1401. int cxCaption = cyMenuButton - CYGAP + 1;
  1402. m_sizeHorz = CSize(cxCaption*3 + CXGAP/2, cyMenuButton);
  1403. }
  1405. CMenuControl::~CMenuControl()
  1406. {
  1408. }
  1410. void CMenuControl::Update(CDC* pDC)
  1411. {
  1412. // do nothing
  1413. }
  1415. void CMenuControl::Layout(CPoint point, BOOL bHorz)
  1416. {
  1417. LTRACE("CMenuControl::Layout bHorz:%dn", bHorz);
  1418. m_bHorz = bHorz;
  1420. // just layout easily
  1421. if (bHorz) {
  1422. m_rcItem = CRect(point, m_sizeHorz);
  1423. }
  1424. else {
  1425. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  1426. }
  1427. }
  1429. void CMenuControl::DelayLayoutAndDraw(CDC* pDC, CSize sizeBar)
  1430. {
  1431. // if (!IsValid())
  1432. // return;
  1434. // layout
  1435. if (m_bHorz) {
  1436. int cxCaption = cyMenuButton - CYGAP + 1;
  1437. int cyCaption = cxCaption - 1;
  1438. CRect rcCaption;
  1439. rcCaption.right = sizeBar.cx;
  1440. rcCaption.bottom = sizeBar.cy - CYGAP;
  1441. rcCaption.left = rcCaption.right - cxCaption;
  1442. rcCaption.top = rcCaption.bottom - cyCaption;
  1444. m_arrCaption[0] = rcCaption;
  1446. rcCaption -= CPoint(cxCaption+CXGAP/2, 0);
  1447. m_arrCaption[1] = rcCaption;
  1449. rcCaption -= CPoint(cxCaption, 0);
  1450. m_arrCaption[2] = rcCaption;
  1452. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  1453. m_arrCaption[0].right, m_arrCaption[0].bottom);
  1454. }
  1455. else {
  1456. int cxCaption = cyMenuButton - CYGAPVERT - 1;
  1457. int cyCaption = cxCaption - 1;
  1458. CRect rcCaption;
  1459. rcCaption.left = CYGAPVERT;
  1460. rcCaption.bottom = sizeBar.cy;
  1461. rcCaption.right = rcCaption.left + cxCaption;
  1462. rcCaption.top = rcCaption.bottom - cyCaption;
  1464. m_arrCaption[0] = rcCaption;
  1466. rcCaption -= CPoint(0, cyCaption+CXGAP/2);
  1467. m_arrCaption[1] = rcCaption;
  1469. rcCaption -= CPoint(0, cyCaption);
  1470. m_arrCaption[2] = rcCaption;
  1472. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  1473. m_arrCaption[0].right, m_arrCaption[0].bottom);
  1474. }
  1476. if (!IsValid())
  1477. return;
  1479. // draw frame controls
  1480. for (int i = 0; i < 3; ++i) {
  1481. DrawControl(pDC, i, FALSE);
  1482. }
  1484. // pDC->DrawFrameControl(m_arrCaption[0], DFC_CAPTION, DFCS_CAPTIONCLOSE);
  1485. // pDC->DrawFrameControl(m_arrCaption[1], DFC_CAPTION, DFCS_CAPTIONRESTORE);
  1486. // pDC->DrawFrameControl(m_arrCaption[2], DFC_CAPTION, DFCS_CAPTIONMIN);
  1487. }
  1490. // pasted from CDockContext
  1491. void CMenuBarDockContext::StartDrag(CPoint pt)
  1492. {
  1493. ASSERT_VALID(m_pBar);
  1494. m_bDragging = TRUE;
  1496. InitLoop();
  1498. if (m_pBar->m_dwStyle & CBRS_SIZE_DYNAMIC)
  1499. {
  1500. // get TRUE bar size (including borders)
  1501. CRect rect;
  1502. m_pBar->GetWindowRect(rect);
  1503. m_ptLast = pt;
  1504. CSize sizeHorz = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK);
  1505. CSize sizeVert = m_pBar->CalcDynamicLayout(0, LM_VERTDOCK);
  1506. CSize sizeFloat = m_pBar->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH);
  1508. m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1509. m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1511. // calculate frame dragging rectangle
  1512. m_rectFrameDragHorz = CRect(rect.TopLeft(), sizeFloat);
  1513. m_rectFrameDragVert = CRect(rect.TopLeft(), sizeFloat);
  1515. #ifdef _MAC
  1516. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz,
  1517. WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX);
  1518. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert,
  1519. WS_THICKFRAME | WS_CAPTION, WS_EX_FORCESIZEBOX);
  1520. #else
  1521. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1522. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1523. #endif
  1524. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1525. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1526. }
  1527. else if (m_pBar->m_dwStyle & CBRS_SIZE_FIXED)
  1528. {
  1529. // get TRUE bar size (including borders)
  1530. CRect rect;
  1531. m_pBar->GetWindowRect(rect);
  1532. m_ptLast = pt;
  1533. CSize sizeHorz = m_pBar->CalcDynamicLayout(-1, LM_HORZ | LM_HORZDOCK);
  1534. CSize sizeVert = m_pBar->CalcDynamicLayout(-1, LM_VERTDOCK);
  1536. // calculate frame dragging rectangle
  1537. m_rectFrameDragHorz = m_rectDragHorz = CRect(rect.TopLeft(), sizeHorz);
  1538. m_rectFrameDragVert = m_rectDragVert = CRect(rect.TopLeft(), sizeVert);
  1540. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1541. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1542. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1543. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1544. }
  1545. else
  1546. {
  1547. // get TRUE bar size (including borders)
  1548. CRect rect;
  1549. m_pBar->GetWindowRect(rect);
  1550. m_ptLast = pt;
  1551. BOOL bHorz = HORZF(m_dwStyle);
  1552. DWORD dwMode = !bHorz ? (LM_HORZ | LM_HORZDOCK) : LM_VERTDOCK;
  1553. CSize size = m_pBar->CalcDynamicLayout(-1, dwMode);
  1555. // calculate inverted dragging rect
  1556. if (bHorz)
  1557. {
  1558. m_rectDragHorz = rect;
  1559. m_rectDragVert = CRect(CPoint(pt.x - rect.Height()/2, rect.top), size);
  1560. }
  1561. else // vertical orientation
  1562. {
  1563. m_rectDragVert = rect;
  1564. m_rectDragHorz = CRect(CPoint(rect.left, pt.y - rect.Width()/2), size);
  1565. }
  1567. // calculate frame dragging rectangle
  1568. m_rectFrameDragHorz = m_rectDragHorz;
  1569. m_rectFrameDragVert = m_rectDragVert;
  1571. CMiniFrameWnd::CalcBorders(&m_rectFrameDragHorz);
  1572. CMiniFrameWnd::CalcBorders(&m_rectFrameDragVert);
  1573. m_rectFrameDragHorz.InflateRect(-cxBorder2, -cyBorder2);
  1574. m_rectFrameDragVert.InflateRect(-cxBorder2, -cyBorder2);
  1575. }
  1577. // adjust rectangles so that point is inside
  1578. AdjustRectangle(m_rectDragHorz, pt);
  1579. AdjustRectangle(m_rectDragVert, pt);
  1580. AdjustRectangle(m_rectFrameDragHorz, pt);
  1581. AdjustRectangle(m_rectFrameDragVert, pt);
  1583. // initialize tracking state and enter tracking loop
  1584. m_dwOverDockStyle = CanDock();
  1585. Move(pt);   // call it here to handle special keys
  1586. _Track();
  1587. }
  1589. BOOL CMenuBarDockContext::_Track()
  1590. {
  1591. // don't handle if capture already set
  1592. if (::GetCapture() != NULL)
  1593. return FALSE;
  1595. // set capture to the window which received this message
  1596. m_pBar->SetCapture();
  1597. ASSERT(m_pBar == CWnd::GetCapture());
  1599. #ifndef _MAC
  1600. // get messages until capture lost or cancelled/accepted
  1601. while (CWnd::GetCapture() == m_pBar)
  1602. {
  1603. MSG msg;
  1604. if (!::GetMessage(&msg, NULL, 0, 0))
  1605. {
  1606. AfxPostQuitMessage(msg.wParam);
  1607. break;
  1608. }
  1610. switch (msg.message)
  1611. {
  1612. case WM_LBUTTONUP:
  1613. if (m_bDragging)
  1614. _EndDrag();
  1615. else
  1616. EndResize();
  1617. return TRUE;
  1618. case WM_MOUSEMOVE:
  1619. if (m_bDragging)
  1620. Move(msg.pt);
  1621. else
  1622. Stretch(msg.pt);
  1623. break;
  1624. case WM_KEYUP:
  1625. if (m_bDragging)
  1626. OnKey((int)msg.wParam, FALSE);
  1627. break;
  1628. case WM_KEYDOWN:
  1629. if (m_bDragging)
  1630. OnKey((int)msg.wParam, TRUE);
  1631. if (msg.wParam == VK_ESCAPE)
  1632. {
  1633. CancelLoop();
  1634. return FALSE;
  1635. }
  1636. break;
  1637. case WM_RBUTTONDOWN:
  1638. CancelLoop();
  1639. return FALSE;
  1641. // just dispatch rest of the messages
  1642. default:
  1643. DispatchMessage(&msg);
  1644. break;
  1645. }
  1646. }
  1647. #else
  1648. Point   ptCur = {0};
  1650. // get messages until capture lost or cancelled/accepted
  1651. while (CWnd::GetCapture() == m_pBar)
  1652. {
  1653. EventRecord     er;
  1655. if (OSEventAvail(everyEvent, &er))
  1656. {
  1657. GetNextEvent(everyEvent, &er);
  1658. switch (er.what)
  1659. {
  1660. case mouseUp:
  1661. if (m_bDragging)
  1662. EndDrag();
  1663. else
  1664. EndResize();
  1665. return TRUE;
  1667. case keyDown:
  1668. case keyUp:
  1669. case autoKey:
  1670. case app2Evt:
  1671. {
  1672. MSG     msg;
  1674. if (WrapEvent(&er, &msg, PM_REMOVE))
  1675. {
  1676. if (m_bDragging)
  1677. OnKey((int)msg.wParam, msg.message == WM_KEYDOWN);
  1678. if (msg.message == WM_KEYUP && msg.wParam == VK_ESCAPE)
  1679. {
  1680. CancelLoop();
  1681. return FALSE;
  1682. }
  1683. }
  1684. break;
  1685. }
  1687. default:
  1688. break;
  1689. }
  1690. }
  1691. else
  1692. {
  1693. if (!EqualPt(er.where, ptCur))
  1694. {
  1695. POINT pt = {er.where.h, er.where.v};
  1696. if (m_bDragging)
  1697. Move(pt);
  1698. else
  1699. Stretch(pt);
  1700. }
  1701. }
  1702. }
  1703. #endif
  1704. CancelLoop();
  1706. return FALSE;
  1707. }
  1709. void CMenuBarDockContext::_EndDrag()
  1710. {
  1711. CancelLoop();
  1713. if (m_dwOverDockStyle != 0)
  1714. {
  1715. CDockBar* pDockBar = GetDockBar(m_dwOverDockStyle);
  1716. ASSERT(pDockBar != NULL);
  1718. CRect rect = (m_dwOverDockStyle & CBRS_ORIENT_VERT) ?
  1719. m_rectDragVert : m_rectDragHorz;
  1721. UINT uID = _AfxGetDlgCtrlID(pDockBar->m_hWnd);
  1722. if (uID >= AFX_IDW_DOCKBAR_TOP &&
  1723. uID <= AFX_IDW_DOCKBAR_BOTTOM)
  1724. {
  1725. m_uMRUDockID = uID;
  1726. m_rectMRUDockPos = rect;
  1727. pDockBar->ScreenToClient(&m_rectMRUDockPos);
  1728. }
  1730. // dock it at the specified position, RecalcLayout will snap
  1732. // insisting own line trick!
  1733. CRect rcDockBar;
  1734. pDockBar->GetWindowRect(rcDockBar);
  1736. if (m_dwOverDockStyle & CBRS_ORIENT_VERT) {
  1737. rect.top = rcDockBar.top - 1;
  1738. }
  1739. else {
  1740. rect.left = rcDockBar.left - 10;
  1741. }
  1743. m_pDockSite->DockControlBar(m_pBar, pDockBar, &rect);
  1744. m_pDockSite->RecalcLayout();
  1746. }
  1747. else if ((m_dwStyle & CBRS_SIZE_DYNAMIC) || (HORZF(m_dwStyle) && !m_bFlip) ||
  1748. (VERTF(m_dwStyle) && m_bFlip))
  1749. {
  1750. m_dwMRUFloatStyle = CBRS_ALIGN_TOP | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  1751. m_ptMRUFloatPos = m_rectFrameDragHorz.TopLeft();
  1752. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  1753. }
  1754. else // vertical float
  1755. {
  1756. m_dwMRUFloatStyle = CBRS_ALIGN_LEFT | (m_dwDockStyle & CBRS_FLOAT_MULTI);
  1757. m_ptMRUFloatPos = m_rectFrameDragVert.TopLeft();
  1758. m_pDockSite->FloatControlBar(m_pBar, m_ptMRUFloatPos, m_dwMRUFloatStyle);
  1759. }
  1760. }
  1763. void CMenuBar::OnPaintMDIClient()
  1764. {
  1765. LTRACE("CMenuBar::OnPaintMDIClientn");
  1767. if (m_hWndMDIClient) {
  1768. BOOL bMax = FALSE;
  1769. // get active MDI child window
  1770. HWND hWndChild = (HWND)::SendMessage(m_hWndMDIClient, WM_MDIGETACTIVE, 0,
  1771. (LPARAM)&bMax);
  1772. //ASSERT(::IsWindow(hWndChild)); crash! tell me why!
  1774. if (bMax != m_bMDIMaximized) {
  1775. LTRACE("    max state changedn");
  1776. m_bMDIMaximized = bMax;
  1778. if (bMax) {
  1779. LTRACE("        maximizedn");
  1780. m_pMenuControl->Validate(TRUE);
  1781. m_pMenuIcon->Validate(TRUE);
  1782. }
  1783. else {
  1784. LTRACE("        not maximizedn");
  1785. m_pMenuControl->Validate(FALSE);
  1786. m_pMenuIcon->Validate(FALSE);
  1787. }
  1789. RefreshBar();
  1790. }
  1791. }
  1792. }
  1794. void CMenuBar::OnInitMenuPopup()
  1795. {
  1796. CMenu menu;
  1797. menu.Attach((HMENU)m_hWindowMenu);
  1799. // scan for first window command
  1800. int n = menu.GetMenuItemCount();
  1801. BOOL bAddSeperator = TRUE;
  1802. for (int iPos=0; iPos<n; iPos++) {
  1803. if (menu.GetMenuItemID(iPos) >= AFX_IDM_FIRST_MDICHILD) {
  1804. bAddSeperator = FALSE;
  1805. break;
  1806. }
  1807. }
  1809. // iPos is either first window item, or end if none found.
  1811. // delete everything after.
  1812. while (iPos < (int)menu.GetMenuItemCount())
  1813. menu.RemoveMenu(iPos, MF_BYPOSITION);
  1815. // get active window so I can check its menu item
  1816. ASSERT(m_hWndMDIClient);
  1817. HWND hwndActive = (HWND)::SendMessage(m_hWndMDIClient,
  1818. WM_MDIGETACTIVE, 0, NULL);
  1820. // append window names in the form "# title"
  1821. int iWin=1;
  1822. for (HWND hwnd=::GetWindow(m_hWndMDIClient, GW_CHILD);
  1823.   hwnd;
  1824.   hwnd = ::GetWindow(hwnd, GW_HWNDNEXT)) {
  1826. if (bAddSeperator) {
  1827. menu.InsertMenu(iPos++, MF_BYPOSITION|MF_SEPARATOR);
  1828. bAddSeperator = FALSE;
  1829. }
  1831. // build item name and add it to the menu
  1832. CString sWinName, sMenuItem;
  1833. CWnd::FromHandle(hwnd)->GetWindowText(sWinName);
  1834. sMenuItem.Format(_T("&%d  %s"), iWin++, (LPCTSTR)sWinName);
  1835. menu.InsertMenu(iPos, MF_BYPOSITION,
  1836. ::GetDlgCtrlID(hwnd), sMenuItem);
  1837. if (hwnd==hwndActive)
  1838. menu.CheckMenuItem(iPos, MF_BYPOSITION|MF_CHECKED);
  1839. iPos++;
  1840. }
  1841. menu.Detach();
  1842. }
  1844. void CMenuBar::OnSetMenu(HMENU hNewMenu, HMENU hWindowMenu)
  1845. {
  1846. // We can get active MDI child window on this message!
  1847. BOOL bMax;
  1848. HWND hWndChild = GetActiveChildWnd(bMax);
  1850. if (!m_hWndActiveChild || m_hWndActiveChild != hWndChild) {
  1851. // active child window changed
  1852. LTRACE("    active child window changedn");
  1853. m_hWndActiveChild = hWndChild;
  1854. // tell MenuIcon child window has been changed
  1855. m_pMenuIcon->OnActivateChildWnd(hWndChild);
  1856. }
  1858. LTRACE("CMenuBar::OnSetMenun");
  1860. if (!m_hMenu || m_hMenu != hNewMenu) { // menu changed
  1861. LTRACE("    menu changedn");
  1862. LoadMenu(hNewMenu, hWindowMenu); // set toolbar menu
  1863. GetOwner()->SetMenu(NULL); // clear frame menu
  1864. }
  1865. }
  1867. HWND CMenuBar::GetActiveChildWnd(BOOL& bMaximized)
  1868. {
  1869. if (!m_hWndMDIClient)
  1870. return NULL;
  1872. BOOL bMax = FALSE;
  1873. HWND hWnd = (HWND)::SendMessage(m_hWndMDIClient,
  1874. WM_MDIGETACTIVE, 0, (LPARAM)&bMax);
  1875. bMaximized = bMax;
  1877. return hWnd;
  1878. }
  1881. CMenuItem::CMenuItem()
  1882. {
  1883. m_itemState = none;
  1884. m_rcItem = CRect(0, 0, 0, 0);
  1885. m_sizeHorz = CSize(0, 0);
  1886. m_bHorz = TRUE;
  1887. m_bWrapped = FALSE;
  1888. }
  1890. CMenuItem::~CMenuItem()
  1891. {
  1893. }
  1895. CPoint CMenuItem::ComputeMenuTrackPoint(CWnd* pWnd, HMENU hSubMenu, TPMPARAMS& tpm, CFont* pFont)
  1896. {
  1897. ASSERT_VALID(pWnd);
  1898. ASSERT_VALID(pFont);
  1899. ASSERT(::IsMenu(hSubMenu));
  1901. tpm.cbSize = sizeof(tpm);
  1902. CRect& rcExclude = (CRect&)tpm.rcExclude;
  1903. CWnd::GetDesktopWindow()->GetWindowRect(&rcExclude);
  1905. CPoint pt;
  1906. CRect  rcItem = m_rcItem;
  1907. pWnd->ClientToScreen(&rcItem);
  1909. // if (hSubMenu == NULL) // it's possible no sub menu
  1910. // return CPoint();
  1912. if (m_bHorz) { // horizontal
  1913. int nCount = ::GetMenuItemCount(hSubMenu);
  1914. ASSERT(nCount != -1);
  1915. int cyPopup = nCount * rcItem.Height(); // I want it be not owner drawn but ordinary menu..
  1917. if (rcItem.bottom + cyPopup > rcExclude.bottom) {
  1918. pt = CPoint(rcItem.left, rcItem.top); // over Screen
  1919. rcExclude.top = rcItem.top;
  1920. }
  1921. else {
  1922. pt = CPoint(rcItem.left, rcItem.bottom);
  1923. }
  1925. pt += CPoint(-1, 1); // precisely same as DevStudio
  1926. }
  1927. else { // vertical
  1928. // we never get the width of popup up menu, but I will try
  1929. int nCount = ::GetMenuItemCount(hSubMenu);
  1930. ASSERT(nCount != -1);
  1932. int cxPopup = 0;
  1933. CWindowDC dc(NULL);
  1935. CFont* pOldFont = dc.SelectObject(pFont);
  1936. for (int i = 0; i < nCount; ++i) {
  1937. char szName[256];
  1938. MENUITEMINFO info;
  1939. ::ZeroMemory(&info, sizeof(MENUITEMINFO));
  1940. info.cbSize = sizeof(MENUITEMINFO);
  1941. info.fMask = MIIM_ID | MIIM_TYPE;
  1942. info.dwTypeData = szName;
  1943. info.cch = sizeof(szName);
  1944. ::GetMenuItemInfo(hSubMenu, i, TRUE, &info);
  1946. CString strItem(szName);
  1948. CRect rcText(0, 0, 0, 0);
  1949. dc.DrawText(strItem, &rcText,
  1950. DT_SINGLELINE | DT_VCENTER | DT_CALCRECT | DT_NOPREFIX);
  1951. int cxOffset = ::GetSystemMetrics(SM_CXMENUCHECK) * 2;
  1952. cxPopup = max(rcText.Width() + 4*2 + CXGAP*2 + cxOffset, cxPopup);
  1953. }
  1954. dc.SelectObject(pOldFont);
  1956. if (rcItem.right + cxPopup > rcExclude.right) { // over right-side
  1957. pt = CPoint(rcItem.left, rcItem.top);
  1958. rcExclude.left = rcItem.left;
  1959. }
  1960. else {
  1961. pt = CPoint(rcItem.right, rcItem.top);
  1962. rcExclude.right = rcItem.right;
  1963. }
  1965. pt += CPoint(1, -1); // precisely same as DevStudio
  1966. }
  1968. return pt;
  1969. }
  1971. CMenuIcon::CMenuIcon(CWnd* pWnd)
  1972. {
  1973. m_hDocIcon = NULL;//hIcon;
  1974. m_sizeHorz = CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON));
  1975. m_bValid = FALSE;
  1976. m_hSysMenu = NULL;//::GetSystemMenu(pWnd->GetSafeHwnd(), FALSE);
  1977. }
  1979. CMenuIcon::~CMenuIcon()
  1980. {
  1982. }
  1984. void CMenuIcon::Update(CDC* pDC)
  1985. {
  1986. ASSERT(m_hDocIcon);
  1987. ASSERT(m_bValid);
  1989. ::DrawIconEx(pDC->m_hDC, m_rcItem.left, m_rcItem.top, m_hDocIcon,
  1990. m_sizeHorz.cx, m_sizeHorz.cy, 0, NULL, DI_NORMAL);
  1991. }
  1993. void CMenuIcon::TrackPopup(CWnd* pWnd)
  1994. {
  1995. ASSERT(m_hDocIcon);
  1996. ASSERT(m_bValid);
  1997. ASSERT(::IsMenu(m_hSysMenu));
  1999. NONCLIENTMETRICS info;
  2000. info.cbSize = sizeof(info);
  2001. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  2002. CFont fontSys;
  2003. if (!fontSys.CreateFontIndirect(&info.lfMenuFont))
  2004. return;
  2006. TPMPARAMS tpm;
  2007. CPoint pt = ComputeMenuTrackPoint(pWnd, m_hSysMenu, tpm, &fontSys);
  2009. ::TrackPopupMenuEx(m_hSysMenu,
  2010. TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
  2011. pt.x, pt.y, pWnd->GetOwner()->GetSafeHwnd(), &tpm);
  2012. }
  2014. void CMenuIcon::Layout(CPoint point, BOOL bHorz)
  2015. {
  2016. ASSERT(m_bValid);
  2018. m_bHorz = bHorz;
  2019. m_rcItem = CRect(point, m_sizeHorz);
  2020. }
  2022. void CMenuIcon::OnActivateChildWnd(HWND hWndChild)
  2023. {
  2024. //TRACE("CMenuIcon::OnActivateChildWndn");
  2025. ASSERT(::IsWindow(hWndChild));
  2026. m_hSysMenu = ::GetSystemMenu(hWndChild, FALSE);
  2027. ASSERT(::IsMenu(m_hSysMenu));
  2028. m_hDocIcon = (HICON)GetClassLong(hWndChild, GCL_HICONSM);
  2029. }
  2032. BOOL CMenuControl::OnMouseMsg(UINT msg, UINT nFlags, CPoint pt)
  2033. {
  2034. if (!IsValid())
  2035. return FALSE;
  2037. if (msg == WM_LBUTTONDOWN) {
  2038. m_nTracking = HitTest(pt);
  2039. if (m_nTracking >= 0) {
  2040. CClientDC dc(m_pBar);
  2041. DrawControl(&dc, m_nTracking, TRUE);
  2042. m_bDown = TRUE;
  2043. m_pBar->SetCapture();   // grab mouse input
  2044. return TRUE;
  2045. }
  2046. }
  2047. else if ((msg == WM_MOUSEMOVE) && m_nTracking >= 0) {
  2048. // mouse moved, and I am tracking: possibly draw button up/down
  2049. BOOL bOldDown = m_bDown;
  2050. m_bDown = m_arrCaption[m_nTracking].PtInRect(pt);
  2051. if (bOldDown != m_bDown) {
  2052. // up/down state changed: need to redraw button
  2053. CClientDC dc(m_pBar);
  2054. DrawControl(&dc, m_nTracking, m_bDown);
  2055. }
  2056. return TRUE; // handled
  2058. }
  2059. else if (msg == WM_LBUTTONUP && m_nTracking >= 0) {
  2060. // user released the mouse and I am tracking: do button command
  2061. ReleaseCapture(); // let go the mouse
  2062. if (m_bDown) {
  2063. // if button was down when released: draw button up, and do system cmd
  2064. CClientDC dc(m_pBar);
  2065. DrawControl(&dc, m_nTracking, FALSE);
  2066. CFrameWnd* pFrame = m_pBar->GetTopLevelFrame()->GetActiveFrame();
  2067. ASSERT_VALID(pFrame);
  2068. static syscmd[3] =
  2069. { /*SC_MOUSEMENU,*/ SC_CLOSE, SC_RESTORE, SC_MINIMIZE };
  2070. pFrame->SendMessage(WM_SYSCOMMAND, syscmd[m_nTracking]);
  2071. }
  2072. m_nTracking = -1; // stop tracking
  2073. return TRUE;   // handled (eat)
  2074. }
  2076. return FALSE;
  2077. }
  2079. int CMenuControl::HitTest(CPoint point)
  2080. {
  2081. for (int i = 0; i < 3; ++i) {
  2082. if (m_arrCaption[i].PtInRect(point))
  2083. return i;
  2084. }
  2086. return -1;
  2087. }
  2090. void CMenuControl::DrawControl(CDC* pDC, int nIndex, BOOL bPressed)
  2091. {
  2092. // draw frame controls
  2093. CRect& rc = m_arrCaption[nIndex];
  2094. static UINT dfcs[3] = { DFCS_CAPTIONCLOSE, DFCS_CAPTIONRESTORE, DFCS_CAPTIONMIN };
  2095. UINT uState = dfcs[nIndex];
  2096. if (bPressed)
  2097. uState |= DFCS_PUSHED;
  2099. pDC->DrawFrameControl(rc, DFC_CAPTION, uState);
  2100. }
  2102. void CMenuControl::ForceDrawControl(CDC * pDC)
  2103. {
  2104. if (!IsValid())
  2105. return;
  2107. for (int i = 0; i < 3; ++i) {
  2108. DrawControl(pDC, i, FALSE);
  2109. }
  2110. }
  2113. namespace {
  2115. const int CXTEXTMARGIN   = 5;
  2116. int CYTEXTMARGIN   = 0;
  2117. const int CYTEXTMARGINMIN = 2;
  2119. CFont fontHorz, fontVert;
  2121. // const int CXGAP = 3;
  2123. }// anonymouse namespace
  2125. CMenuButton::CMenuButton(HMENU hMenu, int nIndex)
  2126. {
  2127. ASSERT(hMenu);
  2128. InitButtonStringAndSubMenuHandle(hMenu, nIndex);
  2129. InitHorizontalButtonSize();
  2130. InitAccessKeyAndVerticalLinePoint();
  2131. }
  2133. CMenuButton::~CMenuButton()
  2134. {
  2136. }
  2138. BOOL CMenuButton::InitCommonResource()
  2139. {
  2140. // clean up
  2141. fontHorz.DeleteObject();
  2142. fontVert.DeleteObject();
  2144. // create fonts
  2145. NONCLIENTMETRICS info;
  2146. info.cbSize = sizeof(info);
  2147. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  2148. if (!fontHorz.CreateFontIndirect(&info.lfMenuFont))
  2149. return FALSE;
  2151. info.lfMenuFont.lfEscapement = -900;
  2152. info.lfMenuFont.lfOrientation = -900;
  2153. if (!fontVert.CreateFontIndirect(&info.lfMenuFont))
  2154. return FALSE;
  2157. // get font height
  2158. LOGFONT logfont;
  2159. fontHorz.GetLogFont(&logfont);
  2160. int cyFont = abs(logfont.lfHeight);
  2162. // calc Y text margin
  2163. int cyText = cyFont + CYTEXTMARGINMIN*2;
  2164. int cyMenu = ::GetSystemMetrics(SM_CYMENU);
  2165. if (cyMenu > cyText) {
  2166. CYTEXTMARGIN = (cyMenu - cyFont)/2;
  2167. }
  2168. else {
  2169. CYTEXTMARGIN = CYTEXTMARGINMIN;
  2170. }
  2172. return TRUE;
  2173. }
  2175. void CMenuButton::InitButtonStringAndSubMenuHandle(HMENU hMenu, int nIndex)
  2176. {
  2177. // get menu button Text
  2178. char szText[256];
  2179. MENUITEMINFO info; ::ZeroMemory(&info, sizeof(MENUITEMINFO));
  2180. info.cbSize = sizeof(MENUITEMINFO);
  2181. info.fMask = MIIM_ID | MIIM_TYPE;
  2182. info.dwTypeData = szText;
  2183. info.cch = sizeof(szText);
  2184. ::GetMenuItemInfo(hMenu, nIndex, TRUE, &info);
  2185. m_strBtn = CString(szText);
  2187. m_hSubMenu = ::GetSubMenu(hMenu, nIndex);
  2188. }
  2190. void CMenuButton::InitHorizontalButtonSize()
  2191. {
  2192. // get menu button Text size
  2193. ASSERT(m_strBtn.IsEmpty() == FALSE);
  2195. CWindowDC dc(NULL);
  2196. CRect rcText(0, 0, 0, 0);
  2197. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2198. dc.DrawText(m_strBtn, &rcText, DT_SINGLELINE | DT_CALCRECT);
  2199. dc.SelectObject(pOldFont);
  2200. m_sizeHorz.cx = rcText.Width() + CXTEXTMARGIN*2;
  2202. LOGFONT logfont;
  2203. fontHorz.GetLogFont(&logfont);
  2204. int cyFont = abs(logfont.lfHeight);
  2206. //this is decide the height of the menubar button
  2207. m_sizeHorz.cy = cyFont + CYTEXTMARGIN*2+2;
  2208. }
  2210. void CMenuButton::InitAccessKeyAndVerticalLinePoint()
  2211. {
  2212. int nIndex = m_strBtn.Find('&');
  2213. m_cAccessKey = m_strBtn[nIndex + 1]; // -1 + 1 = 0; it's ok
  2215. if (nIndex == -1) {
  2216. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2217. }
  2218. else if (nIndex == 0) {
  2219. CRect rcTo;
  2220. CWindowDC dc(NULL);
  2221. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2222. dc.DrawText(m_strBtn.Left(nIndex+2), &rcTo, DT_SINGLELINE | DT_CALCRECT);
  2223. dc.SelectObject(pOldFont);
  2225. m_ptLineFrom = CPoint(CYTEXTMARGIN, CXTEXTMARGIN);
  2226. m_ptLineTo  = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcTo.Width());
  2227. }
  2228. else {
  2229. CRect rcFrom, rcTo;
  2230. CWindowDC dc(NULL);
  2231. CFont* pOldFont = dc.SelectObject(&fontHorz);
  2232. dc.DrawText(m_strBtn.Left(nIndex), &rcFrom, DT_SINGLELINE | DT_CALCRECT);
  2233. dc.DrawText(m_strBtn.Left(nIndex+2), &rcTo, DT_SINGLELINE | DT_CALCRECT);
  2234. dc.SelectObject(pOldFont);
  2236. m_ptLineFrom = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcFrom.Width());
  2237. m_ptLineTo = CPoint(CYTEXTMARGIN, CXTEXTMARGIN + rcTo.Width());
  2238. }
  2239. }
  2241. void CMenuButton::Layout(CPoint point, BOOL bHorz)
  2242. {
  2243. if (bHorz == TRUE) {
  2244. //this can change the rect of menubutton modify by xhs
  2245. CPoint p(point.x-3,point.y-2);
  2246. m_rcItem = CRect(p, m_sizeHorz);
  2247. }
  2248. else {
  2249. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  2250. }
  2252. m_bHorz = bHorz;
  2253. }
  2255. void CMenuButton::Update(CDC* pDC)
  2256. {
  2257. // clean background
  2258. COLORREF clr = ::GetSysColor(COLOR_BTNFACE);
  2259. pDC->FillSolidRect(m_rcItem, clr);
  2261. switch (m_itemState) {
  2262. case hot:
  2263. DrawHot(pDC);
  2264. break;
  2265. case select:
  2266. DrawSelect(pDC);
  2267. break;
  2268. case none:
  2269. DrawNone(pDC);
  2270. break;
  2271. default:
  2272. ASSERT(TRUE);
  2273. }
  2274. }
  2276. void CMenuButton::TrackPopup(CWnd* pWnd)
  2277. {
  2278. TPMPARAMS tpm;
  2279. CPoint pt = ComputeMenuTrackPoint(pWnd, m_hSubMenu, tpm, &fontHorz);
  2281. ::TrackPopupMenuEx(m_hSubMenu,
  2282. TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
  2283. pt.x, pt.y, pWnd->GetOwner()->GetSafeHwnd(), &tpm);
  2284. }
  2286. void CMenuButton::DrawHorzText(CDC* pDC, CPoint ptOffset)
  2287. {
  2288. CRect rcBtn = m_rcItem;
  2289. pDC->SetBkMode(TRANSPARENT);
  2290. CFont* pOldFont = pDC->SelectObject(&fontHorz);
  2291. // I know precise text size
  2292. rcBtn.DeflateRect(CXTEXTMARGIN, CYTEXTMARGIN);
  2293. pDC->DrawText(m_strBtn, rcBtn + ptOffset,
  2294. DT_SINGLELINE);// | DT_CENTER | DT_VCENTER); no need
  2296. pDC->SelectObject(pOldFont);
  2297. }
  2299. void CMenuButton::DrawVertText(CDC* pDC, CPoint ptOffset)
  2300. {
  2301. CRect rcBtn = m_rcItem;
  2302. int nLength = m_strBtn.GetLength();
  2303. int nIndex = m_strBtn.Find('&');
  2304. CString strBtn = m_strBtn.Left(nIndex) + m_strBtn.Right(nLength - (nIndex+1));
  2306. pDC->SetBkMode(TRANSPARENT);
  2307. CFont* pOldFont = pDC->SelectObject(&fontVert);
  2308. // I must know precise text size
  2309. CRect rcString = CRect(
  2310. CPoint(rcBtn.right - CYTEXTMARGIN, rcBtn.top + CXTEXTMARGIN), m_sizeHorz);
  2311. pDC->DrawText(strBtn, rcString + ptOffset,
  2312. DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX); // don't forget DT_NOCLIP
  2314. pDC->SelectObject(pOldFont);
  2316. // DrawText is poor, so we have to draw vertical line by ourselves
  2317. pDC->MoveTo(rcBtn.TopLeft() + m_ptLineFrom + ptOffset);
  2318. pDC->LineTo(rcBtn.TopLeft() + m_ptLineTo + ptOffset);
  2319. }
  2321. void CMenuButton::DrawHot(CDC* pDC)
  2322. {
  2323. if (m_bHorz) {
  2324. // draw down button
  2325. pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2326. DrawHorzText(pDC);
  2327. }
  2328. else {
  2329. pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2330. DrawVertText(pDC);
  2331. }
  2332. }
  2334. void CMenuButton::DrawSelect(CDC* pDC)
  2335. {
  2336. if (m_bHorz) {
  2337. // draw pressed button
  2338. pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2339. DrawHorzText(pDC, CPoint(1, 1));
  2340. }
  2341. else {
  2342. pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2343. DrawVertText(pDC, CPoint(1, 1));
  2344. }
  2345. }
  2347. void CMenuButton::DrawNone(CDC* pDC)
  2348. {
  2349. if (m_bHorz) {
  2350. DrawHorzText(pDC);
  2351. }
  2352. else {
  2353. DrawVertText(pDC);
  2354. }
  2355. }
  2357. int CMenuBar::OnActivateFrame(int nCmdShow)
  2358. {
  2359. CFrameWnd* pFrame = GetParentFrame();
  2360. ASSERT_VALID(pFrame);
  2361. if (pFrame->GetMenu() != NULL) {
  2362. LTRACE(" has menun");
  2363. pFrame->SetMenu(NULL);
  2364. }
  2365. m_nCmdShow = nCmdShow;
  2366. return SW_HIDE;
  2367. }