spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma once

////////////////////////////////////////////////////////////////
//SettingsDialog
#define IDD_SETTINGS_DIALOG                     100 //Der Dialog
#define IDC_TAB_CONTROL                         101 //Das Tab Control
#define IDC_APPLY                               102 //Apply-Button
#define IDC_DSMA                                103 //"Don't show me again" Check-Box

C-/C++-Quelltext

////////////////////////////////////////////////////////////////
//Includes
#include<Windows.h>
#include"Resource.h"

////////////////////////////////////////////////////////////////
//IDC_STATIC definieren, da dies nicht mehr in Windows.h definiert wird
#ifndef IDC_STATIC
#define IDC_STATIC -1
#endif

C-/C++-Quelltext

////////////////////////////////////////////////////////////////
//SettingsDialog
//Größe insgesamt: 220 x 270. Er wird beim Erstellen genau in die Mitte des Bildschirms geschoben.
IDD_SETTINGS_DIALOG DIALOG 0, 0, 220, 270
//Mit Titel, Minimierknopf, Menü (per Icon) und allem Schnickschnack.
STYLE WS_POPUP|WS_CAPTION|DS_MODALFRAME|WS_SYSMENU|WS_MINIMIZEBOX
//Meine bevorzugte Schriftart
FONT 8, "Tahoma"
//Der Titel (sowie der ganze Dialog) in English gehalten
CAPTION "Settings"
{
    //Das Tab Control
    //Genug Platz für 200x200 große Pages
    //Dazu noch links, rechts und unten je 5 Einheiten Platz. Oben muss noch die Größe der Tabs mit einberechnet werden (nochmal 10)
    CONTROL         "", IDC_TAB_CONTROL, "SysTabControl32", TCS_TABS, 5, 5, 210, 220

    //Wenn man nicht jedesmal alles neu einstellen will...
    AUTOCHECKBOX    "Don't show me again.", IDC_DSMA,   120,235, 80, 10

    //Und die 3 Standard-Buttons
    PUSHBUTTON      "Exit",                 IDCANCEL,       10, 250, 60, 15     //Beenden
    PUSHBUTTON      "Apply",                IDC_APPLY,      80, 250, 60, 15     //Speichern
    DEFPUSHBUTTON   "OK",                   IDOK,           150,250, 60, 15     //Speichern und Beenden
}

C-/C++-Quelltext

#pragma once

//Settings-Dialog aufrufen
//Wenn der User auf OK geklickt hat, wird FALSE zurückgegeben.
//Wenn er abgebrochen hat, wird TRUE zurückgegeben.
BOOL DoSettingsDialog();

//Settings-Dialog-Proc
BOOL WINAPI SettingsDialogProc(HWND hDialog, UINT uMessage, WPARAM wParam, LPARAM lParam);

C-/C++-Quelltext

//Settings-Dialog aufrufen
BOOL DoSettingsDialog()
{
    //An dieser Stellt müsste geklärt werden, ob der User das letzte mal DSMA
    //(Don't show me again) gewählt hat und falls ja abbrechen!

    //Den Dialog Erstellen
    HWND hDialog= CreateDialog(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_SETTINGS_DIALOG), NULL, SettingsDialogProc);
    if(!hDialog)
        throw(std::exception("Creating Settings Dialog failed!"));

    //Und Nachrichten bearbeiten
    MSG Message;
    while(GetMessage(&Message, NULL, 0, 0))
    {
        if(!IsDialogMessage(NULL, &Message))
        {
            TranslateMessage(&Message);
            DispatchMessage(&Message);
        }
    }
    
    //Ergebnis auswerten
    //Bei Abbruch wird TRUE zurückgegeben
    //Mit OK bestätigt -> FALSE
    //Immernoch -1 -> Fehler!
    if(Message.wParam == IDCANCEL)  return(TRUE);       
    else if(Message.wParam == IDOK) return(FALSE);
    else                            throw(std::exception("Settings Dialog did not return a valid status code!"));
}

C-/C++-Quelltext

