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

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

对话框与窗口

开发平台：

Visual C++

XTPScrollBar.cpp：源码内容
  1. // XTPScrollBar.cpp : implementation of the CXTPScrollBar 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"
  23. #include "Common/XTPDrawHelpers.h"
  25. #include "XTPCommandBars.h"
  26. #include "XTPPaintManager.h"
  27. #include "XTPScrollBar.h"
  28. #include "XTPMouseManager.h"
  31. #define IDSYS_SCROLL 23345
  32. #define IDSYS_ANIMATE 23346
  35. //////////////////////////////////////////////////////////////////////////
  36. //  CXTPScrollBase
  38. CXTPScrollBase::SLIDERTICKS::SLIDERTICKS(double* pTicks, int nCount)
  39. {
  40. this->nCount = nCount;
  41. this->pTicks = new double[nCount];
  43. for (int i = 0; i < nCount; i++)
  44. this->pTicks[i] = pTicks[i];
  45. }
  47. CXTPScrollBase::SLIDERTICKS::~SLIDERTICKS()
  48. {
  49. SAFE_DELETE(pTicks);
  50. }
  52. CXTPScrollBase::CXTPScrollBase()
  53. {
  54. ZeroMemory(&m_spi, sizeof(m_spi));
  55. m_spi.fVert = TRUE;
  57. m_pSBTrack = NULL;
  59. m_scrollBarStyle = xtpScrollStyleDefault;
  61. m_bAnimation = FALSE;
  62. m_nTimerElapse = 0;
  64. m_pTicks = NULL;
  65. }
  67. CXTPScrollBase::~CXTPScrollBase()
  68. {
  69. SAFE_DELETE(m_pTicks);
  70. }
  72. void CXTPScrollBase::CalcScrollBarInfo(LPRECT lprc, SCROLLBARPOSINFO* pSBInfo, SCROLLINFO* pSI)
  73. {
  74. int cpx;
  75. DWORD dwRange;
  76. int denom;
  77. BOOL fVert = pSBInfo->fVert;
  79. pSBInfo->rc = *lprc;
  80. pSBInfo->pxPopup = 0;
  82. CXTPScrollBarPaintManager* pPaintManager = GetScrollBarPaintManager();
  84. if (fVert)
  85. {
  86. pSBInfo->pxTop = lprc->top;
  87. pSBInfo->pxBottom = lprc->bottom;
  88. pSBInfo->pxLeft = lprc->left;
  89. pSBInfo->pxRight = lprc->right;
  90. pSBInfo->cpxThumb = pPaintManager->m_cyVScroll;
  91. }
  92. else
  93. {
  94. pSBInfo->pxTop = lprc->left;
  95. pSBInfo->pxBottom = lprc->right;
  96. pSBInfo->pxLeft = lprc->top;
  97. pSBInfo->pxRight = lprc->bottom;
  98. pSBInfo->cpxThumb = pPaintManager->m_cxHScroll;
  99. }
  101. pSBInfo->pos = pSI->nPos;
  102. pSBInfo->page = pSI->nPage;
  103. pSBInfo->posMin = pSI->nMin;
  104. pSBInfo->posMax = pSI->nMax;
  106. dwRange = ((DWORD)(pSBInfo->posMax - pSBInfo->posMin)) + 1;
  108. cpx = min((pSBInfo->pxBottom - pSBInfo->pxTop) / 2, pSBInfo->cpxThumb);
  110. pSBInfo->pxUpArrow  = pSBInfo->pxTop    + cpx;
  111. pSBInfo->pxDownArrow = pSBInfo->pxBottom - cpx;
  113. if ((pSBInfo->page != 0) && (dwRange != 0))
  114. {
  115. int i = MulDiv(pSBInfo->pxDownArrow - pSBInfo->pxUpArrow,
  116. pSBInfo->page, dwRange);
  118. pSBInfo->cpxThumb = max(pSBInfo->cpxThumb / 2, i);
  119. }
  121. if (pPaintManager->m_cThumb > 0) pSBInfo->cpxThumb = pPaintManager->m_cThumb;
  123. pSBInfo->pxMin = pSBInfo->pxTop + cpx;
  124. pSBInfo->cpx = pSBInfo->pxBottom - cpx - pSBInfo->cpxThumb - pSBInfo->pxMin;
  126. denom = dwRange - (pSBInfo->page ? pSBInfo->page : 1);
  127. if (denom)
  128. pSBInfo->pxThumbTop = MulDiv(pSBInfo->pos - pSBInfo->posMin,
  129. pSBInfo->cpx, denom) + pSBInfo->pxMin;
  130. else
  131. pSBInfo->pxThumbTop = pSBInfo->pxMin - 1;
  133. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  134. }
  136. void CXTPScrollBase::SetupScrollInfo()
  137. {
  138. CRect rc = GetScrollBarRect();
  140. SCROLLINFO si;
  141. GetScrollInfo(&si);
  143. CalcScrollBarInfo(&rc, &m_spi, &si);
  144. }
  146. CRect CXTPScrollBase::GetScrollBarPartRect(int nPart) const
  147. {
  148. CRect rc(m_spi.rc);
  150. switch (nPart)
  151. {
  152. case XTP_HTSCROLLUP: return m_spi.fVert ? CRect(rc.left, rc.top, rc.right, rc.top + m_spi.pxUpArrow) : CRect(rc.left, rc.top, rc.left + m_spi.pxUpArrow, rc.bottom);
  153. case XTP_HTSCROLLDOWN: return m_spi.fVert ? CRect(rc.left, rc.bottom - m_spi.pxDownArrow, rc.right, rc.bottom) : CRect(rc.right - m_spi.pxDownArrow, rc.top, rc.right, rc.bottom);
  154. case XTP_HTSCROLLUPPAGE: return m_spi.fVert ? CRect(rc.left, rc.top + m_spi.pxUpArrow, rc.right, rc.top + m_spi.pxThumbTop) : CRect(rc.left + m_spi.pxUpArrow, rc.top, rc.left + m_spi.pxThumbTop, rc.bottom);
  155. case XTP_HTSCROLLDOWNPAGE: return m_spi.fVert ? CRect(rc.left, rc.top + m_spi.pxThumbBottom, rc.right, rc.top + m_spi.pxDownArrow) : CRect(rc.left + m_spi.pxThumbBottom, rc.top, rc.left + m_spi.pxDownArrow, rc.bottom);
  156. case XTP_HTSCROLLTHUMB: return m_spi.fVert ? CRect(rc.left, rc.top + m_spi.pxThumbTop, rc.right, rc.top + m_spi.pxThumbBottom) : CRect(rc.left + m_spi.pxThumbTop, rc.top, rc.left + m_spi.pxThumbBottom, rc.bottom);
  157. }
  159. return rc;
  160. }
  162. int CXTPScrollBase::HitTestScrollBar(POINT pt) const
  163. {
  164. int px = m_spi.fVert ? pt.y : pt.x;
  166. if (!::PtInRect(&m_spi.rc, pt))
  167. return HTNOWHERE;
  169. if (px < m_spi.pxUpArrow)
  170. return XTP_HTSCROLLUP;
  172. if (m_spi.pxPopup > 0 && px > m_spi.pxPopup)
  173. return XTP_HTSCROLLPOPUP;
  175. if (px >= m_spi.pxDownArrow)
  176. return XTP_HTSCROLLDOWN;
  178. if (px < m_spi.pxThumbTop)
  179. return XTP_HTSCROLLUPPAGE;
  181. if (px < m_spi.pxThumbBottom)
  182. return XTP_HTSCROLLTHUMB;
  184. if (px < m_spi.pxDownArrow)
  185. return XTP_HTSCROLLDOWNPAGE;
  187. return HTERROR;
  188. }
  191. //////////////////////////////////////////////////////////////////////////
  192. // Scrolling
  194. void CXTPScrollBase::EndScroll(BOOL fCancel)
  195. {
  196. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  198. if (pSBTrack)
  199. {
  200. pSBTrack->cmdSB = 0;
  201. ReleaseCapture();
  203. if (pSBTrack->bTrackThumb)
  204. {
  205. if (fCancel)
  206. {
  207. pSBTrack->posOld = pSBTrack->pSBInfo->pos;
  208. }
  210. DoScroll(SB_THUMBPOSITION, pSBTrack->posOld);
  212. RedrawScrollBar();
  213. }
  214. else
  215. {
  217. if (pSBTrack->hTimerSB != 0)
  218. {
  219. ::KillTimer(pSBTrack->hWndTrack, pSBTrack->hTimerSB);
  220. pSBTrack->hTimerSB = 0;
  221. }
  222. }
  225. DoScroll(SB_ENDSCROLL, 0);
  226. }
  227. }
  229. AFX_INLINE int SBPosFromPx(CXTPScrollBase::SCROLLBARPOSINFO*  pSBInfo, int px)
  230. {
  231. if (px < pSBInfo->pxMin)
  232. {
  233. return pSBInfo->posMin;
  234. }
  236. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  237. {
  238. return (pSBInfo->posMax - (pSBInfo->page ? pSBInfo->page - 1 : 0));
  239. }
  241. if (pSBInfo->cpx)
  242. return (pSBInfo->posMin + MulDiv(pSBInfo->posMax - pSBInfo->posMin -
  243. (pSBInfo->page ? pSBInfo->page - 1 : 0),
  244. px - pSBInfo->pxMin, pSBInfo->cpx));
  245. else
  246. return (pSBInfo->posMin - 1);
  247. }
  250. void CXTPScrollBase::MoveThumb(int px)
  251. {
  252. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  254. if ((pSBTrack == NULL) || (px == pSBTrack->pxOld))
  255. return;
  257. SCROLLBARPOSINFO* pSBInfo = m_pSBTrack->pSBInfo;
  259. pxReCalc:
  261. pSBTrack->posNew = SBPosFromPx(pSBInfo, px);
  263. if (pSBTrack->posNew != pSBTrack->posOld)
  264. {
  265. DoScroll(SB_THUMBTRACK, pSBTrack->posNew);
  267. pSBTrack->posOld = pSBTrack->posNew;
  269. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  270. {
  271. px = pSBInfo->pxMin + pSBInfo->cpx;
  272. goto pxReCalc;
  273. }
  275. }
  277. pSBInfo->pxThumbTop = px;
  278. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  279. pSBTrack->pxOld = px;
  281. RedrawScrollBar();
  282. }
  284. void CXTPScrollBase::TrackThumb(UINT message, CPoint pt)
  285. {
  286. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  287. if (!pSBTrack)
  288. return;
  290. SCROLLBARPOSINFO* pSBInfo = pSBTrack->pSBInfo;
  292. if (HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  293. return;
  295. if (pSBInfo == NULL)
  296. return;
  298. int px;
  300. if (!PtInRect(&pSBTrack->rcTrack, pt) && (GetScrollBarPaintManager()->m_cThumb == 0))
  301. px = pSBInfo->pxStart;
  302. else
  303. {
  304. px = (pSBTrack->pSBInfo->fVert ? pt.y : pt.x) + pSBTrack->dpxThumb;
  305. if (px < pSBInfo->pxMin)
  306. px = pSBInfo->pxMin;
  307. else if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  308. px = pSBInfo->pxMin + pSBInfo->cpx;
  309. }
  311. MoveThumb(px);
  313. if (message == WM_LBUTTONUP || GetKeyState(VK_LBUTTON) >= 0)
  314. {
  315. EndScroll(FALSE);
  316. }
  317. }
  319. void CXTPScrollBase::TrackBox(UINT message, CPoint point)
  320. {
  321. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  323. if (pSBTrack == NULL)
  324. return;
  326. if (message != WM_NULL && HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  327. return;
  329. if ((pSBTrack->cmdSB == SB_PAGEUP || pSBTrack->cmdSB == SB_PAGEDOWN))
  330. {
  331. int* pLength = (int *)&pSBTrack->rcTrack;
  333. if (pSBTrack->pSBInfo->fVert)
  334. pLength++;
  336. if (pSBTrack->cmdSB == SB_PAGEUP)
  337. pLength[2] = pSBTrack->pSBInfo->pxThumbTop;
  338. else
  339. pLength[0] = pSBTrack->pSBInfo->pxThumbBottom;
  340. }
  342. BOOL fHit = PtInRect(&pSBTrack->rcTrack, point);
  344. BOOL fHitChanged = fHit != (BOOL)pSBTrack->fHitOld;
  346. if (fHitChanged)
  347. {
  348. pSBTrack->fHitOld = fHit;
  349. RedrawScrollBar();
  350. }
  352. int cmsTimer = GetDoubleClickTime() / 10;
  354. switch (message)
  355. {
  356. case WM_LBUTTONUP:
  357. EndScroll(FALSE);
  358. break;
  360. case WM_LBUTTONDOWN:
  361. pSBTrack->hTimerSB = 0;
  362. cmsTimer = GetDoubleClickTime() * 4 / 5;
  364. /*
  365. *** FALL THRU **
  366. */
  368. case WM_MOUSEMOVE:
  369. if (fHit && fHitChanged)
  370. {
  371. pSBTrack->hTimerSB = SetTimer(m_pSBTrack->hWndTrack, IDSYS_SCROLL, m_nTimerElapse = cmsTimer, NULL);
  373. DoScroll(pSBTrack->cmdSB, 0);
  374. }
  375. }
  376. }
  378. void CXTPScrollBase::DoAnimate()
  379. {
  381. }
  382. void CXTPScrollBase::ContScroll()
  383. {
  384. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  385. ASSERT(pSBTrack);
  387. if (pSBTrack == NULL)
  388. return;
  390. CPoint pt;
  391. GetCursorPos(&pt);
  393. ScreenToClient(m_pSBTrack->hWndTrack, &pt);
  395. TrackBox(WM_NULL, pt);
  397. if (pSBTrack->fHitOld)
  398. {
  399. pSBTrack->hTimerSB = SetTimer(m_pSBTrack->hWndTrack, IDSYS_SCROLL, m_nTimerElapse = GetDoubleClickTime() / 10, NULL);
  401. DoScroll(pSBTrack->cmdSB, 0);
  402. }
  403. }
  405. void CXTPScrollBase::CalcTrackDragRect(SCROLLBARTRACKINFO* pSBTrack) const
  406. {
  408. int     cx;
  409. int     cy;
  410. LPINT   pwX, pwY;
  412. pwX = pwY = (LPINT)&pSBTrack->rcTrack;
  414. if (pSBTrack->pSBInfo->fVert)
  415. {
  416. cy = GetSystemMetrics(SM_CYVTHUMB);
  417. pwY++;
  418. }
  419. else
  420. {
  421. cy = GetSystemMetrics(SM_CXHTHUMB);
  422. pwX++;
  423. }
  425. cx = (pSBTrack->pSBInfo->pxRight - pSBTrack->pSBInfo->pxLeft) * 8;
  426. cy *= 2;
  428. *(pwX + 0) = pSBTrack->pSBInfo->pxLeft - cx;
  429. *(pwY + 0) = pSBTrack->pSBInfo->pxTop - cy;
  430. *(pwX + 2) = pSBTrack->pSBInfo->pxRight + cx;
  431. *(pwY + 2) = pSBTrack->pSBInfo->pxBottom + cy;
  432. }
  434. void CXTPScrollBase::PerformTrackInit(HWND hWnd, CPoint point, SCROLLBARPOSINFO* pSBInfo, BOOL bDirect)
  435. {
  437. int px = m_spi.fVert ? point.y : point.x;
  439. SCROLLBARTRACKINFO* pSBTrack = new SCROLLBARTRACKINFO;
  440. memset(pSBTrack, 0, sizeof(SCROLLBARTRACKINFO));
  442. pSBTrack->cmdSB = (UINT)-1;
  443. pSBTrack->bTrackThumb = FALSE;
  444. pSBTrack->pSBInfo = pSBInfo;
  445. pSBTrack->hWndTrack = hWnd;
  447. m_pSBTrack = pSBTrack;
  449. CXTPMouseManager* pMouseManager = XTPMouseManager();
  451. RECT rcSB;
  452. LPINT pwX = (LPINT)&rcSB;
  453. LPINT pwY = pwX + 1;
  454. if (!pSBInfo->fVert)
  455. pwX = pwY--;
  457. *(pwX + 0) = pSBInfo->pxLeft;
  458. *(pwY + 0) = pSBInfo->pxTop;
  459. *(pwX + 2) = pSBInfo->pxRight;
  460. *(pwY + 2) = pSBInfo->pxBottom;
  463. if (px < pSBInfo->pxUpArrow)
  464. {
  465. pSBInfo->ht = XTP_HTSCROLLUP;
  466. pSBTrack->cmdSB = SB_LINEUP;
  467. *(pwY + 2) = pSBInfo->pxUpArrow;
  469. }
  470. else if (px >= pSBInfo->pxDownArrow)
  471. {
  472. pSBInfo->ht = XTP_HTSCROLLDOWN;
  473. pSBTrack->cmdSB = SB_LINEDOWN;
  474. *(pwY + 0) = pSBInfo->pxDownArrow;
  475. }
  476. else if (px < pSBInfo->pxThumbTop)
  477. {
  478. pSBInfo->ht = XTP_HTSCROLLUPPAGE;
  479. pSBTrack->cmdSB = SB_PAGEUP;
  480. *(pwY + 0) = pSBInfo->pxUpArrow;
  481. *(pwY + 2) = pSBInfo->pxThumbTop;
  482. }
  483. else if (px < pSBInfo->pxThumbBottom)
  484. {
  485. pSBInfo->ht = XTP_HTSCROLLTHUMB;
  486. DoThumbPos:
  488. if (pSBInfo->pxDownArrow - pSBInfo->pxUpArrow <= pSBInfo->cpxThumb)
  489. {
  490. delete m_pSBTrack;
  491. m_pSBTrack = NULL;
  492. return;
  493. }
  495. pSBTrack->cmdSB = SB_THUMBPOSITION;
  496. CalcTrackDragRect(pSBTrack);
  498. pSBTrack->pxOld = pSBInfo->pxStart = pSBInfo->pxThumbTop;
  499. pSBTrack->posNew = pSBTrack->posOld = pSBInfo->pos;
  500. pSBTrack->dpxThumb = pSBInfo->pxStart - px;
  502. pSBTrack->bTrackThumb = TRUE;
  504. ::SetCapture(hWnd);
  506. DoScroll(SB_THUMBTRACK, pSBTrack->posOld);
  508. }
  509. else if (px < pSBInfo->pxDownArrow)
  510. {
  511. pSBInfo->ht = XTP_HTSCROLLDOWNPAGE;
  512. pSBTrack->cmdSB = SB_PAGEDOWN;
  513. *(pwY + 0) = pSBInfo->pxThumbBottom;
  514. *(pwY + 2) = pSBInfo->pxDownArrow;
  515. }
  517. if ((bDirect && pSBTrack->cmdSB != SB_LINEUP && pSBTrack->cmdSB != SB_LINEDOWN))
  518. {
  519. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  520. {
  521. goto DoThumbPos;
  522. }
  523. pSBTrack->dpxThumb = -(pSBInfo->cpxThumb / 2);
  524. }
  526. ::SetCapture(hWnd);
  528. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  529. {
  530. CopyRect(&pSBTrack->rcTrack, &rcSB);
  531. }
  533. if (!pSBTrack->bTrackThumb)
  534. {
  535. TrackBox(WM_LBUTTONDOWN, point);
  536. }
  537. else
  538. {
  539. TrackThumb(WM_LBUTTONDOWN, point);
  540. RedrawScrollBar();
  541. }
  543. pMouseManager->LockMouseMove();
  545. while (::GetCapture() == hWnd)
  546. {
  547. MSG msg;
  549. if (!::GetMessage(&msg, NULL, 0, 0))
  550. {
  551. AfxPostQuitMessage((int)msg.wParam);
  552. break;
  553. }
  555. if (!IsWindow(hWnd))
  556. break;
  558. UINT cmd = msg.message;
  560. if (cmd == WM_TIMER && msg.wParam == IDSYS_SCROLL)
  561. {
  562. ContScroll();
  563. }
  564. else if (cmd == WM_TIMER && msg.wParam == IDSYS_ANIMATE)
  565. {
  566. DoAnimate();
  567. }
  568. else if (cmd >= WM_MOUSEFIRST && cmd <= WM_MOUSELAST)
  569. {
  570. CPoint ptScreen = msg.pt;
  572. ScreenToClient(hWnd, &ptScreen);
  574. if (!pSBTrack->bTrackThumb)
  575. {
  576. TrackBox(cmd, ptScreen);
  577. }
  578. else
  579. {
  580. TrackThumb(cmd, ptScreen);
  581. }
  582. }
  583. else
  584. {
  585. TranslateMessage(&msg);
  586. DispatchMessage(&msg);
  587. }
  589. }
  590. pMouseManager->UnlockMouseMove();
  592. if (pSBTrack->hTimerSB != 0)
  593. {
  594. ::KillTimer(hWnd, pSBTrack->hTimerSB);
  595. }
  597. delete m_pSBTrack;
  598. m_pSBTrack = NULL;
  600. if (IsWindow(hWnd))
  601. {
  602. GetCursorPos(&point);
  603. ScreenToClient(hWnd, &point);
  604. m_spi.ht = HitTestScrollBar(point);
  606. RedrawScrollBar();
  607. }
  609. while (IsWindow(hWnd) && m_bAnimation)
  610. {
  611. MSG msg;
  613. if (!::GetMessage(&msg, NULL, 0, 0))
  614. {
  615. AfxPostQuitMessage((int)msg.wParam);
  616. break;
  617. }
  619. UINT cmd = msg.message;
  621. if (cmd == WM_TIMER && msg.wParam == IDSYS_ANIMATE)
  622. {
  623. DoAnimate();
  624. }
  625. else
  626. {
  627. TranslateMessage(&msg);
  628. DispatchMessage(&msg);
  629. }
  630. }
  632. }
  634. XTPScrollBarStyle CXTPScrollBase::GetScrollBarStyle() const
  635. {
  636. if (m_scrollBarStyle != xtpScrollStyleDefault)
  637. return m_scrollBarStyle;
  639. switch (GetScrollBarPaintManager()->GetPaintManager()->BaseTheme())
  640. {
  641. case xtpThemeOffice2000:
  642. return xtpScrollStyleFlat;
  644. case xtpThemeOffice2007:
  645. case xtpThemeRibbon:
  646. return xtpScrollStyleOffice2007Light;
  647. }
  649. return xtpScrollStyleSystem;
  650. }
  653. //////////////////////////////////////////////////////////////////////////
  654. // CXTPScrollBar
  656. CXTPScrollBar::CXTPScrollBar()
  657. {
  658. m_pCommandBars = 0;
  659. }
  661. CXTPScrollBar::~CXTPScrollBar()
  662. {
  664. }
  666. BEGIN_MESSAGE_MAP(CXTPScrollBar, CScrollBar)
  667. //{{AFX_MSG_MAP(CXTPStatusBar)
  668. ON_WM_PAINT()
  669. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  670. ON_WM_ENABLE()
  671. ON_WM_MOUSEMOVE()
  672. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  673. ON_WM_LBUTTONDOWN()
  674. ON_WM_LBUTTONDBLCLK()
  675. ON_MESSAGE(SBM_SETSCROLLINFO, OnSetScrollInfo)
  676. ON_MESSAGE(SBM_GETSCROLLINFO, OnGetScrollInfo)
  677. ON_WM_SETFOCUS()
  678. ON_WM_CONTEXTMENU()
  679. //}}AFX_MSG_MAP
  680. END_MESSAGE_MAP()
  683. CRect CXTPScrollBar::GetScrollBarRect()
  684. {
  685. return CXTPClientRect(this);
  686. }
  688. void CXTPScrollBar::GetScrollInfo(SCROLLINFO* psi)
  689. {
  690. psi->cbSize = sizeof(SCROLLINFO);
  692. psi->fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
  693. ::GetScrollInfo(m_hWnd, SB_CTL, psi);
  694. }
  696. BOOL CXTPScrollBar::IsScrollBarEnabled() const
  697. {
  698. return IsWindowEnabled();
  699. }
  701. CWnd* CXTPScrollBar::GetParentWindow() const
  702. {
  703. return GetParent();
  704. }
  706. CXTPScrollBarPaintManager* CXTPScrollBar::GetScrollBarPaintManager() const
  707. {
  708. if (m_pCommandBars)
  709. return (CXTPScrollBarPaintManager*)m_pCommandBars->GetPaintManager()->GetGalleryPaintManager();
  711. return (CXTPScrollBarPaintManager*)XTPPaintManager()->GetGalleryPaintManager();
  712. }
  714. void CXTPScrollBar::OnPaint()
  715. {
  716. CPaintDC dcPaint(this); // device context for painting
  717. CXTPBufferDC dc(dcPaint);
  719. OnDraw(&dc);
  720. }
  722. LRESULT CXTPScrollBar::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  723. {
  724. CDC* pDC = CDC::FromHandle((HDC)wParam);
  725. if (pDC) OnDraw(pDC);
  726. return 1;
  727. }
  729. void CXTPScrollBar::OnDraw(CDC* pDC)
  730. {
  731. DefWindowProc(WM_PAINT, (WPARAM)pDC->GetSafeHdc(), 0);
  733. m_spi.fVert = GetStyle() & SBS_VERT;
  735. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  736. SetupScrollInfo();
  738. GetScrollBarPaintManager()->DrawScrollBar(pDC, this);
  739. }
  741. void CXTPScrollBar::DoScroll(int cmd, int pos)
  742. {
  743. GetParent()->SendMessage((UINT)(m_spi.fVert ? WM_VSCROLL : WM_HSCROLL),
  744. MAKELONG(cmd, pos), (LPARAM)m_hWnd);
  745. }
  747. void CXTPScrollBar::RedrawScrollBar()
  748. {
  749. Invalidate(FALSE);
  750. }
  753. void CXTPScrollBar::OnEnable(BOOL bEnable)
  754. {
  755. CScrollBar::OnEnable(bEnable);
  756. Invalidate(FALSE);
  757. }
  759. void CXTPScrollBar::OnMouseLeave()
  760. {
  761. OnMouseMove(0, CPoint(-1, -1));
  762. }
  764. void CXTPScrollBar::OnMouseMove(UINT /*nFlags*/, CPoint point)
  765. {
  766. int ht = HitTestScrollBar(point);
  768. if (ht != m_spi.ht)
  769. {
  770. m_spi.ht = ht;
  771. Invalidate(FALSE);
  773. if (m_spi.ht != HTNOWHERE)
  774. {
  775. TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, HOVER_DEFAULT};
  776. _TrackMouseEvent(&tme);
  777. }
  778. }
  779. }
  782. void CXTPScrollBar::OnLButtonDown(UINT /*nFlags*/, CPoint point)
  783. {
  784. PerformTrackInit(m_hWnd, point, &m_spi, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  785. }
  787. void CXTPScrollBar::OnContextMenu(CWnd* pWnd, CPoint pos)
  788. {
  789. CScrollBar::OnContextMenu(pWnd, pos);
  790. Invalidate(FALSE);
  791. }
  793. void CXTPScrollBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  794. {
  795. OnLButtonDown(nFlags, point);
  796. }
  798. LRESULT CXTPScrollBar::OnSetScrollInfo(WPARAM wParam, LPARAM lParam)
  799. {
  800. LRESULT bResult = DefWindowProc(SBM_SETSCROLLINFO, FALSE, lParam);
  802. if (wParam)
  803. {
  804. Invalidate(FALSE);
  805. UpdateWindow();
  806. }
  808. return bResult;
  809. }
  811. LRESULT CXTPScrollBar::OnGetScrollInfo(WPARAM wParam, LPARAM lParam)
  812. {
  813. LRESULT bResult = DefWindowProc(SBM_GETSCROLLINFO, wParam, lParam);
  815. LPSCROLLINFO lpsi = (LPSCROLLINFO)lParam;
  817. if (lpsi && (lpsi->fMask & SIF_TRACKPOS) && m_pSBTrack)
  818. {
  819. lpsi->nTrackPos = m_pSBTrack->posNew;
  820. }
  822. return bResult;
  823. }
  826. void CXTPScrollBar::OnSetFocus(CWnd* pOldWnd)
  827. {
  828. pOldWnd;
  829. }
  832. //////////////////////////////////////////////////////////////////////////
  833. // CXTPScrollBarPaintManager
  835. CXTPScrollBarPaintManager::CXTPScrollBarPaintManager(CXTPPaintManager* pPaintManager)
  836. {
  837. m_pPaintManager = pPaintManager;
  839. m_cxHScroll = GetSystemMetrics(SM_CXHSCROLL);
  840. m_cyHScroll = GetSystemMetrics(SM_CYHSCROLL);
  841. m_cxVScroll = GetSystemMetrics(SM_CXVSCROLL);
  842. m_cyVScroll = GetSystemMetrics(SM_CYVSCROLL);
  844. m_cThumb = 0;
  845. }
  847. CXTPScrollBarPaintManager::~CXTPScrollBarPaintManager()
  848. {
  850. }
  853. void CXTPScrollBarPaintManager::RefreshMetrics()
  854. {
  855. m_cxHScroll = GetSystemMetrics(SM_CXHSCROLL);
  856. m_cyHScroll = GetSystemMetrics(SM_CYHSCROLL);
  857. m_cxVScroll = GetSystemMetrics(SM_CXVSCROLL);
  858. m_cyVScroll = GetSystemMetrics(SM_CYVSCROLL);
  860. m_themeScrollBar.OpenTheme(0, L"SCROLLBAR");
  861. }
  863. void CXTPScrollBarPaintManager::DrawArrowGlyph(CDC* pDC, CRect rcArrow, BOOL bHorz, BOOL bUpArrow, BOOL bEnabled)
  864. {
  865. int nHeight = min(rcArrow.Width(), rcArrow.Height());
  866. if (nHeight < 6) return;
  868. int x = rcArrow.left + ((rcArrow.Width() - nHeight) / 2) + 2;
  869. int y = rcArrow.top + ((rcArrow.Height() - nHeight) / 2) + 2;
  870. nHeight -= 4;
  872. COLORREF clr = bEnabled ? RGB(0, 0, 0) : GetSysColor(COLOR_3DSHADOW);
  874. HFONT hFont = CreateFont(nHeight, 0, 0, 0, FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0, 0, 0, 0, _T("MARLETT"));
  875. HFONT hOldFont = (HFONT)SelectObject(pDC->GetSafeHdc(), hFont);
  877. SetTextColor(pDC->GetSafeHdc(), clr);
  878. pDC->SetBkMode(TRANSPARENT);
  879. TextOut(pDC->GetSafeHdc(), x, y, bHorz ? (bUpArrow ? _T("3") : _T("4")) : (bUpArrow ? _T("5") : _T("6")), 1);
  881. SelectObject(pDC->GetSafeHdc(), hOldFont);
  882. DeleteObject(hFont);
  883. }
  885. void CXTPScrollBarPaintManager::DrawScrollBar(CDC* pDC, CXTPScrollBase* pGallery)
  886. {
  887. #define GETPARTSTATE(ht, pressed, hot, normal, disabled) 
  888. (!bEnabled ? disabled : nPressetHt == ht ? pressed : nHotHt == ht ? hot : normal)
  890. CXTPScrollBase::SCROLLBARTRACKINFO* pSBTrack = pGallery->GetScrollBarTrackInfo();
  891. CXTPScrollBase::SCROLLBARPOSINFO* pSBInfo = pGallery->GetScrollBarPosInfo();
  893. BOOL nPressetHt = pSBTrack ? (pSBTrack->bTrackThumb || pSBTrack->fHitOld ? pSBInfo->ht : -1) : -1;
  894. BOOL nHotHt = pSBTrack ? -1 : pSBInfo->ht;
  897. int cWidth = (pSBInfo->pxRight - pSBInfo->pxLeft);
  899. if (cWidth <= 0)
  900. {
  901. return;
  902. }
  904. BOOL bEnabled = (pSBInfo->posMax - pSBInfo->posMin - pSBInfo->page + 1 > 0) && pGallery->IsScrollBarEnabled();
  906. int nBtnTrackSize =   pSBInfo->pxThumbBottom - pSBInfo->pxThumbTop;
  907. int nBtnTrackPos = pSBInfo->pxThumbTop - pSBInfo->pxUpArrow;
  909. if (!bEnabled || pSBInfo->pxThumbBottom > pSBInfo->pxDownArrow)
  910. nBtnTrackPos = nBtnTrackSize = 0;
  911. XTPScrollBarStyle style = pGallery->GetScrollBarStyle();
  913. if (pSBInfo->fVert)
  914. {
  915. CRect rcVScroll(pSBInfo->rc);
  917. CRect rcArrowUp(rcVScroll.left, rcVScroll.top, rcVScroll.right, pSBInfo->pxUpArrow);
  918. CRect rcArrowDown(rcVScroll.left, pSBInfo->pxDownArrow, rcVScroll.right, rcVScroll.bottom);
  919. CRect rcTrack(rcVScroll.left, rcArrowUp.bottom, rcVScroll.right, rcArrowDown.top);
  921. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.right, rcTrack.top + nBtnTrackPos);
  922. CRect rcBtnTrack(rcTrack.left, rcLowerTrack.bottom, rcTrack.right, rcLowerTrack.bottom + nBtnTrackSize);
  923. CRect rcUpperTrack(rcTrack.left, rcBtnTrack.bottom, rcTrack.right, rcTrack.bottom);
  926. if (style == xtpScrollStyleSystem  && m_themeScrollBar.IsAppThemed())
  927. {
  928. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP, ABS_UPPRESSED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPDISABLED),  rcArrowUp, NULL);
  929. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN, ABS_DOWNPRESSED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNDISABLED),  rcArrowDown, NULL);
  931. if (!rcTrack.IsRectEmpty())
  932. {
  933. if (!rcLowerTrack.IsRectEmpty())
  934. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_LOWERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcLowerTrack, NULL);
  936. if (!rcBtnTrack.IsRectEmpty())
  937. {
  938. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_THUMBBTNVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  939. if (rcBtnTrack.Height() > 13)
  940. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_GRIPPERVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  941. }
  943. if (!rcUpperTrack.IsRectEmpty())
  944. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_UPPERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcUpperTrack, NULL);
  945. }
  946. }
  947. else
  948. {
  949. if (style == xtpScrollStyleFlat)
  950. {
  951. pDC->FillSolidRect(rcArrowUp, GetXtremeColor(COLOR_3DFACE));
  952. if (bEnabled && nPressetHt == XTP_HTSCROLLUP)
  953. pDC->Draw3dRect(rcArrowUp,GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHIGHLIGHT));
  954. else
  955. pDC->Draw3dRect(rcArrowUp, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  957. DrawArrowGlyph(pDC, rcArrowUp, FALSE, TRUE, bEnabled);
  959. pDC->FillSolidRect(rcArrowDown, GetXtremeColor(COLOR_3DFACE));
  960. if (bEnabled && nPressetHt == XTP_HTSCROLLDOWN)
  961. pDC->Draw3dRect(rcArrowDown,GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHIGHLIGHT));
  962. else
  963. pDC->Draw3dRect(rcArrowDown, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  964. DrawArrowGlyph(pDC, rcArrowDown, FALSE, FALSE, bEnabled);
  966. }
  967. else
  968. {
  969. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowUp, DFC_SCROLL, DFCS_SCROLLUP | (!bEnabled ? DFCS_INACTIVE : 0) | (nPressetHt == XTP_HTSCROLLUP ? DFCS_PUSHED : 0));
  970. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowDown, DFC_SCROLL, DFCS_SCROLLDOWN | (!bEnabled ? DFCS_INACTIVE : 0)  | (nPressetHt == XTP_HTSCROLLDOWN ? DFCS_PUSHED : 0));
  971. }
  973. CWnd* pParent = pGallery->GetParentWindow();
  974. HBRUSH hbrRet = (HBRUSH)DefWindowProc(pParent->GetSafeHwnd(), WM_CTLCOLORSCROLLBAR, (WPARAM)pDC->GetSafeHdc(), (LPARAM)pParent->GetSafeHwnd());
  976. ::FillRect(pDC->GetSafeHdc(), &rcTrack, hbrRet);
  978. if (nPressetHt == XTP_HTSCROLLUPPAGE)
  979. {
  980. ::InvertRect(pDC->GetSafeHdc(), &rcLowerTrack);
  981. }
  983. if (!rcTrack.IsRectEmpty() && !rcBtnTrack.IsRectEmpty())
  984. {
  985. pDC->FillSolidRect(rcBtnTrack, GetXtremeColor(COLOR_3DFACE));
  987. if (style == xtpScrollStyleFlat)
  988. {
  989. pDC->Draw3dRect(rcBtnTrack, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  990. }
  991. else
  992. {
  993. DrawEdge(pDC->GetSafeHdc(), &rcBtnTrack, EDGE_RAISED, (UINT)(BF_ADJUST | BF_RECT));
  994. }
  995. }
  997. if (nPressetHt == XTP_HTSCROLLDOWNPAGE)
  998. {
  999. ::InvertRect(pDC->GetSafeHdc(), &rcUpperTrack);
  1000. }
  1001. }
  1002. }
  1003. else
  1004. {
  1005. CRect rcHScroll(pSBInfo->rc);
  1007. CRect rcArrowLeft(rcHScroll.left, rcHScroll.top, pSBInfo->pxUpArrow, rcHScroll.bottom);
  1008. CRect rcArrowRight(pSBInfo->pxDownArrow, rcHScroll.top, rcHScroll.right, rcHScroll.bottom);
  1009. CRect rcTrack(rcArrowLeft.right, rcHScroll.top, rcArrowRight.left, rcHScroll.bottom);
  1011. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.left + nBtnTrackPos, rcTrack.bottom);
  1012. CRect rcBtnTrack(rcLowerTrack.right, rcTrack.top, rcLowerTrack.right + nBtnTrackSize, rcTrack.bottom);
  1013. CRect rcUpperTrack(rcBtnTrack.right, rcTrack.top, rcTrack.right, rcTrack.bottom);
  1016. if (style == xtpScrollStyleSystem  && m_themeScrollBar.IsAppThemed())
  1017. {
  1018. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP, ABS_LEFTPRESSED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTDISABLED),  rcArrowLeft, NULL);
  1019. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN, ABS_RIGHTPRESSED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTDISABLED),  rcArrowRight, NULL);
  1021. if (!rcTrack.IsRectEmpty())
  1022. {
  1023. if (!rcLowerTrack.IsRectEmpty())
  1024. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_LOWERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcLowerTrack, NULL);
  1026. if (!rcBtnTrack.IsRectEmpty())
  1027. {
  1028. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_THUMBBTNHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  1029. if (rcBtnTrack.Width() > 13)
  1030. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_GRIPPERHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  1031. }
  1033. if (!rcUpperTrack.IsRectEmpty())
  1034. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_UPPERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcUpperTrack, NULL);
  1035. }
  1036. }
  1037. else
  1038. {
  1039. if (style == xtpScrollStyleFlat)
  1040. {
  1041. pDC->FillSolidRect(rcArrowLeft, GetXtremeColor(COLOR_3DFACE));
  1042. if (bEnabled && nPressetHt == XTP_HTSCROLLUP)
  1043. pDC->Draw3dRect(rcArrowLeft,GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHIGHLIGHT));
  1044. else
  1045. pDC->Draw3dRect(rcArrowLeft, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  1047. DrawArrowGlyph(pDC, rcArrowLeft, TRUE, TRUE, bEnabled);
  1049. pDC->FillSolidRect(rcArrowRight, GetXtremeColor(COLOR_3DFACE));
  1050. if (bEnabled && nPressetHt == XTP_HTSCROLLDOWN)
  1051. pDC->Draw3dRect(rcArrowRight,GetXtremeColor(COLOR_3DSHADOW), GetXtremeColor(COLOR_3DHIGHLIGHT));
  1052. else
  1053. pDC->Draw3dRect(rcArrowRight, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  1054. DrawArrowGlyph(pDC, rcArrowRight, TRUE, FALSE, bEnabled);
  1056. }
  1057. else
  1058. {
  1059. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowLeft, DFC_SCROLL, DFCS_SCROLLLEFT | (!bEnabled ? DFCS_INACTIVE : 0) | (nPressetHt == XTP_HTSCROLLUP ? DFCS_PUSHED : 0));
  1060. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowRight, DFC_SCROLL, DFCS_SCROLLRIGHT | (!bEnabled ? DFCS_INACTIVE : 0)  | (nPressetHt == XTP_HTSCROLLDOWN ? DFCS_PUSHED : 0));
  1061. }
  1063. CWnd* pParent = pGallery->GetParentWindow();
  1064. HBRUSH hbrRet = (HBRUSH)DefWindowProc(pParent->GetSafeHwnd(), WM_CTLCOLORSCROLLBAR, (WPARAM)pDC->GetSafeHdc(), (LPARAM)pParent->GetSafeHwnd());
  1066. ::FillRect(pDC->GetSafeHdc(), &rcTrack, hbrRet);
  1068. if (nPressetHt == XTP_HTSCROLLUPPAGE)
  1069. {
  1070. ::InvertRect(pDC->GetSafeHdc(), &rcLowerTrack);
  1071. }
  1073. if (!rcTrack.IsRectEmpty() && !rcBtnTrack.IsRectEmpty())
  1074. {
  1075. pDC->FillSolidRect(rcBtnTrack, GetXtremeColor(COLOR_3DFACE));
  1077. if (style == xtpScrollStyleFlat)
  1078. {
  1079. pDC->Draw3dRect(rcBtnTrack, GetXtremeColor(COLOR_3DHIGHLIGHT), GetXtremeColor(COLOR_3DSHADOW));
  1080. }
  1081. else
  1082. {
  1083. DrawEdge(pDC->GetSafeHdc(), &rcBtnTrack, EDGE_RAISED, (UINT)(BF_ADJUST | BF_RECT));
  1084. }
  1085. }
  1087. if (nPressetHt == XTP_HTSCROLLDOWNPAGE)
  1088. {
  1089. ::InvertRect(pDC->GetSafeHdc(), &rcUpperTrack);
  1090. }
  1091. }
  1092. }
  1093. }
  1095. //////////////////////////////////////////////////////////////////////////
  1096. // CXTPSliderPaintManager
  1098. CXTPSliderPaintManager::CXTPSliderPaintManager(CXTPPaintManager* pPaintManager)
  1099. : CXTPScrollBarPaintManager(pPaintManager)
  1100. {
  1101. }
  1103. void CXTPSliderPaintManager::RefreshMetrics()
  1104. {
  1105. CXTPScrollBarPaintManager::RefreshMetrics();
  1107. m_cyHScroll = 16;
  1108. m_cxHScroll = 16;
  1110. m_cThumb = 11;
  1111. }
  1113. void CXTPSliderPaintManager::DrawScrollBar(CDC* pDC, CXTPScrollBase* pGallery)
  1114. {
  1115. CXTPScrollBase::SCROLLBARTRACKINFO* pSBTrack = pGallery->GetScrollBarTrackInfo();
  1116. CXTPScrollBase::SCROLLBARPOSINFO* pSBInfo = pGallery->GetScrollBarPosInfo();
  1118. BOOL nPressetHt = pSBTrack ? (pSBTrack->bTrackThumb || pSBTrack->fHitOld ? pSBInfo->ht : -1) : -1;
  1119. BOOL nHotHt = pSBTrack ? -1 : pSBInfo->ht;
  1121. int cWidth = (pSBInfo->pxRight - pSBInfo->pxLeft);
  1123. if (cWidth <= 0)
  1124. return;
  1126. BOOL bEnabled = (pSBInfo->posMax - pSBInfo->posMin - pSBInfo->page + 1 > 0) && pGallery->IsScrollBarEnabled();
  1128. int nBtnTrackSize =   pSBInfo->pxThumbBottom - pSBInfo->pxThumbTop;
  1129. int nBtnTrackPos = pSBInfo->pxThumbTop - pSBInfo->pxUpArrow;
  1131. if (!bEnabled || pSBInfo->pxThumbBottom > pSBInfo->pxDownArrow)
  1132. nBtnTrackPos = nBtnTrackSize = 0;
  1134. COLORREF clrFace = GetXtremeColor(COLOR_3DFACE);
  1135. COLORREF clrShadow = GetXtremeColor(COLOR_3DSHADOW);
  1136. COLORREF clrLight = GetXtremeColor(COLOR_3DHIGHLIGHT);
  1138. if (!pSBInfo->fVert)
  1139. {
  1140. CRect rcHScroll(pSBInfo->rc);
  1142. CRect rcArrowLeft(rcHScroll.left, rcHScroll.top, pSBInfo->pxUpArrow, rcHScroll.bottom);
  1143. CRect rcArrowRight(pSBInfo->pxDownArrow, rcHScroll.top, rcHScroll.right, rcHScroll.bottom);
  1144. CRect rcTrack(rcArrowLeft.right, rcHScroll.top, rcArrowRight.left, rcHScroll.bottom);
  1145. CRect rcBtnTrack(rcTrack.left + nBtnTrackPos, rcTrack.top, rcTrack.left + nBtnTrackPos + nBtnTrackSize, rcTrack.bottom);
  1147. CRect rcTrackDest(CPoint(rcTrack.left, (rcTrack.top + rcTrack.bottom - 2) / 2), CSize(rcTrack.Width(), 2));
  1149. pDC->FillSolidRect(rcTrackDest.left, rcTrackDest.top, rcTrackDest.Width(), 1, clrShadow);
  1150. pDC->FillSolidRect(rcTrackDest.left, rcTrackDest.top + 1, rcTrackDest.Width(), 1, clrLight);
  1152. CXTPScrollBase::SLIDERTICKS* pTicks = pGallery->GetTicks();
  1153. if (!pTicks || (pSBInfo->posMax <= pSBInfo->posMin))
  1154. {
  1155. CRect rcTrackTickDest(CPoint((rcTrackDest.left + rcTrackDest.right - 2) / 2,
  1156. (rcTrackDest.top + rcTrackDest.bottom - 8) / 2), CSize(2, 8));
  1158. pDC->FillSolidRect(rcTrackTickDest.left, rcTrackTickDest.top, 1, 4, clrShadow);
  1159. pDC->FillSolidRect(rcTrackTickDest.left, rcTrackTickDest.top + 5, 1, 2, clrShadow);
  1160. pDC->FillSolidRect(rcTrackTickDest.left + 1, rcTrackTickDest.top + 1, 1, 7, clrLight);
  1161. }
  1162. else
  1163. {
  1164. rcTrackDest.DeflateRect(6, 0);
  1166. for (int i = 0; i < pTicks->nCount; i++)
  1167. {
  1168. double dTick = pTicks->pTicks[i];
  1169. double dPos = (dTick - pSBInfo->posMin) * rcTrackDest.Width() / (pSBInfo->posMax - pSBInfo->posMin);
  1171. if (dPos >= 0 && dPos <= rcTrackDest.Width())
  1172. {
  1173. CRect rcTrackTickDest(CPoint(rcTrackDest.left + (int)dPos - 1,
  1174. (rcTrackDest.top + rcTrackDest.bottom - 8) / 2), CSize(2, 8));
  1176. pDC->FillSolidRect(rcTrackTickDest.left, rcTrackTickDest.top, 1, 4, clrShadow);
  1177. pDC->FillSolidRect(rcTrackTickDest.left, rcTrackTickDest.top + 5, 1, 2, clrShadow);
  1178. pDC->FillSolidRect(rcTrackTickDest.left + 1, rcTrackTickDest.top + 1, 1, 7, clrLight);
  1179. }
  1180. }
  1181. }
  1183. m_pPaintManager->AlphaEllipse(pDC, rcArrowLeft, clrShadow, nHotHt == XTP_HTSCROLLUP ? clrLight : clrFace);
  1184. if (nPressetHt != XTP_HTSCROLLUP)
  1185. {
  1186. rcArrowLeft.DeflateRect(1, 1);
  1187. m_pPaintManager->AlphaEllipse(pDC, rcArrowLeft, clrLight, nHotHt == XTP_HTSCROLLUP ? clrLight : clrFace);
  1188. }
  1189. CPoint ptCenter = rcArrowLeft.CenterPoint();
  1190. pDC->FillSolidRect(ptCenter.x - 4, ptCenter.y - 1, 8, 2, 0);
  1192. m_pPaintManager->AlphaEllipse(pDC, rcArrowRight, clrShadow, nHotHt == XTP_HTSCROLLDOWN ? clrLight : clrFace);
  1193. if (nPressetHt != XTP_HTSCROLLDOWN)
  1194. {
  1195. rcArrowRight.DeflateRect(1, 1);
  1196. m_pPaintManager->AlphaEllipse(pDC, rcArrowRight, clrLight, nHotHt == XTP_HTSCROLLDOWN ? clrLight : clrFace);
  1197. }
  1198. ptCenter = rcArrowRight.CenterPoint();
  1199. pDC->FillSolidRect(ptCenter.x - 4, ptCenter.y - 1, 8, 2, 0);
  1200. pDC->FillSolidRect(ptCenter.x - 1, ptCenter.y - 4, 2, 8, 0);
  1202. if (bEnabled)
  1203. {
  1204. CRect rc(CPoint((rcBtnTrack.left + rcBtnTrack.right - 8) / 2,
  1205. (rcBtnTrack.top + rcBtnTrack.bottom - 13) / 2), CSize(8, 13));
  1207. POINT pts[] = {rc.left, rc.top, rc.right, rc.top,
  1208. rc.right,  rc.bottom - 4, rc.left + 4, rc.bottom, rc.left, rc.bottom - 4, rc.left, rc.top};
  1210. CXTPPenDC pen (*pDC, nHotHt == XTP_HTSCROLLTHUMB ? clrLight : clrFace);
  1211. CXTPBrushDC brush (*pDC, nHotHt == XTP_HTSCROLLTHUMB ? clrLight : clrFace);
  1213. pDC->Polygon(pts, sizeof(pts) / sizeof(POINT));
  1215. pen.Color(clrShadow);
  1216. pDC->Polyline(pts, sizeof(pts) / sizeof(POINT));
  1218. if (nPressetHt != XTP_HTSCROLLTHUMB)
  1219. {
  1220. POINT pts2[] = {rc.left + 1, rc.top + 1, rc.right - 1, rc.top + 1,
  1221. rc.right - 1,  rc.bottom - 4, rc.left + 4, rc.bottom - 1, rc.left + 1, rc.bottom - 4, rc.left + 1, rc.top + 1};
  1223. pen.Color(clrLight);
  1224. pDC->Polyline(pts2, sizeof(pts2) / sizeof(POINT));
  1225. }
  1226. }
  1227. }
  1228. }