AccompanyCube/CDSkinScrollBarUnit.cpp

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include <Vcl.Imaging.pngimage.hpp>
#include "CDSkinScrollBarUnit.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

//add by tj 2013/11/21
#define PIXEL_EXTERNAL_FRAME 1
#define PIXEL_EX2INTERNAL    1
#define PIXEL_INTERNAL_FARME 1
#define PIXEL_INTERNAL_BOUND 1
#define PIXEL_INTERNAL_LINE  6 //add by tj 2013/12/10


static  const COLORREF
		RGB_EXTERNAL_FRAME              =  RGB(29,31,35),
		RGB_EXTERNAL_NOR                =  RGB(60,66,72),
		RGB_EXTERNAL_HIG        	    =  RGB(74,80,88),
		RGB_INTERNAL_NOR                =  RGB(39,42,47), //272a2f
		RGB_INTERNAL_HIG                =  RGB(74,80,88), //4a5058
		RGB_INTERNAL_PUSH               =  RGB(50,54,60), //32363c
		RGB_INTERNAL_LINE_NOR           =  RGB(25,27,30), //191b1e
		RGB_INTERNAL_LINE_HIG           =  RGB(58,63,69), //3a3f45
		RGB_INTERNAL_LINE_PUSH          =  RGB(38,41,45), //26292d
		RGB_INTERNAL_LINE_NOR_TRANS[6]  ={ RGB(44,47,53), //2c2f35
										   RGB(47,51,57),
										   RGB(52,55,62),
										   RGB(56,59,67),
										   RGB(57,59,69),
										   RGB(59,61,71)
										 },
		RGB_INTERNAL_LINE_HIG_TRANS[6]  ={ RGB(79,86,94),//4f565e
										   RGB(83,90,99),
										   RGB(87,94,104),
										   RGB(91,99,109),
										   RGB(92,100,111),
										   RGB(94,104,115),
										 },
		RGB_INTERNAL_LINE_PUSH_TRANS[6] ={ RGB(55,59,66), //373b42
										   RGB(60,65,72),
										   RGB(64,69,77),
										   RGB(69,75,83),
										   RGB(70,77,86),
										   RGB(72,79,88)
										 },
		RGB_INTERNAL_FRAME_NOR          =  RGB(34,36,41),
		RGB_INTERNAL_ROUND_BKG_N_NOR    =  RGB(41,44,49),
		RGB_INTERNAL_ROUND_BKG_N_HIG    =  RGB(51,55,61),
		RGB_INTERNAL_ROUND_BKG_H_NOR    =  RGB(43,46,52),
		RGB_INTERNAL_ROUND_BKG_H_HIG    =  RGB(56,61,67);
//---------------------------------------------------------------------------
static TBitmap *u_pPicLineUp = NULL,
		*u_pPicLineDown = NULL;

static int u_nPicRef = 0;

static void InitialPictures()
{
	if( u_nPicRef==0 ){
		u_pPicLineUp = new TBitmap();
		u_pPicLineUp->LoadFromResourceName(int(HInstance), L"line_up");
		u_pPicLineDown = new TBitmap();
		u_pPicLineDown->LoadFromResourceName(int(HInstance), L"line_Down");
	}

	u_nPicRef++;
}

static void ReleasePictures()
{
	u_nPicRef--;

	if( u_nPicRef==0 ){
		delete u_pPicLineUp;
		delete u_pPicLineDown;
	}
}
//---------------------------------------------------------------------------
__fastcall CDTSkinScrollBar::CDTSkinScrollBar(TComponent* AOwner)
 : TScrollBar(AOwner)
{
	Visible = false;
	ParentCtl3D = false;  //add by tj 2013/11/14
	InitialPictures();

	Kind = sbVertical;
	Width = u_pPicLineUp->Height;//add by tj 2013/11/19
	DoubleBuffered = TRUE;

	m_nThumbHeight = 0;
	m_nThumbTop = Width;
	m_nPreThumbTop = Width;
//	m_nTileHeight = 18; //add by tj 2013/11/14

	m_nTrackPos = m_nMax = m_nMin = m_nPos = m_nPage = 0;
	m_iClicked = -1;
	m_iHitPrev = -1;

	m_bAction = m_bPause = m_bNotify = m_bDrag = m_bTrace = false;

	m_pCanvas = new TControlCanvas();
	((TControlCanvas*)m_pCanvas)->Control = this;
	Ctl3D = false;

	//鼠标长期按下的计时器
	m_pTimer = new TTimer(NULL);
	m_pTimer->Enabled = false;
	m_pTimer->OnTimer = TimerProc;

	OnMouseLeave = CMMouseLeave;
}

