bcgpmultiminiframewnd.cpp

远程网络监视程序的源码

			if (pNextBar->IsTabbed ())
			{
				CBCGPBaseTabWnd* pTabWnd = (CBCGPBaseTabWnd*) pNextBar->GetParent ();
				CBCGPBaseTabbedBar* pTabBar = (CBCGPBaseTabbedBar*) pTabWnd->GetParent ();	
				ASSERT_VALID (pTabBar);
				// set belong to any parent
				pNextBar->SetParent (GetParent ());
				pTabBar->RemoveControlBar (pNextBar);
				if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
				{
					((CBCGPDockingControlBar*) pNextBar)->EnableGripper (TRUE);
				}

				pNextBar->ShowWindow (SW_SHOW);
			}

			if (pNextBar->IsAutoHideMode ())
			{
				pNextBar->SetAutoHideMode (FALSE, CBRS_ALIGN_ANY);
			}
			
			CRect rectDummy;
			pNextBar->GetWindowRect (rectDummy);
			pNextBar->FloatControlBar (rectDummy, DM_SHOW, false);

			CBCGPMiniFrameWnd* pParentMiniFrame = pNextBar->GetParentMiniFrame ();
			if (pParentMiniFrame != NULL)
			{
				pNextBar->SetParent (this);
				pParentMiniFrame->RemoveControlBar (pNextBar);

				CRect rect = pNextBar->m_rectSavedDockedRect;
			
				pNextBar->SetWindowPos (NULL, rect.left, rect.top, rect.Width (), rect.Height (),
											SWP_NOZORDER | SWP_FRAMECHANGED  | SWP_NOACTIVATE);
			}
		}

		for (pos = lstBarsToRemove.GetHeadPosition (); pos != NULL;)
		{
			CBCGPDockingControlBar* pNextBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstBarsToRemove.GetNext (pos));
			RemoveControlBar (pNextBar);
			pNextBar->DestroyWindow ();
		}

		// retake the list
		CObList& lstModifiedControlBars = m_barContainerManager.m_lstControlBars;

		if (lstModifiedControlBars.IsEmpty ())
		{
			SendMessage (BCGPM_CHECKEMPTYMINIFRAME);
			return;
		}

		for (pos = lstModifiedControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPDockingControlBar* pNextBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstModifiedControlBars.GetNext (pos));
			ASSERT_VALID (pNextBar);

			pNextBar->ShowControlBar (pNextBar->GetRecentVisibleState (), FALSE, FALSE);
			AddRemoveBarFromGlobalList (pNextBar, TRUE);
		}

		// set embedded bar to the first bar in the container
		CBCGPBaseControlBar* pEmbeddedBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, lstControlBars.GetHead ());
		if (pEmbeddedBar != NULL)
		{
			if (lstControlBars.GetCount () > 1)
			{
				m_hEmbeddedBar = pEmbeddedBar->GetSafeHwnd ();	
			}
			else
			{
				CString strText;
				pEmbeddedBar->GetWindowText (strText);
				SetWindowText (strText);

				SetIcon (pEmbeddedBar->GetIcon (FALSE), FALSE);
				SetIcon (pEmbeddedBar->GetIcon (TRUE), TRUE);
			}
		}
		OnSetRollUpTimer ();
		SetCaptionButtons (m_dwCaptionButtons);
		OnBarRecalcLayout ();
		return;
	}

	// if we're here the miniframe is empty and should be destroyed
	PostMessage (BCGPM_CHECKEMPTYMINIFRAME);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) 
{
	CSize sizeBase;

	m_barContainerManager.GetMinSize (sizeBase);
	CalcMinSize (sizeBase, lpMMI);

	CWnd::OnGetMinMaxInfo(lpMMI);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnShowControlBar (CBCGPDockingControlBar* pBar, BOOL bShow)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);

	m_barContainerManager.OnShowControlBar (pBar, bShow);

	if (bShow)
	{
		ShowWindow (SW_SHOWNOACTIVATE);
	}
	else if (!m_barContainerManager.IsRootContainerVisible ())
	{
		ShowWindow (SW_HIDE);
	}
	
	CheckGripperVisibility ();

	OnBarRecalcLayout ();

	// redraw caption to reflect the number of visible bars and set the recent pos
	SetWindowPos (NULL, 0, 0, 0, 0, 
					SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::CloseMiniFrame ()
{
	if (OnCloseMiniFrame ())
	{
		ShowWindow (SW_HIDE);
		m_barContainerManager.HideAll ();
	}
}

//********************************************************************************
void CBCGPMultiMiniFrameWnd::CheckGripperVisibility ()
{
	if (IsWindowVisible ())
	{
		int nVisibleCount = m_barContainerManager.GetVisibleBarCount ();

		if (nVisibleCount == 1) // take off caption from this bar
		{
			CBCGPDockingControlBar* pVisibleBar = DYNAMIC_DOWNCAST (CBCGPDockingControlBar, 
								m_barContainerManager.GetFirstVisibleBar ());

			if (pVisibleBar != NULL)
			{
				pVisibleBar->EnableGripper (FALSE);
			}
		}
		else
		{
			m_barContainerManager.EnableGrippers (TRUE);
		}
	}
}
//********************************************************************************
CString CBCGPMultiMiniFrameWnd::GetCaptionText ()
{
	CString strCaptionText;
	if (m_barContainerManager.GetVisibleBarCount () == 1)
	{
		CWnd* pVisibleBar = DYNAMIC_DOWNCAST (CWnd, m_barContainerManager.GetFirstVisibleBar ());

		if (pVisibleBar != NULL)
		{
			pVisibleBar->GetWindowText (strCaptionText);
		}
	}

	return strCaptionText;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnLButtonDblClk(UINT nFlags, CPoint point)
{
	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 ();
	}

	for (pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPDockingControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);
		
		AddRemoveBarFromGlobalList (pNextBar, FALSE);
		pNextBar->DockControlBar (pNextBar, NULL, DM_DBL_CLICK);
	}
	
	SendMessage (BCGPM_CHECKEMPTYMINIFRAME);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::SaveRecentFloatingState ()
{
	GetWindowRect (m_rectRecentFloatingRect);
	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->m_recentDockInfo.m_rectRecentFloatingRect = m_rectRecentFloatingRect;
	}
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::StoreRecentDockInfo (CBCGPControlBar* pBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	ASSERT_KINDOF (CBCGPDockingControlBar, pBar);

	CBCGPDockingControlBar* pDockingBar = 
		DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pBar);

	if (pDockingBar == NULL)
	{
		return;
	}

	BOOL bLeftBar = TRUE;
	CBCGPBarContainer* pRecentContainer = 
		m_barContainerManager.FindContainer (pDockingBar, bLeftBar);

	pDockingBar->m_recentDockInfo.StoreDockInfo (pRecentContainer);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::StoreRecentTabRelatedInfo (CBCGPDockingControlBar* pDockingBar, 
													CBCGPDockingControlBar* pTabbedBar)
{
	BOOL bLeftBar = TRUE;
	CBCGPBarContainer* pRecentContainer = 
		m_barContainerManager.FindContainer (pTabbedBar, bLeftBar);

	pDockingBar->m_recentDockInfo.StoreDockInfo (pRecentContainer, pTabbedBar);
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::DockRecentControlBarToMainFrame (CBCGPDockingControlBar* pBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	AddRemoveBarFromGlobalList (pBar, FALSE);
	pBar->DockControlBar (pBar, NULL, DM_DBL_CLICK);	
}
//********************************************************************************
LRESULT CBCGPMultiMiniFrameWnd::OnCheckEmptyState (WPARAM, LPARAM)
{
	if (m_barContainerManager.m_pRootContainer != NULL)
	{
		m_barContainerManager.m_pRootContainer->ReleaseEmptyContainer ();
	}
	if (m_barContainerManager.GetNodeCount () == 0 ||
		m_barContainerManager.GetNodeCount () == 1 && 
		m_barContainerManager.m_pRootContainer != NULL &&
		m_barContainerManager.m_pRootContainer->GetRefCount () == 0 && 
		m_barContainerManager.m_pRootContainer->IsContainerEmpty ())
	{
		CBCGPMiniFrameWnd::OnCancelMode(); 
		DestroyWindow ();
	}
	else if (m_barContainerManager.GetVisibleBarCount () == 0)
	{
		ShowWindow (SW_HIDE);
		CBCGPMiniFrameWnd::OnCancelMode(); 
	}
	return 0;
}
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::InsertControlBar (CBCGPBaseControlBar* pControlBar, 
												CBCGPBaseControlBar* pTarget, BOOL bAfter)
{
	AddRemoveBarFromGlobalList (pControlBar, TRUE);
	return TRUE;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::CalcExpectedDockedRect (CWnd* pWndToDock, CPoint ptMouse,
													 CRect& rectResult, BOOL& bDrawTab, 
													 CBCGPDockingControlBar** ppTargetBar)
{
	CBCGPGlobalUtils globalUtils;	
	if (m_bRolledUp)
	{
		// can't dock on rolled up miniframe
		bDrawTab = FALSE;
		rectResult.SetRectEmpty ();
		return;
	}
	globalUtils.CalcExpectedDockedRect (m_barContainerManager, pWndToDock, 
										ptMouse, rectResult, bDrawTab, ppTargetBar);
}
//********************************************************************************
CBCGPBaseControlBar* CBCGPMultiMiniFrameWnd::ControlBarFromPoint (CPoint point, int nSencitivity,
																BOOL bCheckVisibility)
{
	if (bCheckVisibility && !IsWindowVisible ())
	{
		return NULL;
	}
	BOOL bTabArea = FALSE; 
	BOOL bCaption = FALSE;
	return m_barContainerManager.ControlBarFromPoint (point, nSencitivity, TRUE, bTabArea, bCaption);
}
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::CanBeDockedToBar (const CBCGPDockingControlBar* pDockingBar) const
{
	for (POSITION pos = m_barContainerManager.m_lstControlBars.GetHeadPosition (); 
			pos != NULL;)
	{
		CBCGPDockingControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, 
								m_barContainerManager.m_lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);
		
		if (pDockingBar->CanAcceptBar (pNextBar) && 
			pNextBar->CanAcceptBar (pDockingBar))
		{
			return TRUE;
		}
	}

	return FALSE;
}
//********************************************************************************
LRESULT CBCGPMultiMiniFrameWnd::OnIdleUpdateCmdUI(WPARAM wParam, LPARAM)
{
	CBCGPMiniFrameWnd::OnIdleUpdateCmdUI (wParam, 0);
	return 0L;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::ReplaceControlBar (CBCGPBaseControlBar* pBarOrg, 
												CBCGPBaseControlBar* pBarReplaceWith)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBarOrg);
	ASSERT_VALID (pBarReplaceWith);
	ASSERT_KINDOF (CBCGPDockingControlBar, pBarReplaceWith);
	
	m_barContainerManager.ReplaceControlBar ((CBCGPDockingControlBar*) pBarOrg, 
											 (CBCGPDockingControlBar*) pBarReplaceWith);
}
//********************************************************************************
CWnd* CBCGPMultiMiniFrameWnd::GetControlBar () const
{
	CWnd* pWnd = CBCGPMiniFrameWnd::GetControlBar ();
	if (pWnd == NULL)
	{
		pWnd = GetFirstVisibleBar ();
	}
	return pWnd;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::RemoveNonValidBars ()
{
	m_barContainerManager.RemoveNonValidBars ();
}