bcgpbasetabbedbar.cpp

远程网络监视程序的源码

// BCGPBaseTabbedBar.cpp : implementation file
//

#include "stdafx.h"
#include "bcgcbpro.h"
#include "BCGPBaseTabWnd.h"
#include "BCGPBaseTabbedBar.h"
#include "BCGPMiniFrameWnd.h"
#include "BCGPMultiMiniFrameWnd.h"
#include "BCGPDockingCBWrapper.h"
#include "BCGPAutoHideToolBar.h"
#include "BCGPDockBar.h"

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

IMPLEMENT_DYNAMIC(CBCGPBaseTabbedBar, CBCGPDockingControlBar)

/////////////////////////////////////////////////////////////////////////////
// CBCGPBaseTabbedBar

CBCGPBaseTabbedBar::CBCGPBaseTabbedBar (BOOL bAutoDestroy)
{
	m_bAutoDestroy = bAutoDestroy;
	m_pTabWnd = NULL;
	m_bEnableIDChecking = FALSE;
	m_bSetCaptionTextToTabName = TRUE;

	EnableDocking (CBRS_ALIGN_ANY);
}
//***********************************************************************************
CBCGPBaseTabbedBar::~CBCGPBaseTabbedBar()
{
}

BEGIN_MESSAGE_MAP(CBCGPBaseTabbedBar, CBCGPDockingControlBar)
	//{{AFX_MSG_MAP(CBCGPBaseTabbedBar)
	ON_WM_SIZE()
	ON_WM_NCDESTROY()
	ON_WM_ERASEBKGND()
	ON_WM_SETFOCUS()
	//}}AFX_MSG_MAP
	ON_REGISTERED_MESSAGE(BCGM_CHANGE_ACTIVE_TAB, OnChangeActiveTab)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CBCGPBaseTabbedBar message handlers

void CBCGPBaseTabbedBar::OnSize(UINT nType, int cx, int cy) 
{
	CBCGPDockingControlBar::OnSize(nType, cx, cy);
	
	CWnd* pUnderlinedWnd = GetUnderlinedWindow ();

	if (pUnderlinedWnd != NULL && IsWindow (pUnderlinedWnd->GetSafeHwnd ()))
	{
		CRect rectClient;
		GetClientRect (rectClient);
		
		pUnderlinedWnd->SetWindowPos (NULL, 0, 0, rectClient.Width (), rectClient.Height (), 
								SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW);
	}
}
//***********************************************************************************
void CBCGPBaseTabbedBar::OnNcDestroy() 
{
	if (m_pTabWnd != NULL)
	{
		delete m_pTabWnd;
		m_pTabWnd = NULL;
	}

	CBCGPDockingControlBar::OnNcDestroy();
	
	if (m_bAutoDestroy)
	{
		delete this;
	}
}
//***********************************************************************************
BOOL CBCGPBaseTabbedBar::OnEraseBkgnd(CDC* pDC) 
{
	return TRUE; 
}
//***********************************************************************************
BOOL CBCGPBaseTabbedBar::AddTab (CWnd* pNewBar, BOOL bVisible, BOOL bSetActive, 
								 BOOL bDetachable)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pTabWnd);
	ASSERT_VALID (pNewBar);

	if (pNewBar->IsKindOf (RUNTIME_CLASS (CBCGPBaseTabbedBar)))
	{
		CBCGPBaseTabbedBar* pTabbedControlBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pNewBar);

		// it's false when the tabbed bar is added from miniframe to docksite
		BOOL bSetInfoForSlider = (GetParentMiniFrame () != NULL);

		ASSERT_VALID (pTabbedControlBar);

		CBCGPBaseTabWnd* pWndTab = pTabbedControlBar->GetUnderlinedWindow ();
		
		ASSERT_VALID (pWndTab);

		int nTabsNum = pWndTab->GetTabsNum ();
		ASSERT (nTabsNum > 0);

		for (int i = 0; i < nTabsNum; i++)
		{
			CBCGPBaseControlBar* pWnd = 
				DYNAMIC_DOWNCAST (CBCGPBaseControlBar, pWndTab->GetTabWnd (i));
			ASSERT_VALID (pWnd);

			BOOL bVisible = pWndTab->IsTabVisible (i);
			BOOL bDetachable = pWndTab->IsTabDetachable (i);

			pWnd->EnableGripper (FALSE);

			if (!AddTab (pWnd, bVisible, bVisible, bDetachable))
			{
				ASSERT (FALSE);
			}

			CBCGPDockingControlBar* pDockingBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pWnd);
			if (pWnd != NULL)
			{
				pDockingBar->m_recentDockInfo.SetInfo (bSetInfoForSlider, 
														pTabbedControlBar->m_recentDockInfo);
			}
		}

		pWndTab->RemoveAllTabs ();
		pNewBar->DestroyWindow ();

		// stop processing - this function will be called 
		// from AttachToTabWnd

		return FALSE;
	}
	else
	{
		if (pNewBar->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)))
		{
			CBCGPControlBar* pNewControlBar = 
				DYNAMIC_DOWNCAST (CBCGPControlBar, pNewBar);
			ASSERT_VALID (pNewControlBar);

			CWnd* pOldParent = pNewControlBar->GetParent ();
			pNewControlBar->OnBeforeChangeParent (m_pTabWnd, TRUE);
			pNewControlBar->SetParent (m_pTabWnd);
			pNewControlBar->OnAfterChangeParent (pOldParent);

			if (pNewControlBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
			{
				((CBCGPDockingControlBar*) pNewControlBar)->EnableGripper (FALSE);
			}
		}

		CString strText; 
		pNewBar->GetWindowText (strText);

		m_pTabWnd->AddTab (pNewBar, strText, bSetActive, bDetachable);

		int iTab = m_pTabWnd->GetTabsNum () - 1;
		m_pTabWnd->SetTabHicon (iTab, pNewBar->GetIcon (FALSE));
		m_pTabWnd->EnableTabDetach (iTab, bDetachable);

		if (bVisible)
		{
			if (bSetActive)
			{
				m_pTabWnd->SetActiveTab (iTab);
			}
		}
		else
		{
			ASSERT (!bSetActive);
			m_pTabWnd->ShowTab (iTab, FALSE);
		}
	}
	return TRUE;
}

