Kurze Einführung in die Windows ... - GIS-Management

Objektorientierte Programmierung
Prof. Dr. –Ing. Franz-Josef Behr
FACHHOCHSCHULE
HOCHSCHULE FÜR
STUTTGART
TECHNIK
Fachbereich Vermessung und Geoinformatik
Kurze Einführung in die Windows Programmierung
mittels API
1 Einleitung
Wenn Sie in den vergangenen Semestern ein C++-Programm entwickelt und gestartet haben, geschieht
im Prinzip nicht viel mehr, als dass Code für Programm und Daten in den Arbeitsspeicher Ihres
Rechners geladen werden und die Ausführung mit dem Einsprungspunkt, also der Funktion main()
beginnt.
Bei Windows-basierten Programmen läuft einiges mehr und anders ab. Dieses „Mehr“ und „Andere“
soll in den nachfolgenden Abschnitten vorgestellt werden. Dabei bauen die vorgestellten
Beispielprogramme auf dem Windows 32-Bit API (application programming interface), einer
gemeinsamen Programmierschnittstelle für alle 32-Bit Windows Plattformen auf.
Die hierbei eingesetzten Prinzipien werden Ihnen das Verständnis
? für die objektorientierte Entwicklung von Windows-Programmen
? für bestimmte Zusammenhänge beim Einsatz der COM-Technologie
erleichtern.
Das Windows API ist eine Sammlung von Befehlen, mit denen man Zugriff auf Funktionen und
Objekte in Windows hat. API-Befehle sind nicht an eine einzige Programmiersprache gebunden. So
können API - Befehle in C++, Visual Basic, Delphi und in anderen Sprachen eingesetzt werden. Die
Befehle sind immer gleich, unterschiedlich ist oft der Zugriff auf vordefinierte Strukturen bedingt
durch die unterschiedliche Syntax der Programmiersprachen.
2 Nachrichtenschleifen und Fensterprozeduren
Wir beginnen mit unserem ersten Windows-Programm, das gerade mal vier Zeilen umfasst:
#include
int WINAPI WinMain(HINSTANCE d1, HINSTANCE d2, LPSTR d3, int d4)
{
MessageBox(NULL, "Hello, World!", "", MB_OK);
}
In der ersten Zeile wird die Windows API-Headerdatei eingebunden. In diese Datei werden wiederum
andere Dateien eingebunden, so dass Sie schließlich alle Prototypen und Konstanten in Ihrem
Programm deklariert und verfügbar haben, die zum Ablauf API-basierter Programme nötig sein. Diese
include-Anweisung muss deshalb in jedem Programm, dass Teile der Windows API benutzt,
vorhanden sein!

Einleitung 2
Nun zu den verwendeten Funktionen!
2.1 WinMain
Die WinMain-Funktion ist das Gegenstück zur main-Funktion eines Konsolenprogramms und stellt
den Einstiegspunkt in eine Win32-Applikation. dar:
WinMain verfügt über folgende Übergabeparameter:
int WINAPI WinMain(
HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR lpCmdLine, // pointer to command line
int nCmdShow // show state of window
);
Die Parameter haben folgende Bedeutung:
? hInstance : Handle auf die aktuelle Instanz der Applikation.
? hPrevInstance: Handle auf eine andere, früher gestartete Instanz der Applikation. Für eine
Win32-basierende Applikation ist dieser Parameter immer NULL.
? lpCmdLine: Pointer auf einen null-terminierte Zeichenkette, der die Kommandozeile des
Aufrufs dieses Programms enthält. Der Programmname ist darin nicht enthalten. Um die
Kommandozeile vollständig zurückzuerhalten, können Sie ggf. die GetCommandLine-
Funktion nutzen.
? nCmdShow: Spezifiziert, wie das Fenster angezeigt wird:
Value
Meaning
SW_HIDE
SW_MINIMIZE
SW_RESTORE
SW_SHOW
SW_SHOWMAXIMIZED
Hides the window (and activates another one).
Minimizes the specified window and activates the
top-level window in the system's list.
Activates and displays a window. If the window is
minimized or maximized, the system restores it to its
original size and position (same as
SW_SHOWNORMAL).
Activates a window and displays it in its current size
and position.
Activates a window and displays it as a maximized
window.

