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

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

对话框与窗口

开发平台：

Visual C++

XTPSkinObjectScrollBar.cpp：源码内容
  1. // XTPSkinObjectScrollBar.cpp: implementation of the CXTPSkinObjectScrollBar class.
  2. //
  3. // This file is a part of the XTREME SKINFRAMEWORK 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 "XTPSkinManager.h"
  26. #include "XTPSkinObjectScrollBar.h"
  28. #ifdef _DEBUG
  29. #undef THIS_FILE
  30. static char THIS_FILE[]=__FILE__;
  31. #define new DEBUG_NEW
  32. #endif
  35. #define IDSYS_SCROLL 0xFA45
  37. CRect CXTPSkinObjectFrame::GetScrollBarRect(int nBar)
  38. {
  39. CRect rcClient;
  40. GetClientRect(&rcClient);
  42. if (nBar == SB_CTL)
  43. {
  44. return rcClient;
  45. }
  47. CRect rc;
  48. GetWindowRect(rc);
  49. ScreenToClient(rc);
  51. if (nBar == SB_VERT)
  52. {
  53. rc.bottom = rcClient.bottom - rc.top;
  54. rc.top = rcClient.top - rc.top;
  56. if (GetExStyle() & WS_EX_LEFTSCROLLBAR)
  57. {
  58. rc.left = rcClient.left - rc.left - GetMetrics()->m_cxVScroll;
  59. }
  60. else
  61. {
  62. rc.left = rcClient.right - rc.left;
  63. }
  64. rc.right = rc.left + GetMetrics()->m_cxVScroll;
  65. }
  67. if (nBar == SB_HORZ)
  68. {
  69. rc.right = rcClient.right - rc.left;
  70. rc.left = rcClient.left - rc.left;
  72. rc.top = rcClient.bottom - rc.top;
  73. rc.bottom = rc.top + GetMetrics()->m_cyHScroll;
  74. }
  76. return rc;
  77. }
  79. void CXTPSkinObjectFrame::SetupScrollInfo(XTP_SKINSCROLLBARPOSINFO* pSBInfo)
  80. {
  81. CRect rc = GetScrollBarRect(pSBInfo->nBar);
  83. SCROLLINFO si;
  84. si.cbSize = sizeof(SCROLLINFO);
  86. si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
  87. ::GetScrollInfo(m_hWnd, pSBInfo->nBar, &si);
  89. CalcScrollBarInfo(&rc, pSBInfo, &si);
  90. }
  92. void CXTPSkinObjectFrame::RedrawScrollBar(int nBar)
  93. {
  94. ASSERT(nBar == SB_VERT || nBar == SB_HORZ);
  95. RedrawScrollBar(&m_spi[nBar]);
  97. }
  99. void CXTPSkinObjectFrame::RedrawScrollBar(XTP_SKINSCROLLBARPOSINFO* pSBInfo)
  100. {
  101. if (!pSBInfo->fVisible )
  102. return;
  104. if (!IsWindow(m_hWnd))
  105. return;
  107. CDC* pDC = pSBInfo->nBar == SB_CTL ? (CDC*)new CClientDC(this) : (CDC*)new CWindowDC(this);
  109. if (pDC)
  110. {
  111. CRect rc = GetScrollBarRect(pSBInfo->nBar);
  113. CXTPBufferDCEx dcMem(*pDC, rc);
  115. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  116. SetupScrollInfo(pSBInfo);
  118. DrawScrollBar(&dcMem, pSBInfo);
  119. }
  121. delete pDC;
  123. }
  125. int CXTPSkinObjectFrame::HitTestScrollBar(XTP_SKINSCROLLBARPOSINFO* pSBInfo, POINT pt)
  126. {
  127. if (!pSBInfo->fVisible)
  128. return HTNOWHERE;
  130. int px = pSBInfo->fVert ? pt.y : pt.x;
  132. if (!::PtInRect(&pSBInfo->rc, pt))
  133. return HTNOWHERE;
  135. if (px < pSBInfo->pxUpArrow)
  136. return XTP_HTSCROLLUP;
  138. if (px >= pSBInfo->pxDownArrow)
  139. return XTP_HTSCROLLDOWN;
  141. if (px < pSBInfo->pxThumbTop)
  142. return XTP_HTSCROLLUPPAGE;
  144. if (px < pSBInfo->pxThumbBottom)
  145. return XTP_HTSCROLLTHUMB;
  147. if (px < pSBInfo->pxDownArrow)
  148. return XTP_HTSCROLLDOWNPAGE;
  150. return HTERROR;
  151. }
  154. void CXTPSkinObjectFrame::CalcScrollBarInfo(LPRECT lprc, XTP_SKINSCROLLBARPOSINFO* pSBInfo, SCROLLINFO* pSI)
  155. {
  156. int cpx;
  157. DWORD dwRange;
  158. int denom;
  159. BOOL fVert = pSBInfo->fVert;
  161. pSBInfo->rc = *lprc;
  163. if (fVert)
  164. {
  165. pSBInfo->pxTop = lprc->top;
  166. pSBInfo->pxBottom = lprc->bottom;
  167. pSBInfo->pxLeft = lprc->left;
  168. pSBInfo->pxRight = lprc->right;
  169. pSBInfo->cpxThumb = GetMetrics()->m_cyVScroll;
  170. }
  171. else
  172. {
  173. pSBInfo->pxTop = lprc->left;
  174. pSBInfo->pxBottom = lprc->right;
  175. pSBInfo->pxLeft = lprc->top;
  176. pSBInfo->pxRight = lprc->bottom;
  177. pSBInfo->cpxThumb = GetMetrics()->m_cxHScroll;
  178. }
  180. pSBInfo->pos = pSI->nPos;
  181. pSBInfo->page = pSI->nPage;
  182. pSBInfo->posMin = pSI->nMin;
  183. pSBInfo->posMax = pSI->nMax;
  185. dwRange = ((DWORD)(pSBInfo->posMax - pSBInfo->posMin)) + 1;
  187. cpx = min((pSBInfo->pxBottom - pSBInfo->pxTop) / 2, pSBInfo->cpxThumb);
  189. pSBInfo->pxUpArrow  = pSBInfo->pxTop    + cpx;
  190. pSBInfo->pxDownArrow = pSBInfo->pxBottom - cpx;
  192. if ((pSBInfo->page != 0) && (dwRange != 0))
  193. {
  194. int i = MulDiv(pSBInfo->pxDownArrow - pSBInfo->pxUpArrow,
  195. pSBInfo->page, dwRange);
  197. pSBInfo->cpxThumb = max(pSBInfo->cpxThumb / 2, i);
  198. }
  200. pSBInfo->pxMin = pSBInfo->pxTop + cpx;
  201. pSBInfo->cpx = pSBInfo->pxBottom - cpx - pSBInfo->cpxThumb - pSBInfo->pxMin;
  203. denom = dwRange - (pSBInfo->page ? pSBInfo->page : 1);
  204. if (denom)
  205. pSBInfo->pxThumbTop = MulDiv(pSBInfo->pos - pSBInfo->posMin,
  206. pSBInfo->cpx, denom) + pSBInfo->pxMin;
  207. else
  208. pSBInfo->pxThumbTop = pSBInfo->pxMin - 1;
  210. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  212. }
  214. void XTPSkinCalcTrackDragRect(XTP_SKINSCROLLBARTRACKINFO* pSBTrack)
  215. {
  217. int     cx;
  218. int     cy;
  219. LPINT   pwX, pwY;
  221. pwX = pwY = (LPINT)&pSBTrack->rcTrack;
  223. if (pSBTrack->fTrackVert)
  224. {
  225. cy = GetSystemMetrics(SM_CYVTHUMB);
  226. pwY++;
  227. }
  228. else
  229. {
  230. cy = GetSystemMetrics(SM_CXHTHUMB);
  231. pwX++;
  232. }
  234. cx = (pSBTrack->pSBInfo->pxRight - pSBTrack->pSBInfo->pxLeft) * 8;
  235. cy *= 2;
  237. *(pwX + 0) = pSBTrack->pSBInfo->pxLeft - cx;
  238. *(pwY + 0) = pSBTrack->pSBInfo->pxTop - cy;
  239. *(pwX + 2) = pSBTrack->pSBInfo->pxRight + cx;
  240. *(pwY + 2) = pSBTrack->pSBInfo->pxBottom + cy;
  241. }
  243. void CXTPSkinObjectFrame::DoScroll(HWND hwnd, HWND hWndSBNotify, int cmd, int pos, BOOL fVert)
  244. {
  245. if (!hWndSBNotify)
  246. return;
  248. ::SendMessage(hWndSBNotify, (UINT)(fVert ? WM_VSCROLL : WM_HSCROLL),
  249. MAKELONG(cmd, pos), (LPARAM)hwnd);
  251. }
  253. void CXTPSkinObjectFrame::EndScroll(BOOL fCancel)
  254. {
  255. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  257. if (pSBTrack)
  258. {
  259. pSBTrack->cmdSB = 0;
  260. ReleaseCapture();
  262. if (pSBTrack->bTrackThumb)
  263. {
  264. if (fCancel)
  265. {
  266. pSBTrack->posOld = pSBTrack->pSBInfo->pos;
  267. }
  269. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
  270. SB_THUMBPOSITION, pSBTrack->posOld, pSBTrack->fTrackVert);
  272. RedrawScrollBar(pSBTrack->pSBInfo);
  273. }
  274. else
  275. {
  277. if (pSBTrack->hTimerSB != 0)
  278. {
  279. KillTimer(pSBTrack->hTimerSB);
  280. pSBTrack->hTimerSB = 0;
  281. }
  282. }
  285. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
  286. SB_ENDSCROLL, 0, pSBTrack->fTrackVert);
  287. }
  288. }
  290. int SBPosFromPx(XTP_SKINSCROLLBARPOSINFO*  pSBInfo, int px)
  291. {
  292. if (px < pSBInfo->pxMin)
  293. {
  294. return pSBInfo->posMin;
  295. }
  297. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  298. {
  299. return (pSBInfo->posMax - (pSBInfo->page ? pSBInfo->page - 1 : 0));
  300. }
  302. if (pSBInfo->cpx)
  303. return (pSBInfo->posMin + MulDiv(pSBInfo->posMax - pSBInfo->posMin -
  304. (pSBInfo->page ? pSBInfo->page - 1 : 0),
  305. px - pSBInfo->pxMin, pSBInfo->cpx));
  306. else
  307. return (pSBInfo->posMin - 1);
  308. }
  311. void CXTPSkinObjectFrame::MoveThumb(int px)
  312. {
  313. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  315. if ((pSBTrack == NULL) || (px == pSBTrack->pxOld))
  316. return;
  318. XTP_SKINSCROLLBARPOSINFO* pSBInfo = m_pSBTrack->pSBInfo;
  320. pxReCalc:
  322. pSBTrack->posNew = SBPosFromPx(pSBInfo, px);
  324. if (pSBTrack->posNew != pSBTrack->posOld)
  325. {
  326. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify, SB_THUMBTRACK, pSBTrack->posNew, pSBTrack->fTrackVert);
  328. pSBTrack->posOld = pSBTrack->posNew;
  330. if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  331. {
  332. px = pSBInfo->pxMin + pSBInfo->cpx;
  333. goto pxReCalc;
  334. }
  336. }
  338. pSBInfo->pxThumbTop = px;
  339. pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
  340. pSBTrack->pxOld = px;
  342. RedrawScrollBar(pSBTrack->pSBInfo);
  343. }
  345. void CXTPSkinObjectFrame::TrackThumb(UINT message, CPoint pt)
  346. {
  347. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  348. if (!pSBTrack)
  349. return;
  351. XTP_SKINSCROLLBARPOSINFO* pSBInfo = pSBTrack->pSBInfo;
  353. if (HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  354. return;
  356. if (pSBInfo == NULL)
  357. return;
  359. int px;
  361. if (!PtInRect(&pSBTrack->rcTrack, pt))
  362. px = pSBInfo->pxStart;
  363. else
  364. {
  365. px = (pSBTrack->fTrackVert ? pt.y : pt.x) + pSBTrack->dpxThumb;
  366. if (px < pSBInfo->pxMin)
  367. px = pSBInfo->pxMin;
  368. else if (px >= pSBInfo->pxMin + pSBInfo->cpx)
  369. px = pSBInfo->pxMin + pSBInfo->cpx;
  370. }
  372. MoveThumb(px);
  374. pSBTrack->fHitOld = TRUE;
  376. if (message == WM_LBUTTONUP || GetKeyState(VK_LBUTTON) >= 0)
  377. {
  378. EndScroll(FALSE);
  379. }
  380. }
  382. void CXTPSkinObjectFrame::TrackBox(UINT message, CPoint point)
  383. {
  384. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  386. if (pSBTrack == NULL)
  387. return;
  389. if (message != WM_NULL && HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
  390. return;
  392. if ((pSBTrack->cmdSB == SB_PAGEUP || pSBTrack->cmdSB == SB_PAGEDOWN))
  393. {
  394. int* pLength = (int *)&pSBTrack->rcTrack;
  396. if (pSBTrack->fTrackVert)
  397. pLength++;
  399. if (pSBTrack->cmdSB == SB_PAGEUP)
  400. pLength[2] = pSBTrack->pSBInfo->pxThumbTop;
  401. else
  402. pLength[0] = pSBTrack->pSBInfo->pxThumbBottom;
  403. }
  405. BOOL fHit = PtInRect(&pSBTrack->rcTrack, point);
  407. BOOL fHitChanged = fHit != (BOOL)pSBTrack->fHitOld;
  409. if (fHitChanged)
  410. {
  411. pSBTrack->fHitOld = fHit;
  412. RedrawScrollBar(pSBTrack->pSBInfo);
  413. }
  415. int cmsTimer = GetDoubleClickTime() / 10;
  417. switch (message)
  418. {
  419. case WM_LBUTTONUP:
  420. EndScroll(FALSE);
  421. break;
  423. case WM_LBUTTONDOWN:
  424. pSBTrack->hTimerSB = 0;
  425. cmsTimer = GetDoubleClickTime() * 4 / 5;
  427. /*
  428. *** FALL THRU **
  429. */
  431. case WM_MOUSEMOVE:
  432. if (fHit && fHitChanged)
  433. {
  434. pSBTrack->hTimerSB = SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
  436. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
  437. pSBTrack->cmdSB, 0, pSBTrack->fTrackVert);
  438. }
  439. }
  440. }
  443. void CXTPSkinObjectFrame::TrackInit(CPoint point, XTP_SKINSCROLLBARPOSINFO* pSBInfo, BOOL bDirect)
  444. {
  446. int px = (pSBInfo->fVert ? point.y : point.x);
  448. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = new XTP_SKINSCROLLBARTRACKINFO;
  449. memset(pSBTrack, 0, sizeof(XTP_SKINSCROLLBARTRACKINFO));
  451. pSBTrack->fTrackVert = pSBInfo->fVert;
  453. if (pSBInfo->nBar == SB_CTL)
  454. {
  455. pSBTrack->hWndSB = m_hWnd;
  456. pSBTrack->hWndSBNotify = ::GetParent(m_hWnd);
  457. pSBTrack->fNonClient = FALSE;
  458. }
  459. else
  460. {
  461. pSBTrack->hWndSB = NULL;
  462. pSBTrack->hWndSBNotify = m_hWnd;
  463. pSBTrack->fNonClient = TRUE;
  464. }
  466. pSBTrack->cmdSB = (UINT)-1;
  467. pSBTrack->nBar = pSBInfo->nBar;
  468. pSBTrack->bTrackThumb = FALSE;
  469. pSBTrack->pSBInfo = pSBInfo;
  471. m_pSBTrack = pSBTrack;
  474. RECT rcSB;
  475. LPINT pwX = (LPINT)&rcSB;
  476. LPINT pwY = pwX + 1;
  477. if (!pSBInfo->fVert)
  478. pwX = pwY--;
  480. *(pwX + 0) = pSBInfo->pxLeft;
  481. *(pwY + 0) = pSBInfo->pxTop;
  482. *(pwX + 2) = pSBInfo->pxRight;
  483. *(pwY + 2) = pSBInfo->pxBottom;
  486. if (px < pSBInfo->pxUpArrow)
  487. {
  488. pSBInfo->ht = XTP_HTSCROLLUP;
  489. pSBTrack->cmdSB = SB_LINEUP;
  490. *(pwY + 2) = pSBInfo->pxUpArrow;
  492. }
  493. else if (px >= pSBInfo->pxDownArrow)
  494. {
  495. pSBInfo->ht = XTP_HTSCROLLDOWN;
  496. pSBTrack->cmdSB = SB_LINEDOWN;
  497. *(pwY + 0) = pSBInfo->pxDownArrow;
  498. }
  499. else if (px < pSBInfo->pxThumbTop)
  500. {
  501. pSBInfo->ht = XTP_HTSCROLLUPPAGE;
  502. pSBTrack->cmdSB = SB_PAGEUP;
  503. *(pwY + 0) = pSBInfo->pxUpArrow;
  504. *(pwY + 2) = pSBInfo->pxThumbTop;
  505. }
  506. else if (px < pSBInfo->pxThumbBottom)
  507. {
  508. pSBInfo->ht = XTP_HTSCROLLTHUMB;
  509. DoThumbPos:
  511. if (pSBInfo->pxDownArrow - pSBInfo->pxUpArrow <= pSBInfo->cpxThumb)
  512. {
  513. delete m_pSBTrack;
  514. m_pSBTrack = NULL;
  515. return;
  516. }
  518. pSBTrack->cmdSB = SB_THUMBPOSITION;
  519. XTPSkinCalcTrackDragRect(pSBTrack);
  521. pSBTrack->pxOld = pSBInfo->pxStart = pSBInfo->pxThumbTop;
  522. pSBTrack->posNew = pSBTrack->posOld = pSBInfo->pos;
  523. pSBTrack->dpxThumb = pSBInfo->pxStart - px;
  525. pSBTrack->bTrackThumb = TRUE;
  527. SetCapture();
  529. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
  530. SB_THUMBTRACK, pSBTrack->posOld, pSBTrack->fTrackVert);
  532. }
  533. else if (px < pSBInfo->pxDownArrow)
  534. {
  535. pSBInfo->ht = XTP_HTSCROLLDOWNPAGE;
  536. pSBTrack->cmdSB = SB_PAGEDOWN;
  537. *(pwY + 0) = pSBInfo->pxThumbBottom;
  538. *(pwY + 2) = pSBInfo->pxDownArrow;
  539. }
  541. if ((bDirect && pSBTrack->cmdSB != SB_LINEUP && pSBTrack->cmdSB != SB_LINEDOWN))
  542. {
  543. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  544. {
  545. goto DoThumbPos;
  546. }
  547. pSBTrack->dpxThumb = -(pSBInfo->cpxThumb / 2);
  548. }
  550. SetCapture();
  552. if (pSBTrack->cmdSB != SB_THUMBPOSITION)
  553. {
  554. CopyRect(&pSBTrack->rcTrack, &rcSB);
  555. }
  557. if (!pSBTrack->bTrackThumb)
  558. {
  559. TrackBox(WM_LBUTTONDOWN, point);
  560. }
  561. else
  562. {
  563. TrackThumb(WM_LBUTTONDOWN, point);
  565. }
  567. while (::GetCapture() == m_hWnd)
  568. {
  569. while (::GetCapture() == m_hWnd)
  570. {
  571. MSG msg;
  573. if (!::GetMessage(&msg, NULL, 0, 0))
  574. {
  575. AfxPostQuitMessage((int)msg.wParam);
  576. break;
  577. }
  579. UINT cmd = msg.message;
  581. if (cmd == WM_TIMER && msg.wParam == IDSYS_SCROLL)
  582. {
  583. ContScroll();
  584. }
  585. else if (cmd >= WM_MOUSEFIRST && cmd <= WM_MOUSELAST)
  586. {
  587. CPoint ptScreen = msg.pt;
  589. if (pSBTrack->fNonClient)
  590. ScreenToFrame(&ptScreen);
  591. else
  592. ScreenToClient(&ptScreen);
  594. if (!pSBTrack->bTrackThumb)
  595. {
  596. TrackBox(cmd, ptScreen);
  597. }
  598. else
  599. {
  600. TrackThumb(cmd, ptScreen);
  601. }
  602. }
  603. else
  604. {
  605. TranslateMessage(&msg);
  606. DispatchMessage(&msg);
  607. }
  608. }
  609. }
  611. if (pSBTrack->hTimerSB != 0)
  612. {
  613. KillTimer(pSBTrack->hTimerSB);
  614. }
  616. pSBInfo->ht = 0;
  618. delete m_pSBTrack;
  619. m_pSBTrack = NULL;
  621. RedrawScrollBar(pSBInfo);
  622. }
  625. void CXTPSkinObjectFrame::ContScroll()
  626. {
  627. XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
  628. ASSERT(pSBTrack);
  630. if (pSBTrack == NULL)
  631. return;
  633. CPoint pt;
  634. GetCursorPos(&pt);
  636. if (pSBTrack->fNonClient)
  637. ScreenToFrame(&pt);
  638. else
  639. ScreenToClient(&pt);
  641. TrackBox(WM_NULL, pt);
  643. if (pSBTrack->fHitOld)
  644. {
  645. pSBTrack->hTimerSB = SetTimer( IDSYS_SCROLL, GetDoubleClickTime() / 10, NULL);
  647. DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
  648. pSBTrack->cmdSB, 0, pSBTrack->fTrackVert);
  649. }
  650. }
  654. void CXTPSkinObjectFrame::DrawScrollBar(CDC* pDC, XTP_SKINSCROLLBARPOSINFO* pSBInfo)
  655. {
  656. GetSkinManager()->GetSchema()->DrawThemeScrollBar(pDC, this, pSBInfo);
  657. }
  660. //////////////////////////////////////////////////////////////////////////
  661. // CXTPSkinObjectScrollBar
  662. IMPLEMENT_DYNCREATE(CXTPSkinObjectScrollBar, CXTPSkinObjectFrame)
  664. CXTPSkinObjectScrollBar::CXTPSkinObjectScrollBar()
  665. {
  666. ZeroMemory(&m_spiCtl, sizeof(XTP_SKINSCROLLBARPOSINFO));
  668. m_strClassName = _T("SCROLLBAR");
  669. }
  671. CXTPSkinObjectScrollBar::~CXTPSkinObjectScrollBar()
  672. {
  674. }
  676. BEGIN_MESSAGE_MAP(CXTPSkinObjectScrollBar, CXTPSkinObjectFrame)
  677. //{{AFX_MSG_MAP(CXTPSkinObjectScrollBar)
  678. ON_WM_CREATE()
  679. ON_WM_PAINT()
  680. ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
  681. ON_WM_ENABLE()
  682. ON_WM_MOUSEMOVE()
  683. ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
  684. ON_WM_LBUTTONDOWN()
  685. ON_WM_LBUTTONDBLCLK()
  686. ON_MESSAGE(SBM_SETSCROLLINFO, OnSetScrollInfo)
  687. ON_MESSAGE(SBM_GETSCROLLINFO, OnGetScrollInfo)
  688. ON_MESSAGE(SBM_SETPOS, OnSetScrollPos)
  689. ON_WM_SETFOCUS()
  690. //}}AFX_MSG_MAP
  691. END_MESSAGE_MAP()
  694. /////////////////////////////////////////////////////////////////////////////
  695. // CXTPSkinObjectScrollBar message handlers
  697. int CXTPSkinObjectScrollBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
  698. {
  699. if (CXTPSkinObjectFrame::OnCreate(lpCreateStruct) == -1)
  700. return -1;
  702. Invalidate(FALSE);
  704. return 0;
  705. }
  707. LRESULT CXTPSkinObjectScrollBar::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
  708. {
  709. CDC* pDC = CDC::FromHandle((HDC)wParam);
  710. if (pDC) OnDraw(pDC);
  711. return 1;
  712. }
  714. void CXTPSkinObjectScrollBar::OnPaint()
  715. {
  716. CXTPSkinObjectPaintDC dc(this); // device context for painting
  717. OnDraw(&dc);
  718. }
  720. void CXTPSkinObjectScrollBar::OnDraw(CDC* pDC)
  721. {
  722. CRect rc;
  723. GetClientRect(&rc);
  725. BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
  727. CXTPBufferDC dcMem(*pDC, rc);
  729. if (!fSize)
  730. {
  731. m_spiCtl.fVert = GetStyle() & SBS_VERT;
  732. m_spiCtl.fVisible = TRUE;
  733. m_spiCtl.nBar = SB_CTL;
  735. if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
  736. SetupScrollInfo(&m_spiCtl);
  738. DrawScrollBar(&dcMem, &m_spiCtl);
  740. }
  741. else
  742. {
  743. CXTPSkinManagerClass* pClassScrollBar = GetSkinManager()->GetSkinClass(_T("SCROLLBAR"));
  744. FillBackground(&dcMem, rc);
  746. if (GetStyle() & SBS_SIZEGRIP)
  747. {
  748. pClassScrollBar->DrawThemeBackground(&dcMem, SBP_SIZEBOX, SZB_RIGHTALIGN, rc);
  749. }
  750. }
  752. }
  754. void CXTPSkinObjectScrollBar::OnEnable(BOOL bEnable)
  755. {
  756. CXTPSkinObjectFrame::OnEnable(bEnable);
  757. Invalidate(FALSE);
  758. }
  760. void CXTPSkinObjectScrollBar::OnMouseLeave()
  761. {
  762. OnMouseMove(0, CPoint(-1, -1));
  763. }
  765. void CXTPSkinObjectScrollBar::OnMouseMove(UINT /*nFlags*/, CPoint point)
  766. {
  767. BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
  769. if (fSize)
  770. return;
  772. int ht = HitTestScrollBar(&m_spiCtl, point);
  774. if (ht != m_spiCtl.ht)
  775. {
  776. m_spiCtl.ht = ht;
  777. Invalidate(FALSE);
  779. if (m_spiCtl.ht != HTNOWHERE)
  780. {
  781. TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, HOVER_DEFAULT};
  782. _TrackMouseEvent(&tme);
  783. }
  784. }
  785. }
  788. void CXTPSkinObjectScrollBar::OnLButtonDown(UINT nFlags, CPoint point)
  789. {
  790. BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
  792. if (fSize)
  793. {
  794. CXTPSkinObjectFrame::OnLButtonDown(nFlags, point);
  795. return;
  796. }
  798. TrackInit(point, &m_spiCtl, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
  800. }
  802. void CXTPSkinObjectScrollBar::OnLButtonDblClk(UINT nFlags, CPoint point)
  803. {
  804. BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
  805. if (fSize)
  806. {
  807. CXTPSkinObjectFrame::OnLButtonDblClk(nFlags, point);
  808. return;
  809. }
  811. OnLButtonDown(nFlags, point);
  812. }
  814. LRESULT CXTPSkinObjectScrollBar::OnSetScrollInfo(WPARAM wParam, LPARAM lParam)
  815. {
  816. LRESULT lResult = DefWindowProc(SBM_SETSCROLLINFO, FALSE, lParam);
  818. if (wParam && IsWindowVisible())
  819. {
  820. CClientDC dc(this);
  821. OnDraw(&dc);
  822. }
  824. return lResult;
  825. }
  827. LRESULT CXTPSkinObjectScrollBar::OnGetScrollInfo(WPARAM wParam, LPARAM lParam)
  828. {
  829. LRESULT bResult = DefWindowProc(SBM_GETSCROLLINFO, wParam, lParam);
  831. LPSCROLLINFO lpsi = (LPSCROLLINFO)lParam;
  833. if (lpsi && (lpsi->fMask & SIF_TRACKPOS) && m_pSBTrack)
  834. {
  835. lpsi->nTrackPos = m_pSBTrack->posNew;
  836. }
  838. return bResult;
  839. }
  841. LRESULT CXTPSkinObjectScrollBar::OnSetScrollPos(WPARAM wParam, LPARAM lParam)
  842. {
  843. LRESULT lResult = DefWindowProc(SBM_SETPOS, wParam, FALSE);
  845. if (lParam && IsWindowVisible())
  846. {
  847. CClientDC dc(this);
  848. OnDraw(&dc);
  849. }
  851. return lResult;
  852. }
  854. void CXTPSkinObjectScrollBar::OnSetFocus(CWnd* pOldWnd)
  855. {
  856. pOldWnd;
  857. }