Optionen Fenster nach dem schließen erneut öffnen

djleitno

Hallo

Ich arbeite seit 2Wochen mit der Winapi und bin jezt auf ein kleines Problem gestoßen.

Und zwar möchte ich ein 2. Fenster machen für die Optionen.
Wenn ich das Programm starte und das Optionen Fenster aufrufe dann kommt des zwar aber das Problem ist das wenn ich es wieder schließe und erneut öffnen will dann läuft was bei der Registrierung der WNDCLASSEX schief. Ich vermute mal das ich das nach dem schliesen wieder löschen muss oder so. Ich hab auch schon ne Funktion gefunden mit der das anscheinend geht, UnregisterClass.
aber ich bekom des ned hin. Wo muss ich die aufrufen?? ich hab da schon einiges probiert.

Hier mein Code:

#include <windows.h>
#include <commctrl.h>
#include "resources.hpp"
#include "main.hpp"

void QuitMessage ();

char szClassName    [ ] = "Main";
char szClassOptName [ ] = "Options";

HWND hWndOpt;
HWND hWndToolbar;
HINSTANCE hInstOpt = NULL;
HINSTANCE hInst;

int WINAPI WinMain (HINSTANCE hInstMain,
                     HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine,
                     int nCmdShow)
{

    HWND hWnd;
    MSG messages;

    hWnd = CreateWindowMain (hInstMain);
    if (hWnd == 0)
    {
        MessageBox (NULL, "Error ID: 1 \n Fenster konnte nicht erzeugt werden", "Error 1", MB_OK | MB_ICONERROR);
    }

    ShowWindow              (hWnd, SW_SHOW);

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

// Haupt Fenster CallBack //
LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    MSG messages;

    switch (message)
    {
        case WM_DESTROY:
            QuitMessage();
            break;
        case WM_PAINT:
            hWndToolbar = CreateToolbar (hInst, hWnd, WS_BORDER);

            CreateWindow ("button",
                          "hhh",
                          WS_CHILD | WS_VISIBLE,
                          5, 5, 100, 50,
                          hWndToolbar,
                          NULL,
                          hInst,
                          NULL);

        case WM_COMMAND:
            switch (wParam)
            {
                case ID_FILE_EXIT:
                    QuitMessage();
                    break;

                case ID_OPTIONS:

                    // Hier müsste das ja spätenstens gelöscht werden damit hWndOpt dann nicht null wird oder?? aber wie??
                    hWndOpt = CreateWindowOption(hInstOpt, hWnd);
                    if (hWndOpt == 0)
                    {
                        MessageBox (NULL, "Error ID: 2 \n Fenster konnte nicht erzeugt werden", "Error 2", MB_OK | MB_ICONERROR);
                    }

                    ShowWindow              (hWndOpt, SW_SHOW);

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

            }
        default:
            return DefWindowProc (hWnd, message, wParam, lParam);
    }

    return 0;
}

LRESULT CALLBACK WindowOptProcedure (HWND hWndOpt, UINT message, WPARAM wParam, LPARAM lParam)
{
    TCHAR clsname[100];
     switch (message)
    {
        case WM_DESTROY:
            GetClassName(hWndOpt,clsname,10);
            UnregisterClass(clsname,hInstOpt);
            break;
        case WM_KEYDOWN:
            switch (wParam)
            {
                case VK_ESCAPE:
                    MessageBox (hWndOpt, "jjjjj", "kkkk", NULL);
            }
        case WM_COMMAND:
            switch (wParam)
            {
                case IDCANCEL:
                    MessageBox (hWndOpt, "jjjjhhhh", "hjhk", NULL);
            }
        default:
            return DefWindowProc (hWndOpt, message, wParam, lParam);
    }
    return 0;
}

// Haupt Fenster erzeugen //
HWND CreateWindowMain (HINSTANCE hInstMain)
{
    HANDLE brush = CreateSolidBrush(RGB(236,233,216));
    WNDCLASSEX wc;

    wc.hInstance     = hInstMain;
    wc.lpszClassName = szClassName;
    wc.lpfnWndProc   = WindowProcedure;
    wc.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
    wc.cbSize        = sizeof         (WNDCLASSEX);
    wc.hIcon         = LoadIcon       (NULL, MAKEINTRESOURCE(ID_ICONM));
    wc.hIconSm       = LoadIcon       (NULL, MAKEINTRESOURCE(ID_ICONS));
    wc.hCursor       = LoadCursor     (NULL, IDC_ARROW);
    wc.lpszMenuName  = MAKEINTRESOURCE(IDR_MENU1);
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

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

    return CreateWindowEx(0,
                          szClassName,
                          "CanWin",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT,
                          CW_USEDEFAULT,
                          544,
                          375,
                          NULL,
                          NULL,
                          hInstMain,
                          NULL);
}

