You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

863 lines
18 KiB
C++

// XTPSkinObjectScrollBar.cpp: implementation of the CXTPSkinObjectScrollBar class.
//
// This file is a part of the XTREME SKINFRAMEWORK MFC class library.
// (c)1998-2012 Codejock Software, All Rights Reserved.
//
// THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
// RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
// CONSENT OF CODEJOCK SOFTWARE.
//
// THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
// IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
// YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
// SINGLE COMPUTER.
//
// CONTACT INFORMATION:
// support@codejock.com
// http://www.codejock.com
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Common/Uxtheme.h"
#include "Common/Tmschema.h"
#include "Common/XTPDrawHelpers.h"
#include "XTPSkinObject.h"
#include "XTPSkinObjectFrame.h"
#include "XTPSkinManager.h"
#include "XTPSkinManagerSchema.h"
#include "XTPSkinObjectScrollBar.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#define IDSYS_SCROLL 0xFA45
CRect CXTPSkinObjectFrame::GetScrollBarRect(int nBar)
{
CRect rcClient;
GetClientRect(&rcClient);
if (nBar == SB_CTL)
{
return rcClient;
}
CRect rc;
GetWindowRect(rc);
ScreenToClient(rc);
if (nBar == SB_VERT)
{
rc.bottom = rcClient.bottom - rc.top;
rc.top = rcClient.top - rc.top;
if (GetExStyle() & WS_EX_LEFTSCROLLBAR)
{
rc.left = rcClient.left - rc.left - GetMetrics()->m_cxVScroll;
}
else
{
rc.left = rcClient.right - rc.left;
}
rc.right = rc.left + GetMetrics()->m_cxVScroll;
}
if (nBar == SB_HORZ)
{
rc.right = rcClient.right - rc.left;
rc.left = rcClient.left - rc.left;
rc.top = rcClient.bottom - rc.top;
rc.bottom = rc.top + GetMetrics()->m_cyHScroll;
}
return rc;
}
void CXTPSkinObjectFrame::SetupScrollInfo(XTP_SKINSCROLLBARPOSINFO* pSBInfo)
{
CRect rc = GetScrollBarRect(pSBInfo->nBar);
SCROLLINFO si;
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
::GetScrollInfo(m_hWnd, pSBInfo->nBar, &si);
CalcScrollBarInfo(&rc, pSBInfo, &si);
}
void CXTPSkinObjectFrame::RedrawScrollBar(int nBar)
{
ASSERT(nBar == SB_VERT || nBar == SB_HORZ);
RedrawScrollBar(&m_spi[nBar]);
}
void CXTPSkinObjectFrame::RedrawScrollBar(XTP_SKINSCROLLBARPOSINFO* pSBInfo)
{
if (!pSBInfo->fVisible )
return;
if (!IsWindow(m_hWnd))
return;
CDC* pDC = pSBInfo->nBar == SB_CTL ? (CDC*)new CClientDC(this) : (CDC*)new CWindowDC(this);
if (pDC)
{
CRect rc = GetScrollBarRect(pSBInfo->nBar);
CXTPBufferDCEx dcMem(*pDC, rc);
if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
SetupScrollInfo(pSBInfo);
DrawScrollBar(&dcMem, pSBInfo);
}
delete pDC;
}
int CXTPSkinObjectFrame::HitTestScrollBar(XTP_SKINSCROLLBARPOSINFO* pSBInfo, POINT pt)
{
if (!pSBInfo->fVisible)
return HTNOWHERE;
int px = pSBInfo->fVert ? pt.y : pt.x;
if (!::PtInRect(&pSBInfo->rc, pt))
return HTNOWHERE;
if (px < pSBInfo->pxUpArrow)
return XTP_HTSCROLLUP;
if (px >= pSBInfo->pxDownArrow)
return XTP_HTSCROLLDOWN;
if (px < pSBInfo->pxThumbTop)
return XTP_HTSCROLLUPPAGE;
if (px < pSBInfo->pxThumbBottom)
return XTP_HTSCROLLTHUMB;
if (px < pSBInfo->pxDownArrow)
return XTP_HTSCROLLDOWNPAGE;
return HTERROR;
}
void CXTPSkinObjectFrame::CalcScrollBarInfo(LPRECT lprc, XTP_SKINSCROLLBARPOSINFO* pSBInfo, SCROLLINFO* pSI)
{
int cpx;
DWORD dwRange;
int denom;
BOOL fVert = pSBInfo->fVert;
pSBInfo->rc = *lprc;
if (fVert)
{
pSBInfo->pxTop = lprc->top;
pSBInfo->pxBottom = lprc->bottom;
pSBInfo->pxLeft = lprc->left;
pSBInfo->pxRight = lprc->right;
pSBInfo->cpxThumb = GetMetrics()->m_cyVScroll;
}
else
{
pSBInfo->pxTop = lprc->left;
pSBInfo->pxBottom = lprc->right;
pSBInfo->pxLeft = lprc->top;
pSBInfo->pxRight = lprc->bottom;
pSBInfo->cpxThumb = GetMetrics()->m_cxHScroll;
}
pSBInfo->pos = pSI->nPos;
pSBInfo->page = pSI->nPage;
pSBInfo->posMin = pSI->nMin;
pSBInfo->posMax = pSI->nMax;
dwRange = ((DWORD)(pSBInfo->posMax - pSBInfo->posMin)) + 1;
cpx = min((pSBInfo->pxBottom - pSBInfo->pxTop) / 2, pSBInfo->cpxThumb);
pSBInfo->pxUpArrow = pSBInfo->pxTop + cpx;
pSBInfo->pxDownArrow = pSBInfo->pxBottom - cpx;
if ((pSBInfo->page != 0) && (dwRange != 0))
{
int i = MulDiv(pSBInfo->pxDownArrow - pSBInfo->pxUpArrow,
pSBInfo->page, dwRange);
pSBInfo->cpxThumb = max(max(16, pSBInfo->cpxThumb / 2), i);
}
pSBInfo->pxMin = pSBInfo->pxTop + cpx;
pSBInfo->cpx = pSBInfo->pxBottom - cpx - pSBInfo->cpxThumb - pSBInfo->pxMin;
if (pSBInfo->cpx < 0) pSBInfo->cpx = 0;
denom = dwRange - (pSBInfo->page ? pSBInfo->page : 1);
if (denom)
pSBInfo->pxThumbTop = MulDiv(pSBInfo->pos - pSBInfo->posMin,
pSBInfo->cpx, denom) + pSBInfo->pxMin;
else
pSBInfo->pxThumbTop = pSBInfo->pxMin - 1;
pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
}
void XTPSkinCalcTrackDragRect(XTP_SKINSCROLLBARTRACKINFO* pSBTrack)
{
int cx;
int cy;
LPINT pwX, pwY;
pwX = pwY = (LPINT)&pSBTrack->rcTrack;
if (pSBTrack->fTrackVert)
{
cy = GetSystemMetrics(SM_CYVTHUMB);
pwY++;
}
else
{
cy = GetSystemMetrics(SM_CXHTHUMB);
pwX++;
}
cx = (pSBTrack->pSBInfo->pxRight - pSBTrack->pSBInfo->pxLeft) * 8;
cy *= 2;
*(pwX + 0) = pSBTrack->pSBInfo->pxLeft - cx;
*(pwY + 0) = pSBTrack->pSBInfo->pxTop - cy;
*(pwX + 2) = pSBTrack->pSBInfo->pxRight + cx;
*(pwY + 2) = pSBTrack->pSBInfo->pxBottom + cy;
}
void CXTPSkinObjectFrame::DoScroll(HWND hwnd, HWND hWndSBNotify, int cmd, int pos, BOOL fVert)
{
if (!hWndSBNotify)
return;
::SendMessage(hWndSBNotify, (UINT)(fVert ? WM_VSCROLL : WM_HSCROLL),
MAKELONG(cmd, pos), (LPARAM)hwnd);
}
void CXTPSkinObjectFrame::EndScroll(BOOL fCancel)
{
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
if (pSBTrack)
{
pSBTrack->cmdSB = 0;
ReleaseCapture();
if (pSBTrack->bTrackThumb)
{
if (fCancel)
{
pSBTrack->posOld = pSBTrack->pSBInfo->pos;
}
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
SB_THUMBPOSITION, pSBTrack->posOld, pSBTrack->fTrackVert);
RedrawScrollBar(pSBTrack->pSBInfo);
}
else
{
if (pSBTrack->hTimerSB != 0)
{
KillTimer(pSBTrack->hTimerSB);
pSBTrack->hTimerSB = 0;
}
}
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
SB_ENDSCROLL, 0, pSBTrack->fTrackVert);
}
pSBTrack->hWndSBNotify = NULL;
}
int SBPosFromPx(XTP_SKINSCROLLBARPOSINFO* pSBInfo, int px)
{
if (px < pSBInfo->pxMin)
{
return pSBInfo->posMin;
}
if (px >= pSBInfo->pxMin + pSBInfo->cpx)
{
return (pSBInfo->posMax - (pSBInfo->page ? pSBInfo->page - 1 : 0));
}
if (pSBInfo->cpx)
return (pSBInfo->posMin + MulDiv(pSBInfo->posMax - pSBInfo->posMin -
(pSBInfo->page ? pSBInfo->page - 1 : 0),
px - pSBInfo->pxMin, pSBInfo->cpx));
else
return (pSBInfo->posMin - 1);
}
void CXTPSkinObjectFrame::MoveThumb(int px)
{
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
if ((pSBTrack == NULL) || (px == pSBTrack->pxOld))
return;
XTP_SKINSCROLLBARPOSINFO* pSBInfo = m_pSBTrack->pSBInfo;
pxReCalc:
pSBTrack->posNew = SBPosFromPx(pSBInfo, px);
if (pSBTrack->posNew != pSBTrack->posOld)
{
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify, SB_THUMBTRACK, pSBTrack->posNew, pSBTrack->fTrackVert);
pSBTrack->posOld = pSBTrack->posNew;
if (px >= pSBInfo->pxMin + pSBInfo->cpx)
{
px = pSBInfo->pxMin + pSBInfo->cpx;
goto pxReCalc;
}
}
pSBInfo->pxThumbTop = px;
pSBInfo->pxThumbBottom = pSBInfo->pxThumbTop + pSBInfo->cpxThumb;
pSBTrack->pxOld = px;
RedrawScrollBar(pSBTrack->pSBInfo);
}
void CXTPSkinObjectFrame::TrackThumb(UINT message, CPoint pt)
{
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
if (!pSBTrack)
return;
XTP_SKINSCROLLBARPOSINFO* pSBInfo = pSBTrack->pSBInfo;
if (HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
return;
if (pSBInfo == NULL)
return;
int px;
if (!PtInRect(&pSBTrack->rcTrack, pt))
px = pSBInfo->pxStart;
else
{
px = (pSBTrack->fTrackVert ? pt.y : pt.x) + pSBTrack->dpxThumb;
if (px < pSBInfo->pxMin)
px = pSBInfo->pxMin;
else if (px >= pSBInfo->pxMin + pSBInfo->cpx)
px = pSBInfo->pxMin + pSBInfo->cpx;
}
MoveThumb(px);
pSBTrack->fHitOld = TRUE;
if (message == WM_LBUTTONUP || GetKeyState(VK_LBUTTON) >= 0)
{
EndScroll(FALSE);
}
}
void CXTPSkinObjectFrame::TrackBox(UINT message, CPoint point)
{
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
if (pSBTrack == NULL)
return;
if (message != WM_NULL && HIBYTE(message) != HIBYTE(WM_MOUSEFIRST))
return;
if ((pSBTrack->cmdSB == SB_PAGEUP || pSBTrack->cmdSB == SB_PAGEDOWN))
{
int* pLength = (int *)&pSBTrack->rcTrack;
if (pSBTrack->fTrackVert)
pLength++;
if (pSBTrack->cmdSB == SB_PAGEUP)
pLength[2] = pSBTrack->pSBInfo->pxThumbTop;
else
pLength[0] = pSBTrack->pSBInfo->pxThumbBottom;
}
BOOL fHit = PtInRect(&pSBTrack->rcTrack, point);
BOOL fHitChanged = fHit != (BOOL)pSBTrack->fHitOld;
if (fHitChanged)
{
pSBTrack->fHitOld = fHit;
RedrawScrollBar(pSBTrack->pSBInfo);
}
int cmsTimer = GetDoubleClickTime() / 10;
switch (message)
{
case WM_LBUTTONUP:
EndScroll(FALSE);
break;
case WM_LBUTTONDOWN:
pSBTrack->hTimerSB = 0;
cmsTimer = GetDoubleClickTime() * 4 / 5;
/*
*** FALL THRU **
*/
case WM_MOUSEMOVE:
if (fHit && fHitChanged)
{
pSBTrack->hTimerSB = SetTimer(IDSYS_SCROLL, cmsTimer, NULL);
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
pSBTrack->cmdSB, 0, pSBTrack->fTrackVert);
}
}
}
void CXTPSkinObjectFrame::TrackInit(CPoint point, XTP_SKINSCROLLBARPOSINFO* pSBInfo, BOOL bDirect)
{
int px = (pSBInfo->fVert ? point.y : point.x);
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = new XTP_SKINSCROLLBARTRACKINFO;
memset(pSBTrack, 0, sizeof(XTP_SKINSCROLLBARTRACKINFO));
pSBTrack->fTrackVert = pSBInfo->fVert;
if (pSBInfo->nBar == SB_CTL)
{
pSBTrack->hWndSB = m_hWnd;
pSBTrack->hWndSBNotify = ::GetParent(m_hWnd);
pSBTrack->fNonClient = FALSE;
}
else
{
pSBTrack->hWndSB = NULL;
pSBTrack->hWndSBNotify = m_hWnd;
pSBTrack->fNonClient = TRUE;
}
pSBTrack->cmdSB = (UINT)-1;
pSBTrack->nBar = pSBInfo->nBar;
pSBTrack->bTrackThumb = FALSE;
pSBTrack->pSBInfo = pSBInfo;
m_pSBTrack = pSBTrack;
RECT rcSB;
LPINT pwX = (LPINT)&rcSB;
LPINT pwY = pwX + 1;
if (!pSBInfo->fVert)
pwX = pwY--;
*(pwX + 0) = pSBInfo->pxLeft;
*(pwY + 0) = pSBInfo->pxTop;
*(pwX + 2) = pSBInfo->pxRight;
*(pwY + 2) = pSBInfo->pxBottom;
if (px < pSBInfo->pxUpArrow)
{
pSBInfo->ht = XTP_HTSCROLLUP;
pSBTrack->cmdSB = SB_LINEUP;
*(pwY + 2) = pSBInfo->pxUpArrow;
}
else if (px >= pSBInfo->pxDownArrow)
{
pSBInfo->ht = XTP_HTSCROLLDOWN;
pSBTrack->cmdSB = SB_LINEDOWN;
*(pwY + 0) = pSBInfo->pxDownArrow;
}
else if (px < pSBInfo->pxThumbTop)
{
pSBInfo->ht = XTP_HTSCROLLUPPAGE;
pSBTrack->cmdSB = SB_PAGEUP;
*(pwY + 0) = pSBInfo->pxUpArrow;
*(pwY + 2) = pSBInfo->pxThumbTop;
}
else if (px < pSBInfo->pxThumbBottom)
{
pSBInfo->ht = XTP_HTSCROLLTHUMB;
DoThumbPos:
if (pSBInfo->pxDownArrow - pSBInfo->pxUpArrow <= pSBInfo->cpxThumb)
{
delete m_pSBTrack;
m_pSBTrack = NULL;
return;
}
pSBTrack->cmdSB = SB_THUMBPOSITION;
XTPSkinCalcTrackDragRect(pSBTrack);
pSBTrack->pxOld = pSBInfo->pxStart = pSBInfo->pxThumbTop;
pSBTrack->posNew = pSBTrack->posOld = pSBInfo->pos;
pSBTrack->dpxThumb = pSBInfo->pxStart - px;
pSBTrack->bTrackThumb = TRUE;
SetCapture();
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
SB_THUMBTRACK, pSBTrack->posOld, pSBTrack->fTrackVert);
}
else if (px < pSBInfo->pxDownArrow)
{
pSBInfo->ht = XTP_HTSCROLLDOWNPAGE;
pSBTrack->cmdSB = SB_PAGEDOWN;
*(pwY + 0) = pSBInfo->pxThumbBottom;
*(pwY + 2) = pSBInfo->pxDownArrow;
}
if ((bDirect && pSBTrack->cmdSB != SB_LINEUP && pSBTrack->cmdSB != SB_LINEDOWN))
{
if (pSBTrack->cmdSB != SB_THUMBPOSITION)
{
goto DoThumbPos;
}
pSBTrack->dpxThumb = -(pSBInfo->cpxThumb / 2);
}
SetCapture();
if (pSBTrack->cmdSB != SB_THUMBPOSITION)
{
CopyRect(&pSBTrack->rcTrack, &rcSB);
}
if (!pSBTrack->bTrackThumb)
{
TrackBox(WM_LBUTTONDOWN, point);
}
else
{
TrackThumb(WM_LBUTTONDOWN, point);
}
while (::GetCapture() == m_hWnd && pSBTrack->hWndSBNotify != 0)
{
MSG msg;
if (!::GetMessage(&msg, NULL, 0, 0))
{
AfxPostQuitMessage((int)msg.wParam);
break;
}
UINT cmd = msg.message;
if (cmd == WM_TIMER && msg.wParam == IDSYS_SCROLL)
{
ContScroll();
}
else if (cmd >= WM_MOUSEFIRST && cmd <= WM_MOUSELAST)
{
CPoint ptScreen = msg.pt;
if (pSBTrack->fNonClient)
ScreenToFrame(&ptScreen);
else
ScreenToClient(&ptScreen);
if (!pSBTrack->bTrackThumb)
{
TrackBox(cmd, ptScreen);
}
else
{
TrackThumb(cmd, ptScreen);
}
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if (pSBTrack->hTimerSB != 0)
{
KillTimer(pSBTrack->hTimerSB);
}
pSBInfo->ht = 0;
delete m_pSBTrack;
m_pSBTrack = NULL;
RedrawScrollBar(pSBInfo);
}
void CXTPSkinObjectFrame::ContScroll()
{
XTP_SKINSCROLLBARTRACKINFO* pSBTrack = m_pSBTrack;
ASSERT(pSBTrack);
if (pSBTrack == NULL)
return;
CPoint pt;
GetCursorPos(&pt);
if (pSBTrack->fNonClient)
ScreenToFrame(&pt);
else
ScreenToClient(&pt);
TrackBox(WM_NULL, pt);
if (pSBTrack->fHitOld)
{
pSBTrack->hTimerSB = SetTimer( IDSYS_SCROLL, GetDoubleClickTime() / 10, NULL);
DoScroll(pSBTrack->hWndSB, pSBTrack->hWndSBNotify,
pSBTrack->cmdSB, 0, pSBTrack->fTrackVert);
}
}
void CXTPSkinObjectFrame::DrawScrollBar(CDC* pDC, XTP_SKINSCROLLBARPOSINFO* pSBInfo)
{
GetSchema()->DrawThemeScrollBar(pDC, this, pSBInfo);
}
//////////////////////////////////////////////////////////////////////////
// CXTPSkinObjectScrollBar
IMPLEMENT_DYNCREATE(CXTPSkinObjectScrollBar, CXTPSkinObjectFrame)
CXTPSkinObjectScrollBar::CXTPSkinObjectScrollBar()
{
ZeroMemory(&m_spiCtl, sizeof(XTP_SKINSCROLLBARPOSINFO));
m_strClassName = _T("SCROLLBAR");
}
CXTPSkinObjectScrollBar::~CXTPSkinObjectScrollBar()
{
}
BEGIN_MESSAGE_MAP(CXTPSkinObjectScrollBar, CXTPSkinObjectFrame)
//{{AFX_MSG_MAP(CXTPSkinObjectScrollBar)
ON_WM_CREATE()
ON_WM_PAINT()
ON_MESSAGE(WM_PRINTCLIENT, OnPrintClient)
ON_WM_ENABLE()
ON_WM_MOUSEMOVE()
ON_MESSAGE_VOID(WM_MOUSELEAVE, OnMouseLeave)
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONDBLCLK()
ON_MESSAGE(SBM_SETSCROLLINFO, OnSetScrollInfo)
ON_MESSAGE(SBM_GETSCROLLINFO, OnGetScrollInfo)
ON_MESSAGE(SBM_SETPOS, OnSetScrollPos)
ON_WM_SETFOCUS()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CXTPSkinObjectScrollBar message handlers
int CXTPSkinObjectScrollBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CXTPSkinObjectFrame::OnCreate(lpCreateStruct) == -1)
return -1;
Invalidate(FALSE);
return 0;
}
LRESULT CXTPSkinObjectScrollBar::OnPrintClient(WPARAM wParam, LPARAM /*lParam*/)
{
CDC* pDC = CDC::FromHandle((HDC)wParam);
if (pDC) OnDraw(pDC);
return 1;
}
void CXTPSkinObjectScrollBar::OnPaint()
{
CXTPSkinObjectPaintDC dc(this); // device context for painting
OnDraw(&dc);
}
void CXTPSkinObjectScrollBar::OnDraw(CDC* pDC)
{
CRect rc;
GetClientRect(&rc);
BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
CXTPBufferDC dcMem(*pDC, rc);
if (!fSize)
{
m_spiCtl.fVert = GetStyle() & SBS_VERT;
m_spiCtl.fVisible = TRUE;
m_spiCtl.nBar = SB_CTL;
if (!m_pSBTrack || !m_pSBTrack->bTrackThumb)
SetupScrollInfo(&m_spiCtl);
DrawScrollBar(&dcMem, &m_spiCtl);
}
else
{
CXTPSkinManagerClass* pClassScrollBar = GetSkinManager()->GetSkinClass(this, _T("SCROLLBAR"));
FillBackground(&dcMem, rc);
if (GetStyle() & SBS_SIZEGRIP)
{
pClassScrollBar->DrawThemeBackground(&dcMem, SBP_SIZEBOX, SZB_RIGHTALIGN, rc);
}
}
}
void CXTPSkinObjectScrollBar::OnEnable(BOOL bEnable)
{
CXTPSkinObjectFrame::OnEnable(bEnable);
Invalidate(FALSE);
}
void CXTPSkinObjectScrollBar::OnMouseLeave()
{
OnMouseMove(0, CPoint(-1, -1));
}
void CXTPSkinObjectScrollBar::OnMouseMove(UINT /*nFlags*/, CPoint point)
{
BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
if (fSize)
return;
int ht = HitTestScrollBar(&m_spiCtl, point);
if (ht != m_spiCtl.ht)
{
m_spiCtl.ht = ht;
Invalidate(FALSE);
if (m_spiCtl.ht != HTNOWHERE)
{
TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT), TME_LEAVE, m_hWnd, HOVER_DEFAULT};
_TrackMouseEvent(&tme);
}
}
}
void CXTPSkinObjectScrollBar::OnLButtonDown(UINT nFlags, CPoint point)
{
BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
if (fSize)
{
CXTPSkinObjectFrame::OnLButtonDown(nFlags, point);
return;
}
TrackInit(point, &m_spiCtl, (GetKeyState(VK_SHIFT) < 0) ? TRUE : FALSE);
}
void CXTPSkinObjectScrollBar::OnLButtonDblClk(UINT nFlags, CPoint point)
{
BOOL fSize = ((GetStyle() & (SBS_SIZEBOX | SBS_SIZEGRIP)) != 0);
if (fSize)
{
CXTPSkinObjectFrame::OnLButtonDblClk(nFlags, point);
return;
}
OnLButtonDown(nFlags, point);
}
LRESULT CXTPSkinObjectScrollBar::OnSetScrollInfo(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = DefWindowProc(SBM_SETSCROLLINFO, FALSE, lParam);
if (wParam && IsWindowVisible())
{
CClientDC dc(this);
OnDraw(&dc);
}
return lResult;
}
LRESULT CXTPSkinObjectScrollBar::OnGetScrollInfo(WPARAM wParam, LPARAM lParam)
{
LRESULT bResult = DefWindowProc(SBM_GETSCROLLINFO, wParam, lParam);
LPSCROLLINFO lpsi = (LPSCROLLINFO)lParam;
if (lpsi && (lpsi->fMask & SIF_TRACKPOS) && m_pSBTrack)
{
lpsi->nTrackPos = m_pSBTrack->posNew;
}
return bResult;
}
LRESULT CXTPSkinObjectScrollBar::OnSetScrollPos(WPARAM wParam, LPARAM lParam)
{
LRESULT lResult = DefWindowProc(SBM_SETPOS, wParam, FALSE);
if (lParam && IsWindowVisible())
{
CClientDC dc(this);
OnDraw(&dc);
}
return lResult;
}
void CXTPSkinObjectScrollBar::OnSetFocus(CWnd* pOldWnd)
{
pOldWnd;
}