//Settings-Dialog-Proc
BOOL WINAPI SettingsDialogProc(HWND hDialog, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    static HWND hTabControl= NULL;                      //das Tab-Control
    
    switch(uMessage)
    {
    case WM_INITDIALOG:
        {
            //TabControl initialisieren
            InitCommonControls();
            hTabControl= GetDlgItem(hDialog, IDC_TAB_CONTROL);

            //An dieser Stelle werden später die Tabs eingetragen und die Pages erstellt.
            
            //"Don't show me again." initialisieren
            //Dazu müsste die letzte Wahl geladen werden und das Häkchen entsprechend gesetzt werden.         

            //Dialog in die Mitte rücken und anzeigen
            CenterWindow(hDialog);
            ShowWindow(hDialog, TRUE);

            return(TRUE);
        }

    //Der Benutzer hat wieder irgendetwas angestellt...
    case WM_COMMAND:
        switch(LOWORD(wParam))
        {
        case IDC_APPLY:
            {
                //Speichern

                //Das gilt auch für "Don't show me again." -> Lass dir etwas einfallen ;)
                
                //Später werden hier noch alle Pages gespeichert.

                //Aber nicht beenden!
                return(TRUE);
            }

        case IDCANCEL:
            {
                //Beenden
                DestroyWindow(hDialog);
                PostQuitMessage(LOWORD(wParam));

                //Alle Pages beenden
                //-> später

                return(TRUE);
            }

        case IDOK:
            {
                //Speichern und beenden 
                SendMessage(hDialog, WM_COMMAND, IDC_APPLY, 0);

                DestroyWindow(hDialog);
                PostQuitMessage(LOWORD(wParam));

                //Alle Pages beenden
                //-> später
            }
        }

    default:
        break;
    }

    return(FALSE);
}

C-/C++-Quelltext

//Fenster mittig ausrichten
void CenterWindow(HWND hWindow)
{
    RECT Size;
    GetWindowRect(hWindow, &Size);
    SetWindowPos(hWindow, 0,
        (GetSystemMetrics(SM_CXSCREEN) - (Size.right - Size.left))/2,
        (GetSystemMetrics(SM_CYSCREEN) - (Size.bottom - Size.top))/2,
        0, 0, SWP_NOZORDER|SWP_NOSIZE);
}

C-/C++-Quelltext

#pragma once
#include<exception>
#include<map>
#include<Windows.h>
#include<Commctrl.h>
#pragma comment(lib, "Comctl32.lib")
#include"Resource.h"

C-/C++-Quelltext

//String definieren
typedef std::string String;

//...

//////////////////////////////////////////////////////////////////
//Basisklasse für Pages im Settings-Dialog
class SettingsPageBase
{
private:
    HWND hPageWindow;       //Das Dialog-Fenster

public:
    ////////////////////////////////////////////////////////////////////////////////
    //Konstruktor und Destruktor
    SettingsPageBase();
    virtual ~SettingsPageBase();

    ////////////////////////////////////////////////////////////////////////////////
    //Init, Exit und Save

    //Initialisieren
    //Diese Methode muss abgeleitet werden!
    //In der eigenen Init-Methode muss erst SettingsPageBase::Init() aufgerufen werden
    //und erst dann können eigene Initialisierungs-methoden aufgerufen werden.
    //Diese Methode initialisiert die Dialog-Box der Page.
    virtual void Init(HWND hDialog);

    //Herunterfahren
    // Diese Methode muss nicht abgeleitet werden, sollte aber.
    // Nachdem alles eigene heruntergefahren wurde, muss SettingsPageBase::Exit() eufgerufen werden!
    // Diese Methode zerstört die Page-Dialogbox.
    // Diese Methode wird automatisch aufgerufen, sobald der User "OK" oder "Exit" gedrückt hat. Bei "OK" wird vorher noch Apply Aufgerufen.
    virtual void Exit();

    //Einstellungen übernehmen
    //Diese Methode muss implementiert werden! Die Basismethode muss nicht aufgerufen werden, da es gar keine gibt.
    //Sie wird automstisch aufgerufen, sobald der User auf "OK" oder "Apply" gedrückt hat.
    //Bei "OK" kommt zusätzlich noch hinzu, dass Exit aufgerufen wird.
    virtual void Apply() =0;

    ////////////////////////////////////////////////////////////////////////////////
    //Getter
    //Gibt das Handle des Dialogs (= Page) zurück.
    HWND GetPageWindow();

    //Gibt den Name der Page zurück.
    //Muss implementiert werden!
    virtual String GetPageName() =0;

    //Gibt das Modul (Instanz) an, in dem sich die Dialog-Resource befindet.
    //Muss implementiert werden!
    virtual HMODULE GetDialogResourceModule() =0;

    //Gibt die Resource-ID der Dialog-Resource zurück.
    //Muss implementiert werden!
    virtual DWORD GetDialogResourceID() =0;

    ////////////////////////////////////////////////////////////////////////////////
    //Event-Handling
    //Command-Handling
    //Bei einer WM_COMMAND Nachricht wird diese Methode aufgerufen. Sie muss implementiert werden!
    //Auf OK, Apply oder Cancel-Messages darf nicht reagiert werden - das übernimmt der Dialog.
    //Nur auf die Messages der eigenen Controls muss eingegangen werden.
    //Wenn die Nachricht verarbeitet werden konnte, muss TRUE zurückgegeben werden, ansonsten FALSE.
    virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam) =0;
};

C-/C++-Quelltext

//////////////////////////////////////////////////////////////////
//Konstruktor und Destruktor
SettingsPageBase::SettingsPageBase()
{
    hPageWindow= NULL;
}

