bcgtabwnd.cpp

一个完整的编辑器的代码（很值得参考

	m_nTabsHorzOffset = min (max (0, m_nTabsHorzOffset), m_nTabsHorzOffsetMax);
	if (nPrevOffset != m_nTabsHorzOffset)
	{
		AdjustTabs ();
		InvalidateRect (m_rectTabsArea);
		UpdateWindow ();

		if (m_nTabsHorzOffset == 0)
		{
			m_wndScrollTabs.EnableScrollBar ();
			m_wndScrollTabs.EnableScrollBar (ESB_DISABLE_LTUP);
		}
		else if (m_nTabsHorzOffset == m_nTabsHorzOffsetMax)
		{
			m_wndScrollTabs.EnableScrollBar ();
			m_wndScrollTabs.EnableScrollBar (ESB_DISABLE_RTDN);
		}
	}
}
//******************************************************************************************
CWnd* CBCGTabWnd::FindTargetWnd (const CPoint& point)
{
	if (point.y < m_nTabsHeight)
	{
		return NULL;
	}

	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGTabInfo* pTab = (CBCGTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);

		if (pTab->m_rect.PtInRect (point))
		{
			return NULL;
		}
	}

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

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

	if (!m_bFlat)
	{
		m_nTabsHorzOffset = 0;
		return;
	}

	if (m_iTabsNum == 0)
	{
		m_wndScrollTabs.EnableScrollBar (ESB_DISABLE_BOTH);
		m_nTabsHorzOffsetMax = 0;
		m_nTabsHorzOffset = 0;
		return;
	}

	int nPrevHorzOffset = m_nTabsHorzOffset;

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

	m_wndScrollTabs.EnableScrollBar ();
	if (m_nTabsHorzOffset <= 0)
	{
		m_nTabsHorzOffset = 0;
		m_wndScrollTabs.EnableScrollBar (ESB_DISABLE_LTUP);
	}

	if (m_nTabsHorzOffset >= m_nTabsHorzOffsetMax)
	{
		m_nTabsHorzOffset = m_nTabsHorzOffsetMax;
		m_wndScrollTabs.EnableScrollBar (ESB_DISABLE_RTDN);
	}

	if (nPrevHorzOffset != m_nTabsHorzOffset)
	{
		AdjustTabs ();
		InvalidateRect (m_rectTabsArea);
		UpdateWindow ();
	}
}
//*************************************************************************************
void CBCGTabWnd::RecalcLayout ()
{
	if (GetSafeHwnd () == NULL)
	{
		return;
	}

	ASSERT_VALID (this);

	CRect rectClient;
	GetClientRect (rectClient);

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

	if (m_bFlat)
	{
		m_rectTabsArea.bottom -= TAB_BORDER_SIZE - 1;
		m_rectTabsArea.top = m_rectTabsArea.bottom - m_nTabsHeight;

		int nScrollBarWidth = ::GetSystemMetrics (SM_CXHSCROLL) * 2;
		int nScrollBarHeight = m_rectTabsArea.Height () - 3;

		m_rectTabsArea.left += nScrollBarWidth + 1;
		m_rectTabsArea.right -= TAB_BORDER_SIZE;

		if (m_rectTabsArea.right < m_rectTabsArea.left)
		{
			nScrollBarWidth = 0;
			m_rectTabsArea.left = rectClient.left + TAB_BORDER_SIZE + 1;
			m_rectTabsArea.right = rectClient.right - TAB_BORDER_SIZE - 1;
		}

		if (m_rectTabsArea.top - TAB_BORDER_SIZE < rectClient.top)
		{
			nScrollBarHeight = 0;
			m_rectTabsArea.left = 0;
			m_rectTabsArea.right = 0;
		}

		ASSERT (m_wndScrollTabs.GetSafeHwnd () != NULL);

		m_wndScrollTabs.SetWindowPos (NULL,
			rectClient.left + TAB_BORDER_SIZE + 1, m_rectTabsArea.top + 1,
			nScrollBarWidth, nScrollBarHeight,
			SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW);
		
	}
	else
	{
		m_rectTabsArea.top = m_rectTabsArea.bottom - m_nTabsHeight;
		m_rectTabsArea.right -= 2 * TAB_BORDER_SIZE;
	}

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

	m_rectWndArea = rectClient;
	m_rectWndArea.DeflateRect (TAB_BORDER_SIZE + 1, TAB_BORDER_SIZE + 1);
	
	if (m_bFlat)
	{
		m_rectWndArea.bottom = m_rectTabsArea.top;
	}
	else
	{
		m_rectWndArea.bottom = m_rectTabsArea.top - 2 * TAB_BORDER_SIZE + 1;
	}

	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGTabInfo* pTab = (CBCGTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);

		pTab->m_pWnd->SetWindowPos (NULL,
			m_rectWndArea.left, m_rectWndArea.top,
			m_rectWndArea.Width () - 1, m_rectWndArea.Height (),
			SWP_NOACTIVATE | SWP_NOZORDER);
	}

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

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

	ASSERT_VALID (this);

	CRect rectScroll = m_rectTabsArea;

	if (m_nHorzScrollWidth >= MIN_SROLL_WIDTH)
	{
		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 ();
	}

	m_wndScrollWnd.SetWindowPos (NULL,
		rectScroll.left, rectScroll.top,
		rectScroll.Width (), rectScroll.Height (),
		SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOCOPYBITS);
}
//***************************************************************************************
BOOL CBCGTabWnd::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 CWnd::OnSetCursor(pWnd, nHitTest, message);
}
//***************************************************************************************
void CBCGTabWnd::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if (m_bTrackSplitter)
	{
		m_bTrackSplitter = FALSE;
		ReleaseCapture ();
	}
	
	CWnd::OnLButtonUp(nFlags, point);
}
//***************************************************************************************
void CBCGTabWnd::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, TAB_BORDER_SIZE);

			InvalidateRect (rect);
		}

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

		InvalidateRect (rectTabSplitter);
		UpdateWindow ();
		AdjustTabsScroll ();
	}
	
	CWnd::OnMouseMove(nFlags, point);
}
//***************************************************************************************
void CBCGTabWnd::OnCancelMode() 
{
	CWnd::OnCancelMode();
	
	if (m_bTrackSplitter)
	{
		m_bTrackSplitter = FALSE;
		ReleaseCapture ();
	}
}
//***********************************************************************************
void CBCGTabWnd::SetActiveTabTextColor (COLORREF clr)
{
	ASSERT (m_bFlat);
	m_clrActiveTabFg = clr;
}
//***********************************************************************************
void CBCGTabWnd::SetActiveTabColor (COLORREF clr)
{
	ASSERT (m_bFlat);

	m_clrActiveTabBk = clr;

	if (m_brActiveTab.GetSafeHandle () != NULL)
	{
		m_brActiveTab.DeleteObject ();
	}

	m_brActiveTab.CreateSolidBrush (GetActiveTabColor ());
}
//**********************************************************************************
void CBCGTabWnd::OnSysColorChange() 
{
	CWnd::OnSysColorChange();

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

		m_brActiveTab.CreateSolidBrush (GetActiveTabColor ());

		Invalidate ();
		UpdateWindow ();
	}
}
//***********************************************************************************
BOOL CBCGTabWnd::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 CBCGTabWnd::HideActiveWindowHorzScrollBar ()
{
	CWnd* pWnd = GetActiveWnd ();
	if (pWnd == NULL)
	{
		return;
	}

	ASSERT_VALID (pWnd);

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

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

		if (pDefaultFont != NULL)	// Just to be relaxed....
		{
			LOGFONT lfDefault;
			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 + 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
	{
		m_nTabsHeight = (max (m_sizeImage.cy + 2 * IMAGE_MARGIN,
			globalData.GetTextHeight () + TEXT_MARGIN / 2));
	}
}
//*************************************************************************************
void CBCGTabWnd::OnSettingChange(UINT uFlags, LPCTSTR lpszSection) 
{
	CWnd::OnSettingChange(uFlags, lpszSection);
	
	//-----------------------------------------------------------------
	// In the flat modetabs height should be same as scroll bar height
	//-----------------------------------------------------------------
	if (m_bFlat)
	{
		SetTabsHeight ();
		RecalcLayout ();
		SynchronizeScrollBar ();
	}
}
//*************************************************************************************
BOOL CBCGTabWnd::EnsureVisible (int iTab)
{
	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		TRACE(_T("EnsureVisible: illegal tab number %d\n"), iTab);
		return FALSE;
	}

	//---------------------------------------------------------
	// Be sure, that active tab is visible (not out of scroll):
	//---------------------------------------------------------
	if (m_bFlat && m_rectTabsArea.Width () > 0)
	{
		CRect rectActiveTab = ((CBCGTabInfo*) m_arTabs [m_iActiveTab])->m_rect;
		BOOL bAdjustTabs = FALSE;

		if (rectActiveTab.left < m_rectTabsArea.left)
		{
			m_nTabsHorzOffset -= (m_rectTabsArea.left - rectActiveTab.left);
			bAdjustTabs = TRUE;
		}
		else if (rectActiveTab.right > m_rectTabsArea.right)
		{
			m_nTabsHorzOffset += (rectActiveTab.right - m_rectTabsArea.right);
			bAdjustTabs = TRUE;
		}

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

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

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

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

	return bRes;
}