bcgpdockingcontrolbar.cpp

远程网络监视程序的源码

						&m_recentDockInfo.m_recentSliderInfo.m_rectDockedRect : lpRect);
		}
		return FALSE;
	}

	CPoint ptMouse (0, 0);
	if (dockMethod == DM_MOUSE || dockMethod == DM_STANDARD)
	{
		GetCursorPos (&ptMouse);
	}


	DWORD dwAlignment = 0;
	if (pTargetBar == NULL)
	{
		// insert the resizable bar as first resizable if it crosses the outer edge
		// IsPointNearDockBar will return this information
		BOOL bOuterEdge = FALSE;
	
		if (dockMethod == DM_MOUSE  || dockMethod == DM_STANDARD)
		{
			CPoint ptMouse;
			GetCursorPos (&ptMouse);
			if (!IsPointNearDockBar (ptMouse, dwAlignment, bOuterEdge))
			{
				return FALSE;
			}
			return DockToFrameWindow (dwAlignment, NULL, DT_DOCK_LAST, 
										NULL, -1, bOuterEdge);
		}
		else if (lpRect != NULL)
		{

		}
		
	}
	else
	{
		ASSERT_VALID (pTargetBar);

		if (dockMethod == DM_MOUSE || dockMethod == DM_STANDARD)
		{
			if (!globalUtils.CheckAlignment (ptMouse, pTargetBar, 
											CBCGPDockManager::m_nDockSencitivity,
											FALSE, dwAlignment))
			{
				return FALSE;
			}

			return DockToWindow ((CBCGPDockingControlBar*) pTargetBar, dwAlignment, NULL);
		}
		else if (lpRect != NULL)
		{
			return DockToWindow ((CBCGPDockingControlBar*) pTargetBar, 0, lpRect);
		}
	}

	return FALSE;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::DockToFrameWindow (DWORD dwAlignment, 
												LPCRECT lpRect, 
												DWORD dwDockFlags, 
												CBCGPBaseControlBar* pRelativeBar, 
												int nRelativeIndex, 
												BOOL bOuterEdge)
{
	ASSERT_VALID (this);
	ASSERT (dwAlignment & CBRS_ALIGN_ANY);

	RemoveFromMiniframe (BCGPGetParentFrame (this), DM_UNKNOWN);
	
	if (m_hDefaultSlider != NULL && IsWindow (m_hDefaultSlider))
	{
		UnDockControlBar (FALSE);
	}

	CBCGPSlider* pDefaultSlider = NULL;
	// create a slider with a control bar container
	if ((pDefaultSlider = CreateDefaultSlider (dwAlignment, GetDockSite ())) == NULL)
	{
		TRACE0 ("Failde to create default slider");
		ShowWindow (SW_SHOW);
		return FALSE;
	}

	m_hDefaultSlider = pDefaultSlider->m_hWnd;

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

	if (pDockManager->AdjustRectToClientArea (rectBar, dwAlignment))
	{
		SetWindowPos (NULL, 0, 0, rectBar.Width (), rectBar.Height (),  
							SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
	}
	
	pDefaultSlider->AddControlBar (this);

	// register this docking bar and slider with the frame's window dock manager
	if (!bOuterEdge)
	{
		AddControlBar (this);
		AddControlBar (pDefaultSlider);
	}
	else
	{
		pDockManager->AddControlBar (pDefaultSlider, !bOuterEdge, FALSE, bOuterEdge);
		pDockManager->AddControlBar (this, !bOuterEdge, FALSE, bOuterEdge);
	}

	SetBarAlignment (dwAlignment);
	pDefaultSlider->SetBarAlignment (GetCurrentAlignment ());
	m_recentDockInfo.m_dwRecentAlignmentToFrame = GetCurrentAlignment ();

	EnableGripper (TRUE);

	if (lpRect != NULL)
	{
		CRect rect (lpRect);
		SetWindowPos (NULL, 0, 0, rect.Width (), rect.Height (),  
					SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE | SWP_FRAMECHANGED);
	}

	AdjustDockingLayout ();
	return TRUE;
}
//***********************************************************************
BOOL CBCGPDockingControlBar::DockToWindow (CBCGPDockingControlBar* pTargetWindow, 
										  DWORD dwAlignment, 
										  LPCRECT lpRect)
{

	ASSERT_VALID (this);
	ASSERT_VALID (pTargetWindow);
	ASSERT (dwAlignment & CBRS_ALIGN_ANY || lpRect != NULL);
	ASSERT_KINDOF (CBCGPDockingControlBar, pTargetWindow);

	CBCGPSlider* pSlider = pTargetWindow->GetDefaultSlider ();

	if (pSlider == NULL)
	{
		ShowWindow (SW_SHOW);
		return FALSE;
	}


	if (m_hDefaultSlider != NULL && IsWindow (m_hDefaultSlider))
	{
		UnDockControlBar (FALSE);
	}

	RemoveFromMiniframe (BCGPGetParentFrame (this), DM_UNKNOWN);
	
	if (pSlider->InsertControlBar (this, pTargetWindow, dwAlignment, lpRect))
	{
		// the bar was successfully inserted into slider's container. Now, we need 
		// to register it with the frame
		InsertControlBar (this, pTargetWindow, TRUE);
		m_hDefaultSlider = pSlider->m_hWnd;

		EnableGripper (TRUE);
		// force NcCalcSize to recalculate and draw the caption (gripper)
		SetWindowPos (NULL, 0, 0, 0, 0, 
						SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | 
						SWP_NOREDRAW | SWP_FRAMECHANGED | SWP_SHOWWINDOW);

		AdjustDockingLayout ();
		return TRUE;
	}
	
	return FALSE;
}
//*****************************************************************************************
BOOL CBCGPDockingControlBar::DockContainer (CBCGPBarContainerManager& barContainerManager, 
											DWORD dwAlignment, BCGP_DOCK_METHOD dockMethod)
{
	if (m_hDefaultSlider != NULL && IsWindow (m_hDefaultSlider))
	{
		CObList lstControlBars; 
		barContainerManager.AddControlBarsToList (&lstControlBars, NULL);

		for (POSITION pos = lstControlBars.GetHeadPosition (); pos != NULL;)
		{
			CBCGPDockingControlBar* pBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, lstControlBars.GetNext (pos));

			InsertControlBar (pBar, this, TRUE);
			pBar->SetDefaultSlider (m_hDefaultSlider); 
			pBar->SetBarAlignment (GetCurrentAlignment ());
		}

		CBCGPSlider* pDefaultSlider = GetDefaultSlider ();
		if (pDefaultSlider != NULL)
		{
			return pDefaultSlider->AddContainer (this, barContainerManager, dwAlignment);
		}
	}

	return FALSE;
}
//*****************************************************************************************
void CBCGPDockingControlBar::DrawCaption (CDC* pDC, CRect rectCaption)
{
	ASSERT_VALID (pDC);

	CRect rcbtnRight = CRect (rectCaption.BottomRight (), CSize (0, 0));
	for (int i = m_arrButtons.GetUpperBound (); i >= 0; i --)
	{
		if (!m_arrButtons [i]->m_bLeftAlign && !m_arrButtons [i]->m_bHidden)
		{
			rcbtnRight = m_arrButtons [i]->GetRect();
			break;
		}
	}

	CRect rcbtnLeft = CRect (rectCaption.TopLeft (), CSize (0, 0));
	for (i = m_arrButtons.GetUpperBound (); i >= 0; i --)
	{
		if (m_arrButtons [i]->m_bLeftAlign && !m_arrButtons [i]->m_bHidden)
		{
			rcbtnLeft = m_arrButtons [i]->GetRect();
			break;
		}
	}

	COLORREF clrCptnText = CBCGPVisualManager::GetInstance ()->OnDrawControlBarCaption (
		pDC, this, m_bActive, rectCaption, rcbtnRight);

	for (i = 0; i < m_arrButtons.GetSize (); i ++)
	{
		CBCGPCaptionButton* pbtn = m_arrButtons [i];
		ASSERT_VALID (pbtn);

		pbtn->m_clrForeground = clrCptnText;
	}

    int nOldBkMode = pDC->SetBkMode(TRANSPARENT);
    COLORREF clrOldText = pDC->SetTextColor (clrCptnText);

    CFont* pOldFont = pDC->SelectObject (&globalData.fontRegular);
	ASSERT (pOldFont != NULL);

    CString strTitle;
    GetWindowText (strTitle);

	rectCaption.right = rcbtnRight.left;
	rectCaption.left = rcbtnLeft.right;
	rectCaption.DeflateRect (g_nCaptionHorzMargin * 2, 0);

	pDC->DrawText (strTitle, rectCaption, DT_LEFT | DT_SINGLELINE | DT_VCENTER);

    pDC->SelectObject(pOldFont);
    pDC->SetBkMode(nOldBkMode);
    pDC->SetTextColor(clrOldText);
}
//*****************************************************************************************
void CBCGPDockingControlBar::RedrawButton (const CBCGPCaptionButton* pButton)
{
	if (pButton == NULL /*|| GetParentMiniFrame (TRUE) != NULL*/)
	{
		return;
	}

	if (!pButton->m_bEnabled)
	{
		return;
	}

	m_rectRedraw = pButton->GetRect ();
	SendMessage (WM_NCPAINT);
	m_rectRedraw.SetRectEmpty ();

	UpdateWindow ();
}
//*****************************************************************************************
void CBCGPDockingControlBar::SetCaptionStyle (BOOL bDrawText, BOOL bForceGradient,
											BOOL bHideDisabledButtons)
{
	m_bCaptionText = bDrawText;
	m_bHideDisabledButtons = bHideDisabledButtons;
}
//*****************************************************************************************
void CBCGPDockingControlBar::ShowControlBar (BOOL bShow, BOOL bDelay, BOOL bActivate)
{
	if (IsAutoHideMode ())
	{
		if (IsHideInAutoHideMode ())
		{
			if (IsBarVisible () && !bShow)
			{
				m_pAutoHideButton->ShowAttachedWindow (FALSE);
			}
			m_pAutoHideBar->ShowAutoHideWindow(this, bShow, bDelay);
		}
		else
		{
			m_pAutoHideButton->ShowAttachedWindow (TRUE);
			if (bShow && bActivate)
			{
				SetFocus ();
				m_bActive = TRUE;
			}
		}
	}
	else if (IsFloating () || IsTabbed ())
	{
		// standard procedure - show/hide bar and its miniframe
		CBCGPControlBar::ShowControlBar (bShow, bDelay, bActivate);
		CBCGPMiniFrameWnd* pMiniFrame = GetParentMiniFrame ();
		if (pMiniFrame != NULL)
		{
			pMiniFrame->OnShowControlBar (this, bShow);
		}
	}
	else
	{
		
		ShowWindow (bShow ? SW_SHOW : SW_HIDE);
		CBCGPSlider* pDefaultSlider = GetDefaultSlider ();
		CBCGPMiniFrameWnd* pMiniFrame = GetParentMiniFrame ();

		if (pMiniFrame != NULL)
		{
			pMiniFrame->OnShowControlBar (this, bShow);
		}
		else if (pDefaultSlider != NULL)
		{
			if (bShow)
			{
				int nLastPercent = GetLastPercentInContainer ();
				if (nLastPercent >= 50)
				{
					SetLastPercentInContainer (50);
				}
				else
				{
					SetLastPercentInContainer (nLastPercent + 1);
				}
			}
			
			// docked at main frame - notify to adjust container
			pDefaultSlider->OnShowControlBar (this, bShow);
			if (!bDelay)
			{
				AdjustDockingLayout ();
			}
		}
		else 
		{
			// flotaing with other bars on miniframe  - notify to adjust container
			
		}
		
	}

	if (IsTabbed () && bShow && bActivate)
	{
		CBCGPBaseTabWnd* pParentTab = DYNAMIC_DOWNCAST (CBCGPBaseTabWnd, GetParent ());
		if (pParentTab == NULL)
		{
			ASSERT (FALSE);
			return;
		}

		ASSERT_VALID (pParentTab);
		pParentTab->SetActiveTab (pParentTab->GetTabFromHwnd (GetSafeHwnd ()));
	}
}
//*****************************************************************************************
void CBCGPDockingControlBar::UnDockControlBar (BOOL bDelay)
{
	CBCGPMiniFrameWnd* pMiniFrame = 
		DYNAMIC_DOWNCAST (CBCGPMiniFrameWnd, GetParentMiniFrame ());

	if (pMiniFrame == NULL)
	{
		RemoveFromDefaultSlider ();
		// remove from dock site		
		RemoveControlBarFromDockManager (this, FALSE, !bDelay);

		if (!bDelay && !IsFloating ())
		{
			AdjustDockingLayout ();
		}
	}
	else
	{
		pMiniFrame->RemoveControlBar (this);
	}
}
//*****************************************************************************************
void CBCGPDockingControlBar::OnDestroy() 
{
	RemoveCaptionButtons ();

	if (GetParentMiniFrame () != NULL)
	{
		RemoveFromMiniframe (m_pDockSite, DM_UNKNOWN);
	}
	else
	{
		UnDockControlBar (TRUE);
	}	

	if (m_ToolTip.GetSafeHwnd () != NULL)
	{
		m_ToolTip.DestroyWindow ();
	}

	CBCGPControlBar::OnDestroy();
}
//*************************************************************************************
void CBCGPDockingControlBar::OnTrackCaptionButtons (CPoint point)
{
	UINT nHot = m_nHot;

	CBCGPCaptionButton* pBtn = FindButton (point);
	if (pBtn != NULL)
	{
		m_nHot = pBtn->GetHit ();

		if (m_nHit == HTNOWHERE || m_nHit == m_nHot)
		{
			pBtn->m_bFocused = TRUE;
		}
	}
	else
	{
		m_nHot = HTNOWHERE;
	}

	if (m_nHot != nHot)
	{
		RedrawButton (pBtn);

		CBCGPCaptionButton* pBtnOld = FindButtonByHit (nHot);
		if (pBtnOld != NULL)
		{
			pBtnOld->m_bFocused = FALSE;
			RedrawButton (pBtnOld);
		}
	}

	if (m_nHit == HTNOWHERE)
	{
		if (nHot != HTNOWHERE && m_nHot == HTNOWHERE)
		{
			::ReleaseCapture();
			m_bCaptionButtonsCaptured = FALSE;
		}
		else if (nHot == HTNOWHERE && m_nHot != HTNOWHERE)
		{
			SetCapture ();
			m_bCaptionButtonsCaptured = TRUE;
		}
	}
}
//*************************************************************************************
void CBCGPDockingControlBar::OnNcMouseMove(UINT nHitTest, CPoint point) 
{
	if (!m_bPrepareToFloat /*&& GetParentMiniFrame (TRUE) == NULL*/)
	{
		OnTrackCaptionButtons (point);
	}

	CBCGPControlBar::OnNcMouseMove(nHitTest, point);
}
//************************************************************************************
void CBCGPDockingControlBar::StopCaptionButtonsTracking ()
{
	if (m_nHit != HTNOWHERE)
	{
		CBCGPCaptionButton* pBtn = FindButtonByHit (m_nHit);
		m_nHit = HTNOWHERE;

		ReleaseCapture ();
		if (pBtn != NULL)
		{
			pBtn->m_bPushed = FALSE;
			RedrawButton (pBtn);
		}
	}

	if (m_nHot != HTNOWHERE)
	{
		CBCGPCaptionButton* pBtn = FindButtonByHit (m_nHot);
		m_nHot = HTNOWHERE;

		ReleaseCapture ();
		if (pBtn != NULL)
		{
			pBtn->m_bFocused = FALSE;
			RedrawButton (pBtn);
		}
	}
	m_bCaptionButtonsCaptured = FALSE;
}
//*************************************************************************************
void CBCGPDockingControlBar: