neues Fenster

Ich versuch grade mal mein glück mit der win-api.

ich möchte gerne als reaktion auf einen Buttonklick ein neues Fenster öffnen. Nun bin ich aber etwas ratlos was wo hin gehört.

Normal bearbeite ich einen buttonklick ja bei WM_COMMAND, kann ich dort einfach ein neues fenster erstellen?!?

Scheinbar zumindest nicht(zumindest klappt es bei mir nicht, hat jemand ein paar gute Tutorials zum Thema Win-API? Mir scheint generell nocht viel vom grundsätzlichen verständnis zu fehlen.

Hier mal mein code

#include "stdafx.h"
#include "Adressbuch.h"

LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);

const TCHAR szAppName[]=TEXT("Adressbuch");

int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	HWND		hMain;
	MSG			msg;
	WNDCLASS	wc;

	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	wc.hIcon         = LoadIcon(hInstance, TEXT("#130"));
	wc.hInstance     = hInstance;
	wc.lpfnWndProc	 = WndProc;
	wc.lpszMenuName  = NULL;
	wc.lpszClassName = szAppName;
	wc.style		 = CS_HREDRAW | CS_VREDRAW;

	RegisterClass(&wc);

	hMain = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
		NULL, NULL, hInstance, NULL);

	ShowWindow(hMain,nCmdShow);
	UpdateWindow(hMain);

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

	return (int) msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HDC			hDC;
	PAINTSTRUCT ps;
	static HWND	hButNeu;
	static HWND	hButAbort;
	static HWND	hWndNeu;
	static int	cxClient;
	static int	cyClient;

	switch (message)
	{
	case WM_CREATE:
		{
			hButNeu = CreateWindow(TEXT("button"), TEXT("Neu"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
								0, 0, 0, 0, hWnd, NULL, ((LPCREATESTRUCT)lParam)->hInstance, NULL);

			hButAbort = CreateWindow(TEXT("button"), TEXT("Abbrechen"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
								0, 0, 0, 0, hWnd, NULL, ((LPCREATESTRUCT)lParam)->hInstance, NULL);

		return 0;
		}

	case WM_COMMAND:
		{
			if(lParam == (LPARAM)hButNeu)
			{
				if(HIWORD(wParam) == BN_CLICKED)
					hWndNeu = CreateWindow(TEXT("TEST"), TEXT("TEST"), WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
								hWnd, NULL, ((LPCREATESTRUCT)lParam)->hInstance, NULL);
			}

			if(lParam == (LPARAM)hButAbort)
				if(HIWORD(wParam) == BN_CLICKED)
					MessageBox(hWnd, TEXT("Abbruch"), TEXT("Wird schon fertig..."), MB_OK);

			return 0;
		}
	case WM_SIZE:
		{
		cxClient = LOWORD(lParam);
		cyClient = HIWORD(lParam);

		MoveWindow(hButNeu, 10, 10, cxClient / 8, cyClient / 12, TRUE);
		MoveWindow(hButAbort, 10, 70, cxClient / 8, cyClient / 12, TRUE);
		MoveWindow(hWndNeu, 10, 70, cxClient / 8, cyClient / 12, TRUE);
		return 0;
		}

	case WM_PAINT:
		{
			hDC = BeginPaint(hWnd, &ps);
			SelectObject(hDC,GetStockObject(GRAY_BRUSH));
			Rectangle(hDC, 0, 0, cxClient / 4, cyClient);
			EndPaint(hWnd, &ps);

			return 0;
		}

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

ne Fenster Klasse "TEST" existiert nicht nach dem Code den du geposted hast. du kannst bei WM_COMMAND auch nicht LPCREATESTRUCT benutzen, das geht nur bei WM_CREATE.

*D*Evil

Jo... solltest, wenn de eine neue "Fensterklasse" haben willst, mal ne Wndclass ausfüllen und dann reggen...

CodeFinder

Du kannst auch (das macht vllt. nicht ganz so viel Arbeit) einen Dialog via Resource einbinden und den dann via CreateDialog() unter WM_COMMAND erstellen.

Jo... solltest, wenn de eine neue "Fensterklasse" haben willst, mal ne Wndclass ausfüllen und dann reggen...

dachte das child-fenster automatisch registriert werden?

Also mein Ziel ist es, beim klick auf den button ein fenster zu öffnen(child-fenster?) und das man dort dann einfach informationen wie name etc. eingeben kann.

So ein neu registrieren, ginge das so?

int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
    HWND        hMain;
    MSG            msg;
    WNDCLASS    wc;

    wc.cbClsExtra     = 0;
    wc.cbWndExtra     = 0;
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.hCursor         = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon         = LoadIcon(hInstance, TEXT("#130"));
    wc.hInstance     = hInstance;
    wc.lpfnWndProc     = WndProc;
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = szAppName;
    wc.style         = CS_HREDRAW | CS_VREDRAW;

    RegisterClass(&wc);

WNDCLASS    wc2;

    wc2.cbClsExtra     = 0;
    wc2.cbWndExtra     = 0;
    wc2.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc2.hCursor         = LoadCursor(NULL, IDC_ARROW);
    wc2.hIcon         = LoadIcon(hInstance, TEXT("#130"));
    wc2.hInstance     = hInstance;
    wc2.lpfnWndProc     = AndereProc;
    wc2.lpszMenuName  = NULL;
    wc2.lpszClassName = szAppName;
    wc2.style         = CS_HREDRAW | CS_VREDRAW;

    RegisterClass(&wc2);

    hMain = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInstance, NULL);

    ShowWindow(hMain,nCmdShow);
    UpdateWindow(hMain);

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

    return (int) msg.wParam;
}

oder wäre es besser sowas in einem dialog zu machen?

btw.
Wäre es sinnvoll die menu-Buttons auf ein eigenes child-fenster zu setzen oder die einfach seperat in den Anwendungsbereich zu setzen wie in meinem code?

Elektronix

dachte das child-fenster automatisch registriert werden?

Nur, wenn WS-Style auf einen Control-Style gesetzt wird (z. B. "button, combobox" o. ä.)

Hier ein Tutorial:

http://www.win-api.de/tutorials.php?tutid=15

Swordfish

Ulnk schrieb:

//...
wc.lpszClassName = szAppName;
//...
RegisterClass(&wc);
//...
wc2.lpszClassName = szAppName;
//...

Zwei Fensterklassen mit selben Namen wird IMHO nicht funktionieren. Prüf doch bitte mal deine RegisterClass()-Aufrufe auf Fehler!

Greetz, Swordfish

(D)Evil schrieb:

Jo... solltest, wenn de eine neue "Fensterklasse" haben willst, mal ne Wndclass ausfüllen und dann reggen...

also eigentlich möchte ich nur, dass sich beim klick auf meinen button, ein neues fenster öffnet. Was das für ein fenster ist ist erstmal egal.(oder?)

Wenn ich die fensterklasse direkt nach der ersten aufbaue, wird mir diese doch immer angezeigt? Ich möchte aber, das mein fenster nur auf den buttonklick erstellt wird......

diese ganzen tuts zeigen zwar mit man buttons erzeugt, aber so einfaches fenster auf buttonklick öffnen behandeln sie irgendwie nicht.....

Nach meinem Verständnis müsste man in WM_Command noch ein createwindow ausführen......das scheint aber nicht zu klappen. Ich bin echt ratlos. Wie kann sowas einfach so kompliziert sein....

Swordfish

dann nimm doch

// ...
case WM_COMMAND:
    if( LOWORD( wParam ) == DIE_ID_DEINES_BUTTONS )
        MessageBox( window, "Hm, you clicked a button!?", "MSG:", MB_OK );
    return 0;
// ...

um zu sehen, ob es überhaupt funktionieren kann...

Greetz, Swordfish

Swordfish schrieb:

dann nimm doch
// ...
case WM_COMMAND:
    if( LOWORD( wParam ) == DIE_ID_DEINES_BUTTONS )
        MessageBox( window, "Hm, you clicked a button!?", "MSG:", MB_OK );
    return 0;
// ...
um zu sehen, ob es überhaupt funktionieren kann...

Greetz, Swordfish

das klappt, messagebox ist kein problem, aber wenn ich das richtig verstanden hab, kan ich bei wm_command kein neues Fenster erzeugen?!

CodeFinder

Doch, das kannst du eigntlt. überall....:

und zwar so:
(vereinfacht)

#include <windows.h>

LRESULT CALLBACK MainWndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK SubWndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{[cpp]
   HWND         hwnd;
   MSG          msg;
   WNDCLASSEX   wndclassex = {0};

   wndclassex.cbSize        = sizeof(WNDCLASSEX);
   wndclassex.style         = CS_HREDRAW | CS_VREDRAW;
   wndclassex.lpfnWndProc   = MainWndProc;
   wndclassex.cbClsExtra    = 0;
   wndclassex.cbWndExtra    = 0;
   wndclassex.hInstance     = hInstance;
   wndclassex.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
   wndclassex.hCursor       = LoadCursor (NULL, IDC_ARROW);
   wndclassex.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
   wndclassex.lpszMenuName  = NULL;
   wndclassex.lpszClassName = TEXT ("MAIN_WND");
   wndclassex.hIconSm       = wndclassex.hIcon;

   if (!RegisterClassEx (&wndclassex))
   {
      MessageBox (NULL, TEXT ("RegisterClassEx fehlgeschlagen!"),
                  szAppName, MB_ICONERROR);
      return 0;
   }
   wndclassex.lpszClassName = TEXT ("SUB_WND");
   wndclassex.lpfnWndProc   = SubWndProc;

   if (!RegisterClassEx (&wndclassex))
   {
      MessageBox (NULL, TEXT ("RegisterClassEx fehlgeschlagen!"),
                  szAppName, MB_ICONERROR);
      return 0;
   }

   hwnd = CreateWindowEx (WS_EX_OVERLAPPEDWINDOW, // erweiterter Fensterstil
                  TEXT ("MAIN_WND"), // Name der Fensterklasse
                  TEXT ("Fenstertitel"), // Fenstertitel
                  WS_OVERLAPPEDWINDOW, // Fensterstil
                  CW_USEDEFAULT, // X-Position des Fensters                      
                  CW_USEDEFAULT, // Y-Position des Fensters       
                  CW_USEDEFAULT, // Fensterbreite                 
                  CW_USEDEFAULT, // Fensterhöhe                
                  NULL, // übergeordnetes Fenster
                  NULL, // Menü           
                  hInstance, // Programm-Kopiezähler (Programm-ID)            
                  NULL); // zusätzliche Parameter

   ShowWindow (hwnd, iCmdShow);
   UpdateWindow (hwnd);

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

// Die Hauptnachrichtenschleife
LRESULT CALLBACK MainWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   static HWND hWndNew;
   HDC hdc;
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_CREATE:
      return (0);

   case WM_COMMAND:
      switch(LOWORD(wParam))
      {
         case 1: // hier die richtige Button ID
            hWndNew= CreateWindowEx (WS_EX_OVERLAPPEDWINDOW, // erweiterter Fensterstil
                  TEXT("SUB_WND"), // Name der Fensterklasse
                  TEXT ("Fenstertitel"), // Fenstertitel
                  WS_OVERLAPPEDWINDOW, // Fensterstil
                  CW_USEDEFAULT, // X-Position des Fensters                      
                  CW_USEDEFAULT, // Y-Position des Fensters       
                  CW_USEDEFAULT, // Fensterbreite                 
                  CW_USEDEFAULT, // Fensterhöhe                
                  NULL, // übergeordnetes Fenster
                  NULL, // Menü           
                  hInstance, // Programm-Kopiezähler (Programm-ID)            
                  NULL); // zusätzliche Parameter
            break;
         // Weitere CASE - Zweige...
      }
      return (0);

   case WM_PAINT:
      hdc = BeginPaint (hwnd, &ps);
      TextOut (hdc, 0, 0, "Hallo, ich bin ein Fenster!", 27);
      EndPaint (hwnd, &ps);
      return (0);

   case WM_DESTROY:
      PostQuitMessage (0);
      return (0);
   }

   return DefWindowProc (hwnd, message, wParam, lParam);
}

