bcgpbasetabwnd.cpp

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

	}
		

	if (!pWrapper->Create (lpszTabLabel, this, rectInit, TRUE, (UINT) pWndToWrap->GetDlgCtrlID (), 
						dwStyle))
	{
		delete pWrapper;
		TRACE0 ("Unable to create CBCGPDockingCBWrapper. \n");
		return pWndToWrap;
	}
	pWrapper->EnableGripper (FALSE);
	pWrapper->SetWrappedWnd (pWndToWrap);

	pWrapper->m_recentDockInfo.m_rectRecentFloatingRect = rectInit;

	if (pSaveRTC != NULL)
	{
		pWrapper->SetTabbedControlBarRTC (pSaveRTC);
	}

	return pWrapper;
}
//*************************************************************************************
BOOL CBCGPBaseTabWnd::StartRenameTab (int iTab)
{
	ASSERT_VALID (this);
	ASSERT (GetSafeHwnd () != NULL);

	if (!m_bIsInPlaceEdit)
	{
		return FALSE;
	}

	if (iTab < 0 || iTab >= m_arTabs.GetSize ())
	{
		return FALSE;
	}

	CBCGPTabInfo* pTabInfo = (CBCGPTabInfo*) m_arTabs.GetAt (iTab);


	ASSERT (m_pInPlaceEdit == NULL);

	m_pInPlaceEdit = new CEdit;
	ASSERT_VALID (m_pInPlaceEdit);

	CRect rectEdit = pTabInfo->m_rect;
	CalcRectEdit (rectEdit);
	
	if (!m_pInPlaceEdit->Create (WS_VISIBLE | WS_CHILD | WS_BORDER | ES_AUTOHSCROLL, rectEdit, 
		this, 1))
	{
		delete m_pInPlaceEdit;
		m_pInPlaceEdit = NULL;

 		return FALSE;
	}

	m_pInPlaceEdit->SetWindowText (pTabInfo->m_strText);
	m_pInPlaceEdit->SetFont (&globalData.fontRegular);
	m_pInPlaceEdit->SetSel (0, -1, TRUE);

	m_pInPlaceEdit->SetFocus ();
	m_iEditedTab = iTab;

	SetCapture ();
	return TRUE;
}
//**************************************************************************************
BOOL CBCGPBaseTabWnd::PreTranslateMessage(MSG* pMsg) 
{
	if (m_pInPlaceEdit != NULL)
	{
		if (pMsg->message >= WM_KEYFIRST &&
			pMsg->message <= WM_KEYLAST)
		{
			switch (pMsg->wParam)
			{
			case VK_RETURN:
				if (!RenameTab ())
				{
					MessageBeep ((UINT)-1);
					return TRUE;
				}
				// Slide down!

			case VK_ESCAPE:
				m_pInPlaceEdit->DestroyWindow ();
				delete m_pInPlaceEdit;
				m_pInPlaceEdit = NULL;
				m_iEditedTab = -1;
				ReleaseCapture ();
				break;

			default:
				return FALSE;
			}

			return TRUE;
		}
		else if (pMsg->message >= WM_MOUSEFIRST &&
				 pMsg->message <= WM_MOUSELAST)
		{
			CRect rectEdit;
			m_pInPlaceEdit->GetClientRect (rectEdit);
			m_pInPlaceEdit->MapWindowPoints (this, rectEdit);

			CPoint ptCursor;
			::GetCursorPos (&ptCursor);
			ScreenToClient (&ptCursor);

			if (rectEdit.PtInRect (ptCursor))
			{
				m_pInPlaceEdit->SendMessage (pMsg->message, pMsg->wParam, pMsg->lParam);
			}
			else if (pMsg->message != WM_MOUSEMOVE)
			{
				m_pInPlaceEdit->DestroyWindow ();
				delete m_pInPlaceEdit;
				m_pInPlaceEdit = NULL;
				m_iEditedTab = -1;
				ReleaseCapture ();
			}

			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}

	return CWnd::PreTranslateMessage(pMsg);
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::RenameTab ()
{
	ASSERT_VALID (this);
	ASSERT (m_bIsInPlaceEdit);

	if (m_pInPlaceEdit == NULL)
	{
		ASSERT (FALSE);
		return FALSE;
	}

	CString strName;
	m_pInPlaceEdit->GetWindowText (strName);

	if (!strName.IsEmpty () &&
		OnRenameTab (m_iEditedTab, strName) &&
		GetParent ()->SendMessage (BCGM_ON_RENAME_TAB, m_iEditedTab,
									(LPARAM)(LPCTSTR) strName) == 0)
	{
		return SetTabLabel (m_iEditedTab, strName);
	}

	return FALSE;
}
//***********************************************************************************
void CBCGPBaseTabWnd::SetActiveTabTextColor (COLORREF clr)
{
	m_clrActiveTabFg = clr;
}
//***********************************************************************************
void CBCGPBaseTabWnd::SetActiveTabColor (COLORREF clr)
{
	m_clrActiveTabBk = clr;

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

	m_brActiveTab.CreateSolidBrush (GetActiveTabColor ());
}
//*********************************************************************************
COLORREF CBCGPBaseTabWnd::GetTabBkColor (int iTab) const
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return (COLORREF)-1;
	}

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

	COLORREF color = pTab->m_clrBack;

	if (color == (COLORREF)-1 && m_bIsAutoColor)
	{
		color = m_arAutoColors [iTab % m_arAutoColors.GetSize ()];
		pTab->m_clrBack = color;
	}

	return color;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabBkColor (int iTab, COLORREF color)
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

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

	pTab->m_clrBack = color;
	return TRUE;
}
//*********************************************************************************
COLORREF CBCGPBaseTabWnd::GetTabTextColor (int iTab) const
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return (COLORREF)-1;
	}

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

	return pTab->m_clrText;
}
//*********************************************************************************
BOOL CBCGPBaseTabWnd::SetTabTextColor (int iTab, COLORREF color)
{
	ASSERT_VALID (this);

	if (iTab < 0 || iTab >= m_iTabsNum)
	{
		return FALSE;
	}

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

	pTab->m_clrText = color;
	return TRUE;
}
//***************************************************************************************
BOOL CBCGPBaseTabWnd::SetImageList (UINT uiID, int cx, COLORREF clrTransp)
{
	CBitmap bmp;
	if (!bmp.LoadBitmap (uiID))
	{
		TRACE(_T("CBCGPTabWnd::SetImageList Can't load bitmap: %x\n"), uiID);
		return FALSE;
	}

	BITMAP bmpObj;
	bmp.GetBitmap (&bmpObj);

	UINT nFlags = (clrTransp == (COLORREF) -1) ? 0 : ILC_MASK;

	switch (bmpObj.bmBitsPixel)
	{
	case 4:
	default:
		nFlags |= ILC_COLOR4;
		break;

	case 8:
		nFlags |= ILC_COLOR8;
		break;

	case 16:
		nFlags |= ILC_COLOR16;
		break;

	case 24:
		nFlags |= ILC_COLOR24;
		break;

	case 32:
		nFlags |= ILC_COLOR32;
		break;
	}

	m_Images.Create (cx, bmpObj.bmHeight, nFlags, 0, 0);
	m_Images.Add (&bmp, clrTransp);

	m_sizeImage = CSize (cx, bmpObj.bmHeight);

	SetTabsHeight ();
	return TRUE;
}
//***************************************************************************************
BOOL CBCGPBaseTabWnd::SetImageList (HIMAGELIST hImageList)
{
	ASSERT (hImageList != NULL);
	ASSERT (m_Images.GetSafeHandle () == NULL);

	CImageList* pImageList = CImageList::FromHandle (hImageList);
	if (pImageList == NULL)
	{
		ASSERT (FALSE);
		return FALSE;
	}

	IMAGEINFO info;
	pImageList->GetImageInfo (0, &info);

	CRect rectImage = info.rcImage;
	m_sizeImage = rectImage.Size ();

	m_hImageList = hImageList;

	SetTabsHeight ();
	return TRUE;
}

