bitmaps.cpp

Windows 图形编程 书籍

	}

	return CommonMDIChildProc(hWnd, uMsg, wParam, lParam, m_hViewMenu, 3);
}



// special routine to display a 8x8 DDB as 32x32
void TestDDB88(HDC hDC, int x, int y, HBITMAP hBmp, const TCHAR * desp)
{
	HDC hMemDC = CreateCompatibleDC(hDC);
	SelectObject(hMemDC, hBmp);

	StretchBlt(hDC, x, y, 32, 32, hMemDC, 0, 0, 8, 8, SRCCOPY);
	
	TCHAR mess[64];

	TextOut(hDC, x+50, y, desp, _tcslen(desp));
		
	DecodeDDB(hBmp, mess);
	TextOut(hDC, x+50, y+20, mess, _tcslen(mess));

	DeleteObject(hMemDC);
	DeleteObject(hBmp);
}


void KDDBView::Test_CreateBitmap(HDC hDC, const RECT * rcPaint)
{
	// Test supported DDB format	
	const SIZE format[] = { 
			{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 4 }, { 1, 8 }, 
			{ 1, 15 }, { 1, 16}, { 1, 24 }, { 1, 32 }, { 1, 48 },
			{ 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 } };

	TextOut(hDC, 100, 10, "Supported DDB Formats", 21);

	for (int i=0; i<sizeof(format)/sizeof(format[0]); i++)
	{
		TCHAR mess[128];
	
		HBITMAP hBmp = CreateBitmap(16, 16, format[i].cx, format[i].cy, NULL);

		wsprintf(mess, "CreateBitmap(16, 16, %d, %d, NULL) ", format[i].cx, format[i].cy);
		TextOut(hDC, 10, 30+i*17, mess, _tcslen(mess));

		DecodeDDB(hBmp, mess);
		TextOut(hDC, 250, 30+i*17, mess, _tcslen(mess));
		DeleteObject(hBmp);
	}

	
	SetViewportOrgEx(hDC, 150, 0, NULL);

	// Initialized 1 bpp
	const WORD Chess44_WORD [] = { 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33 };
	
	TestDDB88(hDC, 300, 20, CreateBitmap(8, 8, 1, 1, Chess44_WORD), _T("CreateBitmap(8, 8, 1, 1, Chess44_WORD)"));

	// Uninitialized 1 bpp
	TestDDB88(hDC, 300, 70, CreateBitmap(8, 8, 1, 1, NULL), _T("CreateBitmap(8, 8, 1, 1, NULL)"));

	// CreateBitmapIndirect, 1 bpp, DWORD aligned pixel array
	DWORD Chess44_DWORD [] = { 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33 };
	
	BITMAP bbp = { 0, 8, 8, sizeof(DWORD), 1, 1, Chess44_DWORD };

	TestDDB88(hDC, 300, 120, CreateBitmapIndirect(&bbp), _T("CreateBitmapIndirect({0,8,8,sizeof(DWORD),1,1,Chess44_DWORD})"));

	// CreateCompatibleBitmap: Mem DC
	HDC hMemDC = CreateCompatibleDC(hDC);
	TestDDB88(hDC, 300, 170, CreateCompatibleBitmap(hMemDC, 8, 8), _T("CreateCompatibleBitmap(hMemDC, 8, 8)"));
	DeleteObject(hMemDC);

	SetViewportOrgEx(hDC, 0, 0, NULL);
}
	

void KDDBView::Test_LargestDDB(HDC hDC, const RECT * rcPaint)
{
	HDC hMemDC = CreateCompatibleDC(hDC);
		
	// Calculate largest DDB size
	TCHAR mess[128];
	HDC DC[2] = { hMemDC, hDC };

	for (int y=0; y<2; y++)
	{
		const TCHAR * desp[] = { "Largest monochrome",
		"Largest screen compatible bitmap" };

		HBITMAP hBmp = LargestDDB(DC[y]);

		TextOut(hDC, 20, 10+y*20, desp[y], _tcslen(desp[y]));

		DecodeDDB(hBmp, mess);
		TextOut(hDC, 280, 10+y*20, mess, _tcslen(mess));

		DeleteObject(hBmp);
	}

	// test maximum number of DDB that can be created
	for (y=0; y<2; y++)
	{
		HBITMAP hBmp[1024];

		for (int x=0; x<1024; x++)
		{
			hBmp[x] = CreateCompatibleBitmap(DC[y], GetSystemMetrics(SM_CXSCREEN), 
				GetSystemMetrics(SM_CYSCREEN));
			if ( hBmp[x]==NULL )
				break;
		}

		wsprintf(mess, "Maximum number of DDB: %d, each of them is ", x);
		TextOut(hDC,  20, 60 + y*20, mess, _tcslen(mess));

		DecodeDDB(hBmp[0], mess);
		TextOut(hDC, 340, 60 + y*20, mess, _tcslen(mess));

		x--;
		while ( x>=0 )
		{
			DeleteObject(hBmp[x]);
			x --;
		}
	}

	DeleteObject(hMemDC);
}