//---------------------------------------------------------------------------
__fastcall CDTSkinScrollBar::~CDTSkinScrollBar()
{
	if( m_pCanvas ){
		delete m_pCanvas;
		m_pCanvas = NULL;
	}

	if( m_pTimer ){
		delete m_pTimer;
		m_pTimer = NULL;
	}

	ReleasePictures();
}

//---------------------------------------------------------------------------
int CDTSkinScrollBar::HitTest( int X, int Y )
{
  if( Y<0 )
	return -1;
  else if( Y<Width )
	return SB_LINEUP;
  else if( Y<m_nThumbTop )
	return SB_PAGEUP;
  else if( Y<m_nThumbTop+m_nThumbHeight )
	return SB_THUMBTRACK;
  else if( Y<Height-Width )
	return SB_PAGEDOWN;
  else if( Y<Height )
	return SB_LINEDOWN;
  else
	return -1;
}

//---------------------------------------------------------------------------
void CDTSkinScrollBar::CalcThumbHeight()
{
	int hInter = Height - 2 * Width;
	int hThumb = m_nPage * hInter / (m_nMax-m_nMin+1);
	if( hThumb<THUMB_MINSIZE )
		hThumb = THUMB_MINSIZE;
	if( hInter<THUMB_MINSIZE )
		hThumb = 0;
	if( m_nMax-m_nMin-m_nPage+1 == 0 )
		hThumb = 0;

	m_nThumbHeight = hThumb;
}

//---------------------------------------------------------------------------
void CDTSkinScrollBar::CalcThumbTop()
{
	int nPos;

	if( m_bDrag )
		nPos = m_nTrackPos;
	else
		nPos = m_nPos;

	if( nPos==0 )
		m_nThumbTop = Width;
	else{
		int nTrackLen = Height - 2*Width - m_nThumbHeight;
		int nLenInSi = m_nMax-m_nMin-m_nPage+1;

		if( nLenInSi==0 )
			m_nThumbTop = nTrackLen / 2 + Width;
		else
			m_nThumbTop = (nTrackLen * nPos / nLenInSi) + Width;
	}
}

//---------------------------------------------------------------------------
void CDTSkinScrollBar::DrawArrow( int iDirection, int iState )
{
	int x, y;
	TRect tmpRect;
	TBitmap * pPic = NULL;

	if( iDirection==SB_LINEUP ){
		pPic = u_pPicLineUp;
		x = - iState * Width;
		y = 0;
	}
	else {
		pPic = u_pPicLineDown;
		x = - iState * Width;
		y = Height - Width;
	}

	if( Width==pPic->Width/3 )
		m_pCanvas->Draw( x, y, pPic );
	else{
		tmpRect.Left = x;
		tmpRect.Right = tmpRect.Left + Width*3;
		tmpRect.Top = y;
		tmpRect.Bottom = tmpRect.top + Width;
		m_pCanvas->StretchDraw( tmpRect, pPic);
	}
}

