bcgpbutton.cpp

远程网络监视程序的源码

		case 16:
			nFlags |= ILC_COLOR16;
			break;

		case 24:
			nFlags |= ILC_COLOR24;
			break;

		case 32:
			nFlags |= ILC_COLOR32;
			break;
		}

		image.Create (bmp.bmWidth, bmp.bmHeight, nFlags, 0, 0);
		image.Add (hIcon);
	}

	if (bAutoDestroy)
	{
		if (hIconCold != NULL)
		{
			::DestroyIcon (hIconCold);
		}

		if (hIconHot != NULL)
		{
			::DestroyIcon (hIconHot);
		}
	}
}
//****************************************************************************
void CBCGPButton::SetImageInternal (HBITMAP hBitmapCold, BOOL bAutoDestroy, HBITMAP hBitmapHot, BOOL bMap3dColors, BOOL bChecked,
									HBITMAP hBitmapDisabled)
{
	ClearImages (bChecked);

	if (hBitmapCold == NULL)
	{
		return;
	}

	const int nCount = hBitmapDisabled == NULL ? 2 : 3;

	for (int i = 0; i < nCount; i++)
	{
		HBITMAP hBitmap = (i == 0) ? hBitmapCold : (i == 1) ? hBitmapHot : hBitmapDisabled;
		CImageList& image = bChecked ? ((i == 0) ? 
			m_ImageChecked : (i == 1) ? m_ImageCheckedHot : m_ImageCheckedDisabled) : 
			((i == 0) ? m_Image : (i == 1) ? m_ImageHot : m_ImageDisabled);

		if (hBitmap == NULL)
		{
			break;
		}

		BITMAP bmp;
		::GetObject (hBitmap, sizeof (BITMAP), (LPVOID) &bmp);

		if (i == 0)
		{
			m_sizeImage.cx = bmp.bmWidth;
			m_sizeImage.cy = bmp.bmHeight;
		}
		else
		{
			// Hot and cold bitmaps should have the same size!
			ASSERT (m_sizeImage.cx == bmp.bmWidth);
			ASSERT (m_sizeImage.cy == bmp.bmHeight);
		}

		UINT nFlags = ILC_MASK;

		switch (bmp.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;
		}

		image.Create (bmp.bmWidth, bmp.bmHeight, nFlags, 0, 0);

		HBITMAP hbmpCopy = (HBITMAP) ::CopyImage (hBitmap, IMAGE_BITMAP, 0, 0, 0);
		image.Add (CBitmap::FromHandle (hbmpCopy), 
			bMap3dColors ? RGB (192, 192, 192) : globalData.clrBtnFace);
		::DeleteObject (hbmpCopy);
	}

	if (hBitmapDisabled == NULL)
	{
		CreateDisabledImage (hBitmapCold, bChecked);
	}

	if (bAutoDestroy)
	{
		if (hBitmapHot != NULL)
		{
			::DeleteObject (hBitmapHot);
		}

		if (hBitmapCold != NULL)
		{
			::DeleteObject (hBitmapCold);
		}
	}
}
//****************************************************************************
static HBITMAP ButtonLoadBitmap (UINT uiBmpResId)
{
	if (uiBmpResId == 0)
	{
		return NULL;
	}


	CBCGPToolBarImages images;
	if (!images.Load (uiBmpResId))
	{
		ASSERT (FALSE);
		return NULL;
	}

	return (HBITMAP) ::CopyImage (images.GetImageWell (), IMAGE_BITMAP, 0, 0, 0);
}
//********************************************************************************
void CBCGPButton::SetImageInternal (UINT uiBmpResId, UINT uiBmpHotResId, BOOL bChecked, UINT uiBmpDsblResID)
{
	ClearImages (bChecked);

	if (uiBmpResId == 0)
	{
		return;
	}

	HBITMAP hbmp = ButtonLoadBitmap (uiBmpResId);
	HBITMAP hbmpHot = ButtonLoadBitmap (uiBmpHotResId);
	HBITMAP hbmpDisabled = ButtonLoadBitmap (uiBmpDsblResID);

	SetImageInternal (hbmp, TRUE /* AutoDestroy */, hbmpHot, FALSE, bChecked, hbmpDisabled);
}
//****************************************************************************
void CBCGPButton::SetStdImage (CMenuImages::IMAGES_IDS id, CMenuImages::IMAGE_STATE state,
							   CMenuImages::IMAGES_IDS idDisabled)
{
	CleanUp ();

	m_sizeImage = CMenuImages::Size ();
	m_nStdImageId = id;
	m_nStdImageDisabledId = idDisabled;
	m_StdImageState = state;
}
//****************************************************************************
void CBCGPButton::OnCancelMode() 
{
	CButton::OnCancelMode();
	
	if (m_bCaptured)
	{
		ReleaseCapture ();

		m_bCaptured = FALSE;
		m_bPushed = FALSE;
		m_bClickiedInside = FALSE;
		m_bHighlighted = FALSE;
		m_bHover = FALSE;

		Invalidate ();
		UpdateWindow ();
	}

	if (m_nAutoRepeatTimeDelay >= 0)
	{
		KillTimer (IdAutoCommand);
	}
}
//****************************************************************************
void CBCGPButton::OnMouseMove(UINT nFlags, CPoint point) 
{
	m_bHover = FALSE;

	if ((nFlags & MK_LBUTTON) || m_nFlatStyle != BUTTONSTYLE_3D ||
		m_bWinXPTheme)
	{
		BOOL bRedraw = FALSE;

		CRect rectClient;
		GetClientRect (rectClient);

		if (rectClient.PtInRect (point))
		{
			m_bHover = TRUE;

			if (!m_bHighlighted)
			{
				m_bHighlighted = TRUE;
				bRedraw = TRUE;
			}

			if ((nFlags & MK_LBUTTON) && !m_bPushed && m_bClickiedInside)
			{
				m_bPushed = TRUE;
				bRedraw = TRUE;
			}

			if (!m_bCaptured)
			{
				SetCapture ();
				m_bCaptured = TRUE;
				bRedraw = TRUE;
			}
		}
		else
		{
			if (nFlags & MK_LBUTTON)
			{
				if (m_bPushed)
				{
					m_bPushed = FALSE;
					bRedraw = TRUE;
				}
			}
			else if (m_bHighlighted)
			{
				m_bHighlighted = FALSE;
				bRedraw = TRUE;
			}

			if (m_bCaptured && (!nFlags & MK_LBUTTON))
			{
				ReleaseCapture ();
				m_bCaptured = FALSE;

				bRedraw = TRUE;
			}
		}

		if (bRedraw)
		{
			Invalidate ();
			UpdateWindow ();
		}
	}
	
	CButton::OnMouseMove(nFlags, point);
}
//****************************************************************************
void CBCGPButton::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if (m_bResponseOnButtonDown)
	{
		CWnd* pParent = GetParent ();
		if (pParent != NULL)
		{
			pParent->SendMessage (	WM_COMMAND,
									MAKEWPARAM (GetDlgCtrlID (), BN_CLICKED),
									(LPARAM) m_hWnd);
		}
	}
	else
	{
		m_bPushed = TRUE;
		m_bClickiedInside = TRUE;
		m_bHighlighted = TRUE;

		if (!m_bCaptured)
		{
			SetCapture ();
			m_bCaptured = TRUE;
		}

		Invalidate ();
		UpdateWindow ();

		if (m_nAutoRepeatTimeDelay > 0)
		{
			SetTimer (IdAutoCommand, m_nAutoRepeatTimeDelay, NULL);
		}
	}

	CButton::OnLButtonDown(nFlags, point);
}
//****************************************************************************
void CBCGPButton::OnLButtonUp(UINT nFlags, CPoint point) 
{
	BOOL bClicked = m_bPushed && m_bClickiedInside && m_bHighlighted;

	m_bPushed = FALSE;
	m_bClickiedInside = FALSE;
	m_bHighlighted = FALSE;

	if (bClicked && m_bAutoCheck)
	{
		if (m_bCheckButton)
		{
			m_bChecked = !m_bChecked;
		}
		else if (m_bRadioButton && !m_bChecked)
		{
			m_bChecked = TRUE;
			UncheckRadioButtonsInGroup ();
		}
	}

	RedrawWindow ();
	CButton::OnLButtonUp(nFlags, point);

	if (m_bCaptured)
	{
		ReleaseCapture ();
		m_bCaptured = FALSE;
	}

	if (m_nAutoRepeatTimeDelay > 0)
	{
		KillTimer (IdAutoCommand);
	}

	if (m_wndToolTip.GetSafeHwnd () != NULL)
	{
		m_wndToolTip.Pop ();

		CString str;
		m_wndToolTip.GetText (str, this);
		m_wndToolTip.UpdateTipText (str, this);
	}
}
//****************************************************************************
CSize CBCGPButton::SizeToContent (BOOL bCalcOnly)
{
	ASSERT (GetSafeHwnd () != NULL);

	CClientDC dc (this);

	CFont* pOldFont = SelectFont (&dc);
	ASSERT(pOldFont != NULL);

	CString strText;
	GetWindowText (strText);
	CSize sizeText = dc.GetTextExtent (strText);

	int cx = sizeText.cx + m_sizeImage.cx + nImageHorzMargin;
	if (sizeText.cx > 0)
	{
		cx += nImageHorzMargin;
	}

	int cy = max (sizeText.cy, m_sizeImage.cy) + nVertMargin * 2;

	if (!bCalcOnly)
	{
		SetWindowPos (NULL, -1, -1, cx, cy,
			SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
	}

	dc.SelectObject (pOldFont);

	return CSize (cx, cy);
}
//****************************************************************************
BOOL CBCGPButton::PreTranslateMessage(MSG* pMsg) 
{
	if (m_wndToolTip.GetSafeHwnd () != NULL)
	{
		if (pMsg->message == WM_LBUTTONDOWN ||
			pMsg->message == WM_LBUTTONUP ||
			pMsg->message == WM_MOUSEMOVE)
		{
			m_wndToolTip.RelayEvent(pMsg);
		}
	}

	if (pMsg->message == WM_KEYDOWN &&
		pMsg->wParam == VK_RETURN &&
		CBCGPPopupMenu::GetActiveMenu () == NULL)
	{
		CWnd* pParent = GetParent ();
		if (pParent != NULL)
		{
			pParent->SendMessage (	WM_COMMAND,
									MAKEWPARAM (GetDlgCtrlID (), BN_CLICKED),
									(LPARAM) m_hWnd);
			return TRUE;
		}
	}
	
	if (pMsg->message == WM_KEYDOWN && m_bAutoCheck && GetParent () != NULL)
	{
		switch (pMsg->wParam) 
		{
		case VK_SPACE:
			if (m_bCheckButton) 
			{
				m_bChecked = !m_bChecked;

				RedrawWindow ();

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

				::SendMessage (pWndParent->GetSafeHwnd(), WM_COMMAND, 
					MAKELONG (::GetWindowLong(m_hWnd, GWL_ID), BN_CLICKED), 
					(LPARAM) m_hWnd);

				return TRUE	;
			}
			break;

		case VK_UP:
		case VK_LEFT:
			if (CheckNextPrevRadioButton (FALSE))
			{
				return TRUE;
			}
			break;

		case VK_DOWN:
		case VK_RIGHT:
			if (CheckNextPrevRadioButton (TRUE))
			{
				return TRUE;
			}
			break	;
		}
	}

	return CButton::PreTranslateMessage(pMsg);
}
//****************************************************************************
void CBCGPButton::SetTooltip (LPCTSTR lpszToolTipText)
{
	ASSERT (GetSafeHwnd () != NULL);

	if (lpszToolTipText == NULL)
	{
		if (m_wndToolTip.GetSafeHwnd () != NULL)
		{
			m_wndToolTip.Activate (FALSE);
		}
	}
	else
	{
		if (m_wndToolTip.GetSafeHwnd () != NULL)
		{
			m_wndToolTip.UpdateTipText (lpszToolTipText, this);
		}
		else
		{
			m_wndToolTip.Create (NULL, TTS_ALWAYSTIP);

			if (globalData.m_nMaxToolTipWidth != -1)
			{
				m_wndToolTip.SetMaxTipWidth (globalData.m_nMaxToolTipWidth);
			}

			m_wndToolTip.AddTool (this, lpszToolTipText);
		}

		m_wndToolTip.Activate (TRUE);
	}
}
//****************************************************************************
void CBCGPButton::SetMouseCursor (HCURSOR hcursor)
{
	m_hCursor = hcursor;
}
//****************************************************************************
void CBCGPButton::SetMouseCursorHand ()
{
	if (globalData.m_hcurHand == NULL)