bitmap.cpp

一个国人自己实现图像库的程序（有参考价值）

#include "stdafx.h"
#include "..\..\Include\Pic\Bitmap.h"
#include "..\..\Include\C_x86_CPU.h"
#include "..\..\Include\fooBit.h"

//===================================================================
void  FCBitmap::ShowDib_SCAN (HDC hdc, HDC hDCmem, const BITMAP & bm, const SHOWEFFECT & Param)
{
	int		iTemp,
			iHMod2 = bm.bmHeight - 1 - (bm.bmHeight % 2),
			iWMod2 = bm.bmWidth - 1 - (bm.bmWidth % 2) ;
	switch (Param.dwSubMethod)
	{
		case SHOWDIB_SCAN_TODOWN :
			for (iTemp = 0 ; iTemp < bm.bmHeight ; iTemp++)
			{
				::BitBlt (hdc, 0, iTemp, bm.bmWidth, 1, hDCmem, 0, iTemp, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_TOUP :
			for (iTemp = bm.bmHeight - 1 ; iTemp >= 0 ; iTemp--)
			{
				::BitBlt (hdc, 0, iTemp, bm.bmWidth, 1, hDCmem, 0, iTemp, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_TOLEFT :
			for (iTemp = bm.bmWidth - 1 ; iTemp >= 0 ; iTemp--)
			{
				::BitBlt (hdc, iTemp, 0, 1, bm.bmHeight, hDCmem, iTemp, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_TORIGHT :
			for (iTemp = 0 ; iTemp < bm.bmWidth ; iTemp++)
			{
				::BitBlt (hdc, iTemp, 0, 1, bm.bmHeight, hDCmem, iTemp, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_HORIZON :
			for (iTemp = 0 ; iTemp <= bm.bmWidth / 2 ; iTemp++)
			{
				::BitBlt (hdc, iTemp, 0, 1, bm.bmHeight, hDCmem, iTemp, 0, SRCCOPY) ;
				::BitBlt (hdc, bm.bmWidth - 1 - iTemp, 0, 1, bm.bmHeight, hDCmem, bm.bmWidth - 1 - iTemp, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_VERTICAL :
			for (iTemp = 0 ; iTemp <= bm.bmHeight / 2 ; iTemp++)
			{
				::BitBlt (hdc, 0, iTemp, bm.bmWidth, 1, hDCmem, 0, iTemp, SRCCOPY) ;
				::BitBlt (hdc, 0, bm.bmHeight - 1 - iTemp, bm.bmWidth, 1, hDCmem, 0, bm.bmHeight - 1 - iTemp, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_VINTERLACE :
			for (iTemp = 0 ; iTemp < bm.bmHeight ; iTemp += 2)
			{
				::BitBlt (hdc, 0, iTemp, bm.bmWidth, 1, hDCmem, 0, iTemp, SRCCOPY) ;
				::BitBlt (hdc, 0, iHMod2 - iTemp, bm.bmWidth, 1, hDCmem, 0, iHMod2 - iTemp, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_SCAN_HINTERLACE :
			for (iTemp = 0 ; iTemp < bm.bmWidth ; iTemp += 2)
			{
				::BitBlt (hdc, iTemp, 0, 1, bm.bmHeight, hDCmem, iTemp, 0, SRCCOPY) ;
				::BitBlt (hdc, iWMod2 - iTemp, 0, 1, bm.bmHeight, hDCmem, iWMod2 - iTemp, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
	}
}
//===================================================================

void  FCBitmap::ShowDib_MOVE (HDC hdc, HDC hDCmem, const BITMAP & bm, const SHOWEFFECT & Param)
{
	int		iTemp ;
	int		iLeft, iRight ;
	switch (Param.dwSubMethod)
	{
		case SHOWDIB_MOVE_TODOWN :
			for (iTemp = 1 ; iTemp <= bm.bmHeight ; iTemp++)
			{
				::BitBlt (hdc, 0, 0, bm.bmWidth, iTemp, hDCmem, 0, bm.bmHeight - iTemp, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_MOVE_TOUP :
			for (iTemp = 1 ; iTemp <= bm.bmHeight ; iTemp++)
			{
				::BitBlt (hdc, 0, bm.bmHeight - iTemp, bm.bmWidth, iTemp, hDCmem, 0, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_MOVE_TOLEFT :
			for (iTemp = 1 ; iTemp <= bm.bmWidth ; iTemp++)
			{
				::BitBlt (hdc, bm.bmWidth - iTemp, 0, iTemp, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_MOVE_TORIGHT :
			for (iTemp = 1 ; iTemp <= bm.bmWidth ; iTemp++)
			{
				::BitBlt (hdc, 0, 0, iTemp, bm.bmHeight, hDCmem, bm.bmWidth - iTemp, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_MOVE_HORIZON :
			iLeft = bm.bmWidth/2 - (bm.bmWidth + 1)%2 ;
			iRight = bm.bmWidth/2 ;
			for (iTemp = 0 ; iTemp <= iLeft ; iTemp++)
			{
		/*左*/	::BitBlt (hdc, 0, 0, iTemp + 1, bm.bmHeight, hDCmem, iLeft - iTemp, 0, SRCCOPY) ;
		/*右*/	::BitBlt (hdc, bm.bmWidth - 1 - iTemp, 0, iTemp + 1, bm.bmHeight, hDCmem, iRight, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
		case SHOWDIB_MOVE_VERTICAL :
			iLeft = bm.bmHeight/2 - (bm.bmHeight + 1)%2 ;
			iRight = bm.bmHeight/2 ;
			for (iTemp = 0 ; iTemp <= iLeft ; iTemp++)
			{
		/*上*/	::BitBlt (hdc, 0, 0, bm.bmWidth, iTemp + 1, hDCmem, 0, iLeft - iTemp, SRCCOPY) ;
		/*下*/	::BitBlt (hdc, 0, bm.bmHeight - 1 - iTemp, bm.bmWidth, iTemp + 1, hDCmem, 0, iRight, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, Param.dwInterval) ;
			}
			break ;
	}
}

//===================================================================

void  FCBitmap::ShowDib_MOSAIC (HDC hdc, HDC hDCmem, const BITMAP& bm, const SHOWEFFECT& Param)
{
	int		iXmax = bm.bmWidth / Param.dwBlockLen + ((bm.bmWidth % Param.dwBlockLen == 0) ? 0 : 1) ;
	int		iYmax = bm.bmHeight / Param.dwBlockLen + ((bm.bmHeight % Param.dwBlockLen == 0) ? 0 : 1) ;
	POINT	* pBlock = (POINT *)::VirtualAlloc (NULL, sizeof(POINT)*iXmax*iYmax, MEM_COMMIT, PAGE_READWRITE) ;

	for (int x = 0 ; x < iXmax ; x++) // 设置小方块左上角
		for (int y = 0 ; y < iYmax ; y++)
		{
			pBlock[iXmax*y + x].x = x*Param.dwBlockLen ;
			pBlock[iXmax*y + x].y = y*Param.dwBlockLen ;
		}

	int		i ;
	for (int iTemp = iXmax*iYmax - 1 ; iTemp >= 0 ; iTemp--)
	{
		i = ::fooRandom (0, iTemp) ;
		::BitBlt (hdc, pBlock[i].x, pBlock[i].y, Param.dwBlockLen, Param.dwBlockLen, hDCmem, pBlock[i].x, pBlock[i].y, SRCCOPY) ;
		if (i != iTemp) // 把当前的和最后一个交换
			pBlock[i] = pBlock[iTemp] ;
		if (!fooIsShowDibEffectContinue ())
			break ;
		::fooDelay (m_iFreq, Param.dwInterval) ;
	}
	::VirtualFree (pBlock, 0, MEM_RELEASE) ;
}

//===================================================================

#define	interval	30
void  FCBitmap::ShowDib_FADESCAN (HDC hdc, HDC hDCmem, BITMAP bm, DWORD dwParam)
{
	int		HighW = HIWORD(dwParam),
			LowW = LOWORD(dwParam) ;
	BLENDFUNCTION	alpha ;
	alpha.AlphaFormat = 0 ;
	alpha.BlendFlags = 0 ;
	alpha.BlendOp = 0 ;

	for (int y = 0 ; y < bm.bmHeight - interval ; y++)
	{
		alpha.SourceConstantAlpha = 216 ;
		for (int i = 0 ; i < interval ; i++)
		{
			alpha.SourceConstantAlpha -= (216-76) / interval ;
			::AlphaBlend (hdc, 0, y + i, bm.bmWidth, 1, hDCmem, 0, y + i, bm.bmWidth, 1, alpha) ;
			if (!fooIsShowDibEffectContinue ())
				break ;
			::fooDelay (m_iFreq, HighW) ;
		}
	}
//	::BitBlt (hdc, 0, 0, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
}

//===================================================================

void  FCBitmap::ShowDib_FADE (HDC hdc, HDC hDCmem, const BITMAP& bm, const SHOWEFFECT& Param)
{
	BLENDFUNCTION	alpha ;
	::ZeroMemory (&alpha, sizeof(alpha)) ;
	for (int i = 40 ; i < 204 ; i+= Param.dwBlockLen)
	{
		alpha.SourceConstantAlpha = i ;
		::AlphaBlend (hdc, 0, 0, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, bm.bmWidth, bm.bmHeight, alpha) ;
		if (!fooIsShowDibEffectContinue ())
			break ;
		::fooDelay (m_iFreq, Param.dwInterval * 1000) ;
	}
	::BitBlt (hdc, 0, 0, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
}

//===================================================================

void	FCBitmap::DrawEx (HDC hdc, SHOWEFFECT ShowParam)
{
	if ((hdc == NULL) || (m_hBitmap == NULL))	return ;

	HDC			hDCmem ;
	if ((hDCmem = ::CreateCompatibleDC (hdc)) == NULL)
		return ;
	BITMAP		bm ;
	this->GetBitmapInfo (&bm) ;
	::SetStretchBltMode (hdc, COLORONCOLOR) ;
	HBITMAP		hOldBmp = (HBITMAP)::SelectObject (hDCmem, m_hBitmap) ;
/*
	SIZE	WndExt, ViewExt ;
	POINT	WndOrg, ViewOrg ;
	if (ShowParam.dwMethod & SHOWDIB_CENTER)
	{
		if ((ShowParam.dwMethod & SHOWDIB_ISOSTRETCH) || (ShowParam.dwMethod & SHOWDIB_STRETCH))
		{
			::SetWindowExtEx (hdc, ShowParam.rcStretch.cx, ShowParam.rcStretch.cy, &WndExt) ;
			::SetWindowOrgEx (hdc, ShowParam.rcStretch.cx/2, ShowParam.rcStretch.cy/2, &WndOrg) ;
		}
		else
		{
			::SetWindowExtEx (hdc, bm.bmWidth, bm.bmHeight, &WndExt) ;
			::SetWindowOrgEx (hdc, bm.bmWidth/2, bm.bmHeight/2, &WndOrg) ;
		}
		::SetViewportExtEx (hdc, ShowParam.rcClient.right, ShowParam.rcClient.bottom, &ViewExt) ;
		::SetViewportOrgEx (hdc, ShowParam.rcClient.right/2, ShowParam.rcClient.bottom/2, &ViewOrg) ;
	}
*/
	__try
	{
		if (ShowParam.dwMethod & SHOWDIB_NORMAL)
		{
			::BitBlt (hdc, 0, 0, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
			__leave ;
		}

		// 缩放 (SHOWDIB_STRETCH)
		if (ShowParam.dwMethod & SHOWDIB_STRETCH)
		{
			::StretchBlt (hdc, 0, 0, ShowParam.sizeStretch.cx, ShowParam.sizeStretch.cy, hDCmem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY) ;
			__leave ;
		}

		// 成比例缩放 (SHOWDIB_ISOSTRETCH)
		if (ShowParam.dwMethod & SHOWDIB_ISOSTRETCH)
		{
			double		duOldScale = bm.bmWidth / (double)bm.bmHeight ;
			DWORD		dwTempW = (DWORD)(duOldScale * ShowParam.sizeStretch.cy) ;

			if (dwTempW < (DWORD)ShowParam.sizeStretch.cx)
				ShowParam.sizeStretch.cx = dwTempW ;
			else
				ShowParam.sizeStretch.cy = DWORD(ShowParam.sizeStretch.cx / duOldScale) ;
			::StretchBlt (hdc, 0, 0, ShowParam.sizeStretch.cx, ShowParam.sizeStretch.cy, hDCmem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY) ;
			__leave ;
		}

		// Show SCAN
		if (ShowParam.dwMethod & SHOWDIB_SCAN)
		{
			this->ShowDib_SCAN (hdc, hDCmem, bm, ShowParam) ;
			__leave ;
		}

		// Show MOVE
		if (ShowParam.dwMethod & SHOWDIB_MOVE)
		{
			this->ShowDib_MOVE (hdc, hDCmem, bm, ShowParam) ;
			__leave ;
		}

		// Show MOSAIC
		if (ShowParam.dwMethod & SHOWDIB_MOSAIC)
		{
			this->ShowDib_MOSAIC (hdc, hDCmem, bm, ShowParam) ;
			__leave ;
		}

		// Show HSHUTTER
		if (ShowParam.dwMethod & SHOWDIB_HSHUTTER)
		{
			int		iLine ;
			for (DWORD i = 0 ; i < ShowParam.dwBlockLen ; i++)
			{
				for (iLine = i ; iLine < bm.bmHeight ; iLine += ShowParam.dwBlockLen)
					::BitBlt (hdc, 0, iLine, bm.bmWidth, 1, hDCmem, 0, iLine, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, ShowParam.dwInterval * 1000) ;
			}
			__leave ;
		} // End of HSHUTTER

		// Show VSHUTTER
		if (ShowParam.dwMethod & SHOWDIB_VSHUTTER)
		{
			int		iLine ;
			for (DWORD i = 0 ; i < ShowParam.dwBlockLen ; i++)
			{
				for (iLine = i ; iLine < bm.bmWidth ; iLine += ShowParam.dwBlockLen)
					::BitBlt (hdc, iLine, 0, 1, bm.bmHeight, hDCmem, iLine, 0, SRCCOPY) ;
				if (!fooIsShowDibEffectContinue ())
					break ;
				::fooDelay (m_iFreq, ShowParam.dwInterval * 1000) ;
			}
			__leave ;
		} // End of VSHUTTER

		// Show Fade
		if (ShowParam.dwMethod & SHOWDIB_FADE)
		{
			this->ShowDib_FADE (hdc, hDCmem, bm, ShowParam) ;
			__leave ;
		}
		  /*
		// Show FADE_SCAN
		if (dwShow & SHOWDIB_FADE_SCAN)
		{
			this->ShowDib_FADESCAN (hdc, hDCmem, bm, dwParam) ;
			::BitBlt (hdc, 0, 0, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
			__leave ;
		}
		}*/
	}
	__finally
	{
		::SelectObject (hDCmem, hOldBmp) ;
		DeleteDC (hDCmem) ;
/*		if (ShowParam.dwMethod & SHOWDIB_CENTER)
		{
			::SetWindowExtEx (hdc, WndExt.cx, WndExt.cy, NULL) ;
			::SetWindowOrgEx (hdc, WndOrg.x, WndOrg.y, NULL) ;
			::SetViewportExtEx (hdc, ViewExt.cx, ViewExt.cy, NULL) ;
			::SetViewportOrgEx (hdc, ViewOrg.x, ViewOrg.y, NULL) ;
		}*/
	}
	return ;
}
//===================================================================
void  FCBitmap::Draw (HDC hdc, int x, int y, int xSrc, int ySrc)
{
	if ((hdc != NULL) && (m_hBitmap != NULL))
	{
		HDC		hDCmem ;
		if ((hDCmem = ::CreateCompatibleDC (hdc)) == NULL)
			return ;
		BITMAP	bm ;
		this->GetBitmapInfo (&bm) ;
		HBITMAP		hOld = (HBITMAP)::SelectObject (hDCmem, m_hBitmap) ;
		if ((m_iScale == 1) || (m_iScale == -1))
			::BitBlt (hdc, x, y, bm.bmWidth, bm.bmHeight, hDCmem, xSrc, ySrc, SRCCOPY) ;
		else
		{
			int		nWidth, nHeight ;
			if (m_iScale > 0)
			{
				nWidth = (bm.bmWidth-xSrc) * m_iScale ;
				nHeight = (bm.bmHeight-ySrc) * m_iScale ;
			}
			else
			{
				nWidth = (bm.bmWidth-xSrc) / -m_iScale ;
				nHeight = (bm.bmHeight-ySrc) / -m_iScale ;
			}
			::SetStretchBltMode (hdc, COLORONCOLOR) ;
			::StretchBlt (hdc, x, y, nWidth, nHeight, hDCmem, xSrc, ySrc, bm.bmWidth-xSrc, bm.bmHeight-ySrc, SRCCOPY) ;
		}

		::SelectObject (hDCmem, hOld) ;
		::DeleteDC (hDCmem) ;
	}
}
//===================================================================
void  FCBitmap::AlphaBlendDraw (HDC hdc, int alpha, int x, int y)
{
	if ((hdc == NULL) || (m_hBitmap == NULL))	return ;
	HDC		hDCmem ;
	if ((hDCmem = ::CreateCompatibleDC (hdc)) == NULL)	return ;
	BITMAP	bm ;
	this->GetBitmapInfo (&bm) ;
	HBITMAP		hOld = (HBITMAP)::SelectObject (hDCmem, m_hBitmap) ;
	BLENDFUNCTION	blend ;
	memset (&blend, 0, sizeof(blend)) ;
	blend.SourceConstantAlpha = 0xFE * alpha / 100 ;
	if (alpha == 100)
		::BitBlt (hdc, x, y, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, SRCCOPY) ;
	else
		::AlphaBlend (hdc, x, y, bm.bmWidth, bm.bmHeight, hDCmem, 0, 0, bm.bmWidth, bm.bmHeight, blend) ;
	::SelectObject (hDCmem, hOld) ;
	::DeleteDC (hDCmem) ;
}
//===================================================================
void  FCBitmap::MapScaledPoint (POINT & pt)
{
	if (m_iScale > 0)
	{
		pt.x *= m_iScale ;
		pt.y *= m_iScale ;
	}
	else
	{
		pt.x /= -m_iScale ;
		pt.y /= -m_iScale ;
	}
}
void  FCBitmap::MapScaledRect (RECT & rect)
{
	if (m_iScale > 0)
	{
		rect.left *= m_iScale ;
		rect.top *= m_iScale ;
		rect.right *= m_iScale ;
		rect.bottom *= m_iScale ;
	}
	else
	{
		rect.left /= -m_iScale ;
		rect.top /= -m_iScale ;
		rect.right /= -m_iScale ;
		rect.bottom /= -m_iScale ;
	}
}
void  FCBitmap::MapRealPoint (POINT & pt)
{
	if (m_iScale > 0)
	{
		pt.x /= m_iScale ;
		pt.y /= m_iScale ;
	}
	else
	{
		pt.x *= -m_iScale ;
		pt.y *= -m_iScale ;
	}
}
void  FCBitmap::MapRealRect (RECT & rect)
{
	if (m_iScale > 0)
	{
		rect.left /= m_iScale ;
		rect.top /= m_iScale ;
		rect.right /= m_iScale ;
		rect.bottom /= m_iScale ;
	}
	else
	{
		rect.left *= -m_iScale ;
		rect.top *= -m_iScale ;
		rect.right *= -m_iScale ;
		rect.bottom *= -m_iScale ;
	}
}
//===================================================================