Thread: BitBlt (Yet Again)

Hi after a recent discussion in this forum i decided to adopt the method of using the bitblt function to display my graphics. I was just creating a driver program and I can't get it to work. All I get is a black screen and I was wondering why.

Code:

#define WIN32_MEAN_AND_LEAN

#include <windows.h>
#include <windowsx.h>

inline bool getKeyDown(int vk_key)
{
	if (GetAsyncKeyState(vk_key) & 0x8000)
		return 1;
	else
		return 0;
}

LRESULT CALLBACK messageHandler (HWND winHandle, UINT theMsg, 
								 WPARAM wParam, LPARAM lParam)
{
	PAINTSTRUCT ps;
	HDC hdc;
	switch (theMsg)
	{
	case WM_CREATE:
		{
			return 0;
			break;
		}
	case WM_PAINT:
		{
			hdc = BeginPaint(winHandle,&ps);
			EndPaint(winHandle,&ps);
			return 0;
			break;
		}
	case WM_DESTROY:
		{
			PostQuitMessage(0);
			return 0;
			break;
		}
	default:
		break;
	}
	return (DefWindowProc(winHandle,theMsg,wParam,lParam));
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
					int nShowCmd)
{
	WNDCLASSEX winclass;
	HWND windowsHandle1;
	MSG theMsg;
	winclass.cbSize = sizeof (WNDCLASSEX);
	winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
	winclass.cbClsExtra = 0;
	winclass.cbWndExtra = 0;
	winclass.hInstance = hInstance;
	winclass.lpfnWndProc = messageHandler;
	winclass.hIcon = LoadIcon(NULL,IDI_APPLICATION);
	winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
	winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	winclass.lpszMenuName = NULL;
	winclass.lpszClassName = "windyClass";
	winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	if(!(RegisterClassEx(&winclass)))
		return 0;

	if (!(windowsHandle1 = CreateWindowEx(NULL, "windyClass", "The First Window",
		WS_OVERLAPPEDWINDOW| WS_VISIBLE , 0, 0 ,
		640, 480, NULL, NULL, hInstance, NULL)))
		return 0;
		HDC hdc;

	while (1)
	{
		if (PeekMessage(&theMsg,NULL,0,0,PM_REMOVE))
		{
			if(theMsg.message == WM_QUIT)
				break;
		TranslateMessage(&theMsg);
		DispatchMessage(&theMsg);
		}
		// Create Dc And HBITMAP and put them in different things
		hdc = GetDC(windowsHandle1);
		HDC hdc2 = CreateCompatibleDC(NULL);
		HBITMAP theBitmap = CreateCompatibleBitmap(hdc2,640,480);
		SelectObject(hdc2,theBitmap);
		// Draw a rectangle on the bitmap
		HPEN thePen = CreatePen(PS_SOLID,1,RGB(0,255,0));
		HBRUSH theBrush = CreateSolidBrush(RGB(0,255,0));
		SelectObject(hdc2,thePen);
		SelectObject(hdc2,theBrush);
		Rectangle(hdc2,0,0,640,480);
		// On the key C blit the bitmap to the screen
		if (getKeyDown(VK_DOWN))
		{
			BitBlt(hdc,0,0,640,680,hdc2,0,0,SRCCOPY);
		}
	}
	ReleaseDC(windowsHandle1,hdc);
	return 0;
}

First thanks for the help, but now im getting really confused. I was taught that the WM_PAINT message is only called when the window needs to be refresed. I also was told that you should try and keep your emssage handler as small as possible and not make it overly complex. Hense why I deal with the keyboard outside the handler.
Is in not possible to deal with grahics outside the message handler because it just makes a lot more sense to me and in my opinion makes your code a lot cleaner.
The problem I now have is that it just creates loads of white squares. I want it tocreate a green rectangle like the function suggests it should do.
Can anyone just do a specific example of the bare minimum you need to do to copy a coulour image from your bitmap to the screen. Including all the HDC's that you have to declare. Make thanks in advance

/*
I have fixed the code with comments included inline.
Use the up and down keys to toggle colour/color.
Some things to note:
- When you use SelectObject you must save the old object and put it at cleanup.
- When you create a gdi object you must destroy it. The function to do this with can be found in the docs of the creation function.
- Code is much more readable when you use functions as below.
- Use names like hBitmap instead of theBitmap. The h signifies the variable is a handle to an object.
- There is similar code (without the double buffering) available here:
http://msdn.microsoft.com/library/en...olors_5noz.asp
*/

Code:

#include <windows.h>
#include <windowsx.h>

static BOOL state;

