bcgptabwnd.cpp

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

		bEnableSetRedraw = !pParentFrame->m_bClosing;
	}

	if (m_iTabsNum > 1 && bEnableSetRedraw)
	{
		pWndParent->SetRedraw (FALSE);
	}

	if (m_iActiveTab != -1 && m_bHideInactiveWnd)
	{
		//--------------------
		// Hide active window:
		//--------------------
		CWnd* pWndActive = GetActiveWnd ();
		if (pWndActive != NULL)
		{
			pWndActive->ShowWindow (SW_HIDE);
		}
	}

	m_iActiveTab = iTab;
	
	//------------------------
	// Show new active window:
	//------------------------
	HideActiveWindowHorzScrollBar ();

	CWnd* pWndActive = GetActiveWnd ();
	if (pWndActive == NULL)
	{
		ASSERT (FALSE);
		pWndParent->SetRedraw (TRUE);
		return FALSE;
	}

	ASSERT_VALID (pWndActive);

	pWndActive->ShowWindow (SW_SHOW);
	if (!m_bHideInactiveWnd)
	{
		pWndActive->BringWindowToTop ();
	}

	if (m_bAutoSizeWindow)
	{
		//----------------------------------------------------------------------
		// Small trick: to adjust active window scroll sizes, I should change an
		// active window size twice (+1 pixel and -1 pixel):
		//----------------------------------------------------------------------
		pWndActive->SetWindowPos (NULL,
				-1, -1,
				m_rectWndArea.Width () + 1, m_rectWndArea.Height (),
				SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
		pWndActive->SetWindowPos (NULL,
				-1, -1,
				m_rectWndArea.Width (), m_rectWndArea.Height (),
				SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
	}

	EnsureVisible (m_iActiveTab);

	if (m_bFlat)
	{
		SynchronizeScrollBar ();
	}

	//--------------------------------------------------
	// Set text to the parent frame/docking control bar:
	//--------------------------------------------------
	CBCGPTabbedControlBar* pTabControlBar = 
		DYNAMIC_DOWNCAST (CBCGPTabbedControlBar, GetParent ());
	if (pTabControlBar != NULL && pTabControlBar->CanSetCaptionTextToTabName ()) // tabbed dock bar - redraw caption only in this case
	{
		CString strCaption;
		GetTabLabel (m_iActiveTab, strCaption);

		// miniframe will take the text from the tab control bar
		pTabControlBar->SetWindowText (strCaption);

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

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

	//-------------
	// Redraw tabs:
	//-------------
	Invalidate ();
	UpdateWindow ();

	if (!bIsFirstTime)
	{
		CView* pActiveView = DYNAMIC_DOWNCAST (CView, pWndActive);
		if (pActiveView != NULL)
		{
			CFrameWnd* pFrame = BCGPGetParentFrame (pActiveView);
			ASSERT_VALID (pFrame);

			pFrame->SetActiveView (pActiveView);
		}
		else if (m_bEnableActivate)
		{
			pWndActive->SetFocus ();
		}
	}

	if (m_btnClose.GetSafeHwnd () != NULL)
	{
		//----------------------------------------------------
		// Enable/disable "Close" button according to ability 
		// to close an active window:
		//----------------------------------------------------
		BOOL bEnableClose = TRUE;

		HMENU hSysMenu = pWndActive->GetSystemMenu (FALSE)->GetSafeHmenu ();
		if (hSysMenu != NULL)
		{
			MENUITEMINFO menuInfo;
			ZeroMemory(&menuInfo,sizeof(MENUITEMINFO));
			menuInfo.cbSize = sizeof(MENUITEMINFO);
			menuInfo.fMask = MIIM_STATE;

			if (!::GetMenuItemInfo (hSysMenu, SC_CLOSE, FALSE, &menuInfo) ||
				(menuInfo.fState & MFS_GRAYED) || 
				(menuInfo.fState & MFS_DISABLED))
			{
				bEnableClose = FALSE;
			}
		}

		m_btnClose.EnableWindow (bEnableClose);
	}
	
	if (m_iTabsNum > 1 && bEnableSetRedraw)
	{
		pWndParent->SetRedraw (TRUE);
		pWndParent->RedrawWindow (NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
	}
	
	pWndParent->SendMessage (BCGM_CHANGE_ACTIVE_TAB, m_iActiveTab, (LPARAM) this);

	return TRUE;
}
//***************************************************************************************
void CBCGPTabWnd::AdjustTabs ()
{
	int	nVisibleTabsNum	= GetVisibleTabsNum ();
	if (nVisibleTabsNum == 0 || GetTabsHeight () == 0)
	{
		return;
	}

	if (m_bHideSingleTab && nVisibleTabsNum <= 1)
	{
		for (int i = 0; i < m_iTabsNum; i ++)
		{
			CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
			ASSERT_VALID (pTab);
			
			pTab->m_rect.SetRectEmpty ();
		}

		return;
	}

	//-------------------------
	// Define tab's full width:
	//-------------------------
	CClientDC dc (this);

	CFont* pOldFont = dc.SelectObject (m_bFlat ? 
		&m_fntTabsBold : &globalData.fontRegular);
	ASSERT(pOldFont != NULL);

	m_nTabsTotalWidth = 0;

	//----------------------------------------------
	// First, try set all tabs in its original size:
	//----------------------------------------------
	int x = m_rectTabsArea.left - m_nTabsHorzOffset;
	for (int i = 0; i < m_iTabsNum; i ++)
	{
		CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTab);
		
		CSize sizeImage (0, 0);
		if (pTab->m_hIcon != NULL || pTab->m_uiIcon != (UINT)-1)
		{
			sizeImage = m_sizeImage;
		}

		if (m_bIsActiveTabBold && (m_bIsOneNoteStyle || i == m_iActiveTab))
		{
			dc.SelectObject (&globalData.fontBold);
		}

		int nExtraWidth = 0;

		if (pTab->m_bVisible)
		{
			pTab->m_nFullWidth = sizeImage.cx + TAB_IMAGE_MARGIN +
				(pTab->m_bIconOnly ? 
					0 : dc.GetTextExtent (pTab->m_strText).cx) + 2 * TAB_TEXT_MARGIN;

			if (m_bIsOneNoteStyle)
			{
				pTab->m_nFullWidth += m_rectTabsArea.Height () + 2 * TAB_IMAGE_MARGIN;
				nExtraWidth = m_rectTabsArea.Height () - TAB_IMAGE_MARGIN - 1;
			}
		}
		else
		{
			pTab->m_nFullWidth = 0;
		}
			
		if (m_bIsActiveTabBold && i == m_iActiveTab)
		{
			dc.SelectObject (&globalData.fontRegular);	// Bold tab is availible for 3d tabs only
		}

		pTab->m_rect = CRect (CPoint (x, m_rectTabsArea.top),
						CSize (pTab->m_nFullWidth, m_rectTabsArea.Height () - 2));
		
		if (!pTab->m_bVisible)
			continue;
		
		if (m_location == LOCATION_TOP)
		{
			pTab->m_rect.OffsetRect (0, 2);
		}

		if (m_ToolTip.GetSafeHwnd () != NULL)
		{
			BOOL bShowTooltip = pTab->m_bAlwaysShowToolTip;

			if (pTab->m_rect.left < m_rectTabsArea.left ||
				pTab->m_rect.right > m_rectTabsArea.right)
			{
				bShowTooltip = TRUE;
			}

			m_ToolTip.SetToolRect (this, pTab->m_iTabID, 
				bShowTooltip ? pTab->m_rect : CRect (0, 0, 0, 0));
		}

		x += pTab->m_rect.Width () + 1 - nExtraWidth;
		m_nTabsTotalWidth += pTab->m_rect.Width () + 1;

		if (i > 0)
		{
			m_nTabsTotalWidth -= nExtraWidth;
		}

		if (m_bFlat)
		{
			//--------------------------------------------
			// In the flat mode tab is overlapped by next:
			//--------------------------------------------
			pTab->m_rect.right += m_nTabsHeight / 2;
		}
	}

	if (m_bScroll || x < m_rectTabsArea.right)
	{
		m_nTabsTotalWidth += m_nTabsHeight / 2;
	}
	else
	{
		//-----------------------------------------
		// Not enouth space to show the whole text.
		//-----------------------------------------
		int nTabWidth = m_rectTabsArea.Width () / nVisibleTabsNum;

		//------------------------------------
		// May be it's too wide for some tabs?
		//------------------------------------
		int nRest = 0;
		int nCutTabsNum = nVisibleTabsNum;

		for (i = 0; i < m_iTabsNum; i ++)
		{
			CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
			ASSERT_VALID (pTab);
			
			if (!pTab->m_bVisible)
				continue;
			
			if (pTab->m_nFullWidth < nTabWidth)
			{
				nRest += nTabWidth - pTab->m_nFullWidth;
				nCutTabsNum --;
			}
		}

		if (nCutTabsNum > 0)
		{
			nTabWidth += nRest / nCutTabsNum;

			//----------------------------------
			// Last pass: set actual rectangles:
			//----------------------------------
			x = m_rectTabsArea.left;
			for (i = 0; i < m_iTabsNum; i ++)
			{
				CBCGPTabInfo* pTab = (CBCGPTabInfo*) m_arTabs [i];
				ASSERT_VALID (pTab);
				
				if (!pTab->m_bVisible)
				{
					m_ToolTip.SetToolRect (this, pTab->m_iTabID, CRect (0, 0, 0, 0));
					continue;
				}
				
				CSize sizeImage (0, 0);
				if (pTab->m_hIcon != NULL || pTab->m_uiIcon != (UINT)-1)
				{
					sizeImage = m_sizeImage;
				}

				BOOL bIsTrucncated = pTab->m_nFullWidth > nTabWidth;
				int nCurrTabWidth = (bIsTrucncated) ? nTabWidth : pTab->m_nFullWidth;

				if (nTabWidth < sizeImage.cx + TAB_IMAGE_MARGIN)
				{
					// Too narrow!
					nCurrTabWidth = (m_rectTabsArea.Width () + m_nTabBorderSize * 2) / nVisibleTabsNum;
				}
				else
				{
					if (pTab->m_strText.IsEmpty () || pTab->m_bIconOnly)
					{
						nCurrTabWidth = sizeImage.cx + 2 * CBCGPBaseTabWnd::TAB_TEXT_MARGIN;
					}
				}

				pTab->m_rect = CRect (CPoint (x, m_rectTabsArea.top),
								CSize (nCurrTabWidth, m_rectTabsArea.Height () - 2));

				if (!m_bFlat)
				{
					if (m_location == LOCATION_TOP)
					{
						pTab->m_rect.OffsetRect (0, 2);
					}

					if (m_ToolTip.GetSafeHwnd () != NULL)
					{
						m_ToolTip.SetToolRect (this, pTab->m_iTabID, 
							bIsTrucncated || pTab->m_bAlwaysShowToolTip ? 
								pTab->m_rect : CRect (0, 0, 0, 0));
					}
				}

				x += nCurrTabWidth;
				if (nRest > 0)
				{
					x ++;
				}
			}
		}
	}

	dc.SelectObject(pOldFont);
}
//***************************************************************************************
void CBCGPTabWnd::Draw3DTab (CDC* pDC, CBCGPTabInfo* pTab, BOOL bActive)
{
	ASSERT_VALID (pTab);
	ASSERT_VALID (pDC);

	ASSERT_VALID (pTab);
	ASSERT_VALID (pDC);

	if (m_bIsOneNoteStyle && pTab->m_rect.left < m_rectTabsArea.left)
	{
		return;
	}

	if (pTab->m_bVisible)
	{
		CBCGPVisualManager::GetInstance ()->OnDrawTab (
			pDC, pTab->m_rect, m_iCurTab, bActive, this);
	}
}
//***************************************************************************************
void CBCGPTabWnd::DrawFlatTab (CDC* pDC, CBCGPTabInfo* pTab, BOOL bActive)
{
	ASSERT_VALID (pTab);
	ASSERT_VALID (pDC);

	if (pTab->m_bVisible)
	{
		CBCGPVisualManager::GetInstance ()->OnDrawTab (
			pDC, pTab->m_rect, m_iCurTab, bActive, this);
	}
}
//***************************************************************************************
void CBCGPTabWnd::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if (m_rectTabSplitter.PtInRect (point))
	{
		m_bTrackSplitter = TRUE;
		SetCapture ();
		return;
	}

	CBCGPBaseTabWnd::OnLButtonDown(nFlags, point);

	if (!m_bReadyToDetach)
	{
		CWnd* pWndTarget = FindTargetWnd (point);
		if (pWndTarget != NULL)
		{
			ASSERT_VALID (pWndTarget);

			MapWindowPoints (pWndTarget, &point, 1);
			pWndTarget->SendMessage (WM_LBUTTONDOWN, nFlags, 
									MAKELPARAM (point.x, point.y));
		}
	}
}
//***************************************************************************************
void CBCGPTabWnd::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	for (POSITION pos = m_lstButtons.GetHeadPosition (); pos != NULL;)
	{
		CWnd* pWndBtn = CWnd::FromHandle (m_lstButtons.GetNext (pos));
		ASSERT_VALID (pWndBtn);

		CRect rectBtn;
		pWndBtn->GetClientRect (rectBtn);

		pWndBtn->MapWindowPoints (this, rectBtn);

		if (rectBtn.PtInRect (point))
		{
			return;
		}
	}

	CWnd* pWndTarget = FindTargetWnd (point);
	if (pWndTarget != NULL)
	{
		ASSERT_VALID (pWndTarget);

		MapWindowPoints (pWndTarget, &point, 1);
		pWndTarget->SendMessage (WM_LBUTTONDBLCLK, nFlags, 
								MAKELPARAM (point.x, point.y));
	}
	else
	{
		CBCGPBaseTabWnd::OnLButtonDblClk(nFlags, point);
	}
}
//****************************************************************************************
int CBCGPTabWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CBCGPBaseTabWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	CRect rectDummy (0, 0, 0, 0);

	if (m_bScroll)
	{
		//-----------------------
		// Create scroll buttons:
		//-----------------------
		if (m_bFlat)
		{
			m_btnScrollFirst.Create (_T(""), WS_CHILD | WS_VISIBLE, rectDummy, this, (UINT) -1);
			m_btnScrollFirst.SetStdImage (CMenuImages::IdArowFirst);
			m_btnScrollFirst.m_bDrawFocus = FALSE;
			m_btnScrollFirst.m_nFlatStyle = CBCGPButton::BUTTONSTYLE_FLAT;
			m_lstButtons.AddTail (m_btnScrollFirst.GetSafeHwnd ());
		}

		m_btnScrollLeft.Create (_T(""), WS_CHILD | WS_VISIBLE, rectDummy, this, (UINT) -1);
		m_btnScrollLeft.SetStdImage (
			m_bFlat ? CMenuImages::IdArowLeftLarge : CMenuImages::IdArowLeftTab3d,
			m_bIsOneNoteStyle || m_bFlat ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray,
			m_bFlat ? (CMenuImages::IMAGES_IDS) 0 : CMenuImages::IdArowLeftDsbldTab3d);
		m_btnScrollLeft.m_bDrawFocus = FALSE;
		m_btnScrollLeft.m_nFlatStyle = CBCGPButton::BUTTONSTYLE_FLAT;

		if (!m_bIsOneNoteStyle)
		{
			m_btnScrollLeft.SetAutorepeatMode (50);
		}

		m_lstButtons.AddTail (m_btnScrollLeft.GetSafeHwnd ());

		m_btnScrollRight.Create (_T(""), WS_CHILD | WS_VISIBLE, rectDummy, this, (UINT) -1);
		m_btnScrollRight.SetStdImage (
			m_bFlat ? CMenuImages::IdArowRightLarge : CMenuImages::IdArowRightTab3d,
			m_bIsOneNoteStyle || m_bFlat ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray,
			m_bFlat ? (CMenuImages::IMAGES_IDS) 0 : CMenuImages::IdArowRightDsbldTab3d);
		m_btnScrollRight.m_bDrawFocus = FALSE;
		m_btnScrollRight.m_nFlatStyle = CBCGPButton::BUTTONSTYLE_FLAT;

		if (!m_bIsOneNoteStyle)
		{
			m_btnScrollRight.SetAutorepeatMode (50);
		}

		m_lstButtons.AddTail (m_btnScrollRight.GetSafeHwnd ());

		if (m_bFlat)
		{
			m_btnScrollLast.Create (_T(""), WS_CHILD | WS_VISIBLE, rectDummy, this, (UINT) -1);
			m_btnScrollLast.SetStdImage (CMenuImages::IdArowLast);
			m_btnScrollLast.m_bDrawFocus = FALSE;
			m_btnScrollLast.m_nFlatStyle = CBCGPButton::BUTTONSTYLE_FLAT;
			m_lstButtons.AddTail (m_btnScrollLast.GetSafeHwnd ());
		}

		m_btnClose.Create (_T(""), WS_CHILD | WS_VISIBLE, rectDummy, this, (UINT) -1);
		m_btnClose.SetStdImage (CMenuImages::IdClose,
			m_bIsOneNoteStyle || m_bFlat ? CMenuImages::ImageBlack : CMenuImages::ImageDkGray);
		m_btnClose.m_bDrawFocus = FALSE;
		m_btnClose.m_nFlatStyle = CBCGPButton::BUTTONSTYLE_FLAT;
		m_lstButtons.AddTail (m_btnClose.GetSafeHwnd ());

		if (!m_bFlat && m_bScroll)
		{
			CBCGPLocalResource locaRes;
			CString str;

			str.LoadString (IDS_BCGBARRES_CLOSEBAR);
			m_btnClose.SetTooltip (str);

			str.LoadString (IDP_BCGBARRES_SCROLL_LEFT);
			m_btnScrollLeft.SetTooltip (str);

			str.LoadString (IDP_BCGBARRES_SCROLL_RIGHT);
			m_btnScrollRight.SetTooltip (str);
		}
	}

	if (m_bSharedScroll)
	{
		m_wndScrollWnd.Create (WS_CHILD | WS_VISIBLE | SBS_HORZ, rectDummy,
			this, (UINT) -1);
	}

	if (m_bFlat)
	{
		//---------------------
		// Create active brush:
		//---------------------
		m_brActiveTab.CreateSolidBrush (GetActiveTabColor ());
	}
	else
	{
		//---------------------------------------
		// Text may be truncated. Create tooltip.
		//---------------------------------------
		m_ToolTip.Create (this, TTS_ALWAYSTIP);
		m_ToolTip.Activate (TRUE);
		if(globalData.m_nMaxToolTipWidth != -1)
		{
			m_ToolTip.SetMaxTipWidth(globalData.m_nMaxToolTipWidth);
		}
		m_ToolTip.BringWindowToTop ();
	}

	SetTabsHeight ();
	return 0;
}
//***************************************************************************************
BOOL CBCGPTabWnd::SetImageList (UINT uiID, int cx, COLORREF clrTransp)
{
	if (m_bFlat)
	{
		ASSERT (FALSE);
		return FALSE;
	}
	return CBCGPBaseTabWnd::SetImageList (uiID, cx, clrTransp);
}
//***************************************************************************************
BOOL CBCGPTabWnd::SetImageList (HIMAGELIST hImageList)
{
	if (m_bFlat)
	{
		ASSERT (FALSE);
		return FALSE;
	}

	return CBCGPBaseTabWnd::SetImageList (hImageList);
}
//***************************************************************************************
BOOL CBCGPTabWnd::OnEraseBkgnd(CDC* pDC)
{
	if (!m_bTransparent && m_iTabsNum == 0)
	{
		CRect rectClient;
		GetClientRect (rectClient);
		pDC->FillRect (rectClient, &globalData.brBtnFace);
	}