spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// ###########################################################################

// Datei:        main.h

// ###########################################################################

// Autor:        Patrick Ullmann

// Erstellt:     06.01.2006

// Änderungen:   06.01.2006/Patrick: Datei erstellt

// ###########################################################################

// Beschreibung: Hauptobjekt


#if !defined(__main_h__)
#define __main_h__

// I N C L U D E S ###########################################################

#include <windows.h>    // Allgemeiner Windowsheader

#include <windowsx.h>   // WindowsX für Fensternachrichten

#include <string>       // std::basic_string<T>


// M A K R O S ###############################################################

    // TODO: Template-Makros einfügen


// D E F I N I T I O N E N ###################################################

    // TODO: Konstanten/enums/unions einfügen


// S T R U K T U R E N #######################################################

class main
{
private:
        // Constructor, Copyconstructor und Destructor

    main  (void);
    main  (const main& other);
    ~main (void);

        // Es gibt nur eine Instanz. Jede Zuweisung wäre eine Selbstzuweisung.

        // Da Selbstzuweisungen selten Sinn machen, ist der op= privat

    main& operator= (const main& other);

public:
        // Diese statische Methode erzeugt die einzige Instanz.

        // Nur über diese Methode erhalten Anwender den Zugriff auf

        // die Instanz.

    inline static main& getInstance (void)
    {
            // Die Instanz wird erst beim ersten Aufruf erzeugt.

            // Endet das Programm, wird Instanz vernichtet.

        static main instance;
        return (instance);
    } 

        // Initialisierungsfunktion

    int init        (void);

private:
        // Hauptschleife

    int run (void);

        // Fensternachrichtenverarbeitungsfunktionen

    bool message_create         (::HWND__* hwnd, ::CREATESTRUCTW* createStruct);        // WM_CREATE  

    void message_destroy        (::HWND__* hwnd);                                       // WM_DESTROY


        // Die ECHTE Fensterprozedur

    long _w64 __stdcall DefWindowProc  (unsigned int message, unsigned int wParam, long _w64 lParam);
    
        // Die Reciever-Funktion für die Fensterprozedur

    static long _w64 __stdcall WndProc (::HWND__* hwnd, unsigned int message, unsigned int wParam, long _w64 lParam);

        // Fensterdaten

    unsigned long               width_;     // Fensterbreite

    unsigned long               height_;    // Fensterhöhe

    unsigned long               style_;     // Fensterstyle

    ::HWND__*                   hwnd_;      // Handle

    std::basic_string<wchar_t>  name_;      // Fenstertitel


        // Programmdaten

    ::HINSTANCE__*              instance_;  // Programminstanz

};

#endif // Include Guard

C-/C++-Quelltext

// ###########################################################################

// Datei:        main.cpp

// ###########################################################################

// Autor:        Patrick Ullmann

// Erstellt:     06.01.2006

// Änderungen:   06.01.2006/Patrick: Datei erstellt

// ###########################################################################

// Beschreibung: Hauptobjekt


// I N C L U D E S ###########################################################

#include "main.h"

// F U N K T I O N E N #######################################################


// ///////////////////////////////////////////////////////////////////////////

// PRIVATE Constructor

// 

// ///////////////////////////////////////////////////////////////////////////

main::main (void) : name_(L"Testapplication"), width_(800), height_(600), style_(WS_CAPTION)
{
        // Instanz holen

    instance_ = ::GetModuleHandleW (NULL);
}

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE Copyconstructor

// 

// ///////////////////////////////////////////////////////////////////////////

main::main (const main& other)
{
}

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE Destructor

// 

// ///////////////////////////////////////////////////////////////////////////

