Fehler 1400 - Invalid Window Handle

geeky

Erzeugt er denn das Fenster ?

jep HWND m_hWnd gibt es
Das Fenster wird nicht erzeugt auch wenn ich die Fehlermeldung auskommentiere
es wird lediglich der Prozess erstellt

Wie sieht die WindowProc aus? Welchen Inhalt haben die Variablen die an CreateWindowEx übergeben werden? Wie sieht die Fensterklasse aus?

DWORD dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
  DWORD dwStyle=WS_OVERLAPPEDWINDOW;
  HINSTANCE m_hInstance = GetModuleHandle(NULL);
  strcpy(m_strClass,"Simple WinClass");
  strcpy(strTitle,"Simple WinTitle");
  int iWidth = 800;
  int iHeight = 600;
  HWND m_hWnd = NULL;
  m_hWnd = CreateWindowEx(dwExStyle,m_strClass,strTitle,dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,0,0,iWidth,iHeight,NULL,NULL,m_hInstance,NULL);

geeky

Du erzeugst, aber auch die "Simple WinClass" oder ? (WNDCLASSEX und RegisterClassEx()...)

WNDCLASS wc;
	m_hInstance = GetModuleHandle(NULL);

	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc		= (WNDPROC)WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= m_hInstance;
	wc.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= NULL;
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= m_strClass;

	if (!RegisterClass(&wc))
	{
		MessageBox(NULL,"Fehler beim Registrieren der Windowklasse.","FEHLER",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

ja wird erstellt... registrieren funktioniert auch

peterchen

MSDN: hWndParent
[in] Handle to the parent or owner window of the window being created. To create a child window or an owned window, supply a valid window handle. This parameter is optional for pop-up windows.

Sieht so aus, als müßtest du für WS_OVERLAPPED ein parent-Fenster angeben. GetDesktopWindow() ist wahrscheinlich das, was Du suchst.

D*niel *chumann

Was sagt denn GetLastError() dazu?
Wird m_strClass auch schon vor RegisterClass initialisert?
Und zeig am Besten mal deine gesamte WinMain().

@peterchen: daran dürfte es IMHO nicht liegen.

peterchen

@Daniel:
bin mir auch nicht sicher - aber es gibt ein paar Stellen, wo NULL als Parent Window nicht durchgeht, und der Titel sagt ja "Fehler 1400 - Invalid Window Handle"

D*niel *chumann

Ach, im Titel stehts ja, mmmhhhh.....ich habs jetzt extra nochmal mit den gleichen Styles getestet, bei mir funktionierts.
Ein Parent muss man ja normalerweise auch nur bei Childwindows angeben.

Gibst du in WM_CREATE auch IMMER 0 zurück?
Wenn ja, dann probiers halt mal mit dem DesktopHandle .

Das ganze ist ziemlich unlogisch... ich hab das doch nur kopiert und in eine Klasse eingefügt...
Sry aber hier der komplette Quellcode:

class CWindow;

#include "Main.h"

CWindow::CWindow()
{
	m_hWnd = NULL;
}

CWindow::~CWindow()
{

}

bool CWindow::CreateGLWindow(const char *strClass, const char *strTitle, int iWidth, int iHeight, bool bSizeFixed, int iBits, bool bFullscreen,HINSTANCE hInstance)
{
	unsigned int iPixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle = 0;
	DWORD dwStyle = 0;
	RECT rcWindowRect;
	rcWindowRect.left=(long)0;
	rcWindowRect.right=(long)iWidth;
	rcWindowRect.top=(long)0;
	rcWindowRect.bottom=(long)iHeight;

	m_bFullscreen = bFullscreen;
	m_hInstance = hInstance;

	strcpy(m_strClass,strClass);
	wc.style			= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc		= (WNDPROC)WndProc;
	wc.cbClsExtra		= 0;
	wc.cbWndExtra		= 0;
	wc.hInstance		= m_hInstance;
	wc.hIcon			= LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor			= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground	= NULL;
	wc.lpszMenuName		= NULL;
	wc.lpszClassName	= m_strClass;
    if (!RegisterClass(&wc))
	{
		MessageBox(NULL,"Fehler beim Registrieren der Windowklasse.","FEHLER",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	if (m_bFullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
		dmScreenSettings.dmSize=sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth	= iWidth;
		dmScreenSettings.dmPelsHeight	= iHeight;
		dmScreenSettings.dmBitsPerPel	= iBits;
		dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
		if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
		{
			if(MessageBox(NULL,"Der benötigte Vollbildmodus wird nicht unterstützt von\ndeiner Grafikkarte. Soll anstelle ein Fenstermodus benutzt werden?","Eingabeaufforderung",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
				m_bFullscreen = false;
			}
			else
			{
				MessageBox(NULL,"Programm wird beendet.","Fehler",MB_OK|MB_ICONSTOP);
				return false;
			}
		}
	}

	if (m_bFullscreen)
	{
		dwExStyle=WS_EX_APPWINDOW;
		dwStyle=WS_POPUP;
		ShowCursor(FALSE);
	}
	else
	{
		dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle=WS_OVERLAPPEDWINDOW;
	}

	AdjustWindowRectEx(&rcWindowRect, dwStyle, FALSE, dwExStyle);
    //m_hWnd = CreateWindowEx(dwExStyle,m_strClass,strTitle,dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,0,0,iWidth,iHeight,NULL,NULL,m_hInstance,NULL);
	m_hWnd = CreateWindow(m_strClass,
                       "Titelleiste",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Fensterbreite              */
                       CW_USEDEFAULT,          /* Fensterhoehe               */
                       NULL,
                       NULL,
                       m_hInstance,
                       NULL);
	if (m_hWnd == NULL)
	{
		int i = GetLastError();
		KillWindow();

		MessageBox(NULL,"Fehler beim Erstellen des Fensters.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	static PIXELFORMATDESCRIPTOR pfd =
	{
		sizeof(PIXELFORMATDESCRIPTOR),
		1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA,								// Request An RGBA Format
		iBits,										// Select Our Color Depth
		0, 0, 0, 0, 0, 0,							// Color Bits Ignored
		0,											// No Alpha Buffer
		0,											// Shift Bit Ignored
		0,											// No Accumulation Buffer
		0, 0, 0, 0,									// Accumulation Bits Ignored
		16,											// 16Bit Z-Buffer (Depth Buffer)  
		0,											// No Stencil Buffer
		0,											// No Auxiliary Buffer
		PFD_MAIN_PLANE,								// Main Drawing Layer
		0,											// Reserved
		0, 0, 0										// Layer Masks Ignored
	};

	if (!(m_hDC=GetDC(m_hWnd)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Erstellen des Device Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if (!(iPixelFormat=ChoosePixelFormat(m_hDC,&pfd)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Finden des richtigen Pixel Formates.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if(!SetPixelFormat(m_hDC,iPixelFormat,&pfd))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Setzen des Pixel Formates.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if (!(m_hRC=wglCreateContext(m_hDC)))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Erstellen des Render Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}

	if(!wglMakeCurrent(m_hDC,m_hRC))
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Aktivieren des Device und Render Contextes.","Fehler",MB_OK|MB_ICONEXCLAMATION);
		return FALSE;
	}
	ShowWindow(m_hWnd,SW_SHOW);
	SetForegroundWindow(m_hWnd);
	SetFocus(m_hWnd);
	ReSizeScene(iWidth, iHeight,100.0f);
	if(!Init())
	{
		KillWindow();
		MessageBox(NULL,"Fehler beim Initalisieren.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return false;
	}
	return true;
}

void CWindow::KillWindow()
{
	if(m_bFullscreen)
	{
		ChangeDisplaySettings(NULL,0);
		ShowCursor(true);
	}
	if (m_hRC)
	{
		if (!wglMakeCurrent(NULL,NULL))
		{
			MessageBox(NULL,"Fehler beim Freigeben des Render und Device Kontextes.","Fehler",MB_OK | MB_ICONINFORMATION);
		}

		if (!wglDeleteContext(m_hRC))
		{
			MessageBox(NULL,"Fehler beim Löschen des Device Kontextes.","Fehler",MB_OK | MB_ICONINFORMATION);
		}
		m_hRC=NULL;
	}

	if (m_hDC && !ReleaseDC(m_hWnd,m_hDC))
	{
		MessageBox(NULL,"Fehler beim Freigeben des Device Kontextes des Fensters.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hDC=NULL;
	}

	if (m_hWnd && !DestroyWindow(m_hWnd))
	{
		MessageBox(NULL,"Fehler beim Freigeben des Fenster Handles.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hWnd=NULL;
	}

	if (!UnregisterClass(m_strClass,m_hInstance))
	{
		MessageBox(NULL,"Fehler beim Deregistrieren der Klasse.","Fehler",MB_OK | MB_ICONINFORMATION);
		m_hInstance=NULL;
	}
}

bool CWindow::Init()
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	m_bActive = true;
	return true;
}

void CWindow::ReSizeScene(unsigned int iWidth, unsigned int iHeight,float fDepth)
{
	if(iHeight==0)
	{
		iHeight=1;
	}
	glViewport(0,0,iWidth,iHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f,(GLfloat)iWidth/(GLfloat)iHeight,0.1f,fDepth);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

void CWindow::DrawScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	SwapBuffers(m_hDC);
}

LRESULT CALLBACK CWindow::WindowProc(unsigned int iMsg, WPARAM wParam, LPARAM lParam)
{
	switch (iMsg)
	{
		case WM_ACTIVATE:
		{
			if (!HIWORD(wParam)) m_bActive = true;
			else m_bActive = false;
			return 0;
		}
		case WM_SYSCOMMAND:
		{
			switch (wParam)
			{
				case SC_SCREENSAVE:
				case SC_MONITORPOWER:
				return 0;
			}
			break;
		}
		case WM_CLOSE:
		{
			PostQuitMessage(0);
			return 0;
		}
		case WM_CREATE:
		{
			return 0;
		}
		case WM_KEYDOWN:
		{
			m_bKeys[wParam] = true;
			return 0;
		}
		case WM_KEYUP:
		{
			m_bKeys[wParam] = false;
			return 0;
		}
		case WM_SIZE:
		{
			ReSizeScene(LOWORD(lParam),HIWORD(lParam),100.0f);
			return 0;
		}
	}
	return DefWindowProc(m_hWnd,iMsg,wParam,lParam);
}

bool CWindow::MainLoop()
{
	if(m_bActive)
	{
		if(m_bKeys[VK_ESCAPE]) return true;
		DrawScene();
	}
	return false;
}

#include "Main.h"
#ifndef _WINDOW_H
#define _WINDOW_H

class CWindow  
{
public:
	bool MainLoop();
	LRESULT CALLBACK WindowProc(unsigned int iMsg,WPARAM wParam,LPARAM lParam);
	void DrawScene();
	void ReSizeScene(unsigned int iWidth,unsigned int iHeight,float fDepth);
	bool Init();
	void KillWindow();
	bool CreateGLWindow(const char *strClass,const char *strTitle,int iWidth,int iHeight, bool bSizeFixed,int iBits, bool bFullscreen, HINSTANCE hInstance);
	CWindow();
	~CWindow();
private:
	bool m_bActive;
	char m_strClass[256];
	bool m_bKeys[256];
	bool m_bFullscreen;
	HGLRC m_hRC;
	HINSTANCE m_hInstance;
	HWND m_hWnd;
	HDC m_hDC;
};

#endif

und die Main.cpp

#include "Main.h"

CWindow Window;

LRESULT CALLBACK WndProc(HWND hWnd,UINT	uMsg,WPARAM	wParam,LPARAM lParam)
{
    return Window.WindowProc(uMsg,wParam,lParam);
}

int WINAPI WinMain(	HINSTANCE	hInstance,HINSTANCE	hPrevInstance,LPSTR	lpCmdLine,int nCmdShow)
{
	MSG msg;
	if (!Window.CreateGLWindow("Simple WinClass","Simple WinTitle",800,600,false,32,false,hInstance))
	{
		return 0;
	}
	while(true)
	{
		if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
		{
			if (msg.message==WM_QUIT) break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);

		}
		else
		{
			if(Window.MainLoop()) break;
		}
	}
    Window.KillWindow();
	return (msg.wParam);							// Exit The Program
}

Sry das ich jetzt den ganzen Code poste aber ich komm da nicht weiter... typisch Windoof

geeky

CreateWindowEx() liefert erst einen Handle zurück, nachdem es bereits einige Nachrichten an das Fenster gesendet hat (das ist nicht nur WM_CREATE !)
Du rufst in deiner WndProc() die Window.WindowProc() auf, aber für die ist m_hWnd noch NULL!
Du solltest also auch an deine Window.WindowProc() das richtige Fenster-Handle mit übergeben!

Danke geeky das wars... danke!

geeky

Am gleichen Problem hab ich damals auch stundenlang rumgesucht bis es mir dann plötzlich beim debuggen aufgefallen war