// Optionen Fenster erzeugen //
HWND CreateWindowOption (HINSTANCE hInstOpt, HWND hWndParent)
{

    WNDCLASSEX wcOpt;
    wcOpt.hInstance     = hInstOpt;
    wcOpt.lpszClassName = szClassOptName;
    wcOpt.lpfnWndProc   = WindowOptProcedure;
    wcOpt.style         = CS_DBLCLKS;
    wcOpt.cbSize        = sizeof         (WNDCLASSEX);
    wcOpt.hIcon         = LoadIcon       (NULL, MAKEINTRESOURCE(ID_ICONM));
    wcOpt.hIconSm       = LoadIcon       (NULL, MAKEINTRESOURCE(ID_ICONS));
    wcOpt.hCursor       = LoadCursor     (NULL, IDC_ARROW);
    wcOpt.lpszMenuName  = NULL;
    wcOpt.cbClsExtra    = NULL;
    wcOpt.cbWndExtra    = NULL;
    wcOpt.hbrBackground = (HBRUSH)COLOR_BACKGROUND;

    if (!RegisterClassEx (&wcOpt)){
        MessageBox (NULL, "jjjj", "kfjjfj", NULL);
        return 0;}

    return CreateWindowEx(0,
                           szClassOptName,
                           "CanWin",
                           WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT,
                           CW_USEDEFAULT,
                           544,
                           375,
                           hWndParent,
                           NULL,
                           hInstOpt,
                           NULL);
}

HWND CreateToolbar(HINSTANCE instance, HWND hWnd, int style)
{
    InitCommonControls();

    //Create window for toolbar, parent is current window
    HWND hWndToolbar = CreateWindowEx(0,
                                       TOOLBARCLASSNAME,
                                       NULL,
                                       WS_CHILD | WS_BORDER| style,
                                       0, 0, 0, 0,
                                       hWnd,
                                       (HMENU) 1,
                                       instance,
                                       NULL);

    if (!hWnd)
    {
        return NULL;
    }

    //Add Standard-Buttons to toolbar's Image-List
           //Backward compatiblity
    ShowWindow(hWndToolbar, SW_SHOW);                                                  //Show Toolbar!
    return hWndToolbar;
}

// Nachricht beim Schliesen //
void QuitMessage ()
{
    /*int result = MessageBox (NULL, "Wollen Sie die Map vor den schließen speichern?", "Speichern?", MB_YESNOCANCEL | MB_ICONQUESTION);
        switch (result)
        {
            case IDNO:
                PostQuitMessage (0);
                break;
            case IDYES:
                break;
            default:
                break;
        }*/
}

Nicht gut:
Erstellen von Controls im WM_PAINT-Zweig - dafür gibt es WM_CREATE.
Verhindern-wollen des Schließens erst im WM_DESTROY-Zweig - zu spät, dafür gibt es WM_CLOSE.
Einfügen einer neuen Nachrichtenschleife in der Fenster-Callback-Funktion - wtf?

Das einfachste wäre wohl, wenn du dir Dialoge (modal oder nichtmodale) anschauen würdest (Funktionen DialogBox und CreateDialog).
Da aber ein Resourceneditor bei den Expressversionen von MSVS nicht mitgeliefert ist, kannst du dir ja mal einen bei google suchen (Resource Hacker oder so ähnlich soll ganz brauchbar sein). Der Vorteil ist dabei, dass du so nicht jedes Control im Code erzeugen musst.

Ansonsten empfehle ich dir dringend ein Buch wie das von Petzold.

djleitno

Danke für die schnelle Antwort.

Ich hab jetzt bissl herum gegoolt und gesehen das viele sagen das Winapis schon eher veraltet sind und man eher mit MFC o.ä arbeiten soll.

Was gibt es denn sonst noch für möglichkeiten um Fenster zu erstellen?? wäre dankbar wenn mir jemand paar stichworte dazu schreiben könnte oder evtl. auch erklärungen dazu

und was haltet ihr von MFC??

Kommt immer drauf an, was genau du machen willst.
Plattformunabhängigkeit? Dann schau dir mal QT und wxWidgets an.
Windows aber "C++"? Dann vielleicht MFC, C++ in Anführungszeichen, weil diese imho schönen Code fast unmöglich machen.

Und wenn du langen Atem hast: Ein eigener Wrapper um die WinAPI. Letzteres baue ich mir Stück für Stück weiter auf (bin aber auch rein auf Windows fixiert).

djleitno

Ja ich möchte nur gerne paar Anwendungen für Windows machen.
Ich hab mir jetzt in so einer online bibliothek das buch http://www.galileocomputing.de/katalog/buecher/titel/gp/titelID-2308 ausgelien weil es nix anderes gab und weil ich leider kein Geld für Bücher und so hab.
Werde das mal durchmachen und dann sehe ich ja ob des was für mich ist.

Vielen Dank für deine Hilfe

dot

djleitno schrieb:

Ja ich möchte nur gerne paar Anwendungen für Windows machen.

Meine Empfehlung: C#
Pure Anwendungsentwicklung ist nicht gerade die große Stärke von C++...

djleitno

Ja C# lerne ich grad in der Schule aber ich mag .Net Sprachen nicht besonders und wer weiß vllt will ich später mal was für linux oder so machen oder auch an was größeren mit arbeiten.

Martin Richter

Dein Fehler ist zudem, dass Du jedesmal versuchst die Klasse neu zu registrieren. Das muss man nur einmal machen.