Einleitung 3
SW_SHOWMINIMIZED
SW_SHOWMINNOACTIVE
SW_SHOWNA
SW_SHOWNOACTIVATE
SW_SHOWNORMAL
Activates a window and displays it as an icon.
Displays a window as an icon. The active window
remains active.
Displays a window in its current state. The active
window remains active.
Displays a window in its most recent size and
position. The active window remains active.
Activates and displays a window. If the window is
minimized or maximized, the system restores it to its
original size and position (same as SW_RESTORE).
2.1.1 Handles
In der Beschreibung dieser Parameter tauscht der Begriff „Handle“ (Handgriff) auf. Ein Handle liefert
den Bezug zu einem Windows-Objekt. Stellen Sie sich vor, dass alle Windows-Objekte (Fenster,
Eingabefelder, Schaltflächen, ...) durchnummeriert sind. Ein Handle (d.h. eine Handle-Variable)
enthält dann die Nummer des zugehörigen Objekts.
Es existieren verschiedene Untertypen von Handles, z. B. Handles für Fenster (Datentyp HWND 1 ),
Handles für Ausgabekontexte (HDC), für Menüs (HMENU) usw.
2.1.2 Instanz
Windows ist ein Multitasking-Betriebssystem: Mehrere Programme laufen gleichzeitig ab, ein
Programm kann auch mehrfach gestartet werden. Sie können zwischen den verschiedenen
Programmen hin- und herwechseln.
Jedes laufende Programm wird als Instanz bezeichnet. Wird eine Programm mehrfach gestartet, wird
nur eine Instanz des Programmcodes in den Speicher geladen, die Daten müssen natürlich getrennt in
eigenen Speicherbereichen gehalten werden.
2.2 Die MessageBox Funktion
Die MessageBox Funktion gibt in einem separaten Fenster eine Nachricht aus. Der erste Parameter
soll normalerweise ein Handle auf ein Fenster sein, zu dem die Nachricht gehören soll, aber da wir
kein Fenster besitzen, geben wir Null an. Dies bedeutet, dass die Nachricht als eigenständiges
Fenster dargestellt wird.
3 Hello World mit einfacher Nachrichtenschleife
Das folgende Programm hello2.c stellt eine den „Hello World“-Text in einem eigenen Fenster dar:
1 HWND steht also für Handle [to a] Window.

