bcgptabwnd.cpp

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

			pDefaultFont->GetLogFont (&lfDefault);

			LOGFONT lf;
			memset (&lf, 0, sizeof (LOGFONT));

			lf.lfCharSet = lfDefault.lfCharSet;
			lf.lfHeight = lfDefault.lfHeight;
			_tcscpy (lf.lfFaceName, TABS_FONT);

			CClientDC dc (this);

			TEXTMETRIC tm;

			do
			{
				m_fntTabs.DeleteObject ();
				m_fntTabs.CreateFontIndirect (&lf);

				CFont* pFont = dc.SelectObject (&m_fntTabs);
				ASSERT (pFont != NULL);

				dc.GetTextMetrics (&tm);
				dc.SelectObject (pFont);

				if (tm.tmHeight + CBCGPBaseTabWnd::TAB_TEXT_MARGIN / 2 <= m_nTabsHeight)
				{
					break;
				}

				//------------------
				// Try smaller font:
				//------------------
				if (lf.lfHeight < 0)
				{
					lf.lfHeight ++;
				}
				else
				{
					lf.lfHeight --;
				}
			}
			while (lf.lfHeight != 0);

			//------------------
			// Create bold font:
			//------------------
			lf.lfWeight = FW_BOLD;
			m_fntTabsBold.DeleteObject ();
			m_fntTabsBold.CreateFontIndirect (&lf);
		}
	}
	else
	{
		CBCGPBaseTabWnd::SetTabsHeight ();
	}
}
//*************************************************************************************
void CBCGPTabWnd::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) 
{
	CBCGPBaseTabWnd::OnSettingChange(uFlags, lpszSection);
	
	//-----------------------------------------------------------------
	// In the flat modetabs height should be same as scroll bar height
	//-----------------------------------------------------------------
	if (m_bFlat)
	{
		SetTabsHeight ();
		RecalcLayout ();
		SynchronizeScrollBar ();
	}
}
//*************************************************************************************
BOOL CBCGPTabWnd::EnsureVisible (int iTab)
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		TRACE(_T("EnsureVisible: illegal tab number %d\n"), iTab);
		return FALSE;
	}

	if (!m_bScroll || m_rectTabsArea.Width () <= 0)
	{
		return TRUE;
	}

	//---------------------------------------------------------
	// Be sure, that active tab is visible (not out of scroll):
	//---------------------------------------------------------
	CRect rectTab = ((CBCGPTabInfo*) m_arTabs [iTab])->m_rect;
	BOOL bAdjustTabs = FALSE;

	if (rectTab.left < m_rectTabsArea.left)
	{
		m_nTabsHorzOffset -= (m_rectTabsArea.left - rectTab.left);

		if (m_bIsOneNoteStyle)
		{
			m_nFirstVisibleTab = iTab;
		}

		bAdjustTabs = TRUE;
	}
	else if (rectTab.right > m_rectTabsArea.right &&
		rectTab.Width () <= m_rectTabsArea.Width ())
	{
		if (m_bIsOneNoteStyle)
		{
			if (rectTab.Width () < m_rectTabsArea.Width ())
			{
				while (rectTab.right > m_rectTabsArea.right)
				{
					if (m_nFirstVisibleTab >= m_iTabsNum)
					{
						return FALSE;
					}

					int nDelta = ((CBCGPTabInfo*) m_arTabs [m_nFirstVisibleTab])->m_rect.Width () - 
						(m_rectTabsArea.Height () - TAB_IMAGE_MARGIN - 1);
					
					m_nTabsHorzOffset += nDelta;
					rectTab.OffsetRect (-nDelta, 0);

					m_nFirstVisibleTab ++;
				}
			}
		}
		else
		{
			m_nTabsHorzOffset += (rectTab.right - m_rectTabsArea.right);
		}

		bAdjustTabs = TRUE;
	}

	if (bAdjustTabs)
	{
		AdjustTabs ();
		AdjustTabsScroll ();

		RedrawWindow ();
	}

	return TRUE;
}
//**********************************************************************************
BOOL CBCGPTabWnd::OnNotify (WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	BOOL bRes = CBCGPBaseTabWnd::OnNotify (wParam, lParam, pResult);

	NMHDR* pNMHDR = (NMHDR*)lParam;
	ASSERT (pNMHDR != NULL);

	if (pNMHDR->code == TTN_SHOW && m_ToolTip.GetSafeHwnd () != NULL)
	{
		m_ToolTip.SetWindowPos (&wndTop, -1, -1, -1, -1,
			SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE);
	}

	if (pNMHDR->code == HDN_ITEMCHANGED)
	{
		SynchronizeScrollBar ();
	}

	return bRes;
}
//*********************************************************************************
void CBCGPTabWnd::HideNoTabs (BOOL bHide)
{
	if (m_bHideNoTabs == bHide)
	{
		return;
	}

	m_bHideNoTabs = bHide;

	if (GetSafeHwnd () != NULL)
	{
		RecalcLayout ();
		SynchronizeScrollBar ();
	}
}
//*************************************************************************************
BOOL CBCGPTabWnd::OnCommand(WPARAM wParam, LPARAM lParam) 
{
	const int nScrollOffset = 20;

	BOOL bScrollTabs = FALSE;
	const int nPrevOffset = m_nTabsHorzOffset;

	if ((HWND)lParam == m_btnScrollLeft.GetSafeHwnd ())
	{
		bScrollTabs = TRUE;

		if (m_bIsOneNoteStyle)
		{
			if (m_nFirstVisibleTab > 0)
			{
				m_nTabsHorzOffset -= ((CBCGPTabInfo*) m_arTabs [m_nFirstVisibleTab - 1])->m_rect.Width () - 
					(m_rectTabsArea.Height () - TAB_IMAGE_MARGIN - 2);
				m_nFirstVisibleTab --;
			}
		}
		else
		{
			m_nTabsHorzOffset -= nScrollOffset;
		}
	}
	else if ((HWND)lParam == m_btnScrollRight.GetSafeHwnd ())
	{
		bScrollTabs = TRUE;

		if (m_bIsOneNoteStyle)
		{
			if (m_nFirstVisibleTab < m_iTabsNum)
			{
				m_nTabsHorzOffset += ((CBCGPTabInfo*) m_arTabs [m_nFirstVisibleTab])->m_rect.Width () - 
					(m_rectTabsArea.Height () - TAB_IMAGE_MARGIN - 1);
				m_nFirstVisibleTab ++;
			}
		}
		else
		{
			m_nTabsHorzOffset += nScrollOffset;
		}
	}
	else if ((HWND)lParam == m_btnScrollFirst.GetSafeHwnd ())
	{
		bScrollTabs = TRUE;
		m_nTabsHorzOffset = 0;
	}
	else if ((HWND)lParam == m_btnScrollLast.GetSafeHwnd ())
	{
		bScrollTabs = TRUE;
		m_nTabsHorzOffset = m_nTabsHorzOffsetMax;
	}
	else if ((HWND)lParam == m_btnClose.GetSafeHwnd ())
	{
		CWnd* pWndActive = GetActiveWnd ();
		if (pWndActive != NULL)
		{
			pWndActive->SendMessage (WM_CLOSE);
		}

		return TRUE;
	}

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

		if (nPrevOffset != m_nTabsHorzOffset)
		{
			AdjustTabs ();
			UpdateScrollButtonsState ();
			Invalidate ();
			UpdateWindow ();
		}

		return TRUE;
	}

	return CBCGPBaseTabWnd::OnCommand(wParam, lParam);
}
//*************************************************************************************
void CBCGTabButton::OnFillBackground (CDC* pDC, const CRect& rectClient)
{
	CBCGPVisualManager::GetInstance ()->OnEraseTabsButton (pDC, rectClient, this,
		DYNAMIC_DOWNCAST (CBCGPTabWnd, GetParent ()));
}
//*************************************************************************************
void CBCGTabButton::OnDrawBorder (CDC* pDC, CRect& rectClient, UINT uiState)
{
	CBCGPVisualManager::GetInstance ()->OnDrawTabsButtonBorder (pDC, rectClient,
		this, uiState, DYNAMIC_DOWNCAST (CBCGPTabWnd, GetParent ()));
}
//***********************************************************************************
void CBCGPTabWnd::OnSetFocus(CWnd* pOldWnd) 
{
	CBCGPBaseTabWnd::OnSetFocus(pOldWnd);
	
	CWnd* pWndActive = GetActiveWnd ();
	if (pWndActive != NULL)
	{
		pWndActive->SetFocus ();
	}
}
//************************************************************************************
void CBCGPTabWnd::ReposButtons (CPoint pt, CSize sizeButton, BOOL bHide)
{
	BOOL bIsFirst = TRUE;

	for (POSITION pos = m_lstButtons.GetHeadPosition (); pos != NULL;)
	{
		HWND hWndButton = m_lstButtons.GetNext (pos);
		ASSERT (hWndButton != NULL);

		if (bHide || (!m_bCloseBtn && hWndButton == m_btnClose.GetSafeHwnd ()))
		{
			::SetWindowPos (hWndButton, NULL,
							0, 0, 0, 0,
							SWP_NOACTIVATE | SWP_NOZORDER);
		}
		else
		{
			int x = pt.x;

			if (m_bIsOneNoteStyle && bIsFirst)	// Scroll left is on left
			{
				x = m_rectTabsArea.left - sizeButton.cx - 1;
			}

			::SetWindowPos (hWndButton, NULL,
				x, pt.y,
				sizeButton.cx, sizeButton.cy,
				SWP_NOACTIVATE | SWP_NOZORDER);

			if (!m_bIsOneNoteStyle || !bIsFirst)
			{
				pt.x += sizeButton.cx;
			}
		}

		::InvalidateRect (hWndButton, NULL, TRUE);
		::UpdateWindow (hWndButton);

		bIsFirst = FALSE;
	}
}
//************************************************************************************
BOOL CBCGPTabWnd::IsPtInTabArea (CPoint point) const
{
	return m_rectTabsArea.PtInRect (point);
}
//************************************************************************************
void CBCGPTabWnd::EnableInPlaceEdit (BOOL bEnable)
{
	ASSERT_VALID (this);

	if (!m_bFlat)
	{
		// In-place editing is available for the flat tabs only!
		ASSERT (FALSE);
		return;
	}

	m_bIsInPlaceEdit = bEnable;
}
//************************************************************************************
void CBCGPTabWnd::SetActiveTabBoldFont (BOOL bIsBold)
{
	ASSERT_VALID (this);

	if (m_bFlat && bIsBold)
	{
		ASSERT (FALSE);
		bIsBold = FALSE;
	}

	m_bIsActiveTabBold = bIsBold;

	if (GetSafeHwnd () != NULL)
	{
		RecalcLayout ();
		SynchronizeScrollBar ();
	}
}
//*************************************************************************************
void CBCGPTabWnd::HideSingleTab (BOOL bHide)
{
	if (m_bHideSingleTab == bHide)
	{
		return;
	}

	m_bHideSingleTab = bHide;

	if (GetSafeHwnd () != NULL)
	{
		RecalcLayout ();
		SynchronizeScrollBar ();
	}
}
//*************************************************************************************
void CBCGPTabWnd::UpdateScrollButtonsState ()
{
	ASSERT_VALID (this);

	if (GetSafeHwnd () == NULL || !m_bScroll || m_bFlat)
	{
		return;
	}

	if (m_bIsOneNoteStyle)
	{
		if (m_arTabs.GetSize () == 0)
		{
			m_btnScrollLeft.EnableWindow (FALSE);
			m_btnScrollRight.EnableWindow (FALSE);
		}
		else
		{
			m_btnScrollLeft.EnableWindow (m_nFirstVisibleTab > 0);

			CBCGPTabInfo* pLastTab = (CBCGPTabInfo*) m_arTabs [m_arTabs.GetSize () - 1];
			ASSERT_VALID (pLastTab);

			m_btnScrollRight.EnableWindow (pLastTab->m_rect.right > m_rectTabsArea.right &&
				m_nFirstVisibleTab < m_arTabs.GetSize () - 1);
		}
	}
	else
	{
		m_btnScrollLeft.EnableWindow (m_nTabsHorzOffset > 0);
		m_btnScrollRight.EnableWindow (m_nTabsHorzOffset < m_nTabsHorzOffsetMax);
	}

	for (POSITION pos = m_lstButtons.GetHeadPosition (); pos != NULL;)
	{
		HWND hWndButton = m_lstButtons.GetNext (pos);
		ASSERT (hWndButton != NULL);

		if (!::IsWindowEnabled (hWndButton))
		{
			::SendMessage (hWndButton, WM_CANCELMODE, 0, 0);
		}
	}
}
//*************************************************************************************
BOOL CBCGPTabWnd::ModifyTabStyle (Style style)
{
	ASSERT_VALID (this);

	if (m_bFlat || !m_bScroll)
	{
		ASSERT (FALSE);
		return FALSE;
	}

	ASSERT (style == STYLE_3D_SCROLLED || style == STYLE_3D_ONENOTE);

	m_bIsOneNoteStyle = (style == STYLE_3D_ONENOTE);
	m_bHighLightTabs = m_bIsOneNoteStyle;

	const int nAutoRepeat = m_bIsOneNoteStyle ? 0 : 50;

	m_btnScrollLeft.SetAutorepeatMode (nAutoRepeat);
	m_btnScrollRight.SetAutorepeatMode (nAutoRepeat);

	m_btnScrollLeft.SetStdImage (
		CMenuImages::IdArowLeftTab3d,
		m_bIsOneNoteStyle ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray,
		CMenuImages::IdArowLeftDsbldTab3d);

	m_btnScrollRight.SetStdImage (
		CMenuImages::IdArowRightTab3d,
		m_bIsOneNoteStyle ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray,
		CMenuImages::IdArowRightDsbldTab3d);

	m_btnClose.SetStdImage (CMenuImages::IdClose,
		m_bIsOneNoteStyle ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray);

	return TRUE;
}
//***********************************************************************************
void CBCGPTabWnd::SetDrawFrame (BOOL bDraw)
{
	m_bDrawFrame = bDraw;
}
//**************************************************************************************
DROPEFFECT CBCGPTabWnd::OnDragEnter(COleDataObject* pDataObject, DWORD dwKeyState, CPoint point) 
{
	return OnDragOver(pDataObject, dwKeyState, point);
}
//****************************************************************************************
DROPEFFECT CBCGPTabWnd::OnDragOver(COleDataObject* pDataObject, DWORD dwKeyState, 
										CPoint point) 
{
#ifdef BCG_NO_CUSTOMIZATION
	return DROPEFFECT_NONE;
#else
	if (!GetParent ()->IsKindOf (RUNTIME_CLASS (CBCGPTabbedToolbar)))
	{
		return DROPEFFECT_NONE;
	}

	CBCGPToolbarButton* pButton = CBCGPToolbarButton::CreateFromOleData (pDataObject);
	if (pButton == NULL)
	{
		return DROPEFFECT_NONE;
	}

	if (!pButton->IsKindOf (RUNTIME_CLASS (CBCGPToolbarButton)))
	{
		delete pButton;
		return DROPEFFECT_NONE;
	}

	delete pButton;

	int nTab = GetTabFromPoint (point);
	if (nTab < 0)
	{
		return DROPEFFECT_NONE;
	}

	SetActiveTab (nTab);
	BOOL bCopy = (dwKeyState & MK_CONTROL);

	return (bCopy) ? DROPEFFECT_COPY : DROPEFFECT_MOVE;
#endif // BCG_NO_CUSTOMIZATION
}
//***************************************************************************************
int CBCGPTabWnd::GetTabFromPoint (CPoint& pt) const
{
	ASSERT_VALID (this);

	if (!m_rectTabsArea.PtInRect (pt))
	{
		return -1;
	}

	if (!m_bIsOneNoteStyle)
	{
		return CBCGPBaseTabWnd::GetTabFromPoint (pt);
	}

	//------------------------
	// Check active tab first:
	//------------------------
	if (m_iActiveTab >= 0)
	{
		CBCGPTabInfo* pActiveTab = (CBCGPTabInfo*) m_arTabs [m_iActiveTab];
		ASSERT_VALID (pActiveTab);

		CRect rectTab = pActiveTab->m_rect;

		if (rectTab.PtInRect (pt))
		{
			if (m_iActiveTab > 0 && pt.x < rectTab.left + rectTab.Height ())
			{
				const int x = pt.x - rectTab.left;
				const int y = pt.y - rectTab.top;

				if (x * x + y * y < rectTab.Height () * rectTab.Height () / 2)
				{
					for (int i = m_iActiveTab - 1; i >= 0; i--)
					{
						CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
						ASSERT_VALID (pTab);

						if (pTab->m_bVisible)
						{
							return i;
						}
					}
				}
			}

			return m_iActiveTab;
		}
	}

	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;
}
//***************************************************************************************
void CBCGPTabWnd::SwapTabs (int nFisrtTabID, int nSecondTabID)
{
	CBCGPBaseTabWnd::SwapTabs (nFisrtTabID, nSecondTabID);

	if (m_bIsOneNoteStyle)
	{
		m_nTabsHorzOffset = 0;
		m_nFirstVisibleTab = 0;
	}
}
//***************************************************************************************
void CBCGPTabWnd::MoveTab(int nSource, int nDest)
{
	CBCGPBaseTabWnd::MoveTab (nSource, nDest);

	if (m_bIsOneNoteStyle)
	{
		m_nTabsHorzOffset = 0;
		m_nFirstVisibleTab = 0;

		EnsureVisible (m_iActiveTab);
	}
}

#endif // BCG_NO_TABCTRL