bcgpbutton.cpp

远程网络监视程序的源码

	{
		CBCGPLocalResource locaRes;
		globalData.m_hcurHand = AfxGetApp ()->LoadCursor (IDC_BCGBARRES_HAND);
	}

	SetMouseCursor (globalData.m_hcurHand);
}
//*****************************************************************************
BOOL CBCGPButton::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if (m_hCursor != NULL)
	{
		CRect rectClient;
		GetClientRect (rectClient);

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

		if (rectClient.PtInRect (ptCursor))
		{
			::SetCursor (m_hCursor);
			return TRUE;
		}
	}
	
	return CButton::OnSetCursor(pWnd, nHitTest, message);
}
//*****************************************************************************
void CBCGPButton::OnDrawFocusRect (CDC* pDC, const CRect& rectClient)
{
	ASSERT_VALID (pDC);

	CRect rectFocus = rectClient;
	rectFocus.DeflateRect (2, 2);

	COLORREF clrBckgr = (m_clrFace == (COLORREF)-1) ? globalData.clrBtnFace : m_clrFace;

	pDC->Draw3dRect (rectFocus, clrBckgr, clrBckgr);
	pDC->DrawFocusRect (rectFocus);
}
//******************************************************************************
BOOL CBCGPButton::CreateDisabledImage (HBITMAP hBitmapOrig, BOOL bChecked)
{
	CImageList& imagesDisabled = bChecked ? m_ImageCheckedDisabled : m_ImageDisabled;

	if (imagesDisabled.GetSafeHandle () != NULL)
	{
		imagesDisabled.DeleteImageList ();
	}

	//-------------------------------
	// Get original bitmap attrbutes:
	//-------------------------------
	BITMAP bmp;
	if (::GetObject (hBitmapOrig, sizeof (BITMAP), &bmp) == 0)
	{
		return FALSE;
	}

	int iBitmapWidth = bmp.bmWidth;
	int iBitmapHeight = bmp.bmHeight;

	//------------------------------
	// Create memory destination DC:
	//------------------------------
	CDC memDCDst;
	memDCDst.CreateCompatibleDC (NULL);
	
	HBITMAP hBitmapDisabled = (HBITMAP) ::CopyImage (hBitmapOrig, IMAGE_BITMAP, 0, 0, 0);
	if (hBitmapDisabled == NULL)
	{
		return FALSE;
	}

	HBITMAP hOldBitmapDst = (HBITMAP) memDCDst.SelectObject (hBitmapDisabled);
	if (hOldBitmapDst == NULL)
	{
		::DeleteObject (hBitmapDisabled);
		return FALSE;
	}

	memDCDst.FillRect (CRect (0, 0, iBitmapWidth, iBitmapHeight), 
		&globalData.brBtnFace);

	CBCGPToolBarImages images;
	images.MapTo3dColors ();
	images.SetImageSize (CSize (iBitmapWidth, iBitmapHeight));
	images.AddImage (hBitmapOrig);

	CBCGPDrawState ds;
	images.PrepareDrawImage (ds);
	images.Draw (&memDCDst, 0, 0, 0, FALSE, TRUE);
	images.EndDrawImage (ds);

	memDCDst.SelectObject (hOldBitmapDst);

	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;
	}

	imagesDisabled.Create (iBitmapWidth, iBitmapHeight, nFlags, 0, 0);
	imagesDisabled.Add (CBitmap::FromHandle (hBitmapDisabled), globalData.clrBtnFace);

	::DeleteObject (hBitmapDisabled);

	return TRUE;
}
//******************************************************************************
void CBCGPButton::OnEnable(BOOL bEnable) 
{
	// By Yury Goltsman
	if (!bEnable)
	{
		// control disabled
		m_bPushed = FALSE;
		m_bClickiedInside = FALSE;
		m_bHighlighted = FALSE;
		
		if (m_bCaptured)
		{
			ReleaseCapture ();
			m_bCaptured = FALSE;
		}
	}
	
	RedrawWindow ();
	CButton::OnEnable(bEnable);
}
//******************************************************************************
void CBCGPButton::SetFaceColor (COLORREF crFace, BOOL bRedraw)
{
	m_clrFace = crFace;

	if (bRedraw && GetSafeHwnd () != NULL)
	{
		Invalidate ();
		UpdateWindow ();
	}
}
//*****************************************************************************
CFont* CBCGPButton::SelectFont (CDC* pDC)
{
	ASSERT_VALID (pDC);

	CFont* pOldFont = m_hFont == NULL ?
		(CFont*) pDC->SelectStockObject (DEFAULT_GUI_FONT) :
		pDC->SelectObject (CFont::FromHandle (m_hFont));

	ASSERT(pOldFont != NULL);
	return pOldFont;
}
//*****************************************************************************
afx_msg LRESULT CBCGPButton::OnSetFont (WPARAM wParam, LPARAM lParam)
{
	BOOL bRedraw = (BOOL) LOWORD (lParam);

	m_hFont = (HFONT) wParam;

	if (bRedraw)
	{
		Invalidate ();
		UpdateWindow ();
	}

	return 0;
}
//*****************************************************************************
afx_msg LRESULT CBCGPButton::OnGetFont (WPARAM, LPARAM)
{
	return (LRESULT) m_hFont;
}
//*****************************************************************************
void CBCGPButton::EnableMenuFont (BOOL bOn, BOOL bRedraw)
{
	m_hFont = bOn ? (HFONT) globalData.fontRegular.GetSafeHandle () : NULL;

	if (bRedraw && GetSafeHwnd () != NULL)
	{
		Invalidate ();
		UpdateWindow ();
	}
}
//******************************************************************************
void CBCGPButton::EnableFullTextTooltip (BOOL bOn)
{
	m_bFullTextTooltip = bOn;
	m_bDelayFullTextTooltipSet = bOn;
}
//******************************************************************************
void CBCGPButton::OnSize(UINT nType, int cx, int cy) 
{
	m_bDelayFullTextTooltipSet = m_bFullTextTooltip;
	CButton::OnSize(nType, cx, cy);
}
//******************************************************************************
void CBCGPButton::OnDrawBorder (CDC* pDC, CRect& rectClient, UINT uiState)
{
	DrawBorder (pDC, rectClient, uiState);
}
//****************************************************************************************
void CBCGPButton::OnKillFocus(CWnd* pNewWnd) 
{
	CButton::OnKillFocus(pNewWnd);
	
	if (m_bCaptured)
	{
		ReleaseCapture ();
		m_bCaptured = FALSE;
	}
	
	m_bPushed = FALSE;
	m_bClickiedInside = FALSE;
	m_bHighlighted = FALSE;
	m_bHover = FALSE;

	Invalidate ();
	UpdateWindow ();
}
//*****************************************************************************************
void CBCGPButton::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	m_bPushed = TRUE;
	m_bClickiedInside = TRUE;
	m_bHighlighted = TRUE;

	Invalidate ();
	UpdateWindow ();

	CButton::OnLButtonDblClk(nFlags, point);
}
//***************************************************************************************
void CBCGPButton::EnableWinXPTheme (BOOL bEnable/* = TRUE*/)
{
	m_bWinXPTheme = bEnable;
}
//***************************************************************************************
LRESULT CBCGPButton::OnGetCheck(WPARAM, LPARAM)
{
	if (m_bCheckButton || m_bRadioButton)
	{
		return m_bChecked ? BST_CHECKED	: BST_UNCHECKED;
	}

	return 0;
}
//***************************************************************************************
LRESULT CBCGPButton::OnSetCheck(WPARAM fCheck, LPARAM)
{
	ASSERT (fCheck != BST_INDETERMINATE);

	if ((m_bCheckButton || m_bRadioButton) && (!m_bChecked) != (fCheck == BST_UNCHECKED)) 
	{
		m_bChecked = fCheck != BST_UNCHECKED;
		
		if (m_bRadioButton)
		{
			UncheckRadioButtonsInGroup ();
		}

		Invalidate();
		UpdateWindow();
	}

	return 0	;
}
//****************************************************************************************
void CBCGPButton::ClearImages (BOOL bChecked)
{
	m_nStdImageId = (CMenuImages::IMAGES_IDS) -1;
	m_nStdImageDisabledId = (CMenuImages::IMAGES_IDS) -1;
	m_sizeImage = CSize (0, 0);

	if (bChecked)
	{
		m_ImageChecked.DeleteImageList ();
		m_ImageCheckedHot.DeleteImageList ();
		m_ImageCheckedDisabled.DeleteImageList ();
	}
	else
	{
		m_Image.DeleteImageList ();
		m_ImageHot.DeleteImageList ();
		m_ImageDisabled.DeleteImageList ();
	}
}
//****************************************************************************************
BOOL CBCGPButton::CheckNextPrevRadioButton (BOOL bNext)
{
	ASSERT_VALID (this);

	if (!m_bRadioButton)
	{
		return FALSE;
	}

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

	CBCGPButton* pBtn = NULL;

	for (CWnd* pWnd = pWndParent->GetNextDlgGroupItem (this, !bNext); 
		pWnd != this; 
		pWnd = pWndParent->GetNextDlgGroupItem (pWnd, !bNext))
	{
		if ((pBtn = DYNAMIC_DOWNCAST(CBCGPButton, pWnd)) != NULL &&
			pBtn->m_bRadioButton &&
			(pBtn->GetStyle() & (WS_DISABLED | WS_VISIBLE)) == WS_VISIBLE)
		{
			break;
		}
	}

	if (pBtn != NULL && pBtn != this && !pBtn->m_bChecked)
	{
		pBtn->SetCheck (TRUE);
		pBtn->SetFocus ();

		::SendMessage (pBtn->GetParent()->GetSafeHwnd(), WM_COMMAND,
			MAKELONG (::GetWindowLong(pBtn->m_hWnd, GWL_ID), BN_CLICKED),
			(LPARAM) pBtn->m_hWnd);
		return TRUE;
	}

	return FALSE;
}
//****************************************************************************************
void CBCGPButton::UncheckRadioButtonsInGroup ()
{
	CWnd* pWndParent = GetParent ();
	if (pWndParent == NULL)
	{
		return;
	}

	ASSERT_VALID (pWndParent);

	//--------------------------------------------------------
	// Walk through group and clear radio buttons check state
	//--------------------------------------------------------
	for (CWnd * pCtl = pWndParent->GetNextDlgGroupItem (this); 
		pCtl != this && pCtl != NULL;
		pCtl = pWndParent->GetNextDlgGroupItem (pCtl))
	{
		CBCGPButton* pBtn = DYNAMIC_DOWNCAST (CBCGPButton, pCtl);

		if (pBtn != NULL && pBtn->m_bRadioButton && pBtn->m_bChecked) 
		{
			pBtn->m_bChecked = FALSE;
			pBtn->RedrawWindow ();
		}
	}
}
//***********************************************************************************
void CBCGPButton::SetAutorepeatMode (int nTimeDelay)
{
	ASSERT (nTimeDelay >= 0);
	m_nAutoRepeatTimeDelay = nTimeDelay;
}
//***********************************************************************************
void CBCGPButton::OnTimer(UINT nIDEvent) 
{
	if (nIDEvent == IdAutoCommand)
	{
		if (m_bPushed && m_bHighlighted)
		{
			CWnd* pParent = GetParent ();
			if (pParent != NULL)
			{
				pParent->SendMessage (	WM_COMMAND,
										MAKEWPARAM (GetDlgCtrlID (), BN_CLICKED),
										(LPARAM) m_hWnd);
			}
		}
	}

	CButton::OnTimer(nIDEvent);
}
//****************************************************************************************
void CBCGPButton::DrawBorder (CDC* pDC, CRect& rectClient, UINT uiState)
{
	ASSERT_VALID (pDC);

	BOOL bBorderIsReady = FALSE;

	//----------------
	// Draw 3d border:
	//----------------
	if (m_nFlatStyle != BUTTONSTYLE_NOBORDERS)
	{
		if (m_bWinXPTheme)
		{
			// Draw borders using current WinXP theme
			CBCGPWinXPVisualManager* pWinXPManager =
				DYNAMIC_DOWNCAST (CBCGPWinXPVisualManager, CBCGPVisualManager::GetInstance ());
			if (pWinXPManager != NULL &&
				pWinXPManager->DrawPushButton (pDC, rectClient, this, uiState))
			{
				bBorderIsReady = TRUE;
			}

			CBCGPVisualManager2003* pManager2003 =
				DYNAMIC_DOWNCAST (CBCGPVisualManager2003, CBCGPVisualManager::GetInstance ());
			if (pManager2003 != NULL &&
				pManager2003->DrawPushButton (pDC, rectClient, this, uiState))
			{
				bBorderIsReady = TRUE;
			}
		}

		if (m_bPushed && m_bHighlighted || (uiState & ODS_SELECTED) || m_bChecked)
		{
			if (!bBorderIsReady)
			{
				pDC->Draw3dRect (rectClient,
							globalData.clrBtnDkShadow, globalData.clrBtnHilite);

				rectClient.DeflateRect (1, 1);

				if (m_nFlatStyle != BUTTONSTYLE_FLAT)
				{
					pDC->Draw3dRect (rectClient,
								globalData.clrBtnShadow, globalData.clrBtnLight);
				}

				rectClient.DeflateRect (1, 1);
			}
			else
			{
				rectClient.DeflateRect (2, 2);
			}

			rectClient.left += m_sizePushOffset.cx;
			rectClient.top += m_sizePushOffset.cy;
		}
		else if (!bBorderIsReady && (m_nFlatStyle != BUTTONSTYLE_FLAT || m_bHighlighted))
		{
			pDC->Draw3dRect (rectClient,
						globalData.clrBtnHilite, 
						globalData.clrBtnDkShadow);
			rectClient.DeflateRect (1, 1);

			if (m_nFlatStyle == BUTTONSTYLE_3D ||
				(m_nFlatStyle == BUTTONSTYLE_SEMIFLAT && m_bHighlighted))
			{
				pDC->Draw3dRect (rectClient,
							globalData.clrBtnLight, globalData.clrBtnShadow);
			}

			rectClient.DeflateRect (1, 1);
		}
		else
		{
			rectClient.DeflateRect (2, 2);
		}
	}
	else
	{
		rectClient.DeflateRect (2, 2);
	}
}