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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
MenuBar.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：89k
源码类别：

对话框与窗口

开发平台：

Visual C++

MenuBar.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * *
  18.  * Bug Fixes and improvements : (Add your name) *
  19.  * -Francisco Campos *
  20.  * -igor1960 *
  21.  ****************************************************************************/
  24. //
  25. // Class :  CMenuBar
  26. // 
  27. // Version : 1.0
  28. // 
  29. // Created : Jan 14, 2001        
  30. //
  31. // Last Modified: Francisco Campos. 
  32. //
  33. // CMenuBar class version 2.12
  34. // simulates a Dev Studio style dockable menu bar.
  35. // based on PixieLib written by Paul DiLascia<www.dilascia.com>
  36. //
  37. // version history
  38. // 2.12 : support OLE menu carelessly.
  39. // 2.11 : WindowMenu fixed by VORGA.
  40. // 2.10 : CMenuDockBar's problem fixed again and again.
  41. // 2.08 : give up precise ComputeMenuTrackPoint
  42. // 2.07 : Sychronizing with frame activation problem fixed
  43. // 2.06 : CMenuItem::ComputeMenuTrackPoint fixed a little
  44. // 2.05 : CMenuDockBar fixed
  45. //  : Inactive state problem fixed
  46. // 2.04 : bug with ::TrackPopupEx carelessly fixed 
  47. //           : synchronizing TrackPopup animation with win98 effect
  48. //
  49. // written by MB <mb2@geocities.co.jp> 1999.11.27
  50. //
  51. //
  52. //
  53. // CMenuBar version 2.13
  55. #include "stdafx.h"
  56. #include "MenuBar.h"
  57. #include "resource.h"
  58. #include "GuiDockContext.h"
  59. #include <afxole.h>
  60. #include "Menubar.h"
  62. #ifdef _DEBUG
  63. #define new DEBUG_NEW
  64. #undef THIS_FILE
  65. static char THIS_FILE[] = __FILE__;
  66. #endif
  68. #ifdef _DEBUG
  69. const BOOL bTraceOn = FALSE;
  70. #define LTRACE if (bTraceOn) TRACE
  71. const BOOL bTraceOn2 = TRUE;
  72. #define LTRACE2 if (bTraceOn2) TRACE
  73. #else
  74. #define LTRACE
  75. #define LTRACE2
  76. #endif
  78. BOOL bActivSystemMenu;
  79. //////////////////////////////////////////////////////////////////////
  80. // I've found string resource of "More windows" in "user.exe".
  81. // But I can't load it, so please replace a following with your language.
  82. static const TCHAR _szMoreWindows[] = _T("&More windows...");
  84. //////////////////////////////////////////////////////////////////////
  85. // used for OLE menu (easy fix)
  86. static BOOL _bWindowMenuSendCmd = FALSE;
  87. static int _nPrevIndexForCmd = -1;
  89. //////////////////////////////////////////////////////////////////////
  90. // hook
  91. static CMenuBar* g_pMenuBar = NULL;
  92. static HHOOK  g_hMsgHook = NULL;
  94. // message
  95. const UINT CMenuBar::WM_GETMENU = ::RegisterWindowMessage(_T("CMenuBar::WM_GETMENU"));
  96. const UINT MB_SET_MENU_NULL = ::RegisterWindowMessage(_T("CMenuBar::MB_SET_MENU_NULL"));
  98. const int cxBorder2 = ::GetSystemMetrics(SM_CXBORDER)*2;
  99. const int cyBorder2 = ::GetSystemMetrics(SM_CYBORDER)*2;
  101. // common resources
  102. static CFont _fontHorzMenu, _fontVertMenu;
  103. static int _cyHorzFont, _cyMenuOnBar, _cyTextMargin;
  104. const int CXTEXTMARGIN = 5;
  106. DWORD dSt;
  107. COLORREF   m_clrFace;
  109. int gbintHorz; //Horz=0, Vert=1
  110. CRect rcMenu; //CRect of button
  111. static BOOL _InitCommonResources(BOOL bForce = FALSE)
  112. {
  113. if (bForce == FALSE && _fontHorzMenu.m_hObject != NULL)
  114. return TRUE;// no need to reinitialize
  116. // clean up
  117. _fontHorzMenu.DeleteObject();
  118. _fontVertMenu.DeleteObject();
  120. // create fonts
  121. NONCLIENTMETRICS info; info.cbSize = sizeof(info);
  122. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  123. if (!_fontHorzMenu.CreateFontIndirect(&info.lfMenuFont))
  124. return FALSE;
  126. // create vertical font
  127. info.lfMenuFont.lfEscapement = -900;
  128. info.lfMenuFont.lfOrientation = -900;
  129. strcpy(info.lfMenuFont.lfFaceName,"verdana");
  130. if (!_fontVertMenu.CreateFontIndirect(&info.lfMenuFont))
  131. return FALSE;
  133. // get font height
  134. _cyHorzFont = abs(info.lfMenuFont.lfHeight);
  136. // calc Y text margin
  137. _cyMenuOnBar = info.iMenuHeight;
  138. _cyMenuOnBar = max(_cyMenuOnBar, ::GetSystemMetrics(SM_CYSMICON));
  139. _cyTextMargin = (_cyMenuOnBar - _cyHorzFont) / 2;
  141. return TRUE;
  142. }
  144. // I wanted to control popup point, but I've fount we can never get popupmenu rect before popup.
  145. // even if not owner draw menu...
  150. static CPoint _ComputeMenuTrackPoint(const CRect& rcItem, DWORD dwStyle, UINT& fuFlags, TPMPARAMS& tpm)
  151. {
  152. fuFlags = TPM_LEFTBUTTON | TPM_LEFTALIGN | TPM_HORIZONTAL;
  153. tpm.cbSize = sizeof(tpm);
  154. CPoint pt;
  155. CRect& rcExclude = (CRect&)tpm.rcExclude;
  156. CWnd::GetDesktopWindow()->GetWindowRect(&rcExclude);
  158. CRect rcFrame;
  159. AfxGetMainWnd()->GetWindowRect(&rcFrame);
  161. switch (dwStyle & CBRS_ALIGN_ANY) {
  162. case CBRS_ALIGN_RIGHT:
  163. case CBRS_ALIGN_LEFT:
  164. pt = CPoint(rcItem.right+1, rcItem.top-1);
  165. // to avoid strange menu flip, won't do : [rcExclude.right = rcItem.right+1;]
  166. // I want to use : fuFlags |= TPM_HORNEGANIMATION;
  167. break;
  169. default: // case CBRS_ALIGN_TOP:
  170. // changed by Manfred Drasch - start
  171. CRect rcTmpItem;
  172. rcTmpItem = rcItem;
  173. if(rcTmpItem.left < 0)
  174. {
  175. rcTmpItem.right = rcTmpItem.Width();
  176. rcTmpItem.left = 0;
  177. }
  179. if(rcTmpItem.left > rcExclude.right)
  180. {
  181. rcTmpItem.right = rcExclude.right; 
  182. rcTmpItem.left = rcTmpItem.right-rcTmpItem.Width();
  183. }
  184. pt = CPoint(rcTmpItem.left-1, rcTmpItem.bottom);
  185. rcExclude.bottom = rcTmpItem.bottom+1;// <- insead of [fuFlags |= TPM_VERPOSANIMATION;]
  186. // changed by Manfred Drasch - end
  187. break;
  188. }
  189. return pt;
  190. }
  193. //******************************************************************
  194. static int _CalcTextWidth(const CString& strText)
  195. {
  196. CWindowDC dc(NULL);
  197. CRect rcText(0, 0, 0, 0);
  198. CFont* pOldFont = dc.SelectObject(&_fontHorzMenu);
  199. dc.DrawText(strText, &rcText, DT_SINGLELINE | DT_CALCRECT);
  200. dc.SelectObject(pOldFont);
  202. return rcText.Width();
  203. }
  205. //******************************************************************
  206. // grippers pasted from MFC6
  207. #define CX_GRIPPER  3
  208. #define CY_GRIPPER  3
  209. #define CX_BORDER_GRIPPER 2
  210. #define CY_BORDER_GRIPPER 2
  211. #define CX_GRIPPER_ALL CX_GRIPPER + CX_BORDER_GRIPPER*2
  212. #define CY_GRIPPER_ALL CY_GRIPPER + CY_BORDER_GRIPPER*2
  214. /////////////////////////////////////////////////////////////////////////////
  215. // CMenuBar
  216. BEGIN_MESSAGE_MAP(CMenuBar, CControlBar)
  217. //{{AFX_MSG_MAP(CMenuBar)
  218. ON_WM_LBUTTONDOWN()
  219. ON_WM_RBUTTONDOWN()
  220. ON_WM_MOUSEMOVE()
  221. ON_WM_CREATE()
  222. ON_WM_LBUTTONUP()
  223. ON_WM_LBUTTONDBLCLK()
  224. ON_WM_TIMER()
  225. ON_WM_DESTROY()
  226. ON_WM_NCCALCSIZE()
  227. ON_WM_NCPAINT()
  228. ON_WM_NCHITTEST()
  229. ON_WM_SIZE()
  230. ON_WM_SETCURSOR()
  231. ON_WM_SYSCOLORCHANGE()
  232. //}}AFX_MSG_MAP
  233. ON_REGISTERED_MESSAGE(MB_SET_MENU_NULL, OnSetMenuNull)
  234. ON_WM_PAINT()
  235. END_MESSAGE_MAP()
  237. IMPLEMENT_DYNAMIC(CMenuBar, CControlBar)
  239. /////////////////////////////////////////////////////////////////////////////
  240. // CMenuBar Construction
  241. CMenuBar::CMenuBar()
  242. {
  243. m_nCurIndex  = -1;
  244. m_nTrackingState = none;
  245. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  246. m_bIgnoreAlt = FALSE;
  247. m_hMenu = NULL;
  248. m_nIDEvent = NULL;
  249. szNameHistory.Empty();
  250. bSaveHistory=FALSE;
  251. m_bChangeState=FALSE;
  252. m_bMDIMaximized = FALSE;
  253. m_hWndMDIClient = NULL;
  254. m_hWndActiveChild = NULL;
  256. m_pMenuIcon = NULL;
  257. m_pMenuControl = NULL;
  259. m_bDelayedButtonLayout = TRUE;
  260. m_dwExStyle = 0;
  262. m_bFrameActive = FALSE;
  263. m_bMDIApp = FALSE;
  264. m_bXP=FALSE;
  265. cmb=NULL;
  266. m_bCombo=FALSE;//combobox by default
  267. bIsTabbed=FALSE;
  268. m_MenuContext=NULL;
  269. m_StyleDisplay=GUISTYLE_XP;
  270. }
  272. //******************************************************************
  273. BOOL CMenuBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
  274. {
  275. return CreateEx(pParentWnd, dwStyle,
  276. CRect(m_cxLeftBorder, m_cyTopBorder, m_cxRightBorder, m_cyBottomBorder), nID);
  278. }
  280. //******************************************************************
  281. BOOL CMenuBar::CreateEx(CWnd* pParentWnd, DWORD dwStyle, CRect rcBorders, UINT nID)
  282. {
  283. ASSERT_VALID(pParentWnd);// must have a parent
  284. ASSERT (!((dwStyle & CBRS_SIZE_FIXED) && (dwStyle & CBRS_SIZE_DYNAMIC)));
  286. SetBorders(rcBorders);
  288. // save the original style
  289. m_dwExStyle = dwStyle;
  291. // save the style
  292. m_dwStyle = (dwStyle & CBRS_ALL);// ******fixed by Mark Gentry, thanx!******
  294. dwStyle &= ~CBRS_ALL;
  295. dwStyle|=WS_CLIPCHILDREN | CCS_NOPARENTALIGN | CCS_NOMOVEY | CCS_NORESIZE;
  296. CString strClass = AfxRegisterWndClass(
  297. /*CS_HREDRAW | CS_VREDRAW |*/
  298. CS_DBLCLKS,// don't forget!
  299. AfxGetApp()->LoadStandardCursor(IDC_ARROW),
  300. (HBRUSH)NULL);
  302. m_clrFace=GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  303. return CWnd::Create(strClass, _T("MenuBar"), dwStyle, CRect(), pParentWnd, nID);
  304. }
  305. void CMenuBar::SetSaveHistory(CString sNameHistory,BOOL bsaveHistory)
  306. {
  307. szNameHistory=sNameHistory;
  308. bSaveHistory=bsaveHistory;
  309. }
  310. //******************************************************************
  311. int CMenuBar::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  312. {
  313. if (CControlBar::OnCreate(lpCreateStruct) == -1)
  314. return -1;
  316. CWnd* pFrame = GetOwner();
  317. ASSERT_VALID(pFrame);
  319. // hook frame window to trap WM_MENUSELECT
  320. //m_hookFrame.Install(this, pFrame->GetSafeHwnd());
  322. // If this is an MDI app, hook client window to trap WM_MDISETMENU
  323. if (pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd))) {
  324. m_bMDIApp = TRUE;
  325. m_hWndMDIClient = ((CMDIFrameWnd*)pFrame)->m_hWndMDIClient;
  326. ASSERT(::IsWindow(m_hWndMDIClient));
  327. m_hookMDIClient.Install(this, m_hWndMDIClient);
  328. }
  330. if (m_pDockContext==NULL)
  331. m_pDockContext=new CGuiDockContext(this);
  332. ASSERT(m_pDockContext);
  334. if (!_InitCommonResources()) {
  335. TRACE(_T("Failed to create menubar resourcen"));
  336. return FALSE;
  337. }
  339. return 0;
  340. }
  343. void CMenuBar::OnSysColorChange( )
  344. {
  346. CClientDC dc(this);
  347. m_clrFace=GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  348. for (int i = 0; i < m_arrItem.GetSize(); ++i)
  349. m_arrItem[i]->UpdateClr();
  350. CWnd::OnSysColorChange( );
  352. /*if(m_pMenuControl != NULL) 
  353. m_pMenuControl->SetColorButton(GuiDrawLayer::GetRGBColorFace());
  354. if(m_pMenuIcon != NULL) 
  355. {
  356. m_pMenuIcon->OnActivateChildWnd();
  357. m_pMenuIcon->Update(&dc);
  358. }*/
  360. }
  361. //******************************************************************
  363. BOOL CMenuBar::CreateCombo(CComboBox* pControl,UINT nID,int iSize,DWORD dwStyle)
  364. {
  365. CFont m_Font;
  366. m_Font.CreateStockObject (DEFAULT_GUI_FONT);
  367. if(!pControl->Create(dwStyle, CRect(1,1,iSize,100), this, nID))
  368. {
  369. TRACE(_T("Failed to create combo-boxn"));
  370. m_bCombo=FALSE;
  371. return FALSE;
  372. }
  373. m_bCombo=TRUE;
  374. cmb=(CGuiComboBoxExt*)pControl;
  375. cmb->ActiveHistory(TRUE);
  376. cmb->LoadHistory(szNameHistory,bSaveHistory);
  377. return TRUE;
  378. }
  380. //******************************************************************
  381. void CMenuBar::OnSize(UINT nType, int cx, int cy) 
  382. {
  383. RefreshBar();
  384. if (m_bCombo==TRUE)
  385. DrawCombo();
  386. }
  389. void CMenuBar::SetTabbed(BOOL bIstabed)
  390. {
  391. bIsTabbed=bIstabed;
  392. }
  394. //******************************************************************
  395. BOOL CMenuBar::InitItems()
  396. {
  397. ASSERT(m_hMenu);
  399. // clean up all items
  400. DeleteItems();
  402. // buttons
  403. for (int i = 0; i < ::GetMenuItemCount(m_hMenu); ++i) {
  404. m_arrItem.Add(new CMenuButton(m_hMenu, i,this));
  405. }
  407. if (m_bMDIApp) {
  408. // icon
  409. CWnd* pFrame = GetTopLevelFrame();
  410. ASSERT_VALID(pFrame);
  411. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  412. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  413. ASSERT(::IsWindow(hWndMDIClient));
  415. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  416. WM_MDIGETACTIVE, 0, 0);
  417. if ((!bIsTabbed) )
  418. {
  420. m_pMenuIcon = new CMenuIcon(this);
  421. m_arrItem.InsertAt(0, m_pMenuIcon);
  422. // frame control
  423. m_pMenuControl = new CMenuControl(this);
  424. m_arrItem.Add(m_pMenuControl);
  426. // reinitializing
  427. m_pMenuIcon->OnActivateChildWnd();
  428. m_pMenuControl->OnActivateChildWnd();
  429. }
  430. }
  432. return TRUE;
  433. }
  436. //******************************************************************
  437. BOOL CMenuBar::LoadMenuBar(UINT nIDResource)
  438. {
  439. ASSERT(m_hMenu == NULL);
  441. ASSERT_VALID(m_pDockSite);
  442. if (m_pDockSite->GetMenu()) {
  443. PostMessage(MB_SET_MENU_NULL, (WPARAM)m_pDockSite->GetSafeHwnd());
  444. }
  446. m_hMenu = ::LoadMenu(AfxGetInstanceHandle(), MAKEINTRESOURCE(nIDResource));
  447. if (m_hMenu == NULL) {
  448. TRACE(_T("Failed to load menun"));
  449. return FALSE;
  450. }
  452. return InitItems();
  453. }
  455. //******************************************************************
  457. HMENU CMenuBar::LoadMenu(HMENU hMenu, HMENU hWindowMenu)
  458. {
  459. ASSERT(::IsMenu(hMenu));
  460. ASSERT_VALID(this);
  462. CFrameWnd* pFrame = GetParentFrame();
  463. if (::GetMenu(pFrame->GetSafeHwnd()) != NULL) {
  464. // not to make MFC ignore SetMenu(NULL), post it.
  465. PostMessage(MB_SET_MENU_NULL, (WPARAM)pFrame->GetSafeHwnd());
  466. }
  468. HMENU hOldMenu = m_hMenu;
  469. m_hMenu = hMenu;// menu is shared with MFC
  471. // initialize Items 
  472. VERIFY(InitItems());
  474. if (hMenu) {
  475. m_hWindowMenu = hWindowMenu;
  476. RefreshBar();// and menubar itself
  477. }
  479. return hOldMenu;
  480. }
  482. //******************************************************************
  484. void CMenuBar::RefreshBar()
  485. {
  486. InvalidateRect(NULL);
  488. #if _MFC_VER >= 0x600
  489. if (GetParent()->IsKindOf(RUNTIME_CLASS(CReBar))) {
  490. m_bDelayedButtonLayout = TRUE;// to avoid ASSERTION
  491. Layout();
  492. }
  493. #endif
  495. CFrameWnd* pFrame = (CFrameWnd*)GetTopLevelFrame();
  496. ASSERT_VALID(pFrame); ASSERT(pFrame->IsFrameWnd());
  498. pFrame->RecalcLayout();
  500. // floating frame
  501. CFrameWnd* pMiniFrame = GetParentFrame();
  502. if (pMiniFrame->IsKindOf(RUNTIME_CLASS(CMiniFrameWnd)))
  503. pMiniFrame->RecalcLayout();
  504. }
  506. /////////////////////////////////////////////////////////////////////////////
  507. // CMenuBar clean up 
  508. CMenuBar::~CMenuBar()
  509. {
  511. }
  513. //******************************************************************
  514. void CMenuBar::DeleteItems()
  515. {
  516. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  517. CMenuItem* pItem = m_arrItem[i];
  518. delete pItem;
  519. }
  521. m_arrItem.RemoveAll();
  523. m_pMenuIcon = NULL;
  524. m_pMenuControl = NULL;
  525. }
  527. //******************************************************************
  528. /////////////////////////////////////////////////////////////////////////////
  529. // CMenuBar draw
  531. //******************************************************************
  532. void CMenuBar::UpdateBar(TrackingState nState, int nNewIndex)
  533. {
  534. if (m_nTrackingState == buttonmouse)
  535. m_bIgnoreAlt = FALSE;// if prev state is BUTTONMOUSE, always should be FALSE!
  537. m_nTrackingState = nState;
  540. // clean up
  541. if (IsValidIndex(m_nCurIndex)) {
  542. CMenuItem* pItem = m_arrItem[m_nCurIndex];
  543. CClientDC dc(this);
  544. pItem->ModifyState(MISTATE_HOT | MISTATE_PRESSED, 0);
  545. pItem->Update(&dc);
  547. // draw captions forcefully
  548. if (m_pMenuControl) {
  549. CRect rcCross = m_pMenuControl->GetRect() & m_arrItem[m_nCurIndex]->GetRect();
  550. if (!rcCross.IsRectEmpty()) {
  551. m_pMenuControl->DrawControl();
  552. if (m_bCombo==TRUE)
  553. DrawCombo();
  554. }
  555. }
  557. m_nCurIndex = -1;
  558. }
  560. if (nState != none) {
  561. ASSERT(IsValidIndex(nNewIndex));
  562. m_nCurIndex = nNewIndex;
  563. CMenuItem* pItem = m_arrItem[m_nCurIndex];
  564. CClientDC dc(this);
  566. if (nState == button || nState == buttonmouse) {
  567. pItem->ModifyState(MISTATE_PRESSED, MISTATE_HOT);
  568. pItem->Update(&dc);
  569. }
  570. else if (nState == popup) {
  571. pItem->ModifyState(MISTATE_HOT, MISTATE_PRESSED);
  572. pItem->Update(&dc);
  573. }
  575. // draw captions forcefully
  576. if (m_pMenuControl) {
  577. CRect rcCross = m_pMenuControl->GetRect() & m_arrItem[m_nCurIndex]->GetRect();
  578. if (!rcCross.IsRectEmpty()) {
  579. m_pMenuControl->DrawControl();
  580. if (m_bCombo==TRUE)
  581. DrawCombo();
  582. }
  583. }
  584. }
  585. else {
  586. // must be default parameter
  587. ASSERT(nNewIndex == -1);
  588. }
  590. m_bProcessRightArrow = m_bProcessLeftArrow = TRUE;
  591. }
  593. /////////////////////////////////////////////////////////////////////////////
  594. // CMenuBar message handler
  595. int CMenuBar::HitTestOnTrack(CPoint point)
  596. {
  597. for (int i = 0; i < GetItemCount(); ++i) {
  598. CMenuItem* pItem = m_arrItem[i];
  599. CRect rcItem = pItem->GetRect();
  601. if ((pItem->GetStyle() & MISTYLE_TRACKABLE) &&
  602. rcItem.PtInRect(point))
  603. return i;
  604. }
  606. return -1;
  607. }
  609. //*******************************************************************
  610. void CMenuBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
  611. {
  612. }
  614. //******************************************************************
  615. void CMenuBar::OnLButtonDown(UINT nFlags, CPoint point) 
  616. {
  617. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  618. //int nIndex = HitTestOnTrack(point);
  619. int nIndex=nFlags >= 100? nFlags-100: -1;
  620. if(m_bMDIApp && !bIsTabbed)
  621. {
  623. if (nFlags == 1000)
  624. nIndex=0;
  625. else if (nIndex == -1)
  626. nIndex=-2;
  627. else 
  628. nIndex++;
  629. }
  630. if (IsValidIndex(nIndex) && (m_arrItem[nIndex]->GetStyle() & MISTYLE_TRACKABLE)) {
  631. UpdateBar(button, nIndex);
  632. TrackPopup(nIndex);
  633. return; // eat it!
  634. }
  636. CControlBar::OnLButtonDown(nFlags, point);
  637. }
  639. void CMenuBar::OnRButtonDown(UINT nFlags, CPoint point) 
  640. {
  642. ClientToScreen (&point);
  643. CMenu m_menu;
  644. if (m_MenuContext!= NULL)
  645. {
  646. m_menu.LoadMenu(m_MenuContext);
  647. CMenu* m_SubMenu = m_menu.GetSubMenu(0);
  648. m_SubMenu->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL,
  649. point.x, point.y-2, AfxGetMainWnd());
  650. Invalidate();
  651. UpdateWindow();
  652. }
  653. // CMenuBar::OnRButtonDown(nFlags, point);
  654. }
  657. //******************************************************************
  658. void CMenuBar::OnMouseMove(UINT nFlags, CPoint point)
  659. {
  660. int nIndex = HitTestOnTrack(point);
  661. if (!IsTopParentActive() || !GetTopLevelParent()->IsWindowEnabled())
  662. return;
  663. if (IsValidIndex(nIndex)) {
  664. if (m_nCurIndex == -1 || m_nCurIndex != nIndex) {// if other button
  665. UpdateBar(buttonmouse, nIndex);// button made hot with mouse
  667. if (!m_nIDEvent)
  668. m_nIDEvent = SetTimer(1, 100, NULL);
  669. }
  670. }
  671. else {
  672. UpdateBar();
  673. }
  675. CControlBar::OnMouseMove(nFlags, point);
  676. }
  678. //******************************************************************
  679. LRESULT CMenuBar::OnSetMenuNull(WPARAM wParam, LPARAM)
  680. {
  681. HWND hWnd = (HWND)wParam;
  682. ASSERT(::IsWindow(hWnd));
  683. ::SetMenu(hWnd, NULL);
  685. return 0;
  686. }
  688. //******************************************************************
  689. LRESULT CMenuBar::OnSettingChange(WPARAM wParam, LPARAM lParam)
  690. {
  691. // reinitialize fonts etc
  692. if (!_InitCommonResources(TRUE)) {
  693. TRACE(_T("Failed to create bar resourcen"));
  694. return FALSE;
  695. }
  697. VERIFY(InitItems());
  699. CFrameWnd* pFrame = GetParentFrame();
  700. ASSERT_VALID(pFrame);
  701. pFrame->RecalcLayout();
  702. return 0;
  703. }
  704. //******************************************************************
  705. void CMenuBar::OnLButtonUp(UINT nFlags, CPoint point) 
  706. {
  707. CControlBar::OnLButtonUp(nFlags, point);
  708. }
  709. //******************************************************************
  710. void CMenuBar::CheckActiveChildWndMaximized()
  711. {
  712. if(!m_pMenuControl) return;
  713. if (!bIsTabbed)
  714. {
  715. ASSERT(m_pMenuControl);
  716. ASSERT(m_pMenuIcon);
  717. }
  719. BOOL bMaximized = FALSE;
  720. GetActiveChildWnd(bMaximized);
  721. if (m_bMDIMaximized != bMaximized) {
  722. LTRACE(_T("CMenuBar::CheckActiveChildWndMaximized---state changed, refreshingn"));
  723. m_bMDIMaximized = bMaximized;
  724. if (!bIsTabbed)
  725. {
  727. m_pMenuControl->OnActivateChildWnd();
  728. m_pMenuIcon->OnActivateChildWnd();
  729. if(!m_bMDIMaximized )
  730. {
  731. m_bChangeState=TRUE;
  732. m_pMenuControl->m_arrButton[0].ShowWindow(SW_HIDE);
  733. m_pMenuControl->m_arrButton[1].ShowWindow(SW_HIDE);
  734. m_pMenuControl->m_arrButton[2].ShowWindow(SW_HIDE);
  735. }
  736. else
  737. {
  738. m_bChangeState=TRUE;
  739. m_pMenuControl->m_arrButton[0].ShowWindow(SW_SHOW);
  740. m_pMenuControl->m_arrButton[1].ShowWindow(SW_SHOW);
  741. m_pMenuControl->m_arrButton[2].ShowWindow(SW_SHOW);
  743. }
  745. }
  747. if (m_bCombo==TRUE)
  748. DrawCombo();
  749. RefreshBar();
  750. }
  753. }
  754. //******************************************************************
  755. void CMenuBar::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
  756. {
  757. LTRACE(_T("CMenuBar::OnInitMenuPopupn"));
  758. CMenu menu;
  759. menu.Attach((HMENU)m_hWindowMenu);
  761. // scan for first window command
  762. int n = menu.GetMenuItemCount();
  763. BOOL bAddSeperator = TRUE;
  764. for (int iPos=0; iPos<n; iPos++) {
  765. if (menu.GetMenuItemID(iPos) >= AFX_IDM_FIRST_MDICHILD) {
  766. bAddSeperator = FALSE;
  767. break;
  768. }
  769. }
  771. while (iPos < (int)menu.GetMenuItemCount())
  772. menu.RemoveMenu(iPos, MF_BYPOSITION);
  774. // get active window so I can check its menu item
  775. ASSERT(m_hWndMDIClient);
  776. HWND hwndActive = (HWND)::SendMessage(m_hWndMDIClient,
  777. WM_MDIGETACTIVE, 0, NULL);
  779. // append window names in the form "# title"
  780. // *****fixed by VORGA, thanks!*****
  781. int iWin;
  782. int nID = AFX_IDM_FIRST_MDICHILD;
  783. CString sWinName, sMenuItem;
  784. HWND hwnd;
  785. for (iWin = 1; iWin <= 10; iWin++, nID++)
  786. {
  787. hwnd = ::GetDlgItem(m_hWndMDIClient, nID);
  788. if (hwnd == NULL)
  789. break;
  791. if (bAddSeperator)
  792. {
  793. menu.InsertMenu(iPos++, MF_BYPOSITION | MF_SEPARATOR);
  794. bAddSeperator = FALSE;
  795. }
  797. if (iWin < 10)
  798. {
  799. CWnd::FromHandle(hwnd)->GetWindowText(sWinName);
  800. sMenuItem.Format(_T("&%d %s"), iWin, (LPCTSTR)sWinName);
  801. menu.InsertMenu(iPos, MF_BYPOSITION, nID, sMenuItem);
  802. if (hwnd == hwndActive)
  803. menu.CheckMenuItem(iPos, MF_BYPOSITION | MF_CHECKED);
  804. }
  805. else
  806. {
  807. menu.InsertMenu(iPos, MF_BYPOSITION, nID, _szMoreWindows);
  808. }
  809. iPos++;
  810. }
  812. menu.Detach();
  813. }
  814. //******************************************************************
  815. void CMenuBar::OnSetMenu(HMENU hNewMenu, HMENU hWindowMenu)
  816. {
  817. if (!bIsTabbed)
  818. ASSERT(m_pMenuIcon && m_pMenuControl);
  819. // We can get active MDI child window on this message!
  820. BOOL bMax = FALSE;
  821. HWND hWndChild = GetActiveChildWnd(bMax);
  823. if (!m_hWndActiveChild || m_hWndActiveChild != hWndChild) {// an active child window changed
  824. LTRACE(_T("CMenuBar::OnSetMenu---an active child window changedn"));
  825. m_hWndActiveChild = hWndChild;
  826. // tell MenuIcon child window has been changed
  827. if (!bIsTabbed)
  828. m_pMenuIcon->OnActivateChildWnd();
  829. }
  831. if (!m_hMenu || m_hMenu != hNewMenu) { // menu changed
  832. LTRACE(_T("CMenuBar::OnSetMenu---menu changedn"));
  833. LoadMenu(hNewMenu, hWindowMenu); // set menubar menu
  834. GetOwner()->SetMenu(NULL); // clear frame menu
  835. }
  836. }
  837. //******************************************************************
  838. BOOL CMenuBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  839. {
  841. CPoint ptCurPos; 
  842. CRect rc;GetClientRect(rc);
  843. GetCursorPos (&ptCurPos);
  844. ScreenToClient (&ptCurPos);
  845. if (m_dwStyle & CBRS_ORIENT_HORZ)
  846. {
  847. rc.right=rc.left+2;
  848. if (ptCurPos.x< 0)
  849. {
  850. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  851. return TRUE;
  852. }
  853. }
  854. else
  855. {
  856. rc.bottom=rc.top+2;
  857. if (ptCurPos.y< 0)
  858. {
  859. SetCursor (LoadCursor(NULL, IDC_SIZEALL));
  860. return TRUE;
  861. }
  862. }
  863. return CControlBar::OnSetCursor(pWnd, nHitTest, message);
  865. }
  867. //******************************************************************
  868. void CMenuBar::OnNcPaint() 
  869. {
  870. EraseNonClientEx();
  871. }
  872. //******************************************************************
  873. UINT CMenuBar::OnNcHitTest(CPoint point) 
  874. {
  875. // make nonclient area clickable
  876. return HTCLIENT;
  877. }
  878. //******************************************************************
  879. void CMenuBar::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS FAR* lpncsp) 
  880. {
  881. // calculate border space (will add to top/bottom, subtract from right/bottom)
  882. CRect rect; rect.SetRectEmpty();
  883. BOOL bHorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  884. _CalcInsideRect(rect, bHorz);
  886. if (!(m_dwStyle & CBRS_FLOATING))
  887. {
  888. // adjust non-client area for border space
  889. lpncsp->rgrc[0].left += bHorz?rect.left+4:rect.left+1;
  890. lpncsp->rgrc[0].top += bHorz?rect.top+4:rect.top+2;
  891. }
  892. else
  893. {
  894. lpncsp->rgrc[0].left += rect.left;
  895. lpncsp->rgrc[0].top += rect.top+4;
  896. }
  897. lpncsp->rgrc[0].right += rect.right;
  898. lpncsp->rgrc[0].bottom += rect.bottom;
  900. }
  901. //******************************************************************
  902. void CMenuBar::OnDestroy() 
  903. {
  904. if(m_bCombo==TRUE)
  905. cmb->SaveHistory(szNameHistory,bSaveHistory);
  906. CControlBar::OnDestroy();
  908. // TODO: 
  909. DeleteItems();
  911. if (m_nIDEvent)
  912. KillTimer(m_nIDEvent);
  914. // for SDI application
  915. if (m_bMDIApp == FALSE && m_hMenu != NULL)
  916. ::FreeResource(m_hMenu);
  917. }
  918. //******************************************************************
  919. void CMenuBar::OnTimer(UINT nIDEvent) 
  920. {
  921. if (m_nTrackingState == buttonmouse) {
  922. CPoint pt; ::GetCursorPos(&pt);
  923. CRect rect;
  924. GetWindowRect(&rect);
  926. if (!rect.PtInRect(pt)) {
  927. UpdateBar();
  929. if (m_nIDEvent) {
  930. KillTimer(m_nIDEvent);
  931. m_nIDEvent = NULL;
  932. }
  933. }
  934. }
  936. CControlBar::OnTimer(nIDEvent);
  937. }
  938. //******************************************************************
  939. HWND CMenuBar::GetActiveChildWnd(BOOL& bMaximized)
  940. {
  941. if (!m_hWndMDIClient)
  942. return NULL;
  944. BOOL bMax = FALSE;
  945. HWND hWnd = (HWND)::SendMessage(m_hWndMDIClient,
  946. WM_MDIGETACTIVE, 0, (LPARAM)&bMax);
  947. bMaximized = bMax;
  949. return hWnd;
  950. }
  951. //******************************************************************
  952. /////////////////////////////////////////////////////////////////////////////
  953. // CMenuBar system hook
  954. void CMenuBar::OnMenuSelect(HMENU hMenu, UINT nIndex)
  955. {
  956. // LTRACE(_T("CMenuBar::OnMenuSelectn"));
  957. if (m_nTrackingState == popup) {
  958. m_bProcessRightArrow = (::GetSubMenu(hMenu, nIndex) == NULL);
  959. HMENU hSubMenu = ::GetSubMenu(hMenu, m_nCurIndex);
  960. if (hSubMenu == NULL)
  961. return;
  962. m_bProcessLeftArrow = (hMenu == hSubMenu);
  963. }
  964. }
  965. //******************************************************************
  966. void CMenuBar::OnFrameNcActivate(BOOL bActive) 
  967. {
  968. CFrameWnd* pFrame = GetTopLevelFrame();
  969. ASSERT_VALID(pFrame);
  971. if (pFrame->m_nFlags & WF_STAYACTIVE)
  972. bActive = TRUE;
  973. if (!pFrame->IsWindowEnabled())
  974. bActive = FALSE;
  975. if (bActive == m_bFrameActive)
  976. return;
  978. if (!bActive) {
  979. for (int i = 0; i < GetItemCount(); ++i) {
  980. m_arrItem[i]->ModifyState(0, MISTATE_INACTIVE);
  981. }
  982. }
  983. else {
  984. for (int i = 0; i < GetItemCount(); ++i) {
  985. m_arrItem[i]->ModifyState(MISTATE_INACTIVE, 0);
  986. }
  987. }
  989. m_bFrameActive = bActive;
  991. // InvalidateRect(NULL); is better, but too late
  992. // while clicking the application title bar (like IE5)
  993. // so we have to redraw now!
  995. }
  996. //******************************************************************
  997. LRESULT CALLBACK CMenuBar::MenuInputFilter(int code, WPARAM wParam, LPARAM lParam)
  998. {
  999. return (
  1000. code == MSGF_MENU &&
  1001. g_pMenuBar &&
  1002. g_pMenuBar->OnMenuInput( *((MSG*)lParam) )
  1003. ) ? TRUE : CallNextHookEx(g_hMsgHook, code, wParam, lParam);
  1004. }
  1005. //******************************************************************
  1006. void CMenuBar::TrackPopup(int nIndex)
  1007. {
  1008. ASSERT_VALID(this);
  1010. m_nCurIndex = nIndex;
  1011. m_bLoop = TRUE;
  1012. while (m_bLoop == TRUE) {
  1013. UpdateWindow(); // force to repaint when button hidden by other window
  1014. UpdateBar(popup, m_nCurIndex);
  1016. // install hook
  1017. ASSERT(g_pMenuBar == NULL);
  1018. g_pMenuBar = this;
  1019. ASSERT(g_hMsgHook == NULL);
  1021. m_bLoop = FALSE;
  1022. g_hMsgHook = ::SetWindowsHookEx(WH_MSGFILTER,
  1023. MenuInputFilter, NULL, AfxGetApp()->m_nThreadID);// m_bLoop may become TRUE
  1025. // popup!!
  1026. m_nTrackingState = popup;
  1027. _nPrevIndexForCmd = m_nCurIndex;
  1028. m_arrItem[m_nCurIndex]->TrackPopup(this, GetTopLevelParent());
  1030. // uninstall hook
  1031. ::UnhookWindowsHookEx(g_hMsgHook);
  1032. g_hMsgHook = NULL;
  1033. g_pMenuBar = NULL;
  1034. }
  1036. UpdateBar();
  1037. }
  1039. //******************************************************************
  1040. BOOL CMenuBar::OnMenuInput(MSG& m)
  1041. {
  1042. ASSERT_VALID(this);
  1043. int nMsg = m.message;
  1044. CPoint pt = m.lParam;
  1045. ScreenToClient(&pt);
  1047. switch (nMsg) {
  1048. case WM_MOUSEMOVE:
  1049. if (pt != m_ptMouse) {
  1050. int nIndex = HitTestOnTrack(pt);
  1051. if ((IsValidIndex(nIndex) && nIndex != m_nCurIndex ) ) {
  1052. // defferent button clicked
  1053. // Invalidate();
  1054. if (!bActivSystemMenu)
  1055. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  1056. if (bActivSystemMenu)
  1057. PostMessage(WM_CANCELMODE);
  1058. UpdateBar(button, nIndex);
  1059. UpdateBar();
  1060. bActivSystemMenu=FALSE;
  1061. m_nCurIndex = nIndex;
  1062. m_bLoop = TRUE; // continue loop
  1063. }
  1064. m_ptMouse = pt;
  1065. }
  1066. break;
  1068. case WM_LBUTTONDOWN:
  1069. if ((HitTestOnTrack(pt) != -1 && HitTestOnTrack(pt) == m_nCurIndex)) {
  1070. // same button clicked
  1071. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  1072. //PostMessage(WM_CANCELMODE);
  1073. UpdateBar(button, m_nCurIndex);
  1074. m_bLoop = FALSE; // out of loop
  1075. return TRUE; // eat it!
  1076. }
  1077. break;
  1080. case WM_KEYDOWN: {
  1081. TCHAR vKey = m.wParam;
  1082. if (m_dwStyle & CBRS_ORIENT_VERT) { // if vertical
  1083. break; // do nothing
  1084. }
  1086. if ((vKey == VK_LEFT  && m_bProcessLeftArrow) ||
  1087. (vKey == VK_RIGHT && m_bProcessRightArrow)) {
  1088. // no submenu
  1089. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vKey==VK_LEFT);
  1090. AfxGetMainWnd()->PostMessage(WM_CANCELMODE); // destroy popupped menu
  1091. UpdateBar();
  1092. m_nCurIndex = nNewIndex;
  1093. m_bLoop = TRUE; // continue loop
  1094. return TRUE; // eat it!
  1095. }
  1096. }
  1097. break;
  1099. case WM_SYSKEYDOWN:
  1100. // LTRACE(_T("    m_bIgnore = TRUEn"));
  1101. m_bIgnoreAlt = TRUE; // next SysKeyUp will be ignored
  1102. break;
  1103. }
  1105. return FALSE; // pass along...
  1106. }
  1108. //******************************************************************
  1109. BOOL CMenuBar::TranslateFrameMessage(MSG* pMsg)
  1110. {
  1111. ASSERT_VALID(this);
  1112. ASSERT(pMsg);
  1114. UINT nMsg = pMsg->message;
  1115. if (WM_LBUTTONDOWN <= nMsg && nMsg <= WM_MOUSELAST) {
  1116. if (pMsg->hwnd != m_hWnd && m_nTrackingState > 0) {
  1117. // clicked outside
  1118. UpdateBar();
  1119. }
  1120. }
  1121. else if (nMsg == WM_SYSKEYDOWN || nMsg == WM_SYSKEYUP || nMsg == WM_KEYDOWN) {
  1122. BOOL bAlt = HIWORD(pMsg->lParam) & KF_ALTDOWN; // Alt key presed?
  1123. TCHAR vkey = pMsg->wParam; // + X key
  1124. if (vkey == VK_MENU ||
  1125. (vkey == VK_F10 && !((GetKeyState(VK_SHIFT) & 0x80000000) ||
  1126.                    (GetKeyState(VK_CONTROL) & 0x80000000) || bAlt))) {
  1127. // only alt key pressed
  1128. if (nMsg == WM_SYSKEYUP) {
  1129. switch (m_nTrackingState) {
  1130. case none:
  1131. if (m_bIgnoreAlt == TRUE) {
  1132. // LTRACE(_T("    ignore ALT key upn"));
  1133. m_bIgnoreAlt = FALSE;
  1134. break;
  1135. }
  1137. if (m_bMDIApp) {
  1138. UpdateBar(button, GetNextOrPrevButton(0, FALSE));
  1139. }
  1140. else {
  1141. UpdateBar(button, 0);
  1142. }
  1143. break;
  1144. case button:
  1145. UpdateBar();
  1146. break;
  1147. case buttonmouse:
  1148. break; // do nothing
  1149. }
  1150. }
  1151. return TRUE;
  1152. }
  1153. else if ((nMsg == WM_SYSKEYDOWN || nMsg == WM_KEYDOWN)) {
  1154. if (m_nTrackingState == button) {
  1155. if (m_dwStyle & CBRS_ORIENT_HORZ) { // if horizontal
  1156. switch (vkey) {
  1157. case VK_LEFT:
  1158. case VK_RIGHT: {
  1159. int nNewIndex  = GetNextOrPrevButton(m_nCurIndex, vkey == VK_LEFT);
  1160. UpdateBar(button, nNewIndex);
  1161. return TRUE;
  1162.    }
  1163. case VK_SPACE:
  1164. case VK_UP:
  1165. case VK_DOWN:
  1166. TrackPopup(m_nCurIndex);
  1167. return TRUE;
  1169. case VK_ESCAPE:
  1170. UpdateBar();
  1171. return TRUE;
  1172. }
  1173. }
  1174. else { // if vertical
  1175. switch (vkey) {
  1176. case VK_UP:
  1177. case VK_DOWN:{
  1178. int nNewIndex = GetNextOrPrevButton(m_nCurIndex, vkey == VK_UP);
  1179. UpdateBar(button, nNewIndex);
  1180. return TRUE;
  1181.    }
  1182. case VK_SPACE:
  1183. case VK_RIGHT:
  1184. case VK_LEFT:
  1185. TrackPopup(m_nCurIndex);
  1186. return TRUE;
  1188. case VK_ESCAPE:
  1189. UpdateBar();
  1190. return TRUE;
  1191. }
  1192. }
  1193. }
  1195. // Alt + X pressed
  1196. if ((bAlt || m_nTrackingState == button) && _istalnum(vkey)) {
  1197. int nIndex;
  1198. if (MapAccessKey(vkey, nIndex) == TRUE) {
  1199. UpdateBar(button, nIndex);
  1200. UpdateBar();
  1201. TrackPopup(nIndex);
  1202. return TRUE; // eat it!
  1203. }
  1204. else if (m_nTrackingState==button && !bAlt) {
  1205. // MessageBeep(0); // if you want
  1206. return TRUE;
  1207. }
  1208. }
  1210. if (m_nTrackingState > 0) { // unknown key
  1211. if (m_nTrackingState != buttonmouse) { // if tracked with mouse, don't update bar
  1212. UpdateBar();
  1213. }
  1214. }
  1215. }
  1216. }
  1217. return FALSE; // pass along...
  1218. }
  1220. //******************************************************************
  1221. BOOL CMenuBar::MapAccessKey(TCHAR cAccessKey, int& nIndex)
  1222. {
  1223. for (int i = 0; i < GetItemCount(); ++i) {
  1224. // fixing point
  1225. TCHAR cKey = m_arrItem[i]->GetAccessKey();
  1226. if (toupper(cKey)/*_totupper(cKey)*/ == cAccessKey) {// *****fixed by andi, thanx!*****
  1227. nIndex = i;
  1228. return TRUE;
  1229. }
  1230. }
  1231. return FALSE;
  1232. }
  1234. /////////////////////////////////////////////////////////////////////////////
  1235. // CMenuBar layout
  1236. int CMenuBar::GetClipBoxLength(BOOL bHorz)
  1237. {
  1238. CFrameWnd* pFrame = GetTopLevelFrame(); ASSERT_VALID(pFrame);
  1239. CRect rcFrame; pFrame->GetWindowRect(rcFrame);
  1241. CWnd* pParent = GetParent(); ASSERT_VALID(pParent);
  1242. CRect rcParent; pParent->GetWindowRect(rcParent);
  1244. const int cxFrameBorder = ::GetSystemMetrics(SM_CXFRAME);
  1245. int cxNonClient = cxFrameBorder*2 + m_cxLeftBorder + m_cxRightBorder;
  1246. if (m_dwExStyle & CBRS_GRIPPER)
  1247. cxNonClient += CX_GRIPPER_ALL;
  1249. if (m_dwStyle & CBRS_SIZE_DYNAMIC) {
  1250. if (bHorz) {
  1251. return rcFrame.Width() - cxNonClient;
  1252. }
  1253. else {
  1254. int nResult = rcParent.Height();
  1255. // I don't know the reason of the following code...
  1256. nResult -= m_cxRightBorder + m_cxLeftBorder + cyBorder2*2;
  1257. if (m_dwExStyle & CBRS_GRIPPER)
  1258. nResult -= CY_GRIPPER_ALL;
  1260. return nResult;
  1261. }
  1262. }
  1263. else {
  1264. CRect rect; GetClientRect(rect);
  1265. if (bHorz) {
  1266. return rect.Width();
  1267. }
  1268. else {
  1269. return rect.Height();
  1270. }
  1271. }
  1272. }
  1274. //******************************************************************
  1275. CSize CMenuBar::CalcLayout(DWORD dwMode, int nLength)
  1276. {
  1277. ASSERT_VALID(this);
  1278. ASSERT(::IsWindow(m_hWnd));
  1279. if (dwMode & LM_HORZDOCK)
  1280. ASSERT(dwMode & LM_HORZ);
  1282. // make SC_CLOSE button disable
  1283. if (m_dwStyle & CBRS_FLOATING) {
  1284. CFrameWnd* pMiniFrame = GetParentFrame(); ASSERT_KINDOF(CMiniFrameWnd, pMiniFrame);
  1285. // Don't do this, cause right click menu turns unavairable
  1286. // pMiniFrame->ModifyStyle(WS_SYSMENU, 0);
  1287. CMenu* pSysMenu = pMiniFrame->GetSystemMenu(FALSE); ASSERT_VALID(pSysMenu);
  1288. pSysMenu->EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
  1289. }
  1291. int nCount = GetItemCount();
  1292. CSize sizeResult(0, 0);
  1294. if (nCount > 0)
  1295. {
  1296. if (!(m_dwStyle & CBRS_SIZE_FIXED))
  1297. {
  1298. BOOL bDynamic = m_dwStyle & CBRS_SIZE_DYNAMIC;
  1300. if (bDynamic && (dwMode & LM_MRUWIDTH))
  1301. {
  1302. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_MRUWIDTHn"));
  1303. SizeMenuBar(m_nMRUWidth);
  1304. CalcItemLayout(nCount);// added
  1306. sizeResult = CalcSize(nCount);
  1307. }
  1308. else if (bDynamic && (dwMode & LM_HORZDOCK))
  1309. {
  1310. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_HORZDOCKn"));
  1311. if (IsFloating() || (m_dwStyle & CBRS_ORIENT_VERT)) {
  1312. // I can't synchronize horz size on dragging with size on dock bar
  1313. // as VC++ developer can't.
  1314. SizeMenuBar(32767);
  1315. }
  1316. else {
  1317. // Menu Button wrapped by frame width
  1318. SizeMenuBar(GetClipBoxLength(TRUE));
  1319. }
  1321. CalcItemLayout(nCount);// added
  1323. sizeResult = CalcSize(nCount);
  1324. if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_VERT)) {
  1325. if (m_pDockContext->m_pDC) {// while dragging (m_pDockContext->m_bDragging is helpless)
  1326. sizeResult.cx = GetClipBoxLength(TRUE);
  1327. }
  1328. }
  1329. }
  1330. else if (bDynamic && (dwMode & LM_VERTDOCK))
  1331. {
  1332. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---LM_VERTDOCKn"));
  1333. //SizeMenuBar(0);
  1334. CalcItemLayout(nCount, TRUE);// added
  1336. sizeResult = CalcVertDockSize(nCount);
  1337. if (!IsFloating() && !(m_dwStyle & CBRS_ORIENT_HORZ)) {
  1338. if (m_pDockContext->m_pDC) {// while dragging
  1339. sizeResult.cy = GetClipBoxLength(FALSE);//GetrcParent.Height() - m_cxRightBorder - m_cxLeftBorder;
  1340. }
  1341. }
  1342. }
  1343. else if (bDynamic && (nLength != -1))
  1344. {
  1345. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---nLength != -1n"));
  1346. CRect rect; rect.SetRectEmpty();
  1347. _CalcInsideRect(rect, (dwMode & LM_HORZ));
  1348. BOOL bVert = (dwMode & LM_LENGTHY);
  1349. int nLen = nLength + (bVert ? rect.Height() : rect.Width());
  1351. SizeMenuBar(nLen, bVert);
  1352. CalcItemLayout(nCount, bVert);// added
  1354. sizeResult = CalcSize(nCount);
  1355. }
  1356. else if (bDynamic && (m_dwStyle & CBRS_FLOATING))
  1357. {
  1358. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---CBRS_FLOATINGn"));
  1359. SizeMenuBar(m_nMRUWidth);
  1360. CalcItemLayout(nCount);// added
  1362. sizeResult = CalcSize(nCount);
  1363. }
  1364. else
  1365. {
  1366. if (!bDynamic) {
  1367. InvalidateRect(NULL);
  1368. goto Junk;
  1369. }
  1371. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_DYNAMIC)---othern"));
  1372. BOOL bVert = !(dwMode & LM_HORZ);
  1373. SizeMenuBar(GetClipBoxLength(TRUE));
  1374. CalcItemLayout(nCount, bVert);// added
  1376. if (bVert) {
  1377. InvalidateRect(NULL);// draw forcefully for captions
  1378. sizeResult = CalcVertDockSize(nCount);
  1379. // DockBar not replaced yet, so I can't get precise size
  1380. sizeResult.cy = 10000;
  1381. }
  1382. else {
  1383. sizeResult = CalcSize(nCount);
  1384. sizeResult.cx = GetClipBoxLength(TRUE);
  1385. }
  1386. }
  1387. }
  1388. else {// CBRS_SIZE_FIXED
  1389. LTRACE(_T("CMenuBar::CalcLayout(CBRS_SIZE_FIXED)n"));
  1390. Junk:
  1391. BOOL bVert = !(dwMode & LM_HORZ);
  1392. SizeMenuBar(32767);
  1393. CalcItemLayout(nCount, bVert);// added
  1395. if (bVert) {
  1396. sizeResult = CalcVertDockSize(nCount);
  1397. }
  1398. else {
  1399. sizeResult = CalcSize(nCount);
  1400. }
  1401. }
  1403. if (dwMode & LM_COMMIT)
  1404. {
  1405. LTRACE(_T("CMenuBar::CalcLayout---LM_COMMITn"));
  1406. int nControlCount = 0;
  1407. BOOL bIsDelayed = m_bDelayedButtonLayout;
  1408. m_bDelayedButtonLayout = FALSE;
  1410. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1411. m_nMRUWidth = sizeResult.cx;
  1413. CalcItemLayout(nCount, dwMode);
  1415. m_bDelayedButtonLayout = bIsDelayed;
  1416. }
  1417. }
  1419. //BLOCK: Adjust Margins
  1420. {
  1421. CRect rect; rect.SetRectEmpty();
  1422. _CalcInsideRect(rect, (dwMode & LM_HORZ));
  1423. sizeResult.cy -= rect.Height();
  1424. sizeResult.cx -= rect.Width();
  1425. CSize size = CControlBar::CalcFixedLayout((dwMode & LM_STRETCH), (dwMode & LM_HORZ));
  1426. sizeResult.cx = max(sizeResult.cx, size.cx);
  1427. sizeResult.cy = max(sizeResult.cy, size.cy);
  1428. }
  1430. if (dwMode & LM_HORZ)
  1432. sizeResult.cy+=5;
  1433. else
  1434. sizeResult.cx+=3;
  1436. return sizeResult;
  1437. }
  1439. //******************************************************************
  1440. CSize CMenuBar::CalcFixedLayout(BOOL bStretch, BOOL bHorz)
  1441. {
  1442. LTRACE(_T("CMenuBar::CalcFixedLayoutn"));
  1443. ASSERT_VALID(this);
  1444. ASSERT(::IsWindow(m_hWnd));
  1446. DWORD dwMode = bStretch ? LM_STRETCH : 0;
  1447. dwMode |= bHorz ? LM_HORZ : 0;
  1449. return CalcLayout(dwMode);
  1450. }
  1451. //******************************************************************
  1453. CSize CMenuBar::CalcDynamicLayout(int nLength, DWORD dwMode)
  1454. {
  1455. LTRACE(_T("CMenuBar::CalcDynamicLayoutn"));
  1456. if ((nLength == -1) && !(dwMode & LM_MRUWIDTH) && !(dwMode & LM_COMMIT) &&
  1457. ((dwMode & LM_HORZDOCK) || (dwMode & LM_VERTDOCK)))
  1458. {
  1459. LTRACE(_T("    FixedLayoutn"));
  1460. return CalcFixedLayout(dwMode & LM_STRETCH, dwMode & LM_HORZDOCK);
  1461. }
  1462. return CalcLayout(dwMode, nLength);
  1463. }
  1465. // set m_bWrapped by nWidth
  1466. int CMenuBar::WrapMenuBar(int nCount, int nWidth)
  1467. {
  1468. // LTRACE(_T("CMenuBar::WrapMenuBarn"));
  1469. int nResult = 0;
  1470. int x = 0;
  1472. for (int i = 0; i < nCount; ++i) {
  1473. CMenuItem* pItem = m_arrItem[i];
  1474. if (i+1 == nCount)
  1475. return ++nResult;
  1477. if (x + pItem->GetHorizontalSize().cx> nWidth) {// itself is over
  1478. if (pItem->GetStyle() & MISTYLE_WRAPPABLE) {
  1479. pItem->ModifyState(0, MISTATE_WRAP);
  1480. ++nResult;
  1481. x = 0;
  1482. }
  1483. }
  1484. else if (x + pItem->GetHorizontalSize().cx + 
  1485.  m_arrItem[i+1]->GetHorizontalSize().cx> nWidth) {
  1486. if (pItem->GetStyle() & MISTYLE_WRAPPABLE) {
  1487. pItem->ModifyState(0, MISTATE_WRAP);
  1488. ++nResult;
  1489. x = 0;
  1490. }
  1491. }
  1492. else {
  1493. pItem->ModifyState(MISTATE_WRAP, 0);
  1494. x += pItem->GetHorizontalSize().cx;
  1495. }
  1496. }
  1498. return nResult + 1;
  1499. }
  1500. //******************************************************************
  1501. // calc only size, by using m_bWrapped
  1502. CSize CMenuBar::CalcSize(int nCount)
  1503. {
  1504. ASSERT(nCount > 0);
  1505. CPoint cur(0,0);
  1506. CSize sizeResult(0,0);
  1507. int nWrap = 0;
  1508. for (int i = 0; i < nCount; ++i) {
  1509. CMenuItem* pItem = m_arrItem[i];
  1510. sizeResult.cx = max(cur.x + pItem->GetHorizontalSize().cx, sizeResult.cx);
  1511. sizeResult.cy = max(cur.y + pItem->GetHorizontalSize().cy, sizeResult.cy);
  1513. cur.x += pItem->GetHorizontalSize().cx;
  1515. if (pItem->GetState() & MISTATE_WRAP) {
  1516. //LTRACE(_T("    nIndex:%d is wrappedn"), i);
  1517. cur.x = 0;// reset x pos
  1518. cur.y += pItem->GetHorizontalSize().cy;
  1519. ++nWrap;
  1520. }
  1521. }
  1523. return sizeResult;
  1524. }
  1525. //******************************************************************
  1526. void CMenuBar::Layout()
  1527. {
  1528. ASSERT(m_bDelayedButtonLayout);
  1530. m_bDelayedButtonLayout = FALSE;
  1532. BOOL bHorz = (m_dwStyle & CBRS_ORIENT_HORZ) != 0;
  1533. if ((m_dwStyle & CBRS_FLOATING) && (m_dwStyle & CBRS_SIZE_DYNAMIC))
  1534. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_HORZ | LM_MRUWIDTH | LM_COMMIT);
  1535. else if (bHorz)
  1536. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_HORZ | LM_HORZDOCK | LM_COMMIT);
  1537. else
  1538. ((CMenuBar*)this)->CalcDynamicLayout(0, LM_VERTDOCK | LM_COMMIT);
  1539. }
  1540. //******************************************************************
  1541. void CMenuBar::SizeMenuBar(int nLength, BOOL bVert)
  1542. {
  1543. //LTRACE("CMenuBar::SizeMenuBarn");
  1544. int nCount = GetItemCount(); ASSERT(nCount > 0);
  1546. if (!bVert) { // nLength is horizontal length
  1548. if (IsFloating()) { // half size wrapping
  1550. CSize sizeMax, sizeMin, sizeMid;
  1552. // Wrap MenuBar vertically
  1553. WrapMenuBar(nCount, 0);
  1554. sizeMin = CalcSize(nCount);
  1556. // Wrap MenuBar horizontally
  1557. WrapMenuBar(nCount, 32767);
  1558. sizeMax = CalcSize(nCount);
  1560. // we can never understand this algorithm :), see CToolBar implementation
  1561. while (sizeMin.cx < sizeMax.cx) {
  1562. // LTRACE("looping sizeMin.cx:%d < sizeMax.cx:%dn", sizeMin.cx, sizeMax.cx);
  1563. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1564. WrapMenuBar(nCount, sizeMid.cx);
  1565. sizeMid = CalcSize(nCount);
  1566. if (sizeMid.cx == sizeMax.cx) { // if you forget, it loops forever!
  1567. return;
  1568. }
  1569. // LTRACE("    sizeMid : %d %dn", sizeMid.cx, sizeMid.cy);
  1571. if (nLength >= sizeMax.cx) {
  1572. // LTRACE("    nLength:%d >= sizeMax.cx:%dn", nLength, sizeMax.cx);
  1573. if (sizeMin == sizeMid) {
  1574. WrapMenuBar(nCount, sizeMax.cx);
  1575. // LTRACE("out SizeMenuBarn");
  1576. return;
  1577. }
  1578. sizeMin = sizeMid;
  1579. }
  1580. else if (nLength < sizeMax.cx) {
  1581. // LTRACE("    nLength:%d < sizeMax.cx:%dn", nLength, sizeMax.cx);
  1582. sizeMax = sizeMid;
  1583. }
  1584. else {
  1585. // LTRACE("out SizeMenuBarn");
  1586. return;
  1587. }
  1588. }
  1589. }
  1590. else { // each one wrapping
  1591. //LTRACE("    just each one wrappingn");
  1592. WrapMenuBar(nCount, nLength);
  1593. }
  1594. }
  1595. else { // nLength is vertical length
  1596. CSize sizeMax, sizeMin, sizeMid;
  1598. // Wrap MenuBar vertically
  1599. WrapMenuBar(nCount, 0);
  1600. sizeMin = CalcSize(nCount);
  1602. // Wrap MenuBar horizontally
  1603. WrapMenuBar(nCount, 32767);
  1604. sizeMax = CalcSize(nCount);
  1606. while (sizeMin.cx < sizeMax.cx) {
  1607. sizeMid.cx = (sizeMin.cx + sizeMax.cx) / 2;
  1608. WrapMenuBar(nCount, sizeMid.cx);
  1609. sizeMid = CalcSize(nCount);
  1610. if (sizeMid.cx == sizeMax.cx) {
  1611. return;
  1612. }
  1613. if (nLength < sizeMid.cy) {
  1614. if (sizeMin == sizeMid) {
  1615. WrapMenuBar(nCount, sizeMax.cx);
  1616. //LTRACE("out SizeMenuBarn");
  1617. return;
  1618. }
  1619. sizeMin = sizeMid;
  1620. }
  1621. else if (nLength > sizeMid.cy)
  1622. sizeMax = sizeMid;
  1623. else {
  1624. //LTRACE("out SizeMenuBarn");
  1625. return;
  1626. }
  1627. }
  1628. }
  1630. //LTRACE("out SizeMenuBarn");
  1631. }
  1632. //***********************************************************************************
  1633. void CMenuBar::DrawCombo()
  1634. {
  1635. CRect rect;
  1636. GetClientRect(rect);
  1637. CalcSizeItem();
  1638. CWnd* pFrame = GetTopLevelFrame();
  1639. BOOL bMaximized = FALSE;
  1640. //la idea es verificar que la ventana es MDI
  1641. if (pFrame->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd)))
  1642. {
  1643. ASSERT_VALID(pFrame);
  1644. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  1645. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  1646. ASSERT(::IsWindow(hWndMDIClient));
  1647. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  1648. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  1649. }
  1650. if ((m_dwStyle & CBRS_ORIENT_HORZ) && m_bCombo==TRUE && !(m_dwStyle & CBRS_FLOATING))
  1651. {
  1652. CRect reccombo;
  1653. cmb->GetClientRect (&reccombo);
  1654. if (rect.Width() > m_sizex+(bMaximized?30:0)+reccombo.Width() )
  1655. {
  1656. cmb->ShowWindow(SW_SHOW);
  1657. CRect rctemp=rect;
  1658. rctemp.top=-1;
  1659. rctemp.bottom-=2;
  1660. int nDif;
  1661. if (!bIsTabbed)
  1662.    nDif=bMaximized?60:0;
  1663. else
  1664.    nDif=0;
  1665. rctemp.left=rctemp.right-reccombo.Width()-  nDif;
  1666. rctemp.right=rctemp.left+reccombo.Width();
  1667. cmb->MoveWindow(rctemp);
  1668. }
  1669. else
  1670. {
  1671. cmb->ShowWindow(SW_HIDE);
  1672. }
  1673. }
  1675. }
  1677. //******************************************************************
  1678. void CMenuBar::CalcSizeItem()
  1679. {
  1680. m_sizex=0;
  1681. for(int i = 0; i < m_arrItem.GetSize(); ++i) {
  1682. CMenuItem* pItem = m_arrItem[i];
  1683. m_sizex+=pItem->GetRect().Width();
  1684. }
  1686. }
  1688. //******************************************************************
  1689. CSize CMenuBar::CalcVertDockSize(int nCount)
  1690. {
  1691. ASSERT(nCount > 0);
  1692. CSize sizeResult(0, 0);
  1694. for (int i = 0; i < nCount; ++i) {
  1695. CMenuItem* pItem = m_arrItem[i];
  1696. sizeResult.cy += pItem->GetRect().Height();
  1697. }
  1699. sizeResult.cx = _cyMenuOnBar;
  1700. return sizeResult;
  1701. }
  1703. //******************************************************************
  1704. void CMenuBar::CalcItemLayout(int nCount, BOOL bVert)
  1705. {
  1706. ASSERT(nCount > 0);
  1707. int x = 0; int y = 0;
  1709. if (!bVert) {
  1710. for (int i = 0; i < nCount; ++i) {
  1711. CMenuItem* pItem = m_arrItem[i];
  1712. CPoint ptItem(x, y);
  1713. pItem->Layout(ptItem, TRUE);// layout by itself!
  1714. if (pItem->GetState() & MISTATE_WRAP) {
  1715. x = 0;// reset x to 0
  1716. y += pItem->GetRect().Height();
  1717. }
  1718. else
  1719. x += pItem->GetRect().Width();
  1720. }
  1721. }
  1722. else {
  1723. for (int i = 0; i < nCount; ++i) {
  1724. CMenuItem* pItem = m_arrItem[i];
  1725. CPoint ptItem(0, y);
  1726. pItem->Layout(ptItem, FALSE); // layout by itself
  1727. y += pItem->GetRect().Height();
  1728. }
  1729. }
  1730. }
  1731. //******************************************************************
  1732. //////////////////////////////////////////////////////////////////////
  1733. // Added by Koay Kah Hoe. Thanx!
  1734. void CMenuBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  1735. {
  1736. if (m_bMDIApp)
  1737. CheckActiveChildWndMaximized();
  1738. }
  1739. //******************************************************************
  1740. //////////////////////////////////////////////////////////////////////
  1741. // CMenuBar decoration
  1743. void CMenuBar::_DrawGripper(CWindowDC* dc,CRect* rcWin)
  1744. {
  1747. if (m_dwStyle & CBRS_FLOATING) return ;
  1748. if(m_StyleDisplay == GUISTYLE_2003) //no es XP
  1749. {
  1750. if (m_dwStyle & CBRS_ORIENT_HORZ)
  1751. {
  1752. rcWin->top+=(rcWin->Height()/2)-4;
  1753. rcWin->left+=7;
  1754. rcWin->right=rcWin->left+2;
  1755. rcWin->bottom-=8;
  1756. CRect rcBlack;
  1758. for (int i=0; i < rcWin->Height(); i+=4)
  1759. {
  1760. CRect rcWindow;
  1761. CBrush cb;
  1762. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  1763. rcWindow=rcWin;
  1764. rcWindow.top=rcWin->top+i;
  1765. rcWindow.bottom=rcWindow.top+2;
  1766. dc->FillRect(rcWindow,&cb);
  1767. rcBlack=rcWindow;
  1768. rcBlack.left-=1;
  1769. rcBlack.top=(rcWin->top+i)-1;
  1770. rcBlack.bottom=rcBlack.top+2;
  1771. rcBlack.right=rcBlack.left+2;
  1772. cb.DeleteObject();
  1773. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  1774. dc->FillRect(rcBlack,&cb);
  1776. }
  1779. }
  1780. else
  1781. {
  1783. rcWin->top+=3;
  1784. rcWin->left+=4;
  1785. rcWin->right-=2;
  1786. rcWin->bottom=rcWin->top+2;
  1787. CRect rcBlack;
  1788. for (int i=0; i < rcWin->Width(); i+=4)
  1789. {
  1790. CRect rcWindow;
  1791. CBrush cb;
  1792. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  1793. rcWindow=rcWin;
  1794. rcWindow.left=rcWindow.left+i;
  1795. rcWindow.right=rcWindow.left+2;
  1796. dc->FillRect(rcWindow,&cb);
  1797. rcBlack=rcWindow;
  1798. rcBlack.top-=1;
  1799. rcBlack.left-=1;
  1800. rcBlack.bottom=rcBlack.top+2;
  1801. rcBlack.right=rcBlack.left+2;
  1802. cb.DeleteObject();
  1803. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorShadow(m_StyleDisplay));
  1804. dc->FillRect(rcBlack,&cb);
  1806. }
  1807. }
  1808. }
  1809. else
  1810. {
  1811. if (m_dwStyle & CBRS_ORIENT_HORZ)
  1812. {
  1814. rcWin->top+=(rcWin->Height()/2)-4;
  1815. rcWin->left+=7;
  1816. rcWin->right=rcWin->left+3;
  1817. rcWin->bottom-=6;
  1819. for (int i=0; i < rcWin->Height(); i+=2)
  1820. {
  1821. CRect rcWindow;
  1822. CBrush cb;
  1823. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1824. rcWindow=rcWin;
  1825. rcWindow.top=rcWin->top+i;
  1826. rcWindow.bottom=rcWindow.top+1;
  1827. dc->FillRect(rcWindow,&cb);
  1829. }
  1831. }
  1832. else
  1833. {
  1834. rcWin->top+=2;
  1835. rcWin->left+=2;
  1836. rcWin->right-=2;
  1837. rcWin->bottom=rcWin->top+3;
  1838. for (int i=0; i < rcWin->Width(); i+=2)
  1839. {
  1840. CRect rcWindow;
  1841. CBrush cb;
  1842. cb.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1843. rcWindow=rcWin;
  1844. rcWindow.left=rcWindow.left+i;
  1845. rcWindow.right=rcWindow.left+1;
  1846. dc->FillRect(rcWindow,&cb);
  1848. }
  1850. }
  1851. }
  1853. }
  1855. //******************************************************************
  1856. void CMenuBar::EraseNonClientEx()
  1857. {
  1858. // get window DC that is clipped to the non-client area
  1860. CRect rcWindow;
  1861. CRect rcClient;
  1862. CWindowDC dc(this);
  1863. GetWindowRect(&rcWindow);
  1864. GetClientRect(&rcClient);
  1865. CBrush cbr;
  1866. cbr.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  1867. rcClient.OffsetRect(-rcWindow.TopLeft());
  1868.     rcWindow.OffsetRect(-rcWindow.TopLeft());
  1869.     ScreenToClient(rcWindow);
  1870. rcClient.OffsetRect(-rcWindow.left, - rcWindow.top);
  1871. dc.ExcludeClipRect(rcClient);   
  1872. rcWindow.OffsetRect(-rcWindow.left, -rcWindow.top);
  1873. int ibotton = rcWindow.bottom;
  1874. rcWindow.top = rcWindow.bottom - 1;
  1875. dc.FillRect(rcWindow, &cbr); 
  1876. rcWindow.top = 0;
  1877. rcWindow.bottom += 3;
  1878. dc.FillRect(rcWindow, &cbr); 
  1879. dc.FillSolidRect(0, rcWindow.top + 1, rcWindow.right + 1, 1, 
  1880. GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style)); 
  1881. cbr.DeleteObject();
  1884. // draw gripper in non-client area
  1885. _DrawGripper(&dc, &rcWindow);
  1886. }
  1888. #define CX_BORDER   1
  1889. #define CY_BORDER   1
  1890. //******************************************************************
  1891. void CMenuBar::DrawRaisedBorders(CDC* pDC, CRect& rect)
  1892. {
  1893. ASSERT_VALID(this);
  1894. ASSERT_VALID(pDC);
  1896. DWORD dwStyle = m_dwStyle;
  1897. if (!(dwStyle & CBRS_BORDER_ANY))
  1898. return;
  1900. // prepare for dark lines
  1901. ASSERT(rect.top == 0 && rect.left == 0);
  1902. CRect rect1, rect2;
  1903. rect1 = rect;
  1904. rect2 = rect;
  1905. COLORREF clrBtnShadow = GuiDrawLayer::GetRGBColorShadow(GuiDrawLayer::m_Style);//afxData.bWin4 ? afxData.clrBtnShadow : afxData.clrWindowFrame;
  1906. COLORREF clrBtnFace = GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  1907. COLORREF clrBtnHilight = ::GetSysColor(COLOR_BTNHILIGHT);
  1909. // draw dark line one pixel back/up
  1910. if (dwStyle & CBRS_BORDER_3D)
  1911. {
  1912. rect1.right -= CX_BORDER;
  1913. rect1.bottom -= CY_BORDER;
  1914. }
  1915. if (dwStyle & CBRS_BORDER_TOP)
  1916. rect2.top += cyBorder2;
  1917. if (dwStyle & CBRS_BORDER_BOTTOM)
  1918. rect2.bottom -= cyBorder2;
  1920. // draw left and top
  1921. if (dwStyle & CBRS_BORDER_LEFT)
  1922. pDC->FillSolidRect(0, rect2.top, CX_BORDER, rect2.Height(), clrBtnFace);
  1923. if (dwStyle & CBRS_BORDER_TOP)
  1924. pDC->FillSolidRect(0, 0, rect.right, CY_BORDER, clrBtnFace);
  1926. // draw right and bottom
  1927. if (dwStyle & CBRS_BORDER_RIGHT)
  1928. pDC->FillSolidRect(rect1.right, rect2.top, -CX_BORDER, rect2.Height(), clrBtnShadow);
  1929. if (dwStyle & CBRS_BORDER_BOTTOM)
  1930. pDC->FillSolidRect(0, rect1.bottom, rect.right, -CY_BORDER, clrBtnShadow);
  1932. if (dwStyle & CBRS_BORDER_3D)
  1933. {
  1934. // draw left and top
  1935. if (dwStyle & CBRS_BORDER_LEFT)
  1936. pDC->FillSolidRect(1, rect2.top, CX_BORDER, rect2.Height(), clrBtnHilight);
  1937. if (dwStyle & CBRS_BORDER_TOP)
  1938. pDC->FillSolidRect(0, 1, rect.right, CY_BORDER, clrBtnHilight);
  1940. // draw right and bottom
  1941. if (dwStyle & CBRS_BORDER_RIGHT)
  1942. pDC->FillSolidRect(rect.right, rect2.top, -CX_BORDER, rect2.Height(), clrBtnFace);
  1943. if (dwStyle & CBRS_BORDER_BOTTOM)
  1944. pDC->FillSolidRect(0, rect.bottom, rect.right, -CY_BORDER, clrBtnFace);
  1945. }
  1947. if (dwStyle & CBRS_BORDER_LEFT)
  1948. rect.left += cxBorder2;
  1949. if (dwStyle & CBRS_BORDER_TOP)
  1950. rect.top += cyBorder2;
  1951. if (dwStyle & CBRS_BORDER_RIGHT)
  1952. rect.right -= cxBorder2;
  1953. if (dwStyle & CBRS_BORDER_BOTTOM)
  1954. rect.bottom -= cyBorder2;
  1955. }
  1957. //******************************************************************
  1958. int CMenuBar::GetNextOrPrevButton(int nIndex, BOOL bPrev)
  1959. {
  1960. int nCount = GetItemCount();
  1961. if (bPrev) { // <-
  1962. --nIndex;
  1963. if (nIndex < 0)
  1964. nIndex = nCount - 1;
  1965. }
  1966. else { // ->
  1967. ++nIndex;
  1968. if (nIndex >= nCount)
  1969. nIndex = 0;
  1970. }
  1972. if (!(m_arrItem[nIndex]->GetStyle() & MISTYLE_TRACKABLE) ||
  1973. (m_arrItem[nIndex]->GetState() & MISTATE_HIDDEN)) {
  1974. return GetNextOrPrevButton(nIndex, bPrev);
  1975. }
  1977. return nIndex;
  1978. }
  1980. //******************************************************************
  1981. /////////////////////////////////////////////////////////////////////////////
  1982. // CMenuBar OLE menu support
  1983. // MFC does'nt do command routing for other process server.
  1984. // ::TrackPopupMenuEx won't accept HWND of other process and
  1985. // we have to determine a message target(ole server window or not)
  1986. // as ::OleCreateMenuDescriptor do.
  1987. // This is a hard coding. 
  1988. // First menu(ordinarily File menu) and WindowMenu regarded as container's own menu.
  1989. // Some components can't update toolbar button and statusbar pane.
  1990. HWND CMenuBar::OleMenuDescriptor(BOOL& bSend, UINT nMsg, WPARAM wParam, LPARAM lParam)
  1991. {
  1992. CWnd* pOleWnd = GetCmdSentOleWnd();
  1993. if (pOleWnd == NULL)
  1994. return NULL;
  1995. HWND hWndSentCmd = NULL;
  1997. HMENU hMenu = NULL;
  1998. if (nMsg == WM_INITMENUPOPUP || nMsg == WM_INITMENU)
  1999. hMenu = (HMENU)wParam;
  2000. else if (nMsg == WM_MENUSELECT)
  2001. hMenu = (HMENU)lParam;
  2003. switch (nMsg) {
  2004. case WM_INITMENUPOPUP:
  2005. case WM_INITMENU:
  2006. case WM_MENUSELECT:
  2007. bSend = TRUE;
  2008. if (m_nTrackingState == popup) {
  2009. LTRACE2(_T("    now popupn"));
  2010. if (m_bMDIApp) {
  2011. LTRACE2(_T("    this is MDIn"));
  2012. if (m_nCurIndex == 0 || m_nCurIndex == 1 || hMenu == m_hWindowMenu) {
  2013. LTRACE2(_T("    it's container menu, send to framen"));
  2014. return NULL;
  2015. }
  2016. }
  2017. else {
  2018. LTRACE2(_T("    it's container menu, send to framen"));
  2019. if (m_nCurIndex == 0) {
  2020. return NULL;
  2021. }
  2022. }
  2023. LTRACE2(_T("    it's server menu, send to servern"));
  2024. return pOleWnd->GetSafeHwnd();
  2025. }
  2026. break;
  2028. case WM_COMMAND:
  2029. bSend = FALSE;
  2030. if (m_bMDIApp) {
  2031. LTRACE2(_T("    this is MDIn"));
  2032. if (_nPrevIndexForCmd == 0 || _nPrevIndexForCmd == 1 || _bWindowMenuSendCmd) {
  2033. LTRACE2(_T("    it's container menu, send to framen"));
  2034. return NULL;
  2035. }
  2036. }
  2037. else {
  2038. if (_nPrevIndexForCmd == 0) {
  2039. LTRACE2(_T("    it's container menu, send to framen"));
  2040. return NULL;
  2041. }
  2042. }
  2043. LTRACE2(_T("    it's server menu, send to servern"));
  2044. return pOleWnd->GetSafeHwnd();
  2045. }
  2047. return NULL;// send to frame
  2048. }
  2049. //******************************************************************
  2050. CWnd* CMenuBar::GetCmdSentOleWnd()
  2051. {
  2052. // *****fixed by VORGA, thanks!*****
  2053. CWnd* pWnd = AfxGetMainWnd();
  2054. if (pWnd == NULL || !pWnd->IsFrameWnd())
  2055. return NULL;
  2057. CFrameWnd* pFrame = NULL;
  2058. if (m_bMDIApp) {
  2059. CMDIFrameWnd *pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pWnd);
  2060. if (pMDIFrame == NULL)
  2061. return NULL;
  2062. pFrame = pMDIFrame->GetActiveFrame();
  2063. }
  2064. else {
  2065. pFrame = STATIC_DOWNCAST(CFrameWnd, pWnd);
  2066. }
  2068. if (pFrame == NULL)
  2069. return NULL;
  2071. CDocument* pDoc = pFrame->GetActiveDocument();
  2072. if (pDoc != NULL && pDoc->IsKindOf(RUNTIME_CLASS(COleDocument))) {
  2073. COleDocument* pOleDoc = STATIC_DOWNCAST(COleDocument, pDoc);
  2074. ASSERT_VALID(pOleDoc);
  2075. COleClientItem* pClientItem = pOleDoc->GetInPlaceActiveItem(pFrame);
  2076. CWnd* pWnd = (pClientItem == NULL) ? NULL : pClientItem->GetInPlaceWindow();
  2077. if (pWnd != NULL) {
  2078. return pWnd;
  2079. }
  2080. }
  2082. return NULL;
  2083. }
  2084. //******************************************************************
  2085. /////////////////////////////////////////////////////////////////////////////
  2086. // CMDIClientHook 
  2087. CMDIClientHook::CMDIClientHook()
  2088. {
  2089. m_pMenuBar = NULL;
  2090. }
  2091. //******************************************************************
  2092. BOOL CMDIClientHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  2093. {
  2094. ASSERT_VALID(pMenuBar);
  2095. ASSERT(m_pMenuBar == NULL);
  2096. m_pMenuBar = pMenuBar;
  2097. return HookWindow(hWndToHook);
  2098. }
  2099. //******************************************************************
  2100. CMDIClientHook::~CMDIClientHook()
  2101. {
  2102. HookWindow((HWND)NULL);
  2103. }
  2104. //******************************************************************
  2105. LRESULT CMDIClientHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  2106. {
  2107. ASSERT_VALID(m_pMenuBar);
  2109. switch (nMsg) {
  2110. case WM_MDISETMENU: // only sent to MDI client window
  2111. // Setting new frame/window menu: bypass MDI. wParam is new menu.
  2112. if (wParam) {
  2113. //LTRACE(_T("CMenuBar::WM_MDISETMENU 0x%04xn"), wParam);
  2114. m_pMenuBar->OnSetMenu((HMENU)wParam, (HMENU)lParam);
  2115. }
  2116. return 0;
  2118. case WM_MDIREFRESHMENU: // only sent to MDI client window
  2119. // Normally, would call DrawMenuBar, but I have the menu, so eat it.
  2120. //LTRACE(_T("CMenuBar::WM_MDIREFRESHMENUn"));
  2121. return 0;
  2123. }
  2125. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  2126. }
  2127. //******************************************************************
  2128. /////////////////////////////////////////////////////////////////////////////
  2129. // CMainFrameHook 
  2130. CMainFrameHook::CMainFrameHook()
  2131. {
  2132. m_pMenuBar = NULL;
  2133. }
  2135. //******************************************************************
  2136. BOOL CMainFrameHook::Install(CMenuBar* pMenuBar, HWND hWndToHook)
  2137. {
  2138. ASSERT_VALID(pMenuBar);
  2139. ASSERT(m_pMenuBar == NULL);
  2140. m_pMenuBar = pMenuBar;
  2141. return HookWindow(hWndToHook);
  2142. }
  2144. //******************************************************************
  2145. CMainFrameHook::~CMainFrameHook()
  2146. {
  2147. }
  2149. //******************************************************************
  2150. LRESULT CMainFrameHook::WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam)
  2151. {
  2152. ASSERT_VALID(m_pMenuBar);
  2153. // be care for other windows(MainFrame) hooking
  2154. // possible called when already this wnd destroyed (WM_NCACTIVATE is)
  2155. if (!::IsWindow(m_pMenuBar->m_hWnd)) {
  2156. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  2157. }
  2159. BOOL bSend = FALSE;
  2160. if (HWND hWndServer = m_pMenuBar->OleMenuDescriptor(bSend, nMsg, wParam, lParam)) {
  2161. // OLE wnd will handle message
  2162. if (bSend)
  2163. return ::SendMessage(hWndServer, nMsg, wParam, lParam);
  2164. else
  2165. return ::PostMessage(hWndServer, nMsg, wParam, lParam);
  2166. }
  2168. switch (nMsg) {
  2169. case WM_MENUSELECT:
  2170. m_pMenuBar->OnMenuSelect((HMENU)lParam, (UINT)LOWORD(wParam));
  2171. break;
  2173. case WM_INITMENUPOPUP:
  2174. if (!HIWORD(lParam) && (HMENU)wParam == m_pMenuBar->m_hWindowMenu)
  2175. m_pMenuBar->OnInitMenuPopup(CMenu::FromHandle((HMENU)wParam),
  2176. LOWORD(lParam), (BOOL)HIWORD(lParam));
  2177. break;
  2179. case WM_NCACTIVATE:
  2180. m_pMenuBar->OnFrameNcActivate((BOOL)wParam);
  2181. break;
  2183. case WM_SYSCOLORCHANGE:
  2184. case WM_SETTINGCHANGE:
  2185. LTRACE(_T("CMenuBar::WM_SETTINGCHANGEn"));
  2186. // It's enough to reinitialize common resources once.
  2187. m_pMenuBar->OnSettingChange(wParam, lParam);
  2188. break;
  2189. }
  2191. if (nMsg == CMenuBar::WM_GETMENU)
  2192. return (LRESULT)m_pMenuBar->m_hMenu;
  2194. return CSubclassWnd::WindowProc(nMsg, wParam, lParam);
  2195. }
  2201. //******************************************************************
  2202. //////////////////////////////////////////////////////////////////////
  2203. // CMenuItem interface
  2204. CMenuItem::CMenuItem()
  2205. {
  2206. m_fsStyle = 0;
  2207. m_fsState = 0;
  2208. m_rcItem.SetRectEmpty();
  2209. m_sizeHorz = CSize(0, 0);
  2210. m_cAccessKey = 0;
  2211. }
  2212. //******************************************************************
  2213. void CMenuItem::ModifyState(BYTE fsRemove, BYTE fsAdd)
  2214. {
  2215. m_fsState = (m_fsState & ~fsRemove) | fsAdd;
  2216. }
  2218. //******************************************************************
  2219. CSize CMenuItem::GetHorizontalSize() const
  2220. {
  2221. if (m_fsState & MISTATE_HIDDEN)
  2222. return CSize(0, 0);
  2223. else
  2224. return m_sizeHorz;
  2225. }
  2228. //-----------------------------------------------------------------
  2229. CGuiMenuButton::CGuiMenuButton()
  2230. {
  2231. m_bHorz=TRUE;
  2232. }
  2234. CGuiMenuButton::~CGuiMenuButton()
  2235. {
  2236. }
  2239. void CGuiMenuButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  2240. {
  2241. CDC*  pdc= CDC::FromHandle(lpDrawItemStruct->hDC);
  2242. CRect rc=lpDrawItemStruct->rcItem;
  2243. UINT  uState=lpDrawItemStruct->itemState;
  2244. CBrush cb;
  2246. if( uState & ODS_SELECTED) //the button is pressed
  2247. cb.CreateSolidBrush(GuiDrawLayer::GetRGBPressBXP());
  2248. else
  2249. if (m_bMouserOver)
  2250. {
  2251. if(m_StyleDisplay==GUISTYLE_2003)
  2252. {
  2253. if (GuiDrawLayer::m_Theme)
  2254. {
  2255. CGradient M(CSize(rc.Width(),rc.Height()));
  2256. M.PrepareCaption(pdc,m_StyleDisplay);
  2257. M.Draw(pdc,rc.left,rc.top,0,0,rc.Width(),rc.Height(),SRCCOPY);
  2258. cb.CreateStockObject(NULL_BRUSH);
  2259. }
  2260. else
  2261. cb.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  2262. }
  2263. else
  2264. cb.CreateSolidBrush(GuiDrawLayer::GetRGBFondoXP());
  2265. }
  2266. else
  2267. {
  2268. if(m_StyleDisplay==GUISTYLE_2003)
  2269. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(m_StyleDisplay));
  2270. else
  2271. cb.CreateSolidBrush(m_clColor);
  2272. }
  2276. if (( uState == ODS_SELECTED) || m_bMouserOver )
  2277. {
  2278. pdc->Draw3dRect(rc,GuiDrawLayer::GetRGBCaptionXP(),GuiDrawLayer::GetRGBCaptionXP());
  2279. rc.DeflateRect(1,1);
  2281. }
  2284. pdc->FillRect(rc,&cb);
  2285. if (m_SizeText.cx > 2)
  2286. {
  2289. int nMode = pdc->SetBkMode(TRANSPARENT);
  2291. if (m_bHorz)
  2292. {
  2293. CRect rectletra=rc;
  2294. CPoint pt=CSize(rectletra.top+1,rectletra.left);
  2295. if (uState & ODS_DISABLED)
  2296. pdc->DrawState(pt, m_SizeText, m_szText, DSS_DISABLED, TRUE, 0, (CBrush*)NULL);
  2297. else
  2298. {
  2299. if(m_bMouserOver != 1) 
  2300. pdc->SetTextColor(m_clrFont);
  2301. pdc->DrawText(m_szText,rectletra,DT_SINGLELINE|DT_CENTER|DT_VCENTER);
  2302. }
  2303. }
  2304. else
  2305. {
  2306. if (( uState == ODS_SELECTED) || m_bMouserOver )
  2307. rc.InflateRect(1,1);
  2309. COLORREF clr = ::GetSysColor(COLOR_MENUTEXT);
  2310. pdc->SetTextColor(clr);
  2311. CPoint ptOffset=CPoint(1,1);
  2312. CRect rcBtn = rc;
  2313. int nLength = m_szText.GetLength();
  2314. int nIndex = m_szText.Find('&');
  2315. CString strBtn = m_szText.Left(nIndex) + m_szText.Right(nLength - (nIndex+1));
  2317. // fixed for WinNT. *****fixed by Simon, thanks!*****
  2318. int iGraphicsMode = ::GetGraphicsMode(pdc->m_hDC);
  2319. ::SetGraphicsMode(pdc->m_hDC, GM_ADVANCED);
  2320. pdc->SetBkMode(TRANSPARENT);
  2321. CFont* pOldFont = pdc->SelectObject(&_fontVertMenu);
  2322. // I know precise text size
  2323. //m_sizeHorz=((CMenuBar*)GetParent())->m_sizeHors;
  2324. CSize m_sizeHorz;
  2325. m_sizeHorz.cx = (_CalcTextWidth(m_szText) + CXTEXTMARGIN*2)+8;
  2326. m_sizeHorz.cy = (_cyHorzFont + _cyTextMargin*2)+1;
  2327. CRect rcString = CRect(
  2328. CPoint(rcBtn.right - _cyTextMargin, rcBtn.top + CXTEXTMARGIN), m_sizeHorz);
  2329. pdc->DrawText(strBtn, rcString + ptOffset,
  2330. DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX);// don't forget DT_NOCLIP
  2331. gbintHorz=-1;
  2332. rcMenu=rcBtn;
  2333. rcMenu.bottom-=3;
  2334. pdc->SelectObject(pOldFont);
  2336. // CDC::DrawText is poor, so we have to draw vertical line by ourselves
  2337. CPen pen(PS_SOLID, 0, clr);
  2338. CPen* pOldPen = pdc->SelectObject(&pen);
  2340. CPoint m_ptLineFrom;
  2341. CPoint m_ptLineTo;
  2342. if (nIndex == 0) {
  2343. m_ptLineFrom = CPoint(_cyTextMargin-1, CXTEXTMARGIN+1);
  2344. m_ptLineTo  = CPoint(_cyTextMargin-1, CXTEXTMARGIN + _CalcTextWidth(strBtn.Left(nIndex+1)));
  2345. }
  2346. else {
  2347. m_ptLineFrom = CPoint(_cyTextMargin-1, CXTEXTMARGIN + _CalcTextWidth(strBtn.Left(nIndex+1)));
  2348. m_ptLineTo = CPoint(_cyTextMargin-1, CXTEXTMARGIN + _CalcTextWidth(strBtn.Left(nIndex+1)));
  2349. }
  2351. pdc->MoveTo(rcBtn.TopLeft() + m_ptLineFrom);
  2352. pdc->LineTo(rcBtn.TopLeft() + m_ptLineTo );
  2354. pdc->SelectObject(pOldPen);
  2355. ::SetGraphicsMode( pdc->m_hDC, iGraphicsMode );
  2356. }
  2357. }
  2359. }
  2361. BEGIN_MESSAGE_MAP(CGuiMenuButton,CGuiToolButton)
  2362. ON_WM_LBUTTONDOWN()
  2363. END_MESSAGE_MAP()
  2365. void CGuiMenuButton::OnLButtonDown(UINT nFlags, CPoint point)
  2366. {
  2367. ShowWindow(SW_HIDE);
  2368. ClientToScreen(&point);
  2369. GetParent()->SendMessage(WM_LBUTTONDOWN,100+GetDlgCtrlID(),MAKEWPARAM(point.x,point.y));
  2370. }
  2373. CGuiIconButton::CGuiIconButton()
  2374. {
  2375. }
  2377. CGuiIconButton::~CGuiIconButton()
  2378. {
  2379. ::FreeResource(m_Icon);
  2380. }
  2382. void CGuiIconButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct)
  2383. {
  2384. CDC*  pdc= CDC::FromHandle(lpDrawItemStruct->hDC);
  2385. CRect rc=lpDrawItemStruct->rcItem;
  2386. UINT  uState=lpDrawItemStruct->itemState;
  2387. CBrush cb;
  2389. cb.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  2390. pdc->FillRect(rc,&cb);
  2392. CPoint m_point=CPoint(1,1);
  2393. if (m_SizeImage.cx > 2)
  2394. {
  2396. pdc->DrawState (m_point, m_SizeImage,m_Icon,
  2397. (uState==ODS_DISABLED?DSS_DISABLED:DSS_NORMAL),(CBrush*)NULL);
  2398. }
  2399. }
  2401. BEGIN_MESSAGE_MAP(CGuiIconButton,CGuiToolButton)
  2402. ON_WM_LBUTTONDOWN()
  2403. END_MESSAGE_MAP()
  2405. void CGuiIconButton::OnLButtonDown(UINT nFlags, CPoint point)
  2406. {
  2407. ClientToScreen(&point);
  2408. GetParent()->SendMessage(WM_LBUTTONDOWN,1000,MAKEWPARAM(point.x,point.y));
  2409. }
  2411. //-----------------------------------------------------------------
  2414. //******************************************************************
  2415. //////////////////////////////////////////////////////////////////////
  2416. // CMenuButton class
  2417. CMenuButton::CMenuButton(HMENU hMenu, int nIndex,CWnd* pWnd)
  2418. {
  2419. ASSERT(::IsMenu(hMenu));
  2420. ASSERT(nIndex >= 0);
  2421. pParent=pWnd;
  2422. m_cfont.CreateFont(-11,0,0,0,400,0,0,0,0,1,2,1,34,"MS Sans Serif");
  2423. m_fsStyle |= (MISTYLE_TRACKABLE | MISTYLE_WRAPPABLE);
  2424. m_bt.Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2425. CRect(0,0,0,0), pWnd, nIndex);
  2427. m_bt.SetFont(&_fontHorzMenu);
  2428. m_bt.StyleDispl(GuiDrawLayer::m_Style);
  2429. m_bt.SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  2430. InitButtonStringAndSubMenuHandle(hMenu, nIndex);
  2431. InitHorizontalButtonSize();
  2432. InitAccessKeyAndVerticalLinePoint();
  2433. }
  2436. //******************************************************************
  2437. // ERNESTO
  2438. void CMenuButton::SetText(TCHAR *szText)
  2439. {
  2440. m_strBtn  = szText;
  2441. InitHorizontalButtonSize();
  2442. InitAccessKeyAndVerticalLinePoint();
  2444. }
  2446. //******************************************************************
  2447. void CMenuButton::InitButtonStringAndSubMenuHandle(HMENU hMenu, int nIndex)
  2448. {
  2449. // get menu button Text
  2450. TCHAR szText[256];
  2451. MENUITEMINFO info; ::memset(&info, 0, sizeof(MENUITEMINFO));
  2452. info.cbSize = sizeof(MENUITEMINFO);
  2453. info.fMask = MIIM_ID | MIIM_TYPE;
  2454. info.dwTypeData = szText;
  2455. info.cch = sizeof(szText);
  2456. ::GetMenuItemInfo(hMenu, nIndex, TRUE, &info);
  2457. m_strBtn = CString(szText);
  2459. m_bt.SetCaption(m_strBtn);
  2460. m_hSubMenu = ::GetSubMenu(hMenu, nIndex);
  2461. if (!m_hSubMenu) {
  2462. m_nID = ::GetMenuItemID(hMenu, nIndex);
  2463. ASSERT(m_nID != -1);
  2464. }
  2465. else {
  2466. m_nID = -1;
  2467. }
  2468. }
  2470. //******************************************************************
  2471. void CMenuButton::InitHorizontalButtonSize()
  2472. {
  2473. // get menu button Text size
  2474. ASSERT(m_strBtn.IsEmpty() == FALSE);
  2475. m_sizeHorz.cx = (_CalcTextWidth(m_strBtn) + CXTEXTMARGIN*2)+8;
  2476. m_sizeHorz.cy = (_cyHorzFont + _cyTextMargin*2)+1;
  2477. }
  2479. //******************************************************************
  2480. void CMenuButton::InitAccessKeyAndVerticalLinePoint()
  2481. {
  2482. int nIndex = m_strBtn.Find('&');
  2483. if (nIndex + 1 == m_strBtn.GetLength()) {
  2484. TRACE(_T("warning : & is bad position, access key is invalid.n"));
  2485. m_cAccessKey = 0;
  2486. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2487. return;
  2488. }
  2490. m_cAccessKey = m_strBtn[nIndex + 1];// -1 + 1 = 0; it's ok
  2492. if (nIndex == -1) {
  2493. m_ptLineFrom = m_ptLineTo = CPoint(0, 0);
  2494. }
  2495. else if (nIndex == 0) {
  2496. m_ptLineFrom = CPoint(_cyTextMargin, CXTEXTMARGIN);
  2497. m_ptLineTo  = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex+2)));
  2498. }
  2499. else {
  2500. m_ptLineFrom = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex)));
  2501. m_ptLineTo = CPoint(_cyTextMargin, CXTEXTMARGIN + _CalcTextWidth(m_strBtn.Left(nIndex+2)));
  2502. }
  2503. }
  2505. //******************************************************************
  2506. void CMenuButton::Layout(CPoint point, BOOL bHorz)
  2507. {
  2508. if (bHorz)
  2509. m_fsState |= MISTATE_HORZ;
  2510. else
  2511. m_fsState &= ~MISTATE_HORZ;
  2513. if (m_fsState & MISTATE_HIDDEN) {
  2514. m_rcItem.SetRectEmpty();
  2515. return;
  2516. }
  2518. if (bHorz) {
  2519. m_rcItem = CRect(point, m_sizeHorz);
  2520. }
  2521. else {
  2522. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  2523. }
  2524. }
  2526. //******************************************************************
  2527. void CMenuButton::Update(CDC* pDC)
  2528. {
  2529. if (m_fsState & MISTATE_HIDDEN)
  2530. return;
  2532. // clean background
  2533. COLORREF clr = GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style );
  2534. pDC->FillSolidRect(m_rcItem, clr);
  2536. if (m_fsState & MISTATE_HOT){
  2537. if (m_bt.IsWindowVisible()) m_bt.ShowWindow(SW_HIDE);
  2538. DrawHot(pDC);
  2539. }
  2540. else if (m_fsState & MISTATE_PRESSED){
  2541. if (m_bt.IsWindowVisible()) m_bt.ShowWindow(SW_HIDE);
  2542. DrawPressed(pDC);
  2543. }
  2544. else {
  2545. DrawNone(pDC);
  2546. }
  2547. }
  2549. //*********************************************************
  2550. void CMenuButton::TrackPopup(CWnd* pBar, CWnd* pWndSentCmd)
  2551. {
  2552. LTRACE(_T("CMenuButton::TrackPopupn"));
  2553. ASSERT_VALID(pBar);
  2554. ASSERT(!(m_fsState & MISTATE_HIDDEN));
  2555. pMenuBar = STATIC_DOWNCAST(CMenuBar, pBar);
  2556. ASSERT_VALID(pMenuBar);
  2558. // "! menu" (no sub menu)
  2559. if (!m_hSubMenu) {
  2560. ASSERT(m_nID != -1);
  2561. pWndSentCmd->SendMessage(WM_COMMAND, (WPARAM)m_nID, (LPARAM)pBar->GetSafeHwnd());
  2562. return;
  2563. }
  2565. CRect rcItem(m_rcItem); pMenuBar->ClientToScreen(rcItem);
  2566. UINT fuFlags; TPMPARAMS tpm;
  2567. CPoint pt = _ComputeMenuTrackPoint(rcItem, pMenuBar->GetBarStyle(), fuFlags, tpm);
  2569. if (m_hSubMenu == pMenuBar->m_hWindowMenu)
  2570. _bWindowMenuSendCmd = TRUE;
  2571. else
  2572. _bWindowMenuSendCmd = FALSE;
  2574. if (pMenuBar->GetBarStyle() & CBRS_ORIENT_HORZ)
  2575. {
  2576. pt.x+=1; pt.y-=2;
  2577. }
  2578. else
  2579. {
  2580. pt.x-=2; pt.y+=2;
  2581. }
  2582. ::TrackPopupMenuEx(m_hSubMenu, fuFlags,
  2583. pt.x, pt.y, pWndSentCmd->GetSafeHwnd(), &tpm);
  2584. gbintHorz=-1;
  2585. rcMenu.SetRectEmpty();
  2587. }
  2589. //****************************************************************
  2590. void CMenuButton::DrawHorzText(CDC* pDC, CPoint ptOffset)
  2591. {
  2592. COLORREF clr = (m_fsState & MISTATE_INACTIVE) ? 
  2593. ::GetSysColor(COLOR_GRAYTEXT) : ::GetSysColor(COLOR_MENUTEXT);
  2594. pDC->SetTextColor(clr);
  2596. CRect rcBtn = m_rcItem;
  2597. rcBtn.right-=1;
  2598. pDC->SetBkMode(TRANSPARENT);
  2599. CFont* pOldFont = pDC->SelectObject(&_fontHorzMenu);
  2600. // I know precise text size, but better to leave this job to Windows
  2601. // *****fixed by andi, thanks!*****
  2602. ptOffset.y-=1;
  2603. ptOffset.x+=2;
  2604. pDC->DrawText(m_strBtn, rcBtn + ptOffset,
  2605. DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  2606. pDC->SelectObject(pOldFont);
  2607. gbintHorz=0;
  2608. rcMenu=rcBtn;
  2609. rcMenu.right-=4;
  2611. }
  2613. //******************************************************************
  2614. void CMenuButton::DrawVertText(CDC* pDC, CPoint ptOffset)
  2615. {
  2616. COLORREF clr = (m_fsState & MISTATE_INACTIVE) ? 
  2617. ::GetSysColor(COLOR_GRAYTEXT) : ::GetSysColor(COLOR_MENUTEXT);
  2618. pDC->SetTextColor(clr);
  2620. CRect rcBtn = m_rcItem;
  2621. int nLength = m_strBtn.GetLength();
  2622. int nIndex = m_strBtn.Find('&');
  2623. CString strBtn = m_strBtn.Left(nIndex) + m_strBtn.Right(nLength - (nIndex+1));
  2625. // fixed for WinNT. *****fixed by Simon, thanks!*****
  2626. int iGraphicsMode = ::GetGraphicsMode(pDC->m_hDC);
  2627. ::SetGraphicsMode(pDC->m_hDC, GM_ADVANCED);
  2628. pDC->SetBkMode(TRANSPARENT);
  2629. CFont* pOldFont = pDC->SelectObject(&_fontVertMenu);
  2630. // I know precise text size
  2631. CRect rcString = CRect(
  2632. CPoint(rcBtn.right - _cyTextMargin, rcBtn.top + CXTEXTMARGIN), m_sizeHorz);
  2633. pDC->DrawText(strBtn, rcString + ptOffset,
  2634. DT_SINGLELINE | DT_NOCLIP | DT_NOPREFIX);// don't forget DT_NOCLIP
  2635. gbintHorz=1;
  2636. rcMenu=rcBtn;
  2637. rcMenu.bottom-=3;
  2638. pDC->SelectObject(pOldFont);
  2640. // CDC::DrawText is poor, so we have to draw vertical line by ourselves
  2641. CPen pen(PS_SOLID, 0, clr);
  2642. CPen* pOldPen = pDC->SelectObject(&pen);
  2643. rcBtn.left-=2;
  2644. pDC->MoveTo(rcBtn.TopLeft() + m_ptLineFrom + ptOffset);
  2645. pDC->LineTo(rcBtn.TopLeft() + m_ptLineTo + ptOffset);
  2647. pDC->SelectObject(pOldPen);
  2648. ::SetGraphicsMode( pDC->m_hDC, iGraphicsMode );
  2649. }
  2651. //******************************************************************
  2652. void CMenuButton::DrawButton(CDC* pDC,WORD wState)
  2653. {
  2655. CBrush cblu;
  2656. CRect rcBtn =m_rcItem;
  2657. if (dSt & CBRS_ORIENT_HORZ )
  2658. rcBtn.right-=4;
  2659. else
  2660. rcBtn.bottom-=2;
  2662. if (wState & BDR_RAISEDINNER)
  2663. pDC->Draw3dRect(rcBtn,m_dw.GetRGBCaptionXP(),m_dw.GetRGBCaptionXP());
  2664. else
  2665. {
  2666. if (dSt & CBRS_ORIENT_HORZ )
  2667. rcBtn.bottom+=1;
  2668. else
  2669. rcBtn.bottom-=1;
  2670. COLORREF ColBorder;
  2671. if (GuiDrawLayer::m_Style==GUISTYLE_XP)
  2672. ColBorder = GuiDrawLayer::GetRGBMenu();
  2673. else
  2674. ColBorder=GuiDrawLayer::GetRGBColorShadow(GuiDrawLayer::m_Style);
  2676. pDC->Draw3dRect(rcBtn,ColBorder,ColBorder);
  2678. if (dSt & CBRS_ORIENT_HORZ )
  2679. rcBtn.bottom-=1;
  2680. else
  2681. rcBtn.bottom+=1;
  2682. if (GuiDrawLayer::m_Style == GUISTYLE_2003)
  2683. {
  2684. CRect rcb=rcBtn;
  2686. if (dSt & CBRS_ORIENT_HORZ)
  2687. {
  2689. CGradient M(CSize(rcb.Width(),rcb.Height()));
  2690. M.PrepareVertical(pDC,GuiDrawLayer::m_Style);
  2691. M.Draw(pDC,rcb.left+1,rcb.top+1,0,0,rcb.Width()-2,rcb.Height(),SRCCOPY);
  2693. }
  2694. else
  2695. {
  2696. CGradient M(CSize(rcb.Width(),rcb.Height()));
  2697. M.PrepareHorizontal(pDC,GuiDrawLayer::m_Style);
  2698. M.Draw(pDC,rcb.left+1,rcb.top+1,0,0,rcb.Width(),rcb.Height()-3,SRCCOPY);
  2699. }
  2701. }
  2702. COLORREF ColB = GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style);
  2703. CPen pen(PS_SOLID, 0, ColB);
  2704. CPen* pOldPen = pDC->SelectObject(&pen);
  2705. pDC->MoveTo(rcBtn.left, rcBtn.bottom);
  2706. pDC->LineTo(rcBtn.right, rcBtn.bottom);
  2707. COLORREF ColA = GetSysColor(COLOR_WINDOW);
  2709. CRect rect = rcBtn;
  2710. int X,Y;
  2711. X=Y=0;
  2712. int winH = rect.Height(); 
  2713. int winW = rect.Width();
  2714. if (dSt & CBRS_ORIENT_HORZ )
  2715. { 
  2717. rect.right+=4;
  2718. // Simulate a shadow on right edge... 
  2719. for (X=1; X<=4 ;X++)
  2720. { 
  2721.   for (Y=0; Y<4 ;Y++)
  2722. pDC->SetPixel(rect.right-X,Y+rect.top, ColB );
  2723.   for (Y=4; Y<8 ;Y++)
  2724.   pDC->SetPixel(rect.right-X,Y+rect.top,GuiDrawLayer::DarkenColor(3 * X * (Y - 3), ColB)) ;
  2725.   for (Y=8; Y<=(winH-1) ;Y++)
  2726. pDC->SetPixel(rect.right - X, Y+rect.top, GuiDrawLayer::DarkenColor(15 * X, ColB) );
  2727. }
  2728. }
  2729. else
  2730. {
  2731.   rect.bottom+=2;
  2732.   for(Y=1; Y<=3 ;Y++)
  2733.   {
  2734. for(X=0; X<=3 ;X++)
  2735. {
  2736.   pDC->SetPixel(X,rect.bottom-Y,pDC->GetPixel(rect.left+X,rect.bottom-Y)) ;
  2737. }
  2738. for(X=4; X<=7 ;X++)
  2739. {
  2740.   COLORREF c = pDC->GetPixel(rect.left + X, rect.bottom - Y) ;
  2741.   pDC->SetPixel(X, rect.bottom - Y, GuiDrawLayer::DarkenColor(3 * (X - 3) * Y, c)) ;
  2742. }
  2743. for(X=8; X<=(winW-2) ;X++)
  2744. {
  2745.   COLORREF  c = pDC->GetPixel(rect.left + X, rect.bottom - Y); 
  2746.   pDC->SetPixel(X, rect.bottom- Y, GuiDrawLayer::DarkenColor(15 * Y, c)) ;
  2747. }
  2748.   }   
  2749.   
  2751. }
  2752. pDC->SelectObject(pOldPen);
  2754. }
  2755. rcBtn.DeflateRect(1,1);
  2756. if (wState & BDR_RAISEDINNER)
  2757. {
  2759. cblu.CreateSolidBrush(m_dw.GetRGBFondoXP());
  2760. pDC->FillRect(rcBtn,&cblu);
  2761. }
  2763. }
  2764. //******************************************************************
  2765. void CMenuButton::DrawHot(CDC* pDC)
  2766. {
  2767. if (m_fsState & MISTATE_HORZ) {
  2769. // draw pressed button
  2770. dSt=CBRS_ORIENT_HORZ;
  2771. DrawButton(pDC,BDR_RAISEDINNER);
  2772. //pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2773. DrawHorzText(pDC,CPoint(-1, 1));
  2774. }
  2775. else {
  2776. dSt=CBRS_ORIENT_VERT;
  2777. DrawButton(pDC,BDR_RAISEDINNER);
  2778. //pDC->DrawEdge(m_rcItem, BDR_RAISEDINNER, BF_RECT);
  2779. DrawVertText(pDC);
  2780. }
  2781. }
  2783. //******************************************************************
  2784. void CMenuButton::DrawPressed(CDC* pDC)
  2785. {
  2786. if (m_fsState & MISTATE_HORZ) {
  2787. DrawButton(pDC,BDR_SUNKENOUTER);
  2788. //pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);// draw pressed button
  2789. DrawHorzText(pDC, CPoint(-1, 1));
  2790. }
  2791. else {
  2792. DrawButton(pDC,BDR_SUNKENOUTER);
  2793. //pDC->DrawEdge(m_rcItem, BDR_SUNKENOUTER, BF_RECT);
  2794. DrawVertText(pDC, CPoint(1, 1));
  2795. }
  2797. }
  2798. //--------------------------------
  2800. //--------------------------------
  2801. //******************************************************************
  2802. void CMenuButton::DrawNone(CDC* pDC)
  2803. {
  2804. CRect rcBtn = m_rcItem;
  2805. if (!m_bt.IsWindowVisible())
  2806. m_bt.ShowWindow(SW_SHOW);
  2807. m_bt.MoveWindow(rcBtn);
  2809. if (m_fsState & MISTATE_HORZ) {
  2810. m_bt.SetHorzVert();
  2811. }
  2812. else {
  2813. CRect rcBtn = m_rcItem;
  2814. m_bt.SetHorzVert(FALSE);
  2815. }
  2818. }
  2821. void CMenuButton::UpdateButtons()
  2822. {
  2823. if (m_bt.IsWindowVisible())
  2824. {
  2825. CRect rcBtn = m_rcItem;
  2826. m_bt.ShowWindow(SW_SHOW);
  2827. m_bt.MoveWindow(rcBtn);
  2828. m_bt.Invalidate();
  2829. m_bt.UpdateWindow();
  2830. }
  2831. }
  2832. //******************************************************************
  2833. //////////////////////////////////////////////////////////////////////
  2834. // CMenuIcon class
  2835. CMenuIcon::CMenuIcon(CWnd* pMenuBar)
  2836. {
  2837. ASSERT_VALID(pMenuBar);
  2838. m_pMenuBar = pMenuBar;
  2839. m_hIconWinLogo = AfxGetApp()->LoadStandardIcon(IDI_WINLOGO);
  2840. ASSERT(m_hIconWinLogo);
  2841. m_btnIcon.Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2842. CRect(0,0,0,0), pMenuBar, 0x999);
  2843. m_btnIcon.ShowWindow(SW_HIDE);
  2844. m_btnIcon.SetScrollButton();
  2845. m_fsStyle |= MISTYLE_TRACKABLE;
  2846. m_fsState |= MISTATE_HIDDEN;
  2847. m_sizeHorz = CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON));
  2848. }
  2849. //******************************************************************
  2850. CMenuIcon::~CMenuIcon()
  2851. {
  2852. if (m_hIconWinLogo != NULL) 
  2853. ::FreeResource(m_hIconWinLogo);
  2855. }
  2856. //******************************************************************
  2857. void CMenuIcon::OnActivateChildWnd()
  2858. {
  2859. //LTRACE(_T("CMenuIcon::OnActivateChildWndn"));
  2861. ASSERT_VALID(m_pMenuBar);
  2863. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2864. ASSERT_VALID(pFrame);
  2865. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2866. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2867. ASSERT(::IsWindow(hWndMDIClient));
  2869. BOOL bMaximized = FALSE;
  2870. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2871. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2873. if (bMaximized == FALSE) {
  2874. //LTRACE(_T("    not maximizedn"));
  2875. m_fsState |= MISTATE_HIDDEN;
  2876. m_btnIcon.ShowWindow(SW_HIDE);
  2877. }
  2878. else {
  2879. //LTRACE(_T("    maximizedn"));
  2880. m_fsState &= ~MISTATE_HIDDEN;
  2881. m_btnIcon.SethIcon(m_hDocIcon);
  2882. m_btnIcon.ShowWindow(SW_SHOW);
  2883. }
  2885. m_hDocIcon = (HICON)::GetClassLong(hWndChild, GCL_HICONSM);
  2887. if (m_hDocIcon == NULL) // if hWndChild doesn't have own icon
  2888. m_hDocIcon = m_hIconWinLogo;
  2889. }
  2891. //******************************************************************
  2892. void CMenuIcon::Update(CDC* pDC)
  2893. {
  2894. if (m_fsState & MISTATE_HIDDEN)
  2895. return;
  2897. ASSERT(m_hDocIcon);
  2898. ASSERT(m_rcItem.IsRectEmpty() == FALSE);
  2899. m_btnIcon.MoveWindow(m_rcItem);
  2900. ::DrawIconEx(pDC->m_hDC, m_rcItem.left, m_rcItem.top, m_hDocIcon,
  2901. m_rcItem.Width(), m_rcItem.Height(), 0, NULL, DI_NORMAL);
  2902. }
  2905. void CMenuIcon::UpdateButtons()
  2906. {
  2908. }
  2909. //******************************************************************
  2910. void CMenuIcon::TrackPopup(CWnd* pBar, CWnd* pWndSentCmd)
  2911. {
  2912. ASSERT(!(m_fsState & MISTATE_HIDDEN));
  2913. ASSERT_VALID(m_pMenuBar);
  2915. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  2916. ASSERT_VALID(pFrame);
  2917. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  2918. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  2919. ASSERT(::IsWindow(hWndMDIClient));
  2921. BOOL bMaximized = FALSE;
  2922. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  2923. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  2924. ASSERT(bMaximized);
  2925. HMENU hSysMenu = ::GetSystemMenu(hWndChild, FALSE);
  2926. ASSERT(::IsMenu(hSysMenu));
  2927. CControlBar* pControlBar = STATIC_DOWNCAST(CControlBar, m_pMenuBar);
  2928. ASSERT_VALID(pControlBar);
  2929. CRect rcItem(m_rcItem); m_pMenuBar->ClientToScreen(rcItem);
  2931. UINT fuFlags; TPMPARAMS tpm;
  2932. bActivSystemMenu=TRUE;
  2933. CPoint pt = _ComputeMenuTrackPoint(rcItem, pControlBar->GetBarStyle(), fuFlags, tpm);
  2934. gbintHorz=-1;
  2935. CRect rcBtn=CRect(0,0,0,0);
  2936. CRect rcMenu=rcBtn;
  2938. ::TrackPopupMenuEx(hSysMenu, fuFlags, pt.x, pt.y,m_pMenuBar->GetSafeHwnd(), &tpm);
  2940. bActivSystemMenu=FALSE;
  2941. }
  2943. //******************************************************************
  2944. void CMenuIcon::Layout(CPoint point, BOOL bHorz)
  2945. {
  2946. if (bHorz)
  2947. m_fsState |= MISTATE_HORZ;
  2948. else
  2949. m_fsState &= ~MISTATE_HORZ;
  2951. if (m_fsState & MISTATE_HIDDEN) {
  2952. m_rcItem.SetRectEmpty();
  2953. return;
  2954. }
  2956. m_rcItem = CRect(point, CSize(::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON)));
  2957. }
  2959. //******************************************************************
  2960. //////////////////////////////////////////////////////////////////////
  2961. // CMenuControl class
  2962. #define CX_GAP_CAPTION 2
  2965. CMenuControl::CMenuControl(CWnd* pMenuBar)
  2966. {
  2967. ASSERT_VALID(pMenuBar);
  2968. m_pMenuBar = pMenuBar;
  2969. m_bDown = FALSE;
  2970. m_nTracking = -1;
  2972. m_fsState |= MISTATE_HIDDEN;
  2974. if (!m_img.Create(IDB_GUI_MDIICONS,9,3,RGB(255,0,255)))
  2975. {
  2976. TRACE0("error");
  2977. }
  2978. m_arrButton[2].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2979. CRect(0,0,0,0),m_pMenuBar, SC_CLOSE);
  2980. m_arrButton[2].SethIcon(m_img.ExtractIcon(2));
  2981. m_arrButton[2].SetToolTip("Close");
  2982. m_arrButton[2].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  2983. m_arrButton[2].ShowDark(FALSE);
  2984. m_arrButton[1].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2985. CRect(0,0,0,0),m_pMenuBar, SC_RESTORE);
  2986. m_arrButton[1].SethIcon(m_img.ExtractIcon(1));
  2987. m_arrButton[1].SetToolTip("Restore");
  2988. m_arrButton[1].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  2989. m_arrButton[1].ShowDark(FALSE);
  2990. m_arrButton[0].Create(_T(""), WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_OWNERDRAW, 
  2991. CRect(0,0,0,0),m_pMenuBar,SC_MINIMIZE);
  2992. m_arrButton[0].SethIcon(m_img.ExtractIcon(0));
  2993. m_arrButton[0].SetToolTip("Minimize");
  2994. m_arrButton[0].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  2995. m_arrButton[0].ShowDark(FALSE);
  2996. CSize sizeCaption = GetCaptionSize();
  2997. m_sizeHorz = CSize(sizeCaption.cx*3 + CX_GAP_CAPTION + 1, sizeCaption.cy + 2);
  2999. }
  3001. void CMenuControl::SetColorButton(COLORREF clrBtn)
  3002. {
  3003. m_arrButton[2].SetColor(clrBtn);
  3004. m_arrButton[1].SetColor(clrBtn);
  3005. m_arrButton[0].SetColor(clrBtn);
  3006. }
  3008. //******************************************************************
  3009. void CMenuControl::Update(CDC* pDC)
  3010. {
  3011. // do nothing
  3013. }
  3016. void CMenuControl::UpdateButtons()
  3017. {
  3019. }
  3020. //******************************************************************
  3021. void CMenuControl::Layout(CPoint point, BOOL bHorz)
  3022. {
  3023. //LTRACE(_T("CMenuControl::Layout bHorz:%dn"), bHorz);
  3025. if (bHorz)
  3026. m_fsState |= MISTATE_HORZ;
  3027. else
  3028. m_fsState &= ~MISTATE_HORZ;
  3030. if (m_fsState & MISTATE_HIDDEN) {
  3031. m_rcItem.SetRectEmpty();
  3032. return;
  3033. }
  3035. // just layout easily
  3036. if (bHorz) {
  3037. m_rcItem = CRect(point, m_sizeHorz);
  3038. }
  3039. else {
  3040. m_rcItem = CRect(point, CSize(m_sizeHorz.cy, m_sizeHorz.cx));
  3041. }
  3042. }
  3044. //******************************************************************
  3045. void CMenuControl::DelayLayoutAndDraw(CDC* pDC, CSize sizeBar,BOOL bFlota)
  3046. {
  3047. CSize sizeCaption = GetCaptionSize();
  3048. int cxCaption = sizeCaption.cx;
  3049. int cyCaption = sizeCaption.cy;
  3051. if (m_fsState & MISTATE_HORZ) {
  3052. CRect rcCaption;
  3053. rcCaption.right = !bFlota?sizeBar.cx-5:sizeBar.cx;
  3054. rcCaption.bottom = sizeBar.cy-3;
  3055. rcCaption.left = rcCaption.right - cxCaption;
  3056. rcCaption.top = (rcCaption.bottom - cyCaption);
  3058. m_arrCaption[0] = rcCaption;
  3060. rcCaption -= CPoint(cxCaption+CX_GAP_CAPTION, 0);
  3061. m_arrCaption[1] = rcCaption;
  3063. rcCaption -= CPoint(cxCaption, 0);
  3064. m_arrCaption[2] = rcCaption;
  3066. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  3067. m_arrCaption[0].right, m_arrCaption[0].bottom);
  3068. }
  3069. else {
  3070. CRect rcCaption;
  3071. rcCaption.left = 0;
  3072. rcCaption.bottom = sizeBar.cy-5;
  3073. rcCaption.right = rcCaption.left + cxCaption;
  3074. rcCaption.top = rcCaption.bottom - cyCaption;
  3076. m_arrCaption[0] = rcCaption;
  3078. rcCaption -= CPoint(0, cyCaption+CX_GAP_CAPTION);
  3079. m_arrCaption[1] = rcCaption;
  3081. rcCaption -= CPoint(0, cyCaption);
  3082. m_arrCaption[2] = rcCaption;
  3084. m_rcItem = CRect(m_arrCaption[2].left, m_arrCaption[2].top,
  3085. m_arrCaption[0].right, m_arrCaption[0].bottom);
  3086. }
  3088. if (m_fsState & MISTATE_HIDDEN) {
  3089. //LTRACE(_T("    hiddenn"));
  3090. return;
  3091. }
  3094. // draw frame controls
  3095. DrawControl();
  3097. }
  3099. //******************************************************************
  3102. //******************************************************************
  3103. void CMenuControl::DrawControl()
  3104. {
  3105. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  3106. ASSERT_VALID(pFrame);
  3107. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  3108. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  3109. ASSERT(::IsWindow(hWndMDIClient));
  3110. BOOL bMaximized = FALSE;
  3111. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  3112. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  3114. if (bMaximized == TRUE) {
  3115. m_arrButton[2].MoveWindow(m_arrCaption[0]);
  3116. if (!(m_fsState & MISTATE_HORZ)) m_arrButton[0].SetSimpleButton();
  3117. else m_arrButton[2].SetSimpleButton(FALSE);
  3118. m_arrButton[1].MoveWindow(m_arrCaption[1]);
  3119. if (!(m_fsState & MISTATE_HORZ)) m_arrButton[1].SetSimpleButton();
  3120. else m_arrButton[1].SetSimpleButton(FALSE);
  3121. m_arrButton[0].MoveWindow(m_arrCaption[2]);
  3122. if (!(m_fsState & MISTATE_HORZ)) m_arrButton[2].SetSimpleButton();
  3123. else m_arrButton[0].SetSimpleButton(FALSE);
  3125. }
  3126. /* m_arrButton[2].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  3127. m_arrButton[1].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  3128. m_arrButton[0].SetColor(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  3129. */
  3130. m_arrButton[2].Invalidate();
  3131. m_arrButton[1].Invalidate();
  3132. m_arrButton[0].Invalidate();
  3133. m_arrButton[2].UpdateWindow();
  3134. m_arrButton[1].UpdateWindow();
  3135. m_arrButton[0].UpdateWindow();
  3136. }
  3138. //******************************************************************
  3141. //******************************************************************
  3142. void CMenuControl::OnActivateChildWnd()
  3143. {
  3144. //LTRACE(_T("CMenuControl::OnActivateChildWndn"));
  3145. ASSERT_VALID(m_pMenuBar);
  3147. CWnd* pFrame = m_pMenuBar->GetTopLevelFrame();
  3148. ASSERT_VALID(pFrame);
  3149. CMDIFrameWnd* pMDIFrame = STATIC_DOWNCAST(CMDIFrameWnd, pFrame);
  3150. HWND hWndMDIClient = pMDIFrame->m_hWndMDIClient;
  3151. ASSERT(::IsWindow(hWndMDIClient));
  3153. BOOL bMaximized = FALSE;
  3154. HWND hWndChild = (HWND)::SendMessage(hWndMDIClient,
  3155. WM_MDIGETACTIVE, 0, (LPARAM)&bMaximized);
  3157. if (bMaximized == FALSE) {
  3158. m_fsState |= MISTATE_HIDDEN;
  3159. }
  3160. else {
  3161. m_fsState &= ~MISTATE_HIDDEN;
  3162. }
  3163. }
  3167. //******************************************************************
  3168. CSize CMenuControl::GetCaptionSize()
  3169. {
  3170. NONCLIENTMETRICS info; info.cbSize = sizeof(info);
  3171. ::SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(info), &info, 0);
  3173. // due to my own feeling
  3174. return CSize(info.iMenuHeight - info.iBorderWidth*2, info.iMenuHeight - info.iBorderWidth*4);
  3175. }
  3177. //******************************************************************
  3178. #if _MFC_VER < 0x0600
  3179. void CMenuBar::SetBorders(int cxLeft, int cyTop, int cxRight, int cyBottom)
  3180. {
  3181. ASSERT(cxLeft >= 0);
  3182. ASSERT(cyTop >= 0);
  3183. ASSERT(cxRight >= 0);
  3184. ASSERT(cyBottom >= 0);
  3186. m_cxLeftBorder = cxLeft;
  3187. m_cyTopBorder = cyTop;
  3188. m_cxRightBorder = cxRight;
  3189. m_cyBottomBorder = cyBottom;
  3190. }
  3191. #endif
  3192. //******************************************************************
  3193. // input CRect should be client rectangle size
  3194. void CMenuBar::_CalcInsideRect(CRect& rect, BOOL bHorz) const
  3195. {
  3196. LTRACE(_T("CMenuBar::_CalcInsideRectn"));
  3197. ASSERT_VALID(this);
  3198. DWORD dwStyle = m_dwStyle;
  3200. if (dwStyle & CBRS_BORDER_LEFT)
  3201. rect.left += cxBorder2;
  3202. if (dwStyle & CBRS_BORDER_TOP)
  3203. rect.top += cyBorder2;
  3204. if (dwStyle & CBRS_BORDER_RIGHT) 
  3205. rect.right -= cxBorder2;
  3206. if (dwStyle & CBRS_BORDER_BOTTOM)
  3207. rect.bottom -= cyBorder2;
  3209. BOOL bDrawGripper = !(m_dwStyle & CBRS_FLOATING) && (m_dwExStyle & CBRS_GRIPPER);
  3211. // inset the top and bottom.
  3212. if (bHorz)
  3213. {
  3214. rect.left += m_cxLeftBorder;
  3215. rect.top += m_cyTopBorder;
  3216. rect.right -= m_cxRightBorder;
  3217. rect.bottom -= m_cyBottomBorder;
  3218. if (bDrawGripper)
  3219. rect.left += CX_GRIPPER_ALL;
  3220. }
  3221. else
  3222. {
  3223. rect.left += m_cyTopBorder;
  3224. rect.top += m_cxLeftBorder;
  3225. rect.right -= m_cyBottomBorder;
  3226. rect.bottom -= m_cxRightBorder;
  3227. if (bDrawGripper)
  3228. rect.top += CY_GRIPPER_ALL;
  3229. }
  3230. }
  3232. //******************************************************************
  3233. /////////////////////////////////////////////////////////////////////////////
  3234. // CMenuDockBar implementation
  3235. // a little changed from CDockBar implementation
  3237. static BOOL _IsMenuBar(int nPos, CPtrArray& arrBars)
  3238. {
  3239. if (nPos < arrBars.GetSize()) {
  3240. CControlBar* pBar = (CControlBar*)arrBars[nPos];
  3241. if (pBar && pBar->GetDlgCtrlID() == AFX_IDW_MENUBAR)
  3242. return TRUE;
  3243. else
  3244. return FALSE;
  3245. }
  3246. else
  3247. return FALSE;
  3248. }
  3251. //******************************************************************
  3252. // ERNESTO
  3253. BOOL CMenuBar::SetSubMenuText( int id, TCHAR *szText)
  3254. {
  3255. BOOL ret= FALSE;
  3256. if( id >= m_arrItem.GetSize() )
  3257. return FALSE;
  3258. CMenuButton *pMenu = (CMenuButton*)m_arrItem.GetAt(id);
  3259. if( pMenu)
  3260. {
  3261. pMenu->SetText(szText);
  3262. ret = TRUE;
  3263. }
  3264. else 
  3265. ret = FALSE;
  3266. return ret;
  3267. }
  3268. //******************************************************************
  3271. void CMenuBar::OnPaint()
  3272. {
  3273. CPaintDC pDC(this); // device context for painting
  3274. // TODO: Add your message handler code here
  3275. // Do not call CControlBar::OnPaint() for painting messages
  3276. CRect rect; GetClientRect(rect);
  3277. BOOL bFlota=m_dwStyle & CBRS_FLOATING;
  3278. // draw items
  3279. m_sizex=0;
  3280. CRect m_rect;
  3281. GetClientRect(m_rect);
  3282. CBrush cbr;
  3283. cbr.CreateSolidBrush(GuiDrawLayer::GetRGBColorFace(GuiDrawLayer::m_Style));
  3284. pDC.FillRect(m_rect,&cbr);
  3286. for (int i = 0; i < m_arrItem.GetSize(); ++i) {
  3287. m_arrItem[i]->Update(&pDC);
  3288. if (m_bChangeState)
  3289. m_arrItem[i]->UpdateButtons();
  3290. }
  3291. if (m_bChangeState)
  3292. m_bChangeState=FALSE;
  3294. // delay draw captions 
  3295. if (m_pMenuControl) {
  3296. if (IsFloating()) {
  3297. m_pMenuControl->DelayLayoutAndDraw(&pDC, rect.Size(),bFlota);
  3300. }
  3301. else {
  3302. if (m_dwStyle & CBRS_ORIENT_HORZ)
  3303. m_pMenuControl->DelayLayoutAndDraw(&pDC, CSize(GetClipBoxLength(TRUE), rect.Height()),bFlota);
  3304. else
  3305. m_pMenuControl->DelayLayoutAndDraw(&pDC, CSize(rect.Width(), GetClipBoxLength(FALSE)),bFlota);
  3306. }
  3307. }
  3309. }