Table Of ContentWin32API-Tutorials für Delphi
von Michael Puff
Copyright © 2002 – 2004 Michael Puff
PDF Version 2.0 [2004-09-28]
2
Inhaltsverzeichnis
1. Fenster und Controls..............................................................................................................................................8
1.1. Fenster.........................................................................................................................................................9
1.2. Textausgabe in Labels..................................................................................................................................17
1.3. Schaltflächen...............................................................................................................................................21
1.4. Checkboxen und Radiobuttons......................................................................................................................24
1.5. Arbeiten mit Eingabefeldern..........................................................................................................................25
2.1. Arbeiten mit Listboxen..................................................................................................................................32
2.2. Arbeiten mit der Combobox..........................................................................................................................38
2.3. Ein Menü hinzufügen....................................................................................................................................44
2.4. Dialoge aus Ressourcen aufrufen..................................................................................................................50
2.5. Problem mit TAB und Alt+<Shortcut>...........................................................................................................56
3. Standarddialoge...................................................................................................................................................57
3.1. Dateien öffnen und speichern.......................................................................................................................58
3.2. Die Schriftart ändern....................................................................................................................................63
3.3. Suchen- / Ersetzendialog..............................................................................................................................65
3.4. Der Hilfe-Button...........................................................................................................................................72
4. CommonControls.................................................................................................................................................74
4.1. Fortschrittsanzeige.......................................................................................................................................76
4.2. Die Statuszeile.............................................................................................................................................79
4.3. Tooltips / Hints............................................................................................................................................81
4.4. Die Toolbar.................................................................................................................................................88
4.5. Das IP-Adress-Eingabefeld............................................................................................................................98
4.6. Die Trackbar..............................................................................................................................................101
4.7. Das List-View-Control.................................................................................................................................104
4.8. Der Tree-View............................................................................................................................................130
4.9. Die Rebar..................................................................................................................................................141
4.10. Das SysLink-Control..................................................................................................................................154
4.11. Tabsheets................................................................................................................................................158
5. Systemfunktionen..............................................................................................................................................161
5.1. Der Timer ohne die VCL..............................................................................................................................162
5.2. Verbindung zur Taskbar Notification Area ...................................................................................................163
5.3. Hotkeys und Shortcuts...............................................................................................................................173
5.4. Datum und Uhrzeit.....................................................................................................................................178
5.5. Die Verwendung von INI-Dateien................................................................................................................191
5.6. Die Registry...............................................................................................................................................197
6. Grundlagen der GDI...........................................................................................................................................214
6.1. Grundlagen der GDI...................................................................................................................................215
7. Sonstige Themen...............................................................................................................................................218
7.1. Subclassing................................................................................................................................................219
7.2. Ressourcenskripte erstellen.........................................................................................................................224
7.3. Anwendung für die Systemsteuerung .........................................................................................................236
7.4. Einen Assistenten erstellen.........................................................................................................................242
7.5. Splitter......................................................................................................................................................251
8. Hilfedateien erstellen und nutzen........................................................................................................................257
8.1. HLP-Hilfedateien........................................................................................................................................258
8.2. CHM-Hilfedateien.......................................................................................................................................270
3
Vorwort
Wie alles begann
Angefangen habe ich, wie wohl jeder Delphi-Programmierer, mit der VCL. Doch irgendwann kommt man an den Punkt,
an dem man neue Herausforderungen sucht ... und im günstigsten Fall auch findet. Ich fand meine in der Delphi-
Programmierung ohne die VCL, also rein auf Win32-API-Basis. Ich darf sagen, dass es sich mit der Zeit zu meinem
Spezialgebiet entwickelt hat.
Begonnen hat alles mit einem Tutorial von Assarbad. Na ja, eigentlich war es nur eine Einführung, gespickt mit
Hintergrundwissen darüber, wie das ganze eigentlich funktioniert. Doch es hatte mich gepackt, und nachdem ich die
ersten wackeligen Schritte unternommen hatte und anfing, mir eigenes Wissen diesbezüglich anzueignen, entschied ich
mich, es an andere weiterzugeben. Daraus sind dann "Luckies nonVCL-Tutorials" in ihrer ersten Version entstanden.
Diese bilden auch heute noch den Kern und die Basis für die Tutorials in ihrer jetzigen Form. Angeboten hatte ich sie zum
Lesen online auf meiner Homepage und zum Download in einem Zip-Archiv (HTML-Seiten plus Sourcen der Demos).
Versionschaos?
Ein befreundeter Programmierer, Mathias Simmack, sprach mich dann darauf an, die Tutorials in einer
anwenderfreundlicheren Version zu präsentieren. Und die Idee, sie in Form einer CHM-Hilfe zu veröffentlichen, ward
geboren. Nach wohl einigen Wochen mühseliger Arbeit konnte die CHM-Version dann das Licht der Öffentlichkeit
erblicken. Verpackt in einem benutzerfreundlichen Setup, für das sich auch Mathias verantwortlich zeigte. Im Laufe der
Zeit hat er sich dadurch zu einem Experten für Hilfedateien und Setups entwickelt. Und noch heute ist er verantwortlich
für die CHM-Version und das Setup. Außerdem steuerte er dann auch noch einige Tutorials bei.
Nach einiger Zeit wurden dann vereinzelt Stimmen nach einer besser druckbaren Version laut. Und da auch ich mal etwas
Handfestes in der Hand haben wollte, sprich: Schwarz auf Weiß, machte ich mich ans Werk und bereitete die Tutorials
als PDF-Datei auf. Als Grundlage dienten mir die aufbereiteten HTML-Dateien der CHM-Version. Somit ist die PDF-Version
inhaltlich mit der CHM-Version identisch. Diese Konsistenz soll auch in Zukunft gewahrt bleiben. Es gab und es wird
immer nur die "Win32-API-Tutorials für Delphi" geben - wenn auch in unterschiedlichen Formaten. Damit sollte für jeden
Geschmack etwas dabei sein.
Pläne für die Zukunft
Ich hoffe, dass die Tutorials nicht nur in der Delphi-Praxis, meinem Stamm-Forum, und im Delphi-Forum Verbreitung
finden, sondern mit der Zeit auch in anderen Delphi-Communities auf größeres Interesse stoßen. Ich hoffe, dass die PDF-
Version dazu beiträgt diese Ziele zu erreichen. Ein weiteres Ziel wäre es, die Tutorials auf einer Zeitschrift oder einem
großen Download-Portal für Software oder eBooks unterzubringen.
Und dann wäre da noch der Traum, welcher aber erstmal auch nur ein Wunschtraum bleiben wird: eine Veröffentlichung
als Buch.
Danksagung
An erster Stelle steht da natürlich Assarbad aka Oliver, mit dessen Tutorial alles angefangen hat, und der mir in der
Anfangszeit per ICQ immer mit Rat und Tat beiseite gestanden hat. Als nächstes wäre dann da noch Nico Bendlin zu
nennen, dessen Übersetzungen der "Iczelion's Win32 ASM Tutorials" nach Delphi als Grundlage für das ein oder andere
Tutorial gedient haben. Nicht zu vergessen natürlich Mathias, der mit der CHM-Version und den dazugehörigen Setups
eine hervorragende Arbeit geleistet hat und mir auch als Autor, Kritiker und Berater immer zur Seite stand und steht.
In diesem Sinne wünsche ich viel Spaß beim Lesen der "Win32-API-Tutorials für Delphi".
Euer Michael Puff, Vellmar im September 2004
4
nonVCL, was ist das eigentlich?
Unter der nonVCL-Programmierung versteht man die Programmierung ohne die Verwendung der VCL. Es gibt keine
Komponenten, keine Formulare in dem Sinne ... usw. Stattdessen greift man direkt auf das API (Application Programmers
Interface) zurück. Wenn Sie bereits Erfahrung mit der VCL-Programmierung haben, dann wird Ihnen zuerst klar werden
(müssen), dass Sie sich bei reinen API-Programmen um viele Dinge selbst kümmern müssen. Der Nachteil dabei ist, dass
die Quelltexte solcher Projekte u.U. etwas umfangreicher und mitunter auch unübersichtlicher werden. Andererseits
haben die kompilierten Exe-Dateien nur einen Bruchteil der Größe der VCL-Versionen. Und das ist für viele Programmierer
Grund genug, kleinere Tools komplett ohne VCL zu entwickeln.
Allerdings dürfen Sie die Vorteile der VCL nicht vergessen. Unserer Meinung nach ist es nicht vertretbar, ein
umfangreiches Projekt mit vier, fünf oder mehr Formularen ausschließlich auf API-Basis zu entwickeln. Sicher wird sich
das realisieren lassen, aber hier sind Sie mit der VCL eindeutig schneller, und Sie können bequemer arbeiten.
Ideal ist die API-Programmierung bei der Entwicklung von kleineren Projekten und Tools, die vielleicht nur ein oder zwei
Fenster oder Dialoge haben und bei denen der Funktionsumfang nicht so gewaltig ist.
Im Gegensatz zum herkömmlichen Weg müssen Sie bei nonVCL-Programmen generell für eins sorgen: Ihr Programm
muss aktiv bleiben. Deshalb besteht ein typisches nonVCL-Grundgerüst aus drei Teilen -
• der Hauptfunktion (in PASCAL durch begin und end. gekennzeichnet)
• der Nachrichtenschleife
• der Nachrichtenfunktion
Beispiel:
// Nachrichtenfunktion
function WndProc(wnd: HWND; uMsg: UINT; wp: WPARAM; lp: LPARAM):
LRESULT; stdcall;
begin
Result := 0;
case uMsg of
WM_CREATE:
// Funktionen ausführen
WM_DESTROY:
PostQuitMessage(0);
else
Result := DefWindowProc(wnd,uMsg,wp,lp);
end;
end;
// Hauptfunktion
var
msg : TMsg;
begin
// Fensterklasse registrieren, & Fenster erzeugen
{ ... }
// Nachrichtenschleife
while(GetMessage(msg,0,0,0)) do
begin
TranslateMessage(msg);
DispatchMessage(msg);
end;
end.
Bevor Sie jedoch beginnen nonVCL-Programme zu schreiben, sollten Sie sich mit den Grundlagen der Programmierung in
PASCAL respektive ObjectPascal (Delphi) auskennen. Es macht nicht viel Sinn, völlig ohne Vorkenntnisse in diese Materie
einsteigen zu wollen. Frust dürfte wohl die Folge sein.
5
Außerdem sind weitergehende API-Dokumentationen unbedingt empfehlenswert. Als erstes wären da die Win32-API-
Hilfedateien von Borland zu nennen. Diese liegen Delphi bei, sind allerdings auch veraltet und (in Bezug auf neue
Controls) unvollständig. Sofern möglich nutzen Sie also gleich die Quellen von Microsoft, als da wären:
• das Microsoft Developers Network (MSDN) (www.msdn.microsoft.com)
• das Platform SDK (PSDK) (http://www.microsoft.com/msdownload/platformsdk/sdkupdate)
Die Tutorials bauen weitgehend aufeinander auf. Wenn Sie also nicht gezielt ein bestimmtes Thema suchen, dann ist es
ganz sinnvoll, sie der Reihe nach durchzuarbeiten.
6
Informationen
Verfügbare Versionen / zugehöriges Material
• chm-Version mit Setup
• Sourcen der Demos mit Setup
• PDF-Version
• Sourcen der Demos in einem Zip-Archiv
Bezugsquellen / Download-Möglichkeiten
www.luckie-online.de
www.simmack.de
Die Autoren
Michael Puff Mathias Simmack Thomas Liebetraut
Fenster Suchen- / Ersetzendialog Ressourcenskripte erstellen
Textsausgabe in Labels Tooltips / Hints
Schaltflächen Das IP-Adress-Eingabefeld
Checkboxen und Radiobuttons Der Treeview
Arbeiten mit Eingabefeldern Die Rebar
Arbeiten mit Listboxen Das SysLink-Control
Arbeiten mit Comboboxen Verbindung zur TNA
Ein Menü hinzufügen Hotkeys und Shortcuts
Dialoge aus Ressourcen aufrufen Datum und Uhrzeit
Dateien öffnen und speichern Die Verwendung von Ini-Dateien
Die Schriftart ändern Die Registry
Fortschrittsanzeige Anwendung für die Systemsteuerung
Die Statuszeile Einen Assistenten erstellen
Die Toolbar HLP-Hilfedateien
Die Trackbar CHM-Hilfedateien
Der Listview
Tabsheets
Der Timer ohne die VCL
Subclassing
Grundlagen der GDI, Teil 1
Kontaktmöglichkeiten
Michael Puff:
Homepage : www.luckie-online.de
E-Mail : [email protected]
Mathias Simmack:
Homepage : www.simmack.de
Thomas Liebetraut:
Homepage : www.tommie-lie.net
E-Mail : [email protected]
7
Fenster und Controls
1. Fenster und Controls
8
Fenster
1.1. Fenster
1.1.1. Das Fenster erzeugen
Unter Windows werden normalerweise rechteckige Fenster erzeugt, mit denen der Benutzer interagiert. Daher stellen wir
erst einmal einige grundlegende Merkmale eines Fensters zusammen, die wir dann in einem Programm definieren wollen:
Wert Bedeutung
x, y, w, h linke obere Ecke (x, y), und Breite und Höhe (w, h) des Fensters
Icon Icon des Fensters
SysMenu das Systemmenü, das sich beim Klicken auf das Icon bzw. mit ALT-Leertaste öffnet
Rahmen kein Rahmen, fester Rahmen, bzw, mit der Maus veränderbarer Rahmen
Caption Beschriftungstext in der Titelzeile
Minimizebox, Schaltfläche zum Minimieren und Maximieren des Fensters
Maximizebox
Cursor Form des Mauszeigers innerhalb des Fensters
Background Hintergrundfarbe, -muster des Fensters
Menu Menü, das zum Fenster gehört
Man sieht: als Programmierer muss man sich allein schon wegen der grafischen Unterstützung von Windows-
Programmen um eine Vielzahl grafischer Details kümmern, die mehr mit dem Design als mit dem Programmierziel zu tun
haben. Die Fenstermerkmale werden an zwei Stellen definiert. Die erste Hälfte wird im Fensterklassen-Record, die zweite
Hälfte wird mit der Funktion "CreateWindow(Ex)" festgelegt. Im Demo-Quellcode finden Sie z.B. die Befehlszeile:
CreateWindowEx(0,
ClassName,
AppName,
WS_CAPTION or WS_VISIBLE or WS_SYSMENU or WS_MINIMIZEBOX or
WS_MAXIMIZEBOX or WS_SIZEBOX,
CW_USEDEFAULT, // Position von Links
CW_USEDEFAULT, // Position von oben
WindowWidth, // Breite (hier Konstante)
WindowHeight, // Höhe (hier Konstante)
0,
0,
hInstance,
nil);
Experimentieren Sie einfach mit den kommentierten Werten, und beobachten Sie die Ergebnisse. Sie können auch
negative Werte eingeben. Wollen Sie sich weder um die Position noch um die Größe des Fensters kümmern, dann
verwenden Sie den Konstantenwert CW_USEDEFAULT anstelle von Pixelangaben.
Ohne vorgreifen zu wollen - Stellen wir uns mal die Frage: »Woher weiß "CreateWindowEx" welche Fensterklasse es als
Grundlage nehmen soll?«. In dem Fall ist es recht einfach. Im Record haben wir mit "wc.lpszClassName :=
Classname;" die Möglichkeit, einen Klassennamen anzugeben. In dem Fall eine Konstante aus dem Programmkopf. Den
selben Namen übergeben wir als zweiten Parameter an die Funktion "CreateWindowEx".
9
Fenster
TWndClassEx-Definition
typedef struct _WNDCLASSEX {
UINT cbSize; // Größe des Records
UINT style; // Stil
WNDPROC lpfnWndProc; // Zeiger auf Nachrichtenfunktion
int cbClsExtra;
int cbWndExtra;
HANDLE hInstance; // Anwendungsinstanz
HICON hIcon; // Symbol-Handle
HCURSOR hCursor; // Cursor-Handle
HBRUSH hbrBackground; // Hintergrund der ClientArea
LPCTSTR lpszMenuName; // MainMenu-Handle
LPCTSTR lpszClassName; // Klassenname
HICON hIconSm; // Symbol-Handle (kleines Symbol)
} WNDCLASSEX;
1.1.2. Symbol und Mauszeiger festlegen
Wie kommt nun eigentlich das Icon in die Titelzeile des Fensters? Im Beispiel wird das Icon aus einer Ressourcendatei
geladen, und zwar an dieser Stelle:
wc.hIcon := LoadIcon(hInstance, MAKEINTRESOURCE(100));
Voraussetzung dafür ist natürlich, dass diese Ressourcendatei vorher erzeugt und dann auch in den Quellcode
eingebunden wurde. Das Symbol selbst wird dann mit der Funktion "LoadIcon" geladen, die als Parameter ein Handle
der Anwendungsinstanz und den Iconnamen oder die Ressourcen-ID des Symbols erwartet. Wenn Sie eine Ressourcen-
ID verwenden, müssen Sie das Makro "MAKEINTRESOURCE" benutzen, um den Integerwert in einen Ressourcentyp
umzuwandeln.
Wenn Sie auf Ressourcendateien verzichten wollen, können Sie bestimmte Standardsymbole von Windows benutzen.
Dazu ändern Sie die obige Zeile wie folgt ab:
wc.hIcon := LoadIcon(hInstance, IDI_WINLOGO);
Und schon sehen Sie das Windows-Logo als Icon in der Titelzeile. In der Hilfe zu der Funktion "LoadIcon" finden Sie
weitere Werte, die Sie verwenden können.
Mit dem Mauszeiger lässt sich entsprechend verfahren. Das Beispielprogramm lädt den Standard-Mauszeiger:
wc.hCursor := LoadCursor(0, IDC_ARROW);
Trotz der heutigen schnellen Rechner keine Seltenheit: IDC_WAIT. Sie wissen sicher schon, welcher Cursor das ist?
Richtig - die altbekannte Sanduhr. Weitere Cursortypen finden Sie in der Hilfe zur Funktion "LoadCursor".
1.1.3. Die Titelzeile
In unserem Beispielprogramm finden wir in der Titelzeile (v.l.n.r): das Systemmenü, den Fenstertitel und die drei
Schaltflächen (Minimieren, Maximieren, Schließen):
10
