bcgpdockingcontrolbar.cpp

远程网络监视程序的源码

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

	if (!m_rectRedraw.IsRectEmpty ())
	{
		CRgn rgn;
		rgn.CreateRectRgnIndirect (m_rectRedraw);

		dc.SelectClipRgn (&rgn);
	}

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

    // erase NC background the hard way
	CBCGPVisualManager::GetInstance ()->OnFillBarBackground (&dc, this, rcBar, rcBar, 
		TRUE /* NC area */);

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

		rectCaption.OffsetRect (-rectCaption.left, -rectCaption.top);
		rectCaption.DeflateRect (0, 1);

		rectCaption.left = rcClient.left;
		rectCaption.top --;
		rectCaption.bottom = rectCaption.top + m_cyGripper - 2;

		DrawCaption (&dc, rectCaption);

		for (int i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			BOOL bIsMax = FALSE;
			if (pbtn->GetHit () == HTMAXBUTTON)
			{
				bIsMax = m_bPinState;
			}

			pbtn->OnDraw (&dc, m_bActive, IsHorizontal (), bIsMax);
			pbtn->m_clrForeground = (COLORREF)-1;
		}
	}

	dc.SelectClipRgn (NULL);

	if (m_bMultiThreaded)
	{
		g_cs.Unlock ();
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnDrawDragRect (LPCRECT lprectNew, LPCRECT lprectOld)
{
	ASSERT_VALID (this);
	CWindowDC dcWnd (GetDesktopWindow ());
	dcWnd.DrawDragRect (lprectNew, CSize (1, 1), lprectOld, CSize (1, 1));
}
//***********************************************************************
UINT CBCGPDockingControlBar::OnNcHitTest(CPoint point) 
{
	ASSERT_VALID (this);
	UINT nHitTest = HitTest (point);
	if (nHitTest != HTERROR)
	{
		return nHitTest;
	}
	return CBCGPControlBar::OnNcHitTest(point);
}
//***********************************************************************
int CBCGPDockingControlBar::HitTest (CPoint point, BOOL bDetectCaption)
{
	ASSERT_VALID (this);
	CRect rectWnd;
	GetWindowRect (&rectWnd);

	if (!rectWnd.PtInRect (point))
	{
		return HTNOWHERE;
	}

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (GetDockSite ());
	ASSERT (pDockManager != NULL || globalUtils.m_bDialogApp);	

	// should return hite test of client or caption only in the lock update mode
	if (pDockManager != NULL && !pDockManager->m_bLockUpdate)
	{
		for (int i = 0; i < m_arrButtons.GetSize (); i ++)
		{
			CBCGPCaptionButton* pbtn = m_arrButtons [i];
			ASSERT_VALID (pbtn);

			CRect rc = pbtn->GetRect();
			rc.OffsetRect(rectWnd.TopLeft());
			if (rc.PtInRect(point))
			{
				return pbtn->GetHit ();
			}
		}
	}

	CRect rectClient;
	GetClientRect (&rectClient);
	ClientToScreen (&rectClient);

	if (rectClient.PtInRect (point))
	{
		return HTCLIENT;
	}

	if (IsDocked ())
	{
		CRect rect;
		int nBorderWidth  = 0;
		int nBorderHeight = 1;
		// caption
		rect.SetRect (rectWnd.left + nBorderWidth, rectWnd.top + nBorderHeight, 
							 rectWnd.right - nBorderWidth, 
							 rectWnd.top + nBorderHeight + m_cyGripper);
		if (rect.PtInRect (point))
		{
			return bDetectCaption ? HTCAPTION : HTCLIENT;
		}
	}

	return HTERROR;
}
//***********************************************************************
CSize CBCGPDockingControlBar::CalcFixedLayout(BOOL /*bStretch*/, BOOL /*bHorz*/)
{
	ASSERT_VALID (this);
	CRect rectWnd;
	GetWindowRect (&rectWnd);
	CSize size = rectWnd.Size ();
	return size;
}
//***********************************************************************
void CBCGPDockingControlBar::OnPaint() 
{
	ASSERT_VALID (this);
	CPaintDC dc(this); // device context for painting
}
//***********************************************************************
BCGP_CS_STATUS CBCGPDockingControlBar::IsChangeState (int nOffset, 
													CBCGPBaseControlBar** ppTargetBar) const
{
	ASSERT_VALID (this);
	ASSERT (ppTargetBar != NULL);

	CPoint ptMouse;
	GetCursorPos (&ptMouse);

	CWnd* pParentWnd = GetParent ();

	if (pParentWnd->IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd)))
	{
		CBCGPMiniFrameWnd* pMiniFrame = DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, pParentWnd);
		pParentWnd = pMiniFrame->GetParent ();
	}

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (pParentWnd);
	
	if (pDockManager == NULL)
	{
		return CS_NOTHING;
	}

	return pDockManager->DetermineControlBarAndStatus (ptMouse, nOffset, 
				GetEnabledAlignment (), ppTargetBar, this, this);
}
//***********************************************************************
void CBCGPDockingControlBar::OnLButtonDown(UINT nFlags, CPoint point) 
{
	ASSERT_VALID (this);

	if (m_nHot != HTNOWHERE)
	{
		CBCGPCaptionButton* pBtn = FindButtonByHit (m_nHot);
		if (pBtn != NULL)
		{
			m_nHit = m_nHot;
			pBtn->m_bPushed = TRUE;
			RedrawButton (pBtn);
			return;
		}
	}
	else
	{
		CWnd* pWndChild = GetWindow (GW_CHILD);
		CWnd* pWndFirstChild = NULL;
		int nCount = 0;

		while (pWndChild != NULL)
		{
			pWndFirstChild = pWndChild;
			pWndChild = pWndChild->GetNextWindow ();
			nCount++;
		}

		if (nCount == 1)
		{
			pWndFirstChild->SetFocus ();
		}
	}

	if (!IsAutoHideMode () && !IsTabbed ())
	{
		if (CanFloat ())
		{
			m_bPrepareToFloat = true;
		}
		CBCGPControlBar::OnLButtonDown(nFlags, point);
	}
	
	SetFocus ();
}
//***********************************************************************
void CBCGPDockingControlBar::StoreRecentDockInfo ()
{
	CBCGPMiniFrameWnd* pParentMiniFrame = GetParentMiniFrame ();

	CBCGPDockingControlBar* pBarToSave = this;

	if (IsTabbed ())
	{
		CBCGPBaseTabWnd* pTabWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
		if (pTabWnd != NULL)
		{
			pBarToSave = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pTabWnd->GetParent ());	
		}
	}			

	CBCGPSlider* pDefaultSlider = pBarToSave->GetDefaultSlider ();

	if (pParentMiniFrame != NULL)
	{
		pParentMiniFrame->StoreRecentDockInfo (pBarToSave);
	}
	else if (pDefaultSlider != NULL)
	{
		pDefaultSlider->StoreRecentDockInfo (pBarToSave);
	}
}
//***********************************************************************
void CBCGPDockingControlBar::StoreRecentTabRelatedInfo ()
{
	if (!IsTabbed ())
	{
		return;
	}

	CBCGPDockingControlBar* pParentTabbedBar = NULL;

	CBCGPBaseTabWnd* pTabWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
	if (pTabWnd != NULL)
	{
		pParentTabbedBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pTabWnd->GetParent ());	
	}

	if (pParentTabbedBar == NULL)
	{
		ASSERT (FALSE);
		return;
	}

	CBCGPMiniFrameWnd* pParentMiniFrame = GetParentMiniFrame ();
	CBCGPSlider* pDefaultSlider = pParentTabbedBar->GetDefaultSlider ();

	if (pParentMiniFrame != NULL)
	{
		pParentMiniFrame->StoreRecentTabRelatedInfo (this, pParentTabbedBar);
	}
	else if (pDefaultSlider != NULL)
	{
		pDefaultSlider->StoreRecentTabRelatedInfo (this, pParentTabbedBar); 
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnRButtonDown(UINT nFlags, CPoint point) 
{
	SetFocus ();
	CBCGPPopupMenu::UpdateAllShadows ();
	
	CBCGPControlBar::OnRButtonDown(nFlags, point);
}
//***********************************************************************
void CBCGPDockingControlBar::OnMouseMove(UINT nFlags, CPoint point) 
{
	ASSERT_VALID (this);
	CPoint ptMouse;
	GetCursorPos (&ptMouse);

	if (GetDockMode () == DT_IMMEDIATE)
	{
		if ((!m_bCaptured && GetCapture () == this ||
			m_bCaptured && GetCapture () != this ||
			(GetAsyncKeyState(VK_LBUTTON) & 0x8000) == 0)
			&& !m_bCaptionButtonsCaptured)
		{
			ReleaseCapture ();
			m_bCaptured = false;
			m_bPrepareToFloat = false;
		}
		if (m_bPrepareToFloat)
		{
			CRect rectBar;
			GetWindowRect (rectBar);

			if (!m_bReadyToFloat)
			{
				m_bReadyToFloat = rectBar.PtInRect (ptMouse) == TRUE;
			}

			CRect rectLast = m_rectDragImmediate;

			CPoint ptOffset = ptMouse - m_dragFrameImpl.m_ptHot;
			m_dragFrameImpl.m_ptHot = ptMouse;

			UpdateVirtualRect (ptOffset);
		

			if (IsTabbed ())
			{
				CBCGPBaseTabWnd* pParentTab = 
						DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
				pParentTab->GetParent ()->GetWindowRect (&rectBar);
			}

			rectBar.InflateRect (m_sizeDragSencitivity.cx, 
								 m_sizeDragSencitivity.cy);


			if (!rectBar.PtInRect (ptMouse) && m_bReadyToFloat)
			{
				if (IsTabbed ())
				{
					CBCGPBaseTabWnd* pParentTab = 
						DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
					if (pParentTab != NULL)
					{
						pParentTab->DetachTab (DM_MOUSE);
					}
				}
				else
				{
					FloatControlBar (m_recentDockInfo.m_rectRecentFloatingRect, DM_MOUSE);			
				}
				m_bPrepareToFloat = false;
				m_bReadyToFloat = false;
			}
			return;
		}
	}
	else if (GetDockMode () == DT_STANDARD && m_bPrepareToFloat)
	{
		CBCGPControlBar::OnMouseMove(nFlags, point);
		return;
	}

	CPoint ptScreen = point;
	ClientToScreen (&ptScreen);

	OnTrackCaptionButtons (ptScreen);
}
//***********************************************************************
void CBCGPDockingControlBar::OnLButtonUp(UINT nFlags, CPoint point) 
{
	ASSERT_VALID (this);

	if (m_bPrepareToFloat)
	{
		m_bPrepareToFloat = false;
	}

	if (m_nHit != HTNOWHERE)
	{
		CBCGPDockManager* pDockManager = globalUtils.GetDockManager (GetDockSite ());
		ASSERT (pDockManager != NULL || globalUtils.m_bDialogApp);		

		UINT nHot = m_nHot;
		UINT nHit = m_nHit;

		StopCaptionButtonsTracking ();

		CBCGPSlider* pDefaultSlider = GetDefaultSlider ();

		if (nHot == nHit)
		{
			switch (nHit)
			{
			case HTCLOSE_BCG:
				OnPressCloseButton ();
				break;

			case HTMAXBUTTON:
				if (GetAsyncKeyState (VK_CONTROL) && IsAutohideAllEnabled ())
				{
					m_pDockSite->SetRedraw (FALSE);
					if (!m_bPinState)
					{
						CObList lstBars;
						pDefaultSlider->GetControlBars (lstBars);
						
						for (POSITION pos = lstBars.GetHeadPosition (); pos != NULL;)
						{
							CBCGPDockingControlBar* pBar = 
								DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstBars.GetNext (pos));
							if (pBar->IsAutohideAllEnabled ())
							{
								pBar->SetAutoHideMode (TRUE, 
									pDefaultSlider->GetCurrentAlignment (), NULL, FALSE);	
							}
						}
					}
					else
					{
						CBCGPAutoHideDockBar* pParentDockBar = 
							DYNAMIC_DOWNCAST (CBCGPAutoHideDockBar, m_pAutoHideBar->GetParentDockBar ());

						if (pParentDockBar != NULL)
						{
							pParentDockBar->UnSetAutoHideMode (NULL);
						}
					}

					m_pDockSite->SetRedraw (TRUE);
					m_pDockSite->RedrawWindow (NULL, NULL, 
							RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
				}
				else
				{
					if (pDockManager != NULL && pDefaultSlider != NULL && 
						(pDefaultSlider->GetCurrentAlignment () & 
						pDockManager->GetEnabledAutoHideAlignment ()))
					{
						SetAutoHideMode (!m_bPinState, 
							pDefaultSlider->GetCurrentAlignment ());
					}
				}
				return;				

			default:
				OnPressButtons (nHit);
			}
		}

		CWnd::OnLButtonUp(nFlags, point);
		return;
	}

	CBCGPControlBar::OnLButtonUp(nFlags, point);
}
//***********************************************************************
void CBCGPDockingControlBar::OnPressCloseButton ()
{
	if (IsAutoHideMode ())
	{
		m_bPinState	= FALSE;	
		SetAutoHideMode (m_bPinState, GetCurrentAlignment ());
	}
	ShowControlBar (FALSE, FALSE, FALSE);
	AdjustDockingLayout ();
}
//***********************************************************************
void CBCGPDockingControlBar::EnterDragMode (BOOL bChangeHotPoint)
{
	m_bPrepareToFloat = true;
	CBCGPControlBar::EnterDragMode (bChangeHotPoint);
}
//***********************************************************************
CBCGPAutoHideToolBar* CBCGPDockingControlBar::SetAutoHideMode (BOOL bMode, DWORD dwAlignment, 
																CBCGPAutoHideToolBar* pCurrAutoHideBar, 
																BOOL bUseTimer)
{
	ASSERT_VALID (this);
	ASSERT (dwAlignment & CBRS_ALIGN_ANY);

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (GetDockSite ());
	ASSERT_VALID (pDockManager);

	if (bMode)
	{
		m_bPinState = TRUE;

		CRect rectBeforeUndock;
		GetWindowRect (rectBeforeUndock);
		GetDockSite ()->ScreenToClient (rectBeforeUndock);

		StoreRecentDockInfo ();

		// set autohide mode
		UnDockControlBar (FALSE);