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

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

对话框与窗口

开发平台：

Visual C++

XTPMarkupScrollViewer.cpp：源码内容
  1. // XTPMarkupButton.cpp: implementation of the CXTPMarkupButton class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO 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/XTPWinThemeWrapper.h"
  25. #include "XTPMarkupContext.h"
  26. #include "XTPMarkupDrawingContext.h"
  27. #include "XTPMarkupScrollViewer.h"
  28. #include "XTPMarkupBuilder.h"
  31. #ifdef _DEBUG
  32. #undef THIS_FILE
  33. static char THIS_FILE[]=__FILE__;
  34. #define new DEBUG_NEW
  35. #endif
  37. #define XTP_HTSCROLLUP          60          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  38. #define XTP_HTSCROLLDOWN        61          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  39. #define XTP_HTSCROLLUPPAGE      62          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  40. #define XTP_HTSCROLLDOWNPAGE    63          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  41. #define XTP_HTSCROLLTHUMB       64          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  42. #define XTP_HTSCROLLPOPUP       65          // <combine CXTPScrollBase::HitTestScrollBar@POINT>
  44. #define IDSYS_SCROLL 63345
  47. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupScrollBar, CXTPMarkupControl)
  49. void CXTPMarkupScrollBar::RegisterMarkupClass()
  50. {
  52. }
  54. CXTPMarkupScrollBar::CXTPMarkupScrollBar()
  55. {
  56. m_orientation = xtpMarkupOrientationVertical;
  58. m_pSBTrack = NULL;
  59. ZeroMemory(&m_spi, sizeof(m_spi));
  60. ZeroMemory(&m_si, sizeof(m_si));
  61. }
  63. void CXTPMarkupScrollBar::SetScrollInfo(SCROLLINFO* pScrollInfo)
  64. {
  65. if (m_si.nMax != pScrollInfo->nMax || m_si.nPage != pScrollInfo->nPage || m_si.nPos != pScrollInfo->nPos)
  66. {
  67. m_si = *pScrollInfo;
  68. m_bArrangeDirty = TRUE;
  69. }
  70. }
  72. void CXTPMarkupScrollBar::GetScrollInfo(SCROLLINFO* pScrollInfo)
  73. {
  74. *pScrollInfo = m_si;
  75. }
  79. int CXTPMarkupScrollBar::HitTestScrollBar(POINT pt) const
  80. {
  81. if (!IsEnabled())
  82. return HTNOWHERE;
  84. int px = m_spi.fVert ? pt.y : pt.x;
  86. if (!::PtInRect(&m_spi.rc, pt))
  87. return HTNOWHERE;
  89. if (px < m_spi.pxUpArrow)
  90. return XTP_HTSCROLLUP;
  92. if (m_spi.pxPopup > 0 && px > m_spi.pxPopup)
  93. return XTP_HTSCROLLPOPUP;
  95. if (px >= m_spi.pxDownArrow)
  96. return XTP_HTSCROLLDOWN;
  98. if (px < m_spi.pxThumbTop)
  99. return XTP_HTSCROLLUPPAGE;
  101. if (px < m_spi.pxThumbBottom)
  102. return XTP_HTSCROLLTHUMB;
  104. if (px < m_spi.pxDownArrow)
  105. return XTP_HTSCROLLDOWNPAGE;
  107. return HTERROR;
  108. }
  111. //////////////////////////////////////////////////////////////////////////
  112. // Scrolling
  114. void CXTPMarkupScrollBar::EndScroll(BOOL fCancel)
  115. {
  116. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  118. if (pSBTrack)
  119. {
  120. pSBTrack->cmdSB = 0;
  121. ReleaseCapture();
  123. if (pSBTrack->bTrackThumb)
  124. {
  125. if (fCancel)
  126. {
  127. pSBTrack->posOld = pSBTrack->pSBInfo->pos;
  128. }
  130. DoScroll(SB_THUMBPOSITION, pSBTrack->posOld);
  132. RedrawScrollBar();
  133. }
  134. else
  135. {
  137. if (pSBTrack->hTimerSB != 0)
  138. {
  139. ::KillTimer(pSBTrack->hWndTrack, pSBTrack->hTimerSB);
  140. pSBTrack->hTimerSB = 0;
  141. }
  142. }
  145. DoScroll(SB_ENDSCROLL, 0);
  146. }
  147. }
  149. int CXTPMarkupScrollBar::SBPosFromPx(CXTPMarkupScrollBar::SCROLLBARPOSINFO*  pSBInfo, int px)
  150. {
  151. if (px < pSBInfo->pxMin)
  152. {
  153. return pSBInfo->posMin;
  154. }
  156. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  157. {
  158. return (pSBInfo->posMax - (pSBInfo->page ? pSBInfo->page - 1 : 0));
  159. }
  161. if (pSBInfo->cpx)
  162. return (pSBInfo->posMin + MulDiv(pSBInfo->posMax - pSBInfo->posMin -
  163. (pSBInfo->page ? pSBInfo->page - 1 : 0),
  164. px - pSBInfo->pxMin, pSBInfo->cpx));
  165. else
  166. return (pSBInfo->posMin - 1);
  167. }
  170. void CXTPMarkupScrollBar::MoveThumb(int px)
  171. {
  172. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  174. if ((pSBTrack == NULL) || (px == pSBTrack->pxOld))
  175. return;
  177. SCROLLBARPOSINFO* pSBInfo = m_pSBTrack->pSBInfo;
  179. pxReCalc:
  181. pSBTrack->posNew = SBPosFromPx(pSBInfo, px);
  183. if (pSBTrack->posNew != pSBTrack->posOld)
  184. {
  185. DoScroll(SB_THUMBTRACK, pSBTrack->posNew);
  187. pSBTrack->posOld = pSBTrack->posNew;
  189. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  190. {
  191. px = pSBInfo->pxMin + pSBInfo->cpx;
  192. goto pxReCalc;
  193. }
  195. }
  197. pSBInfo->pxThumbTop = px;
  198. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  199. pSBTrack->pxOld = px;
  201. RedrawScrollBar();
  202. }
  204. void CXTPMarkupScrollBar::TrackThumb(UINT message, CPoint pt)
  205. {
  206. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  207. if (!pSBTrack)
  208. return;
  210. SCROLLBARPOSINFO* pSBInfo = pSBTrack->pSBInfo;
  212. if (HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  213. return;
  215. if (pSBInfo == NULL)
  216. return;
  218. int px;
  220. if (!PtInRect(&pSBTrack->rcTrack, pt))
  221. px = pSBInfo->pxStart;
  222. else
  223. {
  224. px = (pSBTrack->pSBInfo->fVert ? pt.y : pt.x) + pSBTrack->dpxThumb;
  225. if (px < pSBInfo->pxMin)
  226. px = pSBInfo->pxMin;
  227. else if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  228. px = pSBInfo->pxMin + pSBInfo->cpx;
  229. }
  231. MoveThumb(px);
  233. if (message == WM_LBUTTONUP || GetKeyState(VK_LBUTTON) >= 0)
  234. {
  235. EndScroll(FALSE);
  236. }
  237. }
  239. void CXTPMarkupScrollBar::TrackBox(UINT message, CPoint point)
  240. {
  241. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  243. if (pSBTrack == NULL)
  244. return;
  246. if (message != WM_NULL && HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  247. return;
  249. if ((pSBTrack->cmdSB == SB_PAGEUP || pSBTrack->cmdSB == SB_PAGEDOWN))
  250. {
  251. int* pLength = (int *)&pSBTrack->rcTrack;
  253. if (pSBTrack->pSBInfo->fVert)
  254. pLength++;
  256. if (pSBTrack->cmdSB == SB_PAGEUP)
  257. pLength[2] = pSBTrack->pSBInfo->pxThumbTop;
  258. else
  259. pLength[0] = pSBTrack->pSBInfo->pxThumbBottom;
  260. }
  262. BOOL fHit = PtInRect(&pSBTrack->rcTrack, point);
  264. BOOL fHitChanged = fHit != (BOOL)pSBTrack->fHitOld;
  266. if (fHitChanged)
  267. {
  268. pSBTrack->fHitOld = fHit;
  269. RedrawScrollBar();
  270. }
  272. int cmsTimer = GetDoubleClickTime() / 10;
  274. switch (message)
  275. {
  276. case WM_LBUTTONUP:
  277. EndScroll(FALSE);
  278. break;
  280. case WM_LBUTTONDOWN:
  281. pSBTrack->hTimerSB = 0;
  282. cmsTimer = GetDoubleClickTime() * 4 / 5;
  284. /*
  285. *** FALL THRU **
  286. */
  288. case WM_MOUSEMOVE:
  289. if (fHit && fHitChanged)
  290. {
  291. pSBTrack->hTimerSB = ::SetTimer(m_pSBTrack->hWndTrack, IDSYS_SCROLL, cmsTimer, NULL);
  293. DoScroll(pSBTrack->cmdSB, 0);
  294. }
  295. }
  296. }
  298. void CXTPMarkupScrollBar::ContScroll()
  299. {
  300. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  301. ASSERT(pSBTrack);
  303. if (pSBTrack == NULL)
  304. return;
  306. CPoint pt;
  307. GetCursorPos(&pt);
  309. ScreenToClient(m_pSBTrack->hWndTrack, &pt);
  311. TrackBox(WM_NULL, pt);
  313. if (pSBTrack->fHitOld)
  314. {
  315. pSBTrack->hTimerSB = ::SetTimer(m_pSBTrack->hWndTrack, IDSYS_SCROLL, GetDoubleClickTime() / 10, NULL);
  317. DoScroll(pSBTrack->cmdSB, 0);
  318. }
  319. }
  321. void CXTPMarkupScrollBar::CalcTrackDragRect(SCROLLBARTRACKINFO* pSBTrack) const
  322. {
  324. int     cx;
  325. int     cy;
  326. LPINT   pwX, pwY;
  328. pwX = pwY = (LPINT)&pSBTrack->rcTrack;
  330. if (pSBTrack->pSBInfo->fVert)
  331. {
  332. cy = GetSystemMetrics(SM_CYVTHUMB);
  333. pwY++;
  334. }
  335. else
  336. {
  337. cy = GetSystemMetrics(SM_CXHTHUMB);
  338. pwX++;
  339. }
  341. cx = (pSBTrack->pSBInfo->pxRight - pSBTrack->pSBInfo->pxLeft) * 8;
  342. cy *= 2;
  344. *(pwX + 0) = pSBTrack->pSBInfo->pxLeft - cx;
  345. *(pwY + 0) = pSBTrack->pSBInfo->pxTop - cy;
  346. *(pwX + 2) = pSBTrack->pSBInfo->pxRight + cx;
  347. *(pwY + 2) = pSBTrack->pSBInfo->pxBottom + cy;
  348. }
  350. void CXTPMarkupScrollBar::DoScroll(int cmd, int pos)
  351. {
  352. CXTPMarkupScrollViewer* pViewer = MARKUP_DYNAMICCAST(CXTPMarkupScrollViewer, GetLogicalParent());
  353. if (pViewer)
  354. {
  355. pViewer->Scroll(m_spi.fVert ? SB_VERT : SB_HORZ, cmd, pos);
  356. }
  357. }
  359. void CXTPMarkupScrollBar::ScreenToClient(HWND hWnd,  LPPOINT lpPoint)
  360. {
  361. ::ScreenToClient(hWnd, lpPoint);
  363. CXTPMarkupMouseEventArgs e(0);
  364. e.m_hWnd = hWnd;
  365. e.m_point = *lpPoint;
  367. *lpPoint = e.GetPosition(this);
  368. }
  370. void CXTPMarkupScrollBar::PerformTrackInit(HWND hWnd, CPoint point, SCROLLBARPOSINFO* pSBInfo, BOOL bDirect)
  371. {
  372. int px = m_spi.fVert ? point.y : point.x;
  374. SCROLLBARTRACKINFO* pSBTrack = new SCROLLBARTRACKINFO;
  375. memset(pSBTrack, 0, sizeof(SCROLLBARTRACKINFO));
  377. pSBTrack->cmdSB = (UINT)-1;
  378. pSBTrack->bTrackThumb = FALSE;
  379. pSBTrack->pSBInfo = pSBInfo;
  380. pSBTrack->hWndTrack = hWnd;
  382. m_pSBTrack = pSBTrack;
  384. RECT rcSB;
  385. LPINT pwX = (LPINT)&rcSB;
  386. LPINT pwY = pwX + 1;
  387. if (!pSBInfo->fVert)
  388. pwX = pwY--;
  390. *(pwX + 0) = pSBInfo->pxLeft;
  391. *(pwY + 0) = pSBInfo->pxTop;
  392. *(pwX + 2) = pSBInfo->pxRight;
  393. *(pwY + 2) = pSBInfo->pxBottom;
  396. if (px < pSBInfo->pxUpArrow)
  397. {
  398. pSBInfo->ht = XTP_HTSCROLLUP;
  399. pSBTrack->cmdSB = SB_LINEUP;
  400. *(pwY + 2) = pSBInfo->pxUpArrow;
  402. }
  403. else if (px >= pSBInfo->pxDownArrow)
  404. {
  405. pSBInfo->ht = XTP_HTSCROLLDOWN;
  406. pSBTrack->cmdSB = SB_LINEDOWN;
  407. *(pwY + 0) = pSBInfo->pxDownArrow;
  408. }
  409. else if (px < pSBInfo->pxThumbTop)
  410. {
  411. pSBInfo->ht = XTP_HTSCROLLUPPAGE;
  412. pSBTrack->cmdSB = SB_PAGEUP;
  413. *(pwY + 0) = pSBInfo->pxUpArrow;
  414. *(pwY + 2) = pSBInfo->pxThumbTop;
  415. }
  416. else if (px < pSBInfo->pxThumbBottom)
  417. {
  418. pSBInfo->ht = XTP_HTSCROLLTHUMB;
  419. DoThumbPos:
  421. if (pSBInfo->pxDownArrow - pSBInfo->pxUpArrow <= pSBInfo->cpxThumb)
  422. {
  423. delete m_pSBTrack;
  424. m_pSBTrack = NULL;
  425. return;
  426. }
  428. pSBTrack->cmdSB = SB_THUMBPOSITION;
  429. CalcTrackDragRect(pSBTrack);
  431. pSBTrack->pxOld = pSBInfo->pxStart = pSBInfo->pxThumbTop;
  432. pSBTrack->posNew = pSBTrack->posOld = pSBInfo->pos;
  433. pSBTrack->dpxThumb = pSBInfo->pxStart - px;
  435. pSBTrack->bTrackThumb = TRUE;
  437. ::SetCapture(hWnd);
  439. DoScroll(SB_THUMBTRACK, pSBTrack->posOld);
  441. }
  442. else if (px < pSBInfo->pxDownArrow)
  443. {
  444. pSBInfo->ht = XTP_HTSCROLLDOWNPAGE;
  445. pSBTrack->cmdSB = SB_PAGEDOWN;
  446. *(pwY + 0) = pSBInfo->pxThumbBottom;
  447. *(pwY + 2) = pSBInfo->pxDownArrow;
  448. }
  450. if ((bDirect && pSBTrack->cmdSB != SB_LINEUP && pSBTrack->cmdSB != SB_LINEDOWN))
  451. {
  452. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  453. {
  454. goto DoThumbPos;
  455. }
  456. pSBTrack->dpxThumb = -(pSBInfo->cpxThumb / 2);
  457. }
  459. ::SetCapture(hWnd);
  461. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  462. {
  463. CopyRect(&pSBTrack->rcTrack, &rcSB);
  464. }
  466. if (!pSBTrack->bTrackThumb)
  467. {
  468. TrackBox(WM_LBUTTONDOWN, point);
  469. }
  470. else
  471. {
  472. TrackThumb(WM_LBUTTONDOWN, point);
  474. }
  476. while (::GetCapture() == hWnd)
  477. {
  478. MSG msg;
  480. while (::PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_NOREMOVE))
  481. {
  482. if (!GetMessage(&msg, NULL, WM_PAINT, WM_PAINT))
  483. return;
  484. DispatchMessage(&msg);
  485. }
  487. if (!::GetMessage(&msg, NULL, 0, 0))
  488. {
  489. AfxPostQuitMessage((int)msg.wParam);
  490. break;
  491. }
  493. if (!IsWindow(hWnd))
  494. break;
  496. UINT cmd = msg.message;
  498. if (cmd == WM_TIMER && msg.wParam == IDSYS_SCROLL)
  499. {
  500. ContScroll();
  501. }
  502. else if (cmd >= WM_MOUSEFIRST && cmd <= WM_MOUSELAST)
  503. {
  504. CPoint ptScreen = msg.pt;
  506. ScreenToClient(hWnd, &ptScreen);
  508. if (!pSBTrack->bTrackThumb)
  509. {
  510. TrackBox(cmd, ptScreen);
  511. }
  512. else
  513. {
  514. TrackThumb(cmd, ptScreen);
  515. }
  516. }
  517. else
  518. {
  519. TranslateMessage(&msg);
  520. DispatchMessage(&msg);
  521. }
  523. }
  525. if (pSBTrack->hTimerSB != 0)
  526. {
  527. ::KillTimer(hWnd, pSBTrack->hTimerSB);
  528. }
  530. delete m_pSBTrack;
  531. m_pSBTrack = NULL;
  533. if (IsWindow(hWnd))
  534. {
  535. GetCursorPos(&point);
  536. ScreenToClient(hWnd, &point);
  537. m_spi.ht = HitTestScrollBar(point);
  539. RedrawScrollBar();
  540. }
  541. }
  544. void CXTPMarkupScrollBar::OnMouseLeave(CXTPMarkupMouseEventArgs* e)
  545. {
  546. if (m_spi.ht != HTNOWHERE)
  547. {
  548. m_spi.ht = HTNOWHERE;
  549. RedrawScrollBar();
  550. }
  552. CXTPMarkupControl::OnMouseLeave(e);
  553. }
  555. void CXTPMarkupScrollBar::OnMouseEnter(CXTPMarkupMouseEventArgs* e)
  556. {
  557. CXTPMarkupControl::OnMouseEnter(e);
  558. }
  560. void CXTPMarkupScrollBar::OnMouseMove(CXTPMarkupMouseEventArgs* e)
  561. {
  562. int ht = HitTestScrollBar(e->GetPosition(this));
  564. if (ht != m_spi.ht)
  565. {
  566. m_spi.ht = ht;
  567. RedrawScrollBar();
  568. }
  570. e->SetHandled();
  571. }
  573. void CXTPMarkupScrollBar::OnMouseLeftButtonUp(CXTPMarkupMouseButtonEventArgs* e)
  574. {
  575. CXTPMarkupControl::OnMouseLeftButtonUp(e);
  576. }
  578. void CXTPMarkupScrollBar::OnMouseLeftButtonDown(CXTPMarkupMouseButtonEventArgs* e)
  579. {
  580. e->SetHandled();
  582. if (IsEnabled())
  583. {
  584. PerformTrackInit(e->m_hWnd, e->GetPosition(this), &m_spi, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  585. }
  586. }
  589. void CXTPMarkupScrollBar::RedrawScrollBar()
  590. {
  591. InvalidateVisual();
  592. }
  595. void CXTPMarkupScrollBar::CalcScrollBarInfo(LPRECT lprc, SCROLLBARPOSINFO* pSBInfo, SCROLLINFO* pSI)
  596. {
  597. int cpx;
  598. DWORD dwRange;
  599. int denom;
  602. BOOL fVert = pSBInfo->fVert = (m_orientation == xtpMarkupOrientationVertical);
  604. pSBInfo->rc = *lprc;
  605. pSBInfo->pxPopup = 0;
  607. if (fVert)
  608. {
  609. pSBInfo->pxTop = lprc->top;
  610. pSBInfo->pxBottom = lprc->bottom;
  611. pSBInfo->pxLeft = lprc->left;
  612. pSBInfo->pxRight = lprc->right;
  613. pSBInfo->cpxThumb = GetSystemMetrics(SM_CYVSCROLL);
  614. }
  615. else
  616. {
  617. pSBInfo->pxTop = lprc->left;
  618. pSBInfo->pxBottom = lprc->right;
  619. pSBInfo->pxLeft = lprc->top;
  620. pSBInfo->pxRight = lprc->bottom;
  621. pSBInfo->cpxThumb = GetSystemMetrics(SM_CXHSCROLL);
  622. }
  624. pSBInfo->pos = pSI->nPos;
  625. pSBInfo->page = pSI->nPage;
  626. pSBInfo->posMin = pSI->nMin;
  627. pSBInfo->posMax = pSI->nMax;
  629. dwRange = ((DWORD)(pSBInfo->posMax - pSBInfo->posMin)) + 1;
  631. cpx = min((pSBInfo->pxBottom - pSBInfo->pxTop) / 2, pSBInfo->cpxThumb);
  633. pSBInfo->pxUpArrow  = pSBInfo->pxTop    + cpx;
  634. pSBInfo->pxDownArrow = pSBInfo->pxBottom - cpx;
  636. if ((pSBInfo->page != 0) && (dwRange != 0))
  637. {
  638. int i = MulDiv(pSBInfo->pxDownArrow - pSBInfo->pxUpArrow,
  639. pSBInfo->page, dwRange);
  641. pSBInfo->cpxThumb = max(pSBInfo->cpxThumb / 2, i);
  642. }
  644. pSBInfo->pxMin = pSBInfo->pxTop + cpx;
  645. pSBInfo->cpx = pSBInfo->pxBottom - cpx - pSBInfo->cpxThumb - pSBInfo->pxMin;
  647. denom = dwRange - (pSBInfo->page ? pSBInfo->page : 1);
  648. if (denom)
  649. pSBInfo->pxThumbTop = MulDiv(pSBInfo->pos - pSBInfo->posMin,
  650. pSBInfo->cpx, denom) + pSBInfo->pxMin;
  651. else
  652. pSBInfo->pxThumbTop = pSBInfo->pxMin;
  654. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  655. }
  657. CSize CXTPMarkupScrollBar::ArrangeOverride(CSize szFinalSize)
  658. {
  659. CalcScrollBarInfo(CRect(0, 0, szFinalSize.cx, szFinalSize.cy), &m_spi, &m_si);
  661. return szFinalSize;
  662. }
  664. CSize CXTPMarkupScrollBar::MeasureOverride(CXTPMarkupDrawingContext* /*pDC*/, CSize /*szAvailableSize*/)
  665. {
  666. BOOL bHorizontal = (m_orientation == xtpMarkupOrientationHorizontal);
  668. if (bHorizontal)
  669. return CSize(0, GetSystemMetrics(SM_CYHSCROLL));
  671. return CSize(GetSystemMetrics(SM_CXVSCROLL), 0);
  672. }
  674. BOOL CXTPMarkupScrollBar::IsEnabled() const
  675. {
  676. return m_spi.posMax - m_spi.posMin - m_spi.page + 1 > 0;
  677. }
  679. void CXTPMarkupScrollBar::OnRender(CXTPMarkupDrawingContext* pDC)
  680. {
  681. #define GETPARTSTATE(ht, pressed, hot, normal, disabled) 
  682. (!bEnabled ? disabled : nPressetHt == ht ? pressed : nHotHt == ht ? hot : normal)
  684. SCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  685. SCROLLBARPOSINFO* pSBInfo = &m_spi;
  687. BOOL nPressetHt = pSBTrack ? (pSBTrack->bTrackThumb || pSBTrack->fHitOld ? pSBInfo->ht : -1) : -1;
  688. BOOL nHotHt = pSBTrack ? -1 : pSBInfo->ht;
  691. int cWidth = (pSBInfo->pxRight - pSBInfo->pxLeft);
  693. if (cWidth <= 0)
  694. {
  695. return;
  696. }
  698. BOOL bEnabled = IsEnabled();
  700. int nBtnTrackSize =   pSBInfo->pxThumbBottom - pSBInfo->pxThumbTop;
  701. int nBtnTrackPos = pSBInfo->pxThumbTop - pSBInfo->pxUpArrow;
  703. if (!bEnabled || pSBInfo->pxThumbBottom > pSBInfo->pxDownArrow)
  704. nBtnTrackPos = nBtnTrackSize = 0;
  706. BOOL bUseVisualStyle = TRUE;
  708. CXTPWinThemeWrapper m_themeScrollBar;
  709. m_themeScrollBar.OpenTheme(0, L"SCROLLBAR");
  711. COLORREF clrFace = GetSysColor(COLOR_3DFACE);
  712. COLORREF m_crBackHilite = clrFace, m_crBackPushed = clrFace, m_crBack = clrFace;
  714. if (pSBInfo->fVert)
  715. {
  716. CRect rcVScroll(pSBInfo->rc);
  718. CRect rcArrowUp(rcVScroll.left, rcVScroll.top, rcVScroll.right, pSBInfo->pxUpArrow);
  719. CRect rcArrowDown(rcVScroll.left, pSBInfo->pxDownArrow, rcVScroll.right, rcVScroll.bottom);
  720. CRect rcTrack(rcVScroll.left, rcArrowUp.bottom, rcVScroll.right, rcArrowDown.top);
  722. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.right, rcTrack.top + nBtnTrackPos);
  723. CRect rcBtnTrack(rcTrack.left, rcLowerTrack.bottom, rcTrack.right, rcLowerTrack.bottom + nBtnTrackSize);
  724. CRect rcUpperTrack(rcTrack.left, rcBtnTrack.bottom, rcTrack.right, rcTrack.bottom);
  727. if (bUseVisualStyle  && m_themeScrollBar.IsAppThemed())
  728. {
  729. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP, ABS_UPPRESSED, ABS_UPHOT, ABS_UPNORMAL, ABS_UPDISABLED),  rcArrowUp, NULL);
  730. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN, ABS_DOWNPRESSED, ABS_DOWNHOT, ABS_DOWNNORMAL, ABS_DOWNDISABLED),  rcArrowDown, NULL);
  732. if (!rcTrack.IsRectEmpty())
  733. {
  734. if (!rcLowerTrack.IsRectEmpty())
  735. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_LOWERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcLowerTrack, NULL);
  737. if (!rcBtnTrack.IsRectEmpty())
  738. {
  739. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_THUMBBTNVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  740. if (rcBtnTrack.Height() > 13)
  741. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_GRIPPERVERT, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  742. }
  744. if (!rcUpperTrack.IsRectEmpty())
  745. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_UPPERTRACKVERT, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcUpperTrack, NULL);
  746. }
  747. }
  748. else
  749. {
  750. {
  751. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowUp, DFC_SCROLL, DFCS_SCROLLUP | (!bEnabled ? DFCS_INACTIVE : 0) | (nPressetHt == XTP_HTSCROLLUP ? DFCS_PUSHED : 0));
  752. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowDown, DFC_SCROLL, DFCS_SCROLLDOWN | (!bEnabled ? DFCS_INACTIVE : 0)  | (nPressetHt == XTP_HTSCROLLDOWN ? DFCS_PUSHED : 0));
  753. }
  756. HBRUSH hbrRet = (HBRUSH)SendMessage(::GetDesktopWindow(), WM_CTLCOLORSCROLLBAR, (WPARAM)pDC->GetSafeHdc(), 0);
  757. SetBkColor(pDC->GetSafeHdc(), GetSysColor(COLOR_3DHILIGHT));
  758. SetTextColor(pDC->GetSafeHdc(), GetSysColor(COLOR_BTNFACE));
  759. ::FillRect(pDC->GetSafeHdc(), &rcTrack, hbrRet);
  761. if (nPressetHt == XTP_HTSCROLLUPPAGE)
  762. {
  763. ::InvertRect(pDC->GetSafeHdc(), &rcLowerTrack);
  764. }
  766. if (!rcTrack.IsRectEmpty() && !rcBtnTrack.IsRectEmpty())
  767. {
  768. pDC->FillSolidRect(rcBtnTrack, nPressetHt == XTP_HTSCROLLTHUMB ? m_crBackPushed : nHotHt == XTP_HTSCROLLTHUMB ? m_crBackHilite : m_crBack);
  770. DrawEdge(pDC->GetSafeHdc(), &rcBtnTrack, EDGE_RAISED, (UINT)(BF_ADJUST | BF_RECT));
  772. }
  774. if (nPressetHt == XTP_HTSCROLLDOWNPAGE)
  775. {
  776. ::InvertRect(pDC->GetSafeHdc(), &rcUpperTrack);
  777. }
  778. }
  779. }
  780. else
  781. {
  782. CRect rcHScroll(pSBInfo->rc);
  784. CRect rcArrowLeft(rcHScroll.left, rcHScroll.top, pSBInfo->pxUpArrow, rcHScroll.bottom);
  785. CRect rcArrowRight(pSBInfo->pxDownArrow, rcHScroll.top, rcHScroll.right, rcHScroll.bottom);
  786. CRect rcTrack(rcArrowLeft.right, rcHScroll.top, rcArrowRight.left, rcHScroll.bottom);
  788. CRect rcLowerTrack(rcTrack.left, rcTrack.top, rcTrack.left + nBtnTrackPos, rcTrack.bottom);
  789. CRect rcBtnTrack(rcLowerTrack.right, rcTrack.top, rcLowerTrack.right + nBtnTrackSize, rcTrack.bottom);
  790. CRect rcUpperTrack(rcBtnTrack.right, rcTrack.top, rcTrack.right, rcTrack.bottom);
  793. if (bUseVisualStyle  && m_themeScrollBar.IsAppThemed())
  794. {
  795. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLUP, ABS_LEFTPRESSED, ABS_LEFTHOT, ABS_LEFTNORMAL, ABS_LEFTDISABLED),  rcArrowLeft, NULL);
  796. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_ARROWBTN, GETPARTSTATE(XTP_HTSCROLLDOWN, ABS_RIGHTPRESSED, ABS_RIGHTHOT, ABS_RIGHTNORMAL, ABS_RIGHTDISABLED),  rcArrowRight, NULL);
  798. if (!rcTrack.IsRectEmpty())
  799. {
  800. if (!rcLowerTrack.IsRectEmpty())
  801. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_LOWERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLUPPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcLowerTrack, NULL);
  803. if (!rcBtnTrack.IsRectEmpty())
  804. {
  805. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_THUMBBTNHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  806. if (rcBtnTrack.Width() > 13)
  807. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_GRIPPERHORZ, GETPARTSTATE(XTP_HTSCROLLTHUMB, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcBtnTrack, NULL);
  808. }
  810. if (!rcUpperTrack.IsRectEmpty())
  811. m_themeScrollBar.DrawThemeBackground(pDC->GetSafeHdc(), SBP_UPPERTRACKHORZ, GETPARTSTATE(XTP_HTSCROLLDOWNPAGE, SCRBS_PRESSED, SCRBS_HOT, SCRBS_NORMAL, SCRBS_DISABLED),  rcUpperTrack, NULL);
  812. }
  813. }
  814. else
  815. {
  816. {
  817. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowLeft, DFC_SCROLL, DFCS_SCROLLLEFT | (!bEnabled ? DFCS_INACTIVE : 0) | (nPressetHt == XTP_HTSCROLLUP ? DFCS_PUSHED : 0));
  818. DrawFrameControl(pDC->GetSafeHdc(), &rcArrowRight, DFC_SCROLL, DFCS_SCROLLRIGHT | (!bEnabled ? DFCS_INACTIVE : 0)  | (nPressetHt == XTP_HTSCROLLDOWN ? DFCS_PUSHED : 0));
  819. }
  821. HBRUSH hbrRet = (HBRUSH)SendMessage(::GetDesktopWindow(), WM_CTLCOLORSCROLLBAR, (WPARAM)pDC->GetSafeHdc(), 0);
  822. SetBkColor(pDC->GetSafeHdc(), GetSysColor(COLOR_3DHILIGHT));
  823. SetTextColor(pDC->GetSafeHdc(), GetSysColor(COLOR_BTNFACE));
  824. ::FillRect(pDC->GetSafeHdc(), &rcTrack, hbrRet);
  827. if (nPressetHt == XTP_HTSCROLLUPPAGE)
  828. {
  829. ::InvertRect(pDC->GetSafeHdc(), &rcLowerTrack);
  830. }
  832. if (!rcTrack.IsRectEmpty() && !rcBtnTrack.IsRectEmpty())
  833. {
  834. pDC->FillSolidRect(rcBtnTrack, nPressetHt == XTP_HTSCROLLTHUMB ? m_crBackPushed : nHotHt == XTP_HTSCROLLTHUMB ? m_crBackHilite : m_crBack);
  836. {
  837. DrawEdge(pDC->GetSafeHdc(), &rcBtnTrack, EDGE_RAISED, (UINT)(BF_ADJUST | BF_RECT));
  838. }
  839. }
  841. if (nPressetHt == XTP_HTSCROLLDOWNPAGE)
  842. {
  843. ::InvertRect(pDC->GetSafeHdc(), &rcUpperTrack);
  844. }
  845. }
  846. }
  847. }
  849. //////////////////////////////////////////////////////////////////////////
  850. // CXTPMarkupScrollBarGripper
  852. class CXTPMarkupScrollBarGripper : public CXTPMarkupUIElement
  853. {
  854. DECLARE_MARKUPCLASS(CXTPMarkupScrollBarGripper)
  856. public:
  857. void OnRender(CXTPMarkupDrawingContext* pDC);
  858. };
  860. IMPLEMENT_MARKUPCLASS(NULL, CXTPMarkupScrollBarGripper, CXTPMarkupUIElement)
  862. void CXTPMarkupScrollBarGripper::RegisterMarkupClass()
  863. {
  864. }
  866. void CXTPMarkupScrollBarGripper::OnRender(CXTPMarkupDrawingContext* pDC)
  867. {
  868. CRect rc(GetFinalRect());
  869. pDC->FillSolidRect(rc, GetSysColor(COLOR_BTNFACE));
  870. }
  872. //////////////////////////////////////////////////////////////////////////
  873. // CXTPMarkupScrollViewer
  875. CXTPMarkupDependencyProperty* CXTPMarkupScrollViewer::m_pVerticalScrollBarVisibilityProperty = NULL;
  876. CXTPMarkupDependencyProperty* CXTPMarkupScrollViewer::m_pHorizontalScrollBarVisibilityProperty = NULL;
  878. IMPLEMENT_MARKUPCLASS(L"ScrollViewer", CXTPMarkupScrollViewer, CXTPMarkupContentControl)
  880. void CXTPMarkupScrollViewer::RegisterMarkupClass()
  881. {
  882. m_pVerticalScrollBarVisibilityProperty = CXTPMarkupDependencyProperty::Register(L"VerticalScrollBarVisibility", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupScrollViewer),
  883. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertScrollBarVisibility, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  885. m_pHorizontalScrollBarVisibilityProperty = CXTPMarkupDependencyProperty::Register(L"HorizontalScrollBarVisibility", MARKUP_TYPE(CXTPMarkupEnum), MARKUP_TYPE(CXTPMarkupScrollViewer),
  886. new CXTPMarkupPropertyMetadata(NULL, &CXTPMarkupBuilder::ConvertScrollBarVisibility, CXTPMarkupPropertyMetadata::flagAffectsMeasure));
  888. }
  890. CXTPMarkupScrollViewer::CXTPMarkupScrollViewer()
  891. {
  892. m_pVerticalScrollBar = NULL;
  893. m_pHorizontalScrollBar = NULL;
  894. m_pScrollBarGripper = NULL;
  896. m_xOffset = m_yOffset = 0;
  897. SetValue(m_pClipToBoundsProperty, CXTPMarkupBool::CreateTrueValue());
  898. }
  900. CXTPMarkupScrollViewer::~CXTPMarkupScrollViewer()
  901. {
  902. MARKUP_RELEASE(m_pVerticalScrollBar);
  903. MARKUP_RELEASE(m_pHorizontalScrollBar);
  904. MARKUP_RELEASE(m_pScrollBarGripper);
  905. }
  907. int CXTPMarkupScrollViewer::GetVisualChildrenCount() const
  908. {
  909. return (GetContent() != NULL ? 1 : 0) + (m_pVerticalScrollBar ? 1 : 0) + (m_pHorizontalScrollBar ? 1 : 0) + (m_pScrollBarGripper ? 1 : 0);
  910. }
  912. CXTPMarkupVisual* CXTPMarkupScrollViewer::GetVisualChild(int nIndex) const
  913. {
  914. CXTPMarkupVisual* pContent = GetContent();
  915. if (pContent) if (nIndex == 0) return pContent; else nIndex--;
  916. if (m_pVerticalScrollBar) if (nIndex == 0) return m_pVerticalScrollBar; else nIndex--;
  917. if (m_pHorizontalScrollBar) if (nIndex == 0) return m_pHorizontalScrollBar; else nIndex--;
  918. return m_pScrollBarGripper;
  919. }
  921. CSize CXTPMarkupScrollViewer::ArrangeOverride(CSize szFinalSize)
  922. {
  923. CXTPMarkupUIElement* pContent = GetContent();
  924. if (!pContent)
  925. return szFinalSize;
  927. CSize szViewport(szFinalSize);
  929. if (m_pVerticalScrollBar) szViewport.cx -= m_pVerticalScrollBar->GetDesiredSize().cx;
  930. if (m_pHorizontalScrollBar) szViewport.cy -= m_pHorizontalScrollBar->GetDesiredSize().cy;;
  932. if (m_pVerticalScrollBar)
  933. {
  934. if (m_yOffset > 0 && pContent->GetDesiredSize().cy < m_yOffset + szViewport.cy)
  935. {
  936. m_yOffset = max(0, pContent->GetDesiredSize().cy - szViewport.cy);
  937. }
  939. SCROLLINFO si;
  940. ZeroMemory(&si, sizeof(SCROLLINFO));
  941. si.nMax = pContent->GetDesiredSize().cy - 1;
  942. si.nPage = szViewport.cy;
  943. si.nPos = m_yOffset;
  944. m_pVerticalScrollBar->SetScrollInfo(&si);
  946. m_pVerticalScrollBar->Arrange(CRect(szFinalSize.cx - m_pVerticalScrollBar->GetDesiredSize().cx, 0, szFinalSize.cx, szViewport.cy));
  947. }
  949. if (m_pHorizontalScrollBar)
  950. {
  951. if (m_xOffset > 0 && pContent->GetDesiredSize().cx < m_xOffset + szViewport.cx)
  952. {
  953. m_xOffset = max(0, pContent->GetDesiredSize().cx - szViewport.cx);
  954. }
  956. SCROLLINFO si;
  957. ZeroMemory(&si, sizeof(SCROLLINFO));
  958. si.nMax = pContent->GetDesiredSize().cx - 1;
  959. si.nPage = szViewport.cx;
  960. si.nPos = m_xOffset;
  961. m_pHorizontalScrollBar->SetScrollInfo(&si);
  963. m_pHorizontalScrollBar->Arrange(CRect(0, szFinalSize.cy - m_pHorizontalScrollBar->GetDesiredSize().cy, szViewport.cx, szFinalSize.cy));
  964. }
  966. if (m_pScrollBarGripper && m_pHorizontalScrollBar && m_pVerticalScrollBar)
  967. {
  968. m_pScrollBarGripper->Arrange(CRect(szFinalSize.cx - m_pVerticalScrollBar->GetDesiredSize().cx, szFinalSize.cy - m_pHorizontalScrollBar->GetDesiredSize().cy, szFinalSize.cx, szFinalSize.cy));
  969. }
  971. CRect rcContent(0, 0, max(szViewport.cx, pContent->GetDesiredSize().cx), max(szViewport.cy, pContent->GetDesiredSize().cy));
  972. rcContent.OffsetRect(-m_xOffset, -m_yOffset);
  973. pContent->Arrange(rcContent);
  975. return szFinalSize;
  976. }
  978. void CXTPMarkupScrollViewer::CreateScrollBar(int nBar)
  979. {
  980. if (nBar == SB_VERT && m_pVerticalScrollBar == NULL)
  981. {
  982. m_pVerticalScrollBar = (CXTPMarkupScrollBar*)m_pMarkupContext->CreateMarkupObject(MARKUP_TYPE(CXTPMarkupScrollBar));
  983. m_pVerticalScrollBar->SetOrientation(xtpMarkupOrientationVertical);
  984. m_pVerticalScrollBar->SetLogicalParent(this);
  985. }
  987. if (nBar == SB_HORZ && m_pHorizontalScrollBar == NULL)
  988. {
  989. m_pHorizontalScrollBar = (CXTPMarkupScrollBar*)m_pMarkupContext->CreateMarkupObject(MARKUP_TYPE(CXTPMarkupScrollBar));
  990. m_pHorizontalScrollBar->SetOrientation(xtpMarkupOrientationHorizontal);
  991. m_pHorizontalScrollBar->SetLogicalParent(this);
  992. }
  993. }
  995. CSize CXTPMarkupScrollViewer::MeasureOverride(CXTPMarkupDrawingContext* pDC, CSize szAvailableSize)
  996. {
  997. CXTPMarkupUIElement* pContent = GetContent();
  998. if (!pContent)
  999. return CSize(0, 0);
  1001. CSize szScroll(0, 0);
  1003. XTPMarkupScrollBarVisibility verticalBarVisibility = GetVerticalScrollBarVisibility();
  1004. XTPMarkupScrollBarVisibility horizontalBarVisibility = GetHorizontalScrollBarVisibility();
  1006. CSize szViewportSize(INT_MAX, INT_MAX);
  1008. if (horizontalBarVisibility == xtpMarkupScrollBarDisabled) szViewportSize.cx = szAvailableSize.cx;
  1009. if (verticalBarVisibility == xtpMarkupScrollBarDisabled) szViewportSize.cy = szAvailableSize.cy;
  1011. if (verticalBarVisibility == xtpMarkupScrollBarAuto)
  1012. {
  1013. pContent->Measure(pDC, szViewportSize);
  1015. verticalBarVisibility = (pContent->GetDesiredSize().cy > szAvailableSize.cy) ? xtpMarkupScrollBarVisible : xtpMarkupScrollBarDisabled;
  1016. }
  1018. if (verticalBarVisibility == xtpMarkupScrollBarVisible)
  1019. {
  1020. CreateScrollBar(SB_VERT);
  1021. m_pVerticalScrollBar->Measure(pDC, szAvailableSize);
  1022. szScroll.cx = m_pVerticalScrollBar->GetDesiredSize().cx;
  1024. if (szViewportSize.cx != INT_MAX) szViewportSize.cx = max(0, szViewportSize.cx - szScroll.cx);
  1025. }
  1026. else
  1027. {
  1028. MARKUP_RELEASE(m_pVerticalScrollBar);
  1029. m_yOffset = 0;
  1030. }
  1032. if (horizontalBarVisibility == xtpMarkupScrollBarAuto)
  1033. {
  1034. pContent->Measure(pDC, szViewportSize);
  1036. horizontalBarVisibility = (pContent->GetDesiredSize().cx > szAvailableSize.cx - szScroll.cx) ? xtpMarkupScrollBarVisible : xtpMarkupScrollBarDisabled;
  1037. }
  1039. if (horizontalBarVisibility == xtpMarkupScrollBarVisible)
  1040. {
  1041. CreateScrollBar(SB_HORZ);
  1042. m_pHorizontalScrollBar->Measure(pDC, szAvailableSize);
  1043. szScroll.cy = m_pHorizontalScrollBar->GetDesiredSize().cy;
  1044. if (szViewportSize.cy != INT_MAX)  szViewportSize.cy = max(0, szViewportSize.cy - szScroll.cy);
  1045. }
  1046. else
  1047. {
  1048. MARKUP_RELEASE(m_pHorizontalScrollBar);
  1049. m_xOffset = 0;
  1050. }
  1052. if (m_pVerticalScrollBar && m_pHorizontalScrollBar)
  1053. {
  1054. if (m_pScrollBarGripper == NULL)
  1055. {
  1056. m_pScrollBarGripper = (CXTPMarkupScrollBarGripper*)m_pMarkupContext->CreateMarkupObject(MARKUP_TYPE(CXTPMarkupScrollBarGripper));
  1057. m_pScrollBarGripper->SetLogicalParent(this);
  1058. }
  1059. }
  1060. else
  1061. {
  1062. MARKUP_RELEASE(m_pScrollBarGripper);
  1063. }
  1065. pContent->Measure(pDC, szViewportSize);
  1066. return CSize(min(szAvailableSize.cx, pContent->GetDesiredSize().cx + szScroll.cx), min(szAvailableSize.cy, pContent->GetDesiredSize().cy + szScroll.cy));
  1067. }
  1069. void CXTPMarkupScrollViewer::Scroll(int nBar, int nSBCode, int pos)
  1070. {
  1071. CXTPMarkupScrollBar* pScrollBar = nBar == SB_VERT ? m_pVerticalScrollBar : m_pHorizontalScrollBar;
  1072. if (!pScrollBar)
  1073. return;
  1075. SCROLLINFO si;
  1076. pScrollBar->GetScrollInfo(&si);
  1078. int nCurPos = si.nPos;
  1079. int nPage = (int)si.nPage;
  1080. int nLimit = max(0, si.nMax - max(nPage - 1, 0));
  1082. // decide what to do for each different scroll event
  1083. switch (nSBCode)
  1084. {
  1085. case SB_TOP:
  1086. nCurPos = 0;
  1087. break;
  1088. case SB_BOTTOM:
  1089. nCurPos = nLimit;
  1090. break;
  1091. case SB_LINEUP:
  1092. nCurPos = max(nCurPos - 16, 0);
  1093. break;
  1094. case SB_LINEDOWN:
  1095. nCurPos = min(nCurPos + 16, nLimit);
  1096. break;
  1097. case SB_PAGEUP:
  1098. nCurPos = max(nCurPos - nPage, 0);
  1099. break;
  1100. case SB_PAGEDOWN:
  1101. nCurPos = min(nCurPos + nPage, nLimit);
  1102. break;
  1103. case SB_THUMBTRACK:
  1104. case SB_THUMBPOSITION:
  1106. nCurPos = pos;
  1107. break;
  1108. }
  1110. SetScrollPos(nBar, nCurPos);
  1111. }
  1113. int CXTPMarkupScrollViewer::GetScrollPos(int nBar)
  1114. {
  1115. return (nBar == SB_VERT) ? m_yOffset : m_xOffset;
  1116. }
  1118. int CXTPMarkupScrollViewer::GetScrollLimit(int nBar)
  1119. {
  1120. CXTPMarkupScrollBar* pScrollBar = nBar == SB_VERT ? m_pVerticalScrollBar : m_pHorizontalScrollBar;
  1121. if (!pScrollBar)
  1122. return 0;
  1124. SCROLLINFO si;
  1125. pScrollBar->GetScrollInfo(&si);
  1127. int nPage = (int)si.nPage;
  1128. int nLimit = max(0, si.nMax - max(nPage - 1, 0));
  1130. return nLimit;
  1131. }
  1133. void CXTPMarkupScrollViewer::SetScrollPos(int nBar, int pos)
  1134. {
  1135. int& nOffset = (nBar == SB_VERT) ? m_yOffset : m_xOffset;
  1136. int nLimit = GetScrollLimit(nBar);
  1138. if (pos > nLimit) pos = nLimit;
  1139. if (pos < 0) pos = 0;
  1141. if (nOffset != pos)
  1142. {
  1143. nOffset = pos;
  1144. InvalidateArrange();
  1145. }
  1146. }
  1148. void CXTPMarkupScrollViewer::OnMouseWheel(CXTPMarkupMouseWheelEventArgs* e)
  1149. {
  1150. SetScrollPos(SB_VERT, e->m_nDelta < 0 ? GetScrollPos(SB_VERT) + 48 : GetScrollPos(SB_VERT) - 48);
  1152. e->SetHandled();
  1153. }