bcgpdockingcontrolbar.cpp

远程网络监视程序的源码

		CBCGPSlider* pDefaultSlider = GetDefaultSlider ();
		ASSERT (pDefaultSlider == NULL);
		pDefaultSlider = CreateDefaultSlider (dwAlignment, GetDockSite ());

		if (pDefaultSlider == NULL)
		{
			TRACE0 ("Failed to create default slider\n");
			DockControlBar (this, NULL, DM_DBL_CLICK);
			return NULL;
		}

		m_hDefaultSlider = pDefaultSlider->m_hWnd;

		pDefaultSlider->SetAutoHideMode (TRUE);
		pDefaultSlider->AddControlBar (this);

		SetBarAlignment (dwAlignment);
		pDefaultSlider->SetBarAlignment (dwAlignment);
		
		pCurrAutoHideBar = pDockManager->AutoHideBar (this, pCurrAutoHideBar);

		if (IsBarVisible ())
		{
			pDefaultSlider->RedrawWindow (NULL, NULL,
					RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
			RedrawWindow (NULL, NULL,
					RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);

			GetDockSite ()->RedrawWindow (rectBeforeUndock,  NULL,
							RDW_INVALIDATE | RDW_UPDATENOW |  RDW_ALLCHILDREN);
		}
		else
		{
			ShowWindow (SW_SHOW);
		}

		if (bUseTimer)
		{
			m_nAutoHideConditionTimerID = SetTimer (ID_CHECK_AUTO_HIDE_CONDITION, 
													m_nTimeOutBeforeAutoHide, NULL);	
		}
		else
		{
			Slide (FALSE, FALSE);
		}
	}
	else
	{
		CBCGPAutoHideDockBar* pParentDockBar = 
			DYNAMIC_DOWNCAST (CBCGPAutoHideDockBar, m_pAutoHideBar->GetParentDockBar ());

		if (pParentDockBar != NULL)
		{
			pParentDockBar->UnSetAutoHideMode (m_pAutoHideBar);
		}
	}

	return pCurrAutoHideBar;
}
//***********************************************************************
void CBCGPDockingControlBar::UnSetAutoHideMode (CBCGPDockingControlBar* pFirstBarInGroup)
{
	m_bPinState = FALSE;

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

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

	BOOL bWasActive = m_pAutoHideBar->m_bActiveInGroup;

	m_pAutoHideBar->RemoveAutoHideWindow (this);

	RemoveFromDefaultSlider ();		
	// unset autohide mode - make it docked back
	if (pFirstBarInGroup == NULL)
	{
		if (!DockControlBar (this, NULL, DM_DBL_CLICK))
		{
			return;
		}
	}
	else
	{
		AttachToTabWnd (pFirstBarInGroup, DM_SHOW, bWasActive);
	}
	ShowControlBar (TRUE, FALSE, bWasActive);
	AdjustDockingLayout ();
}
//***********************************************************************
void CBCGPDockingControlBar::OnTimer(UINT nIDEvent) 
{
	BOOL bSlideDirection = FALSE;

	switch (nIDEvent)
	{
	case ID_CHECK_AUTO_HIDE_CONDITION:
		if (CheckAutoHideCondition ())
		{
			KillTimer (m_nAutoHideConditionTimerID);
			m_nAutoHideConditionTimerID = 0;
		}
		return;
	case BCGP_AUTO_HIDE_SLIDE_OUT_EVENT:
		bSlideDirection = TRUE;
		m_bIsHiding = FALSE;
		break;
	case BCGP_AUTO_HIDE_SLIDE_IN_EVENT:
		bSlideDirection = FALSE;
		m_bIsHiding = TRUE;
		break;
	default:
		CBCGPControlBar::OnTimer(nIDEvent);
		return;
	}

	OnSlide (bSlideDirection);

	if (CheckStopSlideCondition (bSlideDirection))
	{
		KillTimer (m_nSlideTimer);

		m_bIsSliding = FALSE;
		m_nSlideTimer = 0;
		m_nSlideStep = 0;

		if (bSlideDirection) // slide out - show
		{
		
			RedrawWindow (NULL, NULL,
				RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | 
				RDW_ALLCHILDREN);

			::RedrawWindow (m_hDefaultSlider, NULL, NULL, RDW_INVALIDATE);
			// one second time out to give the user ability to move the mouse over
			// miniframe
			if (m_nAutoHideConditionTimerID != 0)
			{
				KillTimer (m_nAutoHideConditionTimerID);
			}

			m_nAutoHideConditionTimerID = SetTimer (ID_CHECK_AUTO_HIDE_CONDITION, 
													m_nTimeOutBeforeAutoHide, NULL);
		}
		else
		{
			ShowWindow (SW_HIDE);
			CBCGPSlider* pDefaultSlider = GetDefaultSlider ();
			ASSERT_VALID (pDefaultSlider);
			pDefaultSlider->ShowWindow (SW_HIDE);
		}
	}

	CBCGPControlBar::OnTimer(nIDEvent);
}
//***********************************************************************
// Returns TRUE when the dock bar should be hidden (strats slide in)
//***********************************************************************
BOOL CBCGPDockingControlBar::CheckAutoHideCondition ()
{
	if (m_bActive || m_bIsResizing || !IsAutoHideMode ())
	{
		return FALSE;
	}

	if (m_ToolTip.IsWindowVisible()) 
	{
		return FALSE;
	}

	ASSERT_VALID (m_pAutoHideButton);
	ASSERT_VALID (m_pAutoHideBar);

	CRect rectAutoHideBtn = m_pAutoHideButton->GetRect ();
	m_pAutoHideBar->ClientToScreen (&rectAutoHideBtn);

	CPoint ptCursor;
	GetCursorPos (&ptCursor);

	CWnd* pWndFromPoint = WindowFromPoint (ptCursor);
	BOOL bCursorOverThisWindow = FALSE; // and this is topmost window
	while (pWndFromPoint != NULL)
	{
		if (pWndFromPoint == this ||
			pWndFromPoint->m_hWnd == m_hDefaultSlider)
		{
			bCursorOverThisWindow = TRUE;
			break;
		}
		pWndFromPoint = pWndFromPoint->GetParent ();
	}

	CRect rectWnd;
	GetWindowRect (rectWnd);
	CRect rectSlider;
	::GetWindowRect (m_hDefaultSlider, &rectSlider);

	rectWnd.UnionRect (rectWnd, rectSlider);

	if (rectWnd.PtInRect (ptCursor) &&  bCursorOverThisWindow ||
		rectAutoHideBtn.PtInRect (ptCursor))
	{
		return FALSE;
	}

	Slide (FALSE);

	return TRUE;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::CheckStopSlideCondition (BOOL bDirection)
{
	if (!IsAutoHideMode ())
	{
		return TRUE;
	}

	CRect rectWnd;
	GetWindowRect (rectWnd);

	GetDockSite ()->ScreenToClient (rectWnd);
 
	CRect rectAutoHideDockBar;
	m_pAutoHideBar->GetParentDockBar ()->GetWindowRect (rectAutoHideDockBar);
	GetDockSite ()->ScreenToClient (rectAutoHideDockBar);

	BOOL bStop = FALSE;
	switch (GetCurrentAlignment ())
	{

	case CBRS_ALIGN_RIGHT:
		if (m_ahSlideMode == BCGP_AHSM_MOVE)
		{
			bStop = bDirection ? rectWnd.right <= rectAutoHideDockBar.left : 
								 rectWnd.left >= rectAutoHideDockBar.left;
		}
		else
		{
			bStop = bDirection ? rectWnd.Width () >= m_rectRestored.Width () : 
							 rectWnd.Width () <= 0;
		}
		break;
	case CBRS_ALIGN_LEFT:
		if (m_ahSlideMode == BCGP_AHSM_MOVE)
		{
			bStop = bDirection ? rectWnd.left >= rectAutoHideDockBar.right :
								 rectWnd.right <= rectAutoHideDockBar.right;
		}
		else
		{
			bStop = bDirection ? rectWnd.Width () >= m_rectRestored.Width () : 
							 rectWnd.Width () <= 0;
		}
		break;
	case CBRS_ALIGN_TOP:	
		if (m_ahSlideMode == BCGP_AHSM_MOVE)
		{
			bStop = bDirection ? rectWnd.top >= rectAutoHideDockBar.bottom :
								 rectWnd.bottom <= rectAutoHideDockBar.bottom;
		}
		else
		{

		}
		break;
	case CBRS_ALIGN_BOTTOM:	
		if (m_ahSlideMode == BCGP_AHSM_MOVE)
		{
			bStop = bDirection ? rectWnd.bottom <= rectAutoHideDockBar.top :
								 rectWnd.top >= rectAutoHideDockBar.top;
		}
		else
		{
			bStop = bDirection ? rectWnd.Height () >= m_rectRestored.Height () : 
							 rectWnd.Height () <= 0;
		}
		break;
	}

	return bStop;
}
//***********************************************************************
void CBCGPDockingControlBar::OnSlide (BOOL bSlideDirection)
{
	if (!IsAutoHideMode () && !IsWindow (m_hDefaultSlider))
	{
		return;
	}

	m_nSlideStep++;

	CRect rect;
	GetWindowRect (&rect);
	GetDockSite ()->ScreenToClient (&rect); 

	CRect rectSlider;
	::GetWindowRect (m_hDefaultSlider, &rectSlider);
	GetDockSite ()->ScreenToClient (&rectSlider); 

	if (m_ahSlideMode == BCGP_AHSM_MOVE)
	{
		OffsetRectForSliding (rect, bSlideDirection);
		OffsetRectForSliding (rectSlider, bSlideDirection);
		if (bSlideDirection)
		{
			CPoint pt = CalcCorrectOffset (rect);
			rect.OffsetRect (pt);
			rectSlider.OffsetRect (pt);
		}
	}
	else
	{
		CalcRectForSliding (rect, rectSlider, bSlideDirection);
	}


	SetWindowPos (NULL, rect.left, rect.top,
					rect.Width (), rect.Height (),
					SWP_NOZORDER | SWP_NOACTIVATE);

	::SetWindowPos (m_hDefaultSlider, NULL, rectSlider.left, rectSlider.top,
					rectSlider.Width (), rectSlider.Height (), SWP_NOZORDER | SWP_NOACTIVATE);

}
//***********************************************************************
void CBCGPDockingControlBar::OffsetRectForSliding (CRect& rect, BOOL bSlideDirection)
{
	if (!IsAutoHideMode ())
	{
		return;
	}

	switch (GetCurrentAlignment ())
	{
	case CBRS_ALIGN_LEFT:
		bSlideDirection ? rect.OffsetRect (m_nSlideDelta, 0) : 
						  rect.OffsetRect (-m_nSlideDelta, 0);	
		break;

	case CBRS_ALIGN_RIGHT:
		bSlideDirection ? rect.OffsetRect (-m_nSlideDelta, 0) : 
						  rect.OffsetRect (m_nSlideDelta, 0);
		break;

	case CBRS_ALIGN_TOP:
		bSlideDirection ? rect.OffsetRect (0, m_nSlideDelta) : 
						  rect.OffsetRect (0, -m_nSlideDelta);
		break;

	case CBRS_ALIGN_BOTTOM:
		bSlideDirection ? rect.OffsetRect (0, -m_nSlideDelta) : 
						  rect.OffsetRect (0, m_nSlideDelta);
		break;

	}
}
//***********************************************************************
void CBCGPDockingControlBar::CalcRectForSliding (CRect& rect, CRect& rectSlider, BOOL bSlideDirection)
{
	if (!IsAutoHideMode ())
	{
		return;
	}
	
	switch (GetCurrentAlignment ())
	{
	case CBRS_ALIGN_LEFT:
		if (bSlideDirection)   
		{
			rect.right += m_nSlideDelta;
			if (rect.Width () > m_rectRestored.Width ())
			{
				rect.right = rect.left + m_rectRestored.Width ();
			}
		}
		else
		{
			rect.right -= m_nSlideDelta;	
			if (rect.right < rect.left)
			{
				rect.right = rect.left;
			}
		}
		{
			int nSliderWidth = rectSlider.Width ();
			rectSlider.left = rect.right;
			rectSlider.right = rectSlider.left + nSliderWidth;
		}
		break;

	case CBRS_ALIGN_RIGHT:
		if (bSlideDirection)   
		{
			rect.left -= m_nSlideDelta;
			if (rect.Width () > m_rectRestored.Width ())
			{
				rect.left = rect.right - m_rectRestored.Width ();
			}
		}
		else
		{
			rect.left += m_nSlideDelta;	
			if (rect.left > rect.right)
			{
				rect.left = rect.right;
			}
		}
		{
			int nSliderWidth = rectSlider.Width ();
			rectSlider.right = rect.left;
			rectSlider.left = rectSlider.right - nSliderWidth;
		}
		break;

	case CBRS_ALIGN_TOP:
		if (bSlideDirection)   
		{
			rect.bottom += m_nSlideDelta;
			if (rect.Height () > m_rectRestored.Height ())
			{
				rect.bottom = rect.top + m_rectRestored.Height ();
			}
		}
		else
		{
			rect.bottom -= m_nSlideDelta;	
			if (rect.bottom < rect.top)
			{
				rect.bottom = rect.top;
			}
		}
		{
			int nSliderHeight = rectSlider.Height ();
			rectSlider.top = rect.bottom;
			rectSlider.bottom = rectSlider.top + nSliderHeight;
		}
		break;

	case CBRS_ALIGN_BOTTOM:
		if (bSlideDirection)   
		{
			rect.top -= m_nSlideDelta;
			if (rect.Height () > m_rectRestored.Height ())
			{
				rect.top = rect.bottom - m_rectRestored.Height ();
			}
		}
		else
		{
			rect.top += m_nSlideDelta;	
			if (rect.top > rect.bottom)
			{
				rect.top = rect.bottom;
			}
		}
		{
			int nSliderHeight = rectSlider.Height ();
			rectSlider.bottom = rect.top;
			rectSlider.top = rectSlider.bottom - nSliderHeight;
		}
		break;

	}
}
//***********************************************************************
CPoint CBCGPDockingControlBar::CalcCorrectOffset (CRect rect)
{
	CRect rectAutoHideDockBar;
	m_pAutoHideBar->GetParentDockBar ()->GetWindowRect (rectAutoHideDockBar);
	GetDockSite ()->ScreenToClient (rectAutoHideDockBar);
	
	switch (GetCurrentAlignment ())
	{
	case CBRS_ALIGN_LEFT:
		if (rect.left > rectAutoHideDockBar.right)
		{
			return CPoint (rectAutoHideDockBar.right - rect.left, 0);
		}
		break;
	case CBRS_ALIGN_RIGHT:
		if (rect.right < rectAutoHideDockBar.left)
		{
			return CPoint (rectAutoHideDockBar.left - rect.right, 0);
		}
		break;
	case CBRS_ALIGN_TOP:
		if (rect.top > rectAutoHideDockBar.bottom)
		{
			return CPoint (0, rectAutoHideDockBar.bottom - rect.top);
		}
		break;
	case CBRS_ALIGN_BOTTOM:
		if (rect.bottom < rectAutoHideDockBar.top)
		{
			return CPoint (0, rectAutoHideDockBar.top - rect.bottom);
		}
		break;
	}
	return CPoint (0, 0);
}