bcgptabwnd.cpp

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

	return TRUE;
}
//****************************************************************************************
BOOL CBCGPTabWnd::PreTranslateMessage(MSG* pMsg) 
{
   	switch (pMsg->message)
	{
	case WM_KEYDOWN:
		if (m_iActiveTab != -1 &&
			::GetAsyncKeyState (VK_CONTROL) & 0x8000)	// Ctrl is pressed
		{
			switch (pMsg->wParam)
			{
			case VK_NEXT:
				{
					for (int i = m_iActiveTab + 1; i < m_iActiveTab + m_iTabsNum; ++i)
					{
						int iTabIndex = i % m_iTabsNum;
						if (IsTabVisible (iTabIndex))
						{
							SetActiveTab (iTabIndex);
							GetActiveWnd ()->SetFocus ();
							GetParent ()->SendMessage (BCGM_CHANGE_ACTIVE_TAB, m_iActiveTab);
							break;
						}
					}
					return TRUE;
				}
			case VK_PRIOR:
				{
					for (int i = m_iActiveTab - 1 + m_iTabsNum; i > m_iActiveTab; --i)
					{
						int iTabIndex = i % m_iTabsNum;
						if (IsTabVisible (iTabIndex))
						{
							SetActiveTab (iTabIndex);
							GetActiveWnd ()->SetFocus ();
							GetParent ()->SendMessage (BCGM_CHANGE_ACTIVE_TAB, m_iActiveTab);
							break;
						}
					}
					return TRUE;
				}
			}
		}
			
		// Continue....

	case WM_SYSKEYDOWN:
	case WM_LBUTTONDOWN:
	case WM_RBUTTONDOWN:
	case WM_MBUTTONDOWN:
	case WM_LBUTTONUP:
	case WM_RBUTTONUP:
	case WM_MBUTTONUP:
	case WM_NCLBUTTONDOWN:
	case WM_NCRBUTTONDOWN:
	case WM_NCMBUTTONDOWN:
	case WM_NCLBUTTONUP:
	case WM_NCRBUTTONUP:
	case WM_NCMBUTTONUP:
	case WM_MOUSEMOVE:
		if (m_ToolTip.GetSafeHwnd () != NULL)
		{
			m_ToolTip.RelayEvent(pMsg);
		}
		break;
	}

	return CBCGPBaseTabWnd::PreTranslateMessage(pMsg);
}
//******************************************************************************************
void CBCGPTabWnd::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	if (!m_bFlat)
	{
		CBCGPBaseTabWnd::OnHScroll (nSBCode, nPos, pScrollBar);
		return;
	}

	if (pScrollBar->GetSafeHwnd () == m_wndScrollWnd.GetSafeHwnd ())
	{
		static BOOL bInsideScroll = FALSE;

		if (m_iActiveTab != -1 && !bInsideScroll)
		{
			CWnd* pWndActive = GetActiveWnd ();
			ASSERT_VALID (pWndActive);

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

			WPARAM wParam = MAKEWPARAM (nSBCode, nPos);

			//----------------------------------
			// Pass scroll to the active window:
			//----------------------------------
			bInsideScroll = TRUE;

			if (pTab->m_bIsListView &&
				(LOBYTE (nSBCode) == SB_THUMBPOSITION ||
				LOBYTE (nSBCode) == SB_THUMBTRACK))
			{
				int dx = nPos - pWndActive->GetScrollPos (SB_HORZ);
				pWndActive->SendMessage (LVM_SCROLL, dx, 0);
			}

			pWndActive->SendMessage (WM_HSCROLL, wParam, 0);

			bInsideScroll = FALSE;

			m_wndScrollWnd.SetScrollPos (pWndActive->GetScrollPos (SB_HORZ));

			HideActiveWindowHorzScrollBar ();
			GetParent ()->SendMessage (BCGM_ON_HSCROLL, wParam);
		}

		return;
	}

	CBCGPBaseTabWnd::OnHScroll (nSBCode, nPos, pScrollBar);
}
//******************************************************************************************
CWnd* CBCGPTabWnd::FindTargetWnd (const CPoint& point)
{
	if (point.y < m_nTabsHeight)
	{
		return NULL;
	}

	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);
		
		if (!pTab->m_bVisible)
			continue;
		
		if (pTab->m_rect.PtInRect (point))
		{
			return NULL;
		}
	}

	CWnd* pWndParent = GetParent ();
	ASSERT_VALID (pWndParent);

	return pWndParent;
}
//************************************************************************************
void CBCGPTabWnd::AdjustTabsScroll ()
{
	ASSERT_VALID (this);

	if (!m_bScroll)
	{
		m_nTabsHorzOffset = 0;
		m_nFirstVisibleTab = 0;
		return;
	}

	if (m_iTabsNum == 0)
	{
		m_nTabsHorzOffsetMax = 0;
		m_nTabsHorzOffset = 0;
		m_nFirstVisibleTab = 0;
		return;
	}

	int nPrevHorzOffset = m_nTabsHorzOffset;

	m_nTabsHorzOffsetMax = max (0, m_nTabsTotalWidth - m_rectTabsArea.Width ());

	if (m_bIsOneNoteStyle)
	{
		m_nTabsHorzOffset = max (0, m_nTabsHorzOffset);
	}
	else
	{
		m_nTabsHorzOffset = min (max (0, m_nTabsHorzOffset), m_nTabsHorzOffsetMax);
	}

	if (nPrevHorzOffset != m_nTabsHorzOffset)
	{
		AdjustTabs ();
		InvalidateRect (m_rectTabsArea);
		UpdateWindow ();
	}

	UpdateScrollButtonsState ();
}
//*************************************************************************************
void CBCGPTabWnd::RecalcLayout ()
{
	if (GetSafeHwnd () == NULL)
	{
		return;
	}

	ASSERT_VALID (this);

	int nTabsHeight = GetTabsHeight ();
	const int nTabBorderSize = GetTabBorderSize ();

	int nVisiableTabs = GetVisibleTabsNum ();

	BOOL bHideTabs =	(m_bHideSingleTab && nVisiableTabs <= 1) ||
						(m_bHideNoTabs && nVisiableTabs == 0);

	CRect rectClient;
	GetClientRect (rectClient);

	m_rectTabsArea = rectClient;
	m_rectTabsArea.DeflateRect (nTabBorderSize, 0);

	int nScrollBtnWidth = 0;
	int nButtons = 0;
	int nButtonsWidth = 0;
	int nButtonsHeight = 0;

	if (m_bScroll)
	{
		nScrollBtnWidth = CMenuImages::Size ().cx + 4 +
			CBCGPVisualManager::GetInstance ()->GetButtonExtraBorder ().cx;

		if (!m_bFlat)
		{
			nScrollBtnWidth = min (nTabsHeight - 4 , nScrollBtnWidth + 2);
		}
		
		nButtons = m_lstButtons.GetCount ();
		if (!m_bCloseBtn)
		{
			nButtons--;
		}

		nButtonsWidth = bHideTabs ? 0 : nScrollBtnWidth * nButtons;
	}

	if (m_bFlat)
	{
		if (m_location == LOCATION_BOTTOM)
		{
			if (nTabBorderSize > 1)
			{
				m_rectTabsArea.bottom -= nTabBorderSize - 1;
			}

			m_rectTabsArea.top = m_rectTabsArea.bottom - nTabsHeight;
		}
		else
		{
			if (nTabBorderSize > 1)
			{
				m_rectTabsArea.top += nTabBorderSize - 1;
			}

			m_rectTabsArea.bottom = m_rectTabsArea.top + nTabsHeight;
		}

		m_rectTabsArea.left += nButtonsWidth + 1;
		m_rectTabsArea.right -= nTabBorderSize;

		if (m_rectTabsArea.right < m_rectTabsArea.left)
		{
			if (nTabBorderSize > 0)
			{
				m_rectTabsArea.left = rectClient.left + nTabBorderSize + 1;
				m_rectTabsArea.right = rectClient.right - nTabBorderSize - 1;
			}
			else
			{
				m_rectTabsArea.left = rectClient.left;
				m_rectTabsArea.right = rectClient.right;
			}
		}

		nButtonsHeight = m_rectTabsArea.Height ();

		if (m_rectTabsArea.Height () + nTabBorderSize > rectClient.Height ())
		{
			nButtonsHeight = 0;
			m_rectTabsArea.left = 0;
			m_rectTabsArea.right = 0;
		}

		int y = m_rectTabsArea.top;

		if (nButtonsHeight != 0)
		{
			y += max (0, (nButtonsHeight - nScrollBtnWidth) / 2);
			nButtonsHeight = nScrollBtnWidth;
		}

		// Reposition scroll butons:
		ReposButtons (	CPoint (rectClient.left + nTabBorderSize + 1, y), 
						CSize (nScrollBtnWidth, nButtonsHeight),
						bHideTabs);
	}
	else
	{
		if (m_location == LOCATION_BOTTOM)
		{
			m_rectTabsArea.top = m_rectTabsArea.bottom - nTabsHeight;
		}
		else
		{
			m_rectTabsArea.bottom = m_rectTabsArea.top + nTabsHeight;
		}

		if (m_bScroll)
		{
			m_rectTabsArea.right -= nButtonsWidth;

			if (m_bIsOneNoteStyle)
			{
				m_rectTabsArea.OffsetRect (nScrollBtnWidth, 0);
			}

			// Reposition scroll butons:
			ReposButtons (	
				CPoint (m_rectTabsArea.right, m_rectTabsArea.CenterPoint ().y - nScrollBtnWidth / 2),
				CSize (nScrollBtnWidth, nScrollBtnWidth), bHideTabs);
		}

		m_rectTabsArea.right -= 2 * nTabBorderSize;
	}

	m_rectWndArea = rectClient;
	m_nScrollBarRight = m_rectTabsArea.right - ::GetSystemMetrics (SM_CXVSCROLL);

	if (nTabBorderSize > 0)
	{
		m_rectWndArea.DeflateRect (nTabBorderSize + 1, nTabBorderSize + 1);
	}
	
	if (m_bFlat)
	{
		if (m_location == LOCATION_BOTTOM)
		{
			m_rectWndArea.bottom = m_rectTabsArea.top;

			if (nTabBorderSize == 0)
			{
				m_rectWndArea.top++;
				m_rectWndArea.left++;
			}
		}
		else
		{
			m_rectWndArea.top = m_rectTabsArea.bottom + nTabBorderSize;

			if (nTabBorderSize == 0)
			{
				m_rectWndArea.bottom--;
				m_rectWndArea.left++;
			}
		}
	}
	else
	{
		if (m_location == LOCATION_BOTTOM)
		{
			m_rectWndArea.bottom = m_rectTabsArea.top - 2 * nTabBorderSize;
		}
		else
		{
			m_rectWndArea.top = m_rectTabsArea.bottom + 2 * nTabBorderSize;
		}
	}

	if (m_bAutoSizeWindow)
	{
		for (int i = 0; i < m_iTabsNum; i ++)
		{
			CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
			ASSERT_VALID (pTab);
			
			if (pTab->m_bVisible && pTab->m_pWnd->GetSafeHwnd () != NULL)
			{
				pTab->m_pWnd->SetWindowPos (NULL,
					m_rectWndArea.left, m_rectWndArea.top,
					m_rectWndArea.Width (), m_rectWndArea.Height (),
					SWP_NOACTIVATE | SWP_NOZORDER);
			}
		}
	}

	AdjustWndScroll ();
	AdjustTabs ();
	AdjustTabsScroll ();

	Invalidate ();
	UpdateWindow ();
}
//*************************************************************************************
void CBCGPTabWnd::AdjustWndScroll ()
{
	if (!m_bSharedScroll)
	{
		return;
	}

	ASSERT_VALID (this);

	CRect rectScroll = m_rectTabsArea;

	int nVisiableTabs = GetVisibleTabsNum ();

	BOOL bHideTabs =	(m_bHideSingleTab && nVisiableTabs <= 1) ||
						(m_bHideNoTabs && nVisiableTabs == 0);

	if (!bHideTabs)
	{
		if (m_nHorzScrollWidth >= MIN_SROLL_WIDTH)
		{
			rectScroll.top++;
			rectScroll.right = m_nScrollBarRight;
			rectScroll.left = rectScroll.right - m_nHorzScrollWidth;
			rectScroll.bottom -= 2;

			m_rectTabSplitter = rectScroll;
			m_rectTabSplitter.top ++;
			m_rectTabSplitter.right = rectScroll.left;
			m_rectTabSplitter.left = m_rectTabSplitter.right - SPLITTER_WIDTH;

			m_rectTabsArea.right = m_rectTabSplitter.left;
			
			ASSERT (!m_rectTabSplitter.IsRectEmpty ());
		}
		else
		{
			rectScroll.SetRectEmpty ();
			m_rectTabSplitter.SetRectEmpty ();
		}
	}
	else
	{
		rectScroll.bottom -= 2;
		m_rectTabSplitter.SetRectEmpty ();
	}

	m_wndScrollWnd.SetWindowPos (NULL,
		rectScroll.left, rectScroll.top,
		rectScroll.Width (), rectScroll.Height (),
		SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOCOPYBITS);
}
//***************************************************************************************
BOOL CBCGPTabWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if (m_bFlat && !m_rectTabSplitter.IsRectEmpty ())
	{
		CPoint ptCursor;
		::GetCursorPos (&ptCursor);
		ScreenToClient (&ptCursor);

		if (m_rectTabSplitter.PtInRect (ptCursor))
		{
			::SetCursor (globalData.m_hcurStretch);
			return TRUE;
		}
	}
	
	return CBCGPBaseTabWnd::OnSetCursor(pWnd, nHitTest, message);
}
//***************************************************************************************
void CBCGPTabWnd::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_bTrackSplitter)
	{
		m_bTrackSplitter = FALSE;
		ReleaseCapture ();
	}
	
	CBCGPBaseTabWnd::OnLButtonUp(nFlags, point);
}
//***************************************************************************************
void CBCGPTabWnd::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (m_bTrackSplitter)
	{
		int nSplitterLeftPrev = m_rectTabSplitter.left;

		m_nHorzScrollWidth = min (
			m_nScrollBarRight - m_rectTabsArea.left - SPLITTER_WIDTH, 
			m_nScrollBarRight - point.x);

		m_nHorzScrollWidth = max (MIN_SROLL_WIDTH, m_nHorzScrollWidth);
		AdjustWndScroll ();

		if (m_rectTabSplitter.left > nSplitterLeftPrev)
		{
			CRect rect = m_rectTabSplitter;
			rect.left = nSplitterLeftPrev - 20;
			rect.right = m_rectTabSplitter.left;
			rect.InflateRect (0, GetTabBorderSize () + 1);

			InvalidateRect (rect);
		}

		CRect rectTabSplitter = m_rectTabSplitter;
		rectTabSplitter.InflateRect (0, GetTabBorderSize ());

		InvalidateRect (rectTabSplitter);
		UpdateWindow ();
		AdjustTabsScroll ();
	}

	if (m_bIsOneNoteStyle &&
		!CBCGPVisualManager::GetInstance ()->IsHighlightOneNoteTabs ())
	{
		m_bHighLightTabs = FALSE;
	}

	CBCGPBaseTabWnd::OnMouseMove(nFlags, point);
}
//***********************************************************************************
void CBCGPTabWnd::OnCancelMode() 
{
	CBCGPBaseTabWnd::OnCancelMode();
	
	if (m_bTrackSplitter)
	{
		m_bTrackSplitter = FALSE;
		ReleaseCapture ();
	}
}
//**********************************************************************************
void CBCGPTabWnd::OnSysColorChange() 
{
	CBCGPBaseTabWnd::OnSysColorChange();

	if (m_bFlat && m_clrActiveTabFg == (COLORREF) -1)
	{
		if (m_brActiveTab.GetSafeHandle () != NULL)
		{
			m_brActiveTab.DeleteObject ();
		}

		m_brActiveTab.CreateSolidBrush (GetActiveTabColor ());

		Invalidate ();
		UpdateWindow ();
	}
}
//***********************************************************************************
BOOL CBCGPTabWnd::SynchronizeScrollBar (SCROLLINFO* pScrollInfo/* = NULL*/)
{
	if (!m_bSharedScroll)
	{
		return FALSE;
	}

	ASSERT_VALID (this);

	SCROLLINFO scrollInfo;
	memset (&scrollInfo, 0, sizeof (SCROLLINFO));

	scrollInfo.cbSize = sizeof (SCROLLINFO);
	scrollInfo.fMask = SIF_ALL;

	CWnd* pWndActive = GetActiveWnd ();

	if (pScrollInfo != NULL)
	{
		scrollInfo = *pScrollInfo;
	}
	else if (pWndActive != NULL)
	{
		if (!pWndActive->GetScrollInfo (SB_HORZ, &scrollInfo) ||
			scrollInfo.nMin + (int) scrollInfo.nPage >= scrollInfo.nMax)
		{
			m_wndScrollWnd.EnableScrollBar (ESB_DISABLE_BOTH);
			return TRUE;
		}
	}

	m_wndScrollWnd.EnableScrollBar (ESB_ENABLE_BOTH);
	m_wndScrollWnd.SetScrollInfo (&scrollInfo);

	HideActiveWindowHorzScrollBar ();
	return TRUE;
}
//*************************************************************************************
void CBCGPTabWnd::HideActiveWindowHorzScrollBar ()
{
	CWnd* pWnd = GetActiveWnd ();
	if (pWnd == NULL || !m_bSharedScroll)
	{
		return;
	}

	ASSERT_VALID (pWnd);

	pWnd->ShowScrollBar (SB_HORZ, FALSE);
	pWnd->ModifyStyle (WS_HSCROLL, 0, SWP_DRAWFRAME);
}
//************************************************************************************
void CBCGPTabWnd::SetTabsHeight ()
{
	if (m_bFlat)
	{
		m_nTabsHeight = ::GetSystemMetrics (SM_CYHSCROLL) + CBCGPBaseTabWnd::TAB_TEXT_MARGIN / 2;

		CFont* pDefaultFont = 
			CFont::FromHandle ((HFONT) ::GetStockObject (DEFAULT_GUI_FONT));
		ASSERT_VALID (pDefaultFont);

		if (pDefaultFont != NULL)	// Just to be relaxed....
		{
			LOGFONT lfDefault;