hsgraphics.cpp

漂亮菜单

	::DeleteObject( hrgnTemp );
	::DeleteObject( hbmp );
	::DeleteDC( hdcMem );
}

void WINAPI DrawFadeBmp( HDC hDC, int nX, int nY, HBITMAP hBmp, COLORREF clrTarget, UINT nRate )
{
	BITMAPINFO bmpinfo;
	float fRate = nRate / (float)255;

	::ZeroMemory( &bmpinfo, sizeof( BITMAPINFO ) );
	bmpinfo.bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
	::GetDIBits( hDC, hBmp, 0, 0, NULL, &bmpinfo, DIB_RGB_COLORS );
	
	int nWidth   = bmpinfo.bmiHeader.biWidth;
	int nHeight  = bmpinfo.bmiHeader.biHeight;
	int nBmpSize = ( nWidth * bmpinfo.bmiHeader.biBitCount + 31 ) / 32 * 8 *nHeight;

	BYTE *pData, *pBuffer;
	pData = pBuffer = new BYTE[ nBmpSize ];
	::ZeroMemory( pBuffer, nBmpSize );

	bmpinfo.bmiHeader.biBitCount = 24;
	bmpinfo.bmiHeader.biCompression = BI_RGB;
	bmpinfo.bmiHeader.biSizeImage = 0;

	::GetDIBits( hDC, hBmp, 0, nHeight, pBuffer, &bmpinfo, DIB_RGB_COLORS );

	int nR = GetRValue( clrTarget );
	int nG = GetGValue( clrTarget );
	int nB = GetBValue( clrTarget );

	for ( int nBmpY=0; nBmpY<nHeight; nBmpY++ )
		for ( int nBmpX=0; nBmpX<nWidth; nBmpX++ )
		{
//			pData = pBuffer + nBmpY*nWidth*3 + nBmpX*3;
			
			*pData = (BYTE)(  nB + (((*pData) - nB)/(float)STEP) * nRate ); 	pData++;
			*pData = (BYTE)(  nG + (((*pData) - nG)/(float)STEP) * nRate ); 	pData++;
			*pData = (BYTE)(  nR + (((*pData) - nR)/(float)STEP) * nRate );		pData++;
		}

	HBITMAP hBmpTmp = ::CreateDIBitmap( hDC, &bmpinfo.bmiHeader, CBM_INIT, pBuffer, &bmpinfo, DIB_RGB_COLORS ); 
	HDC		hdcMem  = ::CreateCompatibleDC( hDC );
	HBITMAP hbmpOld = (HBITMAP)::SelectObject( hdcMem, hBmpTmp );
	::BitBlt( hDC, nX, nY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY );
	::SelectObject( hdcMem, hbmpOld );
	::DeleteObject( hBmpTmp );
	::DeleteDC( hdcMem );

	delete[] pBuffer;
}

void WINAPI DrawFadeIcon(HDC hDC, int nX, int nY, HICON hIcon, int nWidth, int nHeight, UINT nRate)
{
	HDC		hdcMem  = ::CreateCompatibleDC( hDC );
	HBITMAP	hbmpMem = ::CreateCompatibleBitmap( hDC, nWidth, nHeight );
	HGDIOBJ	hBmpOld = ::SelectObject( hdcMem, hbmpMem );

	::DrawRect( hdcMem, 0, 0, 0, nWidth, nHeight );
	::DrawIconEx( hdcMem, 0, 0, hIcon, nWidth, nHeight, 0, NULL, DI_NORMAL );
	::DrawFadeBmp( hdcMem, 0, 0, hbmpMem, 0, nRate );
//	::DrawFadeBmp( hDC, nX, nY, hbmpMem, 0, nRate );
//	::BitBlt( hDC, nX, nY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY );

	::DrawTranBmp( hDC, nX, nY, hbmpMem, nWidth, nHeight, 0 );

	::SelectObject( hdcMem, hBmpOld );
	::DeleteObject( hbmpMem );
	::DeleteDC( hdcMem );
}