//**************************************************************************************
CWnd* CBCGPBaseTabbedBar::FindBarByID (UINT uBarID)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pTabWnd);

	for (int i = 0; i < m_pTabWnd->GetTabsNum (); i++)
	{
		CWnd* pBar = m_pTabWnd->GetTabWnd (i);
		ASSERT_VALID (pBar);

		if ((UINT) pBar->GetDlgCtrlID () == uBarID)
		{
			return pBar;
		}
	}

	return NULL;
}
//**************************************************************************************
CWnd* CBCGPBaseTabbedBar::FindBarByTabNumber (int nTabNum, BOOL bGetWrappedBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pTabWnd);

	if (nTabNum < 0 || nTabNum >= m_pTabWnd->GetTabsNum ())
	{
		return NULL;
	}

	CWnd* pWnd = m_pTabWnd->GetTabWnd (nTabNum);
	ASSERT_VALID (pWnd);

	if (bGetWrappedBar && pWnd->IsKindOf (RUNTIME_CLASS (CBCGPDockingCBWrapper)))
	{
		CBCGPDockingCBWrapper* pWrapper = 
			DYNAMIC_DOWNCAST (CBCGPDockingCBWrapper, pWnd);
		pWnd = pWrapper->GetWrappedWnd ();
		ASSERT_VALID (pWnd);
	}

	return pWnd;
}
//*******************************************************************************
BOOL CBCGPBaseTabbedBar::DetachControlBar (CWnd* pBar, BOOL bHide)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	ASSERT_VALID (m_pTabWnd);

	int nTabNumber = m_pTabWnd->GetTabFromHwnd (pBar->GetSafeHwnd ());

	if (nTabNumber < 0)
	{
		return FALSE;
	}

	m_pTabWnd->DetachTab (DM_UNKNOWN, nTabNumber, bHide);
	return TRUE;
}
//*******************************************************************************
BOOL CBCGPBaseTabbedBar::RemoveControlBar (CWnd* pBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	ASSERT_VALID (m_pTabWnd);

	int nTabNumber = m_pTabWnd->GetTabFromHwnd (pBar->GetSafeHwnd ());

	if (nTabNumber < 0 || nTabNumber >= m_pTabWnd->GetTabsNum ())
	{
		return FALSE;
	}

	m_pTabWnd->RemoveTab (nTabNumber);

	if (m_pTabWnd->GetTabsNum () == 0)
	{
		if (AllowDestroyEmptyTabbedBar ())
		{
			if (IsDocked ())
			{
				UnDockControlBar ();
			}
			else
			{
				CBCGPMiniFrameWnd* pMiniFrame = GetParentMiniFrame ();
				pMiniFrame->RemoveControlBar (this);
			}

			DestroyWindow ();
			return FALSE;
		}
		else 
		{
			m_pTabWnd->ShowWindow (SW_HIDE);
		}
	}

	return TRUE;
}
//*******************************************************************************
BOOL CBCGPBaseTabbedBar::ShowTab (CWnd* pBar, BOOL bShow, BOOL bDelay, BOOL bActivate)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	ASSERT_VALID (m_pTabWnd);
	
	int nTabNum = m_pTabWnd->GetTabFromHwnd (pBar->GetSafeHwnd ());

	BOOL bResult = m_pTabWnd->ShowTab (nTabNum, bShow, !bDelay, bActivate);

	BOOL bNowVisible = m_pTabWnd->GetVisibleTabsNum () > 0;

	CBCGPDockingControlBar::ShowControlBar (bNowVisible, bDelay, bActivate);
	return bResult;
}
//*******************************************************************************
BOOL CBCGPBaseTabbedBar::FloatTab (CWnd* pBar, int nTabID, 
									  BCGP_DOCK_METHOD dockMethod, 
									  BOOL bHide)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBar);
	ASSERT_VALID (m_pTabWnd);

	CString strWndText;
	pBar->GetWindowText (strWndText);

	if (strWndText.IsEmpty ())
	{
		if (m_pTabWnd->GetTabLabel (nTabID, strWndText))
		{
			pBar->SetWindowText (strWndText);
		}
	}

	m_pTabWnd->RemoveTab (nTabID);
	
	if (dockMethod == DM_MOUSE)
	{
		m_pTabWnd->SendMessage (WM_LBUTTONUP, 0, 0);
	}

	CBCGPDockingControlBar* pDockingBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pBar);

	if (pDockingBar != NULL)
	{
		pDockingBar->StoreRecentTabRelatedInfo ();
	}

	if (dockMethod == DM_DBL_CLICK && pDockingBar != NULL)
	{
		CBCGPMultiMiniFrameWnd* pParentMiniFrame = 
				DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, GetParentMiniFrame ());

		if (pParentMiniFrame != NULL)
		{
			pParentMiniFrame->DockRecentControlBarToMainFrame (pDockingBar);
			return TRUE;
		}
		else if (m_hDefaultSlider != NULL && IsWindow (m_hDefaultSlider))
		{
			CBCGPMultiMiniFrameWnd* pRecentMiniFrame = 
				DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd,
					CWnd::FromHandlePermanent (pDockingBar->m_recentDockInfo.m_hRecentMiniFrame));
			if (pRecentMiniFrame != NULL && 
				pRecentMiniFrame->AddRecentControlBar (pDockingBar))
			{
				return TRUE;
			}
		}
	}

	if (pBar->IsKindOf (RUNTIME_CLASS (CBCGPControlBar)))
	{
		CBCGPControlBar* pControlBar = 
			DYNAMIC_DOWNCAST (CBCGPControlBar, pBar);
		ASSERT_VALID (pControlBar);
		pControlBar->FloatControlBar (pControlBar->m_recentDockInfo.m_rectRecentFloatingRect, 
									  dockMethod, !bHide);
		return TRUE;
	}
	return FALSE;
}
//**************************************************************************************
void CBCGPBaseTabbedBar::StoreRecentDockInfo ()
{
	int nTabsNum = m_pTabWnd->GetTabsNum ();
	for (int i = 0; i < nTabsNum; i++)
	{
		CBCGPDockingControlBar* pBar = 
			DYNAMIC_DOWNCAST (CBCGPDockingControlBar, m_pTabWnd->GetTabWnd (i));
		if (pBar != NULL)
		{
			pBar->StoreRecentTabRelatedInfo ();
		}
	}

	CBCGPDockingControlBar::StoreRecentDockInfo ();
}
//**************************************************************************************
BOOL CBCGPBaseTabbedBar::FloatControlBar (CRect rectFloat, 
											 BCGP_DOCK_METHOD dockMethod,
											 bool bShow)
{
	ASSERT_VALID (this);
	ASSERT_VALID (m_pTabWnd);