SettingsPageBase::~SettingsPageBase()
{
    hPageWindow= NULL;
}

C-/C++-Quelltext

//////////////////////////////////////////////////////////////////
//Initialisieren
void SettingsPageBase::Init(HWND hDialog)
{
    //Dialog erstellen
    hPageWindow= CreateDialog(GetDialogResourceModule(),
        MAKEINTRESOURCE(GetDialogResourceID()),
        hDialog, PageProc);

    //Der Tab wird vom Settings-Dialog (= Tab-Dialog) automatisch eingetragen
}

//Herunterfahren
void SettingsPageBase::Exit()
{
    //Aufräumen
    DestroyWindow(hPageWindow);
}

C-/C++-Quelltext

//uniforme Page-Proc
BOOL WINAPI PageProc(HWND hDialog, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
    switch(uMessage)
    {
    case WM_INITDIALOG:
        return(TRUE);

    case WM_COMMAND:
        //Commands weiterleiten an Parent, der leitet es dann an die Page weiter
        SendMessage(GetParent(hDialog), WM_COMMAND, wParam, lParam);
        return(TRUE);

    default:
        break;
    }

    return(FALSE);
}

C-/C++-Quelltext

//SettingsPageBase Resource
IDD_PAGE_BASE DIALOG 10, 20, 200, 200   //Genaue Position und Größe!
STYLE WS_CHILD  //Wird ein Child des Settings-Dialogs
FONT 8, "Tahoma"
{
    //Hier kommt der Inhalt der Page rein.
    //Aufpassen, dass die 200x200 eingehalten werden!
}

C-/C++-Quelltext

//Liste mit SettingsPages
typedef std::list<SettingsPageBase*> PageList;

C-/C++-Quelltext

BOOL DoSettingsDialog(PageList * pPages)
{
    //An dieser Stellt müsste geklärt werden, ob der User das letzte mal DSMA
    //(Don't show me again) gewählt hat und falls ja abbrechen!

    //Die Pages als zusätzlichen Parameter mit auf den Weg geben
    LPARAM InitParam= (LPARAM)(pPages);

    //Den Dialog Erstellen
    HWND hDialog= CreateDialogParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_SETTINGS_DIALOG), NULL, SettingsDialogProc, InitParam);
...

C-/C++-Quelltext

static std::map<DWORD, SettingsPageBase*> Pages;    //Pages nach Nummer sortiert
static SettingsPageBase * pCurrentPage;             //Aktuelle Page

C-/C++-Quelltext

            //Pages eintragen
            PageList *pPageList= (PageList*)(lParam);
            if(pPageList->empty())  throw(std::exception("Page List is empty!"));

            TCITEM TabItem;             //Grundstruktur für einen Tab
            TabItem.mask = TCIF_TEXT;   //Nur Text im Tab (es sich auch Icons möglich!)
            DWORD dwPage= 0;            //Laufende Nummer
            //Alle durchgehen
            for(PageList::iterator Iter= pPageList->begin(); Iter != pPageList->end(); Iter++)
            {
                //Tab-Page-Eintrag erstellen
                //Zuerst den Name eintragen
                char Buffer[256];
                strncpy_s(Buffer, (*Iter)->GetPageName().c_str(), (*Iter)->GetPageName().length());
                TabItem.pszText= Buffer;
                //Und jetzt den Tab erstellen
                TabCtrl_InsertItem(hTabControl, dwPage, &TabItem);

                //Page initialisieren und eintragen
                (*Iter)->Init(hDialog);     //Init-Methode aufrufen
                Pages[dwPage++]= (*Iter);   //Und in der Map verewigen
            }
            
            //Erste Page wählen
            pCurrentPage= Pages[0];
            TabCtrl_SetCurSel(hTabControl, 0);
            ShowWindow(pCurrentPage->GetPageWindow(), TRUE);

C-/C++-Quelltext

                //Alle Pages speichern
                for(std::map<DWORD, SettingsPageBase*>::iterator Iter= Pages.begin(); Iter != Pages.end(); Iter++)
                    Iter->second->Apply();

C-/C++-Quelltext

                //Alle Pages beenden
                for(std::map<DWORD, SettingsPageBase*>::iterator Iter= Pages.begin(); Iter != Pages.end(); Iter++)
                    Iter->second->Exit();

C-/C++-Quelltext

        default:
            //An aktuelle Page weiterleiten
            return(pCurrentPage->OnCommand(wParam, lParam));