void WINAPI DrawShadowIcon(HDC hDC, int nX, int nY, HICON hIcon, int nWidth, int nHeight, COLORREF clrShadow)
{
	HDC		hdcMem  = ::CreateCompatibleDC( hDC );
	HDC		hdcMsk  = ::CreateCompatibleDC( hDC );
	HBITMAP	hbmpMsk = ::CreateCompatibleBitmap( hDC, nWidth, nHeight );
	HBITMAP	hbmpMem = ::CreateCompatibleBitmap( hDC, nWidth, nHeight );
	HGDIOBJ	hBmpOld = ::SelectObject( hdcMem, hbmpMem );
	HGDIOBJ	hMskOld = ::SelectObject( hdcMsk, hbmpMsk );

	::DrawIconEx( hdcMsk, 0, 0, hIcon, nWidth, nHeight, 0, NULL, DI_MASK );
	::DrawRect( hdcMem, clrShadow, 0, 0, nWidth, nHeight );
	::BitBlt( hdcMem, 0, 0, nWidth, nHeight, hdcMsk, 0, 0, SRCPAINT );

	::BitBlt( hDC, nX, nY, nWidth, nHeight, hdcMem, 0, 0, SRCINVERT );
	::BitBlt( hDC, nX, nY, nWidth, nHeight, hdcMsk, 0, 0, SRCAND );
	::BitBlt( hDC, nX, nY, nWidth, nHeight, hdcMem, 0, 0, SRCINVERT );

	::SelectObject( hdcMsk, hMskOld );
	::SelectObject( hdcMem, hBmpOld );
	::DeleteObject( hbmpMem );
	::DeleteObject( hbmpMsk );
	::DeleteDC( hdcMem );
	::DeleteDC( hdcMsk );
}

HICON WINAPI LoadIcon(int nIconID)
{
//	ASSERT( nIconID != 0 );
	if ( nIconID )

	return (HICON)::LoadImage(	AfxFindResourceHandle( MAKEINTRESOURCE(nIconID), RT_ICON ),
							    MAKEINTRESOURCE(nIconID), 
								IMAGE_ICON, 
								0, 
								0, 
								0 );

	return NULL;
}


