bcgpdockmanager.cpp

远程网络监视程序的源码

// BCGPDockManager.cpp: implementation of the CBCGPDockManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "BCGPGlobalUtils.h"
#include "BCGPDockBar.h"
#include "BCGPDockingControlBar.h"
#include "BCGPSlider.h"

#include "BCGPAutoHideDockBar.h"
#include "BCGPAutoHideToolBar.h"
#include "BCGPAutoHideButton.h"

#include "BCGPDockManager.h"
#include "BCGPMiniFrameWnd.h"
#include "BCGPMultiMiniFrameWnd.h"
#include "BCGPTabbedControlBar.h"
#include "BCGPMDIChildWnd.h"

#include "BCGPCaptionBar.h"

#include "RegPath.h"
#include "BCGPRegistry.h"

#include "BCGPStatusBar.h"
#include "BCGPDockBarRow.h"

#include "BCGPReBar.h"

#pragma warning (disable : 4706)

#include "multimon.h"

#pragma warning (default : 4706)


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

#define REG_SECTION_FMT						_T("%sBCGPDockManager-%d")
#define REG_ENTRY_DOCKING_CB_AND_SLIDERS	_T ("DockingCBAndSliders")

static const CString strDockManagerProfile	= _T("BCGPDockManagers");

const DWORD dwDockBarMap[4][2] =
{
	{ AFX_IDW_DOCKBAR_TOP,      CBRS_TOP    },
	{ AFX_IDW_DOCKBAR_BOTTOM,   CBRS_BOTTOM },
	{ AFX_IDW_DOCKBAR_LEFT,     CBRS_LEFT   },
	{ AFX_IDW_DOCKBAR_RIGHT,    CBRS_RIGHT  },
};

UINT CBCGPDockManager::g_nTimeOutBeforeToolBarDock = 200;
UINT CBCGPDockManager::g_nTimeOutBeforeDockingBarDock = 220;