void PaintWindow(HWND hwnd, HDC hdc) {

	HDC hdc2;
	HBITMAP theBitmap;
	HBITMAP hOldBitmap;
	HPEN thePen;
	HPEN hOldPen;
	HBRUSH theBrush;
	HBRUSH hOldBrush;

	hdc2 = CreateCompatibleDC(hdc);
	// Note: We pass the hdc of the original window - not the 
	// created hdc which is still monochrome...
	theBitmap = CreateCompatibleBitmap(hdc,640,480);

	// Save old bitmap so we can restore it later...
	hOldBitmap = SelectObject(hdc2,theBitmap);

	// Create a pen and brush to draw with...
	thePen = CreatePen(PS_SOLID,1,RGB(0,255,0)); // Green
	theBrush = CreateSolidBrush(RGB(0,255,0));   // Green

	// Put new objects into our hdc2.
	// Save old objects so we can restore them later...
	hOldPen = SelectObject(hdc2,thePen);
	hOldBrush = SelectObject(hdc2,theBrush);

	// Draw a rectangle on the bitmap...
	Rectangle(hdc2,0,0,640,480);

	// On the key C blit the bitmap to the screen
	// Note that all of this code should be surrounded with
	// if (state)... Otherwise it is a total waste.
	if (state) BitBlt(hdc,0,0,640,680,hdc2,0,0,SRCCOPY);

	// Now put back the old stuff into hdc2...
	SelectObject(hdc2, hOldBitmap);
	SelectObject(hdc2, hOldPen);
	SelectObject(hdc2, hOldBrush);

	// Destroy the stuff we created...
	DeleteObject(theBitmap);
	DeleteObject(thePen);
	DeleteObject(theBrush);
	DeleteDC(hdc2);

}

LRESULT CALLBACK messageHandler (HWND winHandle, UINT theMsg, WPARAM wParam, LPARAM lParam)
{
	switch (theMsg)
	{
	case WM_KEYDOWN:
		if (wParam == VK_DOWN)
		{
			state = TRUE;
			InvalidateRect(winHandle, NULL, TRUE);
		}
		else if (wParam == VK_UP) {
			state = FALSE;
			InvalidateRect(winHandle, NULL, TRUE);
		}
		return 0;
	case WM_CREATE:
		return 0;
	case WM_PAINT: {

		PAINTSTRUCT ps;
		HDC hdc;

		// Note that BeginPaint will fill the update region
		// with the background brush. This will cause flicker and
		// defeats the purpose of double buffering!!
		hdc = BeginPaint(winHandle,&ps);

		PaintWindow(winHandle, hdc);

		// NOTE: We do not call ReleaseDC on hdc.
		// This is only required when we obtained it with GetDC, etc.
		EndPaint(winHandle,&ps);

		return 0;
	}
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	default:
		return (DefWindowProc(winHandle,theMsg,wParam,lParam));
	}
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	WNDCLASSEX winclass;
	HWND windowsHandle1;
	MSG theMsg;
	BOOL bRet;

	winclass.cbSize = sizeof (WNDCLASSEX);
	winclass.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
	winclass.cbClsExtra = 0;
	winclass.cbWndExtra = 0;
	winclass.hInstance = hInstance;
	winclass.lpfnWndProc = messageHandler;
	winclass.hIcon = LoadIcon(NULL,IDI_APPLICATION);
	winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
	winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	winclass.lpszMenuName = NULL;
	winclass.lpszClassName = "windyClass";
	winclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	if(!(RegisterClassEx(&winclass)))
		return 1; // you should return 1 to indicate an error

	if (!(windowsHandle1 = CreateWindowEx(0, "windyClass", "The First Window",
		WS_OVERLAPPEDWINDOW| WS_VISIBLE , 0, 0 ,
		640, 480, NULL, NULL, hInstance, NULL)))
	return 1; // you should return 1 to indicate an error

	// Unless you have a good reason, use GetMessage loop
	// and not PeekMessage...
	while ( bRet = GetMessage(&theMsg, NULL, 0, 0) ) {

		if (bRet == -1) break;

		TranslateMessage(&theMsg);
		DispatchMessage(&theMsg);
	}

	return 0;
}

Hi thanks to all you guys for your help. But I dont wanan change my coding habbits so i asked someone on ICQ. About hit and he had a look and said use CreateBitmap instead of CreateCompatibleBitmap. It sacrfises a bit of speed but at least it works the way its meant too.
Eventually I want to move to direct x but all this COM rubbish is putting me off lol.

Thanks again all

> The problem I now have is that it just creates loads of white squares.

>If the squares remain then set the dhc to white first (use BitBlt( , , , , , , , WHITENESS) or fill the whole area with a white pen.

This problem was caused by the original code passing the wrong hdc to CreateCompatibleBitmap (ie. The buffer hdc instead of the original). This meant that the created bitmap was monochrome and quite useless.

>This example is not 'double buffered'.

>Double buffering keeps a copy of the screen DC to draw to the paint hdc WHILE it uses another copy of teh screen hdc to create the next image. Then the app 'swaps' them and continues.
This way the app does not have to redraw its hdc in response to EVERY paint msg.
It has a frame ready if an external event triggers a paint ( ie other app moves across your apps client area).

Cool. Can we call this example single buffered then?

Anyway the code works and the original poster can use it if they wish.

Yeah thanks everyone. I sort of grasp the concept. i created a demo program using a Compatible Bitmap and it works. I also put it in its own functionw hich is called by the windows paint emssage. I would like to take this time to thank everyone who has helped me through this. God Bless You All !!!!