bcgpbarcontainermanager.cpp

关于远程网络监视程序的源码

CBCGPBarContainer* CBCGPBarContainerManager::FindContainer (CBCGPDockingControlBar* pBar, 
															BOOL& bLeftBar)
{
	ASSERT_VALID (this);
	if (m_pRootContainer != NULL)
	{
		bLeftBar = TRUE;
		CBCGPBarContainer::BC_FIND_CRITERIA barType = CBCGPBarContainer::BC_FIND_BY_LEFT_BAR;
		CBCGPBarContainer* pContainer = m_pRootContainer->FindSubContainer (pBar, barType);
		if (pContainer == NULL)
		{
			barType = CBCGPBarContainer::BC_FIND_BY_RIGHT_BAR;
			pContainer = m_pRootContainer->FindSubContainer (pBar, barType);
			bLeftBar = FALSE;
		}
		return pContainer;
	}
	return NULL;
}
//-----------------------------------------------------------------------------------//
// Look for control bar that contains point according to secitivity: if we're looking
// for the exact bar, the point must be in the area between bars' bounds and deflated bars'
// bounds; otherwise the point must be inside inflated bars' window rectangle
//-----------------------------------------------------------------------------------//
CBCGPDockingControlBar* CBCGPBarContainerManager::ControlBarFromPoint (CPoint point, 
																	   int nSensitivity, 
																	   BOOL bExactBar,
																	   BOOL& bIsTabArea,
																	   BOOL& bCaption)
{
	ASSERT_VALID (this);
	
	bIsTabArea = FALSE;


	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_lstControlBars.GetNext (pos));

		CRect rectWnd;
		pBar->GetWindowRect (rectWnd);

		CRect rectTabAreaTop;
		CRect rectTabAreaBottom;
		pBar->GetTabArea (rectTabAreaTop, rectTabAreaBottom);

		if (rectTabAreaTop.PtInRect (point) ||
			rectTabAreaBottom.PtInRect (point))
		{
			bIsTabArea = TRUE;
			return pBar;
		}

		if (pBar->HitTest (point, TRUE) == HTCAPTION)
		{
			bCaption = TRUE;
			return pBar;
		}

		int nCaptionHeight = pBar->GetCaptionHeight ();
		rectWnd.top += nCaptionHeight;
		rectWnd.bottom -= rectTabAreaBottom.Height ();


		if (rectWnd.PtInRect (point))
		{
			rectWnd.InflateRect (-nSensitivity, -nSensitivity);
			if (!rectWnd.PtInRect (point) || nSensitivity == 0)
			{
				return pBar;
			}
		}
	}

	if (!bExactBar)
	{
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPDockingControlBar* pBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_lstControlBars.GetNext (pos));

			CRect rectWnd;
			pBar->GetWindowRect (rectWnd);

			rectWnd.InflateRect (nSensitivity, nSensitivity);
			if (rectWnd.PtInRect (point))
			{
				return pBar;
			}
		}
	}
	return NULL;
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::GetMinSize (CSize& size)
{
	ASSERT_VALID (this);
	size.cx = size.cy = 0;

	if (m_pRootContainer != NULL)
	{
		m_pRootContainer->GetMinSize (size);
	}
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::IsRootContainerVisible () const
{
	ASSERT_VALID (this);
	if (m_pRootContainer != NULL)
	{
		return m_pRootContainer->IsContainerVisible ();
	}

	return FALSE;
}
//-----------------------------------------------------------------------------------//
int CBCGPBarContainerManager::GetVisibleBarCount () const
{
	ASSERT_VALID (this);
	int nCount = 0;

	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (pWnd->IsBarVisible ())
		{
			nCount++;
		}
	}

	return nCount;
}
//-----------------------------------------------------------------------------------//
CWnd* CBCGPBarContainerManager::GetFirstVisibleBar () const
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (pWnd->IsBarVisible ())
		{
			return pWnd;
		}
	}	
	return NULL;
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::EnableGrippers (BOOL bEnable)
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_lstControlBars.GetNext (pos));

		if (pWnd != NULL)
		{
			pWnd->EnableGripper (bEnable);
		}
	}
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::HideAll ()
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CWnd* pWnd = DYNAMIC_DOWNCAST (CWnd, m_lstControlBars.GetNext (pos));

		if (pWnd != NULL)
		{
			pWnd->ShowWindow (SW_HIDE);
		}
	}

	for (pos = m_lstSliders.GetHeadPosition (); pos != NULL;)
	{
		CWnd* pWnd = DYNAMIC_DOWNCAST (CWnd, m_lstSliders.GetNext (pos));

		if (pWnd != NULL)
		{
			pWnd->ShowWindow (SW_HIDE);
		}
	}
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::DoesContainFloatingBar ()
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		if (pWnd->CanFloat ())
		{
			return TRUE;
		}
	}

	return FALSE;
}
//-----------------------------------------------------------------------------------//
int	CBCGPBarContainerManager::GetNodeCount () const
{
	ASSERT_VALID (this);

	if (m_pRootContainer == NULL)
	{
		return 0;
	}

	return m_pRootContainer->GetNodeCount ();
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::IsEmpty () const 
{
	return m_lstControlBars.IsEmpty ();
}
//-----------------------------------------------------------------------------------//
int CBCGPBarContainerManager::GetTotalRefCount () const
{
	if (m_pRootContainer == NULL)
	{
		return 0;
	}
	return m_pRootContainer->GetTotalReferenceCount ();
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::SetDefaultSliderForControlBars (CBCGPSlider* pSlider)
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_lstControlBars.GetNext (pos));
		if (pWnd != NULL)
		{	
			pWnd->SetDefaultSlider (NULL);
		}
	}
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::AddControlBarsToList (CObList* plstControlBars, 
													 CObList* plstSliders)
{
	ASSERT_VALID (this);
	if (plstControlBars != NULL)
	{
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CWnd* pWnd = 
				DYNAMIC_DOWNCAST (CWnd, m_lstControlBars.GetNext (pos));
			ASSERT_VALID (pWnd);
	
			if (pWnd->GetStyle () & WS_VISIBLE) 
			{	
				plstControlBars->AddTail (pWnd);
			}
		}
	}
	
	if (plstSliders != NULL)
	{
		for (POSITION pos = m_lstSliders.GetHeadPosition (); pos != NULL;)
		{
			CWnd* pWnd = 
				DYNAMIC_DOWNCAST (CWnd, m_lstSliders.GetNext (pos));
			ASSERT_VALID (pWnd);
			
			if (pWnd->GetStyle () & WS_VISIBLE) 
			{	
				plstSliders->AddTail (pWnd);
			}
		}
	}
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::RemoveAllControlBarsAndSliders ()
{
	ASSERT_VALID (this);
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		POSITION posSave = pos;
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (pWnd->IsBarVisible ())
		{
			m_lstControlBars.RemoveAt (posSave);
		}
	}

	for (pos = m_lstSliders.GetHeadPosition (); pos != NULL;)
	{
		POSITION posSave = pos;
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (pWnd->IsBarVisible ())
		{
			m_lstSliders.RemoveAt (posSave);
		}
	}
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::AddControlBarToList (CBCGPDockingControlBar* pControlBarToAdd) 
{
	ASSERT_VALID (this);
	ASSERT_VALID (pControlBarToAdd);

	m_lstControlBars.AddTail (pControlBarToAdd);
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::DoesAllowDynInsertBefore () const
{
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (pWnd->DoesAllowDynInsertBefore ())
		{
			return TRUE;
		}
	}

	return FALSE;
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::NotifySlider ()
{
	if (m_pDefaultSlider != NULL)
	{
		m_pDefaultSlider->NotifyAboutRelease ();
	}
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::CheckForMiniFrameAndCaption (CPoint point, 
									CBCGPDockingControlBar** ppTargetControlBar)
{
	CBCGPMultiMiniFrameWnd* pMiniFrameWnd = 
		DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, m_pDockSite);

	*ppTargetControlBar = NULL;

	if (pMiniFrameWnd == NULL)
	{
		return FALSE;
	}

	if (GetVisibleBarCount () > 1)
	{
		return FALSE;
	}

	CRect rectCaption;
	pMiniFrameWnd->GetCaptionRect (rectCaption);
	pMiniFrameWnd->ScreenToClient (&point);


	CRect rectBorderSize;
	pMiniFrameWnd->CalcBorderSize (rectBorderSize);

	point.Offset (rectBorderSize.left, 
				  rectBorderSize.top + pMiniFrameWnd->GetCaptionHeight ());

	if (rectCaption.PtInRect (point))
	{
		*ppTargetControlBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, GetFirstVisibleBar ());
	}

	return (*ppTargetControlBar != NULL);
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::RemoveNonValidBars ()
{
	if (m_pRootContainer != NULL)
	{
		m_pRootContainer->RemoveNonValidBars ();
	}
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::CheckAndRemoveNonValidBar (CWnd* pWnd)
{
	if (pWnd != NULL)
	{
		UINT nControlID = pWnd->GetDlgCtrlID ();
		if (IsWindow (pWnd->GetSafeHwnd ()) && nControlID != -1)
		{
			return TRUE;
		}

		CBCGPBaseTabbedBar* pBaseTabbedBar = 
				DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pWnd);

		if (pBaseTabbedBar != NULL && pBaseTabbedBar->GetTabsNum () > 0)
		{
			return TRUE;
		}
	}

	POSITION pos = m_lstControlBars.Find (pWnd);
	if (pos != NULL)
	{
		m_lstControlBars.RemoveAt (pos);
	}

	return FALSE;
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::CanBeAttached () const
{
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pWnd = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pWnd);

		if (!pWnd->CanBeAttached ())
		{
			return FALSE;
		}
	}

	return TRUE;
}