www.pudn.com > ÍøÂç¶Ë¿Ú¼àÊÓ.rar > BCGPAnimCtrl.cpp

//******************************************************************************* 
// COPYRIGHT NOTES 
// --------------- 
// This is a part of the BCGPro Library 
// Copyright (C) 1998-2001 BCGSoft Ltd. 
// All rights reserved. 
// 
// This source code can be used, distributed or modified 
// only under terms and conditions  
// of the accompanying license agreement. 
 //******************************************************************************* 
 
// BCGAnimCtrl.cpp : implementation file 
// 
 
#include "stdafx.h" 
 
#ifndef BCG_NO_ANIMCONTROL 
 
#include "BCGPAnimCtrl.h" 
#include "BCGPPopupMenu.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
static const int iAnimEventId = 1; 
 
IMPLEMENT_DYNAMIC(CBCGPAnimCtrl, CStatic) 
 
///////////////////////////////////////////////////////////////////////////// 
// CBCGPAnimCtrl 
 
CBCGPAnimCtrl::CBCGPAnimCtrl() 
{ 
	m_clrBack = (COLORREF)-1; 
	m_sizeFrame = CSize (0, 0); 
	m_iCurrFrame = 0; 
	m_iFrameCount = -1; 
	m_pImagesAnim = NULL; 
	m_bIsRunning = FALSE; 
	m_uiFrameRate = 500; 
} 
 
CBCGPAnimCtrl::~CBCGPAnimCtrl() 
{ 
} 
 
 
BEGIN_MESSAGE_MAP(CBCGPAnimCtrl, CStatic) 
	//{{AFX_MSG_MAP(CBCGPAnimCtrl) 
	ON_WM_ERASEBKGND() 
	ON_WM_TIMER() 
	ON_WM_PAINT() 
	//}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CBCGPAnimCtrl message handlers 
 