//---------------------------------------------------------------------------
void CDTSkinScrollBar::DrawThumb( int iState, bool bEraseBk, int iPageUD )
{
	//add by tj 2013/11/14
	TRect rectDraw;

	//===========================
	//绘制 轨道

	rectDraw.Left   = PIXEL_EXTERNAL_FRAME;
	rectDraw.Right  = Width -rectDraw.Left;

	//绘制 上轨道
	if(iPageUD == SB_PAGEUP || iState== STATE_PUSH ){
		m_pCanvas->Brush->Color = RGB_EXTERNAL_HIG;
		m_pCanvas->Pen->Color   = RGB_EXTERNAL_HIG;
	}else {
		m_pCanvas->Brush->Color = RGB_EXTERNAL_NOR;
		m_pCanvas->Pen->Color   = RGB_EXTERNAL_NOR;
	}

	if( bEraseBk )                        //重绘轨道
		rectDraw.Top = Width;
	else if( m_nPreThumbTop<m_nThumbTop ) //滚动条往下滑动
		rectDraw.Top = m_nPreThumbTop;
	else                                  //滚动条往上滑动
		rectDraw.Top = Width;

	if( rectDraw.Top<m_nThumbTop ){
		rectDraw.Bottom = m_nThumbTop;

		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);
	}

	//绘制 下轨道
	if(iPageUD == SB_PAGEDOWN || iState== STATE_PUSH){
		m_pCanvas->Brush->Color = RGB_EXTERNAL_HIG;
		m_pCanvas->Pen->Color   = RGB_EXTERNAL_HIG;
	}else {
		m_pCanvas->Brush->Color = RGB_EXTERNAL_NOR;
		m_pCanvas->Pen->Color   = RGB_EXTERNAL_NOR;
	}
	rectDraw.Top = m_nThumbTop + m_nThumbHeight;
	if( bEraseBk )
		rectDraw.bottom = Height - Width;
	else if( m_nPreThumbTop>m_nThumbTop ){  //如果向上，则为当前滑动块底部的值
		rectDraw.bottom = m_nThumbHeight+m_nPreThumbTop;
		if( rectDraw.bottom>Height-Width )
			rectDraw.bottom = Height-Width;
	}else
		rectDraw.Bottom = Height - Width;   //如果向下，则为当前滑动块底部的值

	if( rectDraw.Height()>0 ){
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);
	}

	//===========================
	//绘制 滑块
	if( m_nThumbHeight>0 ){
		//===========================
		//绘制 滑块左右区域
		if(iState==STATE_NORMAL || iState == STATE_HIGHLIGHT){
			m_pCanvas->Brush->Color = RGB_EXTERNAL_NOR;
			m_pCanvas->Pen->Color   = RGB_EXTERNAL_NOR;
		}else if(iState== STATE_PUSH ){
			m_pCanvas->Brush->Color = RGB_EXTERNAL_HIG;
			m_pCanvas->Pen->Color   = RGB_EXTERNAL_HIG;
		}
		rectDraw.Top    = m_nThumbTop;
		rectDraw.Bottom = m_nThumbTop + m_nThumbHeight;

		//左区域
		rectDraw.Left   = PIXEL_EXTERNAL_FRAME;
		rectDraw.Right  = rectDraw.Left+PIXEL_EX2INTERNAL;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);
		//右区域
		rectDraw.Left  = Width - PIXEL_EXTERNAL_FRAME-PIXEL_EX2INTERNAL;
		rectDraw.Right = Width - PIXEL_EXTERNAL_FRAME;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);

		//===========================
		//绘制 滑块矩形区域
		if(iState == STATE_NORMAL){
			m_pCanvas->Brush->Color = RGB_INTERNAL_NOR;
			m_pCanvas->Pen->Color   = RGB_INTERNAL_NOR;
		}else if(iState == STATE_HIGHLIGHT){
			m_pCanvas->Brush->Color = RGB_INTERNAL_HIG;
			m_pCanvas->Pen->Color   = RGB_INTERNAL_HIG;
		}else if(iState == STATE_PUSH){
			m_pCanvas->Brush->Color = RGB_INTERNAL_PUSH;
			m_pCanvas->Pen->Color   = RGB_INTERNAL_PUSH;
		}

		rectDraw.left   = PIXEL_EXTERNAL_FRAME+PIXEL_EX2INTERNAL+PIXEL_INTERNAL_FARME;
		rectDraw.right  = Width-rectDraw.left;
		rectDraw.Top    = m_nThumbTop + PIXEL_INTERNAL_BOUND;
		rectDraw.Bottom = m_nThumbTop + m_nThumbHeight - PIXEL_INTERNAL_BOUND;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);

		//add by tj 2013/12/10
		//绘制 滑块矩形区域 横线
		//===========================
		//绘制 滑块矩形区域
	    COLORREF colLine, *colLineTrans, *colLineLight;
		if(iState == STATE_NORMAL){
			colLine       = RGB_INTERNAL_LINE_NOR;
			colLineTrans  = (COLORREF *)RGB_INTERNAL_LINE_NOR_TRANS;
		}else if(iState == STATE_HIGHLIGHT){
			colLine       = RGB_INTERNAL_LINE_HIG;
			colLineTrans  = (COLORREF *)RGB_INTERNAL_LINE_HIG_TRANS;
		}else if(iState == STATE_PUSH){
			colLine       = RGB_INTERNAL_LINE_PUSH;
			colLineTrans  = (COLORREF *)RGB_INTERNAL_LINE_PUSH_TRANS;
		}


		int X,Y,iPixlX,iPixlY;

		iPixlY = Y = m_nThumbTop   + m_nThumbHeight/2 - 3;
		iPixlX = X = rectDraw.left + (Width - 2*rectDraw.left - PIXEL_INTERNAL_LINE)/2;
		for(int i=0; i<3; i++){

			iPixlY  = Y;

			iPixlX  = X;
			iPixlY += 1;
			for(int j=0; j<6; j++){
				m_pCanvas->Pixels[iPixlX][iPixlY] = colLineTrans[j];
				iPixlX += 1;
			}

			iPixlX = X;
			iPixlY = Y;
			m_pCanvas->Pen->Color = colLine;
			m_pCanvas->MoveTo(iPixlX,iPixlY);
			iPixlX = Width - iPixlX;
			m_pCanvas->LineTo(iPixlX,iPixlY);

			Y += 3;
		}

		//===========================
		//绘制 滑块边框
		m_pCanvas->Brush->Color = RGB_INTERNAL_FRAME_NOR;
		m_pCanvas->Pen->Color   = RGB_INTERNAL_FRAME_NOR;


		//左边框
		rectDraw.left   = PIXEL_EXTERNAL_FRAME + PIXEL_EX2INTERNAL;
		rectDraw.right  = PIXEL_EXTERNAL_FRAME + PIXEL_EX2INTERNAL + PIXEL_INTERNAL_FARME;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);
		//右边框
		rectDraw.left   = Width - (PIXEL_EXTERNAL_FRAME+PIXEL_EX2INTERNAL+PIXEL_INTERNAL_FARME);
		rectDraw.right  = Width - (PIXEL_EXTERNAL_FRAME+PIXEL_EX2INTERNAL);
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);

		//上边框
		rectDraw.left   = PIXEL_EXTERNAL_FRAME + PIXEL_EX2INTERNAL + PIXEL_INTERNAL_FARME;
		rectDraw.right  = Width - rectDraw.left;
		rectDraw.Top    = m_nThumbTop;
		rectDraw.Bottom = m_nThumbTop + PIXEL_INTERNAL_BOUND;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);

		//下边框
		rectDraw.Top    = m_nThumbTop + m_nThumbHeight-PIXEL_INTERNAL_BOUND;
		rectDraw.Bottom = m_nThumbTop + m_nThumbHeight;
		m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
							 rectDraw.Right, rectDraw.Bottom);

		//===========================
		//绘制 滑块角
		if(iState == STATE_NORMAL){
			m_pCanvas->Pen->Color   = RGB_INTERNAL_ROUND_BKG_N_NOR;
		}else if(iState == STATE_HIGHLIGHT ){
			m_pCanvas->Pen->Color   = RGB_INTERNAL_ROUND_BKG_N_HIG;
		}else if( iState == STATE_PUSH){
			m_pCanvas->Pen->Color   = RGB_INTERNAL_ROUND_BKG_H_HIG;
		}

		//左上角
		rectDraw.left  = PIXEL_EXTERNAL_FRAME + PIXEL_EX2INTERNAL;
		rectDraw.Top   = m_nThumbTop;
		m_pCanvas->Pixels[rectDraw.left][rectDraw.top] = m_pCanvas->Pen->Color;

		//左下角
		rectDraw.Top   = m_nThumbTop + m_nThumbHeight - PIXEL_INTERNAL_BOUND;
		m_pCanvas->Pixels[rectDraw.left][rectDraw.top] = m_pCanvas->Pen->Color;

		//右上角
		rectDraw.left  = Width - (PIXEL_EXTERNAL_FRAME+PIXEL_EX2INTERNAL+PIXEL_INTERNAL_BOUND);
		rectDraw.Top   = m_nThumbTop;
		m_pCanvas->Pixels[rectDraw.left][rectDraw.top] = m_pCanvas->Pen->Color;

		//右下角
		rectDraw.Top   = m_nThumbTop + m_nThumbHeight - PIXEL_INTERNAL_BOUND;
		m_pCanvas->Pixels[rectDraw.left][rectDraw.top] = m_pCanvas->Pen->Color;
	}

