WS_CHILD / WS_OVERLAPPED und openGl

[SaBoro]

Hallo Leute,

ich beschaeftige mich mit embedded WinMain in Tk-Containers und habe ein Problem.

Ich habe:

...
WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX); 

	wcex.style			= CS_OWNDC | CS_PARENTDC | CS_VREDRAW;
	wcex.lpfnWndProc	= (WNDPROC)WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, (LPCTSTR)IDI_FEOUD);
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= NULL;
	wcex.lpszMenuName	= NULL;
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
...
hWnd = CreateWindow(szWindowClass, szTitle, WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_VISIBLE,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, hWndParent, NULL, hInstance, NULL);

...

Nun kan ich mit WS_CHILD oder mit WS_OVERLAPPEDWINDOW compilieren.
Zweiteres erzeugt ein zweites Fenster und ich sehe dort auch mein openGl-Zeug. Wenn ich es als WS_CHILD compiliere scheint etwas mit den hdc's nicht zu passen. Kann mir jemand einen Tipp geben?

Woran kann es liegen, das es als WS_OVERLAPPEDWINDOW funzt, aber als WS_CHILD nicht?

MfG

[miller_m]

ist dein hdc vom richtigen fensterhandle?
zeig doch mal deinen pixelformatdesciptor bzw. deinen wesentlichen initcode

[SaBoro]

Sag ob noch mehr noetig ist.
Das komische ist, das es als WS_OVERLAPPED funktioniert, aber wenn es als WS_CHILD eingebunden wird, dann geht es nicht.
Ich hab in WM_PAINT auch noch andere Paints drin, die in das selbe HWND gehen, und die landen dort auch. Im WS_OVERLAPPED landen diese DrawText... im WS_CHILD Frame und im WS_OVERLAPPEDWINDOW window.

Also doppenlt, aber die openGl landen nur im Extra-fenster, und nicht doppelt.

OpenGl opengl;
HWND hWnd;

WinMain(...)
{
...
opengl = OpenGl();
...
}

class OpenGl  
{
public:
	OpenGl();
	virtual ~OpenGl();

	BOOL Init(HWND hWnd); 

	void OnClose();
	GLvoid resize(GLsizei, GLsizei); 
	GLvoid initializeGL(GLsizei, GLsizei); 
	GLvoid drawScene(GLvoid); 

private:

	BOOL bSetupPixelFormat(HDC); 

	HWND hWnd;
	HDC   ghDC; 
	HGLRC ghRC; 

	/* OpenGL globals, defines, and prototypes */ 
	GLfloat latitude, longitude, latinc, longinc; 
	GLdouble radius; 

	GLvoid createObjects();
	void polarView( GLdouble, GLdouble, GLdouble, GLdouble); 
};

BOOL OpenGl::Init(HWND hWnd)
{
        hWnd = hWnd;
	ghDC = GetDC(hWnd); 

	if (!bSetupPixelFormat(ghDC)) 
		return FALSE;		
	DWORD test2 = GetLastError();
	ghRC = wglCreateContext(ghDC);
	DWORD test1 = GetLastError();
	wglMakeCurrent(ghDC, ghRC); 
	DWORD test = GetLastError();

	return TRUE;
}

BOOL  OpenGl::bSetupPixelFormat(HDC hdc) 
{ 
    PIXELFORMATDESCRIPTOR pfd, *ppfd; 
    int pixelformat; 

    ppfd = &pfd; 

    ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR); 
    ppfd->nVersion = 1; 
    ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; 
    ppfd->dwLayerMask = PFD_MAIN_PLANE; 
    ppfd->iPixelType = PFD_TYPE_COLORINDEX; 
    ppfd->cColorBits = 8; 
    ppfd->cDepthBits = 16; 
    ppfd->cAccumBits = 0; 
    ppfd->cStencilBits = 0; 

    pixelformat = ChoosePixelFormat(hdc, ppfd); 

    if ( (pixelformat = ChoosePixelFormat(hdc, ppfd)) == 0 ) 
    { 
        MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK); 
        return FALSE; 
    } 

    if (SetPixelFormat(hdc, pixelformat, ppfd) == FALSE) 
    { 
        MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK); 
        return FALSE; 
    } 

    return TRUE; 
}

WndProc:
...
                case WM_CREATE: 
			if(!opengl.Init(hWnd))
				PostQuitMessage (0); 

			GetClientRect(hWnd, &rt); 
			opengl.initializeGL(rt.right, rt.bottom); 
			break; 
		case WM_MOVE:       /* The frame has moved */
			GetClientRect( hWnd, &rt );
			InvalidateRect(hWnd,&rt,TRUE);
                        break;

		case WM_SIZE:       /* The frame changed size */
			GetClientRect( hWnd, &rt );
			opengl.resize(rt.right, rt.bottom);
			InvalidateRect(hWnd,&rt,TRUE);
                        break;
		case WM_CLOSE: 
			opengl.OnClose();

			DestroyWindow (hWnd); 
			break; 
		case WM_PAINT:
			opengl.drawScene();
		        hdc = BeginPaint (hWnd, &ps);
			GetClientRect( hWnd, &rt );
		        DrawFocusRect(hdc,&rt);
			DrawText( hdc, "test", 4, &rt, DT_CENTER );
			EndPaint( hWnd, &ps );
			break;
		case WM_DESTROY:
			DestroyWindow(hWnd);
			PostQuitMessage( 0 );
			break;
		default:                      CallWindowProc(lpPrevWndFunc,hWnd,message,
wParam,lParam);
		        return DefWindowProc( hWnd, message, wParam, lParam );

...

[SaBoro]

Der Witz ist:

Im WS_OVERLAPPED habe ich also zwei Fenster. Das eine (Tcl/)Tk-Fenster und mein neues Fester(openGl). Das Tk-Fenster hat ein freien Frame in den das WS_CHILD passen soll.

Wenn ich jetzt mein Tk-Fenster verziehe, dann wird auch meine openGL-Szene in der groesse wie gewollt upgedateded und die Szene hat genau die Groesse wie der freie Frame.

Aber wenn ich nun WS_CHILD compiliere is nix mit openGL.