bcgpbutton.cpp

远程网络监视程序的源码

//*******************************************************************************
// COPYRIGHT NOTES
// ---------------
// This is a part of the BCGControlBar Library
// Copyright (C) 1998-2000 BCGSoft Ltd.
// All rights reserved.
//
// This source code can be used, distributed or modified
// only under terms and conditions 
// of the accompanying license agreement.
//*******************************************************************************

// BCGPButton.cpp : implementation file
//

#include "stdafx.h"
#include "BCGCBPro.h"
#include "BCGPLocalResource.h"
#include "bcgprores.h"
#include "BCGPButton.h"
#include "BCGGlobals.h"
#include "BCGPToolBarImages.h"
#include "BCGPPopupMenu.h"
#include "BCGPWinXPVisualManager.h"
#include "BCGPVisualManager2003.h"
#include "BCGPDrawManager.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

static const int nImageHorzMargin = 10;
static const int nVertMargin = 5;
static const COLORREF clrDefault = (COLORREF) -1;
static const UINT IdAutoCommand = 1;

BOOL CBCGPButton::m_bWinXPTheme = FALSE;

/////////////////////////////////////////////////////////////////////////////
// CBCGPButton

IMPLEMENT_DYNCREATE(CBCGPButton, CButton)

CBCGPButton::CBCGPButton()
{
	m_bPushed			= FALSE;
	m_bClickiedInside	= FALSE;
	m_bHighlighted		= FALSE;
	m_bCaptured			= FALSE;
	m_nFlatStyle		= BUTTONSTYLE_3D;
	m_nAlignStyle		= ALIGN_CENTER;
	m_sizeImage			= CSize (0, 0);
	m_nStdImageId		= (CMenuImages::IMAGES_IDS) -1;
	m_nStdImageDisabledId = (CMenuImages::IMAGES_IDS) -1;
	m_StdImageState		= CMenuImages::ImageBlack;
	m_bFullTextTooltip	= FALSE;
	m_bRighImage		= FALSE;
	m_hCursor			= NULL;
	m_sizePushOffset	= CSize (2, 2);
	m_bHover			= FALSE;
	m_clrRegular		= clrDefault;
	m_clrHover			= clrDefault;
	m_clrFace			= (COLORREF)-1;
	m_bDrawFocus		= TRUE;
	m_bTransparent		= FALSE;
	m_hFont				= NULL;
	m_bDelayFullTextTooltipSet = FALSE;
	m_bGrayDisabled		= TRUE;
	m_bChecked			= FALSE;
	m_bCheckButton		= FALSE;
	m_bRadioButton		= FALSE;
	m_bAutoCheck		= FALSE;
	m_bHighlightChecked	= TRUE;
	m_nAutoRepeatTimeDelay = 0;
	m_bResponseOnButtonDown = FALSE;
}
//****************************************************************************
CBCGPButton::~CBCGPButton()
{
	CleanUp ();
}
//****************************************************************************
void CBCGPButton::CleanUp ()
{
	m_nStdImageId = (CMenuImages::IMAGES_IDS) -1;
	m_nStdImageDisabledId = (CMenuImages::IMAGES_IDS) -1;

	m_sizeImage = CSize (0, 0);

	m_Image.DeleteImageList ();
	m_ImageHot.DeleteImageList ();
	m_ImageDisabled.DeleteImageList ();

	m_ImageChecked.DeleteImageList ();
	m_ImageCheckedHot.DeleteImageList ();
	m_ImageCheckedDisabled.DeleteImageList ();
}


BEGIN_MESSAGE_MAP(CBCGPButton, CButton)
	//{{AFX_MSG_MAP(CBCGPButton)
	ON_WM_ERASEBKGND()
	ON_WM_CANCELMODE()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_SETCURSOR()
	ON_WM_ENABLE()
	ON_WM_SIZE()
	ON_WM_KILLFOCUS()
	ON_WM_LBUTTONDBLCLK()
	ON_WM_TIMER()
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_SETFONT, OnSetFont)
	ON_MESSAGE(WM_GETFONT, OnGetFont)
	ON_MESSAGE(BM_GETCHECK, OnGetCheck)
	ON_MESSAGE(BM_SETCHECK, OnSetCheck)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBCGPButton message handlers