/*	TBitmap *pBmp = NULL;

	rectDraw.Left = 0;
	rectDraw.Right = rectDraw.Left + Width;

	// 需要拉伸
	if( Width!=u_pPicPageUpTile->Width ){
		pBmp = new TBitmap();
		pBmp->Width = Width;
		pBmp->Height = m_nTileHeight;
		tmpRect.Left = 0;
		tmpRect.Top = 0;
		tmpRect.Right = Width;
		tmpRect.Bottom = m_nTileHeight;
		pBmp->Canvas->StretchDraw( tmpRect, u_pPicPageUpTile );
	}

	// 绘制上轨道
	if( bEraseBk )
		rectDraw.Top = Width;
	else if( m_nPreThumbTop<m_nThumbTop )
		rectDraw.Top = (m_nPreThumbTop-Width) / m_nTileHeight * m_nTileHeight + Width;
	else
		rectDraw.Top = Width;

	if( rectDraw.Top<m_nThumbTop ){
		rectDraw.Bottom = m_nThumbTop;
		if( !pBmp )
			m_pCanvas->Brush->Bitmap = u_pPicPageUpTile;
		else{
			m_pCanvas->Brush->Bitmap = pBmp;
		}

		m_pCanvas->FillRect( rectDraw );
	}

	// 绘制下轨道
	rectDraw.Top = m_nThumbTop + m_nThumbHeight;
	if( bEraseBk )
		rectDraw.bottom = Height - Width;
	else if( m_nPreThumbTop>m_nThumbTop ){
		rectDraw.bottom = m_nThumbHeight+m_nPreThumbTop;
		if( rectDraw.bottom>Height-Width ){
			rectDraw.bottom = Height-Width;
		}
	}
	else
		rectDraw.Bottom = rectDraw.Top;

	if( rectDraw.Height()>0 ){
		if( !pBmp )
			m_pCanvas->Brush->Bitmap = u_pPicPageDownTile;
		else{
		  tmpRect.Left = 0;
		  tmpRect.Top = 0;
		  tmpRect.Right = Width;
		  tmpRect.Bottom = m_nTileHeight;
		  pBmp->Canvas->StretchDraw( tmpRect, u_pPicPageDownTile );
		  m_pCanvas->Brush->Bitmap = pBmp;
		}

		m_pCanvas->FillRect( rectDraw );
	}

	// 绘制滑块
	if( m_nThumbHeight>0 ){
		int x = - iState * Width,
			y = m_nThumbTop,
			hTileUp,
			hTileDown;
		if( m_nThumbHeight>=THUMB_MINSIZE*2 ){
			hTileUp = (m_nThumbHeight-THUMB_MINSIZE*2+1)/2,
			hTileDown = m_nThumbHeight - THUMB_MINSIZE*2 - hTileUp;
		}
		else{
			hTileUp = (m_nThumbHeight-THUMB_MINSIZE+1)/2,
			hTileDown = m_nThumbHeight - THUMB_MINSIZE - hTileUp;
		}

		rectDraw.left = x;
		rectDraw.right = rectDraw.left + Width*3;

		if( !pBmp ){
			//滑块顶部圆弧
			m_pCanvas->Draw( x, y, u_pPicThumbTop ); y += THUMB_BORDER;

			//滑块上部平铺
			if( hTileUp>0 ){
				for( int i=0; i<hTileUp/u_pPicThumbTile->Height+1; i++ ){
					m_pCanvas->Draw( x, y+u_pPicThumbTile->Height*i, u_pPicThumbTile );
				}
				y += hTileUp;
			}

			//滑块中部条纹
			if( m_nThumbHeight>=THUMB_MINSIZE*2 ){
				m_pCanvas->Draw( x, y, u_pPicThumbMid ); y += THUMB_BORDER * 2;
			}

			//滑块下部平铺
			if( hTileDown>0 ){
				for( int i=0; i<hTileDown/u_pPicThumbTile->Height+1; i++ ){
					m_pCanvas->Draw( x, y+u_pPicThumbTile->Height*i, u_pPicThumbTile );
				}
				y += hTileDown;
			}

			//滑块底部圆弧
			m_pCanvas->Draw( x, y, u_pPicThumbBottom );
		}
	}

	// 清除临时图画
	if( pBmp ){
	  delete pBmp;
	  pBmp = NULL;
	}
*/
	m_nPreThumbTop = m_nThumbTop;
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::PaintWindow(HDC DC)
{
	if( !m_pCanvas->Handle )
		m_pCanvas->Handle = DC;

	// 绘制上箭头
	DrawArrow( SB_LINEUP, STATE_NORMAL );

	// 绘制滑块
	DrawThumb( STATE_NORMAL, true );

	// 绘制下箭头
	DrawArrow( SB_LINEDOWN, STATE_NORMAL );

	TRect rectDraw;

	//add by tj 2013/11/14
	//===========================
	//绘制 外面左右边框
	m_pCanvas->Brush->Color = RGB_EXTERNAL_FRAME;
	m_pCanvas->Pen->Color   = RGB_EXTERNAL_FRAME;

	rectDraw.Top    = Width;
	rectDraw.Bottom = Height - Width;

	rectDraw.Left   = 0;
	rectDraw.Right  = rectDraw.Left + PIXEL_EXTERNAL_FRAME;
	m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
						 rectDraw.Right, rectDraw.Bottom);

	rectDraw.Left   = Width - PIXEL_EXTERNAL_FRAME;
	rectDraw.Right  = Width;
	m_pCanvas->Rectangle(rectDraw.Left,  rectDraw.Top,
						 rectDraw.Right, rectDraw.Bottom);
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMPaint(TWMPaint &Message)
{
	PaintHandler(Message);
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::SetPosition(int Value, bool bRedraw)
{
	if( m_nPos!=Value ){
		m_nPos = Value;

		CalcThumbTop();
		if( bRedraw ) DrawThumb( STATE_NORMAL, false );
	}
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::SetPageSize(int Value, bool bRedraw)
{
	if( m_nPage!=Value ){
		m_nPage = Value;

		CalcThumbHeight();
		if( bRedraw ){
			DrawThumb( STATE_NORMAL, true );
			Invalidate();
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::SetRange(int AMin, int AMax, bool bRedraw)
{
	if( m_nMin!=AMin || m_nMax!=AMax ){
		m_nMin = AMin;
		m_nMax = AMax;

		CalcThumbHeight();
		if( bRedraw ){
			DrawThumb( STATE_NORMAL, true );
			Invalidate();
		}
	}
}
//---------------------------------------------------------------------------
int __fastcall CDTSkinScrollBar::GetScrollPos()
{
	return m_nPos;
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::GetScrollRange(int* nMin, int* nMax)
{
	*nMin = m_nMin;
	*nMax = m_nMax;
}
//---------------------------------------------------------------------------
int __fastcall CDTSkinScrollBar::GetPageSize()
{
	return m_nPage;
}
//---------------------------------------------------------------------------

void __fastcall CDTSkinScrollBar::SBMSetScrollInfo(TMessage &Message)
{
/*  //add by tj 2013/11/14
	bool bRedraw = bool(Message.WParam) && Visible;
	PScrollInfo pSi = PScrollInfo(Message.LParam);

	if( pSi->fMask & SIF_RANGE )
		SetRange( pSi->nMin, pSi->nMax, bRedraw );

	if( pSi->fMask & SIF_PAGE )
		SetPageSize( pSi->nPage, bRedraw );

	if( pSi->fMask & SIF_POS )
		SetPosition( pSi->nPos, bRedraw );
*/
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::SBMGetScrollInfo(TMessage &Message)
{
/*  //add by tj 2013/11/14
	PScrollInfo pSi = PScrollInfo(Message.LParam);

	if( pSi->fMask & SIF_PAGE )
		pSi->nPage = m_nPage;

	if( pSi->fMask & SIF_POS )
		pSi->nPos = m_nPos;

	if( pSi->fMask & SIF_TRACKPOS )
		pSi->nTrackPos = m_nTrackPos;

	if( pSi->fMask & SIF_RANGE ){
		pSi->nMin = m_nMin;
		pSi->nMax = m_nMax;
	}
*/
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMLButtonDown(TWMMouse &Message)
{
	SetCapture(Handle);

	m_bAction = true;
	m_pWndCtrl->SetFocus();

	int iHit = HitTest( Message.XPos, Message.YPos );
	if( iHit==SB_THUMBTRACK ){
		m_bDrag = TRUE;
		m_nDragPoint = Message.YPos;
		m_nDragPos = m_nPos;
		m_nTrackPos = m_nDragPos;
		DrawThumb( STATE_PUSH, false );
	}
	else{
		m_iClicked = iHit;
		m_pWndCtrl->Perform( WM_VSCROLL, MAKELONG(m_iClicked,0), LPARAM(Handle) );

		m_pTimer->Interval = TIME_DELAY;
		m_pTimer->Enabled = true;
		m_bPause = false;

		int nNewPos = m_nPos;
		if( iHit==SB_LINEUP || iHit==SB_LINEDOWN ){
			DrawArrow( iHit, STATE_PUSH );
			nNewPos += (iHit==SB_LINEUP) ? -1 : 1;
		}
		else if( iHit==SB_PAGEUP || iHit==SB_PAGEDOWN ){
			nNewPos += (iHit==SB_PAGEUP) ? -m_nPage : m_nPage;
		}

		int nLenInSi = m_nMax-m_nMin-m_nPage+1;
		if( nNewPos<m_nMin )
			nNewPos = m_nMin;
		else if( nNewPos>nLenInSi )
			nNewPos = nLenInSi;

		if( nNewPos!=m_nPos ){
		   m_nPos = nNewPos;
		   CalcThumbTop();
		   //add by tj 2013/11/14
		   DrawThumb( STATE_NORMAL, false, iHit );
		}
	}
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMLButtonUp(TWMMouse &Message)
{
	ReleaseCapture();

	if( m_bDrag ){
		m_bDrag = false;
		m_pWndCtrl->Perform(WM_VSCROLL, MAKELONG(SB_THUMBPOSITION, m_nTrackPos), LPARAM(Handle) );
		if( m_nTrackPos!=m_nPos ){
			m_nPos = m_nTrackPos;
		}

		m_nTrackPos = 0;
		CalcThumbTop();

		int iHit = HitTest( Message.XPos, Message.YPos );
		if( iHit==SB_THUMBTRACK )
			DrawThumb( STATE_HIGHLIGHT, false );
		else
			DrawThumb( STATE_NORMAL, false );
	}
	else if( m_iClicked!=-1 ){
		m_pTimer->Enabled = false;
		if( m_bNotify ){
			m_bNotify = false;
		}

		if( m_iClicked==SB_LINEUP || m_iClicked==SB_LINEDOWN )
			DrawArrow( m_iClicked, STATE_NORMAL );

		//add by tj 2013/11/14
		if( m_iClicked==SB_PAGEUP || m_iClicked==SB_PAGEDOWN )
			DrawThumb( STATE_NORMAL, false);

		m_iClicked = -1;
	}

	m_bAction = false;
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMLButtonDblClk(TWMMouse &Message)
{
	int uHit = HitTest( Message.XPos, Message.YPos );
	if( uHit!=SB_THUMBTRACK ){
		m_iClicked = uHit;

		WMLButtonDown( Message );
		m_bAction = false;
	}
}

//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMMouseMove(TWMMouse &Message)
{
	if( ((Extctrls::TPanel*)m_pWndCtrl)->OnMouseLeave ){
		((Extctrls::TPanel*)m_pWndCtrl)->OnMouseLeave(NULL);
	}

	Windows::TTrackMouseEvent tme;
	int nDragLen, nLenInSi, nSlide, nTrackLen, nNewPos, iHit, iState;
	if( !m_bTrace && (Message.Keys & MK_LBUTTON) ){
		tme.cbSize = sizeof(tme);
		tme.hwndTrack = Handle;
		tme.dwFlags = TME_LEAVE;
		tme.dwHoverTime = 1;
		m_bTrace = _TrackMouseEvent(&tme);
	}

	if( m_bDrag ){
		nTrackLen = Height - 2 * Width - m_nThumbHeight;
		nLenInSi = m_nMax-m_nMin-m_nPage+1;
		nDragLen = Message.YPos - m_nDragPoint;
		if( nTrackLen==0 )
			nSlide = 0;
		else
			nSlide = nDragLen * nLenInSi / nTrackLen;

		nNewPos = m_nDragPos + nSlide;
		if( nNewPos<m_nMin )
			nNewPos = m_nMin;
		else if( nNewPos>nLenInSi )
			nNewPos = nLenInSi;

		if( nNewPos!=m_nTrackPos ){
		   m_nTrackPos = nNewPos;
		   CalcThumbTop();
		   DrawThumb( STATE_PUSH, false );
		   m_pWndCtrl->Perform(WM_VSCROLL, MAKELONG(SB_THUMBTRACK, m_nTrackPos), LPARAM(Handle) );
		}
	}
	else if( m_iClicked!=-1 ){
		iHit = HitTest( Message.XPos, Message.YPos );
		if( iHit==m_iClicked ){
			m_bPause = false;
			iState = STATE_PUSH; //add by tj 2013/11/18
		}
		else{
			m_bPause = true;
			iState = STATE_NORMAL;
		}

		if( m_iClicked==SB_LINEUP || m_iClicked==SB_LINEDOWN )
			  DrawArrow( m_iClicked, iState );
	}
	else{
		iHit = HitTest( Message.XPos, Message.YPos );
		if( iHit!=m_iHitPrev ){
			if( m_iHitPrev!=-1 ){
				if( m_iHitPrev==SB_THUMBTRACK )
					DrawThumb( STATE_NORMAL, FALSE );
				else if( m_iHitPrev==SB_LINEUP || m_iHitPrev==SB_LINEDOWN )
					DrawArrow( m_iHitPrev, STATE_NORMAL );
			}

			if( iHit!=-1 ){
				if( iHit==SB_THUMBTRACK )
					DrawThumb( STATE_HIGHLIGHT, FALSE );
				else if( iHit==SB_LINEUP || iHit==SB_LINEDOWN )
					DrawArrow( iHit, STATE_HIGHLIGHT );
			}

			m_iHitPrev = iHit;
		}
	}
}

//---------------------------------------------------------------------------
/*
void __fastcall CDTSkinScrollBar::CMMouseLeave(TMessage &Message)
{
	if( m_iHitPrev!=-1 ){
		if( m_iHitPrev==SB_THUMBTRACK )
			DrawThumb( STATE_NORMAL, false );
		else if( m_iHitPrev==SB_LINEUP || m_iHitPrev==SB_LINEDOWN )
			DrawArrow( m_iHitPrev, STATE_NORMAL );

		m_iHitPrev = -1;
	}
}
*/
//---------------------------------------------------------------------------

void __fastcall CDTSkinScrollBar::CMMouseLeave(TObject *Sender)
{
	if( m_iHitPrev!=-1 ){
		if( m_iHitPrev==SB_THUMBTRACK )
			DrawThumb( STATE_NORMAL, false );
		else if( m_iHitPrev==SB_LINEUP || m_iHitPrev==SB_LINEDOWN )
			DrawArrow( m_iHitPrev, STATE_NORMAL );

		m_iHitPrev = -1;
	}
}
//---------------------------------------------------------------------------

void __fastcall CDTSkinScrollBar::WMRButtonDown(TWMMouse &Message)
{
//	DefaultHandler(&Message); //add by tj 2013/11/18
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::WMRButtonUp(TWMMouse &Message)
{
// 	DefaultHandler(&Message); //add by tj 2013/11/18
}
//---------------------------------------------------------------------------
void __fastcall CDTSkinScrollBar::TimerProc(TObject* Sender)
{
	if( m_pTimer->Interval==TIME_DELAY ){
		m_bNotify = true;

		m_pTimer->Enabled = false;
		m_pTimer->Interval = TIME_NOTIFY;
		m_pTimer->Enabled = true;
	}
	else if( m_pTimer->Interval==TIME_NOTIFY && !m_bPause ){
		int nNewPos = m_nPos;
		//add by tj 2013/11/14
		bool bPageUD = false;
		int iHit;

		switch( m_iClicked ){
			case SB_LINEUP:
				nNewPos -= 1;
				if( m_nPos==m_nMin ){
					m_pTimer->Enabled = false;
					return;
				}
				break;

			case SB_LINEDOWN:
				nNewPos += 1;
				if( m_nPos==m_nMax ){
					m_pTimer->Enabled = false;
					return;
				}
				break;

			case SB_PAGEUP:
			case SB_PAGEDOWN:
				{
					TPoint pt;
					GetCursorPos(&pt);
					pt = ScreenToClient(pt);

					iHit = HitTest( pt.X, pt.Y );
					if( iHit==SB_THUMBTRACK ){
						m_pTimer->Enabled = false;
						return;
					}
					nNewPos += (m_iClicked==SB_PAGEUP) ? -m_nPage+1 : m_nPage-1;
					bPageUD = true;
				}
				break;
		}

		int nLenInSi = m_nMax-m_nMin-m_nPage+1;
		if( nNewPos<m_nMin )
			nNewPos = m_nMin;
		else if( nNewPos>nLenInSi )
			nNewPos = nLenInSi;

		if( nNewPos!=m_nPos ){
		   m_nPos = nNewPos;
		   CalcThumbTop();
		   //add by tj 2013/11/14
		   if(bPageUD)
				DrawThumb( STATE_NORMAL, false, iHit );
		   else
            	DrawThumb( STATE_NORMAL, false );
		}

		m_pWndCtrl->Perform( WM_VSCROLL, MAKELONG(m_iClicked,0), LPARAM(Handle) );
	}
}