bcgpdockmanager.cpp

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

	{
		CMemFile file;
		{
			CArchive ar (&file, CArchive::store);

			Serialize (ar);
			ar.Flush ();
		}

		UINT uiDataSize = file.GetLength ();
		LPBYTE lpbData = file.Detach ();

		if (lpbData != NULL)
		{
			CBCGPRegistrySP regSP;
			CBCGPRegistry& reg = regSP.Create (FALSE, FALSE);

			if (reg.CreateKey (strSection))
			{
				bResult = reg.Write (REG_ENTRY_DOCKING_CB_AND_SLIDERS, lpbData, uiDataSize);
			}

			free (lpbData);
		}
	}
	catch (CMemoryException* pEx)
	{
		pEx->Delete ();
		TRACE(_T ("Memory exception in CBCGPDockManager::SaveState ()!\n"));
	}

	return bResult;
}
//----------------------------------------------------------------------------------//
BOOL CBCGPDockManager::LoadState (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->LoadState (lpszProfileName);
		}
	}

	for (pos = m_lstAutoHideBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pBar = (CBCGPBaseControlBar*) 
										m_lstAutoHideBars.GetNext (pos);

		ASSERT_VALID (pBar);
		if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
		{
			CBCGPSlider* pSlider = DYNAMIC_DOWNCAST (CBCGPSlider, pBar);
			// SLIDER CONTAINS ONLY ONE BAR IN AUTOHIDE MODE
			pBar = (CBCGPBaseControlBar*) pSlider->GetFirstBar ();
			if (pBar != NULL && pBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
			{
				pBar->LoadState (lpszProfileName);
			}
		}
	}
	

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

		ASSERT_VALID (pWnd);

		pWnd->LoadState (lpszProfileName);
	}

	LPBYTE	lpbData = NULL;
	UINT	uiDataSize;

	CBCGPRegistrySP regSP;
	CBCGPRegistry& reg = regSP.Create (FALSE, TRUE);

	if (!reg.Open (strSection))
	{
		return FALSE;
	}

	if (!reg.Read (REG_ENTRY_DOCKING_CB_AND_SLIDERS, &lpbData, &uiDataSize))
	{
		return FALSE;
	}

	try
	{
		CMemFile file (lpbData, uiDataSize);
		CArchive ar (&file, CArchive::load);

		Serialize (ar);
		bResult = TRUE;
		m_bDisableSetDockState = FALSE;
	}
	catch (CMemoryException* pEx)
	{
		pEx->Delete ();
		TRACE(_T ("Memory exception in CBCGPDockManager::LoadState!\n"));
		m_bDisableSetDockState = TRUE;
	}
	catch (CArchiveException* pEx)
	{
		pEx->Delete ();
		TRACE(_T ("CArchiveException exception in CBCGPDockManager::LoadState ()!\n"));

		// destroy loaded sliders (docking control bars are loaded by ID's and have
		// been already created by application
		
		for (POSITION pos = m_lstLoadedBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = 
				(CBCGPBaseControlBar*) m_lstLoadedBars.GetNext (pos);
			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
			{
				pNextBar->DestroyWindow ();
			}
			else
			{
				pNextBar->SetRestoredFromRegistry (FALSE);
			}
		}
		
		m_lstLoadedBars.RemoveAll ();
		m_bDisableSetDockState = TRUE;
	}
	catch (...)
	{
		// destroy loaded sliders (docking control bars are loaded by ID's and have
		// been already created by application
		
		for (POSITION pos = m_lstLoadedBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = 
				(CBCGPBaseControlBar*) m_lstLoadedBars.GetNext (pos);
			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)))
			{
				pNextBar->DestroyWindow ();
			}
			else
			{
				pNextBar->SetRestoredFromRegistry (FALSE);
			}
		}
		
		m_lstLoadedBars.RemoveAll ();
		m_bDisableSetDockState = TRUE;
	}

	if (lpbData != NULL)
	{
		delete lpbData;
	}

	return bResult;

}
//----------------------------------------------------------------------------------//
void CBCGPDockManager::Serialize (CArchive& ar)
{
	// calculate or load the number of docking control bars and sliders
	int nCBCount = 0;
	int nNonFloatingBarCount = 0;

	if (ar.IsStoring ())
	{
		// get rid on non-valid empty tabbed bars
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseTabbedBar* pNextBar = 
				DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, m_lstControlBars.GetAt (pos));

			if (pNextBar != NULL && pNextBar->GetTabsNum () == 0 && pNextBar->CanFloat ())
			{
				m_lstControlBars.GetPrev (pos);
				pNextBar->UnDockControlBar (TRUE);
				if (pos == NULL)
				{
					pos = m_lstControlBars.GetHeadPosition ();
				}
			}
			if (pos != NULL)
			{
				m_lstControlBars.GetNext (pos);
			}
		}

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

			if (pNextMiniFrame != NULL)
			{
				pNextMiniFrame->RemoveNonValidBars ();
			}
		}

		for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = 
				(CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);

			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) && 
				pNextBar->CanFloat () ||
				pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider)) && 
				((CBCGPSlider*) pNextBar)->DoesContainFloatingBar ())
			{
				nCBCount++;
			}
			else
			{
				// static bar that may contain detachable/floating tabs
				if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPBaseTabbedBar)))
				{
					nNonFloatingBarCount++;
				}
			}
		}

		ar << nNonFloatingBarCount;

		for (pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = 
				(CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
			if (!pNextBar->CanFloat () && 
				pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPBaseTabbedBar)))
			{
				CBCGPBaseTabbedBar* pTabbedBar = 
					DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pNextBar);
				if (pTabbedBar != NULL)
				{
					ASSERT_VALID (pTabbedBar->GetUnderlinedWindow ());
					ar << pTabbedBar->GetDlgCtrlID ();
					pTabbedBar->GetUnderlinedWindow ()->Serialize (ar);
				}
			}
		}

		ar << nCBCount;

		// START from the tail, so the sliders and embedded containers
		// will be stored bedore their control bars

		for (pos = m_lstControlBars.GetTailPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = 
				(CBCGPBaseControlBar*) m_lstControlBars.GetPrev (pos);
			ASSERT_VALID (pNextBar);

			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) && 
				pNextBar->CanFloat ())
			{
				int nBarID = pNextBar->GetDlgCtrlID ();
				// write docking control bar tag and ID
				

				if (nBarID != -1)
				{
					ar << TRUE;
					ar << nBarID;
				}
				else 
				{
					// this is tab control bar - write its tabbed bar ids
					CBCGPBaseTabbedBar* pTabBar = 
						DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pNextBar);
					ASSERT_VALID (pTabBar);

					// use first child bar as identifier of the tab control bar
					CWnd* pWnd  = pTabBar->FindBarByTabNumber (0);
				
					// if pWnd is NULL - write nothing! because we do not allow empty tabbed 
					// bars
					if (pWnd != NULL)
					{
						int nTabbedBarID = pWnd->GetDlgCtrlID ();
						ASSERT (nTabbedBarID != -1);
						
						ar << TRUE;
						ar << nBarID; 
						ar << nTabbedBarID;
					}
				}
				continue;
			}
			else if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPSlider))
					&& ((CBCGPSlider*) pNextBar)->DoesContainFloatingBar ())
			{
				// write slider tag and serialize the slider
				ar << FALSE;

				CBCGPSlider* pSlider = DYNAMIC_DOWNCAST (CBCGPSlider, pNextBar);
				ASSERT_VALID (pSlider);

				pSlider->Serialize (ar);
			}
		}

		int nCountMiniFrames = 0;

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

			if (pWnd->GetControlBarCount () > 0)
			{
				nCountMiniFrames++;
			}
		}

		ar << nCountMiniFrames;

		for (pos = m_lstMiniFrames.GetHeadPosition (); pos != NULL;)
		{
			CBCGPMiniFrameWnd* pWnd = 
				DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, m_lstMiniFrames.GetNext (pos));
			ASSERT_VALID (pWnd);
			if (pWnd->GetControlBarCount () > 0)
			{
				ar << pWnd;
			}
		}

		// serialize autohide bars
	
		ar << m_lstAutoHideBars.GetCount ();

		for (pos = m_lstAutoHideBars.GetHeadPosition (); pos != NULL;)
		{
			BCGP_AUTOHIDEBAR_SAVE_INFO ahSaveInfo;

			CBCGPSlider* pSlider = 
				DYNAMIC_DOWNCAST (CBCGPSlider, m_lstAutoHideBars.GetNext (pos));

			if (pSlider == NULL)
			{
				ASSERT (FALSE);
				continue;
			}

			ahSaveInfo.m_pSavedBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pSlider->GetFirstBar ());

			if (ahSaveInfo.m_pSavedBar != NULL)
			{
				ahSaveInfo.Serilaize (ar);
			}
		}
	}
	else
	{
		m_lstLoadedBars.RemoveAll ();
		m_lstNonFloatingBars.RemoveAll ();
		m_lstLoadedAutoHideBarIDs.RemoveAll ();
		m_lstLoadedMiniFrames.RemoveAll ();

		UINT nBarID = (UINT) -1;

		ar >> nNonFloatingBarCount;

		for (int i = 0; i < nNonFloatingBarCount; i++)
		{
			ar >> nBarID;
			CBCGPBaseTabbedBar* pBar = DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, FindBarByID (nBarID, TRUE));
			if (pBar != NULL)
			{
				pBar->GetUnderlinedWindow ()->Serialize (ar);
				m_lstNonFloatingBars.AddTail (pBar);
			}
		}

		ar >> nCBCount;
		
		BOOL bIsDockingControlBar = FALSE;
		

		CBCGPSlider* pCurrentDefaultSlider = NULL;

		// the list was stored from the tail (to store sliders first)
		// therefore we need to add head
		for (i = 0; i < nCBCount; i++)
		{
			ar >> bIsDockingControlBar;

			if (bIsDockingControlBar)
			{
				ar >> nBarID;
				
				CBCGPDockingControlBar* pBar = NULL;
				if (nBarID != -1)
				{
					pBar = DYNAMIC_DOWNCAST (CBCGPDockingControlBar, FindBarByID (nBarID, TRUE));
				}
				else
				{
					// tab docking bar - load first child bar
					ar >> nBarID; 
					pBar = pCurrentDefaultSlider->FindTabbedBar (nBarID);
				}

				if (pBar != NULL)
				{
					ASSERT_VALID (pBar);

					if (pBar->IsAutoHideMode ())
					{
						pBar->SetAutoHideMode (FALSE, CBRS_ALIGN_ANY);
					}

					pBar->SetRestoredDefaultSlider (pCurrentDefaultSlider->m_hWnd);
					pBar->SetBarAlignment (pCurrentDefaultSlider->GetCurrentAlignment ());
					m_lstLoadedBars.AddHead (pBar);
				}
			}
			else
			{
				pCurrentDefaultSlider = new CBCGPSlider (TRUE, m_pParentWnd);
				pCurrentDefaultSlider->Serialize (ar);
				
				m_lstLoadedBars.AddHead (pCurrentDefaultSlider);
			}
		}

		int nMiniFrameCount = 0;

		ar >> nMiniFrameCount;

		for (i = 0; i < nMiniFrameCount; i++)
		{
			CBCGPMiniFrameWnd* pWnd = NULL;
			CBCGPMiniFrameWnd::m_pParentWndForSerialize = m_pParentWnd;
			ar >> pWnd;
			m_lstLoadedMiniFrames.AddTail (pWnd);
		}

		int nAHBarCount = 0;
		ar >> nAHBarCount;

		for (i = 0; i < nAHBarCount; i++)
		{
			BCGP_AUTOHIDEBAR_SAVE_INFO info;
			info.Serilaize (ar);
			m_lstLoadedAutoHideBarIDs.AddTail (info);
		}
	}
}
//----------------------------------------------------------------------------------//
void CBCGPDockManager::SetDockState ()
{
	if (m_bDisableSetDockState)
	{
		return;
	}

	if (m_lstLoadedBars.IsEmpty () && m_lstLoadedMiniFrames.IsEmpty () && 
		m_lstNonFloatingBars.IsEmpty () && m_lstLoadedAutoHideBarIDs.IsEmpty()  &&
		m_lstControlBars.IsEmpty ())
	{
		return;
	}

	m_bRestoringDockState = TRUE;