// Die Nachrichtenschleife des neuen Fensters
LRESULT CALLBACK SubWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   HDC hdc;
   PAINTSTRUCT ps;

   switch (message)
   {
   case WM_CREATE:
      return (0);

   case WM_PAINT:
      hdc = BeginPaint (hwnd, &ps);
      TextOut (hdc, 0, 0, "Hallo, ich bin ein Fenster!", 27);
      EndPaint (hwnd, &ps);
      return (0);

   case WM_DESTROY:
      PostQuitMessage (0);
      return (0);
   }

   return DefWindowProc (hwnd, message, wParam, lParam);
}

PS: Code ist nicht getestet

Swordfish

Doch, das kannst du eigentlich überall, und zwar so:
(nicht vereinfacht)

#include <windows.h>

const int id_show = 300;
const int id_hide = 301;

long __stdcall WindowProcedure( HWND window, unsigned int message, unsigned int first, long second );
long __stdcall ChildWindowProcedure( HWND window, unsigned int message, unsigned int first, long second );

int __stdcall WinMain( HINSTANCE instance, HINSTANCE prev_instance, char *cmd_line, int show_state )
{
    HWND window;

    WNDCLASSEX wcex;
    memset( &wcex, 0, sizeof( WNDCLASSEX ) );

    wcex.cbSize        = sizeof( WNDCLASSEX );	
    wcex.hInstance     = instance;
    wcex.lpszClassName = "TestWindowClass";
    wcex.lpfnWndProc   = WindowProcedure;
    wcex.style         = CS_HREDRAW | CS_VREDRAW;
    wcex.hIcon         = LoadIcon ( 0, IDI_APPLICATION );
    wcex.hIconSm       = LoadIcon ( 0, IDI_APPLICATION );
    wcex.hCursor       = LoadCursor ( 0, IDC_ARROW );
    wcex.hbrBackground = reinterpret_cast< HBRUSH >( COLOR_BACKGROUND + 1 );

    unsigned short class_atom = RegisterClassEx( &wcex );

    if( !class_atom ) {
        MessageBox( 0, "Couldn't register Window Class!", "Error:", MB_OK );
        return 0;
    }

    window = CreateWindowEx(
        0,
        reinterpret_cast< char* >( class_atom ),
        "Windows App",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        230,
        150,
        0,
        0,
        instance,
        0
    );

    if( !window ) {
        MessageBox( 0, "Couldn't create window!", "Error:", MB_OK );
        return 0;
    }

    UpdateWindow( window );
    ShowWindow( window, show_state );

    MSG message;

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

    return static_cast<int>( message.wParam );
}

