bcgpbasetabwnd.cpp

关于远程网络监视程序的源码

				if (pNextActiveTab->m_bVisible)
				{
					iActiveTab	= i;
				}
			}

			m_iActiveTab = -1;
		}
	}

	// If there was no tab visible, activate this first one
	if (bShow && nVisibleCount == 0)
	{
		iActiveTab	= iTab;
	}

	if (bRecalcLayout)
	{
		RecalcLayout ();
	}

	if (iActiveTab >= 0 && !bShow && m_iActiveTab == -1 || bActivate || nVisibleCount == 0)
	{
		SetActiveTab (iActiveTab);
		GetParent ()->SendMessage (BCGM_CHANGE_ACTIVE_TAB, m_iActiveTab);
	}
	
	return TRUE;
}
//****************************************************************************************
CWnd* CBCGPBaseTabWnd::GetTabWnd (int iTab) const
{
	if (iTab >= 0 && iTab < m_iTabsNum)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
		ASSERT_VALID (pTab);

		return pTab->m_pWnd;
	}
	else
	{
		return NULL;
	}
}
//*********************************************************************************
CWnd* CBCGPBaseTabWnd::GetTabWndNoWrapper (int iTab) const
{
	if (iTab >= 0 && iTab < m_iTabsNum)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
		ASSERT_VALID (pTab);

		CBCGPDockingCBWrapper* pWrapper = 
					DYNAMIC_DOWNCAST (CBCGPDockingCBWrapper, pTab->m_pWnd);
		if (pWrapper != NULL)
		{
			return pWrapper->GetWrappedWnd ();
		}

		return pTab->m_pWnd;
	}
	else
	{
		return NULL;
	}
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::GetTabRect (int iTab, CRect& rect) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}
	
	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);
	
	if (!pTab->m_bVisible)
	{
		rect.SetRectEmpty ();
		return FALSE;
	}
	
	rect = pTab->m_rect;
	return TRUE;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::GetTabLabel (int iTab, CString& strLabel) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}
	
	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);
	
	strLabel = pTab->m_bIconOnly ? _T("") : pTab->m_strText;
	return TRUE;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabLabel (int iTab, const CString& strLabel)
{
	if (iTab < 0 || iTab >= m_iTabsNum || strLabel.IsEmpty ())
	{
		return FALSE;
	}
	
	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID(pTab);
	
	pTab->m_strText = strLabel;
	
	if (m_ToolTip.GetSafeHwnd () != NULL)
	{
		m_ToolTip.UpdateTipText (strLabel, this, pTab->m_iTabID);
	}

	if (pTab->m_pWnd != NULL)
	{
		pTab->m_pWnd->SetWindowText (strLabel);
	}

	RecalcLayout();

	if (iTab == m_iActiveTab)
	{
		//--------------------------------------------------
		// Set text to the parent frame/docking control bar:
		//--------------------------------------------------
		CBCGPBaseTabbedBar* pTabControlBar = 
			DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, GetParent ());
		if (pTabControlBar != NULL) // tabbed dock bar - redraw caption only in this case
		{
			// miniframe will take the text from the tab control bar
			if (pTabControlBar->CanSetCaptionTextToTabName ())
			{
				pTabControlBar->SetWindowText (strLabel);
			}

			CWnd* pWndToUpdate = pTabControlBar;
			if (!pTabControlBar->IsDocked ())
			{
				pWndToUpdate = pTabControlBar->GetParent ();
			}

			if (pWndToUpdate != NULL)
			{
				pWndToUpdate->RedrawWindow (NULL, NULL, RDW_FRAME | RDW_INVALIDATE);
			}
		}
	}

	return TRUE;
}//********************************************************************************
UINT CBCGPBaseTabWnd::GetTabIcon (int iTab) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return (UINT) -1;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	return pTab->m_uiIcon;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabIcon (int iTab, UINT uiIcon)
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	if (pTab->m_hIcon != NULL)
	{
		::DestroyIcon (pTab->m_hIcon);
	}

	pTab->m_uiIcon = uiIcon;
	pTab->m_hIcon = NULL;

	return TRUE;
}
//********************************************************************************
HICON CBCGPBaseTabWnd::GetTabHicon (int iTab) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return NULL;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	return pTab->m_hIcon;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabHicon (int iTab, HICON hIcon)
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	if (pTab->m_hIcon != NULL)
	{
		::DestroyIcon (pTab->m_hIcon);
	}

	if (hIcon != NULL)
	{
		pTab->m_hIcon = ::CopyIcon (hIcon);
	}
	else
	{
		pTab->m_hIcon = NULL;
	}

	pTab->m_uiIcon = (UINT)-1;

	m_sizeImage.cx = max (m_sizeImage.cx, globalData.m_sizeSmallIcon.cx);
	m_sizeImage.cy = max (m_sizeImage.cy, globalData.m_sizeSmallIcon.cy);

	return TRUE;
}
//******************************************************************************************
BOOL CBCGPBaseTabWnd::IsTabIconOnly (int iTab) const
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}
	
	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);
	
	return pTab->m_bIconOnly;
};
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabIconOnly (int iTab, BOOL bIconOnly, BOOL bAlwaysShowToolTip)
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}
	
	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID(pTab);
	
	pTab->m_bIconOnly = bIconOnly;
	pTab->m_bAlwaysShowToolTip = bAlwaysShowToolTip;
	
	RecalcLayout();
	return TRUE;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::IsTabDetachable (int iTab) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	return pTab->m_bIsDetachable;
}
//******************************************************************************************
BOOL CBCGPBaseTabWnd::EnableTabDetach (int iTab, BOOL bEnable)
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

	CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);

	pTab->m_bIsDetachable = bEnable;
	return TRUE;
}
//******************************************************************************************
CWnd* CBCGPBaseTabWnd::GetActiveWnd () const
{
	return m_iActiveTab == -1 ? 
		NULL : 
		((CBCGPTabInfo*) m_arTabs [m_iActiveTab])->m_pWnd;
}
//***************************************************************************************
int CBCGPBaseTabWnd::GetTabFromPoint (CPoint& pt) const
{
	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);

		if (pTab->m_bVisible && pTab->m_rect.PtInRect (pt))
		{
			return i;
		}
	}

	return -1;
}
//***************************************************************************************
int CBCGPBaseTabWnd::GetTabFromHwnd (HWND hwnd) const
{
	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);

		if (pTab->m_pWnd == NULL)
		{
			continue;
		}

		if (pTab->m_pWnd->GetSafeHwnd () == hwnd)
		{
			return i;
		}
	}

	return -1;
}
//***************************************************************************************
BOOL CBCGPBaseTabWnd::IsTabVisible(int iTab) const
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		TRACE(_T("IsTabVisible: illegal tab number %d\n"), iTab);
		return FALSE;
	}
	
	const CBCGPTabInfo* pTab = (const CBCGPTabInfo*) m_arTabs [iTab];
	ASSERT_VALID (pTab);
	
	return pTab->m_bVisible;
}
//***************************************************************************************
int CBCGPBaseTabWnd::GetTabNumberToDetach (int nTabNum) const
{
	return (nTabNum == -1 ? m_iActiveTab : nTabNum);
}
//***************************************************************************************
BOOL CBCGPBaseTabWnd::DetachTab (BCGP_DOCK_METHOD dockMethod, int nTabNum, BOOL bHide)
{
	int nTabToDetach = GetTabNumberToDetach (nTabNum);
	if (nTabToDetach < 0)
	{
		return FALSE;
	}

	ASSERT (nTabToDetach >= 0 && nTabToDetach < GetTabsNum ());

	if (!IsTabDetachable (nTabToDetach))
	{
		return FALSE;
	}
	
	CBCGPControlBar* pDockingBar = 
		DYNAMIC_DOWNCAST (CBCGPControlBar, GetTabWnd (nTabToDetach));
	if (pDockingBar == NULL)
	{
		return FALSE;
	}

	ASSERT_VALID (pDockingBar);

	if (!pDockingBar->CanFloat ())
	{
		return FALSE;
	}

	CRect rectFloat; rectFloat.SetRectEmpty ();

	if (!pDockingBar->OnBeforeFloat (rectFloat, dockMethod))
	{
		return FALSE;
	}

	if (dockMethod == DM_MOUSE)
	{
		CPoint ptMouse;
		GetCursorPos (&ptMouse);
		CPoint ptHotDelta = m_ptHot - ptMouse;
		CSize szSencitivity = CBCGPDockingControlBar::GetDragSencitivity ();

		if (abs (ptHotDelta.x) < szSencitivity.cx && abs (ptHotDelta.y) < szSencitivity.cy)
		{
			return FALSE;
		}
	}

	if (pDockingBar != NULL && pDockingBar->CanBeAttached ())
	{
		BCGP_DOCK_TYPE dockType = pDockingBar->GetDockMode ();

		CBCGPBaseTabbedBar* pParent = DYNAMIC_DOWNCAST (CBCGPBaseTabbedBar, GetParent ());
		CBCGPMiniFrameWnd* pMiniFrame = pParent == NULL ? NULL : pParent->GetParentMiniFrame ();
		
		if (pParent != NULL)
		{
			if (pDockingBar->IsKindOf (RUNTIME_CLASS (CBCGPDockingControlBar)))
			{
				((CBCGPDockingControlBar*) pDockingBar)->EnableGripper (TRUE);
			}

			if (!bHide && dockType == DT_STANDARD && dockMethod == DM_MOUSE)
			{
				bHide = TRUE;
			}

			if (/*!bHide && */nTabToDetach != m_iActiveTab)
			{
				pDockingBar->ShowWindow (SW_SHOW);
			}
				
			pParent->FloatTab (pDockingBar, nTabToDetach, dockMethod, bHide);

			if (GetTabsNum () == 0)
			{
				if (pMiniFrame != NULL)
				{
					pMiniFrame->RemoveControlBar (pParent, TRUE);
				}
				else 
				{
					if (pParent->AllowDestroyEmptyTabbedBar ())
					{
						pParent->DestroyWindow ();
					}
					else
					{
						ShowWindow (SW_HIDE);
					}
				}
			}
			else if (GetVisibleTabsNum () == 0)
			{
				pParent->ShowControlBar (FALSE, FALSE, FALSE);
			}
			RecalcLayout ();
		}

		CBCGPMiniFrameWnd* pParentFrame = pDockingBar->GetParentMiniFrame ();
		if (dockType == DT_STANDARD && dockMethod == DM_MOUSE)
		{
			if (pParentFrame != NULL)
			{
				ReleaseCapture ();
				pParentFrame->SetFocus ();
				GetParent ()->SendMessage (WM_IDLEUPDATECMDUI);
			}
		}

		m_bReadyToDetach = FALSE;

		HWND hWndToDestroy = NULL;
		if (GetTabsNum () == 1 && m_bHideSingleTab)
		{
			CRect rectWnd;
			pParent->GetWindowRect (rectWnd);

			CBCGPDockingControlBar* pDockingBar = 
				DYNAMIC_DOWNCAST (CBCGPDockingControlBar, GetTabWnd (0));	

			pParent->InsertControlBar (pDockingBar, pParent);
			pParent->ReplaceControlBar (pDockingBar, dockMethod);
			pDockingBar->SetBarAlignment (pParent->GetCurrentAlignment ());
			RemoveTab (0);
			CWnd* pNewParent = (pMiniFrame == NULL) ? pParent->GetDockSite () 
													: pMiniFrame;

			pDockingBar->EnableGripper (TRUE);
			pNewParent->ScreenToClient (rectWnd);

			pDockingBar->SetParent (pNewParent);
			pDockingBar->SetWindowPos (NULL, rectWnd.left, rectWnd.top, 
										rectWnd.Width (), rectWnd.Height (),
										SWP_NOZORDER | SWP_NOACTIVATE | SWP_HIDEWINDOW);
		
			pDockingBar->ShowControlBar (TRUE, FALSE, FALSE);
			pParent->ShowWindow (SW_HIDE);
			pDockingBar->GetParent ()->InvalidateRect (NULL);
			pDockingBar->GetParent ()->UpdateWindow ();
			hWndToDestroy = pParent->GetSafeHwnd ();
		}

		if (dockMethod == DM_MOUSE && pParentFrame != NULL)
		{
			ASSERT_VALID (pParentFrame);

			if (dockType == DT_STANDARD)
			{
				pParentFrame->EnterDragMode (hWndToDestroy);
				pParentFrame->MoveDragFrame ();
			}
			else if (dockType == DT_IMMEDIATE)
			{
				pParentFrame->SetFocus ();
			}
		}

		return TRUE;
	}

	return FALSE;
}
//***************************************************************************************
void CBCGPBaseTabWnd::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CWnd::OnLButtonDown(nFlags, point);

	int iHighlighted = m_iHighlighted;
	if (iHighlighted >= 0)
	{
		BOOL bTabWasMoved = FALSE;