main::~main (void)
{
        // Registrierte Klasse freigeben

    ::UnregisterClassW (name_.c_str(), instance_);
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

// 

// Initialisiert ein Fenster

// ///////////////////////////////////////////////////////////////////////////

int main::init (void)
{
        // Fensterklasse erstellen

    ::WNDCLASSW windowclass; 

        // Fensterklasse nullen

    ::ZeroMemory (&windowclass, sizeof(windowclass));

        // Parameter der Fensterklasse setzen

    windowclass.style               = CS_HREDRAW | CS_VREDRAW;              // Neuzeichnen

    windowclass.hbrBackground       = (HBRUSH__*)(5);                       // Hintergrund 

    windowclass.hCursor             = ::LoadCursor (NULL, IDC_ARROW);       // Standardcursor

    windowclass.hIcon               = ::LoadIcon (NULL, IDI_APPLICATION);   // Standardicon

    windowclass.hInstance           = instance_;                            // Instanz

    windowclass.lpfnWndProc         = WndProc;                              // Fensterprozedur

    windowclass.lpszClassName       = name_.c_str();                        // Klassenname

        
        // Fensterklasse registrieren

    ::RegisterClassW (&windowclass); 
        
        // Fenster erstellen

    hwnd_ = ::CreateWindowW (name_.c_str(), name_.c_str(), style_, 0, 0, width_, height_, NULL, NULL, instance_, 
                             this);  // Hier wird der Zeiger auf das erzeugte Objekt übergeben 

                       
        // WM_CREATE aufrufen, da durch die Recieverfunktion dies nicht mehr möglich ist

    message_create (hwnd_, NULL);

        // Fenster anzeigen und updaten

    ::ShowWindow   (hwnd_, SW_NORMAL); 
    ::UpdateWindow (hwnd_); 

        // Hauptschleife aufrufen

    return (run());
}

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE 

// 

// Hauptschleife des Programms

// ///////////////////////////////////////////////////////////////////////////

int main::run (void)
{
        // MessageObjekt

    ::MSG   message;

        // MessageObjekt initialisieren

    ::ZeroMemory (&message, sizeof(message));

            // Hauptschleife

    while (::GetMessage (&message, NULL, 0, 0))
    { 
            // Nachricht verarbeiten

        ::TranslateMessage (&message); 
        ::DispatchMessage  (&message); 
    }

        // Exitcode zurückgeben

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

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE 

// 

// Fensternachrichtenverarbeitung: WM_CREATE

// ///////////////////////////////////////////////////////////////////////////

bool main::message_create (::HWND__* hwnd, ::CREATESTRUCTW* createStruct)
{
        // Fensterrechteck erstellen

    ::RECT rc = {0, 0, width_, height_};

        // "Wahre" Fenstergröße holen

    ::AdjustWindowRectEx (&rc, style_, false, 0);
    
        // Fensterposition ausrechnen

    const long centerX = ::GetSystemMetrics (SM_CXFULLSCREEN) / 2 - (::abs(rc.left) + rc.right) / 2; 
    const long centerY = ::GetSystemMetrics (SM_CYFULLSCREEN) / 2 - (::abs(rc.top) + rc.bottom) / 2; 

        // Fenster neu positionieren

    ::MoveWindow (hwnd, centerX, centerY, (rc.right - rc.left), (rc.bottom - rc.top), true);

    return (true);
}

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE 

// 

// Fensternachrichtenverarbeitung: WM_DESTROY

// ///////////////////////////////////////////////////////////////////////////

void main::message_destroy (::HWND__* hwnd)
{
        // Programmzerstörung durchführen

    ::PostQuitMessage (0);
}

// ///////////////////////////////////////////////////////////////////////////

// PRIVATE 

// 

// Die richtige WndProc der Klasse

// ///////////////////////////////////////////////////////////////////////////

long _w64 __stdcall main::DefWindowProc (unsigned int message, unsigned int wParam, long _w64 lParam) 
{ 
        // Messages verarbeiten

    switch (message) 
    { 
#pragma warning( disable : 4800 ) // warning C4800: 'BOOL' : forcing value to bool

    HANDLE_MSG (hwnd_, WM_DESTROY,      message_destroy);
#pragma warning( default : 4800 )
    } 

        // Nachrichten an Default-Windows-WndProc weiterreichen: 

    return ::DefWindowProcW (hwnd_, message, wParam, lParam); 
} 


// ///////////////////////////////////////////////////////////////////////////

// PRIVATE 

// 

// Recieverfindung des Objekts (Fake-WndProc)

// ///////////////////////////////////////////////////////////////////////////

long _w64 __stdcall main::WndProc (::HWND__* hwnd, unsigned int message, unsigned int wParam, long _w64 lParam) 
{         
        // Übergebenen 'this' merken

    if (message == WM_CREATE)
        ::SetWindowLongW (hwnd, GWL_USERDATA, static_cast<long>((long _w64)(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams))); 

        // Sich selbst als Pointer holen

    main* receiver = reinterpret_cast<main*>(static_cast<long _w64>(::GetWindowLongPtrW(hwnd, GWL_USERDATA))); 

        // Konnte man sich selbst finden? Wenn nein: Windows WndProc benutzen

    if (!receiver)
        return ::DefWindowProcW (hwnd, message, wParam, lParam); 
        
        // Man konnte sich selbst finden: Eigene WndProc ausführen

    return receiver->DefWindowProc (message, wParam, lParam); 
} 


    // Einsprungspunkt des Programms

int __stdcall WinMain (::HINSTANCE__* instance, ::HINSTANCE__* prevInstance, char* cmdLine, int cmdShow)
{
        // Programm durchstarten

    return (main::getInstance().init ());
}