long __stdcall WindowProcedure( HWND window, unsigned int message, unsigned int first, long second )
{
    static HWND btn_show = 0;
    static HWND btn_hide = 0;
    static HWND child_window = 0;

    static unsigned short child_class_atom = 0;

    WNDCLASSEX wcex;

    switch( message ) {

        case WM_CREATE:

            memset( &wcex, 0, sizeof( WNDCLASSEX ) );

            wcex.cbSize        = sizeof( WNDCLASSEX );	
            wcex.hInstance     = reinterpret_cast< HINSTANCE >( GetWindowLong( window, GWL_HINSTANCE ) );
            wcex.lpszClassName = "ChildWindowClass";
            wcex.lpfnWndProc   = ChildWindowProcedure;
            wcex.style         = CS_HREDRAW | CS_VREDRAW;
            wcex.hIcon         = LoadIcon ( 0, IDI_APPLICATION );
            wcex.hIconSm       = LoadIcon ( 0, IDI_APPLICATION );
            wcex.hCursor       = LoadCursor ( 0, IDC_ARROW );
            wcex.hbrBackground = reinterpret_cast< HBRUSH >( COLOR_BACKGROUND + 1 );

            child_class_atom = RegisterClassEx( &wcex );

            if( !child_class_atom ) {
                MessageBox( 0, "Couldn't register Window Class!", "Error:", MB_OK );
                return -1;
            }

            btn_show = CreateWindow(
                "BUTTON",
                "show",
                WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
                10,
                10,
                100,
                100, 
                window,
                reinterpret_cast< HMENU > ( IDC_SHOW ),
                reinterpret_cast< HINSTANCE >( GetWindowLong( window, GWL_HINSTANCE ) ),
                0
            );

            btn_hide = CreateWindow(
                "BUTTON",
                "hide",
                WS_VISIBLE | WS_CHILD | WS_DISABLED | BS_DEFPUSHBUTTON,
                120,
                10,
                100,
                100, 
                window,
                reinterpret_cast< HMENU > ( IDC_HIDE ),
                reinterpret_cast< HINSTANCE >( GetWindowLong( window, GWL_HINSTANCE ) ),
                0
            );

            return 0;

        case WM_COMMAND:
            switch( LOWORD( first ) ) {
                case IDC_SHOW:
                    child_window = CreateWindowEx(
                        0,
                        reinterpret_cast< char* >( child_class_atom ),
                        "Windows App - Child",
                        WS_BORDER | WS_CAPTION | WS_VISIBLE,
                        10,
                        10,
                        500,
                        20,
                        window,
                        0,
                        reinterpret_cast< HINSTANCE >( GetWindowLong( window, GWL_HINSTANCE ) ),
                        0
                    );
                    EnableWindow( btn_show, false );
                    EnableWindow( btn_hide, true );
                    return 0;

                case IDC_HIDE:
                    DestroyWindow( child_window );
                    EnableWindow( btn_hide, false );
                    EnableWindow( btn_show, true );
                    return 0;
            }
            break;

        case WM_CLOSE:
            PostQuitMessage( 0 );
            return 0;
    }
    return static_cast< long >( DefWindowProc( window, message, first, second ) );
}