void KDDBView::Test_LoadBitmap(HDC hDC, const RECT * rcPaint)
{
	TCHAR mess[128];

	HDC hMemDC = CreateCompatibleDC(hDC);

	// load difference BITMAP as resource
	HPALETTE hPal = CreateHalftonePalette(hDC);
	HPALETTE hOld = SelectPalette(hDC, hPal, FALSE);
	RealizePalette(hDC);

	for (int i=0; i<6; i++)
	{
		int x = 10 + (i%3) * 320;
		int y = 10 + (i/3) * 320;

		KDIB dib;

		dib.LoadBitmap(m_hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));

		HBITMAP hBmp;

		if ( (m_nViewOpt==IDM_VIEW_LOADBITMAP) || (m_nViewOpt==IDM_VIEW_LOADBITMAPHEX) )
			hBmp = LoadBitmap(m_hInst, MAKEINTRESOURCE(i+IDB_BITMAP1));
		else
			hBmp = dib.ConvertToDDB(hDC);

		KGDIObject bmp(hMemDC, hBmp);

		if ( hBmp==NULL ) break;

		BITMAP info;
		GetObject(hBmp, sizeof(BITMAP), & info);

		BitBlt(hDC, x, y, info.bmWidth, info.bmHeight, hMemDC, 0, 0, SRCCOPY);

		dib.DecodeDIBFormat(mess);
		TextOut(hDC, x, y + info.bmHeight+20, mess, _tcslen(mess));
		
		DecodeDDB(bmp.m_hObj, mess);
		TextOut(hDC, x, y + info.bmHeight+40, mess, _tcslen(mess));

		int size = GetBitmapBits(hBmp, 0, NULL);
		wsprintf(mess, "DDB %d bytes", size);
		TextOut(hDC, x, y+ info.bmHeight+60, mess, _tcslen(mess));

		if ( (m_nViewOpt==IDM_VIEW_LOADBITMAPHEX) || (m_nViewOpt==IDM_VIEW_CREATEDIBITMAPHEX) )
			SendMessage(GetParent(GetParent(m_hWnd)), WM_USER+1, (WPARAM) hBmp, 1);
	}
	SelectPalette(hDC, hOld, FALSE);
	RealizePalette(hDC);
	DeleteObject(hPal);

	DeleteObject(hMemDC);
}


void KDDBView::Test_Blt(HDC hDC, const RECT * rcPaint)
{
	KDDB ddb;

	int nSeq;

	m_texture.GetChecked(nSeq);

	ddb.LoadBitmap(m_hInst, TextureID[nSeq]);

	RECT rect;

	GetClientRect(m_hWnd, & rect);
	int cwidth = rect.right;
	int cheight = rect.bottom;

	switch ( m_nViewOpt )
	{
		case IDM_VIEW_BLT_NORMAL:
			ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_normal);
			break;

		case IDM_VIEW_BLT_CENTER:
			ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_center);
			break;

		case IDM_VIEW_BLT_STRETCH:
			ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_stretch);
			break;

		case IDM_VIEW_BLT_TILE:
			ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_tile);
			break;

		case IDM_VIEW_BLT_STRETCHPROP:
			ddb.Draw(hDC, 0, 0, cwidth, cheight, SRCCOPY, KDDB::draw_stretchprop);
	}
}


void KDDBView::Test_Blt_Color(HDC hDC, const RECT * rcPaint)
{
	KDDB ddb;

	ddb.LoadBitmap(m_hInst, IDB_LION);
	RECT rect;

	GetClientRect(m_hWnd, & rect);
	int cwidth = rect.right;
	int cheight = rect.bottom;

	BITMAP bmp;
	GetObject(ddb.GetBitmap(), sizeof(bmp), & bmp);
	
	HDC hMemDC = CreateCompatibleDC(hDC);
	SelectObject(hMemDC, ddb.GetBitmap());

	COLORREF ColorTable[] = { 
		RGB(0xFF, 0, 0),    RGB(0, 0xFF, 0),    RGB(0, 0, 0xFF),
		RGB(0xFF, 0xFF, 0), RGB(0, 0xFF, 0xFF), RGB(0xFF, 0, 0xFF) 
	};

	for (int j=0; j<cheight; j+= bmp.bmHeight )
	for (int i=0; i<cwidth;  i+= bmp.bmWidth  )
	{
		SetTextColor(hDC, ColorTable[j/bmp.bmHeight]);
		SetBkColor(hDC,   ColorTable[i/bmp.bmWidth] | RGB(0xC0, 0xC0, 0xC0));

		BitBlt(hDC, i, j, bmp.bmWidth, bmp.bmHeight, hMemDC, 0, 0, SRCCOPY);
	}

	DeleteObject(hMemDC);
}