void WINAPI AlphaBlend( HDC hdcResult, int nX, int nY, int nWidth, int nHeight, HDC hdcDest, int nXDest, int nYDest, HDC hdcSrc, int nXSrc, int nYSrc, BYTE bAlpha )
{
	BITMAPINFOHEADER bih;

	bih.biSize			= sizeof( BITMAPINFOHEADER );
	bih.biWidth			= nWidth;
	bih.biHeight		= nHeight;
	bih.biPlanes		= 1;
	bih.biBitCount		= 32;
	bih.biCompression	= BI_RGB;
	bih.biSizeImage		= 0;
	bih.biXPelsPerMeter	= 0;
	bih.biYPelsPerMeter	= 0;
	bih.biClrUsed		= 0;
	bih.biClrImportant	= 0;

	DWORD	*pdwSrc, *pdwDest;
	HBITMAP	hbmpSrc, hbmpDest;

	hbmpSrc  = ::CreateDIBSection( hdcSrc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&pdwSrc, 0, (DWORD)0 );
	hbmpDest = ::CreateDIBSection( hdcDest,(BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&pdwDest,0, (DWORD)0 );

	HDC		hdcMem  = ::CreateCompatibleDC( NULL );
	HGDIOBJ hobjOld = ::SelectObject( hdcMem, hbmpDest );
	::BitBlt( hdcMem, 0, 0, nWidth, nHeight, hdcDest, nXDest, nYDest, SRCCOPY );
	::SelectObject( hdcMem, hbmpSrc );
	::BitBlt( hdcMem, 0, 0, nWidth, nHeight, hdcSrc,  nXSrc,  nYSrc,  SRCCOPY );

	for( int i=0; i<nHeight; ++i )
	{
		LPBYTE pbRGBSrc  = (LPBYTE)&pdwSrc [i*nWidth];
		LPBYTE pbRGBDest = (LPBYTE)&pdwDest[i*nWidth];

		for ( int j=0; j<nWidth; ++j )
		{
			pbRGBSrc[0] = (BYTE)(( pbRGBDest[0]*(255-bAlpha)+pbRGBSrc[0]*bAlpha )>>8);
			pbRGBSrc[1] = (BYTE)(( pbRGBDest[1]*(255-bAlpha)+pbRGBSrc[1]*bAlpha )>>8);
			pbRGBSrc[2] = (BYTE)(( pbRGBDest[2]*(255-bAlpha)+pbRGBSrc[2]*bAlpha )>>8);

			pbRGBSrc  += 4;
			pbRGBDest += 4;
		}
	}

	::BitBlt( hdcResult, nX, nY, nWidth, nHeight, hdcMem, 0, 0, SRCCOPY );
	::SelectObject( hdcMem, hobjOld );
	::DeleteDC( hdcMem );
	::DeleteObject( hbmpSrc );
	::DeleteObject( hbmpDest );
}

void WINAPI DrawAnimation( RECT *prect, HDC hDCDest, HDC hDCSrc, int nType, int nStep, int nTimeDelay )
{
	ASSERT( nStep >= 0 );
	ASSERT( nTimeDelay >= 0 );

	const int nLeft   = prect->left;
	const int nTop    = prect->top;
	const int nRight  = prect->right;
	const int nBottom = prect->bottom;
	const int nWidth  = nRight  - nLeft;
	const int nHeight = nBottom - nTop;

	if ( nStep )//&& nWidth>1 && nHeight>1 )
	switch ( nType)
	{
		case ANIMATE_NONE:
			break;

		case ANIMATE_SLIDE_TTB:
		{
			while( nHeight/nStep == 0 )
				--nStep;

			int nStepHeight = nHeight / nStep;
			for ( int ntmpHeight=nStepHeight; ntmpHeight<nHeight; ntmpHeight+=nStepHeight )
			{
				::BitBlt( hDCDest, nLeft, nTop, nWidth, ntmpHeight, hDCSrc, 0, nHeight-ntmpHeight, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;
	
		case ANIMATE_SLIDE_LTR:
		{
			while( nWidth/nStep == 0 )
				--nStep;

			int nStepWidth = nWidth / nStep;
			for ( int ntmpWidth=nStepWidth; ntmpWidth<nWidth; ntmpWidth+=nStepWidth )
			{
				::BitBlt( hDCDest, nLeft, nTop, ntmpWidth, nHeight, hDCSrc, nWidth-ntmpWidth, 0, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;

		case ANIMATE_UNFOLD_MTTB:
		{
			while( nHeight/nStep == 0 )
				--nStep;

			int nMiddleCY	= nHeight / 2;
			int nStepHeight = nHeight / nStep;
			int ntmpHeight  = nStepHeight;
			for( ; ntmpHeight<nHeight; ntmpHeight+=nStepHeight )
			{
				::BitBlt( hDCDest, nLeft, nTop+nMiddleCY-ntmpHeight/2, nWidth, ntmpHeight, hDCSrc, 0, nMiddleCY-ntmpHeight/2, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;
	
		case ANIMATE_UNFOLD_MTLR:
		{
			while( nWidth/nStep == 0 )
				--nStep;

			int nMiddleCX  = nWidth / 2;
			int nStepWidth = nWidth / nStep;
			int ntmpWidth  = nStepWidth;
			for( ; ntmpWidth<nWidth; ntmpWidth+=nStepWidth )
			{
				::BitBlt( hDCDest, nLeft+nMiddleCX-ntmpWidth/2, nTop, ntmpWidth, nHeight, hDCSrc, nMiddleCX-ntmpWidth/2, 0, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;

		case ANIMATE_SHUTTER_TTB:
		{
			while( nHeight/nStep/nStep == 0 )
				--nStep;

			int nStepHeight   = nHeight / nStep / nStep;
			int nTotalShutter = nHeight / nStep;
			int nShutterHeight= nHeight / nStep;
			int ntmpHeight	  = nStepHeight;

			for( ; ntmpHeight<nShutterHeight; ntmpHeight+=nStepHeight )
			{
				for( int i=0; i<nTotalShutter; i++ )
					::BitBlt( hDCDest, nLeft, nTop+nShutterHeight*i, nWidth, ntmpHeight, hDCSrc, 0, nShutterHeight*i, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;

		case ANIMATE_SHUTTER_LTR:
		{
			while( nWidth/nStep/nStep == 0 )
				--nStep;

			int nStepWidth    = nWidth / nStep / nStep;
			int nTotalShutter = nWidth / nStep;
			int nShutterWidth = nWidth / nStep;
			int ntmpWidth	  = nStepWidth;

			for( ; ntmpWidth<nShutterWidth; ntmpWidth+=nStepWidth )
			{
				for( int i=0; i<nTotalShutter; i++ )
					::BitBlt( hDCDest, nLeft+nShutterWidth*i, nTop, ntmpWidth, nHeight, hDCSrc, nShutterWidth*i, 0, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;
	
		case ANIMATE_UNFOLD_LTTRB:
		{
			for ( int i=0; i<nStep; ++i)
			{
				int ntmpWidth   = nTop  + nWidth  * (i + 1) / nStep;
				int ntmpHeight  = nLeft + nHeight * (i + 1) / nStep;
				::BitBlt( hDCDest, nLeft, nTop, ntmpWidth, ntmpHeight, hDCSrc, 0, 0, SRCCOPY);
				Sleep( nTimeDelay / nStep );
			}
		}	break;
			
		case ANIMATE_UNFOLDSLIDE_LTTRB:
		{
			while( nWidth/nStep == 0 || nHeight/nStep == 0 )
				--nStep;

			int nStepWidth  = nWidth / nStep;
			int nStepHeight = nHeight / nStep;
			int ntmpWidth   = nStepWidth;
			int ntmpHeight  = nStepHeight;

			for ( ; ntmpHeight<nHeight; ntmpWidth+=nStepWidth, ntmpHeight+=nStepHeight )
			{
				::BitBlt( hDCDest, nLeft, nTop, ntmpWidth, ntmpHeight, hDCSrc, 0, nHeight-ntmpHeight, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;

		case ANIMATE_STRETCH_TTB:
		{
			while( nHeight/nStep == 0 )
				--nStep;

			int nStepHeight = nHeight / nStep;
			for ( int ntmpHeight = nStepHeight; ntmpHeight<nHeight; ntmpHeight+=nStepHeight )
			{
				::StretchBlt( hDCDest, nLeft, nTop, nWidth, ntmpHeight, hDCSrc, 0, 0, nWidth, nHeight, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;	

		case ANIMATE_STRETCH_LTR:
		{
			while( nWidth/nStep == 0 )
				--nStep;

			int nStepWidth = nWidth / nStep;
			for ( int ntmpWidth = nStepWidth; ntmpWidth<nWidth; ntmpWidth+=nStepWidth )
			{
				::StretchBlt( hDCDest, nLeft, nTop, ntmpWidth, nHeight, hDCSrc, 0, 0, nWidth, nHeight, SRCCOPY );
				Sleep( nTimeDelay / nStep );
			}
		}	break;	

		case ANIMATE_NOISE:
		{
			int nCount = nWidth * nHeight / 2;
			for (int i = 0; i < nCount; ++i)
			{
				int nX = nLeft + rand() % nWidth;
				int nY = nTop  + rand() % nHeight;
				::SetPixel( hDCDest, nX, nY, ::GetPixel( hDCSrc, nX, nY ) );
//				Sleep( nTimeDelay / nStep );
			}
		}	break;

		case ANIMATE_FADE:
		{
			HDC hdcBkgnd = ::CreateCompatibleDC( hDCDest );
			HBITMAP	hbmpBkgnd = ::CreateCompatibleBitmap( hDCDest, nWidth, nHeight );
			HGDIOBJ hobjOldB  = ::SelectObject( hdcBkgnd, hbmpBkgnd );
			::BitBlt( hdcBkgnd, 0, 0, nWidth, nHeight, hDCDest, nLeft, nTop, SRCCOPY );

			HDC hdcFade = ::CreateCompatibleDC( hDCDest );
			HBITMAP	hbmpFade = ::CreateCompatibleBitmap( hDCDest, nWidth, nHeight );
			HGDIOBJ hobjOldF = ::SelectObject( hdcFade, hbmpFade );

			for ( int i=0; i<nStep; ++i )
			{
				AlphaBlend( hdcFade, 0, 0, nWidth, nHeight, hdcBkgnd, 0, 0, hDCSrc, 0, 0, (255*i)/nStep );
				::BitBlt( hDCDest, nLeft, nTop, nWidth, nHeight, hdcFade, 0, 0, SRCCOPY );
				Sleep( nTimeDelay / nStep / 3 );
			}

			::SelectObject( hdcBkgnd, hobjOldB );
			::DeleteObject( hbmpBkgnd );
			::DeleteDC( hdcBkgnd );

			::SelectObject( hdcFade, hobjOldF );
			::DeleteObject( hbmpFade );
			::DeleteDC( hdcFade );
		}	break;

		case ANIMATE_RAND:
		{
			UINT uAnimateType[13] = { ANIMATE_SLIDE_TTB,	ANIMATE_SLIDE_LTR,
									  ANIMATE_UNFOLD_MTTB,	ANIMATE_UNFOLD_MTLR,		
									  ANIMATE_SHUTTER_TTB,	ANIMATE_SHUTTER_LTR,
									  ANIMATE_STRETCH_TTB,	ANIMATE_STRETCH_LTR,
									  ANIMATE_UNFOLD_LTTRB,	ANIMATE_UNFOLDSLIDE_LTTRB, 
									  ANIMATE_NOISE,			
									  ANIMATE_FADE,
									  ANIMATE_NONE };

			DrawAnimation( prect, hDCDest, hDCSrc, uAnimateType[rand()%13], nStep, nTimeDelay );
		}	return;
	}

	::BitBlt( hDCDest, nLeft, nTop, nWidth, nHeight, hDCSrc, 0, 0, SRCCOPY );
}