bcgpmultiminiframewnd.cpp

远程网络监视程序的源码

// BCGPMultiMiniFrameWnd.cpp : implementation file
//

#include "stdafx.h"
#include "bcgcbpro.h"
#include "BCGPMultiMiniFrameWnd.h"
#include "BCGPGlobalUtils.h"
#include "BCGPDockManager.h"
#include "BCGPDockingControlBar.h"
#include "BCGPSlider.h"

#include "BCGPBaseTabbedBar.h"

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

IMPLEMENT_SERIAL(CBCGPMultiMiniFrameWnd,CBCGPMiniFrameWnd,VERSIONABLE_SCHEMA | 2)

/////////////////////////////////////////////////////////////////////////////
// CBCGPMultiMiniFrameWnd

CBCGPMultiMiniFrameWnd::CBCGPMultiMiniFrameWnd()
{
	
}

CBCGPMultiMiniFrameWnd::~CBCGPMultiMiniFrameWnd()
{
}


BEGIN_MESSAGE_MAP(CBCGPMultiMiniFrameWnd, CBCGPMiniFrameWnd)
	//{{AFX_MSG_MAP(CBCGPMultiMiniFrameWnd)
	ON_WM_CREATE()
	ON_WM_SIZE()
	ON_WM_SIZING()
	ON_WM_GETMINMAXINFO()
	ON_WM_LBUTTONDBLCLK()
	ON_MESSAGE(WM_IDLEUPDATECMDUI, OnIdleUpdateCmdUI)
	//}}AFX_MSG_MAP
	ON_REGISTERED_MESSAGE(BCGPM_CHECKEMPTYMINIFRAME, OnCheckEmptyState)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CBCGPMultiMiniFrameWnd message handlers

int CBCGPMultiMiniFrameWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CBCGPMiniFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	m_barContainerManager.Create (this, NULL);
	
	return 0;
}