long __stdcall ChildWindowProcedure( HWND window, unsigned int message, unsigned int first, long second )
{
    return static_cast< long >( DefWindowProc( window, message, first, second ) );
}

BugFree

Greetz, Swordfish

[edit]"Style" [/edit]

*D*Evil

Hmm Swordfish... entweder man zeiht einen Style durch, oder man lässt es bleiben... du hast ihn weder durch gezogen noch ist der style der manchmal sichbar ist gut

define erstetzt man durch was anders... und WINAPI ist auch nen __stdcall usw

CodeFinder

Ich lach mich schlapp...OK aber ich wollte ja nur das Prinzip demontrieren... Aber ok ok ok...LOL

Danke für die Beispiele, aber so richtig klappen tuts noch nicht. ich bin jetzt soweit, ich hab versucht die Infos aus euren Beispielen rauszupicken:

#include "stdafx.h"
#include "Adressbuch.h"

LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK	ChildProc(HWND, UINT, WPARAM, LPARAM);

const TCHAR szAppName[]=TEXT("Adressbuch");

int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
	HWND		hMain;
	MSG			msg;
	WNDCLASS	wc;
	WNDCLASS	wc2;

	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	wc.hIcon         = LoadIcon(hInstance, TEXT("#130"));
	wc.hInstance     = hInstance;
	wc.lpfnWndProc	 = WndProc;
	wc.lpszMenuName  = NULL;
	wc.lpszClassName = szAppName;
	wc.style		 = CS_HREDRAW | CS_VREDRAW;

	RegisterClass(&wc);

	wc.lpszClassName = TEXT("SUB");
	wc.lpfnWndProc	 = ChildProc;

	RegisterClass(&wc);

	hMain = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
		NULL, NULL, hInstance, NULL);

	ShowWindow(hMain,nCmdShow);
	UpdateWindow(hMain);

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

	return (int) msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	HDC			hDC;
	PAINTSTRUCT ps;
	static HWND	hButNeu;
	static HWND	hButAbort;
	static HWND	hWndNeu;
	static int	cxClient;
	static int	cyClient;

	switch (message)
	{
	case WM_CREATE:
		{
			hButNeu = CreateWindow(TEXT("button"), TEXT("Neu"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
								0, 0, 0, 0, hWnd, NULL, ((LPCREATESTRUCT)lParam)->hInstance, NULL);

			hButAbort = CreateWindow(TEXT("button"), TEXT("Abbrechen"), WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
								0, 0, 0, 0, hWnd, NULL, ((LPCREATESTRUCT)lParam)->hInstance, NULL);

		return 0;
		}

	case WM_COMMAND:
		{
			if(lParam == (LPARAM)hButNeu)
			{
				if(HIWORD(wParam) == BN_CLICKED)
				{
					hWndNeu = CreateWindow(TEXT("SUB"), TEXT("PoP"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
											NULL, NULL, NULL, NULL);

				}
			}

			if(lParam == (LPARAM)hButAbort)
				if(HIWORD(wParam) == BN_CLICKED)
					MessageBox(hWnd, TEXT("Abbruch"), TEXT("Wird schon fertig..."), MB_OK);

			return 0;
		}
	case WM_SIZE:
		{
		cxClient = LOWORD(lParam);
		cyClient = HIWORD(lParam);

		MoveWindow(hButNeu, 10, 10, cxClient / 8, cyClient / 12, TRUE);
		MoveWindow(hButAbort, 10, 70, cxClient / 8, cyClient / 12, TRUE);
		return 0;
		}

	case WM_PAINT:
		{
			hDC = BeginPaint(hWnd, &ps);
			SelectObject(hDC,GetStockObject(LTGRAY_BRUSH));
			Rectangle(hDC, 0, 0, cxClient / 4, cyClient);
			EndPaint(hWnd, &ps);

			return 0;
		}

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

LRESULT CALLBACK ChildProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{ 
	switch(message)
	{
	case WM_DESTROY:
     PostQuitMessage (0);
     return (0);
	}

   return DefWindowProc (hwnd, message, wParam, lParam); 
}

@Swordfish
Dein Beispiel unterscheidet sich deutlich von dem was ich bisher gesehen hab und ich bin etwas damit überfordert.......

Wo liegt den da jetzt noch der Fehler? ich kriegs kompiliert, nur auf buttonklick öffnet sich kein neues Fenster.....(es geht um den Button hButNeu)

CodeFinder

Du musst das Fenster auch anzeigen...entweder ShowWindow() oder WS_VISIBLE mit in die Styles

Swordfish

(D)Evil schrieb:

Hmm Swordfish... entweder man zeiht einen Style durch, oder man lässt es bleiben... du hast ihn weder durch gezogen noch ist der style der manchmal sichbar ist gut

Passts dir jetzt!? *schmoll*

CodeFinder schrieb:

Ich lach mich schlapp...OK aber ich wollte ja nur das Prinzip demontrieren... Aber ok ok ok...LOL

Wieso?

Ulnk schrieb:

Dein Beispiel unterscheidet sich deutlich von dem was ich bisher gesehen hab und ich bin etwas damit überfordert.......

Jetzt lach ich mich schlapp

Greetz, Swordfish

CodeFinder schrieb:

Du musst das Fenster auch anzeigen...entweder ShowWindow() oder WS_VISIBLE mit in die Styles

ahhhhh

Allerdings scheint das neue Fenster mit dem neuen verbunden zu sein, schließe ich das neue fenster, schließt sich auch mein altes. Eigentlich sollte sich nur das fenster selbst schließen, wenn ich auf das "x" klicke.

Hängt das damit zusammen, das sich die über die selbe WNDCLASS Variable registriert hab? wie krieg ich die auseinander?

CodeFinder

@Ulnk:
Ist zwar n bissl dirty wg. der globalen HWND aber: erstell nen globlalen Handle zu deinem Hauptfenster und sende unter WM_CLOSE oder WM_DESTROY deine neuen Fenstern mit

SendMessage(g_hWndMain, WM_CLOSE, 0, 0L);

ne 'Schließen-Nachricht'

Oder via Get/Set-WindowLongPtr und GWL_USERDATA...aber das is glaube ich zuviel des Guten

@Swordfish:

Swordfish schrieb:

CodeFinder schrieb:

Ich lach mich schlapp...OK aber ich wollte ja nur das Prinzip demontrieren... Aber ok ok ok...LOL

Wieso?

Weil ich mir das:

Swordfish schrieb:

Ulnk schrieb:

Dein Beispiel unterscheidet sich deutlich von dem was ich bisher gesehen hab und ich bin etwas damit überfordert.......

Jetzt lach ich mich schlapp

schon gedacht hab... Muhaha. ich sterbe...vor lachen...deine ganzen C++ Casts sind für 'neue' nämlich etwas ''''verwirrend'''' *GRINZ*

Swordfish

Ne, die kleben nicht zusammen...
Schau dir doch mal deine

LRESULT CALLBACK ChildProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
    case WM_DESTROY:
     PostQuitMessage (0); // <--- *räusper*
     return (0);
    }

   return DefWindowProc (hwnd, message, wParam, lParam);
}

_genau_ an...

Greetz, Swordfish