spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <windows.h>
#include "resource.h"

// Weitere Resourcen Definition

#define ID_BUTTON1 2001

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
BOOL    CALLBACK DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

// Hauptfunktion

//-----------------------------------------------------

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
            LPSTR lpCommandLine, int iCmdShow)
{
    
    HWND        hWnd;
    MSG         msg;
    WNDCLASS    wndclass;

    // Fensterklasse erstellen, dazu UniCode benutzen */


    wndclass.style =            CS_VREDRAW | CS_HREDRAW;            // Style

    wndclass.lpszMenuName =     NULL;                               // Kein Menü

    wndclass.lpszClassName =    TEXT("Testprogramm");               // ProzessName

    wndclass.cbClsExtra =       0;                                  // Keine Extras

    wndclass.cbWndExtra =       0;
    wndclass.hbrBackground =    (HBRUSH)GetStockObject(LTGRAY_BRUSH);// Grauer Hintergrund

    wndclass.hCursor =          LoadCursor(hInstance, IDC_ARROW);   // Standart Cursor

    wndclass.hIcon =            NULL;                               // Kein Icon

    wndclass.hInstance =        hInstance;                          // Die Instanz

    wndclass.lpfnWndProc =      WndProc;                            // An diese Funktion werden unsere

                                                                    // Nachrichten geschickt

    
    // Das ganze nun Registrieren

    if(!RegisterClass(&wndclass))
    {
        // Die einzig vernünftige Fehlermgl. kann nur UniCode sein

        MessageBox(NULL, "Bitte benutzen Sie eine Windows Version ab NT.", "Fatal Error", MB_OK);
    }

    // Nun erstellen wir ein Fenster, dort ist im Moment nichts weiter als ein Rechteck

    // mit Symbolleiste. Das ist im Moment aber nur eine INTERE Datenstruktur

    hWnd = CreateWindow(TEXT("Testprogramm"),
                        TEXT("TestProgramm"),
                        WS_OVERLAPPEDWINDOW,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        NULL, 
                        NULL, 
                        hInstance,
                        NULL);

    // die wir hiermit anzeigen ;)

    ShowWindow(hWnd, iCmdShow);

    // Diese Nachricht schickt u.a. eine WM_PAINT Nachricht. Damit werden Elemente,

    // die wir vllt. noch in WM_PAINT benutzen gemalt.

    UpdateWindow(hWnd);

    // die Nachrichtenwarteschlange

    while(GetMessage(&msg, NULL, 0, 0))
    {
        // Dient zur Umsetzung von einige Tastaturbefehlen, nicht 

        // unbedingt notwenig jetzt

        TranslateMessage(&msg);

        // Verteilung der Nachrichten

        DispatchMessage(&msg);
    }
}

// Windows Prozedur

//-----------------------------------------------------------------------

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HWND hButton;
    static HINSTANCE hInstance;
    
    switch(message)
    {
    case WM_CREATE:
        // Die Instanz ermittel, die brauchen wir, so können

        // wir globale Variablen sparen

        hInstance = ((LPCREATESTRUCT)lParam)->hInstance;

        // Eine Schaltfläche erstellen

        hButton = CreateWindow( TEXT("button"),
                                TEXT("Eine sehr schöne Schaltfläche"),
                                BS_FLAT | WS_CHILD | WS_VISIBLE,
                                10, 10, 
                                250, 23,
                                hWnd,
                                (HMENU)ID_BUTTON1,
                                hInstance,
                                NULL);
        break;
    case WM_COMMAND:
        // Die Nachrichten Abfangen die einzelne Steuerelemente uns schicken

        // Oder auch Maus oder Tastatur

        switch(LOWORD(wParam))
        {
        case ID_BUTTON1:
            // So nun hier einen Dialog starten

            // da gibt es zwei Möglichkeiten, ich benutz hier die gebrääuchlichere

            // Das man einen Resourceneditor benutzt und dort die Dialoge sich "zusammen-

            // klickt". Natürlich ist das ganze dann auch wieder Text, daraus folgt das 

            // man das ganze auch selber schreiben kann, was sehr selten auch nützlich 

            // ist.

            // Visual Studio hhat einen sehr guten Editor mit dabei, dieser erzeugt rc 

            // Dateien, man kann diese mit einem Texteditor öffnen, in diesem Fall

            // kommt dies bei raus

            /*
            IDD_DIALOG DIALOGEX 0, 0, 246, 70
            STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | 
                WS_CAPTION | WS_SYSMENU
            CAPTION "Ein schnell zusammengeklickter Dialog"
            FONT 8, "MS Shell Dlg", 400, 0, 0x1
            BEGIN
                DEFPUSHBUTTON   "OK",IDOK,7,49,50,14
                PUSHBUTTON      "Abbrechen",IDCANCEL,189,49,50,14
            END
            */
            // Den anderen Müll braucht man nicht unbedingt und ist zu großem Teil nur 

            // für den Editor an sich da.

            //

            // WEITERES zu DIALOGEN

            // Es gibt zwei Arten: 

            // -> Modullose Dialoge

            // -> Modulare Dialoge

            // Modullose Dialoge können weitere Dialoge öffnen, im Gegensatz zu den

            // modullaren. Moduallare erstellt man mit DialogBox und Modullose mit 

            // Create Dialog.


            DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG), hWnd, DlgProc);
            break;
        };

        break;
    case WM_CLOSE:
        // Wir wollen das Fenster schließen

        // Dazu schicken wir eine Nachricht

        SendMessage(hWnd, WM_DESTROY, 0, 0);
        break;
    case WM_DESTROY:
        // Programm beenden

        PostQuitMessage(0);
        break;
    };

    // Bearbeitung aller Nachrichten um die wir uns nicht kümmern wollen

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

// Dialog Prozedur

//-----------------------------------------------------------------------

BOOL CALLBACK DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
    case WM_COMMAND:
        switch(LOWORD(wParam))
        {
        case IDOK:
            // Nur bei DialogBox!

            EndDialog(hWnd, 0);
        break;
        };
        break;
    };
    return FALSE;
}