C-/C++-Quelltext

    case WM_NOTIFY:
        switch(((LPNMHDR)lParam)->code)
        {
        case TCN_SELCHANGE: //Der User hat einen anderen Tab gewählt
            { 
                //Zuerst alte Page unsichtbar machen
                ShowWindow(pCurrentPage->GetPageWindow(), FALSE);

                //Und jetzt die gewählte Page sichtbar machen
                DWORD dwChoosenPage = (DWORD)TabCtrl_GetCurSel(hTabControl);
                pCurrentPage= Pages[dwChoosenPage];
                ShowWindow(pCurrentPage->GetPageWindow(), TRUE);

                return(TRUE);
            } 
        }
        break;

C-/C++-Quelltext

//Demo Page
#define IDD_DEMO_PAGE                           110
#define IDC_DEMO_CB                             111

C-/C++-Quelltext

//Demo Page
IDD_DEMO_PAGE DIALOG 10, 20, 200, 200
STYLE WS_CHILD
FONT 8, "Tahoma"
{
    AUTOCHECKBOX    "Demo Check Box",   IDC_DEMO_CB,    5, 5, 80, 10
    LTEXT           "This is a Demo Check Box. Check it!", IDC_STATIC, 5, 15, 80, 50
}

C-/C++-Quelltext

#pragma once
#include<WindowsX.h>
#include"Resource.h"
#include"SettingsPageBase.h"

class DemoPage : public SettingsPageBase
{
private:
    ///////////////////////////////////////////////////////
    //Variablen
    HINSTANCE hProgramInstance;
    String StrSubName;

    HWND hCheckBox;
    BOOL bChecked;

public:
    ///////////////////////////////////////////////////////
    //Konstruktor und Destruktor
    DemoPage(const String & SubName, HINSTANCE hInstance);
    ~DemoPage();

    ///////////////////////////////////////////////////////
    //Init, Exit und Save
    void Init(HWND hDialog);
    void Exit();
    void Apply();

    ///////////////////////////////////////////////////////
    //Getter
    String GetPageName();
    HMODULE GetDialogResourceModule();
    DWORD GetDialogResourceID();

    ///////////////////////////////////////////////////////
    //CommandHandling
    BOOL OnCommand(WPARAM wParam, LPARAM lParam);
};

C-/C++-Quelltext

#include"DemoPage.h"

///////////////////////////////////////////////////////
//Konstruktor und Destruktor
DemoPage::DemoPage(const String & SubName, HINSTANCE hInstance) : SettingsPageBase()
{
    hProgramInstance= hInstance;
    StrSubName= SubName;
}

DemoPage::~DemoPage()
{}

///////////////////////////////////////////////////////
//Init, Exit und Save
void DemoPage::Init(HWND hDialog)
{
    //Geerbte Methode zu erst aufrufen
    SettingsPageBase::Init(hDialog);

    //Laden
    bChecked= FALSE;
    
    hCheckBox= GetDlgItem(hDialog, IDC_DEMO_CB);
    Button_SetCheck(hCheckBox, bChecked);
}

void DemoPage::Exit()
{
    //Exit
    //Hier muss nichts weiter gemacht werden

    //Geerbte Methode zum Schluss aufrufen
    SettingsPageBase::Exit();
}

void DemoPage::Apply()
{
    //Abfragen
    bChecked= Button_GetCheck(hCheckBox);
    
    //Speichern
    MessageBox(NULL, "Die Demo Page würde jetzt speichern.", StrSubName.c_str(), MB_OK|MB_ICONINFORMATION);
}

///////////////////////////////////////////////////////
//Getter
String DemoPage::GetPageName()
{
    return(String("Demo Page - ") + StrSubName);
}

HMODULE DemoPage::GetDialogResourceModule()
{
    return(hProgramInstance);
}

DWORD DemoPage::GetDialogResourceID()
{
    return(IDD_DEMO_PAGE);
}

///////////////////////////////////////////////////////
//CommandHandling
BOOL DemoPage::OnCommand(WPARAM wParam, LPARAM lParam)
{
    //Hier muss nichts weiter getan werden

    return(FALSE);
}

C-/C++-Quelltext

#include<Windows.h>
#include"SettingsDialog.h"
#include"DemoPage.h"

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, char*, int)
{
    try
    {
        //Demo-Page erstellen
        DemoPage DemoPage1("#1", hInstance);
        DemoPage DemoPage2("#2", hInstance);
        PageList Pages;
        Pages.push_back(&DemoPage1);
        Pages.push_back(&DemoPage2);
        
        //Dialog starten
        if(DoSettingsDialog(&Pages))
        {
            //Abgebrochen!
            //Normal beenden
            MessageBox(NULL, "Abbrechen geklickt", "", MB_OK);
            return(0);
        }
        MessageBox(NULL, "OK geklickt", "", MB_OK);
        //Alles klar! Der User ist mit den Einstellungen einverstanden.

        //Das Programm kann jetzt die (veränderten) Einstellungen laden.
    }
    catch(std::exception Err)
    {
        MessageBox(NULL, Err.what(), "Error!", MB_OK|MB_ICONERROR);
    }

    return(0);
}