bcgpdockingcontrolbar.cpp

远程网络监视程序的源码

//***********************************************************************
void CBCGPDockingControlBar::Slide (BOOL bSlideOut, BOOL bUseTimer)
{
	ASSERT_VALID (this);

	if (!IsAutoHideMode ())
	{
		return;
	}

	if (m_nSlideTimer != 0)
	{
		KillTimer (m_nSlideTimer);
	}

	if (m_nAutoHideConditionTimerID != 0)
	{
		KillTimer (m_nAutoHideConditionTimerID);
		m_nAutoHideConditionTimerID = 0;
	}

	CRect rectWnd;
	GetWindowRect (rectWnd);

	if (!bUseTimer || m_bDisableAnimation)
	{
		m_nSlideDelta = IsHorizontal () ? rectWnd.Height () : rectWnd.Width ();
	}

	if (!bUseTimer)
	{
		m_rectRestored = rectWnd;
		// just move out from the screen
		
		OnSlide (FALSE);
		ShowWindow (SW_HIDE);
		::ShowWindow (m_hDefaultSlider, SW_HIDE);
		return;
	}

	CBCGPDockManager* pDockManager = globalUtils.GetDockManager (GetDockSite ());
	ASSERT_VALID (pDockManager);	

	if (bSlideOut)		
	{
		pDockManager->HideAutoHideBars (this);
		pDockManager->AlignAutoHideBar (GetDefaultSlider (), FALSE);
		ShowWindow (SW_SHOW);
		::ShowWindow (m_hDefaultSlider, SW_SHOW);
	}

	
	BringWindowToTop ();
	::BringWindowToTop (m_hDefaultSlider);

	if (m_ahSlideMode == BCGP_AHSM_MOVE)
	{
		pDockManager->BringBarsToTop ();
	}

	m_nSlideTimer = SetTimer (bSlideOut ? BCGP_AUTO_HIDE_SLIDE_OUT_EVENT : 
										  BCGP_AUTO_HIDE_SLIDE_IN_EVENT, 
										  m_nSlideDefaultTimeOut, NULL);

	
	if (!m_bDisableAnimation)
	{
		if (m_ahSlideMode == BCGP_AHSM_MOVE)
		{
			GetDockSite ()->ScreenToClient (rectWnd);
			m_nSlideDelta = max (1, ((GetCurrentAlignment () & CBRS_ORIENT_HORZ) ?
					rectWnd.Height () : rectWnd.Width ()) / m_nSlideSteps);

		}
		else if (m_ahSlideMode == BCGP_AHSM_STRETCH)
		{
			if (!bSlideOut && !m_bIsSliding)
			{
				m_rectRestored = rectWnd;
				GetDockSite ()->ScreenToClient (m_rectRestored);
			}
			m_nSlideDelta = max (1, ((GetCurrentAlignment () & CBRS_ORIENT_HORZ) ?
					m_rectRestored.Height () : m_rectRestored.Width ()) / m_nSlideSteps);
		}	
	}

	m_nSlideStep = 0;
	m_bIsSliding = TRUE;
}
//***********************************************************************
void CBCGPDockingControlBar::SetAutoHideParents (CBCGPAutoHideToolBar* pToolBar, 
												 CBCGPAutoHideButton* pBtn)
{
	ASSERT_VALID (pToolBar);
	ASSERT_VALID (pBtn);

	m_pAutoHideBar		= pToolBar;
	m_pAutoHideButton	= pBtn;
}
//***********************************************************************
void CBCGPDockingControlBar::SetResizeMode (BOOL bResize) 
{ 
	m_bIsResizing = bResize;
}
//***********************************************************************
CBCGPSlider* CBCGPDockingControlBar::CreateDefaultSlider (DWORD dwAlignment, CWnd* pParent, 
															CRuntimeClass* pSliderRTC)
{
	CRect rectSlider (0, 0, CBCGPSlider::GetDefaultWidth (), CBCGPSlider::GetDefaultWidth ());
	WORD dwSliderStyle = CBCGPSlider::SS_HORZ;

	if (dwAlignment & CBRS_ALIGN_LEFT || dwAlignment & CBRS_ALIGN_RIGHT)
	{
		dwSliderStyle = CBCGPSlider::SS_VERT;
	}

	// create a slider with a control bar container
	CBCGPSlider* pSlider = NULL; 
	if (pSliderRTC != NULL)
	{
		pSlider = (CBCGPSlider*) pSliderRTC->CreateObject ();
		pSlider->SetDefaultMode (TRUE);
	}
	else
	{
		pSlider = new CBCGPSlider (TRUE); 
	}

	ASSERT_VALID (pSlider);

	if (!pSlider->CreateEx (0, dwSliderStyle | WS_VISIBLE, 
							rectSlider, pParent, (UINT) -1, NULL))
	{
		TRACE0 ("Can't create default slider while docking\n");
		delete pSlider;
		return NULL;
	}

	pSlider->SetBarAlignment (dwAlignment);

	return pSlider;
}
//***********************************************************************
void CBCGPDockingControlBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CPoint ptScreen = point;
	ClientToScreen (&ptScreen);

	CBCGPCaptionButton* pBtn = FindButton (ptScreen);
	if (pBtn != NULL)
	{
		CWnd::OnLButtonDblClk(nFlags, point);
		return;
	}

	if (!IsAutoHideMode ())
	{
		CBCGPDockingControlBar* pBarToDock = this;
		if (IsTabbed ())
		{
			CBCGPBaseTabWnd* pTabWnd = 
				DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
			if (pTabWnd != NULL)
			{
				pBarToDock = 
					DYNAMIC_DOWNCAST (CBCGPDockingControlBar, pTabWnd->GetParent ());	
			}
		}

		CBCGPMultiMiniFrameWnd* pParentMiniFrame = 
				DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd, GetParentMiniFrame ());

		if (pParentMiniFrame != NULL)
		{
			OnProcessDblClk ();
			pParentMiniFrame->DockRecentControlBarToMainFrame (pBarToDock);
		}
		else if (IsWindow (m_hDefaultSlider))
		{
			// currently docked at main frame
			CBCGPMultiMiniFrameWnd* pRecentMiniFrame = 
				DYNAMIC_DOWNCAST (CBCGPMultiMiniFrameWnd,
					CWnd::FromHandlePermanent (m_recentDockInfo.m_hRecentMiniFrame));
			
			if (pRecentMiniFrame != NULL && 
				(m_recentDockInfo.GetRecentContainer (FALSE) != NULL ||
				 m_recentDockInfo.GetRecentTabContainer (FALSE) != NULL))
			{
				OnProcessDblClk ();
				UnDockControlBar ();
				pRecentMiniFrame->AddRecentControlBar (pBarToDock);
			}
			else
			{
				CBCGPControlBar::OnLButtonDblClk(nFlags, point);
			}
		}
		else
		{
			OnProcessDblClk ();
		}
	}
	else
	{
		CWnd::OnLButtonDblClk(nFlags, point);
	}
}
//***********************************************************************
BOOL CBCGPDockingControlBar::OnBeforeFloat (CRect& rectFloat, BCGP_DOCK_METHOD dockMethod)
{
	ASSERT_VALID (this);
	BOOL bResult = CBCGPControlBar::OnBeforeFloat (rectFloat, dockMethod);
	
	if (dockMethod == DM_MOUSE)
	{
		// prevent drawing of the drag rectangle on mouse up
		m_bPrepareToFloat = false;
	}

	return bResult;
}
//***********************************************************************
void CBCGPDockingControlBar::OnNcLButtonDown(UINT nHitTest, CPoint point) 
{
	ASSERT_VALID (this);

	if (!IsDocked ())
	{
		CBCGPControlBar::OnNcLButtonDown(nHitTest, point);
	}
}
//***********************************************************************
void CBCGPDockingControlBar::OnClose() 
{
	ASSERT_VALID (this);
	DestroyWindow ();
}
//***********************************************************************
CBCGPDockingControlBar* CBCGPDockingControlBar::AttachToTabWnd (CBCGPDockingControlBar* pTabControlBarAttachTo, 
																BCGP_DOCK_METHOD dockMethod,
																BOOL bSetActive, 
																CBCGPDockingControlBar** ppTabbedControlBar)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pTabControlBarAttachTo);

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

	if (!pTabControlBarAttachTo->CanBeAttached () || !CanBeAttached ())
	{
		return NULL; // invalid attempt to attach non-attachable control bar
	}

	// check whether pTabBar is derived from CBCGPTabbedControlBar. If so, we 
	// can attach this bar to it immediately. Otherwise, we need to create a 
	// new tabbed control bar and replace pTabControlBarAttachTo with it.
	CBCGPBaseTabbedBar* pTabbedBarAttachTo = 
		DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pTabControlBarAttachTo);

	BOOL bBarAttachToIsFloating = (pTabControlBarAttachTo->GetParentMiniFrame () != NULL);

	CWnd* pOldParent = GetParent ();
	CRect rectWndTab; rectWndTab.SetRectEmpty ();
	if (pTabbedBarAttachTo == NULL)
	{
		CWnd* pTabParent = pTabControlBarAttachTo->GetParent ();
		if (DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, pTabParent) != NULL)
		{
			pTabParent = pTabParent->GetParent ();
		}

		pTabbedBarAttachTo = DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, pTabParent);

		if (pTabbedBarAttachTo == NULL)
		{
			pTabControlBarAttachTo->StoreRecentDockInfo ();

			pTabControlBarAttachTo->GetWindowRect (rectWndTab);
			pTabControlBarAttachTo->GetParent ()->ScreenToClient (&rectWndTab);

			pTabbedBarAttachTo = pTabControlBarAttachTo->CreateTabbedControlBar (); 
			ASSERT_VALID (pTabbedBarAttachTo);

			pTabControlBarAttachTo->InsertControlBar (pTabbedBarAttachTo, pTabControlBarAttachTo);

			if (!pTabControlBarAttachTo->ReplaceControlBar (pTabbedBarAttachTo, dockMethod))
			{
				if (!bBarAttachToIsFloating)
				{
					RemoveControlBarFromDockManager (pTabbedBarAttachTo);
				}
				ASSERT (FALSE);
				TRACE0 ("Failed to replace resizable control bar by tabbed control bar. \n");
				delete pTabbedBarAttachTo;
				return NULL;
			}

			pTabbedBarAttachTo->
				EnableDocking (pTabControlBarAttachTo->GetEnabledAlignment ());
			pTabbedBarAttachTo->
				SetBarAlignment (pTabControlBarAttachTo->GetCurrentAlignment ());
			
			pTabControlBarAttachTo->UnDockControlBar (TRUE);
			pTabbedBarAttachTo->AddTab (pTabControlBarAttachTo, TRUE, bSetActive);
			pTabControlBarAttachTo->EnableGripper (FALSE);
		}
	}

	if (ppTabbedControlBar != NULL)
	{
		*ppTabbedControlBar = pTabbedBarAttachTo;
	}

	EnableGripper (FALSE);
	
	// send before dock notification without guarantee that the bar will 
	// be attached to another dock bar
	OnBeforeDock ((CBCGPBaseControlBar**)pTabbedBarAttachTo, NULL, dockMethod);
	// reassign the parentship to the tab bar
	OnBeforeChangeParent (pTabbedBarAttachTo, TRUE);

	// remove from miniframe
	RemoveFromMiniframe (pTabbedBarAttachTo, dockMethod);

	// AddTab returns TRUE only if this pointer is not tabbed control bar
	// (tabbed control bar is destroyed by AddTab and its tab windows are copied
	// to pTabbedBarAttachTo tabbed window)
	BOOL bResult = pTabbedBarAttachTo->AddTab (this, TRUE, bSetActive);
	if (bResult)
	{
		OnAfterChangeParent (pOldParent);
		OnAfterDock (pTabbedBarAttachTo, NULL, dockMethod);
	}

	if (!rectWndTab.IsRectEmpty ())
	{
		pTabbedBarAttachTo->SetWindowPos (NULL, rectWndTab.left, rectWndTab.top, 
			rectWndTab.Width (), rectWndTab.Height (), 
			SWP_NOZORDER | SWP_NOACTIVATE);
		
		if (bResult)
		{
			AdjustDockingLayout ();
		}
	}

	pTabbedBarAttachTo->RecalcLayout ();

	return bResult ? this : pTabbedBarAttachTo;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::ReplaceControlBar (CBCGPDockingControlBar* pBarToReplaceWith, 
												BCGP_DOCK_METHOD dockMethod, 
												BOOL bRegisterWithFrame)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pBarToReplaceWith);
	
	CBCGPMiniFrameWnd* pParentMiniFrame = GetParentMiniFrame ();
	
	if (pParentMiniFrame != NULL)
	{
		// this is tabbed control bar that should be replaced by docking control bar
		// within miniframe
		
		ASSERT_VALID (pParentMiniFrame);
		pParentMiniFrame->ReplaceControlBar (this, pBarToReplaceWith);
		return TRUE;
	}
	else if (m_hDefaultSlider != NULL)
	{
		CBCGPSlider* pDefaultSlider = GetDefaultSlider ();

		if (pDefaultSlider != NULL && 
			pDefaultSlider->ReplaceControlBar (this, pBarToReplaceWith))
		{
			// unregister from parent frame/dock manager the bar that is being replaced (this)
			RemoveControlBarFromDockManager (this, FALSE);
			// register with the parent frame the bar we're replacing with
			if (bRegisterWithFrame)
			{
				AddControlBar (pBarToReplaceWith);
			}
			
			return TRUE;
		}
	}
	return FALSE;
}
//***********************************************************************
CBCGPTabbedControlBar* CBCGPDockingControlBar::CreateTabbedControlBar ()
{
	ASSERT_VALID (this);
	CRect rectTabBar;
	GetWindowRect (&rectTabBar);
	ASSERT_VALID (GetParent ());
	GetParent ()->ScreenToClient (&rectTabBar);

	CBCGPTabbedControlBar* pTabbedBar = 
			(CBCGPTabbedControlBar*) m_pTabbedControlBarRTC->CreateObject ();
	ASSERT_VALID (pTabbedBar);

	pTabbedBar->SetAutoDestroy (TRUE);

	if (!pTabbedBar->Create (_T (""), 
							GetParent (), 
							rectTabBar, 
							TRUE, 
							(UINT) -1, 
							GetStyle () | CBRS_FLOAT_MULTI))
	{
		TRACE0 ("Failed to create tabbed control bar\n");
		return NULL;
	}

	// override recent floating/docking info

	pTabbedBar->m_recentDockInfo.m_recentMiniFrameInfo.m_rectDockedRect = 
		m_recentDockInfo.m_recentMiniFrameInfo.m_rectDockedRect;
	pTabbedBar->m_recentDockInfo.m_recentSliderInfo.m_rectDockedRect = 
		m_recentDockInfo.m_recentSliderInfo.m_rectDockedRect;
	pTabbedBar->m_recentDockInfo.m_rectRecentFloatingRect = 
		m_recentDockInfo.m_rectRecentFloatingRect;

	return pTabbedBar;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::Dock (CBCGPBaseControlBar* pTargetBar, LPCRECT lpRect, 
								  BCGP_DOCK_METHOD dockMethod)
{
	CFrameWnd* pParentFrame = DYNAMIC_DOWNCAST (CFrameWnd, BCGPGetParentFrame (this));
	ASSERT_VALID (pParentFrame);

	if (pTargetBar != NULL && !pTargetBar->CanAcceptBar (this) && 
		pTargetBar != this)
	{
		return FALSE;
	}

	if (dockMethod == DM_RECT && lpRect == NULL)
	{
		TRACE0 ("Docking control bar must be docked by rect or by mouse!");
		ASSERT (FALSE);
		return FALSE;
	}

	m_bPrepareToFloat = false;

	if (dockMethod == DM_DBL_CLICK || dockMethod == DM_SHOW)
	{
		CBCGPBarContainer* pRecentTabContainer = 
			m_recentDockInfo.GetRecentTabContainer (TRUE);

		ShowWindow (SW_HIDE);

		RemoveFromMiniframe (BCGPGetParentFrame (this), dockMethod);
		SetBarAlignment (m_recentDockInfo.m_dwRecentAlignmentToFrame);

		CBCGPSlider* pRecentDefaultSlider = m_recentDockInfo.GetRecentDefaultSlider ();
		if (pRecentDefaultSlider != NULL)
		{
			SetDefaultSlider (pRecentDefaultSlider->m_hWnd);
		}

		if (pRecentTabContainer != NULL)
		{
			BOOL bRecentLeftBar = m_recentDockInfo.IsRecentLeftBar (TRUE);
			CBCGPDockingControlBar* pTabbedBar = (CBCGPDockingControlBar*) (bRecentLeftBar ? 
				pRecentTabContainer->GetLeftBar () : pRecentTabContainer->GetRightBar ());
			if (pTabbedBar != NULL)
			{
				BOOL bResult = (AttachToTabWnd (pTabbedBar, DM_DBL_CLICK) != NULL);
				ShowWindow (SW_SHOW);
				AdjustDockingLayout ();
				return bResult;
			}
		}

		if (pRecentDefaultSlider != NULL)
		{
			EnableGripper (TRUE);
			InsertControlBar (this, pRecentDefaultSlider, FALSE);

			ShowWindow (SW_SHOW);
			CBCGPDockingControlBar* pAddedControlBar = 
				pRecentDefaultSlider->AddRecentControlBar (this);
			if (pAddedControlBar == this)
			{
				AdjustDockingLayout ();
				return TRUE;
			}
			else if (pAddedControlBar != NULL)
			{
				pAddedControlBar->AdjustDockingLayout ();
				return FALSE;
			}
		}
		else
		{
			ShowWindow (SW_SHOW);
			return DockToFrameWindow (m_recentDockInfo.m_dwRecentAlignmentToFrame, 
				(lpRect == NULL) ?