// 专门为两个从属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);
    }
}
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();
}
void CTripleLinkageOpt::MoveToPosition(int nIndex, int nPosition)
{
    CFSBThumb* pThumb = m_szThumb[nIndex];

    int nPixPos = m_szTicMarks->at(nPosition);
    CPoint pt = pThumb->GetPixPosition();

    if (m_bHorizontal)
    {
        pt.x = nPixPos+m_rcChannel.left;
    }
    else
    {
        pt.y = nPixPos+m_rcChannel.top;
    }

    pThumb->SetPosition(nPosition);
    pThumb->MoveThumb(pt);
}
void CMultiThumbOpt::MoveToPosition(int nIndex, int nPosition)
{
	ASSERT(nIndex < (int)m_szThumb.size());
	CFSBThumb* pThumb = m_szThumb[nIndex];

	int nPixPos = m_szTicMarks->at(nPosition);
	CPoint pt = pThumb->GetPixPosition();

	if (m_bHorizontal)
	{
		pt.x = nPixPos+m_rcChannel.left;
	}
	else
	{
		pt.y = nPixPos+m_rcChannel.top;
	}

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

}