void KDDBView::Test_Blt_GenMask(HDC hDC, const RECT * rcPaint)
{
	KDDB ddb;

	KGDIObject brush(hDC, CreateSolidBrush(RGB(0xFF, 0xFF, 0)));

	
	ddb.LoadBitmap(m_hInst, IDB_CUBE);
	BITMAP bmp;
	GetObject(ddb.GetBitmap(), sizeof(bmp), & bmp); 

	PatBlt(hDC, 0, 0, bmp.bmWidth * 5 + 70, bmp.bmHeight * 2 + 30, PATCOPY);

	ddb.Draw(hDC, 10, 10, 0, 0, SRCCOPY, KDDB::draw_normal);

	COLORREF ct[] = {
		RGB(128, 128, 128), RGB(192, 192, 192), RGB(255, 255, 255),
		RGB(255, 0, 0), RGB(0, 255, 0), RGB(0, 0, 255),
		RGB(255, 255, 0), RGB(0, 255, 255), RGB(255, 0, 255)
	};

	HDC hMemDC = CreateCompatibleDC(hDC);

	for (int i=0; i<sizeof(ct)/sizeof(COLORREF); i++)
	{
		HBITMAP hOld = ddb.CreateMask(ct[i], hMemDC);

		SetBkColor(hDC, RGB(0xFF, 0xFF, 0xFF));
		SetTextColor(hDC, RGB(0, 0, 0));

		BitBlt(hDC, ((i+1)%5)* (bmp.bmWidth+10)+10, ((i+1)/5)* (bmp.bmHeight+10)+10, bmp.bmWidth, bmp.bmHeight,
			hMemDC, 0, 0, SRCCOPY);

		DeleteObject(SelectObject(hMemDC, hOld));
	}

	DeleteObject(hMemDC);
}


void KDDBView::OnDraw(HDC hDC, const RECT * rcPaint)
{
	switch ( m_nViewOpt )
	{
		case IDM_VIEW_CREATEBITMAP:
			Test_CreateBitmap(hDC, rcPaint);
			break;

		case IDM_VIEW_LARGESTDDB:
			Test_LargestDDB(hDC, rcPaint);
			break;

		case IDM_VIEW_LOADBITMAP:
		case IDM_VIEW_CREATEDIBITMAP:
			Test_LoadBitmap(hDC, rcPaint);
			break;

		case IDM_VIEW_LOADBITMAPHEX:
			Test_LoadBitmap(hDC, rcPaint);
			m_nViewOpt = IDM_VIEW_LOADBITMAP;
			break;

		case IDM_VIEW_CREATEDIBITMAPHEX:
			Test_LoadBitmap(hDC, rcPaint);
			m_nViewOpt = IDM_VIEW_CREATEDIBITMAP;
			break;

		case IDM_VIEW_BLT_NORMAL:
		case IDM_VIEW_BLT_CENTER:
		case IDM_VIEW_BLT_STRETCH:
		case IDM_VIEW_BLT_TILE:
		case IDM_VIEW_BLT_STRETCHPROP:
			Test_Blt(hDC, rcPaint);
			break;

		case IDM_VIEW_BITBLT_COLOR:
			Test_Blt_Color(hDC, rcPaint);
			break;

		case IDM_VIEW_GENMASK:
			Test_Blt_GenMask(hDC, rcPaint);
			break;
	}
}

//////////////////////
//    DIB Section   //
//////////////////////

class KDIBSectionView : public KScrollCanvas
{
	typedef enum { GAP = 16 };

	virtual void    OnDraw(HDC hDC, const RECT * rcPaint);
	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
	void			GetWndClassEx(WNDCLASSEX & wc);
	
	HMENU			m_hViewMenu;
	int				m_nViewOpt;

public:

	KDIBSectionView(void)
	{
		m_hViewMenu = NULL;
		m_nViewOpt  = IDM_VIEW_CREATEBITMAP;
	}

	bool Initialize(HINSTANCE hInstance, KStatusWindow * pStatus)
	{
		m_hInst   = hInstance;
		m_pStatus = pStatus;

		RegisterClass(_T("DIBSectionView"), hInstance);
			
		return true;
	}

	void Test_CreateDIBSection(HDC hDC, const RECT * rcPaint);
};


void KDIBSectionView::Test_CreateDIBSection(HDC hDC, const RECT * rcPaint)
{
	TextOut(hDC, 10, 10, "CreateDIBSection", 10);

	TCHAR temp[128];
	KDIBSection dibsection[11];

	for (int i=0; i<11; i++)
	{
		const int static bitcount   [] = { 0,      1,      4,       4,      8,       8,      16,     16,           24,     32    , 32};
		const int static compression[] = { BI_PNG, BI_RGB, BI_RLE4, BI_RGB, BI_RLE8, BI_RGB, BI_RGB, BI_BITFIELDS, BI_RGB, BI_RGB, BI_BITFIELDS };

		KBitmapInfo bmi;

		bmi.SetFormat(125, 125, bitcount[i], compression[i]);

		dibsection[i].CreateDIBSection(hDC, bmi.GetBMI(), DIB_RGB_COLORS, NULL, NULL);
		
		dibsection[i].DecodeDIBSectionFormat(temp);
		TextOut(hDC, 20, 40 + i*20, temp, _tcslen(temp));

		if ( dibsection[i].GetBitmap() )
		{
			HBITMAP hBig = LargestDIBSection(bmi.GetBMI());

			DecodeDDB(hBig, temp);
			TextOut(hDC, 720, 40 + i*20, temp, _tcslen(temp));

			DeleteObject(hBig);
		}