BCGP_DOCK_TYPE	CBCGPDockManager::m_dockModeGlobal = DT_STANDARD;
UINT			CBCGPDockManager::m_ahSlideModeGlobal = BCGP_AHSM_MOVE;
int				CBCGPDockManager::m_nDockSencitivity = 15;
BOOL			CBCGPDockManager::m_bRestoringDockState = FALSE;
BOOL			CBCGPDockManager::m_bHideDockingBarsInContainerMode = TRUE;
BOOL			CBCGPDockManager::m_bDisableRecalcLayout = FALSE;
BOOL			CBCGPDockManager::m_bFullScreenMode = FALSE;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CBCGPDockManager::CBCGPDockManager() : m_pParentWnd (NULL)
{
	m_dwEnabledDockBars = 0;
	m_dwEnabledSlideBars = 0;
	m_pActiveSlidingWnd = NULL;

	m_pLastTargetBar = NULL;
	m_pLastMultiMiniFrame = NULL;
	m_clkLastTime = 0;
	m_statusLast = CS_NOTHING;

	m_rectDockBarBounds.SetRectEmpty ();
	m_rectClientAreaBounds.SetRectEmpty ();
	m_rectOuterEdgeBounds.SetRectEmpty ();

	m_bIsPrintPreviewMode = FALSE;
	m_bEnableAdjustLayout = TRUE;

	m_bLockUpdate = FALSE;
	m_bAdjustingBarLayout = FALSE;
	m_bRecalcLayout = FALSE;
	m_bSizeFrame = FALSE;

	m_bIsOLEContainerMode = FALSE;
	m_bDisableSetDockState = FALSE;

	m_bIsOLEInPlaceActivate = FALSE;
}
//------------------------------------------------------------------------//
CBCGPDockManager::~CBCGPDockManager()
{

}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::Create (CFrameWnd* pParentWnd)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pParentWnd);
	m_pParentWnd = pParentWnd;

	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::EnableDocking (DWORD dwStyle)
{
	BCGP_DOCKBAR_INFO info;
	if (dwStyle & CBRS_ALIGN_TOP && (m_dwEnabledDockBars & CBRS_ALIGN_TOP) == 0)
	{
		info.m_dwBarAlignment = CBRS_ALIGN_TOP;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledDockBars |= CBRS_ALIGN_TOP;
	}

	if (dwStyle & CBRS_ALIGN_BOTTOM && (m_dwEnabledDockBars & CBRS_ALIGN_BOTTOM) == 0)
	{
		info.m_dwBarAlignment = CBRS_ALIGN_BOTTOM;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledDockBars |= CBRS_ALIGN_BOTTOM;
	}

	if (dwStyle & CBRS_ALIGN_LEFT && (m_dwEnabledDockBars & CBRS_ALIGN_LEFT) == 0)
	{
		info.m_dwBarAlignment = CBRS_ALIGN_LEFT;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledDockBars |= CBRS_ALIGN_LEFT;
	}

	if (dwStyle & CBRS_ALIGN_RIGHT && (m_dwEnabledDockBars & CBRS_ALIGN_RIGHT) == 0)
	{
		info.m_dwBarAlignment = CBRS_ALIGN_RIGHT;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledDockBars |= CBRS_ALIGN_RIGHT;
	}
	AdjustDockingLayout ();

	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::EnableAutoHideBars (DWORD dwStyle)
{
	BCGP_DOCKBAR_INFO info;

	if (dwStyle & CBRS_ALIGN_TOP && (m_dwEnabledSlideBars & CBRS_ALIGN_TOP) == 0)
	{
		if ((m_dwEnabledDockBars & CBRS_ALIGN_TOP) == 0)
		{
			EnableDocking (CBRS_ALIGN_TOP);
		}
		info.m_dwBarAlignment = CBRS_ALIGN_TOP;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPAutoHideDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledSlideBars |= CBRS_ALIGN_TOP;
	}

	if (dwStyle & CBRS_ALIGN_BOTTOM  && (m_dwEnabledSlideBars & CBRS_ALIGN_BOTTOM) == 0)
	{
		if ((m_dwEnabledDockBars & CBRS_ALIGN_BOTTOM) == 0)
		{
			EnableDocking (CBRS_ALIGN_BOTTOM);
		}

		info.m_dwBarAlignment = CBRS_ALIGN_BOTTOM;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPAutoHideDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledSlideBars |= CBRS_ALIGN_BOTTOM;
	}

	if (dwStyle & CBRS_ALIGN_LEFT && (m_dwEnabledSlideBars & CBRS_ALIGN_LEFT) == 0)
	{
		if ((m_dwEnabledDockBars & CBRS_ALIGN_LEFT) == 0)
		{
			EnableDocking (CBRS_ALIGN_LEFT);
		}

		info.m_dwBarAlignment = CBRS_ALIGN_LEFT;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPAutoHideDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledSlideBars |= CBRS_ALIGN_LEFT;
	}

	if (dwStyle & CBRS_ALIGN_RIGHT && (m_dwEnabledSlideBars & CBRS_ALIGN_RIGHT) == 0)
	{
		if ((m_dwEnabledDockBars & CBRS_ALIGN_RIGHT) == 0)
		{
			EnableDocking (CBRS_ALIGN_RIGHT);
		}

		info.m_dwBarAlignment = CBRS_ALIGN_RIGHT;
		info.pDockBarRTC = RUNTIME_CLASS (CBCGPAutoHideDockBar);
		if (!AddDockBar (info))
		{
			return FALSE;
		}
		m_dwEnabledSlideBars |= CBRS_ALIGN_RIGHT;
	}
	
	AdjustDockingLayout ();
	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::AddDockBar (const BCGP_DOCKBAR_INFO& info, 
										 CBCGPDockBar** ppDockBar)
{
	ASSERT_VALID (this);

	if (ppDockBar != NULL)
	{
		*ppDockBar = NULL;
	}

	CBCGPDockBar* pDockBar = (CBCGPDockBar*) info.pDockBarRTC->CreateObject ();
	ASSERT_VALID (pDockBar);
	if (pDockBar->Create (info.m_dwBarAlignment, CRect (0, 0, 0, 0), m_pParentWnd, 0))
	{
		m_lstControlBars.AddTail (pDockBar);
	}
	else
	{
		TRACE0 ("Failed to create DockBar");
		delete pDockBar;
		return FALSE;
	}

	if (ppDockBar != NULL)
	{
		*ppDockBar = pDockBar;
	}

	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::InsertDockBar (const BCGP_DOCKBAR_INFO& info, 
										 DWORD dwAlignToInsertAfter, 
										 CBCGPDockBar** ppDockBar)
{
	ASSERT_VALID (this);

	if (ppDockBar != NULL)
	{
		*ppDockBar = NULL;
	}

	CBCGPDockBar* pDockBar = (CBCGPDockBar*) info.pDockBarRTC->CreateObject ();
	ASSERT_VALID (pDockBar);
	if (pDockBar->Create (info.m_dwBarAlignment, CRect (0, 0, 0, 0), m_pParentWnd, 0))
	{
		BOOL bInserted = FALSE;
		for (POSITION pos = m_lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPBaseControlBar* pNextBar = (CBCGPBaseControlBar*) m_lstControlBars.GetNext (pos);
			ASSERT_VALID (pNextBar);
			
			if (pNextBar->IsKindOf (RUNTIME_CLASS (CBCGPDockBar)) &&
				pNextBar->GetCurrentAlignment () == (dwAlignToInsertAfter & CBRS_ALIGN_ANY) && 
				pos != NULL)
			{
				m_lstControlBars.InsertBefore (pos, pDockBar);
				bInserted = TRUE;
				break;
			}
		}

		if (!bInserted)
		{
			m_lstControlBars.AddTail (pDockBar);
		}				
	}
	else
	{
		TRACE0 ("Failed to create DockBar");
		delete pDockBar;
		return FALSE;
	}

	if (ppDockBar != NULL)
	{
		*ppDockBar = pDockBar;
	}

	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::AddControlBar (CBCGPBaseControlBar* pWnd, BOOL bTail, BOOL bAutoHide, 
									  BOOL bInsertForOuterEdge)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pWnd);

	CObList& lstBars = bAutoHide ? m_lstAutoHideBars : m_lstControlBars;

	if (lstBars.Find (pWnd))
	{
		TRACE0 ("Control bar already added!!!\n");
		ASSERT (FALSE);
		return FALSE;
	}

	if (bTail)
	{
		lstBars.AddTail (pWnd);
	}
	else if (bInsertForOuterEdge)
	{
		// find first control bar with the same alignment and insert before it
		for (POSITION pos = lstBars.GetHeadPosition (); pos != NULL;)
		{
			POSITION posSave = pos;
			CBCGPBaseControlBar* pNextBar = 
				DYNAMIC_DOWNCAST (CBCGPBaseControlBar, m_lstControlBars.GetNext (pos));
			ASSERT_VALID (pNextBar);

			if (pNextBar->DoesAllowDynInsertBefore ())
			{
				lstBars.InsertBefore (posSave, pWnd);
				return TRUE;
			}
		}

		lstBars.AddTail (pWnd);
	}
	else
	{
		lstBars.AddHead (pWnd);
	}

	pWnd->m_pDockSite = m_pParentWnd;

	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::InsertControlBar (CBCGPBaseControlBar* pControlBar, 
										     CBCGPBaseControlBar* pTarget, BOOL bAfter)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pControlBar);	

	if (m_lstControlBars.Find (pControlBar))
	{
		TRACE0 ("Control bar already added!!!\n");
		ASSERT (FALSE);
		return FALSE;
	}

	POSITION pos = m_lstControlBars.Find (pTarget);
	if (pos == NULL)
	{
		TRACE0 ("Control bar does not exist in the control container!!!\n");
		ASSERT (FALSE);
		return FALSE;
	}

	if (bAfter)
	{
		m_lstControlBars.InsertAfter (pos, pControlBar);
	}
	else
	{
		m_lstControlBars.InsertBefore (pos, pControlBar);
	}
	return TRUE;
}
//------------------------------------------------------------------------//
void CBCGPDockManager::RemoveControlBarFromDockManager (CBCGPBaseControlBar* pWnd, BOOL bDestroy,
										 BOOL bAdjustLayout, BOOL bAutoHide)
{
	CObList& lstBars = bAutoHide ? m_lstAutoHideBars : m_lstControlBars;

	POSITION pos = lstBars.Find (pWnd);
	if (pos != NULL)
	{
		lstBars.RemoveAt (pos);
		if (bDestroy)
		{
			pWnd->DestroyWindow ();
		}

		if (bAdjustLayout)
		{
			AdjustDockingLayout ();
		}
	}
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::AddMiniFrame (CBCGPMiniFrameWnd* pWnd)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pWnd);

	POSITION pos = m_lstMiniFrames.Find (pWnd);

	if (pos != NULL)
	{
		return FALSE;
	}

	m_lstMiniFrames.AddTail (pWnd);
	return TRUE;
}
//------------------------------------------------------------------------//
BOOL CBCGPDockManager::RemoveMiniFrame (CBCGPMiniFrameWnd* pWnd)
{
	ASSERT_VALID (this);

	POSITION pos = m_lstMiniFrames.Find (pWnd);
	if (pos != NULL)
	{
		m_lstMiniFrames.RemoveAt (pos);
		return TRUE;
	}

	return FALSE;
}
//------------------------------------------------------------------------//
CBCGPBaseControlBar* CBCGPDockManager::ControlBarFromPoint (CPoint point, int nSensitivity, 
															   bool bExactBar, 
															   CRuntimeClass* pRTCBarType, 
															   BOOL bCheckVisibility, 
															   const CBCGPBaseControlBar* pBarToIgnore) const
{
	ASSERT_VALID (this);
	
	CBCGPMiniFrameWnd* pFrame = FrameFromPoint (point, NULL, TRUE);
	if (pFrame != NULL)
	{
		CBCGPBaseControlBar* pBar = 
			pFrame->ControlBarFromPoint (point, nSensitivity, bCheckVisibility);
		if (pBar != NULL && pBar != pBarToIgnore && 
			(pRTCBarType == NULL || pBar->IsKindOf (pRTCBarType)))
		{
			return pBar;
		}
	}

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

		if ((pRTCBarType == NULL || pNextBar->IsKindOf (pRTCBarType)))  
		{
			if (bCheckVisibility && !pNextBar->IsBarVisible () ||
				pNextBar == pBarToIgnore)
			{
				continue;
			}
			
			CRect rectWnd;
			pNextBar->GetWindowRect (rectWnd);
			if (!bExactBar)
			{
				rectWnd.InflateRect (nSensitivity, nSensitivity);
			}