void CBCGPButton::DrawItem(LPDRAWITEMSTRUCT lpDIS) 
{
	ASSERT (lpDIS != NULL);
	ASSERT (lpDIS->CtlType == ODT_BUTTON);

	CDC* pDC = CDC::FromHandle (lpDIS->hDC);
	ASSERT_VALID (pDC);

	CRect rectClient = lpDIS->rcItem;

	OnFillBackground (pDC, rectClient);
	OnDrawBorder (pDC, rectClient, lpDIS->itemState);

	//---------------------
	// Draw button content:
	//---------------------
	OnDraw (pDC, rectClient, lpDIS->itemState);

	if ((lpDIS->itemState & ODS_FOCUS) && m_bDrawFocus)
	{
		OnDrawFocusRect (pDC, rectClient);
	}
}
//****************************************************************************
void CBCGPButton::PreSubclassWindow() 
{
	InitStyle (GetStyle ());

	ModifyStyle (BS_DEFPUSHBUTTON, BS_OWNERDRAW);
	CButton::PreSubclassWindow();
}
//****************************************************************************
BOOL CBCGPButton::PreCreateWindow(CREATESTRUCT& cs) 
{
	InitStyle (cs.style);

	cs.style |= BS_OWNERDRAW;
	cs.style &= ~BS_DEFPUSHBUTTON;

	return CButton::PreCreateWindow(cs);
}
//****************************************************************************
void CBCGPButton::InitStyle (DWORD dwStyle)
{
	switch (dwStyle & 0x0F) {
	case BS_CHECKBOX:
		m_bCheckButton = TRUE	;
		break	;
	case BS_AUTOCHECKBOX:
		m_bCheckButton =
			m_bAutoCheck = TRUE	;
		break	;
	case BS_RADIOBUTTON:
		m_bRadioButton = TRUE	;
		break	;
	case BS_AUTORADIOBUTTON:
		m_bRadioButton =
			m_bAutoCheck = TRUE	;
		break	;
	}
	if (m_bCheckButton || m_bRadioButton) {
		switch (dwStyle & BS_CENTER) {
		case BS_LEFT:
			m_nAlignStyle = CBCGPButton::ALIGN_LEFT	;
			break	;
		case BS_RIGHT:
			m_nAlignStyle = CBCGPButton::ALIGN_RIGHT	;
			break	;
		case BS_CENTER:
			m_nAlignStyle = CBCGPButton::ALIGN_CENTER	;
			break	;
		}
	}
}
//****************************************************************************
BOOL CBCGPButton::OnEraseBkgnd(CDC* /*pDC*/) 
{
	return TRUE;
}
//****************************************************************************
void CBCGPButton::OnFillBackground (CDC* pDC, const CRect& rectClient)
{
	if (m_bTransparent)
	{
		// Copy background from the parent window
		globalData.DrawParentBackground (this, pDC);
	}
	else
	{
		if (m_clrFace == (COLORREF)-1)
		{
			pDC->FillRect (rectClient, &globalData.brBtnFace);
		}
		else
		{
			pDC->FillSolidRect (rectClient, m_clrFace);
		}
	}

	if (m_bChecked && m_bHighlightChecked && !(m_bPushed && m_bHighlighted))
	{
		CBCGPDrawManager dm (*pDC);
		dm.HighlightRect (rectClient);
	}
}
//****************************************************************************
void CBCGPButton::OnDraw (CDC* pDC, const CRect& rect, UINT uiState)
{
	CRect rectText = rect;
	CRect rectImage = rect;

	CString strText;
	GetWindowText (strText);

	if (m_sizeImage.cx != 0)
	{
		if (!strText.IsEmpty ())
		{
			if (m_bRighImage)
			{
				rectText.right -= m_sizeImage.cx + nImageHorzMargin / 2;
				rectImage.left = rectText.right;
				rectImage.right -= nImageHorzMargin / 2;
			}
			else
			{
				rectText.left +=  m_sizeImage.cx + nImageHorzMargin / 2;
				rectImage.left += nImageHorzMargin / 2;
				rectImage.right = rectText.left;
			}
		}

		// Center image:
		rectImage.DeflateRect ((rectImage.Width () - m_sizeImage.cx) / 2,
			max (0, (rect.Height () - m_sizeImage.cy) / 2));
	}
	else
	{
		rectImage.SetRectEmpty ();
	}

	//-----------
	// Draw text:
	//-----------
	CFont* pOldFont = SelectFont (pDC);
	ASSERT(pOldFont != NULL);

	pDC->SetBkMode (TRANSPARENT);
	COLORREF clrText = m_clrRegular == clrDefault ? 
		globalData.clrBtnText : m_clrRegular;
	
	if (m_bHighlighted && m_clrHover != clrDefault)
	{
		clrText = m_clrHover;
	}

	UINT uiDTFlags = DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;
	switch (m_nAlignStyle)
	{
	case ALIGN_LEFT:
		uiDTFlags |= DT_LEFT;
		rectText.left += nImageHorzMargin / 2;
		break;

	case ALIGN_RIGHT:
		uiDTFlags |= DT_RIGHT;
		rectText.right -= nImageHorzMargin / 2;
		break;

	case ALIGN_CENTER:
		uiDTFlags |= DT_CENTER;
	}

	if ((uiState & ODS_DISABLED) && m_bGrayDisabled)
	{
		pDC->SetTextColor (globalData.clrBtnHilite);

		CRect rectShft = rectText;
		rectShft.OffsetRect (1, 1);
		pDC->DrawText (strText, rectShft, uiDTFlags);

		clrText = globalData.clrGrayedText;
	}

	pDC->SetTextColor (clrText);

	if (m_bDelayFullTextTooltipSet)
	{
		BOOL bIsFullText = pDC->GetTextExtent (strText).cx <= rectText.Width ();
		SetTooltip (bIsFullText ? NULL : (LPCTSTR) strText);
		m_bDelayFullTextTooltipSet = FALSE;
	}

	OnDrawText (pDC, rectText, strText, uiDTFlags, uiState);

	//------------
	// Draw image:
	//------------
	if (!rectImage.IsRectEmpty ())
	{
		if (m_nStdImageId != (CMenuImages::IMAGES_IDS) -1)
		{
			CMenuImages::IMAGES_IDS id = m_nStdImageId;

			if ((uiState & ODS_DISABLED) && m_bGrayDisabled &&
				m_nStdImageDisabledId != 0)
			{
				id = m_nStdImageDisabledId;
			}

			CMenuImages::Draw (pDC, id, rectImage.TopLeft (), m_StdImageState);
		}
		else
		{
			CImageList& imageChecked = 
				(((uiState & ODS_DISABLED) && m_bGrayDisabled && m_ImageCheckedDisabled.GetSafeHandle () != NULL) ?
				m_ImageCheckedDisabled :
				(m_bHighlighted && m_ImageCheckedHot.GetSafeHandle () != NULL) ?
				m_ImageCheckedHot : m_ImageChecked);

			CImageList& image = 
				(((uiState & ODS_DISABLED) && m_bGrayDisabled && m_ImageDisabled.GetSafeHandle () != NULL) ?
				m_ImageDisabled :
				(m_bHighlighted && m_ImageHot.GetSafeHandle () != NULL) ?
				m_ImageHot : m_Image);

			if (m_bChecked && imageChecked.GetSafeHandle () != NULL && imageChecked.GetImageCount () > 0)
			{
				imageChecked.Draw (pDC, 0, rectImage.TopLeft (), ILD_NORMAL);
			}
			else if (image.GetSafeHandle () != NULL && image.GetImageCount () > 0)
			{
				image.Draw (pDC, 0, rectImage.TopLeft (), ILD_NORMAL);
			}
		}
	}

	pDC->SelectObject (pOldFont);
}
//****************************************************************************
void CBCGPButton::OnDrawText (CDC* pDC, const CRect& rect, const CString& strText,
							 UINT uiDTFlags, UINT /*uiState*/)
{
	ASSERT_VALID (pDC);

	CRect rectText = rect;
	pDC->DrawText (strText, rectText, uiDTFlags);
}
//****************************************************************************
void CBCGPButton::SetImage (HICON hIconCold, BOOL bAutoDestroy, HICON hIconHot, HICON hIconDisabled)
{
	SetImageInternal (hIconCold, bAutoDestroy, hIconHot, FALSE /* Not checked */, hIconDisabled);
}
//****************************************************************************
void CBCGPButton::SetImage (HBITMAP hBitmapCold, BOOL bAutoDestroy, HBITMAP hBitmapHot, BOOL bMap3dColors,
							HBITMAP hBitmapDisabled)
{
	SetImageInternal (hBitmapCold, bAutoDestroy, hBitmapHot, bMap3dColors, FALSE /* Not checked */,
		hBitmapDisabled);
}
//****************************************************************************
void CBCGPButton::SetImage (UINT uiBmpResId, UINT uiBmpHotResId, UINT uiBmpDsblResID)
{
	SetImageInternal (uiBmpResId, uiBmpHotResId, FALSE /* Not checked */, uiBmpDsblResID);
}
//****************************************************************************
void CBCGPButton::SetCheckedImage (HICON hIconCold, BOOL bAutoDestroy, HICON hIconHot, HICON hIconDisabled)
{
	SetImageInternal (hIconCold, bAutoDestroy, hIconHot, TRUE /* Checked */, hIconDisabled);
}
//****************************************************************************
void CBCGPButton::SetCheckedImage (HBITMAP hBitmapCold, BOOL bAutoDestroy, HBITMAP hBitmapHot, BOOL bMap3dColors, HBITMAP hBitmapDisabled)
{
	SetImageInternal (hBitmapCold, bAutoDestroy, hBitmapHot, bMap3dColors, TRUE /* Checked */, hBitmapDisabled);
}
//****************************************************************************
void CBCGPButton::SetCheckedImage (UINT uiBmpResId, UINT uiBmpHotResId, UINT uiBmpDsblResID)
{
	SetImageInternal (uiBmpResId, uiBmpHotResId, TRUE /* Checked */, uiBmpDsblResID);
}
//****************************************************************************
void CBCGPButton::SetImageInternal (HICON hIconCold, BOOL bAutoDestroy, HICON hIconHot, BOOL bChecked, HICON hIconDisabled)
{
	ClearImages (bChecked);

	if (hIconCold == NULL)
	{
		return;
	}

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

	for (int i = 0; i < nCount; i++)
	{
		HICON hIcon = (i == 0) ? hIconCold : (i == 1) ? hIconHot : hIconDisabled;
		CImageList& image = bChecked ? ((i == 0) ? 
			m_ImageChecked : (i == 1) ? m_ImageCheckedHot : m_ImageCheckedDisabled) : 
			((i == 0) ? m_Image : (i == 1) ? m_ImageHot : m_ImageDisabled);

		if (hIcon == 0)
		{
			break;
		}

		ICONINFO info;
		::GetIconInfo (hIcon, &info);

		BITMAP bmp;
		::GetObject (info.hbmColor, sizeof (BITMAP), (LPVOID) &bmp);

		m_sizeImage.cx = bmp.bmWidth;
		m_sizeImage.cy = bmp.bmHeight;

		if (i == 0)
		{
			//--------------------------------------------
			// Create disabled image from the "cold" icon:
			//--------------------------------------------
			CDC dcMem;
			dcMem.CreateCompatibleDC (NULL);

			HBITMAP hBmp = (HBITMAP) ::CopyImage (info.hbmColor, IMAGE_BITMAP, 0, 0, 0);
			if (hBmp == NULL)
			{
				ASSERT (FALSE);
			}
			else
			{
				HBITMAP hOldBmp = (HBITMAP) dcMem.SelectObject (hBmp);

				dcMem.FillRect (CRect (0, 0, m_sizeImage.cx, m_sizeImage.cy), 
									&globalData.brBtnFace);

				::DrawIconEx (dcMem.GetSafeHdc (), 0, 0, hIcon, m_sizeImage.cx, m_sizeImage.cy,
								0, NULL, DI_NORMAL);

				dcMem.SelectObject (hOldBmp);

				if (hIconDisabled == NULL)
				{
					CreateDisabledImage (hBmp, bChecked);
				}

				::DeleteObject (hBmp);
			}
		}

		::DeleteObject (info.hbmColor);
		::DeleteObject (info.hbmMask);

		UINT nFlags = ILC_MASK;

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

		case 8:
			nFlags |= ILC_COLOR8;
			break;