Einleitung 4
Der zugehörige Source-Code ist in folgender Box zusammengestellt:
#include
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE d2,
LPSTR d3, int d4)
{
MSG msg;
HWND hwnd;
}
hwnd = CreateWindow("BUTTON", "Hello, World!",
WS_VISIBLE | BS_CENTER, 100, 100, 100, 80,
NULL, NULL, hInstance, NULL);
while (GetMessage(&msg, NULL, 0, 0))
{
if (msg.message == WM_LBUTTONUP)
{
DestroyWindow(hwnd);
PostQuitMessage(0);
}
DispatchMessage(&msg);
}
return msg.wParam;
BUTTON steht für einen bestimmten, vordefinierten Fenstertyp, der als Fensterklasse bezeichnet wird.
Zum Erzeugen des Fensters registriert das Programm zunächst diese Fensterklasse:
hwnd = CreateWindow("BUTTON", "Hello, World!",
WS_VISIBLE | BS_CENTER, 100, 100, 100, 80,
NULL, NULL, hInstance, NULL);
Der return-Wert dieser Funktion ist ein Handle auf das erzeugte Fenster. Es handelt sich tatsächlich
um ein Fenster, auch wenn es nur ein Button (= Schaltfläche) ist – unter Windows ist fast alles (wie
der Name ja auch deutlich macht) ein Fenster!
Selbstverständlich ist es möglich, eigene Fensterklassen zu definieren, wie wir es später auch tun
werden!
Nach dieser Registrierung wird eine Nachrichtenschleife durchlaufen. Dieser Mechanismus gehört
zum wesentlichen Bestandteil von Windows-Anwendungen. Jedes Ereignis, etwa eine
Mausbewegung, ein Tastendruck usw., veranlasst Windows, diesen „Event“ in Form einer Meldung
(message) an das Programm weiterzuleiten, das sich seinerseits um die Abarbeitung kümmern muss.
while (GetMessage(&msg, NULL, 0, 0))
{
if (msg.message == WM_LBUTTONUP)
{
DestroyWindow(hwnd);
PostQuitMessage(0);

Einleitung 5
}
}
DispatchMessage(&msg);
Mit der GetMessage-Funktion holen wir uns eine Meldung (Nachricht) ab und untersuchen sie. In
diesem Beispiel werten wir nur die Meldung WM_LBUTTONUP aus und rufen gegebenenfalls die
DestroyWindow- und PostQuitMessage-Funktion auf.
Die DestroyWindow-Function löscht das angegeben Fenster. Besitzt das Fenster Kindfenster,
werden diese ebenfalls entfernt.
Mit PostQuitMessage wird eine WM_QUIT-Nachricht an das System gesandt, um dem System
anzuzeigen, dass die Anwendung beendet werden will. Als Parameter wird der ExitCode der
Anwendung (meist 0) übergeben. Vielfach wird PostQuitMessage als Reaktion auf die Nachricht
WM_DESTROY in der Nachrichtenschleife der Anwendung aufgerufen.
Wie Sie bereits festgestellt haben, verwendet man in der WinAPI-Programmierung eigene
Bezeichnungen für Datentypen. Die nachfolgende Zusammenstellung zeigt die Zusammenhänge
zwischen WinAPI und C/C++: 2
Bezeichnung in C / C++ Bemerkung
TRUE 1, true
FALSE 0, false
NULL 0 wird insbesondere für Pointer auf "Nichts" verwendet
UINT unsigned int 16bit / 32bit
BYTE unsigned char 8bit
WORD unsigned short 16bit
DWORD unsigned long 32bit
LONG long 32bit
VOID void 3 z.B. als Rückgabewert von Funktionen
LPSTR char* Pointer auf einen String (char-Array)
LPCSTR const char* Pointer auf einen konstanten String (char-Array)
HANDLE void* Handle für verschiedenste Windows-Elemente
HWND - Handle eines Fensters
PASCAL pascal WINAPI = FAR PASCAL
WPARAM unsigned int 16bit / 32bit
LPARAM long 32bit
2 Quelle: http://www.henkessoft.de/api1.htm
3 engl.: leer, nichts

Einleitung 6
LRESULT long 32bit
HINSTANCE - Handle einer Instanz
MSG
Meldung
4 Fensterprozeduren
Tabelle 1: Wesentliche Datentypen in Windows.
Die nächste Version unseres Programms registriert seine eigene Fensterklasse:
Der Source dazu wird um einiges umfangreicher:
#include
void DrawHello(HWND hwnd)
{
HDC hDC;
PAINTSTRUCT paintStruct;
RECT clientRect;
}
hDC = BeginPaint(hwnd, &paintStruct);
if (hDC != NULL)
{
GetClientRect(hwnd, &clientRect);
DPtoLP(hDC, (LPPOINT)&clientRect, 2);
DrawText(hDC, "Hello, World!", -1, &clientRect,
DT_CENTER | DT_VCENTER | DT_SINGLELINE);
EndPaint(hwnd, &paintStruct);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_PAINT:
DrawHello(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);

Einleitung 7
}
}
return 0;
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR d3, int nCmdShow)
{
MSG msg;
HWND hwnd;
WNDCLASS wndClass;
char* szMainWndClass="WinTestWin"; //Name of main window class
}
if (hPrevInstance == NULL)
{
memset(&wndClass, 0, sizeof(wndClass));
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;
wndClass.hInstance = hInstance;
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndClass.lpszClassName = szMainWndClass;
wndClass.lpszMenuName = NULL;
if (!RegisterClass(&wndClass)) return FALSE;
}
hwnd = CreateWindow(szMainWndClass, "HELLO",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, NULL, hInstance, NULL);
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
while (GetMessage(&msg, NULL, 0, 0))
DispatchMessage(&msg);
return msg.wParam;
Eine Vorbemerkung: Vielleicht ist Ihnen aufgefallen, dass alle Variablennamen mit einem Präfix
beginnen? Ich erinnere an die ungarische Notation – diese wird in Windows-Programmen intensiv
genutzt!
Alle Variablennamen, die nach der ungarischen Notation geschrieben sind, beginnen mit einem Präfix
in Kleinbuchstaben, die den Typ der Variable wiedergeben.
Präfix
Datentyp
c
char
by
BYTE (unsigned char)
n
short (int)
i
int (signed int)
x, y int (x- und y-Koorrdinaten)
cx, cy
int (Längenangaben in einem Koordinatensystem, das c steht für 'count')
b, f bool; das f steht für 'Flag'
w
WORD (unsigned short)
l
long
dw
DWORD (unsigned long)
fn
Funktion

