void CMultiThumbOpt::OnLButtonUp(const CPoint& point)
{
	if(m_bStartDraging)// begin to drag?
	{
		CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];

		m_bStartDraging = FALSE;
		//ReleaseCapture();

		int nPos = SearchThumbPosition(point);

		int nMin, nMax;
		GetThumbRange(m_nFocusThumb,  nMin, nMax);
		if (nPos >= nMax)
		{
			nPos = nMax;
		}
		if(nPos <= nMin)
		{
			nPos = nMin;
		}
		pThumb->SetPosition(nPos);

		MoveToPosition(m_nFocusThumb, nPos);

		ReCalcChannelRect();
	}
	((CFlexSlideWnd*)m_pParent)->SendCallBackMsg();
}
// 专门为两个从属thumb movepage使用
void CTripleLinkageOpt::LBtnUpForOtherThumb(const CPoint& point)
{
    if(m_bStartDraging)// begin to drag?
    {
        CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];

        m_bStartDraging = FALSE;
        //ReleaseCapture();

        int nPos = SearchThumbPosition(point);

        int nMin, nMax;
        GetThumbRange(m_nFocusThumb,  nMin, nMax);

        if (nPos >= nMax)
        {
            nPos = nMax;
        }
        if(nPos <= nMin)
        {
            nPos = nMin;
        }
        pThumb->SetPosition(nPos);

        MoveToPosition(m_nFocusThumb, nPos);
    }
}
// 专门为主Thumb使用
void CTripleLinkageOpt::LBtnUpForMainThumb(const CPoint& point)
{
    if(m_bStartDraging)// begin to drag?
    {
        CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];

        int nPos = SearchThumbPosition(point);

        int nltGap, nrbGap;
        int nMin, nMax;

        int nltPos;
        int nrbPos;
        if(m_bHorizontal)
        {
            nltGap=  pThumb->GetPosition()-m_szThumb[0]->GetPosition();
            nrbGap = m_szThumb[2]->GetPosition() - pThumb->GetPosition();

            nMin =  nltGap;
            nMax = m_szTicMarks->size()-1 - nrbGap;

            nltPos = nPos-nltGap;
            nrbPos = nPos+nrbGap;

            //int nMin, nMax;
            //GetThumbRange(m_nFocusThumb,  nMin, nMax);
            if (nPos >= nMax)
            {
                nPos = nMax;
                nltPos = nPos-nltGap;
                nrbPos = nPos + nrbGap;
            }
            if(nPos <= nMin)
            {
                nPos = nMin;
                nltPos = nPos-nltGap;
                nrbPos = nPos + nrbGap;
            }


            pThumb->SetPosition(nPos);
            m_szThumb[0]->SetPosition(nltPos);
            m_szThumb[2]->SetPosition(nrbPos);

            MoveToPosition(0,nltPos);
            MoveToPosition(1,nPos);
            MoveToPosition(2,nrbPos);
        }
        else
        {
            nltGap =  m_szThumb[2]->GetPosition()-pThumb->GetPosition();
            nrbGap = pThumb->GetPosition()-m_szThumb[0]->GetPosition();

            nMin =  nrbGap;
            nMax = m_szTicMarks->size()-1 - nltGap;

            nltPos = nPos+nltGap;
            nrbPos = nPos-nrbGap;

            if (nPos >= nMax)
            {
                nPos = nMax;
            }
            if(nPos <= nMin)
            {
                nPos = nMin;

            }
            nltPos = nPos+nltGap;
            nrbPos = nPos - nrbGap;

            pThumb->SetPosition(nPos);
            m_szThumb[0]->SetPosition(nrbPos);
            m_szThumb[2]->SetPosition(nltPos);

            MoveToPosition(0,nrbPos);
            MoveToPosition(1,nPos);
            MoveToPosition(2,nltPos);
        }




        m_bStartDraging = FALSE;
// 		//ReleaseCapture();
//




    }

}
void CMultiThumbOpt::OnMouseMove(const CPoint& point)
{
	

	if(m_bStartDraging) // begin to drag?
	{    
         CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];
	      ////Check DB
         int nPos = SearchThumbPosition(point);
        int nMax, nMin;
         GetThumbRange(pThumb->GetPosition(), nMin, nMax);


 		CPoint ptPos = pThumb->GetPixPosition();
 		CPoint ptNewPS = ptPos;
// 

		
        int nPixMin, nPixMax;
		nPixMin = m_szTicMarks->at(nMin);
		nPixMax = m_szTicMarks->at(nMax);


		if (m_bHorizontal)
		{
			nPixMax+=m_rcChannel.left;
			nPixMin+=m_rcChannel.left;

			ptNewPS.x  = point.x;

			if(point.x >= nPixMax)
			{
				ptNewPS.x = nPixMax;
			}
			if(point.x < nPixMin)
			{
				ptNewPS.x = nPixMin;
			}
		}
		else   // vertical
		{	
			nPixMax+=m_rcChannel.top;
			nPixMin+=m_rcChannel.top;

			int nTemp = nPixMin;
			nPixMin = nPixMax;
			nPixMax = nTemp;     // 交换一下,

			ptNewPS.y = point.y;

			if(point.y >= nPixMax)
			{
				ptNewPS.y = nPixMax;
			}
			if(point.y < nPixMin)
			{
				ptNewPS.y = nPixMin;
			}

		}
                 //if (nPos >= nMax)
                 //{
                 //    nPos = nMax;
                 //}
                 //if(nPos <= nMin)
                 //{
                 //    nPos = nMin;
                 //}
                 //if (m_nFocusThumb == 0)
                 //{
                 //    if (nPos>m_nMidPos)
                 //    {
                 //        return;
                 //    }
                 //}
                 //if (m_nFocusThumb == 1)
                 //{
                 //    if (nPos<m_nMidPos)
                 //    {
                 //        return;
                 //    }
                 //}
		pThumb->MoveThumb(ptNewPS);

		ReCalcChannelRect();
	}
}