Auslagerungsdateiauslastung ständig steigend

Ich benutzt Windows XP.
Die Funktion wird aufgerufen aus meiner WM_TIMER, in der ich eine Kollisionskontrolle mit den Außenwänden drin habe.

BeginPaint und EndPaint nur im WM_PAINT Handler nutzen. Im WM_TIMER Handler nur InvalidateRect aufrufen.

So, ich sende jetzt von meinem WM_TIMER eine Nachricht
WndProg(hwnd, WM_PAINT,NULL,NULL); damit ich die Funktion im WM_PAINT aufrufe.
Das InvalidateRect habe ich nach den Aufruf der Funktion WndProg angefügt und aus der Lade-Bitmap-Funktion gelöscht. Egal wie ich es drehe oder wende, dass Problem besteht weiterhin.

Christoph

Anfaenger nr 5 schrieb:

So, ich sende jetzt von meinem WM_TIMER eine Nachricht
WndProg(hwnd, WM_PAINT,NULL,NULL); damit ich die Funktion im WM_PAINT aufrufe.

Das ist doch sinnlos.

So rufst du BeginPaint zwar scheinbar nur bei WM_PAINT auf. Aber denkst du wirklich es macht für Windows einen Unterschied, ob du BeginPaint direkt bei WM_TIMER ausführst oder über den Umweg mit "WndProg(hwnd, WM_PAINT,NULL,NULL);"? Windows verlangt, dass BeginPaint nur dann aufgerufen wird, wenn dein Fenster von Windows WM_PAINT erhält.

Nimm bei WM_TIMER InvalidateRect (als dritten Parameter FALSE, sonst hast du wieder flackern). Wenn du dann UpdateWindow aufrufst, schickt Windows deinem Fenster ein WM_PAINT. Erst dort darfst du mit BeginPaint kommen.

Nagut:
Folgendes hab ich jetzt
Bei WM_TIMER steht jetzt

UpdateWindow(hWnd);
InvalidateRect(hWnd, NULL, false);

Bei WM_PAINT steht die schon oben gepostete Funktion ohne das InvalidateRect.
Mir scheint, als ob ich alles befolgt habe, was ihr mir gesagt habt.
Aber mein Problem besteht immer noch.

Wenn schon InvalidateRect und dann UpdateWindow. Aber UpdateWindow brauch man normalerweise nicht. :p

Nagut. Folgendes von meiner Seite. Auch wenn es die Leute nicht gerne sehen, werde ich jetzt das komplette Programm posten. Warum? Weil hier nicht auf das eigentliche Problem eingegangen wird.

Ich müsste noch eine Bitmap zeichen (400400) komplett schwarz
und eine (1616) blauer ausgemalter Kreis auf schwarzen Hintergrund.

Bitte keine Fragen warum und wieso die Bitmaps so sein sollen. ist eben so *g*

#include "stdafx.h"

#define WIDICON 16
#define HIGICON 16

ATOM MyRegisterClass( HINSTANCE hInstance );
BOOL InitInstance( HINSTANCE hInstance, int nCmdShow );
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

void Lade_Bitmap(HWND hWnd, int NEUX, int NEUY);

int Laufrichtung = 1;

int IndexX=400, IndexY=200;
int punkte[400][400];

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow )
{
	MSG msg;

	MyRegisterClass(hInstance);

	if(!InitInstance( hInstance, nCmdShow ))	return FALSE;

	punkte[IndexX][IndexY] = 1;

	while( GetMessage(&msg, NULL, 0, 0) ) 
	{
		TranslateMessage( &msg );
		DispatchMessage( &msg );
	}

	return msg.wParam;

	return 0;
}

ATOM MyRegisterClass( HINSTANCE hInstance )
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX); 
	wcex.style			= NULL;
	wcex.lpfnWndProc	= (WNDPROC)WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= NULL;
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH) (COLOR_WINDOWTEXT);
	wcex.lpszMenuName	= NULL;
	wcex.lpszClassName	= "MYWINDOW";				//=^1.Operator in Create Window
	wcex.hIconSm		= NULL;

	return RegisterClassEx(&wcex);
}

BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
{
   HWND hWnd;

   hWnd = CreateWindow("MYWINDOW", "Fenster1",WS_POPUP,
      0, 0, 400, 400, NULL, NULL, hInstance, NULL);

   if(!hWnd)   return FALSE;

   ShowWindow( hWnd, nCmdShow );
   UpdateWindow( hWnd );

   return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static int X = 200;
	static int Y = 20;

	switch( message ) 
	{
		case WM_CREATE:	
			Laufrichtung = 1;
			SetTimer(hWnd, NULL, 10, NULL);
			break;

//von linksoben --> rechtsunten  Laufrichtung = 1
//von rechtsoben --> linksunten  Laufrichtung = 2
//von linksunten --> rechtsoben  Laufrichtung = 3
//von rechtsunten --> linksoben  Laufrichtung = 4
		case WM_TIMER:
			if (Laufrichtung ==1) {
				if (X==384) Laufrichtung =2;
				else if (Y == 384) Laufrichtung = 3;
			}
			else if (Laufrichtung ==2) {
				if (X==0) Laufrichtung =1;
				else if (Y == 384) Laufrichtung = 4;
			}
			else if (Laufrichtung ==3) {
				if (X==384) Laufrichtung =4;
				else if (Y == 0) Laufrichtung = 1;
			}
			else if (Laufrichtung ==4) {
				if (X==0) Laufrichtung =3;
				else if (Y == 0) Laufrichtung = 2;
			}
			if (Laufrichtung ==1)
			{
				X++;
				Y++;
			}
			else if(Laufrichtung ==2)
			{
				X--;
				Y++;
			}
			else if(Laufrichtung ==3)
			{
				X++;
				Y--;
			}
			else if(Laufrichtung ==4)
			{
				X--;
				Y--;
			}

			InvalidateRect(hWnd, NULL, false);
			UpdateWindow(hWnd);
			//Lade_Bitmap(hWnd, X, Y);
			break;

		case WM_PAINT:
			Lade_Bitmap(hWnd, X, Y);
			break;

		case WM_DESTROY:
			KillTimer(hWnd, NULL);
			PostQuitMessage( 0 );
			break;
		default:
			return DefWindowProc( hWnd, message, wParam, lParam );
   }
   return 0;
}

//Übergabe des Handles und der Koordinatenwerte, an der die Grafik gezeichnet wird
void Lade_Bitmap(HWND hWnd, int NEUX, int NEUY)
{
	PAINTSTRUCT ps;
	HBITMAP hBg, hSprite;
	HDC Bildhdc, Bghdc, Spritehdc, Bufferhdc;

	Bildhdc = BeginPaint (hWnd, &ps);

//Bilder aus einer Datei in hdc holen
	hBg = (HBITMAP)LoadImage(NULL, "bg.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);  
	hSprite = (HBITMAP)LoadImage(NULL, "sprite.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE); 

	Bufferhdc = CreateCompatibleDC(Bildhdc);
	Bghdc = CreateCompatibleDC(Bildhdc);
	Spritehdc = CreateCompatibleDC(Bildhdc);

	HBITMAP hOldBg = (HBITMAP) SelectObject(Bghdc, hBg);
	HBITMAP hOldSprite = (HBITMAP) SelectObject(Spritehdc, hSprite);

	Bufferhdc = Bghdc;
	//BitBlt(Bufferhdc, NEUX, NEUY, WIDICON, HIGICON,Spritehdc,0,0,SRCCOPY);
	TransparentBlt(Bufferhdc, NEUX, NEUY, WIDICON, HIGICON, Spritehdc, 0, 0, 16, 16, RGB(0,0,0));

	BitBlt(Bildhdc, 0, 0, 400, 400, Bufferhdc, 0, 0, SRCCOPY);

	SelectObject(Bildhdc, hOldBg);
	SelectObject(Bildhdc, hOldSprite);

	DeleteDC(Bufferhdc);
    DeleteDC(Bghdc);
	DeleteDC(Spritehdc);

	DeleteObject(hBg);
	DeleteObject(hSprite);

	EndPaint( hWnd, &ps );
}

Eingebunden wird nur windows.h in der stdafx

Christoph

Du lädst bei jedem WM_PAINT die Bitmaps neu von der Festplatte. Da wundert es mich nicht, dass dein Programm langsam läuft.
Besser wäre es die Bitmaps z.B. bei WM_CREATE zu laden und bei WM_DESTROY freizugeben.

Ich weiß, dass ich heute wieder besonders nerve. Eigentlich ist es das erste mal, dass ich nerve. Aber es hilft ja alles nichts.
Habe cd9000´s mal durchdacht und schien mir logisch.

Nach der Umsetzung wird aber trotzdem ständig neuer Speicher zugesichert.

Lade die Bitmaps jetzt in der WM_CREATE und gebe sie in der WM_DESTROY wieder frei.
Ich weiß ja auch nicht, ob das nur bei mir so ist. Ich gebe ja schließlich den Speicher wieder frei.

Nach Stunden suchen habe ich den Fehler gefunden.
Es ist die Zeile

Bufferhdc = Bghdc;

So doof kann aber auch nur ich sein. Schließlich gibt es ja die Funktion Bitblt. warum ich das mit = mache frag ich mich jetzt auch.

Trotzdem danke für die vielen Tipps.

Hepi

Deine riesigen "if (Laufrichtung == " Konstrukte solltest Du auch mal durch einen switch ersetzen...