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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTPMenuBar.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：21k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTPMenuBar.cpp：源码内容
  1. // XTPMenuBar.cpp : implementation of the CXTPMenuBar class.
  2. //
  3. // This file is a part of the XTREME COMMANDBARS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Resource.h"
  24. #include "Common/XTPResourceManager.h"
  25. #include "Common/XTPImageManager.h"
  26. #include "Common/XTPVC50Helpers.h"
  27. #include "Common/XTPIntel80Helpers.h"
  28. #include "Common/XTPHookManager.h"
  30. #include "XTPMenuBar.h"
  31. #include "XTPControls.h"
  32. #include "XTPControl.h"
  33. #include "XTPControlButton.h"
  34. #include "XTPControlPopup.h"
  35. #include "XTPPaintManager.h"
  36. #include "XTPCommandBars.h"
  37. #include "XTPMouseManager.h"
  38. #include "XTPPopupBar.h"
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  46. #define TID_REFRESH 12223
  48. #ifndef OIC_WINLOGO
  49. #define OIC_WINLOGO         32517
  50. #endif
  53. CXTPMenuBarMDIMenuInfo::CXTPMenuBarMDIMenuInfo(CXTPCommandBars* pCommandBars, UINT nIDResource)
  54. {
  55. ASSERT(pCommandBars);
  56. ASSERT(nIDResource != 0);
  58. m_pControls = new CXTPControls;
  59. m_pControls->SetCommandBars(pCommandBars);
  61. m_nIDResource = nIDResource;
  62. m_bChanged = FALSE;
  64. m_hIcon = AfxGetApp()->LoadIcon(nIDResource);
  66. #pragma warning(disable:4510)
  67. #pragma warning(disable:4610)
  69. POSITION pos = AfxGetApp()->GetFirstDocTemplatePosition();
  70. while (pos)
  71. {
  72. CDocTemplate* pDocTemplate = AfxGetApp()->GetNextDocTemplate(pos);
  74. USES_PROTECTED_ACCESS(CXTPMenuBarMDIMenuInfo, CDocTemplate, UINT, m_nIDResource);
  75. UINT nID = PROTECTED_ACCESS(CDocTemplate, pDocTemplate, m_nIDResource);
  77. if (nIDResource == nID)
  78. {
  79. pDocTemplate->GetDocString(m_strTitle, CDocTemplate::docName);
  80. pDocTemplate->GetDocString(m_strDescription, CDocTemplate::regFileTypeName);
  81. break;
  82. }
  83. }
  84. }
  86. CXTPMenuBarMDIMenuInfo::~CXTPMenuBarMDIMenuInfo()
  87. {
  88. m_pControls->InternalRelease();
  89. }
  91. //////////////////////////////////////////////////////////////////////////
  93. CXTPMenuBarMDIMenus::CXTPMenuBarMDIMenus(CXTPMenuBar* pMenuBar)
  94. : m_pMenuBar(pMenuBar)
  95. {
  96. }
  98. CXTPMenuBarMDIMenus::~CXTPMenuBarMDIMenus()
  99. {
  100. RemoveAll();
  101. }
  103. void CXTPMenuBarMDIMenus::RemoveAll()
  104. {
  105. POSITION pos = m_mapMenus.GetStartPosition();
  106. while (pos)
  107. {
  108. UINT nIDCommand;
  109. CXTPMenuBarMDIMenuInfo* pInfo;
  110. m_mapMenus.GetNextAssoc(pos, nIDCommand, pInfo);
  111. pInfo->InternalRelease();
  112. }
  113. m_mapMenus.RemoveAll();
  114. }
  116. void CXTPMenuBarMDIMenus::Remove(UINT nIDResource)
  117. {
  118. CXTPMenuBarMDIMenuInfo* pInfo = Lookup(nIDResource);
  119. if (pInfo)
  120. {
  121. m_mapMenus.RemoveKey(nIDResource);
  122. pInfo->InternalRelease();
  123. }
  124. }
  126. void CXTPMenuBarMDIMenus::SetAt(UINT nIDResource, CXTPMenuBarMDIMenuInfo* pInfo)
  127. {
  128. ASSERT(pInfo);
  129. ASSERT(!Lookup(nIDResource));
  131. m_mapMenus.SetAt(nIDResource, pInfo);
  132. }
  134. CXTPMenuBarMDIMenuInfo* CXTPMenuBarMDIMenus::Lookup(UINT nIDResource) const
  135. {
  136. CXTPMenuBarMDIMenuInfo* pInfo;
  137. if (!m_mapMenus.Lookup(nIDResource, pInfo))
  138. return NULL;
  140. return pInfo;
  141. }
  143. int CXTPMenuBarMDIMenus::GetCount() const
  144. {
  145. return (int)m_mapMenus.GetCount();
  146. }
  148. POSITION CXTPMenuBarMDIMenus::GetStartPosition() const
  149. {
  150. return m_mapMenus.GetStartPosition();
  151. }
  153. void CXTPMenuBarMDIMenus::GetNextMenu(POSITION& pos, CXTPMenuBarMDIMenuInfo*& pInfo) const
  154. {
  155. UINT nIDResource = 0;
  156. m_mapMenus.GetNextAssoc(pos, nIDResource, pInfo);
  157. }
  160. //////////////////////////////////////////////////////////////////////////
  162. class CXTPMenuBar::CControlMDIButton : public CXTPControlButton
  163. {
  164. public:
  165. CControlMDIButton()
  166. {
  167. m_dwFlags |= xtpFlagRightAlign | xtpFlagSkipFocus | xtpFlagManualUpdate | xtpFlagNoMovable;
  168. }
  169. CSize GetSize(CDC* /*pDC*/)
  170. {
  171. return CSize(16, 16);
  172. };
  173. void SetBeginGroup(BOOL /*bBeginGroup*/)
  174. {
  175. }
  176. void Draw(CDC* pDC);
  177. void OnExecute()
  178. {
  179. HWND hWndChild = ((CXTPMenuBar*)m_pParent)->GetActiveMdiChildWnd();
  180. ASSERT(hWndChild);
  182. UINT nId = m_nId == XTP_ID_MENUBAR_CLOSE ? SC_CLOSE :
  183. m_nId == XTP_ID_MENUBAR_RESTORE ? SC_RESTORE : SC_MINIMIZE;
  185. ::PostMessage(hWndChild, WM_SYSCOMMAND, nId, 0);
  186. }
  187. };
  189. class CXTPMenuBar::CControlMDISysMenuPopup : public CXTPControlPopup
  190. {
  191. class CXTPSysMenuPopupBar : public CXTPPopupBar
  192. {
  193. void UpdateShortcuts()
  194. {
  195. }
  197. };
  199. public:
  200. CControlMDISysMenuPopup(HWND hWndActiveChild, HMENU hDocMenu)
  201. {
  202. m_dwFlags |= xtpFlagManualUpdate | xtpFlagNoMovable;
  203. m_controlType = xtpControlPopup;
  204. m_strCaption = _T("-");
  205. m_hIcon = 0;
  207. m_pCommandBar = new CXTPSysMenuPopupBar();
  208. m_pCommandBar->EnableCustomization(FALSE);
  210. SetMDISysMenu(hWndActiveChild, hDocMenu);
  212. }
  213. void SetMDISysMenu(HWND hWndActiveChild, HMENU hDocMenu)
  214. {
  215. m_hDocMenu = hDocMenu;
  217. HICON hIcon = (HICON)::SendMessage(hWndActiveChild, WM_XTP_GETTABICON, 0, 0);
  219. if (hIcon == NULL) hIcon = (HICON)::SendMessage(hWndActiveChild, WM_GETICON, ICON_SMALL, 0);
  220. if (hIcon == NULL) hIcon = (HICON)::SendMessage(hWndActiveChild, WM_GETICON, ICON_BIG, 0);
  221. if (hIcon == NULL) hIcon = (HICON)(ULONG_PTR)::GetClassLongPtr(hWndActiveChild, GCLP_HICONSM);
  222. if (hIcon == NULL) hIcon = AfxGetApp()->LoadOEMIcon(OIC_WINLOGO);
  224. if (m_hIcon)
  225. {
  226. DestroyIcon(m_hIcon);
  227. m_hIcon = 0;
  228. }
  230. if (hIcon)
  231. m_hIcon = CXTPImageManagerIcon::ScaleToFit(hIcon, CXTPImageManagerIcon::GetExtent(hIcon), 16);
  233. m_pCommandBar->GetControls()->RemoveAll();
  235. CMenu* pMenu = CMenu::FromHandle(hDocMenu);
  237. BOOL bSeparator = FALSE;
  238. for (int i = 0; i < (int)pMenu->GetMenuItemCount(); i++)
  239. {
  240. UINT nItemID = pMenu->GetMenuItemID(i);
  241. if (nItemID == 0)
  242. bSeparator = TRUE;
  243. else
  244. {
  245. CXTPControl* pControl = NULL;
  246. if (nItemID >= 0xF000 && nItemID < 0xF1F0)
  247. {
  248. pControl = (CXTPControl*)CXTPControlButton::CreateObject();
  249. pControl->SetFlags(xtpFlagManualUpdate);
  250. m_pCommandBar->GetControls()->Add(pControl, nItemID);
  252. CString strCaption;
  253. pMenu->GetMenuString(i, strCaption, MF_BYPOSITION);
  254. pControl->SetCaption(strCaption);
  256. CString strDescription;
  257. if (!strDescription.LoadString(ID_COMMAND_FROM_SC(nItemID)))
  258. {
  259. }
  260. pControl->SetDescription(strDescription);
  262. pControl->SetItemDefault((int)::GetMenuDefaultItem(pMenu->m_hMenu, TRUE, GMDI_USEDISABLED) == i);
  265. pControl->SetEnabled(!(pMenu->GetMenuState (i, MF_BYPOSITION) & MF_DISABLED));
  266. }
  267. else
  268. {
  269. pControl = m_pCommandBar->GetControls()->AddMenuItem(pMenu, i);
  271. }
  273. if (pControl && bSeparator)
  274. {
  275. pControl->SetBeginGroup(TRUE);
  276. bSeparator = FALSE;
  277. }
  278. }
  279. }
  282. }
  283. ~CControlMDISysMenuPopup()
  284. {
  285. if (m_hIcon) DestroyIcon(m_hIcon);
  286. }
  287. CSize GetSize(CDC* /*pDC*/)
  288. {
  289. return CSize(16, 16);
  290. };
  291. void Draw(CDC* pDC)
  292. {
  293. if (m_hIcon)
  294. {
  295. pDC->DrawState (GetRect().TopLeft(), CSize(16, 16), m_hIcon, (UINT)DSS_NORMAL, HBRUSH(0));
  296. }
  297. }
  298. void UpdateShadow()
  299. {
  301. }
  302. void AdjustExcludeRect(CRect& rc, BOOL /*bVertical*/)
  303. {
  304. rc.InflateRect(1, 1);
  305. }
  307. public:
  308. HMENU m_hDocMenu;
  309. HICON m_hIcon;
  310. };
  312. void CXTPMenuBar::CControlMDIButton::Draw(CDC* pDC)
  313. {
  314. CFont font;
  315. font.CreatePointFont(MulDiv(80, 96, pDC->GetDeviceCaps(LOGPIXELSX)), _T("Marlett"));
  316. CFont* pFont = pDC->SelectObject(&font);
  317. GetPaintManager()->DrawControlEntry(pDC, this);
  318. pDC->SetTextColor(GetPaintManager()->GetControlTextColor(this));
  319. pDC->DrawText(m_strParameter, m_rcControl, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
  320. pDC->SelectObject(pFont);
  321. }
  324. IMPLEMENT_XTP_COMMANDBAR(CXTPMenuBar, CXTPToolBar)
  326. CXTPMenuBar::CXTPMenuBar()
  327. {
  328. m_barType = xtpBarTypeMenuBar;
  329. m_bMdiApp = FALSE;
  330. m_hWndActiveChild = 0;
  331. m_nIDResource = 0;
  332. m_nIDResourceCurrent = 0;
  334. m_bDirtyMenu = FALSE;
  335. m_hMenuDefault = NULL;
  336. m_bShowExpandButton = FALSE;
  338. m_bCloseable = FALSE;
  340. m_nBarID = XTP_IDR_MENUBAR;
  341. m_dwFlags = xtpFlagAlignAny | xtpFlagFloating | xtpFlagStretched;
  343. m_pMDIMenus = new CXTPMenuBarMDIMenus(this);
  345. EnableAutomation();
  346. }
  348. CXTPMenuBar::~CXTPMenuBar()
  349. {
  350. FreeMDIMenus();
  352. CMDTARGET_RELEASE(m_pMDIMenus);
  354. if (m_hMenuDefault)
  355. {
  356. DestroyMenu(m_hMenuDefault);
  357. }
  358. }
  361. void CXTPMenuBar::SetupHook()
  362. {
  363. m_bMdiApp = GetSite()->IsKindOf(RUNTIME_CLASS(CMDIFrameWnd));
  366. CWnd* pSite = GetSite();
  367. XTPHookManager()->SetHook(pSite->GetSafeHwnd(), this);
  369. CMDIFrameWnd* pMDIFrame = DYNAMIC_DOWNCAST(CMDIFrameWnd, pSite);
  370. if (pMDIFrame)
  371. {
  372. XTPHookManager()->SetHook(pMDIFrame->m_hWndMDIClient, this);
  373. }
  374. }
  376. HWND CXTPMenuBar::GetActiveMdiChildWnd(BOOL* bMaximized)
  377. {
  378. BOOL bMax = FALSE;
  379. if (!m_bMdiApp) return NULL;
  380. CMDIFrameWnd * pFrame = DYNAMIC_DOWNCAST(CMDIFrameWnd, GetSite());
  381. ASSERT_VALID(pFrame);
  382. HWND hWndMdiArea = pFrame->m_hWndMDIClient;
  384. ASSERT(hWndMdiArea && ::IsWindow(hWndMdiArea));
  385. if (!hWndMdiArea)
  386. return 0;
  388. HWND hWnd = (HWND) ::SendMessage(hWndMdiArea, WM_MDIGETACTIVE, 0, (LPARAM)&bMax);
  389. if (!hWnd) bMax = FALSE;
  390. ASSERT(hWnd == NULL || ::IsWindow(hWnd));
  391. if (bMaximized) *bMaximized = bMax;
  392. return hWnd;
  393. }
  396. BOOL CXTPMenuBar::IsOleDocumentActive(HWND hWndActiveChild) const
  397. {
  398. #if _MSC_VER >= 1200 // MFC 6.0
  399. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CFrameWnd, CWnd::FromHandle(hWndActiveChild));
  401. COleDocument* pActiveOleDoc =  DYNAMIC_DOWNCAST(COleDocument,
  402. pFrame && pFrame->GetActiveView() ? pFrame->GetActiveView()->GetDocument() : NULL);
  404. if (!pActiveOleDoc || !pFrame)
  405. return FALSE;
  407. COleDocObjectItem* pItem = DYNAMIC_DOWNCAST(COleDocObjectItem,
  408. pActiveOleDoc->GetInPlaceActiveItem(pFrame->GetActiveView()));
  410. return  pItem != NULL;
  411. #else
  412. UNREFERENCED_PARAMETER(hWndActiveChild);
  413. return FALSE;
  414. #endif
  415. }
  417. void CXTPMenuBar::SyncActiveMdiChild()
  418. {
  419. HWND hWndActiveChild = GetActiveMdiChildWnd();
  420. if (m_hWndActiveChild == hWndActiveChild)
  421. return;
  423. if (IsOleDocumentActive(hWndActiveChild))
  424. return;
  426. if (m_hWndActiveChild != NULL)
  427. XTPHookManager()->RemoveHook(m_hWndActiveChild, this);
  428. m_hWndActiveChild = hWndActiveChild;
  429. if (m_hWndActiveChild != NULL)
  430. XTPHookManager()->SetHook(m_hWndActiveChild, this);
  431. }
  433. void CXTPMenuBar::RefreshMenu()
  434. {
  435. SyncActiveMdiChild();
  437. if (IsVisible())
  438. {
  439. RefreshSysButtons();
  440. }
  441. }
  444. void CXTPMenuBar::AddSysButton(CXTPControl* pControl, int nId, LPCTSTR strParameter, int nBefore /*= -1*/)
  445. {
  446. m_pControls->Add(pControl, nId, strParameter, nBefore, TRUE);
  447. }
  449. void CXTPMenuBar::RefreshSysButtons()
  450. {
  451. BOOL bMax = FALSE;
  452. HWND hWndActiveChild = GetActiveMdiChildWnd(&bMax);
  453. DWORD dwStyle = hWndActiveChild ? GetWindowLong(hWndActiveChild, GWL_STYLE) : 0;
  454. CXTPControl*  pButton;
  457. pButton = m_pControls->FindControl(XTP_ID_MENUBAR_SYSMENU);
  459. if (bMax && (m_dwFlags & xtpFlagAddMDISysPopup))
  460. {
  461. HMENU hDocMenuButton = pButton ? ((CControlMDISysMenuPopup*)pButton)->m_hDocMenu : 0;
  463. HMENU hDocMenu =
  464. ::GetSystemMenu(hWndActiveChild, FALSE);
  465. if (hDocMenu && ::IsMenu(hDocMenu))
  466. {
  467. if (hDocMenuButton != hDocMenu)
  468. {
  469. if (pButton)
  470. {
  471. ((CControlMDISysMenuPopup*)pButton)->SetMDISysMenu(hWndActiveChild, hDocMenu);
  472. DelayRedraw();
  473. }
  474. else
  475. {
  476. AddSysButton(new CControlMDISysMenuPopup(hWndActiveChild, hDocMenu), XTP_ID_MENUBAR_SYSMENU, _T(""), 0);
  477. }
  478. }
  479. }
  480. else
  481. {
  482. if (pButton) m_pControls->Remove(pButton);
  483. }
  484. }
  485. else if (pButton) m_pControls->Remove(pButton);
  488. pButton = m_pControls->FindControl(XTP_ID_MENUBAR_MINIMIZE);
  489. if (!pButton && bMax && (dwStyle & WS_MINIMIZEBOX) && (dwStyle & WS_SYSMENU) && (!(m_dwFlags & xtpFlagHideMinimizeBox))) AddSysButton(new CControlMDIButton(), XTP_ID_MENUBAR_MINIMIZE, _T("0"));
  490. else if (pButton && !bMax) m_pControls->Remove(pButton);
  492. pButton = m_pControls->FindControl(XTP_ID_MENUBAR_RESTORE);
  493. if (!pButton && bMax && (dwStyle & WS_MAXIMIZEBOX) && (dwStyle & WS_SYSMENU) && (!(m_dwFlags & xtpFlagHideMaximizeBox))) AddSysButton(new CControlMDIButton(), XTP_ID_MENUBAR_RESTORE, _T("2"));
  494. else if (pButton && !bMax) m_pControls->Remove(pButton);
  496. pButton = m_pControls->FindControl(XTP_ID_MENUBAR_CLOSE);
  497. if (!pButton && bMax && (dwStyle & WS_SYSMENU) && (!(m_dwFlags & xtpFlagHideClose))) AddSysButton(new CControlMDIButton(), XTP_ID_MENUBAR_CLOSE, _T("r"));
  498. else if (pButton && !bMax) m_pControls->Remove(pButton);
  499. }
  501. void CXTPMenuBar::FreeMDIMenus()
  502. {
  503. m_pMDIMenus->RemoveAll();
  504. }
  506. BOOL CXTPMenuBar::IsMDIMenusChanged()
  507. {
  508. m_bDirtyMenu = FALSE;
  510. if (m_pMDIMenus->GetCount() > 0)
  511. {
  512. SwitchMDIMenu(GetDefaultMenuResource());
  513. m_bDirtyMenu = TRUE;
  514. }
  516. BOOL bChanged = FALSE;
  518. POSITION pos = m_pMDIMenus->GetStartPosition();
  519. while (pos)
  520. {
  521. CXTPMenuBarMDIMenuInfo* pInfo;
  522. m_pMDIMenus->GetNextMenu(pos, pInfo);
  524. pInfo->m_bChanged = pInfo->m_pControls->IsChanged();
  525. bChanged = bChanged || pInfo->m_bChanged;
  526. }
  527. return bChanged;
  528. }
  531. CXTPMenuBarMDIMenuInfo* CXTPMenuBar::AddMDIMenu(UINT nIDResource)
  532. {
  533. CXTPMenuBarMDIMenuInfo* pInfo = m_pMDIMenus->Lookup(nIDResource);
  534. if (pInfo)
  535. return pInfo;
  537. pInfo = new CXTPMenuBarMDIMenuInfo(GetCommandBars(), nIDResource);
  538. m_pMDIMenus->SetAt(nIDResource, pInfo);
  540. CMenu menu;
  541. VERIFY(menu.LoadMenu(nIDResource));
  543. pInfo->m_pControls->LoadMenu(&menu);
  544. pInfo->m_pControls->CreateOriginalControls();
  546. return pInfo;
  547. }
  549. void CXTPMenuBar::SwitchActiveMenu()
  550. {
  551. CFrameWnd* pFrame = DYNAMIC_DOWNCAST(CFrameWnd, GetSite());
  552. if (pFrame && pFrame->GetSafeHwnd()) pFrame->OnUpdateFrameMenu(0);
  553. m_bDirtyMenu = FALSE;
  554. }
  556. void CXTPMenuBar::SwitchMDIMenu(UINT nIDResource, CMenu* pMenu)
  557. {
  558. if ((nIDResource == 0) || (m_nIDResourceCurrent == 0) || (m_nIDResourceCurrent == nIDResource))
  559. return;
  561. if (GetCommandBars()->IsCustomizeAvail() || m_pMDIMenus->Lookup(nIDResource))
  562. {
  563. if (pMenu == NULL && !m_pMDIMenus->Lookup(nIDResource))
  564. return;
  566. CXTPMenuBarMDIMenuInfo* pInfo = m_pMDIMenus->Lookup(m_nIDResourceCurrent);
  567. if (pInfo)
  568. {
  569. ASSERT(pInfo->m_pControls == m_pControls);
  570. }
  571. else
  572. {
  573. pInfo = new CXTPMenuBarMDIMenuInfo(GetCommandBars(), m_nIDResourceCurrent);
  574. pInfo->m_pControls->InternalRelease();
  576. pInfo->m_pControls = m_pControls;
  577. m_pControls->InternalAddRef();
  579. m_pMDIMenus->SetAt(m_nIDResourceCurrent, pInfo);
  580. }
  582. m_pControls->SetParent(0);
  583. m_pControls->InternalRelease();
  584. m_pControls = NULL;
  586. pInfo = m_pMDIMenus->Lookup(nIDResource);
  587. if (!pInfo)
  588. {
  589. pInfo = new CXTPMenuBarMDIMenuInfo(GetCommandBars(), nIDResource);
  590. m_pControls = pInfo->m_pControls;
  591. m_pControls->InternalAddRef();
  592. m_pControls->SetParent(this);
  594. ASSERT(pMenu);
  595. if (pMenu)
  596. {
  597. LoadMenu(pMenu);
  598. }
  599. m_pControls->CreateOriginalControls();
  601. ASSERT(nIDResource != m_nIDResource);
  603. m_pMDIMenus->SetAt(nIDResource, pInfo);
  604. }
  605. else
  606. {
  607. m_pControls = pInfo->m_pControls;
  608. m_pControls->SetParent(this);
  609. m_pControls->InternalAddRef();
  611. if (m_pControls->GetOriginalControls() == 0 && pMenu)
  612. {
  613. CXTPOriginalControls* pOriginalControls = new CXTPOriginalControls();
  614. pOriginalControls->LoadMenu(pMenu);
  615. m_pControls->SetOriginalControls(pOriginalControls);
  616. }
  618. if (nIDResource == m_nIDResource)
  619. {
  620. m_pMDIMenus->Remove(nIDResource);
  621. }
  622. }
  623. }
  624. else if (pMenu)
  625. {
  626. LoadMenu(pMenu);
  627. }
  629. OnRecalcLayout();
  631. m_nIDResourceCurrent = nIDResource;
  632. }
  634. void CXTPMenuBar::SwitchMDIMenu(HMENU hMenu)
  635. {
  636. UINT nIDResource = GetActiveDocTemplate();
  638. if (hMenu == m_hMenuDefault)
  639. {
  640. nIDResource = m_nIDResource;
  641. }
  643. if ((nIDResource == 0) || (m_nIDResourceCurrent == 0) || (m_nIDResourceCurrent == nIDResource))
  644. return;
  646. CMenu* pMenu = CMenu::FromHandle(hMenu);
  647. if (!pMenu || pMenu->GetMenuItemCount() == 0)
  648. return;
  650. SwitchMDIMenu(nIDResource, pMenu);
  651. }
  653. int CXTPMenuBar::OnHookMessage(HWND hWnd, UINT nMessage, WPARAM& wParam, LPARAM& lParam, LRESULT& lResult)
  654. {
  656. switch (nMessage)
  657. {
  658. case WM_SYSCOMMAND:
  659. if (IsWindowVisible() && !XTPMouseManager()->IsMouseLocked() && (GetKeyState(VK_SHIFT) >= 0) && !IsCustomizeMode())
  660. if (((wParam & 0xFFF0) == SC_KEYMENU) && (lParam == 0))
  661. {
  662. if (PreviewAccel((UINT)VK_MENU))
  663. return TRUE;
  665. CXTPCommandBars* pCommandBars = GetCommandBars();
  666. if (pCommandBars)
  667. {
  668. pCommandBars->SetToolBarFocus(this);
  669. }
  670. return TRUE;
  671. }
  672. break;
  674. case WM_MDISETMENU:
  675. if (IsVisible())
  676. {
  677. if (IsCustomizeMode())
  678. {
  679. GetSite()->SetMenu(0);
  680. wParam = 0;
  681. return TRUE;
  682. }
  684. BOOL bAccepMenus = ((m_dwFlags & xtpFlagIgnoreSetMenuMessage) == 0) && (wParam || m_hMenuDefault);
  686. if (bAccepMenus)
  687. {
  688. SwitchMDIMenu(wParam ? (HMENU)wParam : m_hMenuDefault);
  689. }
  691. GetSite()->SetMenu(0);
  692. RefreshMenu();
  694. wParam = 0;
  695. return TRUE;
  696. }
  697. else if (GetSite()->GetMenu() == 0)
  698. {
  699. wParam = 0;
  700. return TRUE;
  702. }
  703. break;
  705. case WM_MDICREATE:
  706. case WM_MDIDESTROY:
  707. case WM_MDIACTIVATE:
  708. PostMessage(WM_TIMER, TID_REFRESH, 0);
  709. break;
  711. case WM_SIZE:
  712. case WM_WINDOWPOSCHANGED:
  713. if (hWnd == m_hWndActiveChild)
  714. PostMessage(WM_TIMER, TID_REFRESH, 0);
  715. break;
  717. }
  718. return CXTPToolBar::OnHookMessage(hWnd, nMessage, wParam, lParam, lResult);
  719. }
  721. BOOL CXTPMenuBar::LoadMenuBar(UINT nIDResource)
  722. {
  723. ASSERT(m_pControls->GetCount() == 0);
  725. if (nIDResource != 0)
  726. {
  727. CMenu menu;
  728. if (!menu.LoadMenu(nIDResource))
  729. return FALSE;
  731. if (!LoadMenu(&menu))
  732. return FALSE;
  734. m_nIDResourceCurrent = m_nIDResource = nIDResource;
  735. }
  738. SetupHook();
  740. UINT nIDMenuBarIcons[] =
  741. {
  742. SC_RESTORE, SC_MINIMIZE, SC_MAXIMIZE, SC_CLOSE
  743. };
  745. CXTPCommandBars* pCommandBars = GetCommandBars();
  746. if (pCommandBars)
  747. pCommandBars->GetImageManager()->SetIcons(XTP_IDB_MENUBAR_ICONS, nIDMenuBarIcons, 4, CSize(16, 16));
  749. m_hMenuDefault = ::GetMenu(GetSite()->GetSafeHwnd());
  750. GetSite()->SetMenu(0);
  752. return TRUE;
  753. }
  756. BEGIN_MESSAGE_MAP(CXTPMenuBar, CXTPToolBar)
  757. ON_WM_TIMER()
  758. END_MESSAGE_MAP()
  760. void CXTPMenuBar::OnTimer(UINT_PTR nIDEvent)
  761. {
  762. if (nIDEvent == TID_REFRESH)
  763. RefreshMenu();
  765. CXTPToolBar::OnTimer(nIDEvent);
  766. }
  768. void CXTPMenuBar::Reset(BOOL bShowWarningMessage)
  769. {
  770. if (GetControls()->GetOriginalControls() != NULL)
  771. {
  772. CXTPToolBar::Reset(bShowWarningMessage);
  773. }
  774. else if (((m_pMDIMenus->GetCount() > 0) || (GetControls()->GetOriginalControls() == NULL)) && m_nIDResourceCurrent)
  775. {
  776. if (bShowWarningMessage)
  777. {
  778. CString strMessage, strTitle = GetTitle(), strReset;
  780. VERIFY(XTPResourceManager()->LoadString(&strReset, XTP_IDS_CONFIRM_RESET));
  781. strMessage.Format(strReset, (LPCTSTR)strTitle);
  783. CXTPPushRoutingFrame push(GetFrameSite());
  785. if (XTPResourceManager()->ShowMessageBox(strMessage, MB_ICONWARNING | MB_OKCANCEL) != IDOK)
  786. return;
  787. }
  789. CMenu menu;
  790. VERIFY(menu.LoadMenu(m_nIDResourceCurrent));
  791. LoadMenu(&menu);
  793. CWnd* pWnd = GetSite();
  794. if (pWnd && ::IsWindow(pWnd->m_hWnd)) pWnd->SendMessage(WM_XTP_CUSTOMIZATION_RESETTOOLBAR, 0, (LPARAM)this);
  795. }
  797. RefreshMenu();
  798. OnInitialUpdate();
  799. OnRecalcLayout();
  800. }
  802. void CXTPMenuBar::Copy(CXTPCommandBar* pCommandBar, BOOL bRecursive)
  803. {
  804. CXTPToolBar::Copy(pCommandBar, bRecursive);
  806. m_nIDResource = ((CXTPMenuBar*)pCommandBar)->m_nIDResource;
  808. POSITION pos = ((CXTPMenuBar*)pCommandBar)->m_pMDIMenus->GetStartPosition();
  809. while (pos)
  810. {
  811. CXTPMenuBarMDIMenuInfo* pInfo;
  812. ((CXTPMenuBar*)pCommandBar)->m_pMDIMenus->GetNextMenu(pos, pInfo);
  814. CXTPMenuBarMDIMenuInfo* pInfoOrig = m_pMDIMenus->Lookup(pInfo->m_nIDResource);
  815. if (pInfoOrig)
  816. {
  817. if (pInfoOrig->m_pControls && pInfoOrig->m_pControls->m_pOriginalControls != NULL &&
  818. pInfo->m_pControls && pInfo->m_pControls->m_pOriginalControls == NULL)
  819. {
  820. CXTPOriginalControls* pOriginalControls = pInfoOrig->m_pControls->m_pOriginalControls;
  821. CMDTARGET_ADDREF(pOriginalControls);
  822. pInfo->m_pControls->SetOriginalControls(pOriginalControls);
  823. }
  825. CMDTARGET_RELEASE(pInfoOrig->m_pControls);
  826. pInfoOrig->m_pControls = pInfo->m_pControls;
  827. CMDTARGET_ADDREF(pInfoOrig->m_pControls);
  828. }
  829. else
  830. {
  831. m_pMDIMenus->SetAt(pInfo->m_nIDResource, pInfo);
  832. pInfo->InternalAddRef();
  833. }
  834. }
  836. }
  838. BOOL CXTPMenuBar::ShouldSerializeBar()
  839. {
  840. if (!IsCustomizable())
  841. return FALSE;
  843. BOOL bChanged = IsMDIMenusChanged();
  844. if (bChanged)
  845. return TRUE;
  847. if ((GetControls()->GetOriginalControls() && !GetControls()->IsChanged()))
  848. return FALSE;
  850. return TRUE;
  851. }