bcgpmultiminiframewnd.cpp

远程网络监视程序的源码

}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnSizing(UINT fwSide, LPRECT pRect) 
{
	CWnd::OnSizing(fwSide, pRect);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnBarRecalcLayout ()
{
	ASSERT_VALID (this);

	CRect rect;
	GetClientRect (rect);
	HDWP hdwp = ::BeginDeferWindowPos (20);
	m_barContainerManager.ResizeBarContainers (rect, hdwp);
	EndDeferWindowPos (hdwp);	
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::RemoveControlBar (CBCGPBaseControlBar* pBar, BOOL bDestroy,
											   BOOL bNoDelayedDestroy)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);

	if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
	{
		m_barContainerManager.RemoveControlBarFromContainer ((CBCGPDockingControlBar*) pBar);
		if (!m_barContainerManager.IsEmpty ())
		{
			CBCGPMiniFrameWnd::ReplaceControlBar (pBar, m_barContainerManager.GetFirstBar ());
		}
		else
		{
			// do not destroy the miniframe in the base class
			CBCGPMiniFrameWnd::RemoveControlBar (pBar, FALSE);

			// if embedded bar has became NULL set it to the first bar in the container
			CWnd* pEmbeddedWnd = CWnd::FromHandlePermanent (m_hEmbeddedBar);
			if (pEmbeddedWnd == NULL)
			{
				m_hEmbeddedBar = m_barContainerManager.GetFirstBar ()->GetSafeHwnd ();
			}
		}
	}
	
	if (bDestroy && GetControlBarCount () == 0)
	{
		PostMessage (BCGPM_CHECKEMPTYMINIFRAME);
	}
	else
	{
		CheckGripperVisibility ();
		OnBarRecalcLayout ();
		SendMessage (WM_NCPAINT);
	}

	OnKillRollUpTimer ();
}
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::SetPreDockState (BCGP_PREDOCK_STATE preDockState, 
											  CBCGPBaseControlBar* pBarToDock, 
											  BCGP_DOCK_METHOD dockMethod)
{
	ASSERT_VALID (this);

	if (preDockState == PDS_NOTHING || 
		preDockState == PDS_DOCK_TO_TAB && 
		pBarToDock != NULL && 
		!pBarToDock->CanBeAttached ())
	{
		return TRUE;
	}


	CBCGPDockingControlBar* pTargetDockBar = 
		DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pBarToDock);


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

	CWnd* pFirstDockedBar = m_barContainerManager.GetFirstVisibleBar ();

	// determine dock alignment and edge
	CPoint pt;
	GetCursorPos (&pt);

	DWORD dwAlignment = 0;

	CObList lstControlBars; 
	m_barContainerManager.AddControlBarsToList (&lstControlBars, NULL);

	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);
		
		pNextBar->StoreRecentDockInfo ();
	}
	
	if (pTargetDockBar != NULL)
	{
		CBCGPBaseControlBar* pHeadBar = m_barContainerManager.GetFirstBar ();
		
		if (pHeadBar == NULL || !pTargetDockBar->CanAcceptBar (pHeadBar) || 
			!pHeadBar->CanAcceptBar (pTargetDockBar))
		{
			return TRUE;
		}

		if (!pHeadBar->IsBarVisible () && m_barContainerManager.GetBarCount () == 1 && 
			pHeadBar->GetDockMode () == DT_STANDARD)
		{
			// the head bar is unvisible and there is only one bar in container manager
			// means that this bar was torn off from the tab window and its parent miniframe
			// is hidden
			pHeadBar->ModifyStyle (0, WS_VISIBLE);
		}


		BOOL bOuterEdge = FALSE;
		if (preDockState == PDS_DOCK_REGULAR && 
			!globalUtils.CheckAlignment (pt, pTargetDockBar, 
										 CBCGPDockManager::m_nDockSencitivity, 
										 bOuterEdge, dwAlignment))
		{
			// unable for some reason to determine alignment
			return TRUE;
		}

		if (preDockState == PDS_DOCK_REGULAR)
		{
			if (!pTargetDockBar->DockContainer (m_barContainerManager, dwAlignment, dockMethod))
			{
				return TRUE;
			}
		}
		else if (preDockState == PDS_DOCK_TO_TAB)
		{
			for (pos = lstControlBars.GetHeadPosition (); pos != NULL;)
			{
				CBCGPDockingControlBar* pNextBar = 
					DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
				ASSERT_VALID (pNextBar);
				
				AddRemoveBarFromGlobalList (pNextBar, FALSE);
				pNextBar->AttachToTabWnd (pTargetDockBar, dockMethod);
			}

			ShowWindow (SW_HIDE);
			MoveWindow (GetRecentFloatingRect ());
			CBCGPMiniFrameWnd::OnCancelMode(); 
			SendMessage (BCGPM_CHECKEMPTYMINIFRAME);
			return TRUE;
		}
		else
		{
			return TRUE;
		}
	}
	else // dock to frame window - need to create a new default slider
	{
		BOOL bOuterEdge = FALSE;
		if (!pDockManager->IsPointNearDockBar (pt, dwAlignment, bOuterEdge))
		{
			return TRUE;
		}

		CBCGPSlider* pSlider = 
			CBCGPDockingControlBar::CreateDefaultSlider (dwAlignment, GetParent ());

		if (pSlider == NULL)
		{
			return TRUE;
		}

		pSlider->SetBarAlignment (dwAlignment);

		CRect rectContainer;
		m_barContainerManager.GetWindowRect (rectContainer);
		pDockManager->AdjustRectToClientArea (rectContainer, dwAlignment);
		HDWP hdwp = NULL;
		m_barContainerManager.ResizeBarContainers (rectContainer, hdwp);

		if (bOuterEdge)
		{
			// register slider with the dock manager
			pDockManager->AddControlBar (pSlider, !bOuterEdge, FALSE, bOuterEdge);
			pSlider->AddContainer (m_barContainerManager, bOuterEdge);
		}
		else
		{
			pSlider->AddContainer (m_barContainerManager, FALSE);
			pDockManager->AddControlBar (pSlider);
		}
	}

	// FINALLY destroy the frame - 
	// all its bars should have been docked (and therefore removed)
	HWND hwndSave = m_hWnd;
	SendMessage (BCGPM_CHECKEMPTYMINIFRAME);

	if (IsWindow (hwndSave))
	{
		MoveWindow (m_rectRecentFloatingRect);
	}
	

	if (pFirstDockedBar != NULL && dockMethod == DM_MOUSE)
	{
		pFirstDockedBar->ScreenToClient (&pt);
		if (pFirstDockedBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
		{
			((CBCGPDockingControlBar*)pFirstDockedBar)->EnterDragMode (FALSE);
		}
		else
		{
			pFirstDockedBar->SendMessage (WM_LBUTTONDOWN, 0, MAKELPARAM (pt.x, pt.y));
		}
	}

	// adjust the docking layout
	if (pTargetDockBar != NULL)
	{
		pTargetDockBar->RecalcLayout ();
	}
	else if (pFirstDockedBar != NULL)
	{
		CBCGPDockingControlBar* pDockingBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pFirstDockedBar);
		if (pDockingBar != NULL)
		{
			pDockingBar->AdjustDockingLayout ();
			pDockingBar->SetFocus ();
		}
	}

	OnSetRollUpTimer ();

	return FALSE;
}
//*************************************************************************************
BOOL CBCGPMultiMiniFrameWnd::SaveState (LPCTSTR lpszProfileName, UINT uiID)
{
	ASSERT_VALID (this);
	CObList& lstControlBars = m_barContainerManager.m_lstControlBars;
	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);

		pNextBar->SaveState (lpszProfileName, uiID);
	}	
	return TRUE;
}
//*************************************************************************************
BOOL CBCGPMultiMiniFrameWnd::LoadState (LPCTSTR lpszProfileName, UINT uiID)
{
	ASSERT_VALID (this);
	CObList& lstControlBars = m_barContainerManager.m_lstControlBars;
	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);

		pNextBar->LoadState (lpszProfileName, uiID);
	}	
	return TRUE;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::Serialize (CArchive& ar)
{
	ASSERT_VALID (this);
	CBCGPMiniFrameWnd::Serialize (ar);
	m_barContainerManager.Serialize (ar);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::SetDockState (CBCGPDockManager* pDockManager)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pDockManager);

	CObList lstBarsToRemove;
	if (!m_barContainerManager.IsEmpty ())
	{
		// float each control bar, reparent it and set its window position
		CObList& lstControlBars = m_barContainerManager.m_lstControlBars;
		for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPDockingControlBar* pNextBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
			ASSERT_VALID (pNextBar);

			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPBaseTabbedBar)))
			{
				BOOL bLeftBar = FALSE;
				CBCGPBarContainer* pContainer = 
					m_barContainerManager.FindContainer (pNextBar, bLeftBar);

				ASSERT (pContainer != NULL);

				CList<UINT, UINT>* pListBarIDs = 
					pContainer->GetAssociatedSiblingBarIDs (pNextBar);

				if (pListBarIDs != NULL)
				{
					for (POSITION pos = pListBarIDs->GetHeadPosition (); pos != NULL;)
					{
						UINT nIDNext = pListBarIDs->GetNext (pos);
						CBCGPBaseControlBar* pBarToAttach = pDockManager->FindBarByID (nIDNext, TRUE);

						if (pBarToAttach == NULL)
						{
							continue;
						}

						if (pBarToAttach->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)) && 
							((CBCGPDockingControlBar*)pBarToAttach)->IsAutoHideMode ())
						{
							((CBCGPDockingControlBar*)pBarToAttach)->SetAutoHideMode (FALSE, CBRS_ALIGN_ANY);
						}

						if (pBarToAttach->IsTabbed ())
						{
							CBCGPBaseTabWnd* pTabWnd = 
									(CBCGPBaseTabWnd*) pBarToAttach->GetParent ();
							CBCGPBaseTabbedBar* pTabBar = (CBCGPBaseTabbedBar*)
									pTabWnd->GetParent ();	
							ASSERT_VALID (pTabBar);

							pBarToAttach->SetParent (this);
							pTabBar->RemoveControlBar (pBarToAttach);
						}
						else
						{
							// float this bar in case if was docked somewhere else
							pBarToAttach->FloatControlBar (CRect (0, 0, 10, 10), DM_SHOW, false);
						}
						CBCGPMiniFrameWnd* pParentMiniFrame = pBarToAttach->GetParentMiniFrame ();

						if (pParentMiniFrame != NULL && pParentMiniFrame != this)
						{
							pParentMiniFrame->RemoveControlBar (pBarToAttach);	
						}

						((CBCGPDockingControlBar*) pBarToAttach)->
							AttachToTabWnd (pNextBar, DM_UNKNOWN, FALSE);

						pParentMiniFrame->PostMessage (BCGPM_CHECKEMPTYMINIFRAME);
					}
				}

				if (((CBCGPBaseTabbedBar*)pNextBar)->GetTabsNum () == 0)
				{
					lstBarsToRemove.AddTail (pNextBar);
				}
				else
				{
					((CBCGPBaseTabbedBar*)pNextBar)->ApplyRestoredTabInfo ();
					pNextBar->RecalcLayout ();
				}
				continue;
			}