//************************************************************************************
void CBCGPBaseTabWnd::SetTabsHeight ()
{
	m_nTabsHeight = (max (m_sizeImage.cy + 2 * CBCGPBaseTabWnd::TAB_IMAGE_MARGIN,
			globalData.GetTextHeight () + 2 * CBCGPBaseTabWnd::TAB_TEXT_MARGIN));

}
//*********************************************************************************
void CBCGPBaseTabWnd::HideSingleTab (BOOL bHide)
{
	if (m_bHideSingleTab == bHide)
	{
		return;
	}

	m_bHideSingleTab = bHide;

	if (GetSafeHwnd () != NULL)
	{
		RecalcLayout ();
	}
}
//*********************************************************************************
CWnd* CBCGPBaseTabWnd::GetFirstVisibleTab (int& iTabNum)
{
	for (int i = 0; i < m_iTabsNum; i++)
	{
		CBCGPTabInfo* pTabInfo = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTabInfo);

		if (pTabInfo->m_bVisible)
		{
			iTabNum = i;
			return pTabInfo->m_pWnd;
		}
	}
	iTabNum = -1;
	return NULL;
}
//********************************************************************************
CWnd* CBCGPBaseTabWnd::GetLastVisibleTab (int& iTabNum)
{
	for (int i = m_iTabsNum - 1; i >= 0; i++)
	{
		CBCGPTabInfo* pTabInfo = (CBCGPTabInfo*) m_arTabs [i];
		ASSERT_VALID (pTabInfo);

		if (pTabInfo->m_bVisible)
		{
			iTabNum = i;
			return pTabInfo->m_pWnd;
		}
	}
	iTabNum = -1;
	return NULL;
}
//********************************************************************************
void CBCGPBaseTabWnd::SetDrawNoPrefix (BOOL bNoPrefix, BOOL bRedraw)
{
	ASSERT_VALID (this);
	m_bLabelNoPrefix = bNoPrefix;

	if (bRedraw && GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}
//*******************************************************************************
int CBCGPBaseTabWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	if (BCGPGetParentFrame (this) == NULL)
	{
		m_bEnableWrapping = FALSE;
	}
	
	_AFX_THREAD_STATE* pState = AfxGetThreadState();
	if (pState->m_bNeedTerm)	// AfxOleInit was called
	{
#ifndef BCG_NO_CUSTOMIZATION
		m_DropTarget.Register (this);
#endif // BCG_NO_CUSTOMIZATION
	}
	
	return 0;
}
//*******************************************************************************
CSize CBCGPBaseTabWnd::GetMaxWindowSize () const
{
	CSize sizeMax (0, 0);
	int nTabCount = m_arTabs.GetSize ();

	for (int i = 0; i < nTabCount; i++)
	{
		CBCGPTabInfo* pTabInfo = (CBCGPTabInfo*) m_arTabs.GetAt (i);
		ASSERT_VALID (pTabInfo);

		if (pTabInfo->m_pWnd != NULL)
		{
			CSize sizeCurr (0, 0);
			if (pTabInfo->m_pWnd->IsKindOf (RUNTIME_CLASS (CBCGPBaseControlBar)))
			{
				CBCGPBaseControlBar* pBar = 
					DYNAMIC_DOWNCAST (CBCGPBaseControlBar, pTabInfo->m_pWnd);
				if (pBar != NULL)
				{
					sizeCurr = pBar->CalcFixedLayout (FALSE, TRUE);
				}
			}
			else
			{
				CRect rectWnd;
				pTabInfo->m_pWnd->GetWindowRect (rectWnd);
				sizeCurr = rectWnd.Size ();
			}

			sizeMax.cx = max (sizeCurr.cx, sizeMax.cx);
			sizeMax.cy = max (sizeCurr.cy, sizeMax.cy);
		}
	}

	return sizeMax;
}
//**********************************************************************************
void CBCGPBaseTabWnd::EnableAutoColor (BOOL bEnable/* = TRUE*/)
{
	m_bIsAutoColor = bEnable;
	InitAutoColors ();

	if (GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}
//***********************************************************************************
void CBCGPBaseTabWnd::InitAutoColors ()
{
	if (!m_bIsDefaultAutoColor)
	{
		return;
	}

	m_arAutoColors.RemoveAll ();

	if (globalData.m_nBitsPerPixel > 8)
	{
		m_arAutoColors.Add (RGB (148, 175, 230));
		m_arAutoColors.Add (RGB (255, 219, 117));
		m_arAutoColors.Add (RGB (189, 205, 159));
		m_arAutoColors.Add (RGB (240, 158, 159));
		m_arAutoColors.Add (RGB (186, 166, 225));
		m_arAutoColors.Add (RGB (154, 191, 180));
		m_arAutoColors.Add (RGB (247, 182, 131));
		m_arAutoColors.Add (RGB (213, 164, 187));
	}
	else
	{
		m_arAutoColors.Add (RGB (0, 255, 0));
		m_arAutoColors.Add (RGB (0, 255, 255));
		m_arAutoColors.Add (RGB (255, 0, 255));
		m_arAutoColors.Add (RGB (192, 192, 192));
		m_arAutoColors.Add (RGB (255, 255, 0));
	}
}
//*************************************************************************************
void CBCGPBaseTabWnd::OnSysColorChange() 
{
	CWnd::OnSysColorChange();

	InitAutoColors ();
}
//************************************************************************************
void CBCGPBaseTabWnd::SetAutoColors (const CArray<COLORREF, COLORREF>& arColors)
{
	m_arAutoColors.RemoveAll ();

	if (arColors.GetSize () == 0)
	{
		m_bIsDefaultAutoColor = TRUE;
		InitAutoColors ();
	}
	else
	{
		m_bIsDefaultAutoColor = FALSE;

		for (int i = 0; i < arColors.GetSize (); i++)
		{
			m_arAutoColors.Add (arColors [i]);
		}
	}

	if (GetSafeHwnd () != NULL)
	{
		RedrawWindow ();
	}
}
//*********************************************************************************
void CBCGPBaseTabWnd::SetLocation (Location location)
{
	ASSERT_VALID (this);

	m_location = location;
	RecalcLayout ();

	if (GetSafeHwnd () != NULL)
	{
		GetParent ()->RedrawWindow (NULL, NULL, 
			RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
	}
}