bcgpdockmanager.cpp

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

		return;
	}

	if (m_bRecalcLayout || m_bSizeFrame)
	{
		return;
	}

	if (!m_bEnableAdjustLayout)
	{
		return;
	}

	m_bRecalcLayout = TRUE;

	if (!m_bIsOLEContainerMode)
	{
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextControlBar = 
				(CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
			ASSERT_VALID (pNextControlBar);
			pNextControlBar->AdjustLayout ();
		}

		for (pos = m_lstMiniFrames.GetHeadPosition (); pos != NULL;)
		{
			CBCGPMiniFrameWnd* pNextMiniFrame = 
				(CBCGPMiniFrameWnd*) m_lstMiniFrames.GetNext (pos);
			ASSERT_VALID (pNextMiniFrame);
			pNextMiniFrame->AdjustLayout ();
		}
	}
	else
	{
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextControlBar = 
				(CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
			ASSERT_VALID (pNextControlBar);
			if (pNextControlBar->IsBarVisible ())
			{
				pNextControlBar->AdjustLayout ();
			}
		}
	}

	AdjustDockingLayout ();
	m_bRecalcLayout = FALSE;
}
//------------------------------------------------------------------------//
void CBCGPDockManager::AdjustDockingLayout (HDWP hdwp)
{
	ASSERT_VALID (this);

	if (m_bDisableRecalcLayout)
	{
		return;
	}

	if (m_bAdjustingBarLayout)
	{
		return;
	}

	if (m_pParentWnd == NULL)
	{
		return;
	}

	m_pParentWnd->GetClientRect (m_rectClientAreaBounds);

	if (!m_bEnableAdjustLayout)
	{
		return;
	}

	if (m_lstControlBars.IsEmpty ())
	{
		return;
	}

	m_bAdjustingBarLayout = TRUE;

	CRect rectSaveOuterEdgeBounds = m_rectOuterEdgeBounds;

	BOOL bDeferWindowPosHere = FALSE;
	if (hdwp == NULL && !m_bIsPrintPreviewMode)
	{
		hdwp = BeginDeferWindowPos (m_lstControlBars.GetCount ());
		bDeferWindowPosHere = TRUE;
	}

	CRect rectCurrBounds = m_rectDockBarBounds;

	// temporary - may want to enable feature of independent bounds
	m_pParentWnd->GetClientRect (rectCurrBounds);
	m_pParentWnd->ClientToScreen (rectCurrBounds);


	if(m_bIsOLEInPlaceActivate)
	{
		//take into account container's statusbar Height
		rectCurrBounds.bottom -= 20;
	}


	CRect rectControlBar;
	
	// find position of the last dock bar in the list (actually, it will be position
	// of the next control bar right after the last dock bar in the list)

	for (POSITION posLastDockBar = m_lstControlBars.GetTailPosition (); 
		 posLastDockBar != NULL;)
	{
		CBCGPBaseControlBar* pDockBar = 
			(CBCGPBaseControlBar*) m_lstControlBars.GetPrev (posLastDockBar);
		if (posLastDockBar == NULL)
		{
			break;
		}

		if (pDockBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)) ||
			pDockBar->IsKindOf (RUNTIME_CLASS (CBCGPAutoHideDockBar)))
		{
			m_lstControlBars.GetNext (posLastDockBar);
			if (posLastDockBar != NULL)
			{
				m_lstControlBars.GetNext (posLastDockBar);
			}
			break;
		}
	}

	POSITION posBar = NULL;
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		posBar = pos;

		CBCGPBaseControlBar* pNextControlBar = 
			(CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
		ASSERT_VALID (pNextControlBar);


		if (!pNextControlBar->IsBarVisible() && 
			(pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)) ||
			pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)) ||
			pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)) && 
			(m_bIsPrintPreviewMode || m_bIsOLEContainerMode)))
		{
			continue;
		}
		
		// let's see whether this control bar has enough space to be displayed,
		// has to be aligned differntly and so on. 

		pNextControlBar->GetWindowRect (rectControlBar);
		CRect rectSave = rectControlBar;
		
		DWORD dwAlignment = pNextControlBar->GetCurrentAlignment ();
		BOOL  bHorizontal = pNextControlBar->IsHorizontal ();
		BOOL  bResizable  = pNextControlBar->IsResizable ();

		if (pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
		{
			CBCGPDockingControlBar* pDockingControlBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pNextControlBar);
			if (pDockingControlBar->GetDefaultSlider () != NULL)
			{
				// resizable control bars with sliders will be aligned by slider itself!!!
				continue;
			}
		}

		CSize sizeRequered = pNextControlBar->CalcFixedLayout (FALSE, bHorizontal);

		if (bHorizontal)
		{
			dwAlignment & CBRS_ALIGN_TOP ? rectControlBar.bottom = rectControlBar.top + sizeRequered.cy : 
										   rectControlBar.top = rectControlBar.bottom - sizeRequered.cy;
		}
		else
		{
			dwAlignment & CBRS_ALIGN_LEFT ? rectControlBar.right = rectControlBar.left + sizeRequered.cx : 
											rectControlBar.left = rectControlBar.right - sizeRequered.cx;
		}

		
		AlignByRect (rectCurrBounds, rectControlBar, dwAlignment, bHorizontal, bResizable);	
		
	
		CRect rectControlBarScreen = rectControlBar;

		ASSERT_VALID (pNextControlBar->GetParent ());
		if (pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)))
		{
			pNextControlBar->ScreenToClient (rectControlBar);
			if (pNextControlBar->IsHorizontal () && rectControlBar.Width () > 0 ||
				!pNextControlBar->IsHorizontal () && rectControlBar.Height () > 0)
			{
				((CBCGPDockBar*) pNextControlBar)->RepositionBars (rectControlBar);
			}

			rectControlBar = rectControlBarScreen;
		}

		if (pNextControlBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
		{
			// the slider will change its position, as well as position of
			// its resizable control bars (container)
			((CBCGPSlider*) pNextControlBar)->RepositionBars (rectControlBar, hdwp);			
		}
		else
		{
			pNextControlBar->GetParent ()->ScreenToClient (rectControlBar);
			hdwp = pNextControlBar->SetWindowPos (NULL, rectControlBar.left, 
						rectControlBar.top, rectControlBar.Width (), rectControlBar.Height (), 
						SWP_NOZORDER | SWP_NOACTIVATE, hdwp);
		}

		if (dwAlignment & CBRS_ALIGN_TOP)
		{
			rectCurrBounds.top += rectControlBarScreen.Height ();
		}
		else if (dwAlignment & CBRS_ALIGN_BOTTOM)
		{
			rectCurrBounds.bottom -= rectControlBarScreen.Height ();
		}
		else if (dwAlignment & CBRS_ALIGN_LEFT)
		{
			rectCurrBounds.left += rectControlBarScreen.Width ();
		}
		else 
		{
			rectCurrBounds.right -= rectControlBarScreen.Width ();
		}

		if (posLastDockBar == pos)
		{
			m_rectOuterEdgeBounds = rectCurrBounds;
		}

	}

	m_rectClientAreaBounds = rectCurrBounds;

	if (m_rectOuterEdgeBounds.IsRectEmpty () || m_bIsOLEContainerMode)
	{
		m_rectOuterEdgeBounds = rectCurrBounds;
	}

	

	m_pParentWnd->ScreenToClient (m_rectClientAreaBounds);
	m_pParentWnd->ScreenToClient (m_rectOuterEdgeBounds);

	if (m_rectOuterEdgeBounds != rectSaveOuterEdgeBounds)
	{
		HideAutoHideBars (NULL, TRUE);
	}

	// special processing for autohide dock bars
	for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pBar = (CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
		ASSERT_VALID (pBar);
		if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPAutoHideDockBar)))
		{
			CBCGPAutoHideDockBar* pSlidingBar = (CBCGPAutoHideDockBar*) pBar;
			pSlidingBar->SetOffsetLeft (0);
			pSlidingBar->SetOffsetRight (0);
			CalcBarOffset ((CBCGPAutoHideDockBar*) pBar);
		}
	}

	if (bDeferWindowPosHere)
	{
		EndDeferWindowPos (hdwp);
	}

	m_bAdjustingBarLayout = FALSE;
}
//----------------------------------------------------------------------------------//
void CBCGPDockManager::CalcBarOffset (CBCGPAutoHideDockBar* pBar)
{
	ASSERT_VALID (pBar);
	DWORD dwBarAlignOrg = pBar->GetCurrentAlignment ();
	CRect rectBarOrg;
	pBar->GetWindowRect (rectBarOrg);	
	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pBarNext = (CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
		ASSERT_VALID (pBarNext);
		if (pBarNext->IsKindOf (RUNTIME_CLASS (CBCGPAutoHideDockBar)))
		{
			CBCGPAutoHideDockBar* pNextSlidingDockBar = 
				DYNAMIC_DOWNCAST (CBCGPAutoHideDockBar, pBarNext);

			if (pNextSlidingDockBar == pBar ||
				pNextSlidingDockBar->IsHorizontal () && pBar->IsHorizontal () ||
				!pNextSlidingDockBar->IsHorizontal () && !pBar->IsHorizontal ())
			{
				continue;
			}

			CRect rectBarNext;
			pNextSlidingDockBar->GetWindowRect (rectBarNext);
			if (rectBarNext.IsRectEmpty ())
			{
				continue;
			}

			DWORD dwBarAlignNext = pNextSlidingDockBar->GetCurrentAlignment ();
			
			if (dwBarAlignOrg & CBRS_ALIGN_LEFT && 
				dwBarAlignNext & CBRS_ALIGN_TOP)
			{
				if (rectBarOrg.top == rectBarNext.bottom)
				{
					pNextSlidingDockBar->SetOffsetLeft (rectBarOrg.Width ());
				}

				if (rectBarOrg.right == rectBarNext.left)
				{
					pBar->SetOffsetLeft (rectBarNext.Height ());
				}
			}
			else if (dwBarAlignOrg & CBRS_ALIGN_TOP && 
					 dwBarAlignNext & CBRS_ALIGN_RIGHT)
			{
				if (rectBarOrg.right == rectBarNext.left)
				{
					pNextSlidingDockBar->SetOffsetLeft (rectBarOrg.Height ());
				}

				if (rectBarOrg.bottom == rectBarNext.top)
				{
					pBar->SetOffsetRight (rectBarNext.Width ());
				}
			}
			else if (dwBarAlignOrg & CBRS_ALIGN_RIGHT && 
					 dwBarAlignNext & CBRS_ALIGN_BOTTOM)
			{
				if (rectBarOrg.bottom == rectBarNext.top)
				{
					pNextSlidingDockBar->SetOffsetRight (rectBarOrg.Width ());
				}

				if (rectBarOrg.left == rectBarNext.right)
				{
					pBar->SetOffsetRight (rectBarOrg.Width ());
				}
			}
			else if (dwBarAlignOrg & CBRS_ALIGN_LEFT && 
					 dwBarAlignNext & CBRS_ALIGN_BOTTOM)
			{
				if (rectBarOrg.bottom == rectBarNext.top)
				{
					pNextSlidingDockBar->SetOffsetLeft (rectBarOrg.Width ());
				}

				if (rectBarOrg.right == rectBarNext.left)
				{
					pBar->SetOffsetRight (rectBarNext.Height ());
				}
			}
		}
	}
} 
//----------------------------------------------------------------------------------//
void CBCGPDockManager::AlignByRect (const CRect& rectToAlignBy, 
										CRect& rectResult, DWORD dwAlignment, 
										BOOL bHorizontal, BOOL bResizable)
{
	ASSERT_VALID (this);

	int nCurrWidth = rectResult.Width ();
	int nCurrHeight = rectResult.Height ();


	DWORD dwCurrAlignment = dwAlignment & CBRS_ALIGN_ANY;
	switch (dwCurrAlignment)
	{
	case CBRS_ALIGN_LEFT:
		rectResult.TopLeft () = rectToAlignBy.TopLeft ();
		rectResult.bottom = rectResult.top + rectToAlignBy.Height ();
		rectResult.right = rectResult.left + nCurrWidth;
		break;

	case CBRS_ALIGN_TOP:
		rectResult.TopLeft () = rectToAlignBy.TopLeft ();
		rectResult.right = rectResult.left + rectToAlignBy.Width ();
		rectResult.bottom = rectResult.top + nCurrHeight;
		break;

	case CBRS_ALIGN_RIGHT:
		rectResult.BottomRight () = rectToAlignBy.BottomRight ();
		rectResult.top = rectResult.bottom - rectToAlignBy.Height ();
		rectResult.left = rectResult.right - nCurrWidth;
		break;
	case CBRS_ALIGN_BOTTOM:
		rectResult.BottomRight () = rectToAlignBy.BottomRight ();
		rectResult.left = rectResult.right - rectToAlignBy.Width ();
		rectResult.top = rectResult.bottom - nCurrHeight;	
		break;
	}

	
	if (bHorizontal)
	{		
		int nDelta = rectResult.Width () - rectToAlignBy.Width ();
		if (nDelta != 0)
		{
			rectResult.right += nDelta;
		}

		nDelta = rectResult.Height () - rectToAlignBy.Height ();
		if (nDelta > 0 && bResizable)
		{
			if (dwCurrAlignment & CBRS_ALIGN_TOP)
			{
				rectResult.bottom -= nDelta;
			}
			else if (dwCurrAlignment & CBRS_ALIGN_BOTTOM)
			{
				rectResult.top += nDelta;
			}
		}
	}
	else
	{
		int nDelta = rectResult.Height () - rectToAlignBy.Height ();
		if (nDelta != 0)
		{
			rectResult.bottom += nDelta;
		}

		nDelta = rectResult.Width () - rectToAlignBy.Width ();
		if (rectResult.Width () > rectToAlignBy.Width () && bResizable)
		{
			if (dwCurrAlignment & CBRS_ALIGN_LEFT)
			{
				rectResult.right -= nDelta;
			}
			else if (dwCurrAlignment & CBRS_ALIGN_RIGHT)
			{
				rectResult.left += nDelta;
			}
		}
	}
}
//----------------------------------------------------------------------------------//
BOOL CBCGPDockManager::SaveState (LPCTSTR lpszProfileName, UINT uiID)
{
	ASSERT_VALID (this);

	CString strProfileName = ::BCGPGetRegPath (strDockManagerProfile, lpszProfileName);

	BOOL bResult = FALSE;


	CString strSection;
	strSection.Format (REG_SECTION_FMT, strProfileName, uiID);

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

		if (pBarNext->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) ||
			pBarNext->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)) && 
			!pBarNext->IsKindOf (RUNTIME_CLASS (CBCGPToolBar)))
		{
			pBarNext->SaveState (lpszProfileName);
		}
	}

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

		ASSERT_VALID (pWnd);

		pWnd->SaveState (lpszProfileName);
	}

	try