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

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

对话框与窗口

开发平台：

Visual C++

XTPControlGallery.cpp：源码内容
  1. // XTPControlGallery.cpp : implementation file.
  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 <math.h>
  23. #include "Resource.h"
  25. #include "Common/XTPImageManager.h"
  26. #include "Common/XTPPropExchange.h"
  27. #include "Common/XTPToolTipContext.h"
  29. #include "XTPControls.h"
  30. #include "XTPCommandBar.h"
  31. #include "XTPControlGallery.h"
  32. #include "XTPPaintManager.h"
  33. #include "XTPMouseManager.h"
  34. #include "XTPCommandBars.h"
  36. #define IDSYS_ANIMATE 23346
  38. #ifdef _DEBUG
  39. #define new DEBUG_NEW
  40. #undef THIS_FILE
  41. static char THIS_FILE[] = __FILE__;
  42. #endif
  44. //////////////////////////////////////////////////////////////////////////
  45. // CXTPControlGalleryItem
  47. CXTPControlGalleryItem::CXTPControlGalleryItem()
  48. {
  49. m_pItems = NULL;
  51. m_nId = 0;
  52. m_nIndex = -1;
  53. m_nImage = -1;
  54. m_dwData = 0;
  55. m_bLabel = FALSE;
  57. m_szItem = CSize(0, 0);
  59. }
  61. int CXTPControlGalleryItem::GetIndex() const
  62. {
  63. return m_nIndex;
  64. }
  66. CSize CXTPControlGalleryItem::GetSize()
  67. {
  68. return CSize(m_szItem.cx == 0 ? m_pItems->m_szItem.cx : m_szItem.cx,
  69. m_szItem.cy == 0 ? m_pItems->m_szItem.cy : m_szItem.cy);
  70. }
  72. void CXTPControlGalleryItem::SetSize(CSize szItem)
  73. {
  74. m_szItem = szItem;
  75. }
  77. void CXTPControlGalleryItem::Draw(CDC* pDC, CXTPControlGallery* pGallery, CRect rcItem, BOOL bEnabled, BOOL bSelected, BOOL bPressed, BOOL bChecked)
  78. {
  79. if (IsLabel())
  80. {
  81. pGallery->GetGalleryPaintManager()->
  82. DrawLabel(pDC, this, rcItem);
  83. return;
  84. }
  86. CXTPPaintManager* pPaintManager = pGallery->GetPaintManager();
  88. CXTPImageManagerIcon* pImage = GetImage();
  90. BOOL bDrawImgeAndText = (pImage != NULL && !m_strCaption.IsEmpty()) &&
  91. (pGallery->GetStyle() == xtpButtonIconAndCaption || pGallery->GetStyle() == xtpButtonCaptionAndDescription);
  93. if (bDrawImgeAndText)
  94. {
  95. pPaintManager->DrawRectangle(pDC, rcItem, bSelected, FALSE, bEnabled, FALSE, FALSE, xtpBarTypePopup, xtpBarPopup);
  97. CSize szImage(pImage->GetWidth(), pImage->GetHeight());
  98. int nImageBoxWidth  = max(rcItem.Height() - 4, szImage.cx);
  100. if (bChecked)
  101. {
  102. CRect rcCheckBox(rcItem.left + 2, rcItem.top + 2, rcItem.left + 2 + nImageBoxWidth, rcItem.bottom - 2);
  103. pPaintManager->DrawRectangle(pDC, rcCheckBox, FALSE, FALSE, bEnabled, TRUE, FALSE, xtpBarTypePopup, xtpBarPopup);
  104. }
  106. CPoint pt(rcItem.left + 2 + (nImageBoxWidth - szImage.cx) / 2, (rcItem.top + rcItem.bottom - szImage.cy) / 2);
  108. pImage->Draw(pDC, pt, pImage->GetIcon(bEnabled ? xtpImageNormal : xtpImageDisabled), szImage);
  110. COLORREF clrTextColor = pPaintManager->GetRectangleTextColor(bSelected, FALSE, bEnabled, FALSE, FALSE, xtpBarTypePopup, xtpBarPopup);
  112. pDC->SetTextColor(clrTextColor);
  114. CRect rcText(rcItem);
  115. rcText.left += 2 + nImageBoxWidth + szImage.cx / 3;
  117. if (pGallery->GetStyle() == xtpButtonCaptionAndDescription)
  118. {
  119. CXTPFontDC font(pDC, pPaintManager->GetRegularBoldFont());
  120. pDC->DrawText(m_strCaption, rcText, DT_END_ELLIPSIS | DT_SINGLELINE | DT_TOP | DT_NOPREFIX);
  122. rcText.top += pDC->GetTextExtent(_T("XXX"), 3).cy;
  123. font.SetFont(pPaintManager->GetRegularFont());
  124. pDC->DrawText(m_strDescriptionText, rcText, DT_WORDBREAK | DT_TOP | DT_NOPREFIX);
  125. }
  126. else
  127. {
  128. CXTPFontDC font(pDC, pPaintManager->GetRegularFont());
  129. pDC->DrawText(m_strCaption, rcText, DT_END_ELLIPSIS | DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  130. }
  131. }
  132. else if (pImage)
  133. {
  134. pPaintManager->DrawRectangle(pDC, rcItem, bSelected, bPressed, bEnabled, bChecked, FALSE, xtpBarTypeNormal, xtpBarPopup);
  135. CSize szImage(pImage->GetWidth(), pImage->GetHeight());
  136. CPoint pt((rcItem.left + rcItem.right - szImage.cx) / 2, (rcItem.top + rcItem.bottom - szImage.cy) / 2);
  138. pImage->Draw(pDC, pt, pImage->GetIcon(bEnabled ? xtpImageNormal : xtpImageDisabled), szImage);
  139. }
  140. else
  141. {
  142. pPaintManager->DrawRectangle(pDC, rcItem, bSelected, FALSE, bEnabled, bChecked, FALSE, xtpBarTypePopup, xtpBarPopup);
  143. COLORREF clrTextColor = pPaintManager->GetRectangleTextColor(bSelected, FALSE, bEnabled, bChecked, FALSE, xtpBarTypePopup, xtpBarPopup);
  145. pDC->SetTextColor(clrTextColor);
  146. CXTPFontDC font(pDC, pPaintManager->GetRegularFont());
  148. CRect rcText(rcItem);
  149. rcText.left += 3;
  151. pDC->DrawText(m_strCaption, rcText, DT_END_ELLIPSIS | DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX);
  152. }
  153. }
  155. CXTPImageManagerIcon* CXTPControlGalleryItem::GetImage()
  156. {
  157. if (!m_pItems)
  158. return NULL;
  160. return m_pItems->GetImageManager()->GetImage(m_nImage >= 0 ? m_nImage : m_nId, 0);
  161. }
  164. //////////////////////////////////////////////////////////////////////////
  165. // CXTPControlGalleryItems
  167. IMPLEMENT_DYNAMIC(CXTPControlGalleryItems, CCmdTarget)
  169. CXTPControlGalleryItems::CXTPControlGalleryItems(CXTPControlAction* pAction)
  170. : m_pAction(pAction)
  171. {
  172. m_szItem = CSize(20, 20);
  173. m_pImageManager = new CXTPImageManager();
  174. m_pImageManager->DrawReverted(2);
  175. m_bClipItems = TRUE;
  177. }
  179. CXTPControlGalleryItems::~CXTPControlGalleryItems()
  180. {
  181. m_pAction = NULL;
  183. RemoveAll();
  184. CMDTARGET_RELEASE(m_pImageManager);
  186. }
  188. void CXTPControlGalleryItems::RemoveAll()
  189. {
  190. for (int i = 0; i < m_arrItems.GetSize(); i++)
  191. {
  192. m_arrItems[i]->InternalRelease();
  193. }
  195. m_arrItems.RemoveAll();
  196. OnItemsChanged();
  197. }
  199. void CXTPControlGalleryItems::Remove(int nIndex)
  200. {
  201. CXTPControlGalleryItem* pItem = GetItem(nIndex);
  202. if (!pItem)
  203. return;
  205. m_arrItems.RemoveAt(nIndex);
  206. pItem->InternalRelease();
  208. UpdateIndexes(nIndex);
  209. OnItemsChanged();
  210. }
  212. void CXTPControlGalleryItems::UpdateIndexes(int nStart /*= 0*/)
  213. {
  214. for (int i = nStart; i < GetItemCount(); i++)
  215. GetItem(i)->m_nIndex = i;
  216. }
  218. CXTPControlGalleryItem* CXTPControlGalleryItems::InsertItem(int nIndex, CXTPControlGalleryItem* pItem, int nId, int nImage)
  219. {
  220. if (!pItem)
  221. return NULL;
  223. if (nIndex < 0 || nIndex > GetItemCount())
  224. nIndex = GetItemCount();
  226. m_arrItems.InsertAt(nIndex, pItem);
  227. UpdateIndexes(nIndex);
  229. pItem->m_pItems = this;
  230. pItem->m_nImage = nImage;
  232. if (nId != -1)
  233. {
  234. pItem->m_nId = nId;
  236. CString strCaption;
  237. if (nId > 0 && strCaption.LoadString(nId))
  238. {
  239. pItem->m_strCaption = pItem->m_strToolTip = strCaption;
  240. }
  241. }
  243. OnItemsChanged();
  245. return pItem;
  246. }
  248. void CXTPControlGalleryItems::OnItemsChanged()
  249. {
  250. if (!m_pAction)
  251. return;
  253. for (int i = 0; i < m_pAction->GetCount(); i++)
  254. {
  255. CXTPControlGallery* pGallery = DYNAMIC_DOWNCAST(CXTPControlGallery, m_pAction->GetControl(i));
  256. if (pGallery)
  257. {
  258. pGallery->m_nSelected = -1;
  259. pGallery->m_nScrollPos = 0;
  260. pGallery->Reposition();
  262. if (pGallery->m_bPreview)
  263. {
  264. pGallery->m_bPreview = FALSE;
  265. pGallery->NotifySite(XTP_GN_PREVIEWCANCEL);
  266. }
  267. }
  268. }
  269. }
  271. CXTPControlGalleryItem* CXTPControlGalleryItems::AddItem(CXTPControlGalleryItem* pItem, int nId, int nImage)
  272. {
  273. return InsertItem(GetItemCount(), pItem, nId, nImage);
  274. }
  276. CXTPControlGalleryItem* CXTPControlGalleryItems::AddItem(int nId, int nImage)
  277. {
  278. return AddItem(new CXTPControlGalleryItem(), nId, nImage);
  279. }
  281. CXTPControlGalleryItem* CXTPControlGalleryItems::AddItem(LPCTSTR lpszCaption, int nImage)
  282. {
  283. CXTPControlGalleryItem* pItem = AddItem(new CXTPControlGalleryItem(), -1, nImage);
  284. pItem->SetCaption(lpszCaption);
  286. return pItem;
  287. }
  289. CXTPControlGalleryItem* CXTPControlGalleryItems::AddItem(LPCTSTR lpszCaption, int nId, int nImage)
  290. {
  291. CXTPControlGalleryItem* pItem = AddItem(nId, nImage);
  292. pItem->SetCaption(lpszCaption);
  294. return pItem;
  295. }
  297. CXTPControlGalleryItem* CXTPControlGalleryItems::AddLabel(int nId)
  298. {
  299. CXTPControlGalleryItem* pItem = AddItem(new CXTPControlGalleryItem(), nId);
  300. pItem->m_bLabel = TRUE;
  302. return pItem;
  303. }
  305. CXTPControlGalleryItem* CXTPControlGalleryItems::AddLabel(LPCTSTR lpszCaption)
  306. {
  307. CXTPControlGalleryItem* pItem = AddItem(new CXTPControlGalleryItem());
  308. pItem->SetCaption(lpszCaption);
  309. pItem->m_bLabel = TRUE;
  311. return pItem;
  312. }
  314. int CXTPControlGalleryItems::GetItemCount() const
  315. {
  316. return (int)m_arrItems.GetSize();
  317. }
  319. CXTPControlGalleryItem* CXTPControlGalleryItems::GetItem(int nIndex) const
  320. {
  321. return nIndex >= 0 && nIndex < GetItemCount() ? m_arrItems.GetAt(nIndex) : NULL;
  322. }
  324. void CXTPControlGalleryItems::SetImageManager(CXTPImageManager* pImageManager)
  325. {
  326. CMDTARGET_RELEASE(m_pImageManager);
  328. m_pImageManager = pImageManager;
  329. }
  331. BOOL CXTPControlGalleryItems::PreDrawItem(CDC* pDC, CXTPControlGallery* pGallery, CXTPControlGalleryItem* pItem, CRect rcItem,
  332. BOOL bEnabled, BOOL bSelected, BOOL bPressed, BOOL bChecked)
  333. {
  334. UNREFERENCED_PARAMETER(pDC);
  335. UNREFERENCED_PARAMETER(pGallery);
  336. UNREFERENCED_PARAMETER(pItem);
  337. UNREFERENCED_PARAMETER(rcItem);
  338. UNREFERENCED_PARAMETER(bEnabled);
  339. UNREFERENCED_PARAMETER(bSelected);
  340. UNREFERENCED_PARAMETER(bPressed);
  341. UNREFERENCED_PARAMETER(bChecked);
  344. return FALSE;
  345. }
  348. //////////////////////////////////////////////////////////////////////////
  349. // CXTPControlGallery
  351. IMPLEMENT_XTP_CONTROL(CXTPControlGallery, CXTPControlPopup)
  354. CXTPControlGallery::CXTPControlGallery()
  355. {
  356. m_nChecked = -1;
  357. m_nSelected = -1;
  358. m_bPressed = FALSE;
  359. m_bKeyboardSelected = FALSE;
  360. m_bHideSelection = FALSE;
  362. m_nScrollPos = 0;
  363. m_nTotalHeight = 0;
  364. m_bShowLabels = TRUE;
  366. m_nWidth = 120;
  367. m_nHeight = 60;
  369. m_rcMargin.SetRectEmpty();
  370. m_ptPressed = CPoint(0, 0);
  372. m_bShowScrollBar = TRUE;
  375. m_bShowBorders = FALSE;
  376. m_bShowShadow = FALSE;
  378. m_bPreview = FALSE;
  379. m_nResizable = 0;
  381. m_controlType = xtpControlGallery;
  383. m_bAnimation = FALSE;
  384. m_nScrollPosTarget = 0;
  385. m_dAnimationStep = 0;
  388. SetFlags(xtpFlagShowPopupBarTip);
  389. }
  391. CXTPControlGalleryItems* CXTPControlGalleryItems::CreateItems(CXTPCommandBars* pCommandBars, int nId)
  392. {
  393. CXTPControlAction* pAction = pCommandBars->CreateAction(nId);
  395. if (pAction->m_pTarget == NULL)
  396. {
  397. pAction->m_pTarget = new CXTPControlGalleryItems(pAction);
  398. }
  400. ASSERT_KINDOF(CXTPControlGalleryItems, pAction->m_pTarget);
  402. return (CXTPControlGalleryItems*)pAction->m_pTarget;
  403. }
  405. CXTPControlGalleryItems* CXTPControlGallery::GetItems() const
  406. {
  407. CXTPControlAction* pAction = GetAction();
  408. if (!pAction)
  409. return NULL;
  411. return (CXTPControlGalleryItems*)pAction->m_pTarget;
  412. }
  414. CXTPControlGallery::~CXTPControlGallery()
  415. {
  416. }
  418. int CXTPControlGallery::GetCustomizeMinWidth() const
  419. {
  420. if (!m_pParent || !GetItems())
  421. return 0;
  423. if (DYNAMIC_DOWNCAST(CXTPPopupBar, m_pParent))
  424. {
  425. CXTPControl* pParentControl = ((CXTPPopupBar*)m_pParent)->GetControlPopup();
  426. if (pParentControl && pParentControl->GetType() == xtpControlGallery)
  427. return pParentControl->GetRect().Width();
  428. }
  430. CRect rcBorders(GetBorders());
  431. return max(16, GetItems()->m_szItem.cx) + rcBorders.left + rcBorders.right;
  432. }
  434. int CXTPControlGallery::GetCustomizeMinHeight() const
  435. {
  436. if (!m_pParent || !GetItems())
  437. return 0;
  439. CRect rcBorders(GetBorders());
  440. int nHeight = GetItems()->m_szItem.cy + rcBorders.top + rcBorders.bottom;
  441. return max(nHeight, 32);
  442. }
  444. void CXTPControlGallery::SetAction(CXTPControlAction* pAction)
  445. {
  446. CXTPControlPopup::SetAction(pAction);
  447. Reposition();
  448. }
  450. BOOL CXTPControlGallery::IsShowAsButton() const
  451. {
  452. return GetStyle() == xtpButtonIconAndCaptionBelow || GetStyle() == xtpButtonIcon;
  453. }
  455. void CXTPControlGallery::SetItems(CXTPControlGalleryItems* pItems)
  456. {
  457. if (pItems)
  458. {
  459. SetAction(pItems->m_pAction);
  460. }
  461. }
  463. void CXTPControlGallery::Reposition()
  464. {
  465. if (GetParent() == NULL)
  466. return;
  468. if (IsShowAsButton())
  469. return;
  471. CRect rcItems = GetItemsRect();
  473. int x = rcItems.left;
  474. int y = rcItems.top;
  475. BOOL bFirstItem = TRUE;
  477. int nCount = GetItemCount();
  479. m_arrRects.SetSize(nCount);
  480. int nRowHeight = 0;
  482. for (int i = 0 ; i < nCount; i++)
  483. {
  484. CXTPControlGalleryItem* pItem = GetItem(i);
  485. m_arrRects[i].pItem = pItem;
  486. m_arrRects[i].bBeginRow = FALSE;
  488. if (pItem->IsLabel())
  489. {
  490. if (!m_bShowLabels)
  491. {
  492. m_arrRects[i].rcItem = CRect(0, 0, 0, 0);
  493. continue;
  494. }
  496. if (!bFirstItem)
  497. {
  498. y += nRowHeight;
  499. }
  501. CRect rcItem(rcItems.left, y, rcItems.right, y + 19);
  502. m_arrRects[i].rcItem = rcItem;
  503. m_arrRects[i].bBeginRow = TRUE;
  505. y += 20;
  506. nRowHeight = 0;
  507. x = rcItems.left;
  508. bFirstItem = TRUE;
  510. }
  511. else
  512. {
  513. CSize szItem = pItem->GetSize();
  514. if (szItem.cx == 0)
  515. szItem.cx = rcItems.Width();
  517. if (bFirstItem)
  518. {
  519. m_arrRects[i].bBeginRow = TRUE;
  520. }
  522. if (!bFirstItem && x + szItem.cx > rcItems.right)
  523. {
  524. y += nRowHeight;
  525. x = rcItems.left;
  526. m_arrRects[i].bBeginRow = TRUE;
  527. nRowHeight = 0;
  528. }
  530. CRect rcItem(x, y, x + szItem.cx, y + szItem.cy);
  531. m_arrRects[i].rcItem = rcItem;
  533. nRowHeight = max(nRowHeight, szItem.cy);
  535. bFirstItem = FALSE;
  536. x += szItem.cx;
  537. }
  538. }
  540. if (!bFirstItem)
  541. y += nRowHeight;
  543. m_nTotalHeight = y - rcItems.top;
  545. if (m_nScrollPos > m_nTotalHeight - rcItems.Height())
  546. m_nScrollPos = max(0, m_nTotalHeight - rcItems.Height());
  548. SetupScrollInfo();
  549. }
  551. void CXTPControlGallery::SetCheckedItem(int nId)
  552. {
  553. if (m_nChecked != nId)
  554. {
  555. m_nChecked = nId;
  556. InvalidateItems();
  557. }
  558. }
  560. int CXTPControlGallery::GetCheckedItem() const
  561. {
  562. return m_nChecked;
  563. }
  565. int CXTPControlGallery::GetSelectedItem() const
  566. {
  567. return m_nSelected;
  568. }
  570. int CXTPControlGallery::GetItemCount() const
  571. {
  572. CXTPControlGalleryItems* pItems = GetItems();
  574. return pItems ? pItems->GetItemCount() : 0;
  575. }
  577. CXTPControlGalleryItem* CXTPControlGallery::GetItem(int nIndex) const
  578. {
  579. CXTPControlGalleryItems* pItems = GetItems();
  581. return pItems ? pItems->GetItem(nIndex) : NULL;
  582. }
  584. void CXTPControlGallery::DrawItems(CDC* pDC)
  585. {
  586. CXTPControlGalleryItems* pItems = GetItems();
  587. if (!pItems)
  588. return;
  590. ASSERT(m_arrRects.GetSize() == pItems->GetItemCount());
  592. CRect rcItems = GetItemsRect();
  594. CRgn rgn;
  595. CPoint point = pDC->GetViewportOrg();
  596. CRect rcClipBox(rcItems);
  597. rcClipBox.OffsetRect(point);
  599. rgn.CreateRectRgnIndirect(rcClipBox);
  600. pDC->SelectClipRgn(&rgn);
  602. int nSelected = m_bHideSelection ? -1 : m_nSelected;
  604. for (int i = 0; i < m_arrRects.GetSize(); i++)
  605. {
  606. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  608. CRect rcItem = pos.rcItem;
  609. rcItem.OffsetRect(0, -m_nScrollPos);
  611. if (rcItem.bottom < rcItems.top)
  612. continue;
  614. if (!rcItem.IsRectEmpty())
  615. {
  616. if (!pItems->PreDrawItem(pDC, this, pos.pItem, rcItem, GetEnabled(), nSelected == i, nSelected == i && m_bPressed, m_nChecked == pos.pItem->GetID()))
  617. {
  618. pos.pItem->Draw(pDC, this, rcItem, GetEnabled(), nSelected == i, nSelected == i && m_bPressed, m_nChecked == pos.pItem->GetID());
  619. }
  620. }
  622. if (rcItem.top > rcItems.bottom)
  623. break;
  624. }
  626. pDC->SelectClipRgn(NULL);
  627. }
  629. int CXTPControlGallery::HitTestItem(CPoint point, LPRECT lpRect) const
  630. {
  631. if (!GetEnabled())
  632. return -1;
  634. if (IsShowAsButton())
  635. return -1;
  637. ASSERT(m_arrRects.GetSize() == GetItemCount());
  639. CRect rcItems = GetItemsRect();
  641. for (int i = 0; i < m_arrRects.GetSize(); i++)
  642. {
  643. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  645. CRect rcItem = pos.rcItem;
  646. rcItem.OffsetRect(0, -m_nScrollPos);
  648. if (rcItem.top >= rcItems.bottom)
  649. break;
  651. if (rcItem.PtInRect(point))
  652. {
  653. if (lpRect)
  654. {
  655. *lpRect = rcItem;
  656. }
  657. return pos.pItem->IsLabel() ? -1 : i;
  658. }
  659. }
  661. return -1;
  662. }
  664. void CXTPControlGallery::InvalidateItems(LPCRECT lpRect, BOOL bAnimate)
  665. {
  666. GetParent()->Redraw(lpRect ? lpRect : GetRect(), bAnimate);
  667. }
  669. void CXTPControlGallery::OnExecute()
  670. {
  671. if (m_bPreview)
  672. {
  673. NotifySite(XTP_GN_PREVIEWAPPLY);
  674. m_bPreview = FALSE;
  675. }
  677. CXTPControlPopup::OnExecute();
  678. }
  680. BOOL CXTPControlGallery::OnSetPopup(BOOL bPopup)
  681. {
  682. if (m_bPreview)
  683. {
  684. NotifySite(XTP_GN_PREVIEWCANCEL);
  685. m_bPreview = FALSE;
  686. }
  688. return CXTPControlPopup::OnSetPopup(bPopup);
  689. }
  692. void CXTPControlGallery::OnMouseHover()
  693. {
  694. if (IsItemSelected() && !m_bPreview && GetSelected())
  695. {
  696. m_bPreview = TRUE;
  697. NotifySite(XTP_GN_PREVIEWSTART);
  699. NotifySite(XTP_GN_PREVIEWCHANGE);
  700. }
  701. if (!m_pParent->m_bTrackOnHover)
  702. return;
  704. CXTPControlPopup::OnMouseHover();
  705. }
  707. void CXTPControlGallery::PerformMouseMove(CPoint point)
  708. {
  709. int nItem = HitTestItem(point);
  711. if (nItem == -1 && m_bKeyboardSelected)
  712. return;
  714. if (nItem == -1 && point == CPoint(-1, -1) && m_nSelected != -1)
  715. {
  716. HideSelection();
  717. return;
  718. }
  720. int nSelected = m_nSelected;
  722. if (nItem != m_nSelected || m_bHideSelection || m_bKeyboardSelected)
  723. {
  724. m_nSelected = nItem;
  725. m_bHideSelection = FALSE;
  726. m_bKeyboardSelected = FALSE;
  727. m_bPressed = FALSE;
  729. CXTPControlGalleryItems* pItems = GetItems();
  731. if (pItems && pItems->m_bClipItems)
  732. {
  733. if (nSelected != -1)
  734. {
  735. InvalidateItems(GetItemDrawRect(nSelected), TRUE);
  736. }
  738. if (m_nSelected != -1)
  739. {
  740. InvalidateItems(GetItemDrawRect(m_nSelected), FALSE);
  741. }
  742. }
  743. else
  744. {
  745. InvalidateItems();
  746. }
  748. if (!m_bPreview && m_nSelected != -1)
  749. {
  750. m_pParent->SetTimer(XTP_TID_HOVER, 200, NULL);
  751. }
  753. if (m_bPreview)
  754. {
  755. NotifySite(XTP_GN_PREVIEWCHANGE);
  756. }
  758. if (m_nSelected == -1 && m_bPreview)
  759. {
  760. m_bPreview = FALSE;
  761. NotifySite(XTP_GN_PREVIEWCANCEL);
  762. }
  764. OnSelectedItemChanged();
  765. }
  767. if (m_bPressed && (m_ptPressed != CPoint(0, 0)) && (m_nSelected != -1) &&
  768. (abs(m_ptPressed.x - point.x) > 4 || abs(m_ptPressed.y - point.y) > 4))
  769. {
  770. m_ptPressed = CPoint(0, 0);
  771. NotifySite(XTP_GN_STARTDRAG);
  772. }
  773. }
  774. void CXTPControlGallery::PerformMouseDown(CPoint point)
  775. {
  776. if (m_nSelected != -1 && !m_bKeyboardSelected)
  777. {
  778. m_bPressed = TRUE;
  779. m_ptPressed = point;
  780. InvalidateItems();
  781. }
  782. }
  784. void CXTPControlGallery::PerformMouseUp(CPoint /*point*/)
  785. {
  786. if (m_bPressed || (GetParent()->GetPosition() == xtpBarPopup && IsItemSelected()))
  787. {
  788. m_bPressed = FALSE;
  789. InvalidateItems();
  791. OnExecute();
  792. }
  793. }
  795. BOOL CXTPControlGallery::HasBottomSeparator() const
  796. {
  797. if (GetParent()->GetType() != xtpBarTypePopup)
  798. return FALSE;
  800. if (m_bShowBorders)
  801. return FALSE;
  803. int nIndex = GetIndex();
  804. int nNextIndex = GetParent()->GetControls()->GetNext(nIndex, +1, TRUE);
  806. return nNextIndex > nIndex;
  807. }
  809. CRect CXTPControlGallery::GetItemDrawRect(int nIndex)
  810. {
  811. if (nIndex < 0 || nIndex >= m_arrRects.GetSize())
  812. return CRect(0, 0, 0, 0);
  814. CRect rc(m_arrRects[nIndex].rcItem);
  815. rc.OffsetRect(0, -m_nScrollPos);
  817. rc.IntersectRect(rc, GetItemsRect());
  819. return rc;
  820. }
  822. CRect CXTPControlGallery::GetBorders() const
  823. {
  824. CRect rcBorders(0, 0, 0, 0);
  825. if (m_bShowBorders)
  826. {
  827. rcBorders.SetRect(1, 1, 1, 1);
  828. }
  829. if (m_pParent && m_bShowScrollBar)
  830. {
  831. rcBorders.right += (GetCommandBar() ? GetGalleryPaintManager()->m_cxPopup : GetGalleryPaintManager()->m_cxVScroll);
  832. }
  834. if (m_pParent && HasBottomSeparator())
  835. {
  836. rcBorders.bottom = 2;
  837. }
  839. rcBorders.DeflateRect(m_rcMargin.left, m_rcMargin.top, -m_rcMargin.right, -m_rcMargin.bottom);
  841. return rcBorders;
  842. }
  844. CXTPControlGalleryPaintManager* CXTPControlGallery::GetGalleryPaintManager() const
  845. {
  846. return GetPaintManager()->GetGalleryPaintManager();
  847. }
  849. CXTPScrollBarPaintManager* CXTPControlGallery::GetScrollBarPaintManager() const
  850. {
  851. return GetPaintManager()->GetGalleryPaintManager();
  852. }
  854. void CXTPControlGallery::SetResizable(BOOL bResizeWidth, BOOL bResizeHeight)
  855. {
  856. m_nResizable = (bResizeWidth ? 1 : 0) +  (bResizeHeight ? 2 : 0);
  857. }
  859. CRect CXTPControlGallery::GetItemsRect() const
  860. {
  861. CRect rc = GetRect();
  862. rc.DeflateRect(GetBorders());
  864. return rc;
  865. }
  867. void CXTPControlGallery::FillControl(CDC* pDC, CRect rcControl)
  868. {
  869. GetGalleryPaintManager()->FillControl(pDC, this, rcControl);
  870. }
  872. void CXTPControlGallery::DoAnimate()
  873. {
  874. if (abs(m_nScrollPos - m_nScrollPosTarget) > fabs(m_dAnimationStep))
  875. {
  876. m_nScrollPos = int((double)m_nScrollPos + m_dAnimationStep);
  877. }
  878. else
  879. {
  880. m_bAnimation = FALSE;
  881. m_nScrollPos = m_nScrollPosTarget;
  882. ::KillTimer(GetParent()->GetSafeHwnd(), IDSYS_ANIMATE);
  883. }
  884. Reposition();
  886. OnScrollChanged();
  887. InvalidateItems(NULL, FALSE);
  888. GetParent()->UpdateWindow();
  889. }
  891. void CXTPControlGallery::StartAnimation(int nScrollPos)
  892. {
  893. CRect rcItems = GetItemsRect();
  895. if (nScrollPos > m_nTotalHeight - rcItems.Height())
  896. nScrollPos = m_nTotalHeight - rcItems.Height();
  898. if (nScrollPos < 0)
  899. nScrollPos = 0;
  901. if (m_bAnimation && m_nScrollPosTarget == nScrollPos)
  902. return;
  904. if (!m_bAnimation && m_nScrollPos == nScrollPos)
  905. return;
  907. m_bAnimation = TRUE;
  908. m_nScrollPosTarget = nScrollPos;
  909. m_dAnimationStep = double(m_nScrollPosTarget - m_nScrollPos) / (m_nTimerElapse > 200 ? 8.0 : 3.0);
  910. if (m_dAnimationStep > 0 && m_dAnimationStep < 1) m_dAnimationStep = 1;
  911. if (m_dAnimationStep < 0 && m_dAnimationStep > -1) m_dAnimationStep = -1;
  913. UINT nms = 40;
  914. SetTimer(GetParent()->GetSafeHwnd(), IDSYS_ANIMATE, nms, NULL);
  915. DoAnimate();
  916. }
  918. void CXTPControlGallery::SetScrollPos(int nScrollPos)
  919. {
  920. CRect rcItems = GetItemsRect();
  922. if (nScrollPos > m_nTotalHeight - rcItems.Height())
  923. nScrollPos = m_nTotalHeight - rcItems.Height();
  925. if (nScrollPos < 0)
  926. nScrollPos = 0;
  928. if (m_bAnimation)
  929. {
  930. m_bAnimation = FALSE;
  931. ::KillTimer(GetParent()->GetSafeHwnd(), IDSYS_ANIMATE);
  932. m_nScrollPos = -1;
  933. }
  935. if (m_nScrollPos == nScrollPos)
  936. return;
  938. m_nScrollPos = nScrollPos;
  939. Reposition();
  941. OnScrollChanged();
  942. InvalidateItems(NULL, FALSE);
  943. }
  946. void CXTPControlGallery::EnsureVisible(int nIndex)
  947. {
  948. if (!GetParent()->GetSafeHwnd())
  949. return;
  951. if (GetItemCount() == 0 || nIndex == -1 || nIndex >= GetItemCount() || nIndex >= (int)m_arrRects.GetSize())
  952. return;
  954. const GALLERYITEM_POSITION& pos = m_arrRects[nIndex];
  956. CRect rcItem = pos.rcItem;
  957. rcItem.OffsetRect(0, -m_nScrollPos);
  959. CRect rcItems = GetItemsRect();
  961. if (rcItem.top < rcItems.top)
  962. {
  963. int nScrollPos = pos.rcItem.top - rcItems.top;
  965. if (m_bShowLabels)
  966. {
  967. for (int i = nIndex - 1; i >= 0; i--)
  968. {
  969. const GALLERYITEM_POSITION& posLabel = m_arrRects[i];
  971. if (posLabel.pItem->IsLabel() && pos.rcItem.top - posLabel.rcItem.top <= rcItems.Height() - rcItem.Height())
  972. {
  973. nScrollPos = posLabel.rcItem.top - rcItems.top;
  974. break;
  975. }
  977. if (pos.rcItem.top - posLabel.rcItem.top > rcItems.Height()  - rcItem.Height())
  978. break;
  979. }
  980. }
  982. SetScrollPos(nScrollPos);
  983. }
  984. else if (rcItem.bottom > rcItems.bottom)
  985. {
  986. SetScrollPos(pos.rcItem.bottom - rcItems.bottom);
  987. }
  988. }
  990. long CXTPControlGallery::GetNextInRow(long nIndex, int nDirection) const
  991. {
  992. if (GetItemCount() == 0 || nIndex == -1 || nIndex >= GetItemCount())
  993. return -1;
  995. CRect rcItems = GetItemsRect();
  996. CSize szItem = GetItems()->GetItemSize();
  998. if (szItem.cx * 2 > rcItems.Width() || szItem.cx == 0)
  999. return nIndex;
  1000. int i;
  1002. if (nDirection < 0)
  1003. {
  1004. if (!m_arrRects[nIndex].bBeginRow)
  1005. {
  1006. for (i = nIndex - 1; i >= 0; i--)
  1007. {
  1008. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1010. if (!IsRectEmpty(&pos.rcItem))
  1011. {
  1012. return i;
  1013. }
  1014. }
  1015. }
  1017. for (i = nIndex + 1; i < m_arrRects.GetSize(); i++)
  1018. {
  1019. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1021. if (pos.bBeginRow)
  1022. {
  1023. return nIndex;
  1024. }
  1026. if (!IsRectEmpty(&pos.rcItem))
  1027. {
  1028. nIndex = i;
  1029. }
  1030. }
  1031. return nIndex;
  1032. }
  1033. else
  1034. {
  1035. for (i = nIndex + 1; i < GetItemCount(); i++)
  1036. {
  1037. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1039. if (!IsRectEmpty(&pos.rcItem) && !pos.bBeginRow)
  1040. {
  1041. return i;
  1042. }
  1044. if (pos.bBeginRow)
  1045. break;
  1046. }
  1048. for (i = nIndex; i >= 0; i--)
  1049. {
  1050. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1052. if (pos.bBeginRow)
  1053. {
  1054. return i;
  1055. }
  1056. }
  1057. }
  1059. return nIndex;
  1060. }
  1062. long CXTPControlGallery::GetNextInPage(long nIndex, int nDirection) const
  1063. {
  1064. if (GetItemCount() == 0)
  1065. return -1;
  1067. if (nIndex == -1 || nIndex >= GetItemCount())
  1068. nIndex = GetNext(-1, nDirection);
  1070. int i;
  1071. RECT rcItem = m_arrRects[nIndex].rcItem;
  1072. CRect rcItems = GetItemsRect();
  1074. if (nDirection < 0)
  1075. {
  1076. for (i = nIndex - 1; i >= 0; i--)
  1077. {
  1078. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1080. if (!pos.pItem->IsLabel() &&
  1081. rcItem.top - pos.rcItem.top< rcItems.Height())
  1082. {
  1083. nIndex = i;
  1084. }
  1086. if (rcItem.top - pos.rcItem.top> rcItems.Height())
  1087. return nIndex;
  1088. }
  1089. }
  1090. else
  1091. {
  1092. for (i = nIndex + 1; i < GetItemCount(); i++)
  1093. {
  1094. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1096. if (!pos.pItem->IsLabel() &&
  1097. pos.rcItem.bottom - rcItem.bottom < rcItems.Height())
  1098. {
  1099. nIndex = i;
  1100. }
  1102. if (pos.rcItem.bottom - rcItem.bottom > rcItems.Height())
  1103. return nIndex;
  1104. }
  1105. }
  1107. return nIndex;
  1109. }
  1111. long CXTPControlGallery::GetNextInColumn(long nIndex, int nDirection) const
  1112. {
  1113. if (GetItemCount() == 0)
  1114. return -1;
  1116. if (nIndex == -1 || nIndex >= GetItemCount())
  1117. return GetNext(-1, nDirection);
  1119. int i;
  1120. RECT rcItem = m_arrRects[nIndex].rcItem;
  1122. if (nDirection < 0)
  1123. {
  1124. for (i = nIndex - 1; i >= 0; i--)
  1125. {
  1126. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1128. if (!pos.pItem->IsLabel() && pos.rcItem.left == rcItem.left)
  1129. {
  1130. return i;
  1131. }
  1132. }
  1133. }
  1134. else
  1135. {
  1136. for (i = nIndex + 1; i < GetItemCount(); i++)
  1137. {
  1138. const GALLERYITEM_POSITION& pos = m_arrRects[i];
  1140. if (!pos.pItem->IsLabel() && pos.rcItem.left == rcItem.left)
  1141. {
  1142. return i;
  1143. }
  1144. }
  1146. }
  1148. return -1;
  1149. }
  1151. long CXTPControlGallery::GetNext(long nIndex, int nDirection) const
  1152. {
  1153. ASSERT(nDirection == +1 || nDirection == -1);
  1154. if (GetItemCount() == 0) return -1;
  1156. long nNext = nIndex + nDirection;
  1158. if (nDirection == -1 && nIndex == -1)
  1159. {
  1160. nNext = GetItemCount() - 1;
  1161. }
  1163. BOOL bCircle = FALSE;
  1165. while (nNext != nIndex)
  1166. {
  1167. if (nNext >= GetItemCount())
  1168. {
  1169. if ((nIndex == -1 && nDirection == +1) || bCircle) return -1;
  1170. nNext = 0;
  1171. bCircle = TRUE;
  1172. }
  1173. if (nNext < 0)
  1174. {
  1175. if ((nIndex == -1 && nDirection == -1) || bCircle) return -1;
  1176. nNext = GetItemCount() - 1;
  1177. bCircle = TRUE;
  1178. }
  1180. if (!GetItem(nNext)->IsLabel())
  1181. {
  1182. return nNext;
  1183. }
  1184. nNext += nDirection;
  1185. }
  1186. return nNext;
  1187. }
  1189. void CXTPControlGallery::SetSelectedItem(int nItem)
  1190. {
  1191. int nSelected = m_nSelected;
  1193. m_bHideSelection = FALSE;
  1194. m_nSelected = nItem;
  1195. m_bPressed = FALSE;
  1196. m_bKeyboardSelected = TRUE;
  1198. CXTPControlGalleryItems* pItems = GetItems();
  1200. if (pItems && pItems->m_bClipItems && nSelected != -1)
  1201. {
  1202. InvalidateItems(GetItemDrawRect(nSelected), TRUE);
  1203. }
  1205. EnsureVisible(m_nSelected);
  1207. if (pItems && pItems->m_bClipItems && m_nSelected != -1)
  1208. {
  1209. InvalidateItems(GetItemDrawRect(m_nSelected), FALSE);
  1210. }
  1212. if (!pItems || !pItems->m_bClipItems)
  1213. {
  1214. InvalidateItems();
  1215. }
  1217. if (m_nSelected != -1)
  1218. {
  1219. AccessibleNotifyWinEvent(EVENT_OBJECT_FOCUS , GetParent()->GetSafeHwnd(), GetID(), m_nSelected + 1);
  1220. }
  1222. if (m_nSelected != -1 && !m_bPreview)
  1223. {
  1224. m_bPreview = TRUE;
  1225. NotifySite(XTP_GN_PREVIEWSTART);
  1226. }
  1228. if (m_bPreview)
  1229. {
  1230. NotifySite(XTP_GN_PREVIEWCHANGE);
  1231. }
  1233. if (m_nSelected == -1 && m_bPreview)
  1234. {
  1235. m_bPreview = FALSE;
  1236. NotifySite(XTP_GN_PREVIEWCANCEL);
  1237. }
  1239. OnSelectedItemChanged();
  1240. }
  1242. int CXTPControlGallery::FindItem(int nStartAfter, LPCTSTR lpszItem, BOOL bExact) const
  1243. {
  1244. if (GetItemCount() == 0)
  1245. return -1;
  1247. UINT len1 = lpszItem ? (UINT)_tcslen(lpszItem) : 0;
  1248. if (len1 < 1)
  1249. return -1;
  1251. int nItem = nStartAfter + 1;
  1252. if (nItem >= GetItemCount())
  1253. nItem = 0;
  1255. if (nItem < 0)
  1256. nItem = 0;
  1258. int nStop = nItem;
  1260. do
  1261. {
  1262. CXTPControlGalleryItem* pItem = GetItem(nItem);
  1264. if (bExact )
  1265. {
  1266. if (pItem->GetCaption().CompareNoCase(lpszItem) == 0)
  1267. return nItem;
  1268. }
  1269. else
  1270. {
  1271. UINT len2 = pItem->GetCaption().GetLength();
  1273. int nResult = CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, lpszItem, min(len1,len2),
  1274. pItem->GetCaption(), min(len1,len2));
  1276. if (nResult == CSTR_EQUAL)
  1277. {
  1278. if (len1 <= len2)
  1279. {
  1280. return nItem;
  1281. }
  1282. }
  1285. }
  1287. if (++nItem == GetItemCount())
  1288. nItem = 0;
  1290. } while (nItem != nStop);
  1292. return -1;
  1293. }
  1295. int CXTPControlGallery::GetScrollPos() const
  1296. {
  1297. return m_nScrollPos;
  1298. }
  1300. int CXTPControlGallery::SetTopIndex(int nIndex)
  1301. {
  1302. if (nIndex == -1 || nIndex > m_arrRects.GetSize())
  1303. return -1;
  1305. SetScrollPos(m_arrRects[nIndex].rcItem.top);
  1306. return 0;
  1307. }
  1309. CString CXTPControlGallery::GetItemCaption(int nIndex)
  1310. {
  1311. CXTPControlGalleryItem* pItem = GetItem(nIndex);
  1313. if (pItem)
  1314. return pItem->GetCaption();
  1316. return _T("");
  1317. }
  1319. void CXTPControlGallery::DoScroll(int cmd, int pos)
  1320. {
  1321. int y = m_bAnimation ? m_nScrollPosTarget : m_nScrollPos;
  1322. CRect rcItems = GetItemsRect();
  1324. CXTPControlGalleryItems* pItems = GetItems();
  1325. if (!pItems)
  1326. return;
  1328. switch (cmd)
  1329. {
  1330. case SB_TOP:
  1331. y = 0;
  1332. break;
  1333. case SB_BOTTOM:
  1334. y = m_nTotalHeight;
  1335. break;
  1336. case SB_LINEUP:
  1337. y -= pItems->GetItemSize().cy;
  1338. break;
  1339. case SB_LINEDOWN:
  1340. y += pItems->GetItemSize().cy;
  1341. break;
  1342. case SB_PAGEUP:
  1343. y -= rcItems.Height();
  1344. break;
  1345. case SB_PAGEDOWN:
  1346. y += rcItems.Height();
  1347. break;
  1348. case SB_THUMBTRACK:
  1349. y = pos;
  1350. break;
  1351. }
  1353. if (GetCommandBar() && (cmd == SB_LINEUP || cmd == SB_LINEDOWN || cmd == SB_ENDSCROLL))
  1354. {
  1355. StartAnimation(y);
  1356. }
  1357. else
  1358. {
  1359. SetScrollPos(y);
  1360. }
  1361. }
  1363. void CXTPControlGallery::GetScrollInfo(SCROLLINFO* pSI)
  1364. {
  1365. CRect rcItems = GetItemsRect();
  1367. pSI->nMin = 0;
  1368. pSI->nMax = max(0, m_nTotalHeight - 1);
  1369. pSI->nPos = m_nScrollPos;
  1370. pSI->nPage = rcItems.Height();
  1371. }
  1374. //////////////////////////////////////////////////////////////////////////
  1376. CSize CXTPControlGallery::GetSize(CDC* pDC)
  1377. {
  1378. if (IsShowAsButton())
  1379. {
  1380. int nWidth = m_nWidth, nHeight = m_nHeight;
  1381. m_nWidth = m_nHeight = 0;
  1383. CSize sz = CXTPControlPopup::GetSize(pDC);
  1384. m_nWidth = nWidth; m_nHeight = nHeight;
  1385. return sz;
  1386. }
  1388. return CSize(max(IsResizable() ? GetCustomizeMinWidth() : 0, m_nWidth), m_nHeight);
  1389. }
  1391. void CXTPControlGallery::RedrawScrollBar()
  1392. {
  1393. InvalidateItems(NULL, FALSE);
  1394. }
  1396. void CXTPControlGallery::DrawScrollBar(CDC* pDC)
  1397. {
  1398. if (GetCommandBar())
  1399. GetGalleryPaintManager()->DrawPopupScrollBar(pDC, this);
  1400. else
  1401. GetGalleryPaintManager()->DrawScrollBar(pDC, this);
  1402. }
  1404. void CXTPControlGallery::Draw(CDC* pDC)
  1405. {
  1406. if (IsShowAsButton())
  1407. {
  1408. CXTPControlPopup::Draw(pDC);
  1409. return;
  1410. }
  1411. FillControl(pDC, m_rcControl);
  1413. DrawItems(pDC);
  1415. if (m_bShowScrollBar)
  1416. {
  1417. DrawScrollBar(pDC);
  1418. }
  1419. }
  1421. void CXTPControlGallery::OnMouseMove(CPoint point)
  1422. {
  1423. if (IsShowAsButton())
  1424. {
  1425. CXTPControlPopup::OnMouseMove(point);
  1426. return;
  1427. }
  1429. PerformMouseMove(point);
  1431. int ht = HitTestScrollBar(point);
  1433. if (ht != m_spi.ht)
  1434. {
  1435. m_spi.ht = ht;
  1436. RedrawParent();
  1437. }
  1438. }
  1440. void CXTPControlGallery::HideSelection()
  1441. {
  1442. m_bHideSelection = TRUE;
  1443. m_bKeyboardSelected = FALSE;
  1445. if (m_nSelected != -1)
  1446. {
  1447. CXTPControlGalleryItems* pItems = GetItems();
  1449. if (pItems && pItems->m_bClipItems)
  1450. {
  1451. InvalidateItems(GetItemDrawRect(m_nSelected), FALSE);
  1452. }
  1453. else
  1454. {
  1455. InvalidateItems();
  1456. }
  1457. }
  1459. if (m_bPreview && m_nSelected != -1)
  1460. {
  1461. NotifySite(XTP_GN_PREVIEWCHANGE);
  1462. }
  1464. if (m_bPreview)
  1465. {
  1466. m_bPreview = FALSE;
  1467. NotifySite(XTP_GN_PREVIEWCANCEL);
  1468. }
  1470. OnSelectedItemChanged();
  1471. }
  1473. void CXTPControlGallery::OnSelectedItemChanged()
  1474. {
  1475. NotifySite(XTP_GN_SELCHANGE);
  1476. }
  1478. BOOL CXTPControlGallery::OnSetSelected(int bSelected)
  1479. {
  1480. if (IsShowAsButton())
  1481. {
  1482. return CXTPControlPopup::OnSetSelected(bSelected);
  1483. }
  1485. if (!bSelected)
  1486. {
  1487. m_bPressed = FALSE;
  1488. m_spi.ht = HTNOWHERE;
  1489. HideSelection();
  1490. }
  1492. if (IsKeyboardSelected(bSelected) && !IsItemSelected())
  1493. {
  1494. if (GetCommandBar() == NULL)
  1495. {
  1496. SetSelectedItem(GetNext(-1, bSelected == TRUE_KEYBOARD_PREV ? -1 : +1));
  1497. }
  1498. else
  1499. {
  1500. SetSelectedItem(-1);
  1501. }
  1502. }
  1504. return CXTPControl::OnSetSelected(bSelected);
  1505. }
  1508. BOOL CXTPControlGallery::IsFocused() const
  1509. {
  1510. return IsShowAsButton() ? FALSE : GetSelected();
  1511. }
  1514. BOOL CXTPControlGallery::OnHookKeyDown(UINT nChar, LPARAM /*lParam*/)
  1515. {
  1516. ASSERT(IsFocused());
  1518. if (!IsFocused())
  1519. return FALSE;
  1521. if (m_nSelected == -1 && GetCommandBar() != NULL)
  1522. {
  1523. if (nChar == VK_RETURN || nChar == VK_SPACE)
  1524. {
  1525. GetParent()->SetPopuped(m_nIndex);
  1526. return TRUE;
  1527. }
  1528. return FALSE;
  1529. }
  1531. int nSelected;
  1532. CXTPDrawHelpers::KeyToLayout(CXTPControl::GetParent(), nChar);
  1534. switch (nChar)
  1535. {
  1536. case VK_HOME:
  1537. SetSelectedItem(GetNext(-1, +1));
  1538. return TRUE;
  1540. case VK_END:
  1541. SetSelectedItem(GetNext(-1, -1));
  1542. return TRUE;
  1544. case VK_LEFT:
  1545. SetSelectedItem(GetNextInRow(m_nSelected, -1));
  1546. return TRUE;
  1548. case VK_RIGHT:
  1549. SetSelectedItem(GetNextInRow(m_nSelected, +1));
  1550. return TRUE;
  1552. case VK_UP:
  1553. nSelected = GetNextInColumn(m_nSelected, -1);
  1555. if (nSelected == -1 && GetControls()->GetNext(m_nIndex, -1) == m_nIndex)
  1556. {
  1557. nSelected = GetNext(-1, -1);
  1558. }
  1560. if (nSelected != -1)
  1561. {
  1562. SetSelectedItem(nSelected);
  1563. return TRUE;
  1564. }
  1565. return FALSE;
  1567. case VK_PRIOR:
  1568. SetSelectedItem(GetNextInPage(m_nSelected, -1));
  1569. return TRUE;
  1571. case VK_NEXT:
  1572. SetSelectedItem(GetNextInPage(m_nSelected, +1));
  1573. return TRUE;
  1575. case VK_DOWN:
  1576. nSelected = GetNextInColumn(m_nSelected, +1);
  1578. if (nSelected == -1 && GetControls()->GetNext(m_nIndex, +1) == m_nIndex)
  1579. {
  1580. nSelected = GetNext(-1, +1);
  1581. }
  1583. if (nSelected != -1)
  1584. {
  1585. SetSelectedItem(nSelected);
  1586. return TRUE;
  1587. }
  1588. return FALSE;
  1590. case VK_TAB:
  1591. if (GetKeyState(VK_SHIFT) >= 0)
  1592. {
  1593. nSelected = GetNext(m_nSelected, +1);
  1594. if (nSelected > m_nSelected)
  1595. {
  1596. SetSelectedItem(nSelected);
  1597. return TRUE;
  1598. }
  1599. }
  1600. else
  1601. {
  1602. nSelected = GetNext(m_nSelected, -1);
  1603. if (nSelected < m_nSelected)
  1604. {
  1605. SetSelectedItem(nSelected);
  1606. return TRUE;
  1607. }
  1608. }
  1609. return FALSE;
  1611. case VK_RETURN:
  1612. OnExecute();
  1613. break;
  1614. }
  1616. return FALSE;
  1617. }
  1619. BOOL CXTPControlGallery::OnHookMouseWheel(UINT /*nFlags*/, short zDelta, CPoint /*pt*/)
  1620. {
  1621. CXTPControlGalleryItems* pItems = GetItems();
  1622. if (!pItems)
  1623. return FALSE;
  1625. SetScrollPos(m_nScrollPos + (zDelta < 0 ? 3 * pItems->GetItemSize().cy : -3 * pItems->GetItemSize().cy));
  1626. return TRUE;
  1627. }
  1629. void CXTPControlGallery::OnScrollChanged()
  1630. {
  1631. SetupScrollInfo();
  1632. }
  1634. void CXTPControlGallery::OnClick(BOOL bKeyboard /*= FALSE*/, CPoint point /*= CPoint(0, 0)*/)
  1635. {
  1636. if (IsShowAsButton())
  1637. {
  1638. CXTPControlPopup::OnClick(bKeyboard, point);
  1639. return;
  1640. }
  1642. if (IsCustomizeMode())
  1643. {
  1644. m_pParent->SetPopuped(-1);
  1645. m_pParent->SetSelected(-1);
  1646. CustomizeStartDrag(point);
  1647. return;
  1648. }
  1650. if (!GetEnabled())
  1651. return;
  1653. if (!bKeyboard)
  1654. {
  1655. OnMouseMove(point);
  1657. if (m_spi.ht == XTP_HTSCROLLPOPUP)
  1658. {
  1659. m_pParent->SetPopuped(m_nIndex);
  1660. }
  1661. else if (m_spi.ht != HTNOWHERE)
  1662. {
  1663. PerformTrackInit(CXTPControl::GetParent()->GetSafeHwnd(), point, &m_spi, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  1664. }
  1665. else
  1666. {
  1667. m_pParent->SetPopuped(-1);
  1668. PerformMouseDown(point);
  1669. }
  1670. }
  1671. else
  1672. {
  1674. }
  1675. }
  1677. void CXTPControlGallery::OnLButtonUp(CPoint point)
  1678. {
  1679. if (IsShowAsButton())
  1680. {
  1681. CXTPControlPopup::OnLButtonUp(point);
  1682. }
  1683. else
  1684. {
  1685. PerformMouseUp(point);
  1686. }
  1687. }
  1690. CRect CXTPControlGallery::GetScrollBarRect()
  1691. {
  1692. if (!m_bShowScrollBar)
  1693. return CRect(0, 0, 0, 0);
  1695. CRect rc(m_rcControl);
  1697. rc.left = rc.right - (GetCommandBar() ? GetGalleryPaintManager()->m_cxPopup :
  1698. GetGalleryPaintManager()->m_cxVScroll);
  1700. if (m_bShowBorders)
  1701. {
  1702. rc.top++;
  1703. rc.bottom--;
  1704. rc.right--;
  1705. rc.left--;
  1706. }
  1708. if (HasBottomSeparator())
  1709. rc.bottom -= 2;
  1711. return rc;
  1712. }
  1714. void CXTPControlGallery::CalcScrollBarInfo(LPRECT lprc, SCROLLBARPOSINFO* pSBInfo, SCROLLINFO* pSI)
  1715. {
  1716. if (GetCommandBar())
  1717. {
  1718. pSBInfo->rc = *lprc;
  1719. pSBInfo->pxTop = lprc->top;
  1720. pSBInfo->pxBottom = lprc->bottom;
  1721. pSBInfo->pxLeft = lprc->left;
  1722. pSBInfo->pxRight = lprc->right;
  1724. pSBInfo->pos = pSI->nPos;
  1725. pSBInfo->page = pSI->nPage;
  1726. pSBInfo->posMin = pSI->nMin;
  1727. pSBInfo->posMax = pSI->nMax;
  1729. pSBInfo->pxDownArrow = pSBInfo->pxUpArrow  = pSBInfo->pxTop + GetGalleryPaintManager()->m_cyPopupUp;
  1730. pSBInfo->pxPopup = pSBInfo->pxDownArrow + GetGalleryPaintManager()->m_cyPopupDown;
  1731. }
  1732. else
  1733. {
  1734. CXTPScrollBase::CalcScrollBarInfo(lprc, pSBInfo, pSI);
  1735. }
  1736. }
  1738. CWnd* CXTPControlGallery::GetParentWindow() const
  1739. {
  1740. return CXTPControl::GetParent();
  1741. }
  1743. void CXTPControlGallery::SetRect(CRect rcControl)
  1744. {
  1745. if (m_rcControl == rcControl)
  1746. return;
  1748. CXTPControl::SetRect(rcControl);
  1749. Reposition();
  1750. }
  1752. void CXTPControlGallery::Copy(CXTPControl* pControl, BOOL bRecursive)
  1753. {
  1754. ASSERT(DYNAMIC_DOWNCAST(CXTPControlGallery, pControl));
  1756. CXTPControlPopup::Copy(pControl, bRecursive);
  1758. CXTPControlGallery* pGallery = (CXTPControlGallery*)pControl;
  1760. m_bShowLabels = pGallery->m_bShowLabels;
  1761. m_bShowBorders = pGallery->m_bShowBorders;
  1762. m_bShowScrollBar = pGallery->m_bShowScrollBar;
  1764. m_rcMargin = pGallery->m_rcMargin;
  1765. m_nResizable = pGallery->m_nResizable;
  1766. }
  1768. void CXTPControlGallery::DoPropExchange(CXTPPropExchange* pPX)
  1769. {
  1770. CXTPControlPopup::DoPropExchange(pPX);
  1772. PX_Bool(pPX, _T("ShowLabels"), m_bShowLabels, TRUE);
  1773. PX_Bool(pPX, _T("ShowBorders"), m_bShowBorders, TRUE);
  1774. PX_Bool(pPX, _T("ShowScrollBar"), m_bShowScrollBar, TRUE);
  1776. PX_Rect(pPX, _T("GalleryMargin"), m_rcMargin, CRect(0, 0, 0, 0));
  1778. if (pPX->GetSchema() > _XTP_SCHEMA_110)
  1779. {
  1780. PX_Int(pPX, _T("Resizable"), m_nResizable, 0);
  1781. }
  1782. }
  1784. INT_PTR CXTPControlGallery::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
  1785. {
  1786. if (IsShowAsButton() || GetItems() == NULL)
  1787. {
  1788. return -1;
  1789. }
  1791. RECT rcItem;
  1792. int nIndex = HitTestItem(point, &rcItem);
  1793. if (nIndex != -1)
  1794. {
  1795. CXTPControlGalleryItem* pItem = GetItem(nIndex);
  1797. INT_PTR nHit = pItem->m_nImage >= 0 ? pItem->m_nImage : pItem->m_nId;
  1799. CXTPToolTipContext::FillInToolInfo(pTI, GetParent()->GetSafeHwnd(), rcItem, nHit,
  1800. pItem->GetToolTip(), pItem->GetToolTip(), pItem->GetDescription(), GetItems()->GetImageManager());
  1802. return nHit;
  1803. }
  1804. return 0;
  1805. }
  1807. BOOL CXTPControlGallery::IsScrollBarEnabled() const
  1808. {
  1809. return GetEnabled();
  1810. }
  1812. BOOL CXTPControlGallery::IsScrollButtonEnabled(int ht)
  1813. {
  1814. if (!GetEnabled())
  1815. return FALSE;
  1817. if (!GetCommandBar())
  1818. return TRUE;
  1820. if (ht == XTP_HTSCROLLUP)
  1821. {
  1822. return m_nScrollPos > 0;
  1823. }
  1824. else if (ht == XTP_HTSCROLLDOWN)
  1825. {
  1826. CRect rcItems = GetItemsRect();
  1827. return m_nScrollPos < m_nTotalHeight - rcItems.Height();
  1828. }
  1829. else
  1830. {
  1831. ASSERT(FALSE);
  1832. }
  1834. return TRUE;
  1835. }
  1837. void CXTPControlGallery::SetItemsMargin(int nLeft, int nTop, int nRight, int nBottom)
  1838. {
  1839. m_rcMargin.SetRect(nLeft, nTop, nRight, nBottom);
  1840. }
  1842. void CXTPControlGallery::AdjustExcludeRect(CRect& rc, BOOL bVertical)
  1843. {
  1844. if (IsShowAsButton())
  1845. {
  1846. CXTPControlPopup::AdjustExcludeRect(rc, bVertical);
  1847. }
  1848. else
  1849. {
  1850. rc.SetRect(m_rcControl.left - 1, m_rcControl.top, m_rcControl.left - 1, m_rcControl.top);
  1851. }
  1852. }
  1854. HRESULT CXTPControlGallery::GetAccessibleChildCount(long FAR* pChildCount)
  1855. {
  1856. if (pChildCount == 0)
  1857. return E_INVALIDARG;
  1859. *pChildCount = GetItemCount();
  1861. return S_OK;
  1862. }
  1863. HRESULT CXTPControlGallery::GetAccessibleChild(VARIANT /*varChild*/, IDispatch* FAR* ppdispChild)
  1864. {
  1865. SAFE_MANAGE_STATE(m_pModuleState);
  1867. *ppdispChild = NULL;
  1868. return S_FALSE;
  1869. }
  1871. HRESULT CXTPControlGallery::GetAccessibleName(VARIANT varChild, BSTR* pszName)
  1872. {
  1873. SAFE_MANAGE_STATE(m_pModuleState);
  1875. int nIndex = GetChildIndex(&varChild);
  1877. if (nIndex == CHILDID_SELF)
  1878. return CXTPControl::GetAccessibleName(varChild, pszName);
  1880. CXTPControlGalleryItem* pItem = GetItem(nIndex - 1);
  1881. if (!pItem)
  1882. return E_INVALIDARG;
  1884. CString strCaption = pItem->GetCaption();
  1885. CXTPDrawHelpers::StripMnemonics(strCaption);
  1887. if (strCaption.IsEmpty())
  1888. {
  1889. strCaption = pItem->GetToolTip();
  1890. }
  1892. *pszName = strCaption.AllocSysString();
  1893. return S_OK;
  1894. }
  1896. HRESULT CXTPControlGallery::GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole)
  1897. {
  1898. pvarRole->vt = VT_I4;
  1899. pvarRole->lVal = GetChildIndex(&varChild) == CHILDID_SELF ? ROLE_SYSTEM_LISTITEM : ROLE_SYSTEM_LIST;
  1900. return S_OK;
  1901. }
  1903. HRESULT CXTPControlGallery::AccessibleSelect(long flagsSelect, VARIANT varChild)
  1904. {
  1905. SAFE_MANAGE_STATE(m_pModuleState);
  1907. int nIndex = GetChildIndex(&varChild);
  1908. if (nIndex == CHILDID_SELF)
  1909. return CXTPControl::AccessibleSelect(flagsSelect, varChild);
  1911. SetSelectedItem(nIndex - 1);
  1913. return S_OK;
  1914. }
  1916. HRESULT CXTPControlGallery::GetAccessibleState(VARIANT varChild, VARIANT* pvarState)
  1917. {
  1918. int nIndex = GetChildIndex(&varChild);
  1920. if (nIndex == CHILDID_SELF)
  1921. return CXTPControl::GetAccessibleState(varChild, pvarState);
  1923. CXTPControlGalleryItem* pItem = GetItem(nIndex - 1);
  1924. if (!pItem)
  1925. return E_INVALIDARG;
  1927. pvarState->vt = VT_I4;
  1928. pvarState->lVal = STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_SELECTABLE;
  1930. if (m_nSelected == pItem->GetIndex())
  1931. pvarState->lVal |= STATE_SYSTEM_FOCUSED;
  1933. if (m_nChecked == pItem->GetID())
  1934. pvarState->lVal |= STATE_SYSTEM_SELECTED;
  1936. return S_OK;
  1937. }
  1939. HRESULT CXTPControlGallery::GetAccessibleDefaultAction(VARIANT varChild, BSTR* pszDefaultAction)
  1940. {
  1941. if (GetChildIndex(&varChild) == CHILDID_SELF)
  1942. return CXTPControl::GetAccessibleDefaultAction(varChild, pszDefaultAction);
  1944. *pszDefaultAction = SysAllocString(L"Click");
  1946. return S_OK;
  1947. }
  1949. HRESULT CXTPControlGallery::AccessibleDoDefaultAction(VARIANT varChild)
  1950. {
  1951. SAFE_MANAGE_STATE(m_pModuleState);
  1953. int nIndex = GetChildIndex(&varChild);
  1955. if (nIndex == CHILDID_SELF)
  1956. return CXTPControl::AccessibleDoDefaultAction(varChild);
  1958. CXTPControlGalleryItem* pItem = GetItem(nIndex - 1);
  1959. if (!pItem)
  1960. return E_INVALIDARG;
  1962. SetSelectedItem(nIndex - 1);
  1963. return S_OK;
  1964. }
  1967. HRESULT CXTPControlGallery::AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight, VARIANT varChild)
  1968. {
  1969. *pxLeft = *pyTop = *pcxWidth = *pcyHeight = 0;
  1971. int nIndex = GetChildIndex(&varChild);
  1973. if (!m_pParent->GetSafeHwnd())
  1974. return S_OK;
  1976. if (!IsVisible())
  1977. return S_OK;
  1979. CRect rcControl = GetRect();
  1981. if (nIndex != CHILDID_SELF)
  1982. {
  1983. rcControl = GetItemDrawRect(nIndex - 1);
  1984. }
  1986. m_pParent->ClientToScreen(&rcControl);
  1988. *pxLeft = rcControl.left;
  1989. *pyTop = rcControl.top;
  1990. *pcxWidth = rcControl.Width();
  1991. *pcyHeight = rcControl.Height();
  1993. return S_OK;
  1994. }
  1996. HRESULT CXTPControlGallery::AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarID)
  1997. {
  1998. if (pvarID == NULL)
  1999. return E_INVALIDARG;
  2001. pvarID->vt = VT_EMPTY;
  2003. if (!m_pParent->GetSafeHwnd())
  2004. return S_FALSE;
  2006. if (!CXTPWindowRect(m_pParent).PtInRect(CPoint(xLeft, yTop)))
  2007. return S_FALSE;
  2009. pvarID->vt = VT_I4;
  2010. pvarID->lVal = CHILDID_SELF;
  2012. CPoint pt(xLeft, yTop);
  2013. m_pParent->ScreenToClient(&pt);
  2015. if (!GetRect().PtInRect(pt))
  2016. return S_FALSE;
  2018. int nIndex = HitTestItem(pt);
  2019. if (nIndex != -1)
  2020. {
  2021. pvarID->lVal = nIndex + 1;
  2022. }
  2024. return S_OK;
  2025. }
  2027. //////////////////////////////////////////////////////////////////////////
  2028. // CXTPControlComboBoxGalleryPopupBar
  2030. IMPLEMENT_XTP_COMMANDBAR(CXTPControlComboBoxGalleryPopupBar, CXTPControlComboBoxPopupBar)
  2032. CXTPControlComboBoxGalleryPopupBar::CXTPControlComboBoxGalleryPopupBar()
  2033. {
  2034. }
  2036. CXTPControlComboBoxGalleryPopupBar* AFX_CDECL CXTPControlComboBoxGalleryPopupBar::CreateComboBoxGalleryPopupBar(CXTPCommandBars* pCommandBars)
  2037. {
  2038. CXTPControlComboBoxGalleryPopupBar* pPopupBar = new CXTPControlComboBoxGalleryPopupBar();
  2039. pPopupBar->SetCommandBars(pCommandBars);
  2040. return pPopupBar;
  2041. }
  2043. BEGIN_MESSAGE_MAP(CXTPControlComboBoxGalleryPopupBar, CXTPControlComboBoxPopupBar)
  2044. ON_WM_LBUTTONUP()
  2045. END_MESSAGE_MAP()
  2047. CXTPControlGallery* CXTPControlComboBoxGalleryPopupBar::GetGalleryItem() const
  2048. {
  2049. CXTPControl* pItem = GetControl(0);
  2050. ASSERT_KINDOF(CXTPControlGallery, pItem);
  2052. return (CXTPControlGallery*)pItem;
  2053. }
  2055. void CXTPControlComboBoxGalleryPopupBar::OnLButtonUp(UINT nFlags, CPoint point)
  2056. {
  2057. if (GetControls()->HitTest(point) == GetGalleryItem())
  2058. {
  2059. CXTPControlComboBox* pComboBox = (CXTPControlComboBox*)m_pControlPopup;
  2060. pComboBox->OnSelChanged();
  2061. pComboBox->OnExecute();
  2062. return;
  2063. }
  2065. CXTPPopupBar::OnLButtonUp(nFlags, point);
  2066. }
  2068. BOOL CXTPControlComboBoxGalleryPopupBar::SetTrackingMode(int bMode, BOOL bSelectFirst, BOOL bKeyboard)
  2069. {
  2070. CXTPControlComboBox* pComboBox = ((CXTPControlComboBox*)m_pControlPopup);
  2072. if (!CXTPPopupBar::SetTrackingMode(bMode, bSelectFirst, bKeyboard))
  2073. return FALSE;
  2075. if (!bMode)
  2076. {
  2077. pComboBox->NotifySite(CBN_CLOSEUP);
  2079. }
  2080. else
  2081. {
  2082. SetSelected(0, TRUE);
  2084. pComboBox->UpdatePopupSelection();
  2085. pComboBox->NotifySite(CBN_DROPDOWN);
  2087. }
  2089. return TRUE;
  2090. }
  2092. BOOL CXTPControlComboBoxGalleryPopupBar::OnHookKeyDown(UINT nChar, LPARAM lParam)
  2093. {
  2094. ASSERT(m_pControlPopup);
  2095. CXTPControlComboBox* pComboBox = ((CXTPControlComboBox*)m_pControlPopup);
  2096. if (!pComboBox)
  2097. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  2099. if (nChar == VK_ESCAPE)
  2100. {
  2101. if (pComboBox->IsFocused())
  2102. return FALSE;
  2104. return CXTPCommandBar::OnHookKeyDown(nChar, lParam);
  2105. }
  2107. if (nChar == VK_TAB) return FALSE;
  2109. if (nChar == VK_RETURN)
  2110. {
  2111. if (GetControl(m_nSelected) == GetGalleryItem())
  2112. {
  2113. m_pControlPopup->OnExecute();
  2114. return TRUE;
  2115. }
  2116. }
  2118. return ProcessHookKeyDown(pComboBox, nChar, lParam);
  2119. }
  2121. //////////////////////////////////////////////////////////////////////////
  2122. // CXTPControlGalleryPaintManager
  2124. CXTPControlGalleryPaintManager::CXTPControlGalleryPaintManager(CXTPPaintManager* pPaintManager)
  2125. : CXTPScrollBarPaintManager(pPaintManager)
  2126. {
  2127. m_cyPopupUp = m_cyPopupDown = 19;
  2128. m_cxPopup = 16;
  2129. }
  2131. void CXTPControlGalleryPaintManager::DrawLabel(CDC* pDC, CXTPControlGalleryItem* pLabel, CRect rcItem)
  2132. {
  2133. CXTPPaintManager* pPaintManager = m_pPaintManager;
  2134. pDC->FillSolidRect(rcItem, pPaintManager->GetXtremeColor(XPCOLOR_LABEL));
  2136. pDC->FillSolidRect(rcItem.left, rcItem.bottom - 1, rcItem.Width(), 1, pPaintManager->GetXtremeColor(XPCOLOR_3DSHADOW));
  2138. CXTPFontDC fnt(pDC, pPaintManager->GetRegularBoldFont());
  2140. CRect rcText(rcItem);
  2141. rcText.DeflateRect(10, 0);
  2142. pDC->SetTextColor(pPaintManager->GetXtremeColor(XPCOLOR_MENUBAR_TEXT));
  2143. pDC->DrawText(pLabel->GetCaption(), rcText, DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
  2144. }
  2146. void CXTPControlGalleryPaintManager::FillControl(CDC* pDC, CXTPControlGallery* pGallery, CRect rcControl)
  2147. {
  2148. pDC->FillSolidRect(rcControl, m_pPaintManager->GetXtremeColor(XPCOLOR_MENUBAR_FACE));
  2150. if (pGallery->IsShowBorders())
  2151. {
  2152. pDC->Draw3dRect(rcControl, m_pPaintManager->GetXtremeColor(XPCOLOR_3DSHADOW),
  2153. m_pPaintManager->GetXtremeColor(XPCOLOR_3DSHADOW));
  2154. }
  2156. if (pGallery->HasBottomSeparator())
  2157. {
  2158. pDC->FillSolidRect(rcControl.left, rcControl.bottom - 2, rcControl.Width(), 1, m_pPaintManager->GetXtremeColor(XPCOLOR_SEPARATOR));
  2159. }
  2160. }
  2162. void CXTPControlGalleryPaintManager::RefreshMetrics()
  2163. {
  2164. CXTPScrollBarPaintManager::RefreshMetrics();
  2166. m_cyPopupUp = m_cyPopupDown = 19;
  2167. m_cxPopup = 16;
  2168. }
  2170. void CXTPControlGalleryPaintManager::DrawScrollBar(CDC* pDC, CXTPScrollBase* pGallery)
  2171. {
  2172. CXTPScrollBarPaintManager::DrawScrollBar(pDC, pGallery);
  2173. }
  2175. void CXTPControlGalleryPaintManager::DrawPopupScrollBar(CDC* pDC, CXTPControlGallery* pGallery)
  2176. {
  2177. #define GETPARTSTATE3(ht, bEnabled) 
  2178. (!bEnabled ? 4 : nPressetHt == ht ? 3 : nHotHt == ht ? 2 : 0)
  2180. CXTPControlGallery::SCROLLBARTRACKINFO* pSBTrack = pGallery->GetScrollBarTrackInfo();
  2181. CXTPControlGallery::SCROLLBARPOSINFO* pSBInfo = pGallery->GetScrollBarPosInfo();
  2183. CRect rcScroll = pSBInfo->rc;
  2184. pDC->FillSolidRect(rcScroll, m_pPaintManager->GetXtremeColor(XPCOLOR_TOOLBAR_FACE));
  2186. CRect rcScrollUp(rcScroll.left, rcScroll.top, rcScroll.right, rcScroll.top + m_cyPopupUp);
  2187. CRect rcScrollDown(rcScroll.left, rcScrollUp.bottom, rcScroll.right, rcScrollUp.bottom + m_cyPopupDown);
  2188. CRect rcScrollPopup(rcScroll.left, rcScrollDown.bottom, rcScroll.right, rcScroll.bottom);
  2190. BOOL bControlEnabled = pGallery->GetEnabled();
  2191. BOOL nPressetHt = pSBTrack ? pSBInfo->ht : -1;
  2192. BOOL nHotHt = pSBTrack ? -1 : pSBInfo->ht;
  2194. int nState = GETPARTSTATE3(XTP_HTSCROLLUP, (bControlEnabled && pGallery->IsScrollButtonEnabled(XTP_HTSCROLLUP)));
  2195. m_pPaintManager->DrawRectangle(pDC, rcScrollUp, nState == 3 || nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2196. COLORREF clr = m_pPaintManager->GetRectangleTextColor(nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2197. CPoint pt = rcScrollUp.CenterPoint();
  2198. m_pPaintManager->Triangle(pDC, CPoint(pt.x - 4 , pt.y + 2), CPoint(pt.x + 4, pt.y + 2), CPoint (pt.x, pt.y - 2), clr);
  2200. nState = GETPARTSTATE3(XTP_HTSCROLLDOWN, (bControlEnabled && pGallery->IsScrollButtonEnabled(XTP_HTSCROLLDOWN)));
  2201. m_pPaintManager->DrawRectangle(pDC, rcScrollDown, nState == 3 || nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2202. clr = m_pPaintManager->GetRectangleTextColor(nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2203. pt = rcScrollDown.CenterPoint();
  2204. m_pPaintManager->Triangle(pDC, CPoint(pt.x - 4 , pt.y - 2), CPoint(pt.x + 4, pt.y - 2), CPoint (pt.x, pt.y + 2), clr);
  2206. nState = GETPARTSTATE3(XTP_HTSCROLLPOPUP, bControlEnabled);
  2207. m_pPaintManager->DrawRectangle(pDC, rcScrollPopup, nState == 3 || nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2208. clr = m_pPaintManager->GetRectangleTextColor(nState == 2, nState == 3, nState != 4, FALSE, FALSE, xtpBarTypeNormal, xtpBarPopup);
  2209. pt = rcScrollPopup.CenterPoint();
  2210. m_pPaintManager->Triangle(pDC, CPoint(pt.x - 4 , pt.y - 1), CPoint(pt.x + 4, pt.y - 1), CPoint (pt.x, pt.y + 3), clr);
  2211. pDC->FillSolidRect(pt.x - 4, pt.y - 4, 9, 2, clr);
  2212. }