Einleitung 8
s
sz
h
p
Pp
String
ASCIIZ-String (genauer: char* abgeschlossen mit '\0')
Handle
Zeiger (pointer)
Doppel Zeiger (**pp)
Nun zurück zu unserem Programm. Seine Ausführung beginnt wie immer mit WinMain.
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR d3, int nCmdShow)
Zu Beginn werden einige Variablen definiert, deren Datentypen Sie Tabelle 1 entnehmen können:
{
MSG msg;
HWND hwnd;
WNDCLASS wndClass;
wndClass werden wir gleich nutzen. Sind Instanzen der Applikation vorhanden, braucht diese
Fensterklasse nicht neu initialisiert werden, andernfalls definieren wir ihre Eigenschaften:.
if (hPrevInstance == NULL)
{
memset(&wndClass, 0, sizeof(wndClass));
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;
wndClass.hInstance = hInstance;
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndClass.lpszClassName = "HELLO";
wndClass.lpszMenuName = NULL;
if (!RegisterClass(&wndClass)) return FALSE;
Diese Fensterklasse definiert das grundlegende Verhalten eines Fensters (Aufbau, Fenstersymbol,
Menü, ...). Außerdem wird die Adresse einer Funktion in der Klasse gespeichert, die als
Fensterprozedur bezeichnet wird. Wir haben es hierbei mit dem für uns seltenen Fall zu tun, dass wir
bei
wndClass.lpfnWndProc = WndProc;
einen Zeiger auf eine Funktion verwenden!
Windows bietet eine Reihe vordefinierter Fensterklassen (vgl. BUTTON, Kap. 3), es ist aber genauso
möglich, eigene über die Funktion RegisterClass zu definieren (wie in diesem Fall).
? Der Eigenschaft hInstance müssen wir den Handle zu unserer Programminstanz übergeben,
damit nur unser Programm diese Fensterklasse benutzen kann.
? Mit hCursor kann man den Typ des Cursors bestimmen. Wenn man hier Null angibt,
erscheint auf unserem Fenster kein Cursor. Wir laden jedoch mit der Funktion LoadCursor
den Standard-Pfeilcursor.

Einleitung 9
? Dann müssen wir noch über die Variable hbrBackground 4 die Hintergrundfarbe des
Fensters festlegen.
Über GetStockObject (BLACK_BRUSH); können Sie alternativ vordefinierte Füllungen
nutzen. Es stehen folgende zur Verfügung:
? WHITE_BRUSH,
? BLACK_BRUSH,
? LTGRAY_BRUSH,
? GRAY_BRUSH,
? DKGRAY_BRUSH,
? HOLLOW_BRUSH ( identisch mit NULL_BRUSH).
Versuchen Sie NULL_BRUSH – damit wird das Fenster durchsichtig!
Sie können auch eine eigene Füllfarbe erzeugen:
HBRUSH MyBrush = CreateSolidBrush( RGB( 0, 150, 255 ) );
Damit stehen Ihnen mittels RGB( rot, grün, blau ) insgesamt 256*256*256 = 16.777.216 Farbwerte
(24 bit) zur Verfügung. Die Werte für die Einzelfarben sind jeweils von 0 bis 255 einstellbar.
Experimentieren Sie ein wenig mit den Farben, damit Sie die Wirkung des RGB-Makros verfolgen
können! 5
LoadCursor bietet folgende Standard-Cursor:
IDC_APPSTARTING
IDC_ARROW
IDC_CROSS
IDC_HAND
IDC_HELP
IDC_IBEAM
IDC_NO
IDC_SIZEALL
IDC_SIZENESW
IDC_SIZENS
IDC_SIZENWSE
IDC_SIZEWE
IDC_UPARROW
IDC_WAIT
Standard arrow and small hourglass
Standard arrow
Crosshair
Windows NT 5.0 and later: Hand
Arrow and question mark
I-beam
Slashed circle
Four-pointed arrow pointing north, south, east, and west
Double-pointed arrow pointing northeast and southwest
Double-pointed arrow pointing north and south
Double-pointed arrow pointing northwest and southeast
Double-pointed arrow pointing west and east
Vertical arrow
Hourglass
4 hbr ist die Abkürzung für Handle [to a] Brush
5 Quelle: http://www.henkessoft.de/api2.htm

Einleitung 10
Übung
Experimentieren Sie mit verschiedenen Cursor-Varianten
Die Membervariable lpszClassName soll den Fensterklassennamen speichern. Über ihn können
Sie später Fenster dieser Klasse erzeugen. Die Hauptfensterklasse bekommt üblicherweise den Namen
des Programms.
Da unser Fenster (noch) kein Menü haben soll, geben wir der Membervariable
lpszMenuName den Wert NULL.
Mit der CreateWindow Funktion erstellen wir nun ein Fenster gemäß unserer registrierten
Fensterklasse.
hwnd = CreateWindow("HELLO", "HELLO",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, NULL, hInstance, NULL);
Dem ersten Parameter, lpClassName, wird der Name der Fensterklasse als Zeichenkette übergeben.
Über den zweiten Parameter können wir den Text in der Titelleiste beeinflussen. Im dritten Parameter
speichern wir den Stil des Fensters. Die nächsten vier Parameter sind für die räumliche Position des
Fensters verantwortlich. Der vorletzte Parameter muss wieder der Handle auf unsere Programminstanz
sein, damit man das Fenster unserem Programm zuordnen kann. Die anderen drei Parameter sind im
Moment unwichtig, daher belassen wir sie bei Null. Die CreateWindow Funktion liefert als
Rückgabewert den Handle auf das Fenster zurück.
Unser Fenster ist nun erstellt, es erscheint jedoch noch nicht auf dem Bildschirm. Dazu müssen wir die
ShowWindow Funktion aufrufen. Die UpdateWindow Funktion lässt den Anwendungsbereich, also
den freien Fensterbereich, sofort nach dem Start neu zeichnen.
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
Das Fenster ist nun erstellt und wird angezeigt. Der Aufruf von UpdateWindow sendet eine
WM_PAINT-Nachricht, damit der Client-Bereich des Fensters hWnd neu gezeichnet wird.
Nun warten wir auf die Eingabe bzw. Aktivitäten des Benutzers. Wenn etwas passiert, das unser
Fenster betrifft, informiert uns Windows über die entsprechende Nachricht. Jedoch werden uns die
Nachrichten nicht aufgezwängt, sondern sie werden in einer Warteschleife abgelegt, aus der wir sie
erst mittels der GetMessage Funktion abholen müssen.
while (GetMessage(&msg, NULL, 0, 0))
DispatchMessage(&msg);
Wenn keine Nachricht vorhanden ist, dann bleibt unser Programm in der Funktion stehen und
wartet auf die nächste Nachricht.

Einleitung 11
Die GetMessage Funktion hat folgende Parameter:
BOOL GetMessage(
LPMSG lpMsg, // address of structure with message
HWND hWnd, // handle of window
UINT wMsgFilterMin, // first message
UINT wMsgFilterMax // last message
);
In dem ersten Parameter wird die Nachricht gespeichert. Im zweiten Parameter können wir uns auf das
Abholen von Nachrichten für nur ein Fenster beschränken. Wenn wir dies wollten, müssten wir hier
den Handle des Fensters eintragen. Jedoch würde dann unser Programm nicht korrekt beenden, da zum
Beispiel die Nachricht, die PostQuitMessage sendet, nicht für unser Fenster bestimmt ist, da dies ja
schon zerstört wurde. Mit dem dritten und vierten Parameter kann man die Art der Nachrichten
beschränken. Es werden nur Nachrichten abgeholt, die zwischen diesen beiden Werten liegen. Eine
Ausnahme ist, wenn beide Parameter Null sind, dann werden alle Nachrichten abgeholt.
Bei Eintritt eines Ereignisses ruft Windows eine Funktion des Programms auf, wenn eines der im
Aufruf von GetMessage eingetreten ist. Diese Funktion (auch Fensterfunktion, Window Procedure
oder kurz WndProc genannt) ist jedoch nicht an ein Programm gebunden, sondern an ein Fenster. Es
kommt daher häufig vor, dass ein Programm mehrere solcher Funktionen enthält. Über die Parameter
der WndProc-Funktion bekommt man die Nachricht übergeben.
LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_PAINT:
DrawHello(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
Die WndProc Funktion gibt einen LRESULT Wert zurück. LRESULT ist ein typedef 6 auf einen
long Typ. CALLBACK sagt aus, dass diese Funktion von Windows aufgerufen wird. Der Name der
WndProc Funktion ist frei wählbar. Sie verfügt über folgende Parameter:
Der erste Parameter ist der Handle zu dem Fenster, für das die Nachricht bestimmt ist.
Der zweite Parameter message enthält die Kennziffer der Nachricht. Für alle Nachrichten sind in
6 typedef erzeugt keinen neuen Datentyp, sondern führt lediglich mnemonische Synonyme (einfachere Namen)
oder Alias-Bezeichnungen für einen existierenden Typ ein. typedef eignet sich daher besonders zur
Vereinfachung komplexer Deklarationen:

Einleitung 12
winuser.h Konstanten deklariert.
Die nächsten beiden Parameter enthalten je nach Nachricht verschiedene Daten. WPARAM ist vom Typ
unsigned int. Das W stammt noch aus alten Tagen, als ein int noch 16 Bit breit war, damals
war WPARAM also noch ein Speicherwort.
case WM_PAINT:
DrawHello(hwnd);
break;
Die WM_PAINT-Nachricht informiert darüber, dass ein Teil des Fensters oder das gesamte Fensters
der Applikation neu gezeichnet werden muss. Die Applikation ruft, immer wenn sie eine Nachricht
WM_PAINT erhält, die Funktion DrawHello auf.
Im Falle einer WM_DESTROY-Nachricht wird die Meldung zur Beendigung des Programms an
WinMain weitergeleitet, das einen geordneten Abschluss des Programms vornehmen kann.
Alle übrigen Meldungen werden an die Standard-Fensterprozedur DefWindowProc weitergeleitet.
Diese stellt sicher, dass alle Meldungen abgearbeitet werden.
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
Nun zur Funktion DrawHello:
void DrawHello(HWND hwnd)
{
HDC hDC;
PAINTSTRUCT paintStruct;
RECT clientRect;
}
hDC = BeginPaint(hwnd, &paintStruct);
if (hDC != NULL)
{
GetClientRect(hwnd, &clientRect);
DPtoLP(hDC, (LPPOINT)&clientRect, 2);
DrawText(hDC, "Hello, World!", -1, &clientRect,
DT_CENTER | DT_VCENTER | DT_SINGLELINE);
EndPaint(hwnd, &paintStruct);
}
Mit der BeginPaint-Funktion teilen wir Windows mit, dass wir in unseren Anwendungsbereich
zeichnen möchten. Der erste Parameter der BeginPaint Funktion legt das Fenster fest, in dem wir
zeichnen wollen. Der zweite Parameter ist ein Zeiger auf unsere PAINTSTRUCT Funktion, in der
Windows die Daten bezüglich des Zeichenbereiches speichern wird. Der Rückgabewert hDC (Device
Context) ist der Handle auf den Zeichenbereich.
Die BeginPaint Funktion übermalt, wenn es so gewollt war, den zu erneuernden (ungültigen)
Zeichenbereich mit dem Hintergrund Füllmuster. Der Zeichenbereich wird danach wieder als gültig
erklärt. Dieses als gültig markieren ist wichtig, denn solange noch ein Bereich als ungültig markiert

Einleitung 13
ist, wird uns Windows immer wieder eine WM_PAINT Nachricht schicken.
Die DPtoLP-Function konvertiert Koordinaten des Geräts (device) in logische Koordinaten. Dabei
werden verschiedene Geräteeinstellungen (mapping mode, Koordinaten des Bezugspunkts, viewport,
...) berücksichtig. Bei einem Bildschirm entsprechen die Gerätekoordinaten den Pixelkoordinaten am
Bildschirm. Logische Koordinaten werden applikationsspezifisch durch den Entwickler festgelegt.
GetClientRect(hwnd, &clientRect);
Die GetClientRect-Funktion liefert die Koordinaten der Clien-Area eines Fensters. Die Client-
Koordinaten spezifizieren die linke obere und untere rechte Ecke dieser Client-Fläche. Da Client
Koordinaten relative zur linken, oberen Ecke definiert sind, ist links oben immer (0,0).
Mit der DrawText Funktion kann man Text formatiert ausgeben. Der erste Parameter ist, wie immer
bei GDI Funktionen, der Handle zu unserem Device Context. Bei der Windows-Programmierung
sprechen wir ein Ausgabegerät in der Regel nicht direkt an, sondern über einen Gerätekontext. Dies
hat für Sie den Vorteil, dass Sie sich um die spezifischen Eigenschaften eines Geräts (Bildschirm,
Drucker, Plotter, Zwischenablage) nicht selbst kümmern müssen, sondern Windows die Ausgabe
überlassen. Beachten Sie dabei jedoch, dass diese Ausgaben nicht von Windows gespeichert werden.
Bei bestimmten Fensteroperationen (wie Verschieben, Minimieren, Vergrößern, in den Vordergrund
holen) muss also Ihr Programm dafür sorgen, angeregt durch die vom Betriebssystem gesendeten
Botschaften, den Fensterinhalt neu zu zeichnen!
Der zweite Parameter ist ein Zeiger auf den auszudruckenden Text (in diesem Fall eine
Zeichenkettenkonstante). Im dritten Parameter muss man die Länge des Textes angeben; dies
geschieht hier durch Übergabe des zuvor bestimmten Client-Rects. Mit dem vierten Parameter kann
man festlegen, wie der Text formatiert werden soll. Wir benutzen die Konstanten DT_SINGLELINE,
DT_CENTER und DT_VCENTER, die den Text einzeilig und zentriert ausgeben lassen.
Am Ende jeder Zeichenoperation müssen wir mit der EndPaint Funktion Windows mitteilen, dass wir
nichts mehr zeichnen möchten. Die Funktion gibt den Device Context wieder frei.
5 Nachrichtenschleifen und Fensterprozeduren
In einer Fensterprozedur kann ebenfalls eine Nachrichtenschleife enthalten sein. Im folgenden
Programm implementieren wir eine grundlegende Zeichnungsfunktionalität.
#include
void AddSegmentAtMessagePos(HDC hDC, HWND hwnd, BOOL bDraw)
{
DWORD dwPos;
POINTS points;
POINT point;
}
dwPos = GetMessagePos();
points = MAKEPOINTS(dwPos);
point.x = points.x;
point.y = points.y;
ScreenToClient(hwnd, &point);
DPtoLP(hDC, &point, 1);
if (bDraw) LineTo(hDC, point.x, point.y);
else MoveToEx(hDC, point.x, point.y, NULL);

Einleitung 14
void DrawHello(HWND hwnd)
{
HDC hDC;
MSG msg;
if (GetCapture() != NULL) return;
hDC = GetDC(hwnd);
if (hDC != NULL)
{
SetCapture(hwnd);
AddSegmentAtMessagePos(hDC, hwnd, FALSE);
while(GetMessage(&msg, NULL, 0, 0))
{
if (GetCapture() != hwnd) break;
switch (msg.message)
{
case WM_MOUSEMOVE:
AddSegmentAtMessagePos(hDC, hwnd, TRUE);
break;
case WM_LBUTTONUP:
goto ExitLoop;
default:
DispatchMessage(&msg);
}
}
ExitLoop:
ReleaseCapture();
ReleaseDC(hwnd, hDC);
}
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_LBUTTONDOWN:
DrawHello(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR d3, int nCmdShow)
{
MSG msg;
HWND hwnd;
WNDCLASS wndClass;
if (hPrevInstance == NULL)
{
memset(&wndClass, 0, sizeof(wndClass));
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WndProc;

Einleitung 15
wndClass.hInstance = hInstance;
}
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wndClass.lpszClassName = "HELLO";
if (!RegisterClass(&wndClass)) return FALSE;
}
hwnd = CreateWindow("HELLO", "HELLO",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, NULL, hInstance, NULL);
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
while (GetMessage(&msg, NULL, 0, 0))
DispatchMessage(&msg);
return msg.wParam;
Machen Sie sich mit dem Programm vertraut! Was hat es mit den beiden Nachrichtenschleifen auf
sich?
Was geschieht, wenn
? Sie das Programm minimieren?
? Sie ein anderes Programmfenster über das Anwendungsfenster schieben?