//********************************************************************************
// Should return TRUE if no docking occures!!!
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::DockFrame (CBCGPMiniFrameWnd* pDockedFrame, 
										BCGP_DOCK_METHOD dockMethod)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pDockedFrame);

	CBCGPMultiMiniFrameWnd* pMultiDockedFrame = 
		DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, pDockedFrame);

	if (pMultiDockedFrame == NULL)
	{
		// we can dock only multi mini frame windows! 
		//(their dock bars have CBRS_FLOAT_MULTI style)
		return TRUE;
	}

	CBCGPDockingControlBar* pTargetControlBar = NULL;
	BOOL bTabArea = FALSE;
	BOOL bCaption = FALSE;
	DWORD dwAlignment = CBRS_ALIGN_LEFT;

	CPoint pt;
	GetCursorPos (&pt);

	if (dockMethod == DM_MOUSE || dockMethod == DM_STANDARD)
	{
		CBCGPGlobalUtils globalUtils;
		if (!globalUtils.GetCBAndAlignFromPoint (m_barContainerManager, pt, 
									&pTargetControlBar, dwAlignment, bTabArea, bCaption))
		{
			return TRUE;
		}
	}

	if (pTargetControlBar == NULL || dwAlignment == 0)
	{
		return TRUE;
	}

	CBCGPBarContainerManager& barManager = pMultiDockedFrame->GetContainerManager ();
	CWnd* pFirstDockedBar = barManager.GetFirstVisibleBar ();

	if ((bTabArea || bCaption) && pTargetControlBar != NULL)  
		
	{
		// if the first bar is a tabbed bar it will be destroyed when adding to tab wnd
		// we need to take one of its tabs
		CBCGPBaseTabbedBar* pTabbedBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pFirstDockedBar);

		if (pTabbedBar != NULL)
		{
			int iTabNum = -1; 
			pFirstDockedBar = pTabbedBar->GetFirstVisibleTab (iTabNum);
		}

		if (!m_barContainerManager.AddContainerManagerToTabWnd (pTargetControlBar, barManager))
		{
			return TRUE;
		}
	}
	else
	{
		if (!m_barContainerManager.AddContainerManager (pTargetControlBar, dwAlignment, 
														barManager, TRUE))
		{	
			return TRUE;
		}
	}

	HWND hDockedFrame = pDockedFrame->m_hWnd;
	pMultiDockedFrame->SendMessage (BCGPM_CHECKEMPTYMINIFRAME);
	if (IsWindow (hDockedFrame))
	{
		pMultiDockedFrame->MoveWindow (pMultiDockedFrame->GetRecentFloatingRect ());
	}

	OnBarRecalcLayout ();

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

	OnSetRollUpTimer ();

	return FALSE;
}
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::DockBar (CBCGPDockingControlBar* pDockedBar)
{
	CPoint pt;
	GetCursorPos (&pt);

	BOOL bTabArea = FALSE;
	BOOL bCaption = FALSE;
	CBCGPDockingControlBar* pTargetControlBar = NULL;
	DWORD dwAlignment = 0;

	CBCGPGlobalUtils globalUtils;
	if (!globalUtils.GetCBAndAlignFromPoint (m_barContainerManager, pt, 
									&pTargetControlBar, dwAlignment, bTabArea, bCaption))
	{
		return TRUE;
	}

	if (pTargetControlBar == NULL || dwAlignment == 0)
	{
		return TRUE;
	}

	pDockedBar->UnDockControlBar (FALSE);

	pDockedBar->SetParent (this);
	BOOL bResult = m_barContainerManager.InsertControlBar (pDockedBar, 
		pTargetControlBar, dwAlignment);

	if (!bResult)
	{
		ASSERT (FALSE);
	}

	if (bResult)
	{
		AddRemoveBarFromGlobalList (pDockedBar, TRUE);
		CheckGripperVisibility ();
		OnBarRecalcLayout ();
		SendMessage (WM_NCPAINT);
	}

	OnSetRollUpTimer ();

	return !bResult;
}
//********************************************************************************
CBCGPDockingControlBar* CBCGPMultiMiniFrameWnd::DockControlBarStandard (BOOL& bWasDocked)
{
	if (!OnBeforeDock ())
	{
		return NULL;
	}

	CBCGPBaseControlBar* pTargetControlBar = m_dragFrameImpl.m_pFinalTargetBar;
	BCGP_PREDOCK_STATE state = m_dragFrameImpl.m_bDockToTab ? PDS_DOCK_TO_TAB : PDS_DOCK_REGULAR;
	
	CBCGPMiniFrameWnd* pParentMiniFrame = NULL; 

	if (pTargetControlBar != NULL)
	{
		pParentMiniFrame = pTargetControlBar->GetParentMiniFrame ();
	}

	if (pParentMiniFrame == NULL)
	{
		bWasDocked = !SetPreDockState (state, pTargetControlBar, DM_STANDARD);
	}
	else
	{
		CBCGPMultiMiniFrameWnd* pParentMultiMiniFrame = 
			DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, pParentMiniFrame);
		if (pParentMultiMiniFrame != NULL && 
			pParentMultiMiniFrame != this)
		{
			bWasDocked = !pParentMultiMiniFrame->DockFrame (this, DM_STANDARD);
		}
	}

	return NULL;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnSetRollUpTimer ()
{
	CObList lstControlBars; 
	m_barContainerManager.AddControlBarsToList (&lstControlBars, NULL);	

	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);

		if (pNextBar != NULL && pNextBar->GetBCGStyle () & CBRS_BCGP_AUTO_ROLLUP)
		{
			SetRollUpTimer ();	
			break;
		}
	}
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnKillRollUpTimer ()
{
	CObList lstControlBars; 
	m_barContainerManager.AddControlBarsToList (&lstControlBars, NULL);

	BOOL bThereIsRollupState = FALSE;
	for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
	{
		CBCGPBaseControlBar* pNextBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseControlBar, lstControlBars.GetNext (pos));
		ASSERT_VALID (pNextBar);

		if (pNextBar != NULL && pNextBar->GetBCGStyle () & CBRS_BCGP_AUTO_ROLLUP)
		{
			bThereIsRollupState = TRUE;
			break;
		}
	}

	if (!bThereIsRollupState)
	{
		KillRollupTimer ();
	}
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::AddControlBar (CBCGPBaseControlBar* pWnd)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pWnd);
	ASSERT_KINDOF (CBCGPDockingControlBar, pWnd);

	CBCGPDockingControlBar* pBar = DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pWnd);

	if (m_barContainerManager.IsEmpty ())
	{
		m_barContainerManager.AddControlBar (pBar);
		CBCGPMiniFrameWnd::AddControlBar (pWnd);
	}

	OnSetRollUpTimer ();
}
//********************************************************************************
BOOL CBCGPMultiMiniFrameWnd::AddRecentControlBar (CBCGPDockingControlBar* pBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	
	CBCGPBarContainer* pRecentContainer = pBar->m_recentDockInfo.GetRecentContainer (FALSE);
	CBCGPBarContainer* pRecentTabContainer = pBar->m_recentDockInfo.GetRecentTabContainer (FALSE);
	if (pRecentContainer != NULL)
	{
		pBar->SetParent (this);
		AddRemoveBarFromGlobalList (pBar, TRUE);
		CBCGPDockingControlBar* pAddedBar = m_barContainerManager.AddControlBarToRecentContainer (pBar, pRecentContainer);

		CWnd* pEmbeddedWnd = CWnd::FromHandlePermanent (m_hEmbeddedBar);

		if (pAddedBar != NULL && pEmbeddedWnd == NULL)
		{
			m_hEmbeddedBar = pAddedBar->GetSafeHwnd ();
		}
		if (m_barContainerManager.GetVisibleBarCount () == 1 && 
			pBar == pAddedBar)
		{
			MoveWindow (m_rectRecentFloatingRect);
		}
		if (pAddedBar != NULL)
		{
			OnShowControlBar (pAddedBar, TRUE);
		}
	}
	else if (pRecentTabContainer != NULL)
	{
		pBar->SetParent (this);
		AddRemoveBarFromGlobalList (pBar, TRUE);
		BOOL bRecentLeftBar = pBar->m_recentDockInfo.IsRecentLeftBar (FALSE);
		CBCGPDockingControlBar* pTabbedBar = (CBCGPDockingControlBar*) (bRecentLeftBar ? 
			pRecentTabContainer->GetLeftBar () : pRecentTabContainer->GetRightBar ());
		if (pTabbedBar != NULL)
		{
			CBCGPDockingControlBar* pCreatedTabbedBar = NULL;
			pBar->AttachToTabWnd (pTabbedBar, DM_DBL_CLICK, TRUE, &pCreatedTabbedBar);

			pTabbedBar->ShowControlBar (TRUE, FALSE, TRUE);
			OnBarRecalcLayout ();		
		}
		else
		{
			CBCGPDockingControlBar* pAddedBar = m_barContainerManager.AddControlBarToRecentContainer (pBar, pRecentTabContainer);
			OnShowControlBar (pAddedBar, TRUE);
		}
	}
	else
	{
		ASSERT (FALSE);
		return FALSE;
	}
	OnSetRollUpTimer ();
	return TRUE;
}
//********************************************************************************
void CBCGPMultiMiniFrameWnd::OnSize(UINT nType, int cx, int cy) 
{
	CWnd::OnSize(nType, cx, cy);

	OnBarRecalcLayout ();

	ArrangeCaptionButtons ();
	SendMessage (WM_NCPAINT);