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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
MenuBar.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：82k
源码类别：

金融证券系统

开发平台：

Visual C++

MenuBar.cpp：源码内容
  1. //-----------------------------------------------------------------------//
  2. // This is a part of the GuiLib MFC Extention.  //
  3. // Modified by  :  Francisco Campos  //
  4. // (C) 2002 Francisco Campos <www.beyondata.com> All rights reserved     //
  5. // This code is provided "as is", with absolutely no warranty expressed  //
  6. // or implied. Any use is at your own risk.  //
  7. // You must obtain the author's consent before you can include this code //
  8. // in a software library.  //
  9. // If the source code in  this file is used in any application  //
  10. // then acknowledgement must be made to the author of this program  //
  11. // fcampos@tutopia.com  //
  12. //-----------------------------------------------------------------------//
  14. //
  15. // Class :  CMenuBar
  16. //
  17. // Version : 1.0
  18. //
  19. // Created : Jan 14, 2001        
  20. //
  21. // Last Modified: Francisco Campos. 
  22. //
  23. // CMenuBar class version 2.12
  24. // simulates a Dev Studio style dockable menu bar.
  25. // based on PixieLib written by Paul DiLascia<www.dilascia.com>
  26. //
  27. // version history
  28. // 2.12 : support OLE menu carelessly.
  29. // 2.11 : WindowMenu fixed by VORGA.
  30. // 2.10 : CMenuDockBar's problem fixed again and again.
  31. // 2.08 : give up precise ComputeMenuTrackPoint
  32. // 2.07 : Sychronizing with frame activation problem fixed
  33. // 2.06 : CMenuItem::ComputeMenuTrackPoint fixed a little
  34. // 2.05 : CMenuDockBar fixed
  35. //  : Inactive state problem fixed
  36. // 2.04 : bug with ::TrackPopupEx carelessly fixed 
  37. //           : synchronizing TrackPopup animation with win98 effect
  38. //
  39. // written by MB <mb2@geocities.co.jp> 1999.11.27
  40. //
  41. //
  42. //
  43. // CMenuBar version 2.13
  45. #include "stdafx.h"
  46. #include "MenuBar.h"
  47. #include "resource.h"
  48. #include "GuiDockContext.h"
  49. #include <afxole.h>
  50. #ifdef _DEBUG
  51. #define new DEBUG_NEW
  52. #undef THIS_FILE
  53. static char THIS_FILE[] = __FILE__;
  54. #endif
  56. #ifdef _DEBUG
  57. const BOOL bTraceOn = FALSE;
  58. #define LTRACE if (bTraceOn) TRACE
  59. const BOOL bTraceOn2 = TRUE;
  60. #define LTRACE2 if (bTraceOn2) TRACE
  61. #else
  62. #define LTRACE
  63. #define LTRACE2
  64. #endif
  67. //////////////////////////////////////////////////////////////////////
  68. // I've found string resource of "More windows" in "user.exe".
  69. // But I can't load it, so please replace a following with your language.
  70. static const TCHAR _szMoreWindows[] = _T("&More windows...");
  72. //////////////////////////////////////////////////////////////////////
  73. // used for OLE menu (easy fix)
  74. static BOOL _bWindowMenuSendCmd = FALSE;
  75. static int _nPrevIndexForCmd = -1;
  77. //////////////////////////////////////////////////////////////////////
  78. // hook
  79. static CMenuBar* g_pMenuBar = NULL;
  80. static HHOOK  g_hMsgHook = NULL;
  82. // message
  83. const UINT CMenuBar::WM_GETMENU = ::RegisterWindowMessage(_T("CMenuBar::WM_GETMENU"));
  84. const UINT MB_SET_MENU_NULL = ::RegisterWindowMessage(_T("CMenuBar::MB_SET_MENU_NULL"));
  86. const int cxBorder2 = ::GetSystemMetrics(SM_CXBORDER)*2;
  87. const int cyBorder2 = ::GetSystemMetrics(SM_CYBORDER)*2;
  89. // common resources
  90. static CFont _fontHorzMenu, _fontVertMenu;
  91. static int _cyHorzFont, _cyMenuOnBar, _cyTextMargin;
  92. const int CXTEXTMARGIN = 5;
  94. DWORD dSt;
  96. int gbintHorz; //Horz=0, Vert=1
  97. CRect rcMenu; //CRect of button
  98. static BOOL _InitCommonResources(BOOL bForce = FALSE)
  99. {
  100. if (bForce == FALSE && _fontHorzMenu.m_hObject != NULL)
  101. return TRUE;// no need to reinitialize
  103. // clean up
  104. _fontHorzMenu.DeleteObject();
  105. _fontVertMenu.DeleteObject();
  107. // create fonts
  108. NONCLIENTMETRICS info; info.cbSize = sizeof(info);
  109. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  110. if (!_fontHorzMenu.CreateFontIndirect(&info.lfMenuFont))
  111. return FALSE;
  113. // create vertical font
  114. info.lfMenuFont.lfEscapement = -900;
  115. info.lfMenuFont.lfOrientation = -900;
  116. if (!_fontVertMenu.CreateFontIndirect(&info.lfMenuFont))
  117. return FALSE;
  119. // get font height
  120. _cyHorzFont = abs(info.lfMenuFont.lfHeight);
  122. // calc Y text margin
  123. _cyMenuOnBar = info.iMenuHeight;
  124. _cyMenuOnBar = max(_cyMenuOnBar, ::GetSystemMetrics(SM_CYSMICON));
  125. _cyTextMargin = (_cyMenuOnBar - _cyHorzFont) / 2;
  127. return TRUE;
  128. }
  130. // I wanted to control popup point, but I've fount we can never get popupmenu rect before popup.
  131. // even if not owner draw menu...
  132. static CPoint _ComputeMenuTrackPoint(const CRect& rcItem, DWORD dwStyle, UINT& fuFlags, TPMPARAMS& tpm)
  133. {
  134. fuFlags = TPM_LEFTBUTTON | TPM_LEFTALIGN | TPM_HORIZONTAL;
  135. tpm.cbSize = sizeof(tpm);
  136. CPoint pt;
  137. CRect& rcExclude = (CRect&)tpm.rcExclude;
  138. CWnd::GetDesktopWindow()->GetWindowRect(&rcExclude);
  140. CRect rcFrame;
  141. AfxGetMainWnd()->GetWindowRect(&rcFrame);
  143. switch (dwStyle & CBRS_ALIGN_ANY) {
  144. case CBRS_ALIGN_RIGHT:
  145. case CBRS_ALIGN_LEFT:
  146. pt = CPoint(rcItem.right+1, rcItem.top-1);
  147. // to avoid strange menu flip, won't do : [rcExclude.right = rcItem.right+1;]
  148. // I want to use : fuFlags |= TPM_HORNEGANIMATION;
  149. break;
  151. default: // case CBRS_ALIGN_TOP:
  152. pt = CPoint(rcItem.left-1, rcItem.bottom);
  153. rcExclude.bottom = rcItem.bottom+1;// <- insead of [fuFlags |= TPM_VERPOSANIMATION;]
  155. break;
  156. }
  157. return pt;
  158. }
  161. //******************************************************************
  162. static int _CalcTextWidth(const CString& strText)
  163. {
  164. CWindowDC dc(NULL);
  165. CRect rcText(0, 0, 0, 0);
  166. CFont* pOldFont = dc.SelectObject(&_fontHorzMenu);
  167. dc.DrawText(strText, &rcText, DT_SINGLELINE | DT_CALCRECT);
  168. dc.SelectObject(pOldFont);
  170. return rcText.Width();
  171. }
  173. //******************************************************************
  174. // grippers pasted from MFC6
  175. #define CX_GRIPPER  3
  176. #define CY_GRIPPER  3
  177. #define CX_BORDER_GRIPPER 2
  178. #define CY_BORDER_GRIPPER 2
  179. #define CX_GRIPPER_ALL CX_GRIPPER + CX_BORDER_GRIPPER*2
  180. #define CY_GRIPPER_ALL CY_GRIPPER + CY_BORDER_GRIPPER*2
  182. /////////////////////////////////////////////////////////////////////////////
  183. // CMenuBar
  184. BEGIN_MESSAGE_MAP(CMenuBar, CControlBar)
  185. //{{AFX_MSG_MAP(CMenuBar)
  186. ON_WM_LBUTTONDOWN()
  187. ON_WM_MOUSEMOVE()
  188. ON_WM_CREATE()
  189. ON_WM_LBUTTONUP()
  190. ON_WM_TIMER()
  191. ON_WM_DESTROY()
  192. ON_WM_NCCALCSIZE()
  193. ON_WM_NCPAINT()
  194. ON_WM_NCHITTEST()
  195. ON_WM_SIZE()
  196. ON_WM_SETCURSOR()
  197. //}}AFX_MSG_MAP
  198. ON_REGISTERED_MESSAGE(MB_SET_MENU_NULL, OnSetMenuNull)
  199. END_MESSAGE_MAP()
  201. IMPLEMENT_DYNAMIC(CMenuBar, CControlBar)
  203. /////////////////////////////////////////////////////////////////////////////
  204. // CMenuBar Construction
  205. CMenuBar::CMenuBar()
  206. {
  207. m_nCurIndex  = -1;
  208. m_nTrackingState = none;
  209. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  210. m_bIgnoreAlt = FALSE;
  211. m_hMenu = NULL;
  212. m_nIDEvent = NULL;
  213. szNameHistory.Empty();
  214. bSaveHistory=FALSE;
  216. m_bMDIMaximized = FALSE;
  217. m_hWndMDIClient = NULL;
  218. m_hWndActiveChild = NULL;
  220. m_pMenuIcon = NULL;
  221. m_pMenuControl = NULL;
  223. m_bDelayedButtonLayout = TRUE;
  224. m_dwExStyle = 0;
  226. m_bFrameActive = FALSE;
  227. m_bMDIApp = FALSE;
  228. m_style = Office97;  //by default
  229. m_bXP=FALSE;
  230. cmb=NULL;
  231. m_bCombo=FALSE;//combobox by default
  232. bIsTabbed=FALSE;
  233. }
  235. //******************************************************************
  236. BOOL CMenuBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
  237. {
  238. return CreateEx(pParentWnd, dwStyle,
  239. CRect(m_cxLeftBorder, m_cyTopBorder, m_cxRightBorder, m_cyBottomBorder), nID);
  241. }
  243. //******************************************************************
  244. BOOL CMenuBar::CreateEx(CWnd* pParentWnd, DWORD dwStyle, CRect rcBorders, UINT nID)
  245. {
  246. ASSERT_VALID(pParentWnd);// must have a parent
  247. ASSERT (!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  249. SetBorders(rcBorders);
  251. // save the original style
  252. m_dwExStyle = dwStyle;
  254. // save the style
  255. m_dwStyle = (dwStyle & CBRS_ALL);// ******fixed by Mark Gentry, thanx!******
  257. dwStyle &= ~CBRS_ALL;
  258. dwStyle|=WS_CLIPCHILDREN | CCS_NOPARENTALIGN | CCS_NOMOVEY | CCS_NORESIZE;
  259. CString strClass = AfxRegisterWndClass(
  260. CS_HREDRAW | CS_VREDRAW |
  261. CS_DBLCLKS,// don't forget!
  262. AfxGetApp()->LoadStandardCursor(IDC_ARROW),
  263. (HBRUSH)(COLOR_BTNFACE+1));
  266. return CWnd::Create(strClass, _T("MenuBar"), dwStyle, CRect(), pParentWnd, nID);
  267. }
  268. void CMenuBar::SetSaveHistory(CString sNameHistory,BOOL bsaveHistory)
  269. {
  270. szNameHistory=sNameHistory;
  271. bSaveHistory=bsaveHistory;
  272. }
  273. //******************************************************************
  274. int CMenuBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  275. {
  276. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  277. return -1;
  279. CWnd* pFrame = GetOwner();
  280. ASSERT_VALID(pFrame);
  282. // hook frame window to trap WM_MENUSELECT
  283. //m_hookFrame.Install(this, pFrame->GetSafeHwnd());
  285. // If this is an MDI app, hook client window to trap WM_MDISETMENU
  286. if (pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd))) {
  287. m_bMDIApp = TRUE;
  288. m_hWndMDIClient = ((CMDIFrameWnd*)pFrame)->m_hWndMDIClient;
  289. ASSERT(::IsWindow(m_hWndMDIClient));
  290. m_hookMDIClient.Install(this, m_hWndMDIClient);
  291. }
  293. if (m_pDockContext==NULL)
  294. m_pDockContext=new CGuiDockContext(this);
  295. ASSERT(m_pDockContext);
  297. if (!_InitCommonResources()) {
  298. TRACE(_T("Failed to create menubar resourcen"));
  299. return FALSE;
  300. }
  302. return 0;
  303. }
  305. //******************************************************************
  307. BOOL CMenuBar::CreateCombo(CComboBox* pControl,UINT nID,int iSize,DWORD dwStyle)
  308. {
  309. CFont m_Font;
  310. m_Font.CreateStockObject (DEFAULT_GUI_FONT);
  311. if(!pControl->Create(dwStyle, CRect(1,1,iSize,200), this, nID))
  312. {
  313. TRACE(_T("Failed to create combo-boxn"));
  314. m_bCombo=FALSE;
  315. return FALSE;
  316. }
  317. m_bCombo=TRUE;
  318. cmb=(CGuiComboBoxExt*)pControl;
  319. cmb->ActiveHistory(TRUE);
  320. cmb->LoadHistory(szNameHistory,bSaveHistory);
  321. return TRUE;
  322. }
  324. //******************************************************************
  325. void CMenuBar::OnSize(UINT nType, int cx, int cy) 
  326. {
  327. RefreshBar();
  328. if (m_bCombo==TRUE)
  329. DrawCombo();
  330. }
  333. void CMenuBar::SetTabbed(BOOL bIstabed)
  334. {
  335. bIsTabbed=bIstabed;
  336. }
  338. //******************************************************************
  339. BOOL CMenuBar::InitItems()
  340. {
  341. ASSERT(m_hMenu);
  343. // clean up all items
  344. DeleteItems();
  346. // buttons
  347. for (int i = 0; i < ::GetMenuItemCount(m_hMenu); ++i) {
  348. m_arrItem.Add(new CMenuButton(m_hMenu, i));
  349. }
  351. if (m_bMDIApp) {
  352. // icon
  353. if (!bIsTabbed)
  354. {
  356. m_pMenuIcon = new CMenuIcon(this);
  357. m_arrItem.InsertAt(0, m_pMenuIcon);
  358. // frame control
  359. m_pMenuControl = new CMenuControl(this);
  360. m_arrItem.Add(m_pMenuControl);
  362. // reinitializing
  363. m_pMenuIcon->OnActivateChildWnd();
  364. m_pMenuControl->OnActivateChildWnd();
  365. }
  366. }
  368. return TRUE;
  369. }
  371. //******************************************************************
  372. BOOL CMenuBar::LoadMenuBar(UINT nIDResource)
  373. {
  374. ASSERT(m_hMenu == NULL);
  376. ASSERT_VALID(m_pDockSite);
  377. if (m_pDockSite->GetMenu()) {
  378. PostMessage(MB_SET_MENU_NULL, (WPARAM)m_pDockSite->GetSafeHwnd());
  379. }
  381. m_hMenu = ::LoadMenu(AfxGetInstanceHandle(), MAKEINTRESOURCE(nIDResource));
  382. if (m_hMenu == NULL) {
  383. TRACE(_T("Failed to load menun"));
  384. return FALSE;
  385. }
  387. return InitItems();
  388. }
  390. //******************************************************************
  392. HMENU CMenuBar::LoadMenu(HMENU hMenu, HMENU hWindowMenu)
  393. {
  394. ASSERT(::IsMenu(hMenu));
  395. ASSERT_VALID(this);
  397. CFrameWnd* pFrame = GetParentFrame();
  398. if (::GetMenu(pFrame->GetSafeHwnd()) != NULL) {
  399. // not to make MFC ignore SetMenu(NULL), post it.
  400. PostMessage(MB_SET_MENU_NULL, (WPARAM)pFrame->GetSafeHwnd());
  401. }
  403. HMENU hOldMenu = m_hMenu;
  404. m_hMenu = hMenu;// menu is shared with MFC
  406. // initialize Items 
  407. VERIFY(InitItems());
  409. if (hMenu) {
  410. m_hWindowMenu = hWindowMenu;
  411. RefreshBar();// and menubar itself
  412. }
  414. return hOldMenu;
  415. }
  417. //******************************************************************
  419. void CMenuBar::RefreshBar()
  420. {
  421. InvalidateRect(NULL);
  423. #if _MFC_VER >= 0x600
  424. if (GetParent()->IsKindOf(RUNTIME_CLASS(CReBar))) {
  425. m_bDelayedButtonLayout = TRUE;// to avoid ASSERTION
  426. Layout();
  427. }
  428. #endif
  430. CFrameWnd* pFrame = (CFrameWnd*)GetTopLevelFrame();
  431. ASSERT_VALID(pFrame); ASSERT(pFrame->IsFrameWnd());
  432. pFrame->RecalcLayout();
  434. // floating frame
  435. CFrameWnd* pMiniFrame = GetParentFrame();
  436. if (pMiniFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd)))
  437. pMiniFrame->RecalcLayout();
  438. }
  440. /////////////////////////////////////////////////////////////////////////////
  441. // CMenuBar clean up 
  442. CMenuBar::~CMenuBar()
  443. {
  445. }
  447. //******************************************************************
  448. void CMenuBar::DeleteItems()
  449. {
  450. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  451. CMenuItem* pItem = m_arrItem[i];
  452. delete pItem;
  453. }
  455. m_arrItem.RemoveAll();
  457. m_pMenuIcon = NULL;
  458. m_pMenuControl = NULL;
  459. }
  461. //******************************************************************
  462. /////////////////////////////////////////////////////////////////////////////
  463. // CMenuBar draw
  464. void CMenuBar::DoPaint(CDC* pDC)
  465. {
  466. CRect rect; GetClientRect(rect);
  467. BOOL bFlota=m_dwStyle & CBRS_FLOATING;
  468. // draw items
  469. m_sizex=0;
  470. for (int i = 0; i < m_arrItem.GetSize(); ++i) {
  471. m_arrItem[i]->Update(pDC);
  472. }
  474. // delay draw captions 
  475. if (m_pMenuControl) {
  476. if (IsFloating()) {
  477. m_pMenuControl->DelayLayoutAndDraw(pDC, rect.Size(),bFlota);
  478. }
  479. else {
  480. if (m_dwStyle & CBRS_ORIENT_HORZ)
  481. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(GetClipBoxLength(TRUE), rect.Height()),bFlota);
  482. else
  483. m_pMenuControl->DelayLayoutAndDraw(pDC, CSize(rect.Width(), GetClipBoxLength(FALSE)),bFlota);
  484. }
  485. }
  486. }
  488. //******************************************************************
  489. void CMenuBar::UpdateBar(TrackingState nState, int nNewIndex)
  490. {
  491. if (m_nTrackingState == buttonmouse)
  492. m_bIgnoreAlt = FALSE;// if prev state is BUTTONMOUSE, always should be FALSE!
  494. m_nTrackingState = nState;
  497. // clean up
  498. if (IsValidIndex(m_nCurIndex)) {
  499. CMenuItem* pItem = m_arrItem[m_nCurIndex];
  500. CClientDC dc(this);
  501. pItem->ModifyState(MISTATE_HOT | MISTATE_PRESSED, 0);
  502. pItem->Update(&dc);
  504. // draw captions forcefully
  505. if (m_pMenuControl) {
  506. CRect rcCross = m_pMenuControl->GetRect() & m_arrItem[m_nCurIndex]->GetRect();
  507. if (!rcCross.IsRectEmpty()) {
  508. m_pMenuControl->DrawControl();
  509. if (m_bCombo==TRUE)
  510. DrawCombo();
  511. }
  512. }
  514. m_nCurIndex = -1;
  515. }
  517. if (nState != none) {
  518. ASSERT(IsValidIndex(nNewIndex));
  519. m_nCurIndex = nNewIndex;
  520. CMenuItem* pItem = m_arrItem[m_nCurIndex];
  521. CClientDC dc(this);
  523. if (nState == button || nState == buttonmouse) {
  524. pItem->ModifyState(MISTATE_PRESSED, MISTATE_HOT);
  525. pItem->Update(&dc);
  526. }
  527. else if (nState == popup) {
  528. pItem->ModifyState(MISTATE_HOT, MISTATE_PRESSED);
  529. pItem->Update(&dc);
  530. }
  532. // draw captions forcefully
  533. if (m_pMenuControl) {
  534. CRect rcCross = m_pMenuControl->GetRect() & m_arrItem[m_nCurIndex]->GetRect();
  535. if (!rcCross.IsRectEmpty()) {
  536. m_pMenuControl->DrawControl();
  537. if (m_bCombo==TRUE)
  538. DrawCombo();
  539. }
  540. }
  541. }
  542. else {
  543. // must be default parameter
  544. ASSERT(nNewIndex == -1);
  545. }
  547. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  548. }
  550. /////////////////////////////////////////////////////////////////////////////
  551. // CMenuBar message handler
  552. int CMenuBar::HitTestOnTrack(CPoint point)
  553. {
  554. for (int i = 0; i < GetItemCount(); ++i) {
  555. CMenuItem* pItem = m_arrItem[i];
  556. CRect rcItem = pItem->GetRect();
  558. if ((pItem->GetStyle() & MISTYLE_TRACKABLE) &&
  559. rcItem.PtInRect(point))
  560. return i;
  561. }
  563. return -1;
  564. }
  566. //******************************************************************
  567. void CMenuBar::OnLButtonDown(UINT nFlags, CPoint point) 
  568. {
  569. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  570. int nIndex = HitTestOnTrack(point);
  571. if (IsValidIndex(nIndex) && (m_arrItem[nIndex]->GetStyle() & MISTYLE_TRACKABLE)) {
  572. TrackPopup(nIndex);
  573. return; // eat it!
  574. }
  576. CControlBar::OnLButtonDown(nFlags, point);
  577. }
  579. //******************************************************************
  580. void CMenuBar::OnMouseMove(UINT nFlags, CPoint point)
  581. {
  582. int nIndex = HitTestOnTrack(point);
  583. if (IsValidIndex(nIndex)) {
  584. if (m_nCurIndex == -1 || m_nCurIndex != nIndex) {// if other button
  585. UpdateBar(buttonmouse, nIndex);// button made hot with mouse
  587. if (!m_nIDEvent)
  588. m_nIDEvent = SetTimer(1, 100, NULL);
  589. }
  590. }
  591. else {
  592. UpdateBar();
  593. }
  595. CControlBar::OnMouseMove(nFlags, point);
  596. }
  598. //******************************************************************
  599. LRESULT CMenuBar::OnSetMenuNull(WPARAM wParam, LPARAM)
  600. {
  601. HWND hWnd = (HWND)wParam;
  602. ASSERT(::IsWindow(hWnd));
  603. ::SetMenu(hWnd, NULL);
  605. return 0;
  606. }
  608. //******************************************************************
  609. LRESULT CMenuBar::OnSettingChange(WPARAM wParam, LPARAM lParam)
  610. {
  611. // reinitialize fonts etc
  612. if (!_InitCommonResources(TRUE)) {
  613. TRACE(_T("Failed to create bar resourcen"));
  614. return FALSE;
  615. }
  617. VERIFY(InitItems());
  619. CFrameWnd* pFrame = GetParentFrame();
  620. ASSERT_VALID(pFrame);
  621. pFrame->RecalcLayout();
  622. return 0;
  623. }
  624. //******************************************************************
  625. void CMenuBar::OnLButtonUp(UINT nFlags, CPoint point) 
  626. {
  627. CControlBar::OnLButtonUp(nFlags, point);
  628. }
  629. //******************************************************************
  630. void CMenuBar::CheckActiveChildWndMaximized()
  631. {
  632. if (!bIsTabbed)
  633. {
  634. ASSERT(m_pMenuControl);
  635. ASSERT(m_pMenuIcon);
  636. }
  638. BOOL bMaximized = FALSE;
  639. GetActiveChildWnd(bMaximized);
  640. if (m_bMDIMaximized != bMaximized) {
  641. LTRACE(_T("CMenuBar::CheckActiveChildWndMaximized---state changed, refreshingn"));
  642. m_bMDIMaximized = bMaximized;
  643. if (!bIsTabbed)
  644. {
  646. m_pMenuControl->OnActivateChildWnd();
  647. m_pMenuIcon->OnActivateChildWnd();
  648. if(!m_bMDIMaximized )
  649. {
  650. m_pMenuControl->m_arrButton[0].ShowWindow(SW_HIDE);
  651. m_pMenuControl->m_arrButton[1].ShowWindow(SW_HIDE);
  652. m_pMenuControl->m_arrButton[2].ShowWindow(SW_HIDE);
  653. }
  654. else
  655. {
  656. m_pMenuControl->m_arrButton[0].ShowWindow(SW_SHOW);
  657. m_pMenuControl->m_arrButton[1].ShowWindow(SW_SHOW);
  658. m_pMenuControl->m_arrButton[2].ShowWindow(SW_SHOW);
  659. }
  660. }
  661. RefreshBar();
  662. }
  663. }
  664. //******************************************************************
  665. void CMenuBar::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
  666. {
  667. LTRACE(_T("CMenuBar::OnInitMenuPopupn"));
  668. CMenu menu;
  669. menu.Attach((HMENU)m_hWindowMenu);
  671. // scan for first window command
  672. int n = menu.GetMenuItemCount();
  673. BOOL bAddSeperator = TRUE;
  674. for (int iPos=0; iPos<n; iPos++) {
  675. if (menu.GetMenuItemID(iPos) >= AFX_IDM_FIRST_MDICHILD) {
  676. bAddSeperator = FALSE;
  677. break;
  678. }
  679. }
  681. while (iPos < (int)menu.GetMenuItemCount())
  682. menu.RemoveMenu(iPos, MF_BYPOSITION);
  684. // get active window so I can check its menu item
  685. ASSERT(m_hWndMDIClient);
  686. HWND hwndActive = (HWND)::SendMessage(m_hWndMDIClient,
  687. WM_MDIGETACTIVE, 0, NULL);
  689. // append window names in the form "# title"
  690. // *****fixed by VORGA, thanks!*****
  691. int iWin;
  692. int nID = AFX_IDM_FIRST_MDICHILD;
  693. CString sWinName, sMenuItem;
  694. HWND hwnd;
  695. for (iWin = 1; iWin <= 10; iWin++, nID++)
  696. {
  697. hwnd = ::GetDlgItem(m_hWndMDIClient, nID);
  698. if (hwnd == NULL)
  699. break;
  701. if (bAddSeperator)
  702. {
  703. menu.InsertMenu(iPos++, MF_BYPOSITION | MF_SEPARATOR);
  704. bAddSeperator = FALSE;
  705. }
  707. if (iWin < 10)
  708. {
  709. CWnd::FromHandle(hwnd)->GetWindowText(sWinName);
  710. sMenuItem.Format(_T("&%d %s"), iWin, (LPCTSTR)sWinName);
  711. menu.InsertMenu(iPos, MF_BYPOSITION, nID, sMenuItem);
  712. if (hwnd == hwndActive)
  713. menu.CheckMenuItem(iPos, MF_BYPOSITION | MF_CHECKED);
  714. }
  715. else
  716. {
  717. menu.InsertMenu(iPos, MF_BYPOSITION, nID, _szMoreWindows);
  718. }
  719. iPos++;
  720. }
  722. menu.Detach();
  723. }
  724. //******************************************************************
  725. void CMenuBar::OnSetMenu(HMENU hNewMenu, HMENU hWindowMenu)
  726. {
  727. if (!bIsTabbed)
  728. ASSERT(m_pMenuIcon && m_pMenuControl);
  729. // We can get active MDI child window on this message!
  730. BOOL bMax = FALSE;
  731. HWND hWndChild = GetActiveChildWnd(bMax);
  733. if (!m_hWndActiveChild || m_hWndActiveChild != hWndChild) {// an active child window changed
  734. LTRACE(_T("CMenuBar::OnSetMenu---an active child window changedn"));
  735. m_hWndActiveChild = hWndChild;
  736. // tell MenuIcon child window has been changed
  737. if (!bIsTabbed)
  738. m_pMenuIcon->OnActivateChildWnd();
  739. }
  741. if (!m_hMenu || m_hMenu != hNewMenu) { // menu changed
  742. LTRACE(_T("CMenuBar::OnSetMenu---menu changedn"));
  743. LoadMenu(hNewMenu, hWindowMenu); // set menubar menu
  744. GetOwner()->SetMenu(NULL); // clear frame menu
  745. }
  746. }
  747. //******************************************************************
  748. BOOL CMenuBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  749. {
  751. CPoint ptCurPos; 
  752. CRect rc;GetClientRect(rc);
  753. GetCursorPos (&ptCurPos);
  754. ScreenToClient (&ptCurPos);
  755. if (m_dwStyle & CBRS_ORIENT_HORZ)
  756. {
  757. rc.right=rc.left+2;
  758. if (ptCurPos.x< 0)
  759. {
  760. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  761. return TRUE;
  762. }
  763. }
  764. else
  765. {
  766. rc.bottom=rc.top+2;
  767. if (ptCurPos.y< 0)
  768. {
  769. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  770. return TRUE;
  771. }
  772. }
  773. return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  775. }
  777. //******************************************************************
  778. void CMenuBar::OnNcPaint() 
  779. {
  780. EraseNonClientEx();
  781. }
  782. //******************************************************************
  783. UINT CMenuBar::OnNcHitTest(CPoint point) 
  784. {
  785. // make nonclient area clickable
  786. return HTCLIENT;
  787. }
  788. //******************************************************************
  789. void CMenuBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  790. {
  791. // calculate border space (will add to top/bottom, subtract from right/bottom)
  792. CRect rect; rect.SetRectEmpty();
  793. BOOL bHorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  794. _CalcInsideRect(rect, bHorz);
  796. if (!(m_dwStyle & CBRS_FLOATING))
  797. {
  798. // adjust non-client area for border space
  799. lpncsp->rgrc[0].left += bHorz?rect.left+4:rect.left+1;
  800. lpncsp->rgrc[0].top += bHorz?rect.top+4:rect.top+2;
  801. }
  802. else
  803. {
  804. lpncsp->rgrc[0].left += rect.left;
  805. lpncsp->rgrc[0].top += rect.top+4;
  806. }
  807. lpncsp->rgrc[0].right += rect.right;
  808. lpncsp->rgrc[0].bottom += rect.bottom;
  810. }
  811. //******************************************************************
  812. void CMenuBar::OnDestroy() 
  813. {
  814. if(m_bCombo==TRUE)
  815. cmb->SaveHistory(szNameHistory,bSaveHistory);
  816. CControlBar::OnDestroy();
  818. // TODO: 
  819. DeleteItems();
  821. if (m_nIDEvent)
  822. KillTimer(m_nIDEvent);
  824. // for SDI application
  825. if (m_bMDIApp == FALSE && m_hMenu != NULL)
  826. ::FreeResource(m_hMenu);
  827. }
  828. //******************************************************************
  829. void CMenuBar::OnTimer(UINT nIDEvent) 
  830. {
  831. if (m_nTrackingState == buttonmouse) {
  832. CPoint pt; ::GetCursorPos(&pt);
  833. CRect rect;
  834. GetWindowRect(&rect);
  836. if (!rect.PtInRect(pt)) {
  837. UpdateBar();
  839. if (m_nIDEvent) {
  840. KillTimer(m_nIDEvent);
  841. m_nIDEvent = NULL;
  842. }
  843. }
  844. }
  846. CControlBar::OnTimer(nIDEvent);
  847. }
  848. //******************************************************************
  849. HWND CMenuBar::GetActiveChildWnd(BOOL& bMaximized)
  850. {
  851. if (!m_hWndMDIClient)
  852. return NULL;
  854. BOOL bMax = FALSE;
  855. HWND hWnd = (HWND)::SendMessage(m_hWndMDIClient,
  856. WM_MDIGETACTIVE, 0, (LPARAM)&bMax);
  857. bMaximized = bMax;
  859. return hWnd;
  860. }
  861. //******************************************************************
  862. /////////////////////////////////////////////////////////////////////////////
  863. // CMenuBar system hook
  864. void CMenuBar::OnMenuSelect(HMENU hMenu, UINT nIndex)
  865. {
  866. // LTRACE(_T("CMenuBar::OnMenuSelectn"));
  867. if (m_nTrackingState == popup) {
  868. m_bProcessRightArrow = (::GetSubMenu(hMenu, nIndex) == NULL);
  869. HMENU hSubMenu = ::GetSubMenu(hMenu, m_nCurIndex);
  870. if (hSubMenu == NULL)
  871. return;
  872. m_bProcessLeftArrow = (hMenu == hSubMenu);
  873. }
  874. }
  875. //******************************************************************
  876. void CMenuBar::OnFrameNcActivate(BOOL bActive) 
  877. {
  878. CFrameWnd* pFrame = GetTopLevelFrame();
  879. ASSERT_VALID(pFrame);
  881. if (pFrame->m_nFlags & WF_STAYACTIVE)
  882. bActive = TRUE;
  883. if (!pFrame->IsWindowEnabled())
  884. bActive = FALSE;
  885. if (bActive == m_bFrameActive)
  886. return;
  888. if (!bActive) {
  889. for (int i = 0; i < GetItemCount(); ++i) {
  890. m_arrItem[i]->ModifyState(0, MISTATE_INACTIVE);
  891. }
  892. }
  893. else {
  894. for (int i = 0; i < GetItemCount(); ++i) {
  895. m_arrItem[i]->ModifyState(MISTATE_INACTIVE, 0);
  896. }
  897. }
  899. m_bFrameActive = bActive;
  901. // InvalidateRect(NULL); is better, but too late
  902. // while clicking the application title bar (like IE5)
  903. // so we have to redraw now!
  904. CClientDC dc(this);
  905. DoPaint(&dc);
  906. }
  907. //******************************************************************
  908. LRESULT CALLBACK CMenuBar::MenuInputFilter(int code, WPARAM wParam, LPARAM lParam)
  909. {
  910. return (
  911. code == MSGF_MENU &&
  912. g_pMenuBar &&
  913. g_pMenuBar->OnMenuInput( *((MSG*)lParam) )
  914. ) ? TRUE : CallNextHookEx(g_hMsgHook, code, wParam, lParam);
  915. }
  916. //******************************************************************
  917. void CMenuBar::TrackPopup(int nIndex)
  918. {
  919. ASSERT_VALID(this);
  921. m_nCurIndex = nIndex;
  922. m_bLoop = TRUE;
  923. while (m_bLoop == TRUE) {
  924. UpdateWindow(); // force to repaint when button hidden by other window
  925. UpdateBar(popup, m_nCurIndex);
  927. // install hook
  928. ASSERT(g_pMenuBar == NULL);
  929. g_pMenuBar = this;
  930. ASSERT(g_hMsgHook == NULL);
  932. m_bLoop = FALSE;
  933. g_hMsgHook = ::SetWindowsHookEx(WH_MSGFILTER,
  934. MenuInputFilter, NULL, AfxGetApp()->m_nThreadID);// m_bLoop may become TRUE
  936. // popup!!
  937. m_nTrackingState = popup;
  938. _nPrevIndexForCmd = m_nCurIndex;
  939. m_arrItem[m_nCurIndex]->TrackPopup(this, GetTopLevelParent());
  941. // uninstall hook
  942. ::UnhookWindowsHookEx(g_hMsgHook);
  943. g_hMsgHook = NULL;
  944. g_pMenuBar = NULL;
  945. }
  947. UpdateBar();
  948. }
  950. //******************************************************************
  951. BOOL CMenuBar::OnMenuInput(MSG& m)
  952. {
  953. ASSERT_VALID(this);
  954. int nMsg = m.message;
  955. CPoint pt = m.lParam;
  956. ScreenToClient(&pt);
  958. switch (nMsg) {
  959. case WM_MOUSEMOVE:
  960. if (pt != m_ptMouse) {
  961. int nIndex = HitTestOnTrack(pt);
  962. if (IsValidIndex(nIndex) && nIndex != m_nCurIndex) {
  963. // defferent button clicked
  964. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  965. UpdateBar(); // clean up
  966. m_nCurIndex = nIndex;
  967. m_bLoop = TRUE; // continue loop
  968. }
  969. m_ptMouse = pt;
  970. }
  971. break;
  973. case WM_LBUTTONDOWN:
  974. if (HitTestOnTrack(pt) != -1 && HitTestOnTrack(pt) == m_nCurIndex) {
  975. // same button clicked
  976. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  977. UpdateBar(button, m_nCurIndex);
  978. m_bLoop = FALSE; // out of loop
  979. return TRUE; // eat it!
  980. }
  981. break;
  983. case WM_KEYDOWN: {
  984. TCHAR vKey = m.wParam;
  985. if (m_dwStyle & CBRS_ORIENT_VERT) { // if vertical
  986. break; // do nothing
  987. }
  989. if ((vKey == VK_LEFT  && m_bProcessLeftArrow) ||
  990. (vKey == VK_RIGHT && m_bProcessRightArrow)) {
  991. // no submenu
  992. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vKey==VK_LEFT);
  993. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  994. UpdateBar();
  995. m_nCurIndex = nNewIndex;
  996. m_bLoop = TRUE; // continue loop
  997. return TRUE; // eat it!
  998. }
  999. }
  1000. break;
  1002. case WM_SYSKEYDOWN:
  1003. // LTRACE(_T("    m_bIgnore = TRUEn"));
  1004. m_bIgnoreAlt = TRUE; // next SysKeyUp will be ignored
  1005. break;
  1006. }
  1008. return FALSE; // pass along...
  1009. }
  1011. //******************************************************************
  1012. BOOL CMenuBar::TranslateFrameMessage(MSG* pMsg)
  1013. {
  1014. ASSERT_VALID(this);
  1015. ASSERT(pMsg);
  1017. UINT nMsg = pMsg->message;
  1018. if (WM_LBUTTONDOWN <= nMsg && nMsg <= WM_MOUSELAST) {
  1019. if (pMsg->hwnd != m_hWnd && m_nTrackingState > 0) {
  1020. // clicked outside
  1021. UpdateBar();
  1022. }
  1023. }
  1024. else if (nMsg == WM_SYSKEYDOWN || nMsg == WM_SYSKEYUP || nMsg == WM_KEYDOWN) {
  1025. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN; // Alt key presed?
  1026. TCHAR vkey = pMsg->wParam; // + X key
  1027. if (vkey == VK_MENU ||
  1028. (vkey == VK_F10 && !((GetKeyState(VK_SHIFT) & 0x80000000) ||
  1029.                    (GetKeyState(VK_CONTROL) & 0x80000000) || bAlt))) {
  1030. // only alt key pressed
  1031. if (nMsg == WM_SYSKEYUP) {
  1032. switch (m_nTrackingState) {
  1033. case none:
  1034. if (m_bIgnoreAlt == TRUE) {
  1035. // LTRACE(_T("    ignore ALT key upn"));
  1036. m_bIgnoreAlt = FALSE;
  1037. break;
  1038. }
  1040. if (m_bMDIApp) {
  1041. UpdateBar(button, GetNextOrPrevButton(0, FALSE));
  1042. }
  1043. else {
  1044. UpdateBar(button, 0);
  1045. }
  1046. break;
  1047. case button:
  1048. UpdateBar();
  1049. break;
  1050. case buttonmouse:
  1051. break; // do nothing
  1052. }
  1053. }
  1054. return TRUE;
  1055. }
  1056. else if ((nMsg == WM_SYSKEYDOWN || nMsg == WM_KEYDOWN)) {
  1057. if (m_nTrackingState == button) {
  1058. if (m_dwStyle & CBRS_ORIENT_HORZ) { // if horizontal
  1059. switch (vkey) {
  1060. case VK_LEFT:
  1061. case VK_RIGHT: {
  1062. int nNewIndex  = GetNextOrPrevButton(m_nCurIndex, vkey == VK_LEFT);
  1063. UpdateBar(button, nNewIndex);
  1064. return TRUE;
  1065.    }
  1066. case VK_SPACE:
  1067. case VK_UP:
  1068. case VK_DOWN:
  1069. TrackPopup(m_nCurIndex);
  1070. return TRUE;
  1072. case VK_ESCAPE:
  1073. UpdateBar();
  1074. return TRUE;
  1075. }
  1076. }
  1077. else { // if vertical
  1078. switch (vkey) {
  1079. case VK_UP:
  1080. case VK_DOWN:{
  1081. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vkey == VK_UP);
  1082. UpdateBar(button, nNewIndex);
  1083. return TRUE;
  1084.    }
  1085. case VK_SPACE:
  1086. case VK_RIGHT:
  1087. case VK_LEFT:
  1088. TrackPopup(m_nCurIndex);
  1089. return TRUE;
  1091. case VK_ESCAPE:
  1092. UpdateBar();
  1093. return TRUE;
  1094. }
  1095. }
  1096. }
  1098. // Alt + X pressed
  1099. if ((bAlt || m_nTrackingState == button) && _istalnum(vkey)) {
  1100. int nIndex;
  1101. if (MapAccessKey(vkey, nIndex) == TRUE) {
  1102. UpdateBar();
  1103. TrackPopup(nIndex);
  1104. return TRUE; // eat it!
  1105. }
  1106. else if (m_nTrackingState==button && !bAlt) {
  1107. // MessageBeep(0); // if you want
  1108. return TRUE;
  1109. }
  1110. }
  1112. if (m_nTrackingState > 0) { // unknown key
  1113. if (m_nTrackingState != buttonmouse) { // if tracked with mouse, don't update bar
  1114. UpdateBar();
  1115. }
  1116. }
  1117. }
  1118. }
  1119. return FALSE; // pass along...
  1120. }
  1122. //******************************************************************
  1123. BOOL CMenuBar::MapAccessKey(TCHAR cAccessKey, int& nIndex)
  1124. {
  1125. for (int i = 0; i < GetItemCount(); ++i) {
  1126. // fixing point
  1127. TCHAR cKey = m_arrItem[i]->GetAccessKey();
  1128. if (toupper(cKey)/*_totupper(cKey)*/ == cAccessKey) {// *****fixed by andi, thanx!*****
  1129. nIndex = i;
  1130. return TRUE;
  1131. }
  1132. }
  1133. return FALSE;
  1134. }
  1136. /////////////////////////////////////////////////////////////////////////////
  1137. // CMenuBar layout
  1138. int CMenuBar::GetClipBoxLength(BOOL bHorz)
  1139. {
  1140. CFrameWnd* pFrame = GetTopLevelFrame(); ASSERT_VALID(pFrame);
  1141. CRect rcFrame; pFrame->GetWindowRect(rcFrame);
  1143. CWnd* pParent = GetParent(); ASSERT_VALID(pParent);
  1144. CRect rcParent; pParent->GetWindowRect(rcParent);
  1146. const int cxFrameBorder = ::GetSystemMetrics(SM_CXFRAME);
  1147. int cxNonClient = cxFrameBorder*2 + m_cxLeftBorder + m_cxRightBorder;
  1148. if (m_dwExStyle & CBRS_GRIPPER)
  1149. cxNonClient += CX_GRIPPER_ALL;
  1151. if (m_dwStyle & CBRS_SIZE_DYNAMIC) {
  1152. if (bHorz) {
  1153. return rcFrame.Width() - cxNonClient;
  1154. }
  1155. else {
  1156. int nResult = rcParent.Height();
  1157. // I don't know the reason of the following code...
  1158. nResult -= m_cxRightBorder + m_cxLeftBorder + cyBorder2*2;
  1159. if (m_dwExStyle & CBRS_GRIPPER)
  1160. nResult -= CY_GRIPPER_ALL;
  1162. return nResult;
  1163. }
  1164. }
  1165. else {
  1166. CRect rect; GetClientRect(rect);
  1167. if (bHorz) {
  1168. return rect.Width();
  1169. }
  1170. else {
  1171. return rect.Height();
  1172. }
  1173. }
  1174. }
  1176. //******************************************************************
  1177. CSize CMenuBar::CalcLayout(DWORD dwMode, int nLength)
  1178. {
  1179. ASSERT_VALID(this);
  1180. ASSERT(::IsWindow(m_hWnd));
  1181. if (dwMode & LM_HORZDOCK)
  1182. ASSERT(dwMode & LM_HORZ);
  1184. // make SC_CLOSE button disable
  1185. if (m_dwStyle & CBRS_FLOATING) {
  1186. CFrameWnd* pMiniFrame = GetParentFrame(); ASSERT_KINDOF(CMiniFrameWnd, pMiniFrame);
  1187. // Don't do this, cause right click menu turns unavairable
  1188. // pMiniFrame->ModifyStyle(WS_SYSMENU, 0);
  1189. CMenu* pSysMenu = pMiniFrame->GetSystemMenu(FALSE); ASSERT_VALID(pSysMenu);
  1190. pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
  1191. }
  1193. int nCount = GetItemCount();
  1194. CSize sizeResult(0, 0);
  1196. if (nCount > 0)
  1197. {
  1198. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  1199. {
  1200. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1202. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1203. {
  1204. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_MRUWIDTHn"));
  1205. SizeMenuBar(m_nMRUWidth);
  1206. CalcItemLayout(nCount);// added
  1208. sizeResult = CalcSize(nCount);
  1209. }
  1210. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1211. {
  1212. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_HORZDOCKn"));
  1213. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_VERT)) {
  1214. // I can't synchronize horz size on dragging with size on dock bar
  1215. // as VC++ developer can't.
  1216. SizeMenuBar(32767);
  1217. }
  1218. else {
  1219. // Menu Button wrapped by frame width
  1220. SizeMenuBar(GetClipBoxLength(TRUE));
  1221. }
  1223. CalcItemLayout(nCount);// added
  1225. sizeResult = CalcSize(nCount);
  1226. if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_VERT)) {
  1227. if (m_pDockContext->m_pDC) {// while dragging (m_pDockContext->m_bDragging is helpless)
  1228. sizeResult.cx = GetClipBoxLength(TRUE);
  1229. }
  1230. }
  1231. }
  1232. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1233. {
  1234. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_VERTDOCKn"));
  1235. //SizeMenuBar(0);
  1236. CalcItemLayout(nCount, TRUE);// added
  1238. sizeResult = CalcVertDockSize(nCount);
  1239. if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_HORZ)) {
  1240. if (m_pDockContext->m_pDC) {// while dragging
  1241. sizeResult.cy = GetClipBoxLength(FALSE);//GetrcParent.Height() - m_cxRightBorder - m_cxLeftBorder;
  1242. }
  1243. }
  1244. }
  1245. else if (bDynamic && (nLength != -1))
  1246. {
  1247. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---nLength != -1n"));
  1248. CRect rect; rect.SetRectEmpty();
  1249. _CalcInsideRect(rect, (dwMode & LM_HORZ));
  1250. BOOL bVert = (dwMode & LM_LENGTHY);
  1251. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1253. SizeMenuBar(nLen, bVert);
  1254. CalcItemLayout(nCount, bVert);// added
  1256. sizeResult = CalcSize(nCount);
  1257. }
  1258. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1259. {
  1260. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---CBRS_FLOATINGn"));
  1261. SizeMenuBar(m_nMRUWidth);
  1262. CalcItemLayout(nCount);// added
  1264. sizeResult = CalcSize(nCount);
  1265. }
  1266. else
  1267. {
  1268. if (!bDynamic) {
  1269. InvalidateRect(NULL);
  1270. goto Junk;
  1271. }
  1273. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---othern"));
  1274. BOOL bVert = !(dwMode & LM_HORZ);
  1275. SizeMenuBar(GetClipBoxLength(TRUE));
  1276. CalcItemLayout(nCount, bVert);// added
  1278. if (bVert) {
  1279. InvalidateRect(NULL);// draw forcefully for captions
  1280. sizeResult = CalcVertDockSize(nCount);
  1281. // DockBar not replaced yet, so I can't get precise size
  1282. sizeResult.cy = 10000;
  1283. }
  1284. else {
  1285. sizeResult = CalcSize(nCount);
  1286. sizeResult.cx = GetClipBoxLength(TRUE);
  1287. }
  1288. }
  1289. }
  1290. else {// CBRS_SIZE_FIXED
  1291. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_FIXED)n"));
  1292. Junk:
  1293. BOOL bVert = !(dwMode & LM_HORZ);
  1294. SizeMenuBar(32767);
  1295. CalcItemLayout(nCount, bVert);// added
  1297. if (bVert) {
  1298. sizeResult = CalcVertDockSize(nCount);
  1299. }
  1300. else {
  1301. sizeResult = CalcSize(nCount);
  1302. }
  1303. }
  1305. if (dwMode & LM_COMMIT)
  1306. {
  1307. LTRACE(_T("CMenuBar::CalcLayout---LM_COMMITn"));
  1308. int nControlCount = 0;
  1309. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1310. m_bDelayedButtonLayout = FALSE;
  1312. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1313. m_nMRUWidth = sizeResult.cx;
  1315. //CalcItemLayout(nCount, dwMode);
  1317. m_bDelayedButtonLayout = bIsDelayed;
  1318. }
  1319. }
  1321. //BLOCK: Adjust Margins
  1322. {
  1323. CRect rect; rect.SetRectEmpty();
  1324. _CalcInsideRect(rect, (dwMode & LM_HORZ));
  1325. sizeResult.cy -= rect.Height();
  1326. sizeResult.cx -= rect.Width();
  1328. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1329. sizeResult.cx = max(sizeResult.cx, size.cx);
  1330. sizeResult.cy = max(sizeResult.cy, size.cy);
  1331. }
  1333. if (dwMode & LM_HORZ)
  1334. sizeResult.cy+=5;
  1335. else
  1336. sizeResult.cx+=3;
  1337. if (m_bCombo==TRUE)
  1338. DrawCombo();
  1339. return sizeResult;
  1340. }
  1342. //******************************************************************
  1343. CSize CMenuBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1344. {
  1345. LTRACE(_T("CMenuBar::CalcFixedLayoutn"));
  1346. ASSERT_VALID(this);
  1347. ASSERT(::IsWindow(m_hWnd));
  1349. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1350. dwMode |= bHorz ? LM_HORZ : 0;
  1352. return CalcLayout(dwMode);
  1353. }
  1354. //******************************************************************
  1356. CSize CMenuBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  1357. {
  1358. LTRACE(_T("CMenuBar::CalcDynamicLayoutn"));
  1359. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1360. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1361. {
  1362. LTRACE(_T("    FixedLayoutn"));
  1363. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1364. }
  1365. return CalcLayout(dwMode, nLength);
  1366. }
  1368. // set m_bWrapped by nWidth
  1369. int CMenuBar::WrapMenuBar(int nCount, int nWidth)
  1370. {
  1371. // LTRACE(_T("CMenuBar::WrapMenuBarn"));
  1372. int nResult = 0;
  1373. int x = 0;
  1375. for (int i = 0; i < nCount; ++i) {
  1376. CMenuItem* pItem = m_arrItem[i];
  1377. if (i+1 == nCount)
  1378. return ++nResult;
  1380. if (x + pItem->GetHorizontalSize().cx> nWidth) {// itself is over
  1381. if (pItem->GetStyle() & MISTYLE_WRAPPABLE) {
  1382. pItem->ModifyState(0, MISTATE_WRAP);
  1383. ++nResult;
  1384. x = 0;
  1385. }
  1386. }
  1387. else if (x + pItem->GetHorizontalSize().cx + 
  1388.  m_arrItem[i+1]->GetHorizontalSize().cx> nWidth) {
  1389. if (pItem->GetStyle() & MISTYLE_WRAPPABLE) {
  1390. pItem->ModifyState(0, MISTATE_WRAP);
  1391. ++nResult;
  1392. x = 0;
  1393. }
  1394. }
  1395. else {
  1396. pItem->ModifyState(MISTATE_WRAP, 0);
  1397. x += pItem->GetHorizontalSize().cx;
  1398. }
  1399. }
  1401. return nResult + 1;
  1402. }
  1403. //******************************************************************
  1404. // calc only size, by using m_bWrapped
  1405. CSize CMenuBar::CalcSize(int nCount)
  1406. {
  1407. ASSERT(nCount > 0);
  1408. CPoint cur(0,0);
  1409. CSize sizeResult(0,0);
  1410. int nWrap = 0;
  1411. for (int i = 0; i < nCount; ++i) {
  1412. CMenuItem* pItem = m_arrItem[i];
  1413. sizeResult.cx = max(cur.x + pItem->GetHorizontalSize().cx, sizeResult.cx);
  1414. sizeResult.cy = max(cur.y + pItem->GetHorizontalSize().cy, sizeResult.cy);
  1416. cur.x += pItem->GetHorizontalSize().cx;
  1418. if (pItem->GetState() & MISTATE_WRAP) {
  1419. //LTRACE(_T("    nIndex:%d is wrappedn"), i);
  1420. cur.x = 0;// reset x pos
  1421. cur.y += pItem->GetHorizontalSize().cy;
  1422. ++nWrap;
  1423. }
  1424. }
  1426. return sizeResult;
  1427. }
  1428. //******************************************************************
  1429. void CMenuBar::Layout()
  1430. {
  1431. ASSERT(m_bDelayedButtonLayout);
  1433. m_bDelayedButtonLayout = FALSE;
  1435. BOOL bHorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  1436. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1437. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH | LM_COMMIT);
  1438. else if (bHorz)
  1439. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK | LM_COMMIT);
  1440. else
  1441. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_VERTDOCK | LM_COMMIT);
  1442. }
  1443. //******************************************************************
  1444. void CMenuBar::SizeMenuBar(int nLength, BOOL bVert)
  1445. {
  1446. //LTRACE("CMenuBar::SizeMenuBarn");
  1447. int nCount = GetItemCount(); ASSERT(nCount > 0);
  1449. if (!bVert) { // nLength is horizontal length
  1451. if (IsFloating()) { // half size wrapping
  1453. CSize sizeMax, sizeMin, sizeMid;
  1455. // Wrap MenuBar vertically
  1456. WrapMenuBar(nCount, 0);
  1457. sizeMin = CalcSize(nCount);
  1459. // Wrap MenuBar horizontally
  1460. WrapMenuBar(nCount, 32767);
  1461. sizeMax = CalcSize(nCount);
  1463. // we can never understand this algorithm :), see CToolBar implementation
  1464. while (sizeMin.cx < sizeMax.cx) {
  1465. // LTRACE("looping sizeMin.cx:%d < sizeMax.cx:%dn", sizeMin.cx, sizeMax.cx);
  1466. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1467. WrapMenuBar(nCount, sizeMid.cx);
  1468. sizeMid = CalcSize(nCount);
  1469. if (sizeMid.cx == sizeMax.cx) { // if you forget, it loops forever!
  1470. return;
  1471. }
  1472. // LTRACE("    sizeMid : %d %dn", sizeMid.cx, sizeMid.cy);
  1474. if (nLength >= sizeMax.cx) {
  1475. // LTRACE("    nLength:%d >= sizeMax.cx:%dn", nLength, sizeMax.cx);
  1476. if (sizeMin == sizeMid) {
  1477. WrapMenuBar(nCount, sizeMax.cx);
  1478. // LTRACE("out SizeMenuBarn");
  1479. return;
  1480. }
  1481. sizeMin = sizeMid;
  1482. }
  1483. else if (nLength < sizeMax.cx) {
  1484. // LTRACE("    nLength:%d < sizeMax.cx:%dn", nLength, sizeMax.cx);
  1485. sizeMax = sizeMid;
  1486. }
  1487. else {
  1488. // LTRACE("out SizeMenuBarn");
  1489. return;
  1490. }
  1491. }
  1492. }
  1493. else { // each one wrapping
  1494. //LTRACE("    just each one wrappingn");
  1495. WrapMenuBar(nCount, nLength);
  1496. }
  1497. }
  1498. else { // nLength is vertical length
  1499. CSize sizeMax, sizeMin, sizeMid;
  1501. // Wrap MenuBar vertically
  1502. WrapMenuBar(nCount, 0);
  1503. sizeMin = CalcSize(nCount);
  1505. // Wrap MenuBar horizontally
  1506. WrapMenuBar(nCount, 32767);
  1507. sizeMax = CalcSize(nCount);
  1509. while (sizeMin.cx < sizeMax.cx) {
  1510. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1511. WrapMenuBar(nCount, sizeMid.cx);
  1512. sizeMid = CalcSize(nCount);
  1513. if (sizeMid.cx == sizeMax.cx) {
  1514. return;
  1515. }
  1516. if (nLength < sizeMid.cy) {
  1517. if (sizeMin == sizeMid) {
  1518. WrapMenuBar(nCount, sizeMax.cx);
  1519. //LTRACE("out SizeMenuBarn");
  1520. return;
  1521. }
  1522. sizeMin = sizeMid;
  1523. }
  1524. else if (nLength > sizeMid.cy)
  1525. sizeMax = sizeMid;
  1526. else {
  1527. //LTRACE("out SizeMenuBarn");
  1528. return;
  1529. }
  1530. }
  1531. }
  1533. //LTRACE("out SizeMenuBarn");
  1534. }
  1535. //***********************************************************************************
  1536. void CMenuBar::DrawCombo()
  1537. {
  1538. CRect rect;
  1539. GetClientRect(rect);
  1540. CalcSizeItem();
  1541. CWnd* pFrame = GetTopLevelFrame();
  1542. BOOL bMaximized = FALSE;
  1543. //la idea es verificar que la ventana es MDI
  1544. if (pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd)))
  1545. {
  1546. ASSERT_VALID(pFrame);
  1547. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  1548. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  1549. ASSERT(::IsWindow(hWndMDIClient));
  1550. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  1551. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  1552. }
  1553. if ((m_dwStyle & CBRS_ORIENT_HORZ) && m_bCombo==TRUE && !(m_dwStyle & CBRS_FLOATING))
  1554. {
  1555. CRect reccombo;
  1556. cmb->GetClientRect (&reccombo);
  1557. if (rect.Width() > m_sizex+(bMaximized?30:0)+reccombo.Width() )
  1558. {
  1559. cmb->ShowWindow(SW_SHOW);
  1560. CRect rctemp=rect;
  1561. rctemp.top=-1;
  1562. rctemp.bottom-=2;
  1563. int nDif;
  1564. if (!bIsTabbed)
  1565.    nDif=bMaximized?60:0;
  1566. else
  1567.    nDif=0;
  1568. rctemp.left=rctemp.right-reccombo.Width()-  nDif;
  1569. rctemp.right=rctemp.left+reccombo.Width();
  1570. cmb->MoveWindow(rctemp);
  1571. }
  1572. else
  1573. {
  1574. cmb->ShowWindow(SW_HIDE);
  1575. }
  1576. }
  1578. }
  1580. //******************************************************************
  1581. void CMenuBar::CalcSizeItem()
  1582. {
  1583. m_sizex=0;
  1584. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  1585. CMenuItem* pItem = m_arrItem[i];
  1586. m_sizex+=pItem->GetRect().Width();
  1587. }
  1589. }
  1591. //******************************************************************
  1592. CSize CMenuBar::CalcVertDockSize(int nCount)
  1593. {
  1594. ASSERT(nCount > 0);
  1595. CSize sizeResult(0, 0);
  1597. for (int i = 0; i < nCount; ++i) {
  1598. CMenuItem* pItem = m_arrItem[i];
  1599. sizeResult.cy += pItem->GetRect().Height();
  1600. }
  1602. sizeResult.cx = _cyMenuOnBar;
  1603. return sizeResult;
  1604. }
  1606. //******************************************************************
  1607. void CMenuBar::CalcItemLayout(int nCount, BOOL bVert)
  1608. {
  1609. ASSERT(nCount > 0);
  1610. int x = 0; int y = 0;
  1612. if (!bVert) {
  1613. for (int i = 0; i < nCount; ++i) {
  1614. CMenuItem* pItem = m_arrItem[i];
  1615. CPoint ptItem(x, y);
  1616. pItem->Layout(ptItem, TRUE);// layout by itself!
  1617. if (pItem->GetState() & MISTATE_WRAP) {
  1618. x = 0;// reset x to 0
  1619. y += pItem->GetRect().Height();
  1620. }
  1621. else
  1622. x += pItem->GetRect().Width();
  1623. }
  1624. }
  1625. else {
  1626. for (int i = 0; i < nCount; ++i) {
  1627. CMenuItem* pItem = m_arrItem[i];
  1628. CPoint ptItem(0, y);
  1629. pItem->Layout(ptItem, FALSE); // layout by itself
  1630. y += pItem->GetRect().Height();
  1631. }
  1632. }
  1633. }
  1634. //******************************************************************
  1635. //////////////////////////////////////////////////////////////////////
  1636. // Added by Koay Kah Hoe. Thanx!
  1637. void CMenuBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  1638. {
  1639. if (m_bMDIApp)
  1640. CheckActiveChildWndMaximized();
  1641. }
  1642. //******************************************************************
  1643. //////////////////////////////////////////////////////////////////////
  1644. // CMenuBar decoration
  1646. void CMenuBar::_DrawGripper(CWindowDC* dc,CRect* rcWin)
  1647. {
  1650. if (m_dwStyle & CBRS_FLOATING) return ;
  1651. if (m_dwStyle & CBRS_ORIENT_HORZ)
  1652. {
  1654. rcWin->top+=9;
  1655. rcWin->left+=7;
  1656. rcWin->right=rcWin->left+3;
  1657. rcWin->bottom-=3;
  1659. for (int i=0; i < rcWin->Height(); i+=2)
  1660. {
  1661. CRect rcWindow;
  1662. CBrush cb;
  1663. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1664. rcWindow=rcWin;
  1665. rcWindow.top=rcWin->top+i;
  1666. rcWindow.bottom=rcWindow.top+1;
  1667. dc->FillRect(rcWindow,&cb);
  1669. }
  1671. }
  1672. else
  1673. {
  1674. rcWin->top+=2;
  1675. rcWin->left+=2;
  1676. rcWin->right-=2;
  1677. rcWin->bottom=rcWin->top+3;
  1678. for (int i=0; i < rcWin->Width(); i+=2)
  1679. {
  1680. CRect rcWindow;
  1681. CBrush cb;
  1682. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1683. rcWindow=rcWin;
  1684. rcWindow.left=rcWindow.left+i;
  1685. rcWindow.right=rcWindow.left+1;
  1686. dc->FillRect(rcWindow,&cb);
  1688. }
  1690. }
  1693. }
  1695. //******************************************************************
  1696. void CMenuBar::EraseNonClientEx()
  1697. {
  1698. // get window DC that is clipped to the non-client area
  1699. CWindowDC dc(this);
  1700. CRect rectClient;
  1701. GetClientRect(rectClient);
  1702. CRect rectWindow;
  1703. GetWindowRect(rectWindow);
  1704. ScreenToClient(rectWindow);
  1705. rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
  1706. dc.ExcludeClipRect(rectClient);
  1708. // draw borders in non-client area
  1709. rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);
  1711. dc.IntersectClipRect(rectWindow);
  1712. SendMessage(WM_ERASEBKGND, (WPARAM)dc.m_hDC);
  1714. // draw gripper in non-client area
  1715. _DrawGripper(&dc, &rectWindow);
  1716. }
  1718. #define CX_BORDER   1
  1719. #define CY_BORDER   1
  1720. //******************************************************************
  1721. void CMenuBar::DrawRaisedBorders(CDC* pDC, CRect& rect)
  1722. {
  1723. ASSERT_VALID(this);
  1724. ASSERT_VALID(pDC);
  1726. DWORD dwStyle = m_dwStyle;
  1727. if (!(dwStyle & CBRS_BORDER_ANY))
  1728. return;
  1730. // prepare for dark lines
  1731. ASSERT(rect.top == 0 && rect.left == 0);
  1732. CRect rect1, rect2;
  1733. rect1 = rect;
  1734. rect2 = rect;
  1735. COLORREF clrBtnShadow = ::GetSysColor(COLOR_BTNSHADOW);//afxData.bWin4 ? afxData.clrBtnShadow : afxData.clrWindowFrame;
  1736. COLORREF clrBtnFace = ::GetSysColor(COLOR_BTNFACE);
  1737. COLORREF clrBtnHilight = ::GetSysColor(COLOR_BTNHILIGHT);
  1739. // draw dark line one pixel back/up
  1740. if (dwStyle & CBRS_BORDER_3D)
  1741. {
  1742. rect1.right -= CX_BORDER;
  1743. rect1.bottom -= CY_BORDER;
  1744. }
  1745. if (dwStyle & CBRS_BORDER_TOP)
  1746. rect2.top += cyBorder2;
  1747. if (dwStyle & CBRS_BORDER_BOTTOM)
  1748. rect2.bottom -= cyBorder2;
  1750. // draw left and top
  1751. if (dwStyle & CBRS_BORDER_LEFT)
  1752. pDC->FillSolidRect(0, rect2.top, CX_BORDER, rect2.Height(), clrBtnFace);
  1753. if (dwStyle & CBRS_BORDER_TOP)
  1754. pDC->FillSolidRect(0, 0, rect.right, CY_BORDER, clrBtnFace);
  1756. // draw right and bottom
  1757. if (dwStyle & CBRS_BORDER_RIGHT)
  1758. pDC->FillSolidRect(rect1.right, rect2.top, -CX_BORDER, rect2.Height(), clrBtnShadow);
  1759. if (dwStyle & CBRS_BORDER_BOTTOM)
  1760. pDC->FillSolidRect(0, rect1.bottom, rect.right, -CY_BORDER, clrBtnShadow);
  1762. if (dwStyle & CBRS_BORDER_3D)
  1763. {
  1764. // draw left and top
  1765. if (dwStyle & CBRS_BORDER_LEFT)
  1766. pDC->FillSolidRect(1, rect2.top, CX_BORDER, rect2.Height(), clrBtnHilight);
  1767. if (dwStyle & CBRS_BORDER_TOP)
  1768. pDC->FillSolidRect(0, 1, rect.right, CY_BORDER, clrBtnHilight);
  1770. // draw right and bottom
  1771. if (dwStyle & CBRS_BORDER_RIGHT)
  1772. pDC->FillSolidRect(rect.right, rect2.top, -CX_BORDER, rect2.Height(), clrBtnFace);
  1773. if (dwStyle & CBRS_BORDER_BOTTOM)
  1774. pDC->FillSolidRect(0, rect.bottom, rect.right, -CY_BORDER, clrBtnFace);
  1775. }
  1777. if (dwStyle & CBRS_BORDER_LEFT)
  1778. rect.left += cxBorder2;
  1779. if (dwStyle & CBRS_BORDER_TOP)
  1780. rect.top += cyBorder2;
  1781. if (dwStyle & CBRS_BORDER_RIGHT)
  1782. rect.right -= cxBorder2;
  1783. if (dwStyle & CBRS_BORDER_BOTTOM)
  1784. rect.bottom -= cyBorder2;
  1785. }
  1787. //******************************************************************
  1788. int CMenuBar::GetNextOrPrevButton(int nIndex, BOOL bPrev)
  1789. {
  1790. int nCount = GetItemCount();
  1791. if (bPrev) { // <-
  1792. --nIndex;
  1793. if (nIndex < 0)
  1794. nIndex = nCount - 1;
  1795. }
  1796. else { // ->
  1797. ++nIndex;
  1798. if (nIndex >= nCount)
  1799. nIndex = 0;
  1800. }
  1802. if (!(m_arrItem[nIndex]->GetStyle() & MISTYLE_TRACKABLE) ||
  1803. (m_arrItem[nIndex]->GetState() & MISTATE_HIDDEN)) {
  1804. return GetNextOrPrevButton(nIndex, bPrev);
  1805. }
  1807. return nIndex;
  1808. }
  1809. //******************************************************************
  1810. /////////////////////////////////////////////////////////////////////////////
  1811. // CMenuBar insists own bar line 
  1812. void CMenuBar::EnableDockingEx(DWORD dwDockStyle)
  1813. {
  1814. // pasted from CFrameWnd implementation
  1815. static const DWORD dwDockBarMap[4][2] =
  1816. {
  1817. { AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
  1818. { AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
  1819. { AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
  1820. { AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
  1821. };
  1823. EnableDocking(dwDockStyle);
  1825. // must be CBRS_ALIGN_XXX or CBRS_FLOAT_MULTI only
  1826. ASSERT((dwDockStyle & ~(CBRS_ALIGN_ANY|CBRS_FLOAT_MULTI)) == 0);
  1828. CFrameWnd* pFrame = GetParentFrame(); ASSERT_VALID(pFrame);
  1829. //pFrame->m_pFloatingFrameClass = RUNTIME_CLASS(CMiniDockFrameWnd);
  1830. for (int i = 0; i < 4; i++)
  1831. {
  1832. if (dwDockBarMap[i][1] & dwDockStyle & CBRS_ALIGN_ANY)
  1833. {
  1834. CDockBar* pDock = (CDockBar*)pFrame->GetControlBar(dwDockBarMap[i][0]);
  1835. if (pDock == NULL)
  1836. {
  1837. pDock = new CMenuDockBar;// which wait for CMenuBar
  1838. if (!pDock->Create(pFrame,
  1839. WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE |
  1840. dwDockBarMap[i][1], dwDockBarMap[i][0]))
  1841. {
  1842. AfxThrowResourceException();
  1843. }
  1844. }
  1845. }
  1846. }
  1847. }
  1848. //******************************************************************
  1849. /////////////////////////////////////////////////////////////////////////////
  1850. // CMenuBar OLE menu support
  1851. // MFC does'nt do command routing for other process server.
  1852. // ::TrackPopupMenuEx won't accept HWND of other process and
  1853. // we have to determine a message target(ole server window or not)
  1854. // as ::OleCreateMenuDescriptor do.
  1855. // This is a hard coding. 
  1856. // First menu(ordinarily File menu) and WindowMenu regarded as container's own menu.
  1857. // Some components can't update toolbar button and statusbar pane.
  1858. HWND CMenuBar::OleMenuDescriptor(BOOL& bSend, UINT nMsg, WPARAM wParam, LPARAM lParam)
  1859. {
  1860. CWnd* pOleWnd = GetCmdSentOleWnd();
  1861. if (pOleWnd == NULL)
  1862. return NULL;
  1863. HWND hWndSentCmd = NULL;
  1865. HMENU hMenu = NULL;
  1866. if (nMsg == WM_INITMENUPOPUP || nMsg == WM_INITMENU)
  1867. hMenu = (HMENU)wParam;
  1868. else if (nMsg == WM_MENUSELECT)
  1869. hMenu = (HMENU)lParam;
  1871. switch (nMsg) {
  1872. case WM_INITMENUPOPUP:
  1873. case WM_INITMENU:
  1874. case WM_MENUSELECT:
  1875. bSend = TRUE;
  1876. if (m_nTrackingState == popup) {
  1877. LTRACE2(_T("    now popupn"));
  1878. if (m_bMDIApp) {
  1879. LTRACE2(_T("    this is MDIn"));
  1880. if (m_nCurIndex == 0 || m_nCurIndex == 1 || hMenu == m_hWindowMenu) {
  1881. LTRACE2(_T("    it's container menu, send to framen"));
  1882. return NULL;
  1883. }
  1884. }
  1885. else {
  1886. LTRACE2(_T("    it's container menu, send to framen"));
  1887. if (m_nCurIndex == 0) {
  1888. return NULL;
  1889. }
  1890. }
  1891. LTRACE2(_T("    it's server menu, send to servern"));
  1892. return pOleWnd->GetSafeHwnd();
  1893. }
  1894. break;
  1896. case WM_COMMAND:
  1897. bSend = FALSE;
  1898. if (m_bMDIApp) {
  1899. LTRACE2(_T("    this is MDIn"));
  1900. if (_nPrevIndexForCmd == 0 || _nPrevIndexForCmd == 1 || _bWindowMenuSendCmd) {
  1901. LTRACE2(_T("    it's container menu, send to framen"));
  1902. return NULL;
  1903. }
  1904. }
  1905. else {
  1906. if (_nPrevIndexForCmd == 0) {
  1907. LTRACE2(_T("    it's container menu, send to framen"));
  1908. return NULL;
  1909. }
  1910. }
  1911. LTRACE2(_T("    it's server menu, send to servern"));
  1912. return pOleWnd->GetSafeHwnd();
  1913. }
  1915. return NULL;// send to frame
  1916. }
  1917. //******************************************************************
  1918. CWnd* CMenuBar::GetCmdSentOleWnd()
  1919. {
  1920. // *****fixed by VORGA, thanks!*****
  1921. CWnd* pWnd = AfxGetMainWnd();
  1922. if (pWnd == NULL || !pWnd->IsFrameWnd())
  1923. return NULL;
  1925. CFrameWnd* pFrame = NULL;
  1926. if (m_bMDIApp) {
  1927. CMDIFrameWnd *pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pWnd);
  1928. if (pMDIFrame == NULL)
  1929. return NULL;
  1930. pFrame = pMDIFrame->GetActiveFrame();
  1931. }
  1932. else {
  1933. pFrame = STATIC_DOWNCAST(CFrameWnd, pWnd);
  1934. }
  1936. if (pFrame == NULL)
  1937. return NULL;
  1939. CDocument* pDoc = pFrame->GetActiveDocument();
  1940. if (pDoc != NULL && pDoc->IsKindOf(RUNTIME_CLASS(COleDocument))) {
  1941. COleDocument* pOleDoc = STATIC_DOWNCAST(COleDocument, pDoc);
  1942. ASSERT_VALID(pOleDoc);
  1943. COleClientItem* pClientItem = pOleDoc->GetInPlaceActiveItem(pFrame);
  1944. CWnd* pWnd = (pClientItem == NULL) ? NULL : pClientItem->GetInPlaceWindow();
  1945. if (pWnd != NULL) {
  1946. return pWnd;
  1947. }
  1948. }
  1950. return NULL;
  1951. }
  1952. //******************************************************************
  1953. /////////////////////////////////////////////////////////////////////////////
  1954. // CMDIClientHook 
  1955. CMDIClientHook::CMDIClientHook()
  1956. {
  1957. m_pMenuBar = NULL;
  1958. }
  1959. //******************************************************************
  1960. BOOL CMDIClientHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  1961. {
  1962. ASSERT_VALID(pMenuBar);
  1963. ASSERT(m_pMenuBar == NULL);
  1964. m_pMenuBar = pMenuBar;
  1965. return HookWindow(hWndToHook);
  1966. }
  1967. //******************************************************************
  1968. CMDIClientHook::~CMDIClientHook()
  1969. {
  1970. }
  1971. //******************************************************************
  1972. LRESULT CMDIClientHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  1973. {
  1974. ASSERT_VALID(m_pMenuBar);
  1976. switch (nMsg) {
  1977. case WM_MDISETMENU: // only sent to MDI client window
  1978. // Setting new frame/window menu: bypass MDI. wParam is new menu.
  1979. if (wParam) {
  1980. //LTRACE(_T("CMenuBar::WM_MDISETMENU 0x%04xn"), wParam);
  1981. m_pMenuBar->OnSetMenu((HMENU)wParam, (HMENU)lParam);
  1982. }
  1983. return 0;
  1985. case WM_MDIREFRESHMENU: // only sent to MDI client window
  1986. // Normally, would call DrawMenuBar, but I have the menu, so eat it.
  1987. //LTRACE(_T("CMenuBar::WM_MDIREFRESHMENUn"));
  1988. return 0;
  1990. }
  1992. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  1993. }
  1994. //******************************************************************
  1995. /////////////////////////////////////////////////////////////////////////////
  1996. // CMainFrameHook 
  1997. CMainFrameHook::CMainFrameHook()
  1998. {
  1999. m_pMenuBar = NULL;
  2000. }
  2002. //******************************************************************
  2003. BOOL CMainFrameHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  2004. {
  2005. ASSERT_VALID(pMenuBar);
  2006. ASSERT(m_pMenuBar == NULL);
  2007. m_pMenuBar = pMenuBar;
  2008. return HookWindow(hWndToHook);
  2009. }
  2011. //******************************************************************
  2012. CMainFrameHook::~CMainFrameHook()
  2013. {
  2014. }
  2016. //******************************************************************
  2017. LRESULT CMainFrameHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  2018. {
  2019. ASSERT_VALID(m_pMenuBar);
  2020. // be care for other windows(MainFrame) hooking
  2021. // possible called when already this wnd destroyed (WM_NCACTIVATE is)
  2022. if (!::IsWindow(m_pMenuBar->m_hWnd)) {
  2023. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  2024. }
  2026. BOOL bSend = FALSE;
  2027. if (HWND hWndServer = m_pMenuBar->OleMenuDescriptor(bSend, nMsg, wParam, lParam)) {
  2028. // OLE wnd will handle message
  2029. if (bSend)
  2030. return ::SendMessage(hWndServer, nMsg, wParam, lParam);
  2031. else
  2032. return ::PostMessage(hWndServer, nMsg, wParam, lParam);
  2033. }
  2035. switch (nMsg) {
  2036. case WM_MENUSELECT:
  2037. m_pMenuBar->OnMenuSelect((HMENU)lParam, (UINT)LOWORD(wParam));
  2038. break;
  2040. case WM_INITMENUPOPUP:
  2041. if (!HIWORD(lParam) && (HMENU)wParam == m_pMenuBar->m_hWindowMenu)
  2042. m_pMenuBar->OnInitMenuPopup(CMenu::FromHandle((HMENU)wParam),
  2043. LOWORD(lParam), (BOOL)HIWORD(lParam));
  2044. break;
  2046. case WM_NCACTIVATE:
  2047. m_pMenuBar->OnFrameNcActivate((BOOL)wParam);
  2048. break;
  2050. case WM_SYSCOLORCHANGE:
  2051. case WM_SETTINGCHANGE:
  2052. LTRACE(_T("CMenuBar::WM_SETTINGCHANGEn"));
  2053. // It's enough to reinitialize common resources once.
  2054. m_pMenuBar->OnSettingChange(wParam, lParam);
  2055. break;
  2056. }
  2058. if (nMsg == CMenuBar::WM_GETMENU)
  2059. return (LRESULT)m_pMenuBar->m_hMenu;
  2061. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  2062. }
  2064. //******************************************************************
  2065. //////////////////////////////////////////////////////////////////////
  2066. // CMenuItem interface
  2067. CMenuItem::CMenuItem()
  2068. {
  2069. m_fsStyle = 0;
  2070. m_fsState = 0;
  2071. m_rcItem.SetRectEmpty();
  2072. m_sizeHorz = CSize(0, 0);
  2073. m_cAccessKey = 0;
  2074. }
  2075. //******************************************************************
  2076. void CMenuItem::ModifyState(BYTE fsRemove, BYTE fsAdd)
  2077. {
  2078. m_fsState = (m_fsState & ~fsRemove) | fsAdd;
  2079. }
  2081. //******************************************************************
  2082. CSize CMenuItem::GetHorizontalSize() const
  2083. {
  2084. if (m_fsState & MISTATE_HIDDEN)
  2085. return CSize(0, 0);
  2086. else
  2087. return m_sizeHorz;
  2088. }
  2090. //******************************************************************
  2091. //////////////////////////////////////////////////////////////////////
  2092. // CMenuButton class
  2093. CMenuButton::CMenuButton(HMENU hMenu, int nIndex)
  2094. {
  2095. ASSERT(::IsMenu(hMenu));
  2096. ASSERT(nIndex >= 0);
  2098. m_fsStyle |= (MISTYLE_TRACKABLE | MISTYLE_WRAPPABLE);
  2099. InitButtonStringAndSubMenuHandle(hMenu, nIndex);
  2100. InitHorizontalButtonSize();
  2101. InitAccessKeyAndVerticalLinePoint();
  2102. }
  2104. //******************************************************************
  2105. void CMenuButton::InitButtonStringAndSubMenuHandle(HMENU hMenu, int nIndex)
  2106. {
  2107. // get menu button Text
  2108. TCHAR szText[256];
  2109. MENUITEMINFO info; ::memset(&info, 0, sizeof(MENUITEMINFO));
  2110. info.cbSize = sizeof(MENUITEMINFO);
  2111. info.fMask = MIIM_ID | MIIM_TYPE;
  2112. info.dwTypeData = szText;
  2113. info.cch = sizeof(szText);
  2114. ::GetMenuItemInfo(hMenu, nIndex, TRUE, &info);
  2115. m_strBtn = CString(szText);
  2117. m_hSubMenu = ::GetSubMenu(hMenu, nIndex);
  2118. if (!m_hSubMenu) {
  2119. m_nID = ::GetMenuItemID(hMenu, nIndex);
  2120. ASSERT(m_nID != -1);
  2121. }
  2122. else {
  2123. m_nID = -1;
  2124. }
  2125. }
  2127. //******************************************************************
  2128. void CMenuButton::InitHorizontalButtonSize()
  2129. {
  2130. // get menu button Text size
  2131. ASSERT(m_strBtn.IsEmpty() == FALSE);
  2132. m_sizeHorz.cx = (_CalcTextWidth(m_strBtn) + CXTEXTMARGIN*2)+5;
  2133. m_sizeHorz.cy = (_cyHorzFont + _cyTextMargin*2)+1;
  2134. }
  2136. //******************************************************************
  2137. void CMenuButton::InitAccessKeyAndVerticalLinePoint()
  2138. {
  2139. int nIndex = m_strBtn.Find('&');
  2140. if (nIndex + 1 == m_strBtn.GetLength()) {
  2141. TRACE(_T("warning : & is bad position, access key is invalid.n"));
  2142. m_cAccessKey = 0;
  2143. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2144. return;
  2145. }
  2147. m_cAccessKey = m_strBtn[nIndex + 1];// -1 + 1 = 0; it's ok
  2149. if (nIndex == -1) {
  2150. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2151. }
  2152. else if (nIndex == 0) {
  2153. m_ptLineFrom = CPoint(_cyTextMargin, CXTEXTMARGIN);
  2154. m_ptLineTo  = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex+2)));
  2155. }
  2156. else {
  2157. m_ptLineFrom = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex)));
  2158. m_ptLineTo = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex+2)));
  2159. }
  2160. }
  2162. //******************************************************************
  2163. void CMenuButton::Layout(CPoint point, BOOL bHorz)
  2164. {
  2165. if (bHorz)
  2166. m_fsState |= MISTATE_HORZ;
  2167. else
  2168. m_fsState &= ~MISTATE_HORZ;
  2170. if (m_fsState & MISTATE_HIDDEN) {
  2171. m_rcItem.SetRectEmpty();
  2172. return;
  2173. }
  2175. if (bHorz) {
  2176. m_rcItem = CRect(point, m_sizeHorz);
  2177. }
  2178. else {
  2179. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  2180. }
  2181. }
  2183. //******************************************************************
  2184. void CMenuButton::Update(CDC* pDC)
  2185. {
  2186. if (m_fsState & MISTATE_HIDDEN)
  2187. return;
  2189. // clean background
  2190. COLORREF clr = ::GetSysColor(COLOR_BTNFACE);
  2191. pDC->FillSolidRect(m_rcItem, clr);
  2193. if (m_fsState & MISTATE_HOT){
  2194. DrawHot(pDC);
  2195. }
  2196. else if (m_fsState & MISTATE_PRESSED){
  2197. DrawPressed(pDC);
  2198. }
  2199. else {
  2200. DrawNone(pDC);
  2201. }
  2202. }
  2204. //*********************************************************
  2205. void CMenuButton::TrackPopup(CWnd* pBar, CWnd* pWndSentCmd)
  2206. {
  2207. LTRACE(_T("CMenuButton::TrackPopupn"));
  2208. ASSERT_VALID(pBar);
  2209. ASSERT(!(m_fsState & MISTATE_HIDDEN));
  2210. pMenuBar = STATIC_DOWNCAST(CMenuBar, pBar);
  2211. ASSERT_VALID(pMenuBar);
  2213. // "! menu" (no sub menu)
  2214. if (!m_hSubMenu) {
  2215. ASSERT(m_nID != -1);
  2216. pWndSentCmd->SendMessage(WM_COMMAND, (WPARAM)m_nID, (LPARAM)pBar->GetSafeHwnd());
  2217. return;
  2218. }
  2220. CRect rcItem(m_rcItem); pMenuBar->ClientToScreen(rcItem);
  2221. UINT fuFlags; TPMPARAMS tpm;
  2222. CPoint pt = _ComputeMenuTrackPoint(rcItem, pMenuBar->GetBarStyle(), fuFlags, tpm);
  2224. if (m_hSubMenu == pMenuBar->m_hWindowMenu)
  2225. _bWindowMenuSendCmd = TRUE;
  2226. else
  2227. _bWindowMenuSendCmd = FALSE;
  2229. if (pMenuBar->GetBarStyle() & CBRS_ORIENT_HORZ)
  2230. {
  2231. pt.x+=1; pt.y-=2;
  2232. }
  2233. else
  2234. {
  2235. pt.x-=2; pt.y+=2;
  2236. }
  2237. ::TrackPopupMenuEx(m_hSubMenu, fuFlags,
  2238. pt.x, pt.y, pWndSentCmd->GetSafeHwnd(), &tpm);
  2240. }
  2242. //******************************************************************
  2243. void CMenuButton::DrawHorzText(CDC* pDC, CPoint ptOffset)
  2244. {
  2245. COLORREF clr = (m_fsState & MISTATE_INACTIVE) ? 
  2246. ::GetSysColor(COLOR_GRAYTEXT) : ::GetSysColor(COLOR_MENUTEXT);
  2247. pDC->SetTextColor(clr);
  2249. CRect rcBtn = m_rcItem;
  2250. pDC->SetBkMode(TRANSPARENT);
  2251. CFont* pOldFont = pDC->SelectObject(&_fontHorzMenu);
  2252. // I know precise text size, but better to leave this job to Windows
  2253. // *****fixed by andi, thanks!*****
  2254. pDC->DrawText(m_strBtn, rcBtn + ptOffset,
  2255. DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  2256. pDC->SelectObject(pOldFont);
  2257. gbintHorz=0;
  2258. rcMenu=rcBtn;
  2259. rcMenu.right-=4;
  2261. }
  2263. //******************************************************************
  2264. void CMenuButton::DrawVertText(CDC* pDC, CPoint ptOffset)
  2265. {
  2266. COLORREF clr = (m_fsState & MISTATE_INACTIVE) ? 
  2267. ::GetSysColor(COLOR_GRAYTEXT) : ::GetSysColor(COLOR_MENUTEXT);
  2268. pDC->SetTextColor(clr);
  2270. CRect rcBtn = m_rcItem;
  2271. int nLength = m_strBtn.GetLength();
  2272. int nIndex = m_strBtn.Find('&');
  2273. CString strBtn = m_strBtn.Left(nIndex) + m_strBtn.Right(nLength - (nIndex+1));
  2275. // fixed for WinNT. *****fixed by Simon, thanks!*****
  2276. int iGraphicsMode = ::GetGraphicsMode(pDC->m_hDC);
  2277. ::SetGraphicsMode(pDC->m_hDC, GM_ADVANCED);
  2279. pDC->SetBkMode(TRANSPARENT);
  2280. CFont* pOldFont = pDC->SelectObject(&_fontVertMenu);
  2281. // I know precise text size
  2282. CRect rcString = CRect(
  2283. CPoint(rcBtn.right - _cyTextMargin, rcBtn.top + CXTEXTMARGIN), m_sizeHorz);
  2284. pDC->DrawText(strBtn, rcString + ptOffset,
  2285. DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX);// don't forget DT_NOCLIP
  2286. gbintHorz=1;
  2287. rcMenu=rcBtn;
  2288. rcMenu.bottom-=3;
  2289. pDC->SelectObject(pOldFont);
  2291. // CDC::DrawText is poor, so we have to draw vertical line by ourselves
  2292. CPen pen(PS_SOLID, 0, clr);
  2293. CPen* pOldPen = pDC->SelectObject(&pen);
  2295. pDC->MoveTo(rcBtn.TopLeft() + m_ptLineFrom + ptOffset);
  2296. pDC->LineTo(rcBtn.TopLeft() + m_ptLineTo + ptOffset);
  2298. pDC->SelectObject(pOldPen);
  2299. ::SetGraphicsMode( pDC->m_hDC, iGraphicsMode );
  2300. }
  2302. //******************************************************************
  2303. void CMenuButton::DrawButton(CDC* pDC,WORD wState)
  2304. {
  2307. /* ASSERT(m_strBtn.IsEmpty() == FALSE);
  2308. m_sizeHorz.cx = (_CalcTextWidth(m_strBtn) + CXTEXTMARGIN*2)+5;
  2309. m_sizeHorz.cy = (_cyHorzFont + _cyTextMargin*2)+1;
  2310. */
  2311. CBrush cblu;
  2312. CRect rcBtn =m_rcItem;
  2313. if (dSt & CBRS_ORIENT_HORZ )
  2314. rcBtn.right-=4;
  2315. else
  2316. rcBtn.bottom-=2;
  2318. if (wState & BDR_RAISEDINNER)
  2319. pDC->Draw3dRect(rcBtn,m_dw.GetRGBCaptionXP(),m_dw.GetRGBCaptionXP());
  2320. else
  2321. {
  2322. if (dSt & CBRS_ORIENT_HORZ )
  2323. rcBtn.bottom+=1;
  2324. else
  2325. rcBtn.bottom-=1;
  2326. pDC->Draw3dRect(rcBtn,GuiDrawLayer::GetRGBColorShadow(),GuiDrawLayer::GetRGBColorShadow());
  2328. if (dSt & CBRS_ORIENT_HORZ )
  2329. rcBtn.bottom-=1;
  2330. else
  2331. rcBtn.bottom+=1;
  2332. CPen pen(PS_SOLID, 0, GuiDrawLayer::GetRGBColorFace());
  2333. CPen* pOldPen = pDC->SelectObject(&pen);
  2334. pDC->MoveTo(rcBtn.left, rcBtn.bottom);
  2335. pDC->LineTo(rcBtn.right, rcBtn.bottom);
  2336. COLORREF ColA = GetSysColor(COLOR_WINDOW);
  2337. COLORREF ColB = GuiDrawLayer::GetRGBColorFace();
  2338. CRect rect = rcBtn;
  2339. int X,Y;
  2340. X=Y=0;
  2341. int winH = rect.Height(); 
  2342. int winW = rect.Width();
  2343. if (dSt & CBRS_ORIENT_HORZ )
  2344. { 
  2346. rect.right+=4;
  2347. // Simulate a shadow on right edge... 
  2348. for (X=1; X<=4 ;X++)
  2349. { 
  2350.   for (Y=0; Y<4 ;Y++)
  2351. pDC->SetPixel(rect.right-X,Y+rect.top, ColB );
  2352.   for (Y=4; Y<8 ;Y++)
  2353.   pDC->SetPixel(rect.right-X,Y+rect.top,GuiDrawLayer::DarkenColor(3 * X * (Y - 3), ColB)) ;
  2354.   for (Y=8; Y<=(winH-1) ;Y++)
  2355. pDC->SetPixel(rect.right - X, Y+rect.top, GuiDrawLayer::DarkenColor(15 * X, ColB) );
  2356. }
  2357. }
  2358. else
  2359. {
  2360.   rect.bottom+=2;
  2361.   for(Y=1; Y<=3 ;Y++)
  2362.   {
  2363. for(X=0; X<=3 ;X++)
  2364. {
  2365.   pDC->SetPixel(X,rect.bottom-Y,pDC->GetPixel(rect.left+X,rect.bottom-Y)) ;
  2366. }
  2367. for(X=4; X<=7 ;X++)
  2368. {
  2369.   COLORREF c = pDC->GetPixel(rect.left + X, rect.bottom - Y) ;
  2370.   pDC->SetPixel(X, rect.bottom - Y, GuiDrawLayer::DarkenColor(3 * (X - 3) * Y, c)) ;
  2371. }
  2372. for(X=8; X<=(winW-2) ;X++)
  2373. {
  2374.   COLORREF  c = pDC->GetPixel(rect.left + X, rect.bottom - Y); 
  2375.   pDC->SetPixel(X, rect.bottom- Y, GuiDrawLayer::DarkenColor(15 * Y, c)) ;
  2376. }
  2377.   }   
  2378.   
  2380. }
  2381. pDC->SelectObject(pOldPen);
  2383. }
  2384. rcBtn.DeflateRect(1,1);
  2385. if (wState & BDR_RAISEDINNER)
  2386. {
  2388. cblu.CreateSolidBrush(m_dw.GetRGBFondoXP());
  2389. pDC->FillRect(rcBtn,&cblu);
  2390. }
  2392. }
  2393. //******************************************************************
  2394. void CMenuButton::DrawHot(CDC* pDC)
  2395. {
  2396. if (m_fsState & MISTATE_HORZ) {
  2398. // draw pressed button
  2399. dSt=CBRS_ORIENT_HORZ;
  2400. DrawButton(pDC,BDR_RAISEDINNER);
  2401. //pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2402. DrawHorzText(pDC);
  2403. }
  2404. else {
  2405. dSt=CBRS_ORIENT_VERT;
  2406. DrawButton(pDC,BDR_RAISEDINNER);
  2407. //pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2408. DrawVertText(pDC);
  2409. }
  2410. }
  2412. //******************************************************************
  2413. void CMenuButton::DrawPressed(CDC* pDC)
  2414. {
  2415. if (m_fsState & MISTATE_HORZ) {
  2416. DrawButton(pDC,BDR_SUNKENOUTER);
  2417. //pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);// draw pressed button
  2418. DrawHorzText(pDC, CPoint(1, 1));
  2419. }
  2420. else {
  2421. DrawButton(pDC,BDR_SUNKENOUTER);
  2422. //pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2423. DrawVertText(pDC, CPoint(1, 1));
  2424. }
  2425. }
  2427. //******************************************************************
  2428. void CMenuButton::DrawNone(CDC* pDC)
  2429. {
  2430. if (m_fsState & MISTATE_HORZ) {
  2431. DrawHorzText(pDC);
  2432. }
  2433. else {
  2434. DrawVertText(pDC);
  2435. }
  2437. }
  2439. //******************************************************************
  2440. //////////////////////////////////////////////////////////////////////
  2441. // CMenuIcon class
  2442. CMenuIcon::CMenuIcon(CWnd* pMenuBar)
  2443. {
  2444. ASSERT_VALID(pMenuBar);
  2445. m_pMenuBar = pMenuBar;
  2446. m_hIconWinLogo = AfxGetApp()->LoadStandardIcon(IDI_WINLOGO);
  2447. ASSERT(m_hIconWinLogo);
  2449. m_fsStyle |= MISTYLE_TRACKABLE;
  2450. m_fsState |= MISTATE_HIDDEN;
  2451. m_sizeHorz = CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON));
  2452. }
  2453. //******************************************************************
  2454. CMenuIcon::~CMenuIcon()
  2455. {
  2456. if (m_hIconWinLogo != NULL)
  2457. ::FreeResource(m_hIconWinLogo);
  2458. }
  2459. //******************************************************************
  2460. void CMenuIcon::OnActivateChildWnd()
  2461. {
  2462. //LTRACE(_T("CMenuIcon::OnActivateChildWndn"));
  2464. ASSERT_VALID(m_pMenuBar);
  2466. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2467. ASSERT_VALID(pFrame);
  2468. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2469. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2470. ASSERT(::IsWindow(hWndMDIClient));
  2472. BOOL bMaximized = FALSE;
  2473. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2474. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2476. if (bMaximized == FALSE) {
  2477. //LTRACE(_T("    not maximizedn"));
  2478. m_fsState |= MISTATE_HIDDEN;
  2479. }
  2480. else {
  2481. //LTRACE(_T("    maximizedn"));
  2482. m_fsState &= ~MISTATE_HIDDEN;
  2483. }
  2485. m_hDocIcon = (HICON)::GetClassLong(hWndChild, GCL_HICONSM);
  2487. if (m_hDocIcon == NULL) // if hWndChild doesn't have own icon
  2488. m_hDocIcon = m_hIconWinLogo;
  2489. }
  2491. //******************************************************************
  2492. void CMenuIcon::Update(CDC* pDC)
  2493. {
  2494. if (m_fsState & MISTATE_HIDDEN)
  2495. return;
  2497. ASSERT(m_hDocIcon);
  2498. ASSERT(m_rcItem.IsRectEmpty() == FALSE);
  2499. ::DrawIconEx(pDC->m_hDC, m_rcItem.left, m_rcItem.top, m_hDocIcon,
  2500. m_rcItem.Width(), m_rcItem.Height(), 0, NULL, DI_NORMAL);
  2501. }
  2503. //******************************************************************
  2504. void CMenuIcon::TrackPopup(CWnd* pBar, CWnd* pWndSentCmd)
  2505. {
  2506. ASSERT(!(m_fsState & MISTATE_HIDDEN));
  2507. ASSERT_VALID(m_pMenuBar);
  2509. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2510. ASSERT_VALID(pFrame);
  2511. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2512. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2513. ASSERT(::IsWindow(hWndMDIClient));
  2515. BOOL bMaximized = FALSE;
  2516. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2517. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2518. ASSERT(bMaximized);
  2519. HMENU hSysMenu = ::GetSystemMenu(hWndChild, FALSE);
  2520. ASSERT(::IsMenu(hSysMenu));
  2521. CControlBar* pControlBar = STATIC_DOWNCAST(CControlBar, m_pMenuBar);
  2522. ASSERT_VALID(pControlBar);
  2523. CRect rcItem(m_rcItem); m_pMenuBar->ClientToScreen(rcItem);
  2525. UINT fuFlags; TPMPARAMS tpm;
  2526. CPoint pt = _ComputeMenuTrackPoint(rcItem, pControlBar->GetBarStyle(), fuFlags, tpm);
  2527. ::TrackPopupMenuEx(hSysMenu, fuFlags, pt.x, pt.y,pBar->GetSafeHwnd(), &tpm);
  2529. }
  2531. //******************************************************************
  2532. void CMenuIcon::Layout(CPoint point, BOOL bHorz)
  2533. {
  2534. if (bHorz)
  2535. m_fsState |= MISTATE_HORZ;
  2536. else
  2537. m_fsState &= ~MISTATE_HORZ;
  2539. if (m_fsState & MISTATE_HIDDEN) {
  2540. m_rcItem.SetRectEmpty();
  2541. return;
  2542. }
  2544. m_rcItem = CRect(point, CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON)));
  2545. }
  2547. //******************************************************************
  2548. //////////////////////////////////////////////////////////////////////
  2549. // CMenuControl class
  2550. #define CX_GAP_CAPTION 2
  2553. CMenuControl::CMenuControl(CWnd* pMenuBar)
  2554. {
  2555. ASSERT_VALID(pMenuBar);
  2556. m_pMenuBar = pMenuBar;
  2557. m_bDown = FALSE;
  2558. m_nTracking = -1;
  2560. m_fsState |= MISTATE_HIDDEN;
  2562. if (!m_img.Create(IDB_MDIICONS,9,3,RGB(255,0,255)))
  2563. {
  2564. TRACE0("error");
  2565. }
  2566. m_arrButton[2].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2567. CRect(0,0,0,0),m_pMenuBar, SC_CLOSE);
  2568. m_arrButton[2].SethIcon(m_img.ExtractIcon(2));
  2569. m_arrButton[2].SetToolTip("Close");
  2570. m_arrButton[2].SetColor(GuiDrawLayer::GetRGBColorFace());
  2571. m_arrButton[2].ShowDark(FALSE);
  2572. m_arrButton[1].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2573. CRect(0,0,0,0),m_pMenuBar, SC_RESTORE);
  2574. m_arrButton[1].SethIcon(m_img.ExtractIcon(1));
  2575. m_arrButton[1].SetToolTip("Restore");
  2576. m_arrButton[1].SetColor(GuiDrawLayer::GetRGBColorFace());
  2577. m_arrButton[1].ShowDark(FALSE);
  2578. m_arrButton[0].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2579. CRect(0,0,0,0),m_pMenuBar,SC_MINIMIZE);
  2580. m_arrButton[0].SethIcon(m_img.ExtractIcon(0));
  2581. m_arrButton[0].SetToolTip("Minimize");
  2582. m_arrButton[0].SetColor(GuiDrawLayer::GetRGBColorFace());
  2583. m_arrButton[0].ShowDark(FALSE);
  2585. CSize sizeCaption = GetCaptionSize();
  2586. m_sizeHorz = CSize(sizeCaption.cx*3 + CX_GAP_CAPTION + 1, sizeCaption.cy + 2);
  2588. }
  2590. //******************************************************************
  2591. void CMenuControl::Update(CDC* pDC)
  2592. {
  2593. // do nothing
  2594. }
  2596. //******************************************************************
  2597. void CMenuControl::Layout(CPoint point, BOOL bHorz)
  2598. {
  2599. //LTRACE(_T("CMenuControl::Layout bHorz:%dn"), bHorz);
  2601. if (bHorz)
  2602. m_fsState |= MISTATE_HORZ;
  2603. else
  2604. m_fsState &= ~MISTATE_HORZ;
  2606. if (m_fsState & MISTATE_HIDDEN) {
  2607. m_rcItem.SetRectEmpty();
  2608. return;
  2609. }
  2611. // just layout easily
  2612. if (bHorz) {
  2613. m_rcItem = CRect(point, m_sizeHorz);
  2614. }
  2615. else {
  2616. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  2617. }
  2618. }
  2620. //******************************************************************
  2621. void CMenuControl::DelayLayoutAndDraw(CDC* pDC, CSize sizeBar,BOOL bFlota)
  2622. {
  2623. CSize sizeCaption = GetCaptionSize();
  2624. int cxCaption = sizeCaption.cx;
  2625. int cyCaption = sizeCaption.cy;
  2627. if (m_fsState & MISTATE_HORZ) {
  2628. CRect rcCaption;
  2629. rcCaption.right = !bFlota?sizeBar.cx-5:sizeBar.cx;
  2630. rcCaption.bottom = sizeBar.cy-3;
  2631. rcCaption.left = rcCaption.right - cxCaption;
  2632. rcCaption.top = (rcCaption.bottom - cyCaption);
  2634. m_arrCaption[0] = rcCaption;
  2636. rcCaption -= CPoint(cxCaption+CX_GAP_CAPTION, 0);
  2637. m_arrCaption[1] = rcCaption;
  2639. rcCaption -= CPoint(cxCaption, 0);
  2640. m_arrCaption[2] = rcCaption;
  2642. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  2643. m_arrCaption[0].right, m_arrCaption[0].bottom);
  2644. }
  2645. else {
  2646. CRect rcCaption;
  2647. rcCaption.left = 0;
  2648. rcCaption.bottom = sizeBar.cy-5;
  2649. rcCaption.right = rcCaption.left + cxCaption;
  2650. rcCaption.top = rcCaption.bottom - cyCaption;
  2652. m_arrCaption[0] = rcCaption;
  2654. rcCaption -= CPoint(0, cyCaption+CX_GAP_CAPTION);
  2655. m_arrCaption[1] = rcCaption;
  2657. rcCaption -= CPoint(0, cyCaption);
  2658. m_arrCaption[2] = rcCaption;
  2660. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  2661. m_arrCaption[0].right, m_arrCaption[0].bottom);
  2662. }
  2664. if (m_fsState & MISTATE_HIDDEN) {
  2665. //LTRACE(_T("    hiddenn"));
  2666. return;
  2667. }
  2670. // draw frame controls
  2671. DrawControl();
  2673. }
  2675. //******************************************************************
  2678. //******************************************************************
  2679. void CMenuControl::DrawControl()
  2680. {
  2681. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2682. ASSERT_VALID(pFrame);
  2683. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2684. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2685. ASSERT(::IsWindow(hWndMDIClient));
  2686. BOOL bMaximized = FALSE;
  2687. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2688. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2690. if (bMaximized == TRUE) {
  2691. m_arrButton[2].MoveWindow(m_arrCaption[0]);
  2692. m_arrButton[1].MoveWindow(m_arrCaption[1]);
  2693. m_arrButton[0].MoveWindow(m_arrCaption[2]);
  2694. }
  2695. }
  2697. //******************************************************************
  2700. //******************************************************************
  2701. void CMenuControl::OnActivateChildWnd()
  2702. {
  2703. //LTRACE(_T("CMenuControl::OnActivateChildWndn"));
  2704. ASSERT_VALID(m_pMenuBar);
  2706. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2707. ASSERT_VALID(pFrame);
  2708. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2709. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2710. ASSERT(::IsWindow(hWndMDIClient));
  2712. BOOL bMaximized = FALSE;
  2713. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2714. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2716. if (bMaximized == FALSE) {
  2717. m_fsState |= MISTATE_HIDDEN;
  2718. }
  2719. else {
  2720. m_fsState &= ~MISTATE_HIDDEN;
  2721. }
  2722. }
  2726. //******************************************************************
  2727. CSize CMenuControl::GetCaptionSize()
  2728. {
  2729. NONCLIENTMETRICS info; info.cbSize = sizeof(info);
  2730. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  2732. // due to my own feeling
  2733. return CSize(info.iMenuHeight - info.iBorderWidth*2, info.iMenuHeight - info.iBorderWidth*4);
  2734. }
  2736. //******************************************************************
  2737. #if _MFC_VER < 0x0600
  2738. void CMenuBar::SetBorders(int cxLeft, int cyTop, int cxRight, int cyBottom)
  2739. {
  2740. ASSERT(cxLeft >= 0);
  2741. ASSERT(cyTop >= 0);
  2742. ASSERT(cxRight >= 0);
  2743. ASSERT(cyBottom >= 0);
  2745. m_cxLeftBorder = cxLeft;
  2746. m_cyTopBorder = cyTop;
  2747. m_cxRightBorder = cxRight;
  2748. m_cyBottomBorder = cyBottom;
  2749. }
  2750. #endif
  2751. //******************************************************************
  2752. // input CRect should be client rectangle size
  2753. void CMenuBar::_CalcInsideRect(CRect& rect, BOOL bHorz) const
  2754. {
  2755. LTRACE(_T("CMenuBar::_CalcInsideRectn"));
  2756. ASSERT_VALID(this);
  2757. DWORD dwStyle = m_dwStyle;
  2759. if (dwStyle & CBRS_BORDER_LEFT)
  2760. rect.left += cxBorder2;
  2761. if (dwStyle & CBRS_BORDER_TOP)
  2762. rect.top += cyBorder2;
  2763. if (dwStyle & CBRS_BORDER_RIGHT)
  2764. rect.right -= cxBorder2;
  2765. if (dwStyle & CBRS_BORDER_BOTTOM)
  2766. rect.bottom -= cyBorder2;
  2768. BOOL bDrawGripper = !(m_dwStyle & CBRS_FLOATING) && (m_dwExStyle & CBRS_GRIPPER);
  2770. // inset the top and bottom.
  2771. if (bHorz)
  2772. {
  2773. rect.left += m_cxLeftBorder;
  2774. rect.top += m_cyTopBorder;
  2775. rect.right -= m_cxRightBorder;
  2776. rect.bottom -= m_cyBottomBorder;
  2777. if (bDrawGripper)
  2778. rect.left += CX_GRIPPER_ALL;
  2779. }
  2780. else
  2781. {
  2782. rect.left += m_cyTopBorder;
  2783. rect.top += m_cxLeftBorder;
  2784. rect.right -= m_cyBottomBorder;
  2785. rect.bottom -= m_cxRightBorder;
  2786. if (bDrawGripper)
  2787. rect.top += CY_GRIPPER_ALL;
  2788. }
  2789. }
  2791. //******************************************************************
  2792. /////////////////////////////////////////////////////////////////////////////
  2793. // CMenuDockBar implementation
  2794. // a little changed from CDockBar implementation
  2796. static BOOL _IsMenuBar(int nPos, CPtrArray& arrBars)
  2797. {
  2798. if (nPos < arrBars.GetSize()) {
  2799. CControlBar* pBar = (CControlBar*)arrBars[nPos];
  2800. if (pBar && pBar->GetDlgCtrlID() == AFX_IDW_MENUBAR)
  2801. return TRUE;
  2802. else
  2803. return FALSE;
  2804. }
  2805. else
  2806. return FALSE;
  2807. }
  2809. //******************************************************************
  2810. CSize CMenuDockBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  2811. {
  2812. LTRACE(_T("CMenuDockBar::CalcFixedLayoutn"));
  2813. ASSERT_VALID(this);
  2815. CSize sizeFixed = CControlBar::CalcFixedLayout(bStretch, bHorz);
  2817. // get max size
  2818. CSize sizeMax;
  2819. if (!m_rectLayout.IsRectEmpty())
  2820. sizeMax = m_rectLayout.Size();
  2821. else
  2822. {
  2823. CRect rectFrame;
  2824. CFrameWnd* pFrame = GetParentFrame();
  2825. pFrame->GetClientRect(&rectFrame);
  2826. sizeMax = rectFrame.Size();
  2827. }
  2829. // prepare for layout
  2830. AFX_SIZEPARENTPARAMS layout;
  2831. layout.hDWP = m_bLayoutQuery ?
  2832. NULL : ::BeginDeferWindowPos(m_arrBars.GetSize());
  2833. CPoint pt(-cxBorder2, -cyBorder2);
  2834. int nWidth = 0;
  2836. BOOL bWrapped = FALSE;
  2838. // layout all the control bars
  2839. for (int nPos = 0; nPos < m_arrBars.GetSize(); nPos++)
  2840. {
  2841. CControlBar* pBar = GetDockedControlBar(nPos);
  2842. void* pVoid = m_arrBars[nPos];
  2844. if (pBar != NULL)// pBar is valid
  2845. {
  2846. if (pBar->IsVisible())// visible
  2847. {
  2848. // get ideal rect for bar
  2849. DWORD dwMode = 0;
  2850. if ((pBar->m_dwStyle & CBRS_SIZE_DYNAMIC) &&
  2851. (pBar->m_dwStyle & CBRS_FLOATING))
  2852. dwMode |= LM_HORZ | LM_MRUWIDTH;
  2853. else if (pBar->m_dwStyle & CBRS_ORIENT_HORZ)
  2854. dwMode |= LM_HORZ | LM_HORZDOCK;
  2855. else
  2856. dwMode |=  LM_VERTDOCK;
  2858. CSize sizeBar = pBar->CalcDynamicLayout(-1, dwMode);
  2860. CRect rect(pt, sizeBar);
  2862. // get current rect for bar
  2863. CRect rectBar;
  2864. pBar->GetWindowRect(&rectBar);
  2865. ScreenToClient(&rectBar);
  2867. if (bHorz)// horizontal
  2868. {
  2869. // Offset Calculated Rect out to Actual
  2870. if (rectBar.left > rect.left && !m_bFloating)
  2871. rect.OffsetRect(rectBar.left - rect.left, 0);
  2873. // If ControlBar goes off the right, then right justify
  2874. if (rect.right > sizeMax.cx && !m_bFloating)
  2875. {
  2876. int x = rect.Width() - cxBorder2;
  2877. x = max(sizeMax.cx - x, pt.x);
  2878. rect.OffsetRect(x - rect.left, 0);
  2879. }
  2881. // If ControlBar has been wrapped, then left justify
  2882. if (bWrapped)
  2883. {
  2884. bWrapped = FALSE;
  2885. rect.OffsetRect(-(rect.left + cxBorder2), 0);
  2886. }
  2887. // If ControlBar is completely invisible, then wrap it
  2888. else if ((rect.left >= (sizeMax.cx - cxBorder2) || _IsMenuBar(nPos, m_arrBars))
  2889. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2890. {
  2891. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2892. pBar = NULL; pVoid = NULL;
  2893. bWrapped = TRUE;
  2894. }
  2895. if (!bWrapped)
  2896. {
  2897. if (rect != rectBar)
  2898. {
  2899. if (!m_bLayoutQuery &&
  2900. !(pBar->m_dwStyle & CBRS_FLOATING))
  2901. {
  2902. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2903. }
  2904. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2905. }
  2906. pt.x = rect.left + sizeBar.cx - cxBorder2;
  2907. nWidth = max(nWidth, sizeBar.cy);
  2908. }
  2909. }
  2910. else // vertical
  2911. {
  2912. // Offset Calculated Rect out to Actual
  2913. if (rectBar.top > rect.top && !m_bFloating)
  2914. rect.OffsetRect(0, rectBar.top - rect.top);
  2916. // If ControlBar goes off the bottom, then bottom justify
  2917. if (rect.bottom > sizeMax.cy && !m_bFloating)
  2918. {
  2919. int y = rect.Height() - cyBorder2;
  2920. y = max(sizeMax.cy - y, pt.y);
  2921. rect.OffsetRect(0, y - rect.top);
  2922. }
  2924. // If ControlBar has been wrapped, then top justify
  2925. if (bWrapped)
  2926. {
  2927. bWrapped = FALSE;
  2928. rect.OffsetRect(0, -(rect.top + cyBorder2));
  2929. }
  2930. // If ControlBar is completely invisible, then wrap it
  2931. else if ((rect.top >= (sizeMax.cy - cyBorder2) || _IsMenuBar(nPos, m_arrBars))
  2932. && (nPos > 0) && (m_arrBars[nPos - 1] != NULL))
  2933. {
  2934. m_arrBars.InsertAt(nPos, (CObject*)NULL);
  2935. pBar = NULL; pVoid = NULL;
  2936. bWrapped = TRUE;
  2937. }
  2939. if (!bWrapped)
  2940. {
  2941. if (rect != rectBar)
  2942. {
  2943. if (!m_bLayoutQuery &&
  2944. !(pBar->m_dwStyle & CBRS_FLOATING))
  2945. {
  2946. pBar->m_pDockContext->m_rectMRUDockPos = rect;
  2947. }
  2948. AfxRepositionWindow(&layout, pBar->m_hWnd, &rect);
  2949. }
  2950. pt.y = rect.top + sizeBar.cy - cyBorder2;
  2951. nWidth = max(nWidth, sizeBar.cx);
  2952. }
  2953. }// if vertical
  2954. }// if visible
  2955. if (!bWrapped)
  2956. {
  2957. // handle any delay/show hide for the bar
  2958. pBar->RecalcDelayShow(&layout);
  2959. }
  2960. }// if pBar is valid
  2961. if (pBar == NULL && pVoid == NULL && nWidth != 0)
  2962. {
  2963. // end of row because pBar == NULL
  2964. if (bHorz)
  2965. {
  2966. pt.y += nWidth - cyBorder2;
  2967. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2968. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2969. pt.x = -cxBorder2;
  2970. }
  2971. else
  2972. {
  2973. pt.x += nWidth - cxBorder2;
  2974. sizeFixed.cx = max(sizeFixed.cx, pt.x);
  2975. sizeFixed.cy = max(sizeFixed.cy, pt.y);
  2976. pt.y = -cyBorder2;
  2977. }
  2978. nWidth = 0;
  2979. }
  2980. }// for
  2981. if (!m_bLayoutQuery)
  2982. {
  2983. // move and resize all the windows at once!
  2984. if (layout.hDWP == NULL || !::EndDeferWindowPos(layout.hDWP))
  2985. {
  2986. TRACE0("Warning: DeferWindowPos failed - low system resources.n");
  2987. }
  2988. }
  2990. // adjust size for borders on the dock bar itself
  2991. CRect rect;
  2992. rect.SetRectEmpty();
  2993. CalcInsideRect(rect, bHorz);
  2995. if ((!bStretch || !bHorz) && sizeFixed.cx != 0)
  2996. sizeFixed.cx += -rect.right + rect.left;
  2997. if ((!bStretch || bHorz) && sizeFixed.cy != 0)
  2998. sizeFixed.cy += -rect.bottom + rect.top;
  3000. return sizeFixed;
  3001. }