|
Win32 Programmierung mit FPC - Teil 1 - by Delax
Nun fügen wir das bisher gelernte zu einem funktionierenden Programm zusammen. Wir teilen den ganzen Initialisierungskram auf und packen ihn in Prozeduren. Außerdem führen wir während dessen ein paar Überprüfungen durch, ob auch wirklich alles geklappt hat.
Werfen wir erst einmal einen Blick auf unsere Variablen etc.
{$APPTYPE GUI}
{$MODE DELPHI}
program Win32_Source3;
uses
Windows;
const
AppName = 'Win32 Tutorial - Source 3';
var
AMessage: Msg;
hWindow: HWnd;
Die Unit Windows sollte sich selbst erklären. AMessage ist die Variable welche in der WndProc angegeben wird und die Windows Nachrichten enthält. hWindow ist das Handle zu unserem Fenster.
Dann folgt eine Prozedur namens "Throw". Anstatt immer bei Fehlern eine Messagebox neu zu erzeugen nutzen wir eine Prozedur, die diese Box für uns ausgibt. Wir übergeben dann nur noch den Text.
PROCEDURE Throw(throw_string : pChar);
begin
MessageBox(0, throw_string, 'Error', MB_OK);
Halt(0);
end;
Anschließend folgt die WndProc.
FUNCTION WindowProc(Window: HWnd; AMessage, WParam,
LParam: Longint): Longint; stdcall; export;
begin
WindowProc := 0;
case AMessage of
WM_DESTROY:
begin
PostQuitMessage(0);
Exit;
end;
end;
WindowProc := DefWindowProc(Window, AMessage, WParam, LParam);
end;
Wir fangen eigentlich nur ein Ereignis auf: WM_DESTROY. Dieses wird gesendet, wenn der Nutzer das Fenster schließt. Wenn das der Fall ist beenden wir unser Programm. Und das war es auch schon.
Als nächstes brauchen wie eine Prozedur zum registrieren der Fensterklasse.
PROCEDURE WindowRegister;
var
WindowClass: WndClass;
begin
WindowClass.Style := cs_hRedraw or cs_vRedraw;
WindowClass.lpfnWndProc := WndProc(@WindowProc);
WindowClass.cbClsExtra := 0;
WindowClass.cbWndExtra := 0;
WindowClass.hInstance := system.MainInstance;
WindowClass.hIcon := LoadIcon(0, idi_Application);
WindowClass.hCursor := LoadCursor(0, idc_Arrow);
WindowClass.hbrBackground := GetStockObject(WHITE_BRUSH);
WindowClass.lpszMenuName := nil;
WindowClass.lpszClassName := 'WinClass';
if RegisterClass(WindowClass) <> 0 = false then Throw('Could not Register Window!');
end;
Keine Überraschung hier, eigentlich entspricht sie der Klasse aus dem "Hello World" Beispiel.
Als nächstes wir das Fenster erzeugt.
PROCEDURE WindowCreate;
begin
hWindow := CreateWindow('WinClass, AppName,
ws_OverlappedWindow, cw_UseDefault, cw_UseDefault,
cw_UseDefault, cw_UseDefault, 0, 0, system.MainInstance, nil);
if hWindow <> 0 then begin
ShowWindow(hWindow, CmdShow);
UpdateWindow(hWindow);
end;
if longint(hWindow) = 0 then Throw('Could not create Window!');
end;
Im Gegensatz zu dem "Hello World" Beispiel verzichten wir darauf die Erzeugung des Fensters in eine Funktion zu verpacken. Meiner Meinung nach ist das ziemlich unnötig, da wir die Fehlerprüfung auch so erledigen können. Einzig sinnvoll ist es, wenn man mehrere Fenster öffnen will, was wir aber im Moment nicht vorhaben.
Nachdem wir das Fenster erzeugt haben, überprüfen wir, ob auch wirklich ein Handle zu unserem Fenster besteht. Wenn nicht wird eine Message Box mit einer Fehlermeldung ausgegeben und das Programm angehalten.
BEGIN
WindowRegister;
WindowCreate;
while GetMessage(@AMessage, 0, 0, 0) do begin
TranslateMessage(AMessage);
DispatchMessage(AMessage);
end;
Halt(AMessage.wParam);
Als erstes registrieren wir die Fensterklasse und erzeugen unser Fenster. Windows erstellt an dieser Stelle das Fenster und füllt die Variable hWindow mit dem Handle zu unserem Fenster. Der Rest besteht aus Nachrichtenverarbeitung.
Tja, das wars. Das ist unser Rahmen, den wir von nun an benutzen. Ihr könnt den Source hier herunterladen. Und jetzt können wir uns der eigentlichen Windows-Programmierung widmen ;)
Delax/ Sundancer Inc.
[delax@sundancerinc.de]
Back to previous page
|
