bcgsizingcontrolbar.cpp

一个完整的编辑器的代码（很值得参考

	for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
	{
		CSCBButton& btn = m_Buttons [i];

		if (btn.m_nHit == nHitTest)
		{
			if (nHitTest != HTMAXBUTTON || !m_bIsSingleInRow)
			{
				btn.m_bFocused = btn.m_bPushed = TRUE;
				m_nTrackingPushedButton = i;

				RedrawWindow (btn.GetRect (), NULL,
					RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
				
				SetTimer (uiHotBtnTimerId, uiHotBtnTimerDelay, NULL);
				SetCapture ();
			}

			break;
		}
	}

    if ((nHitTest >= HTSIZEFIRST) && (nHitTest <= HTSIZELAST))
	{
        StartTracking(nHitTest); // sizing edge hit
	}

	if (nHitTest == HTCAPTION) 
	{
		m_pDockContext->StartDrag(point);
	}
}

void CBCGSizingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
{
    if (m_bTracking)
	{
        StopTracking ();

		BOOL bHorz = IsHorzDocked();

        CSCBArray arrSCBars;
        GetRowSizingBars(arrSCBars);

		for (int i = 0; i < arrSCBars.GetSize(); i++)
		{
			CBCGSizingControlBar* pBar = arrSCBars[i];

			BOOL bMaximized = pBar->m_bMaximized;

			if (bHorz)
			{
				if (pBar->m_szHorz.cx == m_szMaxT.cx)
				{
					pBar->m_bMaximized = TRUE;

					if (pBar->m_szOld.cx == pBar->m_szHorz.cx)
					{
						pBar->m_szOld.cx = pBar->m_szHorz.cx / arrSCBars.GetSize();
					}
				}
				else
				{
					pBar->m_bMaximized = FALSE;
				}
			}
			else
			{
				if (pBar->m_szVert.cy == m_szMaxT.cy)
				{
					pBar->m_bMaximized = TRUE;

					if (pBar->m_szOld.cy == pBar->m_szVert.cy)
					{
						pBar->m_szOld.cy = pBar->m_szVert.cy / arrSCBars.GetSize();
					}
				}
				else
				{
					pBar->m_bMaximized = FALSE;
				}
			}

			if (bMaximized != pBar->m_bMaximized)
			{
				CSCBButton& btn = pBar->m_Buttons [1];
				pBar->RedrawWindow (btn.GetRect (), NULL,
					RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
			}
		}
	}
	else
	{
		for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
		{
			CSCBButton& btn = m_Buttons [i];

			if (btn.m_bPushed)
			{
				if (btn.m_bFocused)
				{
					switch (btn.m_nHit)
					{
					case HTCLOSE:
						m_pDockSite->ShowControlBar(this, FALSE, FALSE); // hide
						break;

					case HTMAXBUTTON:
						ToggleExpand ();
						break;
					}
				}

				ReleaseCapture ();
				btn.m_bFocused = btn.m_bPushed = FALSE;
				m_nTrackingPushedButton = -1;

				RedrawWindow (btn.GetRect (), NULL,
					RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
				break;
			}
		}
	}

    CControlBar::OnLButtonUp(nFlags, point);
}

void CBCGSizingControlBar::OnRButtonDown(UINT nFlags, CPoint point) 
{
    if (m_bTracking)
	{
        StopTracking();
	}
	else if (!CBCGToolBar::IsCustomizeMode ())
	{
		CFrameWnd* pParentFrame = (m_pDockSite == NULL) ?
			GetDockingFrame() : m_pDockSite;
		ASSERT_VALID(pParentFrame);

		ClientToScreen (&point);
		pParentFrame->SendMessage (BCGM_TOOLBARMENU,
			(WPARAM) GetSafeHwnd (),
			MAKELPARAM(point.x, point.y));
		return;
	}
    
    CControlBar::OnRButtonDown(nFlags, point);
}

void CBCGSizingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
{
    if (m_bTracking)
	{
        OnTrackUpdateSize(point);
	}
	else {
		for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
		{
			CSCBButton& btn = m_Buttons [i];


			CRect rcBar;
			GetWindowRect (rcBar);

			CRect rectBtn = btn.GetRect();
			rectBtn.OffsetRect (rcBar.TopLeft());

			CPoint ptScreen = point;
			ClientToScreen(&ptScreen);

			if (rectBtn.PtInRect (ptScreen))
			{
				OnTimer (uiHotBtnTimerId);
			}

		}
	}
    
    CControlBar::OnMouseMove(nFlags, point);
}


void CBCGSizingControlBar::OnNcMouseMove(UINT nHitTest, CPoint point) 
{
    if (!m_bTracking)
	{
		for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
		{
			CSCBButton& btn = m_Buttons [i];


			CRect rcBar;
			GetWindowRect (rcBar);

			CRect rectBtn = btn.GetRect();
			rectBtn.OffsetRect (rcBar.TopLeft());

			CPoint ptScreen = point;

			if (rectBtn.PtInRect (ptScreen))
			{
				OnTimer (uiHotBtnTimerId);
			}

		}
	}

	CControlBar::OnNcMouseMove(nHitTest, point);
}

void CBCGSizingControlBar::OnCaptureChanged(CWnd *pWnd) 
{
    if (m_bTracking && (pWnd != this))
	{
        StopTracking();
	}

    CControlBar::OnCaptureChanged(pWnd);

	KillTimer (uiHotBtnTimerId);
	for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
	{
		CSCBButton& btn = m_Buttons [i];
		if (btn.m_bFocused || btn.m_bPushed)
		{
			btn.m_bFocused = btn.m_bPushed = FALSE;
			m_nTrackingPushedButton = -1;

			RedrawWindow (btn.GetRect (), NULL,
				RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
		}
	}
}

void CBCGSizingControlBar::OnNcCalcSize(BOOL /*bCalcValidRects*/,
                                     NCCALCSIZE_PARAMS FAR* lpncsp) 
{
    // compute the the client area
    CRect rcClient = lpncsp->rgrc[0];
    rcClient.DeflateRect(5, 5);

    m_dwSCBStyle &= ~SCBS_EDGEALL;

    switch(m_nDockBarID)
    {
    case AFX_IDW_DOCKBAR_TOP:
        m_dwSCBStyle |= SCBS_EDGEBOTTOM;
        rcClient.DeflateRect(m_cyGripper, 0, 0, 0);
        break;
    case AFX_IDW_DOCKBAR_BOTTOM:
        m_dwSCBStyle |= SCBS_EDGETOP;
        rcClient.DeflateRect(m_cyGripper, 0, 0, 0);
        break;
    case AFX_IDW_DOCKBAR_LEFT:
        m_dwSCBStyle |= SCBS_EDGERIGHT;
        rcClient.DeflateRect(0, m_cyGripper, 0, 0);
        break;
    case AFX_IDW_DOCKBAR_RIGHT:
        m_dwSCBStyle |= SCBS_EDGELEFT;
        rcClient.DeflateRect(0, m_cyGripper, 0, 0);
        break;
    default:
        break;
    }

    if (!IsFloating() && m_pDockBar != NULL)
    {
        CSCBArray arrSCBars;
        GetRowSizingBars(arrSCBars);

        for (int i = 0; i < arrSCBars.GetSize(); i++)
		{
            if (arrSCBars[i] == this)
            {
                if (i > 0)
                    m_dwSCBStyle |= IsHorzDocked() ?
                        SCBS_EDGELEFT : SCBS_EDGETOP;
                if (i < arrSCBars.GetSize() - 1)
                    m_dwSCBStyle |= IsHorzDocked() ?
                        SCBS_EDGERIGHT : SCBS_EDGEBOTTOM;
            }
		}
    }

    // make room for edges only if they will be painted
    if (m_dwSCBStyle & SCBS_SHOWEDGES)
	{
        rcClient.DeflateRect(
            IsEdgeVisible (HTLEFT) ? m_cxEdge : 0,
            IsEdgeVisible (HTTOP) ? m_cxEdge : 0,
            IsEdgeVisible (HTRIGHT) ? m_cxEdge : 0,
            IsEdgeVisible (HTBOTTOM) ? m_cxEdge : 0);
	}

    // "hide" and "expand" buttons positioning:
    CPoint ptOrgBtn;
    if (IsHorzDocked())
        ptOrgBtn = CPoint(rcClient.left - m_cyGripper - 3,
            rcClient.top - 3);
    else
        ptOrgBtn = CPoint(rcClient.right - CSCBButton::GetSize ().cx,
            rcClient.top - m_cyGripper - 3);

    CRect rcBar;
    GetWindowRect(rcBar);
	ScreenToClient (rcBar);

	for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
	{
		CSCBButton& btn = m_Buttons [i];
		btn.Move (ptOrgBtn - CRect (lpncsp->rgrc[0]).TopLeft ());

		if (m_wndToolTip.GetSafeHwnd () != NULL)
		{
			CRect rectTT = btn.GetRect ();
			rectTT.OffsetRect (rcBar.TopLeft());
			m_wndToolTip.SetToolRect (this, i + 1, rectTT);
		}

		if (IsHorzDocked())
		{
			ptOrgBtn.Offset (0, CSCBButton::GetSize ().cy + 2);
		}
		else
		{
			ptOrgBtn.Offset (- CSCBButton::GetSize ().cx - 2, 0);
		}
	}

    lpncsp->rgrc[0] = rcClient;
}

void CBCGSizingControlBar::OnNcPaint() 
{
	if (m_bTracking)
	{
		return;
	}

    // get window DC that is clipped to the non-client area
    CWindowDC dc(this);

    CRect rcClient, rcBar;
    GetClientRect(rcClient);
    ClientToScreen(rcClient);
    GetWindowRect(rcBar);

    rcClient.OffsetRect(-rcBar.TopLeft());
    rcBar.OffsetRect(-rcBar.TopLeft());

    // client area is not our bussiness :)
    dc.ExcludeClipRect(rcClient);

    // erase parts not drawn
    dc.IntersectClipRect(rcBar);

    // erase NC background the hard way
    HBRUSH hbr = (HBRUSH)GetClassLong(m_hWnd, GCL_HBRBACKGROUND);
    ::FillRect(dc.m_hDC, rcBar, hbr);

	CRect rcBorder = rcBar;
	rcBorder.InflateRect (IsHorzDocked(), IsVertDocked ());

    if (m_dwSCBStyle & SCBS_SHOWEDGES)
    {
        CRect rcEdge; // paint the sizing edges
        for (int i = 3; i >= 0; --i)
		{
			UINT nHitTest = GetEdgeHTCode(i);
            if (GetEdgeRect (rcBar, nHitTest, rcEdge))
			{
				CRect rcEdgeInternal = rcEdge;

				switch (nHitTest)
				{
				case HTLEFT:
					rcEdge.InflateRect( 0, IsVertDocked()?2:0 );

					rcEdge.OffsetRect(-IsVertDocked(), 0);
					rcEdgeInternal = rcEdge;
					rcEdgeInternal.InflateRect (1, 0);

					if(IsVertDocked())
						rcBorder.left	= rcEdge.right;
					break;

				case HTRIGHT:
					rcEdge.InflateRect( 0, IsVertDocked()?2:1 );

					rcEdge.OffsetRect(IsVertDocked(), 0);
					rcEdgeInternal = rcEdge;
					rcEdgeInternal.InflateRect (1, 0);

					if(IsVertDocked())
						rcBorder.right = rcEdge.left;
					break;

				case HTTOP:
					rcEdge.InflateRect( IsHorzDocked()?2:0, 0 );
					rcEdge.OffsetRect(0, -(m_nDockBarID == AFX_IDW_DOCKBAR_BOTTOM) );

					rcEdgeInternal = rcEdge;
					rcEdgeInternal.InflateRect (0, 1);

					if(IsHorzDocked())
						rcBorder.top	= rcEdge.bottom;
					break;

				case HTBOTTOM:
					rcEdge.InflateRect( IsHorzDocked()?2:1, 0 );

					rcEdge.OffsetRect(0, IsHorzDocked());
					rcEdgeInternal = rcEdge;
					rcEdgeInternal.InflateRect (0, 1);

					if(IsHorzDocked())
						rcBorder.bottom	= rcEdge.top;
					break;

				default:
					if( IsEdgeVisible (nHitTest))

					ASSERT(FALSE); // invalid hit test code
				}

				dc.Draw3dRect(rcEdgeInternal, ::GetSysColor (COLOR_3DSHADOW),
					::GetSysColor (COLOR_3DHIGHLIGHT));

				dc.Draw3dRect (rcEdge, ::GetSysColor (COLOR_3DHIGHLIGHT),
					::GetSysColor (COLOR_3DSHADOW));

				rcEdge.DeflateRect ( nHitTest==HTLEFT || nHitTest==HTRIGHT,
					nHitTest==HTTOP || nHitTest==HTBOTTOM);

				if(! CBCGToolBar::IsLook2000() ) {

					dc.Draw3dRect (rcEdge, ::GetSysColor (COLOR_3DLIGHT),
						::GetSysColor (COLOR_3DDKSHADOW));

				}
			}
		}
    }

	dc.Draw3dRect (rcBorder, ::GetSysColor (COLOR_3DHILIGHT),
		::GetSysColor (COLOR_3DSHADOW));

    if (m_cyGripper && !IsFloating())
	{
		// Paint gripper and buttons:
		CRect rectGripper;
		
		GetWindowRect (&rectGripper);
		ScreenToClient (&rectGripper);

		rectGripper.OffsetRect (-rectGripper.left, -rectGripper.top);

		CRect rcbtn = m_Buttons [CBCGSIZINGCONTROLBAR_BUTTONS_NUM - 1].GetRect();
    
		rectGripper.DeflateRect(1, 1);

		if (IsHorzDocked())
		{   // gripper at left
			rectGripper.top = rcbtn.bottom + 3;
			rectGripper.bottom = rcClient.bottom;
			rectGripper.right = rcbtn.right;
		}
		else
		{   // gripper at top
			rectGripper.left = rcClient.left;
			rectGripper.right = rcbtn.left - 3;
			rectGripper.bottom = rcbtn.bottom;
		}

		CBCGControlBarImpl::DrawGripper (&dc, rectGripper, IsHorzDocked());

		for (int i = 0; i < CBCGSIZINGCONTROLBAR_BUTTONS_NUM; i ++)
		{
			m_Buttons [i].Paint (&dc, IsHorzDocked(), m_bMaximized, m_bIsSingleInRow);
		}