void CMultiThumbOpt::OnMouseMove(const CPoint& point)
{
	CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];

	if(m_bStartDraging) // begin to drag?
	{
	
		CPoint ptPos = pThumb->GetPixPosition();
		CPoint ptNewPS = ptPos;
		int nMax, nMin;
		GetThumbRange(pThumb->GetPosition(), nMin, nMax);
		
		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;
			}

		}

		pThumb->MoveThumb(ptNewPS);

		ReCalcChannelRect();
	}
}
// 专门为主Thumb使用
void CTripleLinkageOpt::MouseMoveForOtherThumb(const CPoint& point)
{
    CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];

    if(m_bStartDraging) // begin to drag?
    {

        CPoint ptPos = pThumb->GetPixPosition();
        CPoint ptNewPS = ptPos;
        int nMax, nMin;
        GetThumbRange(pThumb->GetPosition(), nMin, nMax);

        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
        {
            nPixMin = m_szTicMarks->at(nMax);
            nPixMax = m_szTicMarks->at(nMin);

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

        }

        pThumb->MoveThumb(ptNewPS);
    }
}
// 专门为主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();
//




    }

}
// 专门为主Thumb使用
void CTripleLinkageOpt::MovePageForMainThumb(const CPoint& pt)
{
    CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];
    ASSERT(pThumb);

    CPoint ptPos = pThumb->GetPixPosition();
    CPoint ptltPos = m_szThumb[FOCUS_ON_TOPLEFT]->GetPixPosition();
    CPoint ptbrPos = m_szThumb[FOCUS_ON_RIGHTBTM]->GetPixPosition();

    int nPosition	= pThumb->GetPosition();
    int nltPos	  = m_szThumb[FOCUS_ON_TOPLEFT]->GetPosition();
    int nbrPos = m_szThumb[FOCUS_ON_RIGHTBTM]->GetPosition();


    int nMax = m_szTicMarks->size()-1;
    int nMin = 0;
    //GetThumbRange(m_nFocusThumb, nMin, nMax);

    CPoint ptNewPS = ptPos;
    CPoint ptNewltPS = ptltPos;
    CPoint ptNewbrPS = ptbrPos;

    int		nNewPos = nPosition;
    int		nNewltPos = nltPos;
    int		nNewbrPos = nbrPos;

    if (m_bHorizontal)
    {
        if (pt.x > ptPos.x)  // move right
        {
            nNewbrPos = nbrPos+m_nLengthOfPage;
            if(nNewbrPos <= nMax)
            {
                nNewPos = nPosition+m_nLengthOfPage;
                nNewltPos = nltPos+m_nLengthOfPage;

                ptNewbrPS.x = m_szTicMarks->at(nNewbrPos)+m_rcChannel.left;
                ptNewltPS.x = m_szTicMarks->at(nNewltPos)+m_rcChannel.left;
                ptNewPS.x = m_szTicMarks->at(nNewPos)+m_rcChannel.left;

            }
            else
            {
                nNewbrPos = nMax;
                int nSteps = nMax - nbrPos;

                nNewPos = nPosition+nSteps;
                nNewltPos = nltPos+nSteps;

                ptNewbrPS.x = m_szTicMarks->at(nNewbrPos)+m_rcChannel.left;
                ptNewltPS.x = m_szTicMarks->at(nNewltPos)+m_rcChannel.left;
                ptNewPS.x = m_szTicMarks->at(nNewPos)+m_rcChannel.left;
            }
        }
        else // move left
        {
            nNewltPos = nPosition - m_nLengthOfPage;
            if(nNewltPos >= nMin)
            {
                nNewPos = nPosition-m_nLengthOfPage;
                nNewbrPos = nbrPos-m_nLengthOfPage;

                ptNewbrPS.x = m_szTicMarks->at(nNewbrPos)+m_rcChannel.left;
                ptNewltPS.x = m_szTicMarks->at(nNewltPos)+m_rcChannel.left;
                ptNewPS.x = m_szTicMarks->at(nNewPos)+m_rcChannel.left;
            }
            else
            {
                nNewltPos = nMin;
                int nSteps = nltPos - nNewltPos;

                nNewPos = nPosition-nSteps;
                nNewbrPos = nbrPos-nSteps;

                ptNewbrPS.x = m_szTicMarks->at(nNewbrPos)+m_rcChannel.left;
                ptNewltPS.x = m_szTicMarks->at(nNewltPos)+m_rcChannel.left;
                ptNewPS.x = m_szTicMarks->at(nNewPos)+m_rcChannel.left;
            }
        }
        pThumb->SetPosition(nNewPos);
        pThumb->MoveThumb(ptNewPS);

        m_szThumb[FOCUS_ON_TOPLEFT]->SetPosition(nNewltPos);
        m_szThumb[FOCUS_ON_TOPLEFT]->MoveThumb(ptNewltPS);


        m_szThumb[FOCUS_ON_RIGHTBTM]->SetPosition(nNewbrPos);
        m_szThumb[FOCUS_ON_RIGHTBTM]->MoveThumb(ptNewbrPS);
    }
    else
    {
        // 交换
        int nTemp = nltPos;
        nltPos = nbrPos;
        nbrPos = nTemp;

        //CPoint ptTemp = 0;

        //
        if (pt.y > ptPos.y)  // move down
        {
            nNewbrPos = nbrPos-m_nLengthOfPage;// 向下是减

            if(nNewbrPos <= nMin)
            {
                //ptNewPS.y = m_szTicMarks->at(nNewPosition)+m_rcChannel.top;
                nNewbrPos = nMin;
                int nSteps = abs(nbrPos - nNewbrPos);

                nNewPos = nPosition-nSteps;
                nNewltPos = nltPos-nSteps;

                ptNewbrPS.y = m_szTicMarks->at(nNewbrPos)+m_rcChannel.top;
                ptNewltPS.y = m_szTicMarks->at(nNewltPos)+m_rcChannel.top;
                ptNewPS.y = m_szTicMarks->at(nNewPos)+m_rcChannel.top;

            }
            else
            {

                nNewPos = nPosition-m_nLengthOfPage;
                nNewltPos = nltPos-m_nLengthOfPage;

                ptNewbrPS.y = m_szTicMarks->at(nNewbrPos)+m_rcChannel.top;
                ptNewltPS.y = m_szTicMarks->at(nNewltPos)+m_rcChannel.top;
                ptNewPS.y = m_szTicMarks->at(nNewPos)+m_rcChannel.top;
            }

        }
        else // move up
        {
            nNewltPos = nltPos + m_nLengthOfPage;  // up +

            if(nNewltPos >= nMax)
            {
                nNewltPos = nMax;
                int nSteps = abs(nNewltPos - nltPos);

                nNewPos = nPosition+nSteps;
                nNewbrPos = nbrPos+nSteps;

                ptNewbrPS.y = m_szTicMarks->at(nNewbrPos)+m_rcChannel.top;
                ptNewltPS.y = m_szTicMarks->at(nNewltPos)+m_rcChannel.top;
                ptNewPS.y = m_szTicMarks->at(nNewPos)+m_rcChannel.top;
            }
            else
            {
                nNewPos = nPosition+m_nLengthOfPage;
                nNewbrPos = nbrPos+m_nLengthOfPage;

                ptNewbrPS.y = m_szTicMarks->at(nNewbrPos)+m_rcChannel.top;
                ptNewltPS.y = m_szTicMarks->at(nNewltPos)+m_rcChannel.top;
                ptNewPS.y = m_szTicMarks->at(nNewPos)+m_rcChannel.top;


            }
        }
        pThumb->SetPosition(nNewPos);
        pThumb->MoveThumb(ptNewPS);

        m_szThumb[FOCUS_ON_TOPLEFT]->SetPosition(nNewbrPos);
        m_szThumb[FOCUS_ON_TOPLEFT]->MoveThumb(ptNewbrPS);


        m_szThumb[FOCUS_ON_RIGHTBTM]->SetPosition(nNewltPos);
        m_szThumb[FOCUS_ON_RIGHTBTM]->MoveThumb(ptNewltPS);
    }



}
// 专门为两个从属thumb movepage使用
void CTripleLinkageOpt::MovePageForOtherThumb(const CPoint& pt)
{

    CFSBThumb* pThumb = m_szThumb[m_nFocusThumb];
    ASSERT(pThumb);

    CPoint ptPos = pThumb->GetPixPosition();
    int nPosition	= pThumb->GetPosition();

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

    CPoint ptNewPS = ptPos;
    int		nNewPosition = nPosition;

    if (m_bHorizontal)
    {
        if (pt.x > ptPos.x)  // move right
        {
            nNewPosition = nPosition+m_nLengthOfPage;

            if(nNewPosition <= nMax)
            {
                ptNewPS.x = m_szTicMarks->at(nNewPosition)+m_rcChannel.left;
            }
            else
            {
                nNewPosition = nMax;
                ptNewPS.x = m_szTicMarks->at(nNewPosition)+m_rcChannel.left;
            }
        }
        else // move left
        {
            nNewPosition = nPosition - m_nLengthOfPage;
            if(nNewPosition >= nMin)
            {
                ptNewPS.x = m_szTicMarks->at(nNewPosition)+m_rcChannel.left;
            }
            else
            {
                nNewPosition = nMin;
                ptNewPS.x = m_szTicMarks->at(nNewPosition)+m_rcChannel.left;
            }
        }
    }
    else
    {
        if (pt.y > ptPos.y)  // move down
        {
            nNewPosition = nPosition-m_nLengthOfPage; // down -

            if(nNewPosition <= nMin)
            {
                nNewPosition = nMin;
                ptNewPS.y = m_szTicMarks->at(nNewPosition)+m_rcChannel.top;
            }
            else
            {
                ptNewPS.y = m_szTicMarks->at(nNewPosition)+m_rcChannel.top;
            }

        }
        else // move up
        {
            nNewPosition = nPosition + m_nLengthOfPage;
            if(nNewPosition >= nMax)
            {
                nNewPosition = nMax;
                ptNewPS.y = m_szTicMarks->at(nNewPosition)+m_rcChannel.top;

            }
            else
            {
                ptNewPS.y = m_szTicMarks->at(nNewPosition)+m_rcChannel.top;
            }
        }
    }

    pThumb->SetPosition(nNewPosition);
    pThumb->MoveThumb(ptNewPS);

}