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

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

对话框与窗口

开发平台：

Visual C++

XTPStatusBar.cpp：源码内容
  1. // XTPStatusBar.cpp : implementation of the CXTPStatusBar 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 "Common/XTPDrawHelpers.h"
  23. #include "Common/XTPColorManager.h"
  24. #include "Common/XTPVC80Helpers.h"
  25. #include "Common/XTPImageManager.h"
  26. #include "Common/XTPToolTipContext.h"
  27. #include "Common/XTPMarkupRender.h"
  28. #include "Common/XTPResourceManager.h"
  30. #include "XTPStatusBar.h"
  31. #include "XTPPaintManager.h"
  32. #include "XTPToolBar.h"
  33. #include "XTPCommandBars.h"
  34. #include "XTPPopupBar.h"
  35. #include "XTPControlButton.h"
  36. #include "XTPMouseManager.h"
  38. #ifdef _XTP_INCLUDE_RIBBON
  39. #include "XTPOffice2007FrameHook.h"
  40. #endif
  43. #ifdef _DEBUG
  44. #define new DEBUG_NEW
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #endif
  49. #define SBPF_UPDATE 0x0001  // pending update of text
  50. #define CX_PANE_BORDER 2    // 3 pixels on each side of each pane
  52. //////////////////////////////////////////////////////////////////////////
  53. // CXTPStatusBarPane
  55. IMPLEMENT_DYNAMIC(CXTPStatusBarPane, CCmdTarget)
  57. CXTPStatusBarPane::CXTPStatusBarPane()
  58. {
  59. m_nID = 0;
  60. m_cxText = 0;
  61. m_nStyle = 0;
  62. m_nBestFit = 0;
  64. m_nIndex = -1;
  65. m_pStatusBar = NULL;
  67. m_hWndPane = NULL;
  68. m_bAutoDeleteWnd = FALSE;
  69. m_dwHideFlags = 0;
  71. m_clrText = (COLORREF)-1;
  72. m_clrBackground = (COLORREF)-1;
  74. m_nIconIndex = -1;
  75. m_nAlignment = DT_LEFT;
  77. m_rcMargins.SetRect(0, 0, 0, 0);
  78. m_rcPadding.SetRect(3, 1, 3, 1);
  80. m_bButton = FALSE;
  81. m_bPressed = FALSE;
  82. m_pMarkupUIElement = NULL;
  84. m_rcPane.SetRectEmpty();
  86. m_bBeginGroup = TRUE;
  88. }
  90. CXTPStatusBarPane::~CXTPStatusBarPane()
  91. {
  92. CWnd* pWnd = CWnd::FromHandlePermanent(m_hWndPane);
  94. if (pWnd && ::IsWindow(pWnd->GetSafeHwnd()))
  95. {
  96. pWnd->DestroyWindow();
  98. if (m_bAutoDeleteWnd)
  99. {
  100. delete pWnd;
  101. }
  102. }
  104. XTPMarkupReleaseElement(m_pMarkupUIElement);
  105. }
  107. void CXTPStatusBarPane::SetButton(BOOL bButton)
  108. {
  109. m_bButton = bButton;
  110. ShowBorders(FALSE);
  111. }
  113. BOOL CXTPStatusBarPane::IsButton() const
  114. {
  115. return m_bButton;
  116. }
  119. CRect CXTPStatusBarPane::GetRect() const
  120. {
  121. return m_rcPane;
  122. }
  124. void CXTPStatusBarPane::Redraw() const
  125. {
  126. if (this && m_pStatusBar && m_pStatusBar->GetSafeHwnd() && IsVisible())
  127. {
  128. m_pStatusBar->InvalidateRect(GetRect());
  129. }
  130. }
  132. CRect CXTPStatusBarPane::GetMargins() const
  133. {
  134. return m_rcMargins;
  135. }
  137. CRect CXTPStatusBarPane::GetPadding() const
  138. {
  139. return m_rcPadding;
  140. }
  142. void CXTPStatusBarPane::SetMargins(int nLeft, int nTop, int nRight, int nBottom)
  143. {
  144. m_rcMargins.SetRect(nLeft, nTop, nRight, nBottom);
  145. }
  147. void CXTPStatusBarPane::SetPadding(int nLeft, int nTop, int nRight, int nBottom)
  148. {
  149. m_rcPadding.SetRect(nLeft, nTop, nRight, nBottom);
  150. }
  152. void CXTPStatusBarPane::SetText(LPCTSTR lpszText)
  153. {
  154. if (m_strText == lpszText)
  155. return;
  157. XTPMarkupReleaseElement(m_pMarkupUIElement);
  158. m_strText = lpszText;
  160. if (m_pStatusBar->GetMarkupContext())
  161. {
  162. m_pMarkupUIElement = XTPMarkupParseText(m_pStatusBar->GetMarkupContext(), lpszText);
  163. }
  165. if (!IsVisible())
  166. return;
  168. if (m_cxText == 0 && m_nBestFit != GetBestFit())
  169. {
  170. m_pStatusBar->RecalcLayout();
  171. }
  172. else
  173. {
  174. Redraw();
  175. }
  176. }
  178. CString CXTPStatusBarPane::GetText() const
  179. {
  180. return m_strText;
  181. }
  183. void CXTPStatusBarPane::SetWidth(int cxText)
  184. {
  185. if (m_cxText != cxText)
  186. {
  187. m_cxText = cxText;
  188. m_pStatusBar->RecalcLayout();
  189. }
  190. }
  192. int CXTPStatusBarPane::GetWidth()
  193. {
  194. return m_cxText <= 0 ? GetBestFit() : m_cxText;
  195. }
  197. void CXTPStatusBarPane::SetStyle(UINT nStyle)
  198. {
  199. if (m_nStyle != nStyle)
  200. {
  201. // if the pane is changing SBPS_STRETCH, then...
  202. if ((m_nStyle ^ nStyle) & SBPS_STRETCH)
  203. {
  204. // ... we need to re-layout the panes
  205. m_nStyle = nStyle;
  206. m_pStatusBar->RecalcLayout();
  207. }
  209. // use SetPaneText, since it updates the style and text
  210. m_nStyle = nStyle;
  211. Redraw();
  212. }
  213. }
  214. UINT CXTPStatusBarPane::GetStyle() const
  215. {
  216. return m_nStyle;
  217. }
  219. UINT CXTPStatusBarPane::GetID() const
  220. {
  221. return m_nID;
  222. }
  224. int CXTPStatusBarPane::GetIndex() const
  225. {
  226. return m_nIndex;
  227. }
  229. CXTPStatusBar* CXTPStatusBarPane::GetStatusBar() const
  230. {
  231. return m_pStatusBar;
  232. }
  234. void CXTPStatusBarPane::Remove()
  235. {
  236. m_pStatusBar->RemoveAt(m_nIndex);
  237. }
  239. void CXTPStatusBarPane::SetVisible(BOOL bVisible)
  240. {
  241. DWORD dwHideFlags = bVisible ? m_dwHideFlags &~ xtpHideGeneric : m_dwHideFlags | xtpHideGeneric;
  243. if (m_dwHideFlags != dwHideFlags)
  244. {
  245. m_dwHideFlags = dwHideFlags;
  247. m_pStatusBar->RecalcLayout();
  248. }
  249. }
  251. BOOL CXTPStatusBarPane::IsVisible() const
  252. {
  253. return m_dwHideFlags == xtpNoHide;
  254. }
  256. void CXTPStatusBarPane::OnDraw(CDC* pDC, CRect rcItem)
  257. {
  258. CXTPPaintManager* pPaintManager = m_pStatusBar->GetPaintManager();
  260. if (pPaintManager)
  261. {
  262. pPaintManager->DrawStatusBarPaneEntry(pDC, rcItem, this);
  263. }
  264. }
  266. void CXTPStatusBarPane::BestFit()
  267. {
  268. SetWidth(GetBestFit());
  269. }
  271. int CXTPStatusBarPane::GetBestFit()
  272. {
  273. int cxText = 0;
  275. if (m_pMarkupUIElement)
  276. {
  277. XTPMarkupSetDefaultFont(m_pStatusBar->m_pMarkupContext, (HFONT)GetTextFont()->GetSafeHandle(), COLORREF_NULL);
  278. cxText = XTPMarkupMeasureElement(m_pMarkupUIElement).cx + m_rcPadding.left + m_rcPadding.right;
  279. }
  280. else
  281. {
  282. CClientDC dc(m_pStatusBar);
  283. CXTPFontDC font(&dc, GetTextFont());
  284. cxText = dc.GetTextExtent(m_strText).cx + m_rcPadding.left + m_rcPadding.right;
  285. }
  287. CXTPImageManagerIcon* pIcon = GetImage();
  288. if (pIcon) cxText += pIcon->GetWidth() + (!m_strText.IsEmpty() ? 2 : 0);
  290. return cxText;
  291. }
  293. void CXTPStatusBarPane::SetTextColor(COLORREF clrText)
  294. {
  295. m_clrText = clrText;
  296. Redraw();
  297. }
  299. COLORREF CXTPStatusBarPane::GetTextColor() const
  300. {
  301. return m_clrText;
  302. }
  304. void CXTPStatusBarPane::SetBackgroundColor(COLORREF clrBackground)
  305. {
  306. m_clrBackground = clrBackground;
  307. Redraw();
  308. }
  310. COLORREF CXTPStatusBarPane::GetBackgroundColor() const
  311. {
  312. return m_clrBackground;
  313. }
  315. CFont* CXTPStatusBarPane::GetTextFont()
  316. {
  317. ASSERT(m_pStatusBar);
  318. return (m_pStatusBar && m_fntText.m_hObject == NULL) ?
  319. m_pStatusBar->GetFont(): &m_fntText;
  320. }
  322. void CXTPStatusBarPane::SetTextFont(CFont* pFntText)
  323. {
  324. ASSERT(pFntText);
  325. if (!pFntText)
  326. return;
  328. LOGFONT lf;
  329. pFntText->GetLogFont(&lf);
  331. SetTextFont(&lf);
  332. }
  334. void CXTPStatusBarPane::SetTextFont(PLOGFONT pLogfText)
  335. {
  336. ASSERT(pLogfText);
  338. m_fntText.DeleteObject();
  339. m_fntText.CreateFontIndirect(pLogfText);
  341. Redraw();
  342. }
  344. CXTPImageManagerIcon* CXTPStatusBarPane::GetImage() const
  345. {
  346. if (m_nIconIndex != -1)
  347. return m_pStatusBar->GetImageManager()->GetImage(m_nIconIndex, 0);
  349. return NULL;
  350. }
  352. int CXTPStatusBarPane::GetIconIndex() const
  353. {
  354. return m_nIconIndex;
  355. }
  357. void CXTPStatusBarPane::SetIconIndex(int nIconIndex)
  358. {
  359. m_nIconIndex = nIconIndex;
  360. m_pStatusBar->RecalcLayout();
  361. }
  363. void CXTPStatusBarPane::SetTextAlignment(int nAlign)
  364. {
  365. m_nAlignment = nAlign;
  366. Redraw();
  367. }
  369. int CXTPStatusBarPane::GetTextAlignment() const
  370. {
  371. return m_nAlignment;
  372. }
  374. void CXTPStatusBarPane::SetTooltip(LPCTSTR lpszTooltip)
  375. {
  376. m_strToolTip = lpszTooltip;
  377. }
  379. CString CXTPStatusBarPane::GetTooltip() const
  380. {
  381. return m_strToolTip;
  382. }
  384. void CXTPStatusBarPane::SetEnabled(BOOL bEnabled)
  385. {
  386. SetStyle(bEnabled ? GetStyle() & ~SBPS_DISABLED : GetStyle() | SBPS_DISABLED);
  387. }
  389. BOOL CXTPStatusBarPane::IsEnabled() const
  390. {
  391. return ((m_nStyle & SBPS_DISABLED) == 0);
  392. }
  394. BOOL CXTPStatusBarPane::IsChecked() const
  395. {
  396. return ((m_nStyle & SBPS_POPOUT) == SBPS_POPOUT);
  397. }
  399. void CXTPStatusBarPane::SetChecked(BOOL bChecked)
  400. {
  401. SetStyle(!bChecked ? GetStyle() & ~SBPS_POPOUT : GetStyle() | SBPS_POPOUT);
  402. }
  404. void CXTPStatusBarPane::OnMouseMove(CPoint /*point*/)
  405. {
  407. }
  409. INT_PTR CXTPStatusBarPane::OnToolHitTest(CPoint /*point*/, TOOLINFO* /*pTI*/) const
  410. {
  411. return -1;
  412. }
  414. void CXTPStatusBarPane::OnLButtonDown(CPoint point)
  415. {
  416. if (!m_bButton)
  417. return;
  419. m_bPressed = TRUE;
  420. Redraw();
  422. m_pStatusBar->SetCapture();
  423. CRect rcButton = GetRect();
  425. BOOL  bClick = FALSE;
  427. while (::GetCapture() == m_pStatusBar->GetSafeHwnd())
  428. {
  429. BOOL bPressed = rcButton.PtInRect(point);
  431. if (bPressed != m_bPressed)
  432. {
  433. m_bPressed = bPressed;
  434. Redraw();
  435. }
  436. MSG msg;
  438. if (!::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
  439. continue;
  441. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  443. switch (msg.message)
  444. {
  445. case WM_MOUSEMOVE:
  446. point = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  447. break;
  449. case WM_LBUTTONUP:
  450. bClick = m_bPressed;
  451. goto ExitLoop;
  453. case WM_KEYDOWN:
  454. if (msg.wParam != VK_ESCAPE)
  455. break;
  457. case WM_CANCELMODE:
  458. case WM_RBUTTONDOWN:
  459. goto ExitLoop;
  461. default:
  462. DispatchMessage (&msg);
  463. break;
  464. }
  465. }
  467. ExitLoop:
  468. ReleaseCapture();
  470. m_bPressed = FALSE;
  471. Redraw();
  473. if (bClick)
  474. {
  475. m_pStatusBar->OnPaneClick(this);
  476. }
  477. }
  480. //////////////////////////////////////////////////////////////////////////
  481. // CXTPStatusBar
  483. IMPLEMENT_DYNAMIC(CXTPStatusBar, CControlBar)
  485. CXTPStatusBar::CXTPStatusBar()
  486. {
  487. // setup default border/margin depending on type of system
  488. m_cyTopBorder = 2;
  489. m_cxLeftBorder = 0;
  490. m_cxRightBorder = 0;
  491. m_cyBottomBorder = 0;
  492. m_cxPaneSpacing = 2;
  494. m_bCustomizable = FALSE;
  496. m_nMinHeight = 20;
  498. m_pCommandBars = NULL;
  499. m_bDrawDisabledText = TRUE;
  500. m_pToolTipContext = new CXTPToolTipContext;
  503. m_pHighlightedPane = NULL;
  505. m_bShowSizeGripper = FALSE;
  506. m_nRibbonDividerIndex = 0;
  508. m_pMarkupContext = NULL;
  510. }
  512. BOOL CXTPStatusBar::IsWin4()
  513. {
  514. #if (_MSC_VER >= 1300)
  515. return TRUE;
  516. #else
  517. DWORD dwVersion = ::GetVersion();
  518. return (BYTE)dwVersion >= 4;
  519. #endif
  520. }
  523. CXTPStatusBar::~CXTPStatusBar()
  524. {
  525. RemoveAll();
  527. CMDTARGET_RELEASE(m_pToolTipContext);
  529. XTPMarkupReleaseContext(m_pMarkupContext);
  530. }
  532. void CXTPStatusBar::EnableMarkup(BOOL bEnableMarkup)
  533. {
  534. XTPMarkupReleaseContext(m_pMarkupContext);
  536. if (bEnableMarkup)
  537. {
  538. m_pMarkupContext = XTPMarkupCreateContext(m_hWnd);
  539. }
  540. }
  542. CXTPImageManager* CXTPStatusBar::GetImageManager() const
  543. {
  544. if (m_pCommandBars)
  545. return m_pCommandBars->GetImageManager();
  547. return XTPImageManager();
  548. }
  550. CXTPStatusBarPane* CXTPStatusBar::HitTest(CPoint pt, CRect* lpRect) const
  551. {
  552. for (int i = 0; i < GetPaneCount(); i++)
  553. {
  554. CXTPStatusBarPane* pPane = GetPane(i);
  555. if (!pPane->IsVisible())
  556. continue;
  558. CRect rc = pPane->GetRect();
  560. if (rc.PtInRect(pt))
  561. {
  562. if (lpRect)
  563. *lpRect = rc;
  565. return pPane;
  566. }
  567. }
  569. return NULL;
  570. }
  572. void CXTPStatusBar::RemoveAll()
  573. {
  574. for (int i = 0; i < (int)m_arrPanes.GetSize(); i++)
  575. {
  576. m_arrPanes[i]->InternalRelease();
  577. }
  578. m_arrPanes.RemoveAll();
  580. m_pHighlightedPane = NULL;
  582. RecalcLayout();
  583. }
  585. CXTPStatusBarPane* CXTPStatusBar::GetPane(int nIndex) const
  586. {
  587. ASSERT(nIndex >= 0 && nIndex < GetPaneCount());
  589. return nIndex >= 0 && nIndex < GetPaneCount() ? m_arrPanes[nIndex]: NULL;
  590. }
  592. CXTPStatusBarPane* CXTPStatusBar::FindPane(UINT nID) const
  593. {
  594. for (int i = 0; i < GetPaneCount(); i++)
  595. {
  596. if (GetPane(i)->m_nID == nID)
  597. return GetPane(i);
  598. }
  599. return NULL;
  600. }
  602. int CXTPStatusBar::GetVisiblePaneCount() const
  603. {
  604. int nCount = 0;
  606. for (int i = 0; i < GetPaneCount(); i++)
  607. {
  608. if (m_arrPanes[i]->IsVisible()) nCount++;
  609. }
  611. return nCount;
  612. }
  614. /////////////////////////////////////////////////////////////////////////////
  615. // CXTPStatusBar creation, etc
  619. BOOL CXTPStatusBar::Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID)
  620. {
  621. return CreateEx(pParentWnd, 0, dwStyle, nID);
  622. }
  624. CFont* CXTPStatusBar::GetFont()
  625. {
  626. if (m_fontStatus.GetSafeHandle())
  627. return &m_fontStatus;
  629. return &GetPaintManager()->m_fontToolTip;
  630. }
  632. void CXTPStatusBar::SetFont(CFont* pFont, BOOL bRedraw /* = TRUE */)
  633. {
  634. m_fontStatus.DeleteObject();
  636. if (pFont)
  637. {
  638. LOGFONT lf;
  639. pFont->GetLogFont(&lf);
  641. m_fontStatus.CreateFontIndirect(&lf);
  642. }
  644. if (bRedraw)
  645. {
  646. Invalidate(FALSE);
  647. }
  648. }
  650. BOOL CXTPStatusBar::CreateEx(CWnd* pParentWnd, DWORD dwCtrlStyle, DWORD dwStyle, UINT nID)
  651. {
  652. ASSERT_VALID(pParentWnd);   // must have a parent
  654. // save the style (some of these style bits are MFC specific)
  655. m_dwStyle = (dwStyle & CBRS_ALL);
  657. // translate MFC style bits to windows style bits
  658. dwStyle &= ~CBRS_ALL;
  659. dwStyle |= CCS_NOPARENTALIGN | CCS_NOMOVEY | CCS_NODIVIDER | CCS_NORESIZE;
  661. if ((pParentWnd->GetStyle() & WS_THICKFRAME))
  662.  m_bShowSizeGripper = TRUE;
  664. dwStyle |= dwCtrlStyle;
  666. CXTPDrawHelpers::RegisterWndClass(0, _T("XTPStatusBar"), CS_DBLCLKS);
  668. // create the HWND
  669. CRect rect;
  670. rect.SetRectEmpty();
  672. return CWnd::Create(_T("XTPStatusBar"), NULL, dwStyle, rect, pParentWnd, nID);
  673. }
  675. BOOL CXTPStatusBar::PreCreateWindow(CREATESTRUCT& cs)
  676. {
  677. // in Win4, status bars do not have a border at all, since it is
  678. //  provided by the client area.
  679. if (IsWin4() &&
  680. (m_dwStyle & (CBRS_ALIGN_ANY | CBRS_BORDER_ANY)) == CBRS_BOTTOM)
  681. {
  682. m_dwStyle &= ~(CBRS_BORDER_ANY | CBRS_BORDER_3D);
  683. }
  684. return CControlBar::PreCreateWindow(cs);
  685. }
  687. BOOL CXTPStatusBar::SetIndicators(const UINT* lpIDArray, int nIDCount)
  688. {
  689. ASSERT_VALID(this);
  690. ASSERT(nIDCount >= 1);  // must be at least one of them
  691. ASSERT(lpIDArray == NULL ||
  692. AfxIsValidAddress(lpIDArray, sizeof(UINT) * nIDCount, FALSE));
  693. ASSERT(::IsWindow(m_hWnd));
  695. RemoveAll();
  697. // copy initial data from indicator array
  698. BOOL bResult = TRUE;
  700. if (lpIDArray != NULL)
  701. {
  702. for (int i = 0; i < nIDCount; i++)
  703. {
  704. CXTPStatusBarPane* pPane = new CXTPStatusBarPane();
  705. m_arrPanes.Add(pPane);
  707. pPane->m_pStatusBar = this;
  708. pPane->m_nID = *lpIDArray++;
  710. if (pPane->m_nID != 0)
  711. {
  712. if (!pPane->m_strText.LoadString(pPane->m_nID))
  713. {
  714. TRACE1("Warning: failed to load indicator string 0x%04X.n",
  715. pPane->m_nID);
  716. bResult = FALSE;
  717. break;
  718. }
  719. }
  720. else if (i == 0)
  721. {
  722. pPane->m_cxText = 1;
  723. pPane->m_nStyle |= (SBPS_STRETCH | SBPS_NOBORDERS);
  724. }
  725. }
  726. }
  727. RecalcLayout();
  729. return bResult;
  730. }
  732. void CXTPStatusBar::CalcInsideRect(CRect& rect, BOOL bHorz) const
  733. {
  734. ASSERT_VALID(this);
  735. ASSERT(::IsWindow(m_hWnd));
  736. ASSERT(bHorz);  // vertical status bar not supported
  738. // subtract standard CControlBar borders
  739. CControlBar::CalcInsideRect(rect, bHorz);
  741. CXTPPaintManager* pPaintManager = GetPaintManager();
  742. rect.DeflateRect(pPaintManager->m_rcStatusBarBorder);
  744. // subtract size grip if present
  745. if (m_bShowSizeGripper && !::IsZoomed(::GetParent(m_hWnd)))
  746. {
  747. // size grip uses a border + size of scrollbar + cx border
  748. rect.right -= m_cxRightBorder + ::GetSystemMetrics(SM_CXVSCROLL) +
  749. ::GetSystemMetrics(SM_CXBORDER) * 2;
  750. }
  751. }
  753. void CXTPStatusBar::RecalcLayout()
  754. {
  755. if (!GetSafeHwnd())
  756. return;
  758. // get border information and client work area
  759. CRect rect;
  760. GetWindowRect(rect);
  761. rect.OffsetRect(-rect.left, -rect.top);
  762. CalcInsideRect(rect, TRUE);
  764. // determine extra space for stretchy pane
  765. int cxExtra = rect.Width();
  766. int nStretchyCount = 0, i;
  767. BOOL bSeparator = FALSE, bFirstVisible = TRUE;
  769. for (i = 0; i < GetPaneCount(); i++)
  770. {
  771. CXTPStatusBarPane* pPane = GetPane(i);
  772. pPane->m_nIndex = i;
  773. pPane->m_dwHideFlags &= ~xtpHideWrap;
  775. if (pPane->GetBeginGroup() && !bFirstVisible) bSeparator = TRUE;
  777. if (!pPane->IsVisible())
  778. continue;
  780. pPane->m_nBestFit = pPane->GetWidth();
  782. if (pPane->m_nStyle & SBPS_STRETCH)
  783. ++nStretchyCount;
  785. cxExtra -= (pPane->m_nBestFit + (pPane->HasBorders() ? CX_PANE_BORDER : 0) + (bSeparator ? m_cxPaneSpacing : 0)
  786.  + pPane->m_rcMargins.left + pPane->m_rcMargins.right);
  788. bSeparator = FALSE;
  789. bFirstVisible = FALSE;
  790. }
  792. int left = m_cxLeftBorder;
  793. BOOL bHideAll = FALSE;
  794. bSeparator = FALSE;
  795. bFirstVisible = TRUE;
  797. for (i = 0; i < GetPaneCount(); i++)
  798. {
  799. CXTPStatusBarPane* pPane = GetPane(i);
  801. if (bHideAll)
  802. pPane->m_dwHideFlags |= xtpHideWrap;
  804. if (pPane->GetBeginGroup() && !bFirstVisible) bSeparator = TRUE;
  806. if (!pPane->IsVisible())
  807. {
  808. pPane->m_rcPane.SetRectEmpty();
  809. continue;
  810. }
  812. if (bSeparator)
  813. left += m_cxPaneSpacing;
  815. int nPaneWidth = pPane->m_nBestFit;
  816. int right = left + pPane->m_rcMargins.left;
  818. // determine size of the pane
  819. ASSERT(nPaneWidth >= 0);
  820. right += nPaneWidth + (pPane->HasBorders() ? CX_PANE_BORDER : 0);
  822. if ((pPane->m_nStyle & SBPS_STRETCH) && cxExtra > 0)
  823. {
  824. ASSERT(nStretchyCount != 0);
  825. int cxAddExtra = cxExtra / nStretchyCount;
  826. right += cxAddExtra;
  827. --nStretchyCount;
  828. cxExtra -= cxAddExtra;
  829. }
  830. if (right > rect.right)
  831. {
  832. if (pPane->m_nStyle & SBPS_STRETCH)
  833. {
  834. right = rect.right;
  835. }
  836. else
  837. {
  838. bHideAll = TRUE;
  839. pPane->m_dwHideFlags |= xtpHideWrap;
  840. pPane->m_rcPane.SetRectEmpty();
  841. continue;
  842. }
  843. }
  844. bSeparator = FALSE;
  845. bFirstVisible = FALSE;
  847. pPane->m_rcPane.SetRect(left, rect.top + pPane->m_rcMargins.top, right, rect.bottom - pPane->m_rcMargins.bottom);
  848. left = right + pPane->m_rcMargins.right;
  849. }
  851. m_pHighlightedPane = NULL;
  853. Invalidate(FALSE);
  855. PositionControls();
  856. }
  858. void CXTPStatusBar::UpdateAllPanes(BOOL bUpdateRects, BOOL /*bUpdateText*/)
  859. {
  860. if (bUpdateRects)
  861. {
  862. RecalcLayout();
  863. }
  864. }
  867. /////////////////////////////////////////////////////////////////////////////
  868. // CXTPStatusBar attribute access
  870. int CXTPStatusBar::CommandToIndex(UINT nIDFind) const
  871. {
  872. ASSERT_VALID(this);
  874. if (GetPaneCount() <= 0)
  875. return -1;
  877. for (int i = 0; i < GetPaneCount(); i++)
  878. {
  879. if (GetPane(i)->m_nID == nIDFind)
  880. return i;
  881. }
  883. return -1;
  884. }
  886. UINT CXTPStatusBar::GetItemID(int nIndex) const
  887. {
  888. ASSERT_VALID(this);
  890. CXTPStatusBarPane* pPane = GetPane(nIndex);
  891. ASSERT(pPane);
  893. if (!pPane)
  894. return 0;
  896. return pPane->m_nID;
  897. }
  899. void CXTPStatusBar::GetItemRect(int nIndex, LPRECT lpRect) const
  900. {
  901. ASSERT_VALID(this);
  902. ASSERT(::IsWindow(m_hWnd));
  904. if (!lpRect)
  905. return;
  907. CXTPStatusBarPane* pPane = GetPane(nIndex);
  908. if (!pPane)
  909. {
  910. ::SetRectEmpty(lpRect);
  911. return;
  912. }
  914. *lpRect = pPane->GetRect();
  915. }
  917. UINT CXTPStatusBar::GetPaneStyle(int nIndex) const
  918. {
  919. CXTPStatusBarPane* pPane = GetPane(nIndex);
  920. ASSERT(pPane);
  922. if (!pPane)
  923. return 0;
  925. return pPane->m_nStyle;
  926. }
  928. void CXTPStatusBar::SetPaneStyle(int nIndex, UINT nStyle)
  929. {
  930. CXTPStatusBarPane* pPane = GetPane(nIndex);
  931. ASSERT(pPane);
  933. if (pPane) pPane->SetStyle(nStyle);
  934. }
  936. void CXTPStatusBar::GetPaneInfo(int nIndex, UINT& nID, UINT& nStyle,
  937. int& cxWidth) const
  938. {
  939. ASSERT_VALID(this);
  941. CXTPStatusBarPane* pPane = GetPane(nIndex);
  942. nID = pPane->m_nID;
  943. nStyle = pPane->m_nStyle;
  944. cxWidth = pPane->GetWidth();
  945. }
  947. void CXTPStatusBar::SetPaneInfo(int nIndex, UINT nID, UINT nStyle, int cxWidth)
  948. {
  949. ASSERT_VALID(this);
  951. BOOL bChanged = FALSE;
  952. CXTPStatusBarPane* pPane = GetPane(nIndex);
  953. pPane->m_nID = nID;
  954. if (pPane->m_nStyle != nStyle)
  955. {
  956. if ((pPane->m_nStyle ^ nStyle) & SBPS_STRETCH)
  957. bChanged = TRUE;
  958. else
  959. {
  960. pPane->m_nStyle = nStyle;
  961. pPane->Redraw();
  962. }
  963. pPane->m_nStyle = nStyle;
  964. }
  965. if (cxWidth != pPane->m_cxText)
  966. {
  967. // change width of one pane -> invalidate the entire status bar
  968. pPane->m_cxText = cxWidth;
  969. bChanged = TRUE;
  970. }
  971. if (bChanged)
  972. RecalcLayout();
  973. }
  975. void CXTPStatusBar::GetPaneText(int nIndex, CString& s) const
  976. {
  977. ASSERT_VALID(this);
  979. CXTPStatusBarPane* pPane = GetPane(nIndex);
  980. ASSERT(pPane);
  981. if (!pPane)
  982. return;
  984. s = pPane->m_strText;
  985. }
  987. CString CXTPStatusBar::GetPaneText(int nIndex) const
  988. {
  989. ASSERT_VALID(this);
  991. CXTPStatusBarPane* pPane = GetPane(nIndex);
  992. ASSERT(pPane);
  993. if (!pPane)
  994. return _T("");
  996. return pPane->m_strText;
  997. }
  999. void CXTPStatusBar::SetPaneWidth(int nIndex, int cxText)
  1000. {
  1001. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1002. ASSERT(pPane);
  1003. if (!pPane)
  1004. return;
  1006. pPane->SetWidth(cxText);
  1007. }
  1009. BOOL CXTPStatusBar::SetPaneText(int nIndex, const CString& lpszNewText)
  1010. {
  1011. ASSERT_VALID(this);
  1012. ASSERT(::IsWindow(m_hWnd));
  1014. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1015. ASSERT(pPane);
  1016. if (!pPane)
  1017. return FALSE;
  1019. pPane->SetText(lpszNewText);
  1020. return TRUE;
  1021. }
  1023. /////////////////////////////////////////////////////////////////////////////
  1024. // CXTPStatusBar implementation
  1026. CSize CXTPStatusBar::CalcFixedLayout(BOOL, BOOL /*bHorz*/)
  1027. {
  1028. ASSERT_VALID(this);
  1029. ASSERT(::IsWindow(m_hWnd));
  1031. // determine size of font being used by the status bar
  1032. CSize szText(0, 0);
  1033. {
  1034. CClientDC dc(NULL);
  1035. CXTPFontDC font(&dc, GetFont());
  1036. szText = dc.GetTextExtent(_T("X"), 1);
  1037. }
  1039. CXTPPaintManager* pPaintManager = GetPaintManager();
  1041. // determine size, including borders
  1042. CSize size;
  1043. size.cx = 32767;
  1044. size.cy = szText.cy + m_cyBottomBorder + m_cyTopBorder + ::GetSystemMetrics(SM_CYBORDER) * 2 + pPaintManager->m_rcStatusBarBorder.top
  1045.  + pPaintManager->m_rcStatusBarBorder.bottom;
  1047. if (size.cy < m_nMinHeight)
  1048. size.cy = m_nMinHeight;
  1050. if (size.cy < pPaintManager->m_nStatusBarMinHeight)
  1051. size.cy = pPaintManager->m_nStatusBarMinHeight;
  1053. return size;
  1054. }
  1056. /////////////////////////////////////////////////////////////////////////////
  1057. // CXTPStatusBar message handlers
  1059. BEGIN_MESSAGE_MAP(CXTPStatusBar, CControlBar)
  1060. //{{AFX_MSG_MAP(CXTPStatusBar)
  1061. ON_WM_NCHITTEST_EX()
  1062. ON_WM_NCPAINT()
  1063. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  1064. ON_WM_PAINT()
  1065. ON_WM_CREATE()
  1066. ON_WM_ERASEBKGND()
  1067. ON_WM_NCCALCSIZE()
  1068. ON_WM_SIZE()
  1069. ON_WM_LBUTTONDOWN()
  1070. ON_WM_RBUTTONUP()
  1071. ON_WM_LBUTTONDBLCLK()
  1072. ON_WM_MOUSEMOVE()
  1073. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  1074. ON_WM_WINDOWPOSCHANGING()
  1075. ON_MESSAGE(WM_SETTEXT, OnSetText)
  1076. ON_MESSAGE(WM_GETTEXT, OnGetText)
  1077. ON_MESSAGE(WM_GETTEXTLENGTH, OnGetTextLength)
  1078. ON_MESSAGE(SB_SETMINHEIGHT, OnSetMinHeight)
  1079. ON_MESSAGE(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
  1080. ON_WM_WINDOWPOSCHANGED()
  1081. ON_WM_SYSCOMMAND()
  1082. //}}AFX_MSG_MAP
  1083. END_MESSAGE_MAP()
  1085. int CXTPStatusBar::OnCreate(LPCREATESTRUCT lpcs)
  1086. {
  1087. if (CControlBar::OnCreate(lpcs) == -1)
  1088. return -1;
  1090. return 0;
  1091. }
  1093. void CXTPStatusBar::OnSysCommand(UINT nID, LPARAM lParam)
  1094. {
  1095. if (nID == SC_SIZE + HTBOTTOM - HTSIZEFIRST + 1)
  1096. {
  1097. ::SendMessage(::GetParent(m_hWnd), WM_SYSCOMMAND, (WPARAM)nID, lParam);
  1098. return;
  1100. }
  1101. CControlBar::OnSysCommand(nID, lParam);
  1102. }
  1104. LRESULT CXTPStatusBar::OnNcHitTest(CPoint point)
  1105. {
  1106. if (m_bShowSizeGripper && !::IsZoomed(::GetParent(m_hWnd)))
  1107. {
  1108. CXTPWindowRect rc(this);
  1110. int dxGripper = (m_cxRightBorder + ::GetSystemMetrics(SM_CXVSCROLL) + ::GetSystemMetrics(SM_CXBORDER) * 2);
  1112. if (GetExStyle() & WS_EX_LAYOUTRTL)
  1113. {
  1114. if (point.x < rc.left + dxGripper)
  1115. return (LRESULT)HTBOTTOMLEFT;
  1116. }
  1117. else
  1118. {
  1119. if (point.x > rc.right - dxGripper)
  1120. return (LRESULT)HTBOTTOMRIGHT;
  1121. }
  1123. #ifdef _XTP_INCLUDE_RIBBON
  1124. if (point.y >= rc.bottom - 3 && GetPaintManager()->BaseTheme() == xtpThemeRibbon && CXTPOffice2007FrameHook::m_nMsgQueryFrameHook != 0)
  1125. {
  1126. CXTPOffice2007FrameHook* pFrame = (CXTPOffice2007FrameHook*)::SendMessage(::GetParent(m_hWnd), CXTPOffice2007FrameHook::m_nMsgQueryFrameHook, 0, 0);
  1127. if (pFrame && pFrame->IsFrameHasStatusBar())
  1128. {
  1129. return (LRESULT)HTBOTTOM;
  1130. }
  1131. }
  1132. #endif
  1133. }
  1135. return (LRESULT)HTCLIENT;
  1136. }
  1138. void CXTPStatusBarPane::SetCustomizationVisible(BOOL bVisible)
  1139. {
  1140. DWORD dwHideFlags = bVisible ? m_dwHideFlags &~ xtpHideCustomize : m_dwHideFlags | xtpHideCustomize;
  1142. if (m_dwHideFlags != dwHideFlags)
  1143. {
  1144. m_dwHideFlags = dwHideFlags;
  1146. m_pStatusBar->RecalcLayout();
  1147. }
  1148. }
  1150. BOOL CXTPStatusBarPane::GetCustomizationVisible() const
  1151. {
  1152. return (m_dwHideFlags & xtpHideCustomize) == 0;
  1153. }
  1155. class CXTPStatusBar::CControlCustomization : public CXTPControlButton
  1156. {
  1157. public:
  1158. CControlCustomization(CXTPStatusBarPane* pPane)
  1159. {
  1160. m_pPane = pPane;
  1161. }
  1162. void OnExecute()
  1163. {
  1164. m_pPane->SetCustomizationVisible(!m_pPane->GetCustomizationVisible());
  1165. SetChecked(!GetChecked());
  1166. }
  1167. protected:
  1168. CXTPStatusBarPane* m_pPane;
  1169. };
  1171. CXTPPopupBar* CXTPStatusBar::GetStatusBarPopup()
  1172. {
  1173. CXTPPopupBar* pPopup = CXTPPopupBar::CreatePopupBar(m_pCommandBars);
  1175. CXTPControl* pControl = pPopup->GetControls()->Add(xtpControlLabel, XTP_IDS_CUSTOMIZE_STATUSBAR);
  1176. pControl->SetItemDefault(TRUE);
  1177. pControl->SetDescription(_T(""));
  1179. for (int i = 0; i < GetPaneCount(); i++)
  1180. {
  1181. CXTPStatusBarPane* pPane = GetPane(i);
  1182. if (pPane->GetID() == 0)
  1183. continue;
  1185. pControl = pPopup->GetControls()->Add(new CControlCustomization(pPane));
  1187. pControl->SetCaption(pPane->m_strCaption.IsEmpty() ? pPane->m_strText : pPane->m_strCaption);
  1188. pControl->SetShortcutText(pPane->m_strValue);
  1189. pControl->SetBeginGroup(pPane->GetBeginGroup() && i > 0);
  1190. pControl->SetChecked(pPane->GetCustomizationVisible());
  1191. }
  1193. return pPopup;
  1194. }
  1196. void CXTPStatusBar::OnRButtonUp(UINT /*nFlags*/, CPoint point)
  1197. {
  1198. if (m_bCustomizable)
  1199. {
  1200. ClientToScreen(&point);
  1202. OnMouseLeave();
  1204. CXTPPopupBar* pPopup = GetStatusBarPopup();
  1206. if (pPopup && pPopup->GetControlCount() > 0)
  1207. {
  1208. CXTPCommandBars::TrackPopupMenu(pPopup, 0, point.x, point.y, this);
  1209. }
  1211. CMDTARGET_RELEASE(pPopup);
  1212. }
  1213. }
  1215. void CXTPStatusBar::OnMouseLeave()
  1216. {
  1217. OnMouseMove(0, CPoint(-1, -1));
  1218. }
  1220. void CXTPStatusBar::OnMouseMove(UINT nFlags, CPoint point)
  1221. {
  1222. CXTPStatusBarPane* pPane = XTPMouseManager()->IsTrackedLock() ? NULL : HitTest(point);
  1223. if (pPane && (!pPane->IsButton() || !pPane->IsEnabled()))
  1224. pPane = NULL;
  1226. if (pPane != m_pHighlightedPane)
  1227. {
  1228. CXTPStatusBarPane* pHighlightedPane = m_pHighlightedPane;
  1229. m_pHighlightedPane = pPane;
  1231. if (pHighlightedPane) pHighlightedPane->Redraw();
  1232. if (m_pHighlightedPane) m_pHighlightedPane->Redraw();
  1234. if (m_pHighlightedPane)
  1235. {
  1236. TRACKMOUSEEVENT tme =
  1237. {
  1238. sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd
  1239. };
  1240. _TrackMouseEvent(&tme);
  1241. }
  1243. if (pHighlightedPane)
  1244. {
  1245. pHighlightedPane->OnMouseMove(CPoint(-1, -1));
  1246. }
  1247. }
  1249. if (m_pHighlightedPane)
  1250. {
  1251. m_pHighlightedPane->OnMouseMove(point);
  1252. }
  1255. CControlBar::OnMouseMove(nFlags, point);
  1256. }
  1258. void CXTPStatusBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  1259. {
  1260. CControlBar::OnLButtonDblClk(nFlags, point);
  1262. if (m_pHighlightedPane)
  1263. {
  1264. m_pHighlightedPane->OnLButtonDown(point);
  1265. }
  1266. }
  1268. void CXTPStatusBar::OnLButtonDown(UINT nFlags, CPoint point)
  1269. {
  1270. CControlBar::OnLButtonDown(nFlags, point);
  1272. if (m_pHighlightedPane)
  1273. {
  1274. m_pHighlightedPane->OnLButtonDown(point);
  1275. }
  1276. }
  1278. void CXTPStatusBar::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp)
  1279. {
  1280. // calculate border space (will add to top/bottom, subtract from right/bottom)
  1281. CRect rect;
  1282. rect.SetRectEmpty();
  1283. CControlBar::CalcInsideRect(rect, TRUE);
  1284. ASSERT(rect.top >= 2);
  1286. // adjust non-client area for border space
  1287. lpncsp->rgrc[0].left += rect.left;
  1288. lpncsp->rgrc[0].top += rect.top - 2;
  1289. lpncsp->rgrc[0].right += rect.right;
  1290. lpncsp->rgrc[0].bottom += rect.bottom;
  1291. }
  1293. void CXTPStatusBar::OnBarStyleChange(DWORD dwOldStyle, DWORD dwNewStyle)
  1294. {
  1295. if (m_hWnd != NULL &&
  1296. ((dwOldStyle & CBRS_BORDER_ANY) != (dwNewStyle & CBRS_BORDER_ANY)))
  1297. {
  1298. // recalc non-client area when border styles change
  1299. SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
  1300. }
  1301. }
  1303. void CXTPStatusBar::OnNcPaint()
  1304. {
  1305. EraseNonClient();
  1306. }
  1308. void CXTPStatusBar::OnSize(UINT nType, int cx, int cy)
  1309. {
  1310. ASSERT_VALID(this);
  1311. ASSERT(::IsWindow(m_hWnd));
  1313. CControlBar::OnSize(nType, cx, cy);
  1315. // need to adjust pane right edges (because of stretchy pane)
  1316. RecalcLayout();
  1317. }
  1319. void CXTPStatusBar::OnWindowPosChanging(LPWINDOWPOS lpWndPos)
  1320. {
  1321. // not necessary to invalidate the borders
  1322. DWORD dwStyle = m_dwStyle;
  1323. m_dwStyle &= ~(CBRS_BORDER_ANY);
  1324. CControlBar::OnWindowPosChanging(lpWndPos);
  1325. m_dwStyle = dwStyle;
  1326. }
  1328. LRESULT CXTPStatusBar::OnSetText(WPARAM, LPARAM lParam)
  1329. {
  1330. ASSERT_VALID(this);
  1331. ASSERT(::IsWindow(m_hWnd));
  1333. int nIndex = CommandToIndex(0);
  1334. if (nIndex < 0)
  1335. return -1;
  1337. return SetPaneText(nIndex, (LPCTSTR)lParam) ? 0 : -1;
  1338. }
  1340. LRESULT CXTPStatusBar::OnGetText(WPARAM wParam, LPARAM lParam)
  1341. {
  1342. ASSERT_VALID(this);
  1343. ASSERT(::IsWindow(m_hWnd));
  1345. int nMaxLen = (int)wParam;
  1346. if (nMaxLen == 0)
  1347. return 0;       // nothing copied
  1348. LPTSTR lpszDest = (LPTSTR)lParam;
  1350. int nLen = 0;
  1351. int nIndex = CommandToIndex(0); // use pane with ID zero
  1352. if (nIndex >= 0)
  1353. {
  1354. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1355. nLen = pPane->m_strText.GetLength();
  1356. if (nLen > nMaxLen)
  1357. nLen = nMaxLen - 1; // number of characters to copy (less term.)
  1358. MEMCPY_S(lpszDest, (LPCTSTR)pPane->m_strText, nLen*sizeof(TCHAR));
  1359. }
  1360. lpszDest[nLen] = '';
  1361. return nLen + 1;      // number of bytes copied
  1362. }
  1364. LRESULT CXTPStatusBar::OnGetTextLength(WPARAM, LPARAM)
  1365. {
  1366. ASSERT_VALID(this);
  1367. ASSERT(::IsWindow(m_hWnd));
  1369. int nLen = 0;
  1370. int nIndex = CommandToIndex(0); // use pane with ID zero
  1371. if (nIndex >= 0)
  1372. {
  1373. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1374. nLen = pPane->m_strText.GetLength();
  1375. }
  1376. return nLen;
  1377. }
  1379. LRESULT CXTPStatusBar::OnSetMinHeight(WPARAM wParam, LPARAM)
  1380. {
  1381. LRESULT lResult = Default();
  1382. m_nMinHeight = (int)wParam;
  1383. return lResult;
  1384. }
  1386. /////////////////////////////////////////////////////////////////////////////
  1387. // CXTPStatusBar idle update through CStatusCmdUI class
  1389. class CXTPStatusBar::CStatusCmdUI : public CCmdUI      // class private to this file!
  1390. {
  1391. public: // re-implementations only
  1392. virtual void Enable(BOOL bOn);
  1393. virtual void SetCheck(int nCheck);
  1394. virtual void SetText(LPCTSTR lpszText);
  1395. };
  1397. void CXTPStatusBar::CStatusCmdUI::Enable(BOOL bOn)
  1398. {
  1399. m_bEnableChanged = TRUE;
  1400. CXTPStatusBar* pStatusBar = (CXTPStatusBar*)m_pOther;
  1401. ASSERT(pStatusBar != NULL);
  1402. if (!pStatusBar)
  1403. return;
  1404. ASSERT_KINDOF(CXTPStatusBar, pStatusBar);
  1405. ASSERT(m_nIndex < m_nIndexMax);
  1407. CXTPStatusBarPane* pPane = pStatusBar->GetPane(m_nIndex);
  1408. if (pPane) pPane->SetEnabled(bOn);
  1409. }
  1411. void CXTPStatusBar::CStatusCmdUI::SetCheck(int nCheck) // "checking" will pop out the text
  1412. {
  1413. CXTPStatusBar* pStatusBar = (CXTPStatusBar*)m_pOther;
  1414. ASSERT(pStatusBar != NULL);
  1415. if (!pStatusBar)
  1416. return;
  1417. ASSERT_KINDOF(CXTPStatusBar, pStatusBar);
  1418. ASSERT(m_nIndex < m_nIndexMax);
  1420. UINT nNewStyle = pStatusBar->GetPaneStyle(m_nIndex) & ~SBPS_POPOUT;
  1421. if (nCheck != 0)
  1422. nNewStyle |= SBPS_POPOUT;
  1423. pStatusBar->SetPaneStyle(m_nIndex, nNewStyle);
  1424. }
  1426. void CXTPStatusBar::CStatusCmdUI::SetText(LPCTSTR lpszText)
  1427. {
  1428. CXTPStatusBar* pStatusBar = (CXTPStatusBar*)m_pOther;
  1429. ASSERT(pStatusBar != NULL);
  1430. if (!pStatusBar)
  1431. return;
  1432. ASSERT_KINDOF(CXTPStatusBar, pStatusBar);
  1433. ASSERT(m_nIndex < m_nIndexMax);
  1435. pStatusBar->SetPaneText(m_nIndex, lpszText);
  1436. }
  1438. void CXTPStatusBar::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  1439. {
  1440. CStatusCmdUI state;
  1441. state.m_pOther = this;
  1442. state.m_nIndexMax = (UINT)GetPaneCount();
  1443. for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax;
  1444. state.m_nIndex++)
  1445. {
  1446. state.m_nID = GetPane(state.m_nIndex)->m_nID;
  1448. // allow the statusbar itself to have update handlers
  1449. if (CWnd::OnCmdMsg(state.m_nID, CN_UPDATE_COMMAND_UI, &state, NULL))
  1450. continue;
  1452. // allow target (owner) to handle the remaining updates
  1453. state.DoUpdate(pTarget, FALSE);
  1454. }
  1456. // update the dialog controls added to the status bar
  1457. UpdateDialogControls(pTarget, bDisableIfNoHndler);
  1458. }
  1460. /////////////////////////////////////////////////////////////////////////////
  1461. // CXTPStatusBar diagnostics
  1463. #ifdef _DEBUG
  1464. void CXTPStatusBar::AssertValid() const
  1465. {
  1466. CControlBar::AssertValid();
  1467. }
  1469. void CXTPStatusBar::Dump(CDumpContext& dc) const
  1470. {
  1471. CControlBar::Dump(dc);
  1473. if (dc.GetDepth() > 0)
  1474. {
  1475. for (int i = 0; i < GetPaneCount(); i++)
  1476. {
  1477. dc << "nstatus pane[" << i << "] = {";
  1478. dc << "ntnID = " << GetPane(i)->m_nID;
  1479. dc << "ntnStyle = " << GetPane(i)->m_nStyle;
  1480. dc << "ntcxText = " << GetPane(i)->m_cxText;
  1481. dc << "ntstrText = " << GetPane(i)->m_strText;
  1482. dc << "nt}";
  1483. }
  1484. }
  1485. dc << "n";
  1486. }
  1487. #endif //_DEBUG
  1490. CXTPPaintManager* CXTPStatusBar::GetPaintManager() const
  1491. {
  1492. if (m_pCommandBars)
  1493. return m_pCommandBars->GetPaintManager();
  1495. return XTPPaintManager();
  1496. }
  1498. void CXTPStatusBar::DrawPaneEntry(CDC* pDC, int nIndex, CRect rcItem)
  1499. {
  1500. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1502. if (pPane)
  1503. {
  1504. pPane->OnDraw(pDC, rcItem);
  1505. }
  1506. }
  1508. void CXTPStatusBar::OnPaint()
  1509. {
  1510. CPaintDC dcPaint (this);
  1511. CXTPBufferDC dc(dcPaint);
  1513. OnDraw(&dc);
  1514. }
  1516. LRESULT CXTPStatusBar::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  1517. {
  1518. if (GetPaintManager() == NULL)
  1519. {
  1520. return Default();
  1521. }
  1523. CDC* pDC = CDC::FromHandle((HDC)wParam);
  1524. if (pDC)
  1525. {
  1526. OnDraw(pDC);
  1527. }
  1529. return TRUE;
  1530. }
  1532. void CXTPStatusBar::OnDraw(CDC* pDC)
  1533. {
  1534. CXTPClientRect rcClient(this);
  1536. CXTPPaintManager* pPaintManager = GetPaintManager();
  1537. pPaintManager->FillStatusBar(pDC, this);
  1539. int nCount = GetPaneCount(), nGripperPane;
  1541. for (nGripperPane = nCount - 1; nGripperPane >= 0; nGripperPane--)
  1542. {
  1543. if (m_arrPanes[nGripperPane]->IsVisible())
  1544. break;
  1545. }
  1546. BOOL bSeparator = FALSE, bFirstVisible = TRUE;
  1548. for (int i = 0; i < nCount; i++)
  1549. {
  1550. CXTPStatusBarPane* pPane = GetPane(i);
  1552. if (pPane->GetBeginGroup() && !bFirstVisible) bSeparator = TRUE;
  1554. if (!pPane->IsVisible())
  1555. continue;
  1557. CRect rcItem = pPane->GetRect();
  1559. BOOL bGripperPane = (i == nGripperPane);
  1561. if (pPane->HasBorders())
  1562. {
  1563. pPaintManager->DrawStatusBarPaneBorder(pDC, rcItem, pPane, bGripperPane);
  1564. }
  1565. else if (bSeparator)
  1566. {
  1567. pPaintManager->DrawStatusBarPaneSeparator(pDC, rcItem, pPane);
  1568. }
  1570. DrawPaneEntry(pDC, i, rcItem);
  1572. bSeparator = FALSE;
  1573. bFirstVisible = FALSE;
  1574. }
  1576. if (m_bShowSizeGripper && !::IsZoomed(::GetParent(m_hWnd)))
  1577. DrawStretch(pDC, rcClient);
  1578. }
  1580. BOOL CXTPStatusBar::OnEraseBkgnd(CDC* /*pDC*/)
  1581. {
  1582. return TRUE;
  1583. }
  1585. void CXTPStatusBar::DrawStretch(CDC* pDC, CRect& rcClient)
  1586. {
  1587. GetPaintManager()->DrawStatusBarGripper(pDC, rcClient);
  1588. }
  1592. /////////////////////////////////////////////////////////////////////////////
  1593. // CXTPStatusBar message handlers
  1595. BOOL CXTPStatusBar::RemoveIndicator(UINT nID)
  1596. {
  1597. int nIndex = CommandToIndex(nID);
  1598. if (nIndex == -1)
  1599. {
  1600. TRACE1("WARNING: Pane ID %d was not found in the status bar.n", nID);
  1601. return FALSE;
  1602. }
  1604. return RemoveAt(nIndex);
  1605. }
  1607. BOOL CXTPStatusBar::RemoveAt(int nIndex)
  1608. {
  1610. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1611. if (!pPane)
  1612. return FALSE;
  1614. if (m_pHighlightedPane == pPane)
  1615. {
  1616. m_pHighlightedPane = NULL;
  1617. }
  1619. m_arrPanes.RemoveAt(nIndex);
  1621. pPane->InternalRelease();
  1623. UpdateAllPanes(TRUE, TRUE);
  1625. return TRUE;
  1626. }
  1628. CXTPStatusBarPane* CXTPStatusBar::AddIndicator(CXTPStatusBarPane* pPane, UINT nID, int nIndex)
  1629. {
  1630. if (nIndex < 0 || nIndex > GetPaneCount())
  1631. {
  1632. TRACE0("WARNING: Pane index out of range.n");
  1633. nIndex = GetPaneCount();
  1634. }
  1636. if (CommandToIndex(nID) != -1)
  1637. {
  1638. TRACE1("WARNING: Pane ID %d already exists in the status bar.n", nID);
  1639. }
  1641. m_arrPanes.InsertAt(nIndex, pPane);
  1642. pPane->m_nID = nID;
  1643. pPane->m_pStatusBar = this;
  1645. if (nID != 0)
  1646. {
  1647. CString strText;
  1648. if (strText.LoadString(nID))
  1649. {
  1650. pPane->m_strText = strText;
  1651. }
  1652. }
  1653. else if (nIndex == 0)
  1654. {
  1655. pPane->m_cxText = 1;
  1656. pPane->m_nStyle |= (SBPS_STRETCH | SBPS_NOBORDERS);
  1657. }
  1659. RecalcLayout();
  1661. return pPane;
  1662. }
  1664. CXTPStatusBarPane* CXTPStatusBar::AddIndicator(UINT nID, int nIndex)
  1665. {
  1666. if (nIndex < 0 || nIndex > GetPaneCount())
  1667. {
  1668. nIndex = GetPaneCount();
  1669. }
  1671. if (CommandToIndex(nID) != -1)
  1672. {
  1673. TRACE1("WARNING: Pane ID %d already exists in the status bar.n", nID);
  1674. return NULL;
  1675. }
  1677. return AddIndicator(new CXTPStatusBarPane(), nID, nIndex);
  1678. }
  1680. void CXTPStatusBar::PositionControls()
  1681. {
  1682. CXTPClientRect rcClient(this);
  1684. int cx = ::GetSystemMetrics(SM_CXEDGE);
  1686. for (int i = 0; i < GetPaneCount(); i++)
  1687. {
  1688. CXTPStatusBarPane* pPane = GetPane(i);
  1689. if (pPane->m_hWndPane == NULL || !IsWindow(pPane->m_hWndPane))
  1690. continue;
  1692. CRect rcPane = pPane->GetRect();
  1693. if (rcPane.IsRectEmpty() || !pPane->IsVisible())
  1694. {
  1695. ::SetWindowPos(pPane->m_hWndPane, 0, 0, 0, 0, 0, SWP_HIDEWINDOW);
  1696. }
  1697. else
  1698. {
  1699. if (pPane->HasBorders())
  1700. {
  1701. rcPane.DeflateRect(cx, cx);
  1702. }
  1704. ::SetWindowPos(pPane->m_hWndPane, 0, rcPane.left, rcPane.top, rcPane.Width(), rcPane.Height(), SWP_NOZORDER | SWP_SHOWWINDOW);
  1705. ::InvalidateRect(pPane->m_hWndPane, 0, FALSE);
  1706. }
  1707. }
  1708. }
  1710. BOOL CXTPStatusBar::AddControl(CWnd* pWnd, UINT nID, BOOL bAutoDelete)
  1711. {
  1712. int nIndex = CommandToIndex (nID);
  1714. if (nIndex == -1)
  1715. return FALSE;
  1717. CXTPStatusBarPane* pPane = GetPane(nIndex);
  1718. if (!pPane)
  1719. return FALSE;
  1721. pPane->m_hWndPane = pWnd->GetSafeHwnd();
  1722. pPane->m_bAutoDeleteWnd = bAutoDelete;
  1724. PositionControls();
  1725. return TRUE;
  1726. }
  1728. void CXTPStatusBar::OnWindowPosChanged(WINDOWPOS* lpwndpos)
  1729. {
  1730. CControlBar::OnWindowPosChanged(lpwndpos);
  1732. CXTPPaintManager* pPaintManager = GetPaintManager();
  1733. if (pPaintManager && pPaintManager->BaseTheme() == xtpThemeRibbon)
  1734. {
  1735. if ((lpwndpos->flags & (SWP_SHOWWINDOW | SWP_HIDEWINDOW)) != 0)
  1736. {
  1737. GetParentFrame()->SetWindowPos(0, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
  1738. }
  1739. }
  1740. }
  1742. LRESULT CXTPStatusBar::OnIdleUpdateCmdUI(WPARAM wParam, LPARAM)
  1743. {
  1744. // handle delay hide/show
  1745. BOOL bVis = GetStyle() & WS_VISIBLE;
  1746. UINT swpFlags = 0;
  1747. if ((m_nStateFlags & delayHide) && bVis)
  1748. swpFlags = SWP_HIDEWINDOW;
  1749. else if ((m_nStateFlags & delayShow) && !bVis)
  1750. swpFlags = SWP_SHOWWINDOW;
  1751. m_nStateFlags &= ~(delayShow | delayHide);
  1752. if (swpFlags != 0)
  1753. {
  1754. SetWindowPos(NULL, 0, 0, 0, 0, swpFlags |
  1755. SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
  1756. }
  1758. // the style must be visible and if it is docked
  1759. // the dockbar style must also be visible
  1760. if ((GetStyle() & WS_VISIBLE) &&
  1761. (m_pDockBar == NULL || (m_pDockBar->GetStyle() & WS_VISIBLE)))
  1762. {
  1763. // MFCBUG: removed check for IsFrameWnd so we can update statusbar
  1764. // for dialog based applications as well as doc/view apps.
  1765. CFrameWnd* pTarget = (CFrameWnd*)GetOwner();
  1766. if (pTarget == NULL)
  1767. pTarget = (CFrameWnd*)GetParent();
  1768. if (pTarget != NULL)
  1769. OnUpdateCmdUI(pTarget, (BOOL)wParam);
  1770. }
  1771. return 0L;
  1772. }
  1774. INT_PTR CXTPStatusBar::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1775. {
  1776. ASSERT_VALID(this);
  1777. ASSERT(::IsWindow(m_hWnd));
  1779. // check child windows first by calling CControlBar
  1780. INT_PTR nHit = CControlBar::OnToolHitTest(point, pTI);
  1781. if (nHit != -1)
  1782. return nHit;
  1784. CRect rcPane;
  1785. CXTPStatusBarPane* pPane = HitTest(point, &rcPane);
  1786. if (pPane)
  1787. {
  1788. nHit = pPane->OnToolHitTest(point, pTI);
  1789. if (nHit != -1)
  1790. return nHit;
  1792. nHit = pPane->GetID();
  1794. CString strTip = pPane->GetTooltip();
  1795. if (strTip.IsEmpty())
  1796. return -1;
  1798. CXTPToolTipContext::FillInToolInfo(pTI, m_hWnd, rcPane, nHit, strTip);
  1800. return nHit;
  1801. }
  1802. return -1;
  1803. }
  1805. void CXTPStatusBar::OnPaneClick(CXTPStatusBarPane* pPane)
  1806. {
  1807. GetParentFrame()->SendMessage(WM_COMMAND, pPane->GetID());
  1808. }
  1810. void CXTPStatusBar::OnSwitchPaneClick(CXTPStatusBarPane* pPane, long Id)
  1811. {
  1812. pPane;
  1813. GetParentFrame()->SendMessage(WM_COMMAND, Id);
  1814. }
  1818. BOOL CXTPStatusBar::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
  1819. {
  1821. if (m_pMarkupContext)
  1822. {
  1823. for (int i = 0; i < GetPaneCount(); i++)
  1824. {
  1825. CXTPStatusBarPane* pPane = GetPane(i);
  1826. if (pPane->IsVisible() && pPane->GetMarkupUIElement())
  1827. {
  1828. if (XTPMarkupRelayMessage(pPane->GetMarkupUIElement(), message, wParam, lParam, pResult))
  1829. return TRUE;
  1830. }
  1831. }
  1832. }
  1835. if (m_pToolTipContext)
  1836. {
  1837. m_pToolTipContext->FilterToolTipMessage(this, message, wParam, lParam);
  1838. }
  1840. return CControlBar::OnWndMsg(message, wParam, lParam, pResult);
  1841. }
  1843. void CXTPStatusBar::EnableCustomization(BOOL bEnable)
  1844. {
  1845. m_bCustomizable = bEnable;
  1846. }
  1848. void CXTPStatusBar::LoadState(LPCTSTR lpszProfileName)
  1849. {
  1850. if (!AfxGetApp()->GetProfileInt(lpszProfileName, _T("StatusBar"), TRUE))
  1851. {
  1852. SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_HIDEWINDOW);
  1853. DelayShow(FALSE);
  1854. }
  1856. if (m_bCustomizable)
  1857. {
  1858. CString strValue = AfxGetApp()->GetProfileString(lpszProfileName,  _T("StatusBarPanes"));
  1859. while (!strValue.IsEmpty())
  1860. {
  1861. CString strPane;
  1863. int nIndex = strValue.Find(_T('n'));
  1864. if (nIndex == -1)
  1865. {
  1866. strPane = strValue;
  1867. strValue.Empty();
  1868. }
  1869. else
  1870. {
  1871. strPane = strValue.Left(nIndex);
  1872. strValue = strValue.Mid(nIndex + 1);
  1873. }
  1875. int nID, bVisible = 0;
  1876. int nResult = SCANF_S(strPane, _T("%i=%i"), &nID, &bVisible);
  1878. CXTPStatusBarPane* pPane = (nResult == 2) && (nID != 0) ? FindPane(nID) : NULL;
  1879. if (pPane)
  1880. {
  1881. pPane->SetCustomizationVisible(bVisible);
  1882. }
  1883. }
  1884. }
  1885. }
  1887. void CXTPStatusBar::SaveState(LPCTSTR lpszProfileName)
  1888. {
  1889. if (GetSafeHwnd() && !IsVisible())
  1890. {
  1891. AfxGetApp()->WriteProfileInt(lpszProfileName, _T("StatusBar"), FALSE);
  1892. }
  1893. else
  1894. {
  1895. AfxGetApp()->WriteProfileString(lpszProfileName, _T("StatusBar"), NULL);
  1896. }
  1898. if (m_bCustomizable)
  1899. {
  1900. int nCount = GetPaneCount();
  1901. CString strValue;
  1902. for (int i = 0; i < nCount; i++)
  1903. {
  1904. CXTPStatusBarPane* pPane = GetPane(i);
  1906. CString strPaneState;
  1907. strPaneState.Format(_T("%i=%i"), pPane->GetID(), pPane->GetCustomizationVisible() ? 1 : 0);
  1908. strValue += (strValue.IsEmpty() ? _T("") : _T("n")) + strPaneState;
  1909. }
  1911. AfxGetApp()->WriteProfileString(lpszProfileName, _T("StatusBarPanes"), strValue.IsEmpty() ? (LPCTSTR)NULL : (LPCTSTR)strValue);
  1912. }
  1913. else
  1914. {
  1915. AfxGetApp()->WriteProfileString(lpszProfileName, _T("StatusBarPanes"), NULL);
  1916. }
  1917. }
  1920. //////////////////////////////////////////////////////////////////////////
  1921. // CXTPStatusBarSwitchPane
  1923. IMPLEMENT_DYNAMIC(CXTPStatusBarSwitchPane, CXTPStatusBarPane)
  1925. CXTPStatusBarSwitchPane::CXTPStatusBarSwitchPane()
  1926. {
  1927. m_nStyle |= SBPS_NOBORDERS;
  1929. m_pHighlighted = NULL;
  1930. m_bButton = TRUE;
  1932. m_rcMargins.SetRect(0, 0, 0, 0);
  1933. m_rcPadding.SetRect(0, 0, 0, 0);
  1934. }
  1936. CXTPStatusBarSwitchPane::~CXTPStatusBarSwitchPane()
  1937. {
  1938. RemoveAll();
  1939. }
  1941. void CXTPStatusBarSwitchPane::RemoveAll()
  1942. {
  1943. for (int i = 0; i < m_arrSwitches.GetSize(); i++)
  1944. {
  1945. delete m_arrSwitches[i];
  1946. }
  1947. m_arrSwitches.RemoveAll();
  1948. m_pHighlighted = NULL;
  1949. }
  1951. BOOL CXTPStatusBarSwitchPane::SetSwitches(const UINT* lpIDArray, int nIDCount)
  1952. {
  1953. for (int i = 0; i < nIDCount; i++)
  1954. {
  1955. if (!AddSwitch(lpIDArray[i]))
  1956. return FALSE;
  1957. }
  1959. m_pStatusBar->RecalcLayout();
  1961. return TRUE;
  1962. }
  1964. CXTPStatusBarSwitchPane::SWITCH* CXTPStatusBarSwitchPane::AddSwitch(UINT nID)
  1965. {
  1966. CString strToolTip;
  1967. strToolTip.LoadString(nID);
  1969. return AddSwitch(nID, strToolTip);
  1970. }
  1972. CXTPStatusBarSwitchPane::SWITCH* CXTPStatusBarSwitchPane::AddSwitch(UINT nID, LPCTSTR lpszToolTip)
  1973. {
  1974. SWITCH* pSwitch = new SWITCH();
  1975. pSwitch->nWidth = 0;
  1976. pSwitch->strToolTip = lpszToolTip;
  1977. pSwitch->nID = nID;
  1978. pSwitch->bHighlighted = FALSE;
  1979. pSwitch->bChecked = FALSE;
  1980. pSwitch->bPressed = FALSE;
  1982. m_arrSwitches.Add(pSwitch);
  1983. return pSwitch;
  1984. }
  1986. void CXTPStatusBarSwitchPane::RemoveSwitch(UINT nID)
  1987. {
  1988. for (int i = 0; i < m_arrSwitches.GetSize(); i++)
  1989. {
  1990. if (m_arrSwitches[i]->nID == nID)
  1991. {
  1992. delete m_arrSwitches[i];
  1993. m_arrSwitches.RemoveAt(i);
  1994. return;
  1995. }
  1996. }
  1997. }
  1999. int CXTPStatusBarSwitchPane::GetWidth()
  2000. {
  2001. CXTPPaintManager* pPaintManager = m_pStatusBar->GetPaintManager();
  2002. if (!pPaintManager)
  2003. return 0 ;
  2005. return m_cxText = pPaintManager->DrawStatusBarSwitchPane(NULL, CRect(0, 0, 0, 0), this);
  2006. }
  2008. void CXTPStatusBarSwitchPane::OnDraw(CDC* pDC, CRect rcItem)
  2009. {
  2010. CXTPPaintManager* pPaintManager = m_pStatusBar->GetPaintManager();
  2012. if (pPaintManager)
  2013. {
  2014. pPaintManager->DrawStatusBarSwitchPane(pDC, rcItem, this);
  2015. }
  2016. }
  2018. int CXTPStatusBarSwitchPane::GetSwitchCount() const
  2019. {
  2020. return (int)m_arrSwitches.GetSize();
  2021. }
  2023. CXTPStatusBarSwitchPane::SWITCH* CXTPStatusBarSwitchPane::GetSwitch(int nIndex) const
  2024. {
  2025. return m_arrSwitches[nIndex];
  2026. }
  2028. CXTPStatusBarSwitchPane::SWITCH* CXTPStatusBarSwitchPane::HitTest(CPoint point, CRect& rcItem) const
  2029. {
  2030. rcItem = GetRect();
  2032. for (int i = 0; i < m_arrSwitches.GetSize(); i++)
  2033. {
  2034. rcItem.right = rcItem.left + m_arrSwitches[i]->nWidth;
  2036. if (rcItem.PtInRect(point))
  2037. return m_arrSwitches[i];
  2039. rcItem.left = rcItem.right;
  2040. }
  2042. return NULL;
  2043. }
  2045. INT_PTR CXTPStatusBarSwitchPane::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  2046. {
  2047. CRect rcItem(0, 0, 0, 0);
  2049. SWITCH* pHighlighted = HitTest(point, rcItem);
  2050. if (!pHighlighted)
  2051. return -1;
  2053. INT_PTR nHit = pHighlighted->nID;
  2055. CString strTip = pHighlighted->strToolTip;
  2056. if (strTip.IsEmpty())
  2057. return -1;
  2059. CXTPToolTipContext::FillInToolInfo(pTI, m_pStatusBar->m_hWnd, rcItem, nHit, strTip);
  2061. return nHit;
  2062. }
  2064. void CXTPStatusBarSwitchPane::OnMouseMove(CPoint point)
  2065. {
  2066. CRect rcItem(0, 0, 0, 0);
  2068. SWITCH* pHighlighted = HitTest(point, rcItem);
  2069. if (pHighlighted != m_pHighlighted)
  2070. {
  2071. if (m_pHighlighted)
  2072. {
  2073. m_pHighlighted->bHighlighted = FALSE;
  2074. }
  2076. m_pHighlighted = pHighlighted;
  2078. if (m_pHighlighted)
  2079. {
  2080. m_pHighlighted->bHighlighted = TRUE;
  2081. }
  2083. Redraw();
  2084. }
  2085. }
  2087. void CXTPStatusBarSwitchPane::OnLButtonDown(CPoint point)
  2088. {
  2089. CRect rcItem;
  2091. SWITCH* pHighlighted = HitTest(point, rcItem);
  2092. if (!pHighlighted)
  2093. return;
  2095. pHighlighted->bPressed = TRUE;
  2096. Redraw();
  2098. m_pStatusBar->SetCapture();
  2100. BOOL  bClick = FALSE;
  2102. while (::GetCapture() == m_pStatusBar->GetSafeHwnd())
  2103. {
  2104. BOOL bPressed = rcItem.PtInRect(point);
  2106. if (bPressed != pHighlighted->bPressed)
  2107. {
  2108. pHighlighted->bPressed = bPressed;
  2109. Redraw();
  2110. }
  2111. MSG msg;
  2113. if (!::PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
  2114. continue;
  2116. VERIFY(::GetMessage(&msg, NULL, 0, 0));
  2118. switch (msg.message)
  2119. {
  2120. case WM_MOUSEMOVE:
  2121. point = CPoint((short signed)LOWORD(msg.lParam), (short signed)HIWORD(msg.lParam));
  2122. break;
  2124. case WM_LBUTTONUP:
  2125. bClick = pHighlighted->bPressed;
  2126. goto ExitLoop;
  2128. case WM_KEYDOWN:
  2129. if (msg.wParam != VK_ESCAPE)
  2130. break;
  2132. case WM_CANCELMODE:
  2133. case WM_RBUTTONDOWN:
  2134. goto ExitLoop;
  2136. default:
  2137. DispatchMessage (&msg);
  2138. break;
  2139. }
  2140. }
  2142. ExitLoop:
  2143. ReleaseCapture();
  2145. pHighlighted->bPressed = FALSE;
  2146. Redraw();
  2148. if (bClick)
  2149. {
  2150. m_pStatusBar->OnSwitchPaneClick(this, pHighlighted->nID);
  2151. }
  2152. }
  2154. void CXTPStatusBarSwitchPane::SetChecked(UINT nID)
  2155. {
  2156. for (int i = 0; i < m_arrSwitches.GetSize(); i++)
  2157. {
  2158. SWITCH* pSwitch = m_arrSwitches[i];
  2159. BOOL bChecked = pSwitch->nID == nID;
  2161. if (pSwitch->bChecked != bChecked)
  2162. {
  2163. pSwitch->bChecked = bChecked;
  2164. Redraw();
  2165. }
  2166. }
  2167. }
  2169. //////////////////////////////////////////////////////////////////////////
  2170. // CXTPStatusBarScrollBarPane
  2172. IMPLEMENT_DYNAMIC(CXTPStatusBarScrollBarPane, CXTPStatusBarPane)
  2174. CXTPStatusBarScrollBarPane::CXTPStatusBarScrollBarPane()
  2175. {
  2176. m_nMax = 100;
  2177. m_nMin = 0;
  2178. m_nValue = 0;
  2179. m_nPage = 0;
  2181. m_nStyle |= SBPS_NOBORDERS;
  2182. m_bButton = TRUE;
  2183. m_rcMargins.SetRect(0, 0, 0, 0);
  2184. m_rcPadding.SetRect(0, 0, 0, 0);
  2186. m_spi.fVert = FALSE;
  2187. }
  2189. CXTPStatusBarScrollBarPane::~CXTPStatusBarScrollBarPane()
  2190. {
  2192. }
  2194. CRect CXTPStatusBarScrollBarPane::GetScrollBarRect()
  2195. {
  2196. CRect rcItem(GetRect());
  2197. rcItem.DeflateRect(m_rcPadding);
  2199. int nHeight = GetScrollBarPaintManager()->m_cyHScroll;
  2200. if (rcItem.Height() > nHeight)
  2201. {
  2202. rcItem.top = (rcItem.top + rcItem.bottom - nHeight) / 2;
  2203. rcItem.bottom = rcItem.top + nHeight;
  2204. }
  2206. return rcItem;
  2207. }
  2209. void CXTPStatusBarScrollBarPane::GetScrollInfo(SCROLLINFO* psi)
  2210. {
  2211. psi->cbSize = sizeof(SCROLLINFO);
  2213. psi->fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
  2214. psi->nMax = m_nMax;
  2215. psi->nMin = m_nMin;
  2216. psi->nPage = m_nPage;
  2217. psi->nPos = m_nValue;
  2218. }
  2220. BOOL CXTPStatusBarScrollBarPane::IsScrollBarEnabled() const
  2221. {
  2222. return IsEnabled();
  2223. }
  2225. CWnd* CXTPStatusBarScrollBarPane::GetParentWindow() const
  2226. {
  2227. return m_pStatusBar;
  2228. }
  2230. CXTPScrollBarPaintManager* CXTPStatusBarScrollBarPane::GetScrollBarPaintManager() const
  2231. {
  2232. return (CXTPScrollBarPaintManager*)m_pStatusBar->GetPaintManager()->GetGalleryPaintManager();
  2233. }
  2235. void CXTPStatusBarScrollBarPane::OnDraw(CDC* pDC, CRect /*rcItem*/)
  2236. {
  2237. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  2238. SetupScrollInfo();
  2240. GetScrollBarPaintManager()->DrawScrollBar(pDC, this);
  2241. }
  2243. void CXTPStatusBarScrollBarPane::DoScroll(int cmd, int pos)
  2244. {
  2245. CWnd* pParent = m_pStatusBar->GetParent();
  2247. NMXTPSCROLL nmScroll;
  2248. nmScroll.hdr.code = XTP_SBN_SCROLL;
  2249. nmScroll.hdr.idFrom = GetID();
  2250. nmScroll.hdr.hwndFrom = m_pStatusBar->GetSafeHwnd();
  2251. nmScroll.pSender = this;
  2252. nmScroll.nPos = pos;
  2253. nmScroll.nSBCode = cmd;
  2255. LRESULT lResult = 0;
  2256. AFX_NOTIFY notify;
  2257. notify.pResult = &lResult;
  2258. notify.pNMHDR = (NMHDR*)&nmScroll.hdr;
  2260. pParent->OnCmdMsg(GetID(), MAKELONG(XTP_SBN_SCROLL, WM_NOTIFY), &notify, NULL);
  2261. }
  2263. void CXTPStatusBarScrollBarPane::RedrawScrollBar()
  2264. {
  2265. Redraw();
  2266. }
  2268. void CXTPStatusBarScrollBarPane::OnMouseMove(CPoint point)
  2269. {
  2270. int ht = HitTestScrollBar(point);
  2272. if (ht != m_spi.ht)
  2273. {
  2274. m_spi.ht = ht;
  2275. Redraw();
  2276. }
  2277. }
  2280. void CXTPStatusBarScrollBarPane::OnLButtonDown(CPoint point)
  2281. {
  2282. PerformTrackInit(m_pStatusBar->m_hWnd, point, &m_spi, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  2283. }
  2285. void CXTPStatusBarScrollBarPane::SetPos(int nValue)
  2286. {
  2287. if (m_nValue != nValue)
  2288. {
  2289. m_nValue = nValue;
  2290. Redraw();
  2291. }
  2292. }
  2294. int CXTPStatusBarScrollBarPane::GetPos() const
  2295. {
  2296. return m_nValue;
  2297. }
  2299. void CXTPStatusBarScrollBarPane::SetRange(int nMin, int nMax)
  2300. {
  2301. m_nMin = nMin;
  2302. m_nMax = nMax;
  2303. }
  2305. INT_PTR CXTPStatusBarScrollBarPane::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  2306. {
  2307. int ht = HitTestScrollBar(point);
  2308. if (ht < XTP_HTSCROLLUP || ht > XTP_HTSCROLLTHUMB)
  2309. return -1;
  2311. CString strTip = m_strToolTipPart[ht - XTP_HTSCROLLUP];
  2312. if (strTip.IsEmpty())
  2313. return -1;
  2315. CXTPToolTipContext::FillInToolInfo(pTI, m_pStatusBar->m_hWnd, GetScrollBarPartRect(ht), ht, strTip);
  2317. return ht;
  2318. }
  2320. void CXTPStatusBarScrollBarPane::SetTooltipPart(int nPart, LPCTSTR lpszTooltip)
  2321. {
  2322. if (nPart >= XTP_HTSCROLLUP && nPart <= XTP_HTSCROLLTHUMB)
  2323. {
  2324. m_strToolTipPart[nPart - XTP_HTSCROLLUP] = lpszTooltip;
  2325. }
  2326. else
  2327. {
  2328. if (nPart == SB_LINELEFT) m_strToolTipPart[0] = lpszTooltip;
  2329. if (nPart == SB_LINERIGHT) m_strToolTipPart[1] = lpszTooltip;
  2330. if (nPart == SB_PAGELEFT) m_strToolTipPart[2] = lpszTooltip;
  2331. if (nPart == SB_PAGERIGHT) m_strToolTipPart[3] = lpszTooltip;
  2332. if (nPart == SB_THUMBTRACK) m_strToolTipPart[4] = lpszTooltip;
  2333. }
  2334. }
  2336. //////////////////////////////////////////////////////////////////////////
  2337. // CXTPStatusBarSliderPane
  2339. IMPLEMENT_DYNAMIC(CXTPStatusBarSliderPane, CXTPStatusBarScrollBarPane)
  2341. CXTPStatusBarSliderPane::CXTPStatusBarSliderPane()
  2342. {
  2344. }
  2346. CXTPStatusBarSliderPane::~CXTPStatusBarSliderPane()
  2347. {
  2349. }
  2351. CXTPScrollBarPaintManager* CXTPStatusBarSliderPane::GetScrollBarPaintManager() const
  2352. {
  2353. return m_pStatusBar->GetPaintManager()->GetSliderPaintManager();
  2354. }
  2356. void CXTPStatusBarSliderPane::SetTicks(double* pTicks, int nCount)
  2357. {
  2358. SAFE_DELETE(m_pTicks);
  2360. if (nCount)
  2361. {
  2362. m_pTicks = new SLIDERTICKS(pTicks, nCount);
  2363. }
  2364. }
  2366. //////////////////////////////////////////////////////////////////////////
  2367. // CXTPStatusBarProgressPane
  2369. IMPLEMENT_DYNAMIC(CXTPStatusBarProgressPane, CXTPStatusBarPane)
  2371. CXTPStatusBarProgressPane::CXTPStatusBarProgressPane()
  2372. {
  2373. m_nStyle |= SBPS_NOBORDERS;
  2374. m_rcMargins.SetRect(0, 0, 0, 0);
  2375. m_rcPadding.SetRect(0, 0, 0, 0);
  2376. m_cxText = 100;
  2377. }
  2379. CXTPStatusBarProgressPane::~CXTPStatusBarProgressPane()
  2380. {
  2382. }
  2384. CXTPProgressPaintManager* CXTPStatusBarProgressPane::GetProgressPaintManager() const
  2385. {
  2386. return m_pStatusBar->GetPaintManager()->GetProgressPaintManager();
  2387. }
  2389. void CXTPStatusBarProgressPane::RedrawProgress()
  2390. {
  2391. Redraw();
  2392. }
  2394. CRect CXTPStatusBarProgressPane::GetProgressRect()
  2395. {
  2396. CRect rcItem(GetRect());
  2397. rcItem.DeflateRect(m_rcPadding);
  2399. int nHeight = GetProgressPaintManager()->m_cyProgress;
  2400. if (rcItem.Height() > nHeight)
  2401. {
  2402. rcItem.top = (rcItem.top + rcItem.bottom - nHeight) / 2;
  2403. rcItem.bottom = rcItem.top + nHeight;
  2404. }
  2406. return rcItem;
  2407. }
  2409. void CXTPStatusBarProgressPane::OnDraw(CDC* pDC, CRect /*rcItem*/)
  2410. {
  2411. CXTPProgressPaintManager* pPaintManager = GetProgressPaintManager();
  2413. if (pPaintManager)
  2414. {
  2415. pPaintManager->DrawProgress(pDC, this);
  2416. }
  2417. }