bcgpbarcontainermanager.cpp

远程网络监视程序的源码

// BCGBarContainerManager.cpp: implementation of the CBCGPBarContainerManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "BCGPControlBar.h"
#include "BCGPDockingControlBar.h"
#include "BCGPBaseTabbedBar.h"
#include "BCGPSlider.h"
#include "BCGPBarContainerManager.h"
#include "BCGPBarContainer.h"
#include "BCGPDockManager.h"
#include "BCGPGlobalUtils.h"
#include "BCGPMiniFrameWnd.h"
#include "BCGPMultiMiniFrameWnd.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

static int g_nSliderSpacingForMove = 4;

static int g_nSliderID = 1;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBCGPBarContainerManager::CBCGPBarContainerManager() : m_pRootContainer (NULL), 
													 m_pDockSite (NULL), 
													 m_pContainerRTC (NULL), 
													 m_pDefaultSlider (NULL),
													 m_bDestroyRootContainer (TRUE)
{
	
}

CBCGPBarContainerManager::~CBCGPBarContainerManager()
{
	// should not be destroyed when the rrot container is "exported" to another 
	// manager (when one multi miniframe is docked to another multi miniframe)
	if (m_bDestroyRootContainer)
	{
		for (POSITION pos = m_lstSliders.GetHeadPosition (); pos != NULL;)
		{
			CBCGPSlider* pSlider = 
				DYNAMIC_DOWNCAST (CBCGPSlider, m_lstSliders.GetNext (pos));
			if (pSlider != NULL)
			{
				pSlider->SetContainerManager (NULL);
			}
		}
		if (m_pRootContainer != NULL)
		{
			delete m_pRootContainer;
		}
	}
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::Create (CWnd* pParentWnd, 
									   CBCGPSlider* pDefaultSlider,
									  CRuntimeClass* pContainerRTC)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pParentWnd);
	m_pDockSite = pParentWnd;
	m_pContainerRTC = pContainerRTC;


	ASSERT (m_pRootContainer == NULL);

	if (m_pContainerRTC != NULL)
	{
		m_pRootContainer = (CBCGPBarContainer*) m_pContainerRTC->CreateObject ();
		m_pRootContainer->SetContainerManager (this);
	}
	else
	{
		m_pRootContainer = new CBCGPBarContainer (this);
	}

	m_pDefaultSlider = pDefaultSlider;
	return TRUE;
}
//-----------------------------------------------------------------------------------//
void CBCGPBarContainerManager::AddControlBar (CBCGPDockingControlBar* pControlBarToAdd)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pControlBarToAdd); 
	ASSERT_KINDOF (CBCGPDockingControlBar, pControlBarToAdd);

	m_pRootContainer->SetBar (pControlBarToAdd, TRUE);
	m_lstControlBars.AddTail (pControlBarToAdd);
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::AddContainerManager (CBCGPBarContainerManager& srcManager, 
													BOOL bOuterEdge)
{
	ASSERT_VALID (this);
	ASSERT (m_pRootContainer != NULL);

	if (!m_pRootContainer->IsContainerEmpty ())
	{
		return FALSE;
	}

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (m_pDockSite);
	if (pDockManager == NULL)
	{
		ASSERT (FALSE);
		return FALSE;
	}

	m_lstControlBars.RemoveAll ();
	m_lstSliders.RemoveAll ();

	srcManager.AddControlBarsToList (&m_lstControlBars, &m_lstSliders);
	srcManager.RemoveAllControlBarsAndSliders ();

	// we must copy containers before SetParent, because Copy sets recent dock info
	// internally and we need the "old" parent for that
	CBCGPBarContainer* pNewContainer = srcManager.m_pRootContainer->Copy (m_pRootContainer);
	m_pRootContainer->SetContainer (pNewContainer, TRUE);
	pNewContainer->SetContainerManager (this, TRUE);


	globalUtils.SetNewParent (m_lstControlBars, m_pDockSite);
	globalUtils.SetNewParent (m_lstSliders, m_pDockSite);

	for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar,  m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pBar);
		// move them out of screen
		CRect rect;
		pBar->GetWindowRect (rect);
		pBar->GetParent ()->ScreenToClient (rect);
		rect.OffsetRect (-rect.Width (), rect.Height ());
		pBar->MoveWindow (rect);
	}

	// set new container manager for each slider
	for (pos = m_lstSliders.GetHeadPosition (); pos != NULL;)
	{
		CBCGPSlider* pSlider = (CBCGPSlider*) m_lstSliders.GetNext (pos);
		ASSERT_VALID (pSlider);

		pSlider->SetContainerManager (this);
	}


	// finally, enable caption for each control bar in the container manager
	for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar,  m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pBar);

		pBar->SetDefaultSlider (m_pDefaultSlider->m_hWnd);	
		pBar->SetBarAlignment (m_pDefaultSlider->GetCurrentAlignment ());
		pDockManager->AddControlBar (pBar, !bOuterEdge, FALSE, bOuterEdge);

		pBar->EnableGripper (TRUE);
	}

	m_pRootContainer->CheckSliderVisibility ();
	m_pRootContainer->CalculateRecentSize ();

	return TRUE;
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::AddContainerManager (CBCGPDockingControlBar* pTargetControlBar, 
													DWORD dwAlignment, 
													CBCGPBarContainerManager& srcManager, 
													BOOL bCopy)
{
	CObList lstControlBars;
	CObList lstSliders;

	srcManager.AddControlBarsToList (&lstControlBars, &lstSliders);

	BOOL bLeftBar = FALSE;
	CBCGPBarContainer* pContainer = FindContainer (pTargetControlBar, bLeftBar);

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

	POSITION posTargetBar = m_lstControlBars.Find (pTargetControlBar);

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

	CBCGPBarContainer* pNewContainer = NULL;
	
	if (!bCopy)
	{
		pNewContainer = srcManager.m_pRootContainer;
	}
	else
	{
		// we must copy containers before SetParent, because Copy sets recent dock info
		// internally and we need the "old" parent for that
		pNewContainer = srcManager.m_pRootContainer->Copy (m_pRootContainer);
		pNewContainer->SetContainerManager (this, TRUE);
		srcManager.RemoveAllControlBarsAndSliders ();
	}

	CWnd* pOldParent = srcManager.GetDockSite ();

	globalUtils.SetNewParent (lstControlBars, m_pDockSite);
	globalUtils.SetNewParent (lstSliders, m_pDockSite);
	
	if (!AddControlBarAndContainer (pTargetControlBar, pNewContainer, dwAlignment))
	{
		// reparent back
		globalUtils.SetNewParent (lstControlBars, pOldParent);
		globalUtils.SetNewParent (lstSliders, pOldParent);
		return FALSE;
	}

	BOOL bInsertBefore = (dwAlignment & CBRS_ALIGN_TOP) || (dwAlignment & CBRS_ALIGN_LEFT);

	// add/insert control bars and sliders from the manager is being added
	if (bInsertBefore)
	{
		for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CWnd* pWnd = (CWnd*) lstControlBars.GetNext (pos);
			m_lstControlBars.InsertBefore (posTargetBar, pWnd);
		}
	}
	else
	{
		for (POSITION pos = lstControlBars.GetTailPosition (); pos != NULL;)
		{
			CWnd* pWnd = (CWnd*) lstControlBars.GetPrev (pos);
			m_lstControlBars.InsertAfter (posTargetBar, pWnd);
		}
	}

	m_lstSliders.AddTail (&lstSliders);

	// set new container manager for each slider
	for (POSITION pos = lstSliders.GetHeadPosition (); pos != NULL;)
	{
		CBCGPSlider* pSlider = (CBCGPSlider*) lstSliders.GetNext (pos);
		ASSERT_VALID (pSlider);

		pSlider->SetContainerManager (this);
	}
	
	if (!bCopy)
	{
		srcManager.m_bDestroyRootContainer = FALSE;
		srcManager.m_pRootContainer->SetContainerManager (this, TRUE);
	}

	// finally, enable caption for each control bar in the container manager
	for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar,  m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pBar);
		
		pBar->EnableGripper (TRUE);
		pBar->RedrawWindow ();
	}

	m_pRootContainer->CheckSliderVisibility ();
	m_pRootContainer->CalculateRecentSize ();
	
	return TRUE;
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::AddContainerManagerToTabWnd (CBCGPDockingControlBar* pTargetControlBar, 
															CBCGPBarContainerManager& srcManager)
{
	CObList lstControlBars;

	srcManager.AddControlBarsToList (&lstControlBars, NULL);

	BOOL bLeftBar = FALSE;
	CBCGPBarContainer* pContainer = FindContainer (pTargetControlBar, bLeftBar);

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

	POSITION posTargetBar = m_lstControlBars.Find (pTargetControlBar);

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

	CBCGPBaseTabbedBar* pTabbedBar = DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pTargetControlBar);
	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
		if (pBar != NULL)
		{
			if (pTabbedBar == NULL)
			{
				pBar->AttachToTabWnd (pTargetControlBar, DM_MOUSE, TRUE, 
										(CBCGPDockingControlBar**) &pTabbedBar);
			}
			else
			{
				pBar->AttachToTabWnd (pTabbedBar, DM_MOUSE, TRUE, 
										(CBCGPDockingControlBar**) &pTabbedBar);
			}
		}
	}

	return TRUE;
}
//-----------------------------------------------------------------------------------//
BOOL CBCGPBarContainerManager::InsertControlBar (CBCGPDockingControlBar* pControlBarToInsert,
												 CBCGPDockingControlBar* pTargetControlBar,
												 DWORD dwAlignment,
												 LPCRECT lpRect,
												 BCGP_DOCK_METHOD /*dockMethod*/)
{
	ASSERT_VALID (this);
	ASSERT (m_pRootContainer != NULL);
	ASSERT_VALID (pControlBarToInsert); 
	ASSERT_KINDOF (CBCGPDockingControlBar, pControlBarToInsert);

	BOOL bResult = FALSE;
	if (pTargetControlBar != NULL)
	{
		POSITION pos = m_lstControlBars.Find (pTargetControlBar);
		if (pos != NULL)
		{
			bResult = AddControlBarAndSlider (pTargetControlBar, pControlBarToInsert, 
												pos, dwAlignment);
		}
		else
		{
			TRACE0 ("TargetControlBar does not belong to the container. Docking failed\n");
			ASSERT (FALSE);
		}
	}
	return bResult;
}
//-----------------------------------------------------------------------------------//
CBCGPDockingControlBar* CBCGPBarContainerManager::AddControlBarToRecentContainer 
													(CBCGPDockingControlBar* pBarToAdd, 
													 CBCGPBarContainer* pRecentContainer)
{
	ASSERT_VALID (this);
	ASSERT_KINDOF (CBCGPDockingControlBar, pBarToAdd);
	ASSERT_VALID (pRecentContainer);

	CBCGPBarContainer::BC_FIND_CRITERIA searchType = 
							CBCGPBarContainer::BC_FIND_BY_CONTAINER;

	CBCGPBarContainer* pContainer = 
		m_pRootContainer->FindSubContainer (pRecentContainer, searchType);

	if (pContainer == NULL)
	{
		return NULL;
	}
	
	if (!pContainer->IsContainerEmpty () && pContainer->GetSlider () == NULL)
	{
		CBCGPSlider* pSlider = CreateSlider (pContainer->GetRecentSliderRect (), 
											  pContainer->GetRecentSliderStyle ());
		pContainer->SetSlider (pSlider);
	}
	
	if (pContainer->IsContainerEmpty ())
	{
		// this container becomes non-empty
		// we need to ckeck parent containers in order to ensure their 
		// slider existance
		CBCGPBarContainer* pParentContainer = pContainer->GetParentContainer ();
		while (pParentContainer != m_pRootContainer &&
				pParentContainer != NULL)
		{
			if (pParentContainer->GetSlider () == NULL && 
				pParentContainer->GetRecentSliderStyle () != 0)
			{
				CBCGPSlider* pSlider = CreateSlider (pParentContainer->GetRecentSliderRect (), 
													 pParentContainer->GetRecentSliderStyle ());
				pParentContainer->SetSlider (pSlider);
			}
			pParentContainer = pParentContainer->GetParentContainer ();
		}
	}

	BOOL bDockSiteIsMiniFrame = m_pDockSite->
			IsKindOf (RUNTIME_CLASS (CBCGPMiniFrameWnd));
	CObList lstRecentListOfBars; 
	lstRecentListOfBars.AddTail (&pBarToAdd->m_recentDockInfo.GetRecentListOfBars (!bDockSiteIsMiniFrame));
	// scan recent list of bars and look for the bar to insert after
	POSITION posRecent = lstRecentListOfBars.Find (pBarToAdd);

	// it may be different from pBarToAdd in case of tabbed window
	CBCGPDockingControlBar* pAddedBar = pContainer->AddControlBar (pBarToAdd);
	if (pAddedBar == pBarToAdd)
	{
		m_pRootContainer->CheckSliderVisibility ();

		while (posRecent != NULL)
		{
			CBCGPDockingControlBar* p = 
				(CBCGPDockingControlBar*) lstRecentListOfBars.GetPrev (posRecent);

			ASSERT_VALID (p);

			POSITION posCurrent = m_lstControlBars.Find (p);
			if (posCurrent != NULL)
			{
				m_lstControlBars.InsertAfter (posCurrent, pAddedBar);
				return pAddedBar;
			}
		}

		m_lstControlBars.AddHead (pAddedBar);

		return pAddedBar;
	}
	

	return pAddedBar;
}
//-----------------------------------------------------------------------------------//