BOOL CBCGPAnimCtrl::OnEraseBkgnd(CDC* /*pDC*/)  
{ 
	return TRUE; 
} 
//************************************************************************************** 
void CBCGPAnimCtrl::OnTimer(UINT nIDEvent)  
{ 
	if (nIDEvent == iAnimEventId) 
	{ 
		if (++ m_iCurrFrame == m_iFrameCount) 
		{ 
			m_iCurrFrame = 0; 
		} 
 
		Invalidate (FALSE); 
		UpdateWindow (); 
	} 
 
	CRect rectScreen; 
	GetWindowRect (&rectScreen); 
	CBCGPPopupMenu::UpdateAllShadows (rectScreen); 
 
	CStatic::OnTimer(nIDEvent); 
} 
//************************************************************************************** 
void CBCGPAnimCtrl::OnPaint()  
{ 
	CPaintDC dc(this); // device context for painting 
 
	CDC*		pDC = &dc; 
	BOOL		m_bMemDC = FALSE; 
	CDC			dcMem; 
	CBitmap		bmp; 
	CBitmap*	pOldBmp = NULL; 
 
	CRect rect; 
	GetClientRect (rect); 
 
	if (dcMem.CreateCompatibleDC (&dc) && 
		bmp.CreateCompatibleBitmap (&dc, rect.Width (), 
								  rect.Height ())) 
	{ 
		//------------------------------------------------------------- 
		// Off-screen DC successfully created. Better paint to it then! 
		//------------------------------------------------------------- 
		m_bMemDC = TRUE; 
		pOldBmp = dcMem.SelectObject (&bmp); 
		pDC = &dcMem; 
	} 
 
	if (m_clrBack != (COLORREF)-1) 
	{ 
		CBrush brBack (m_clrBack); 
		pDC->FillRect (rect, &brBack); 
	} 
	else 
	{ 
		globalData.DrawParentBackground (this, pDC); 
	} 
 
	if (m_pImagesAnim != NULL && 
		m_pImagesAnim->GetSafeHandle () != NULL) 
	{ 
		m_pImagesAnim->Draw (pDC, m_iCurrFrame,  
			CPoint ((rect.Width () - m_sizeFrame.cx) / 2, 
					(rect.Height () - m_sizeFrame.cy) / 2), 
			ILD_NORMAL); 
	} 
 
	if (m_bMemDC) 
	{ 
		//-------------------------------------- 
		// Copy the results to the on-screen DC: 
		//--------------------------------------  
		CRect rectClip; 
		int nClipType = dc.GetClipBox (rectClip); 
		if (nClipType != NULLREGION) 
		{ 
			if (nClipType != SIMPLEREGION) 
			{ 
				rectClip = rect; 
			} 
 
			dc.BitBlt (rectClip.left, rectClip.top, rectClip.Width(), rectClip.Height(), 
						   &dcMem, rectClip.left, rectClip.top, SRCCOPY); 
		} 
 
		dcMem.SelectObject(pOldBmp); 
	} 
} 
//************************************************************************************** 
BOOL CBCGPAnimCtrl::SetBitmap (UINT uiBmpId, int nFrameWidth, 
							  COLORREF clrTransparent, 
							  BOOL bSizeToContent) 
{ 
	ASSERT_VALID (this); 
 
	if (nFrameWidth <= 0) 
	{ 
		ASSERT (FALSE); 
		return FALSE; 
	} 
 
	CBitmap bmp; 
	if (!bmp.LoadBitmap (uiBmpId)) 
	{ 
		TRACE(_T ("Can't load bitmap: %x\n"), uiBmpId); 
		return FALSE; 
	} 
 
	if (m_imagesAnim.GetSafeHandle () != NULL) 
	{ 
		::DeleteObject (m_imagesAnim.Detach ()); 
	} 
 
	BITMAP bmpObj; 
	bmp.GetBitmap (&bmpObj); 
 
	UINT nFlags = (clrTransparent == (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_imagesAnim.Create (nFrameWidth, bmpObj.bmHeight, nFlags, 0, 0); 
	m_imagesAnim.Add (&bmp, clrTransparent); 
 
	return SetBitmap (&m_imagesAnim, bSizeToContent); 
} 
//************************************************************************************** 
BOOL CBCGPAnimCtrl::SetBitmap (CImageList* pImagesAnim, BOOL bSizeToContent) 
{ 
	ASSERT_VALID (this); 
	ASSERT_VALID (pImagesAnim); 
 
	if (m_imagesAnim.GetSafeHandle () != NULL && 
		m_imagesAnim.GetSafeHandle () != pImagesAnim->GetSafeHandle ()) 
	{ 
		::DeleteObject (m_imagesAnim.Detach ()); 
	} 
 
	if (m_bIsRunning) 
	{ 
		KillTimer (iAnimEventId); 
		m_bIsRunning = FALSE; 
	} 
 
	m_pImagesAnim = pImagesAnim; 
 
	IMAGEINFO imageInfo; 
	pImagesAnim->GetImageInfo (0, &imageInfo); 
 
	CRect rectImage = imageInfo.rcImage; 
 
	m_sizeFrame.cx = rectImage.Width (); 
	m_sizeFrame.cy = rectImage.Height (); 
 
	m_iFrameCount = pImagesAnim->GetImageCount (); 
 
	if (bSizeToContent) 
	{ 
		SetWindowPos (NULL, -1, -1, m_sizeFrame.cx, m_sizeFrame.cy, 
			SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER); 
	} 
 
	Invalidate (); 
	UpdateWindow (); 
 
	return TRUE; 
} 
//************************************************************************************** 
BOOL CBCGPAnimCtrl::Play (UINT uiFrameRate) 
{ 
	ASSERT_VALID (this); 
 
	if (uiFrameRate != 0) 
	{ 
		m_uiFrameRate = uiFrameRate; 
	} 
 
	if (m_pImagesAnim == NULL || 
		m_pImagesAnim->GetSafeHandle () == NULL || 
		m_bIsRunning) 
	{ 
		return FALSE; 
	} 
 
	SetTimer (iAnimEventId, m_uiFrameRate, NULL); 
	m_bIsRunning = TRUE; 
 
	return TRUE; 
} 
//************************************************************************************** 
BOOL CBCGPAnimCtrl::Stop () 
{ 
	if (m_pImagesAnim == NULL || 
		m_pImagesAnim->GetSafeHandle () == NULL || 
		!m_bIsRunning) 
	{ 
		return FALSE; 
	} 
 
	KillTimer (iAnimEventId); 
	m_iCurrFrame = 0; 
	m_bIsRunning = FALSE; 
 
	Invalidate (); 
	UpdateWindow (); 
 
	return TRUE; 
} 
//******************************************************************************* 
void CBCGPAnimCtrl::SetFrameRate (UINT uiFrameRate) 
{ 
	ASSERT_VALID (this); 
 
	if (uiFrameRate == 0) 
	{ 
		ASSERT (FALSE); 
		return; 
	} 
 
	if (m_uiFrameRate != uiFrameRate) 
	{ 
		m_uiFrameRate = uiFrameRate; 
 
		if (m_bIsRunning) 
		{ 
			KillTimer (iAnimEventId); 
			SetTimer (iAnimEventId, uiFrameRate, NULL); 
		} 
	} 
} 
 
#endif // BCG_NO_ANIMCONTROL