香港IT網 Delpih 中的Windows API編程初步

Delpih 中的Windows API編程初步

2004-12-30 方舟天極網

列印自: 香港IT網
地址: http://www.hkitn.com/article.php/2552

[1]

　　使用RAD類型工具的人越來越多了，雖然我對於RAD類的工具向來不多作評議，但我還是常常使用的。所以我深深的知道這類工具雖然給我們帶來了便利，使我們能不用將更多的精力放在介面上，但同時也將初學者緊緊的圈在了他所提供的控制項和元件中。所以很多人並不能真正的瞭解windows的消息驅動原理以及windows的運作過程。本文中我們就一起來學習一下windows的運作過程，使我們對delphi這樣一個優秀的編程工具有一個新的認識，並對windows下的程式編寫有更深刻、透闢的瞭解和認識。

　　一、消息的定義

　　我們先從使用的角度看看windows的運作過程。我們都知道windows是一個多工的平臺，使用這個平臺，我們可以一邊工作，一邊聽歌曲，等等。所以對於這個操作平臺可以想像到它除了一般作業系統所提供的對檔系統，記憶體系統等的管理之外，更重要的就是我們所熟知的消息驅動了，也就是說，要通過一定的方法和結構可以給每一個運行中的程式實例以及其中的每一個視窗傳遞其中所觸發的事件。 Windows中究竟是怎樣做到的呢？讓我們打開安裝delphi的目錄，在其中的source\rtl\Win\Windows.pas檔（或者在一個工程檔，找到uses，在其中找到Ｗindows，然後按下Ctrl鍵，用滑鼠點擊單詞），在其中的第18919行，我們可以看到這樣一個結構的定義：
{ Message structure }
PMsg = ^TMsg ;
tagMSG = packed record
hwnd : HWND ;
message : UINT ;
wParam : WPARAM ;
lParam : LPARAM ;
time : DWORD ;
pt : TPoint ;
end ;
{ $ EXTERNALSYM tagMSG }
TMsg = tagMSG ;
MSG = tagMSG ;
{ $ EXTERNALSYM MSG }

　　其中hwnd欄位表示觸發了消息的視窗的ID，由此可以保證消息正確的發送到每一個視窗去。 Message 表示消息的類型，其中更細緻的解釋要通過wParam和lParam一起來進行，不同的消息，wParam和lParam的值也就不相同。time用來記錄消息觸發的時間。Pt則表示觸發的位置（畢竟window中有了滑鼠）。我們也可以用同樣的方法打開Messages檔。其中定義了windows中的絕大部分消息和結構。下面是我們截取的其中一部分。
const
　{ $ EXTERNALSYM WM_NULL }
　　WM_NULL = $0000 ;
　{ $ EXTERNALSYM WM_CREATE }
　　WM_CREATE = $0001 ;
　{ $ EXTERNALSYM WM_DESTROY }
　　WM_DESTROY = $0002 ;
　{ $ EXTERNALSYM WM_MOVE }
　　WM_MOVE = $0003 ;
　{ $ EXTERNALSYM WM_SIZE }
　　WM_SIZE = $0005 ;
　　…… ……
　　WM_APP = $8000 ;
　{ NOTE : All Message Numbers below 0x0400 are RESERVED }
　{ Private Window Messages Start Here }
　{ $ EXTERNALSYM WM_USER }
　　WM_USER = $0400 ;
　　…… ……　
　{ Dialog messages }
　{ $ EXTERNALSYM DM_GETDEFID }
　　DM_GETDEFID = ( WM_USER+0 ) ;
　{ $ EXTERNALSYM DM_SETDEFID }
　　DM_SETDEFID = ( WM_USER+1 ) ;
　{ $ EXTERNALSYM DM_REPOSITION }
　　DM_REPOSITION = ( WM_USER+2 ) ;
　{ $ EXTERNALSYM PSM_PAGEINFO }
　　PSM_PAGEINFO = ( WM_USER+100 ) ;
　{ $ EXTERNALSYM PSM_SHEETINFO }
　　PSM_SHEETINFO = ( WM_USER+101 ) ;
　{ Button Notification Codes }
　　…… ……

　　可以看到，windows中每一個消息都對應著一個唯一的數值。當然我們也可以定義自己的消息，它的數值只要定義在WM_USER之後，保證和其中的定義不想重複即可。

　　二、消息的接收

　　消息到是有了，但怎樣才能讓程式以及視窗接收到呢？還是從使用的角度考慮，可以想像到，對於一個程式或視窗可以接收到來自滑鼠、鍵盤等輸入設備的消息，也可以接收到來自程式傳遞的消息，因為有了前面的tagMSG結構，我們就可以被動的在程式中接收消息了。這個功能的實現就是由下面的程式實現的（同樣的這段程式來自於delphi的元代碼）：
function Tapplication . ProcessMessage ( var Msg : TMsg ) : Boolean;
var
　Handled : Boolean ;
begin
　Result : = False ;
　if PeekMessage ( Msg , 0 , 0 , 0 , PM_REMOVE ) then
　begin
　　Result : = True ;
　　if Msg.Message <> WM_QUIT then
　　begin
　　　Handled := False ;
　　　if Assigned ( FonMessage ) then FonMessage ( Msg , Handled ) ;
　　　if not IsHintMsg ( Msg ) and not Handled and not IsMDIMsg ( Msg ) and
　　　not IsKeyMsg ( Msg ) and not IsDlgMsg ( Msg ) then
　　　begin
　　　　TranslateMessage ( Msg ) ;
　　　　DispatchMessage ( Msg ) ;
　　　end ;
　　end ;
　else
　　FTerminate : = True ;
　end ;
end ;

　　其中主要的是這幾句：
if PeekMessage ( Msg , 0 , 0 , 0 , PM_REMOVE ) then
begin
　TranslateMessage ( Msg ) ;
　DispatchMessage ( Msg ) ;
end ;

　　但更常見的是：
while GetMessage ( Msg , 0 , 0 , 0 ) do
begin
　TranslateMessage ( Msg ) ;
　DispatchMessage ( Msg ) ;
End ;

　　PeekMessage和GetMessage都是從消息佇列中得到發給程式的消息，只要有消息，就通過TranslateMessage ( Msg )和DispatchMessage ( Msg )兩句將消息翻譯為可處理的格式並分派給應用程式所註冊的回調函數進行處理。

[2]

　　三、消息的處理

　　那麼消息是怎樣被處理的呢？回調函數又有什麼作用呢？有了前面的知識，我們只要能對不同的消息進行正確的解釋，就可以做到對消息的正確處理了。但前面我們提到了對於不同的消息傳遞的資訊使不相同的，所以這是API編程中最麻煩的一部分了。

　　我們這裏先給出一個常見而又必須的訊息方塊架。
function WindowProc ( hwnd : HWnd ; Msg : UINT; Wparam : WPARAM ; Lparam : LPARAM ) : LRESULT ; stdcall ; export ;
var
　dc : hdc ;
　rc : Trect ;
　ps : TpaintStruct ;
begin
　case Msg of
　　WM_PAINT :
　　Begin
　　　dc : = BeginPaint ( hwnd , ps ) ;
　　　…… ……
　　　EndPaint (hwnd, &ps) ;
　　　Exit ;
　　end;
　　WM_COMMAND :
　　…… ……
　　WM_DESTROY :
　　Begin
　　PostQuitMessage ( 0 ) ;
　　Exit ;
　end ;
end;
Result : = DefWindowProc ( hWnd , Msg , wParam , lParam ) ;
end ;

　　在這個框架中，WindowProc就是我們前面提到的回調函數。它是windows程式設計中的重點。無論是從輸入輸出等硬體設備傳來的消息，還是從軟體傳來的消息，都要保存到系統的消息佇列中，這個消息佇列有兩種，一種是系統消息佇列，主要是用來保存從輸入輸出等硬體設備傳來的消息，另一種是每個程式視窗的視窗消息佇列，主要保存每個視窗的發送來的消息。之後對消息的獲取和分發工作，當然是由前面講到的GetMessage 、 TranslateMessage和DispatchMessage三個函數來完成。至於消息的處理工作，則是由WindowProc函數來完成了。也就是說它是由系統在程式有消息到達時才調用的，所以我們稱之為回調函數。

　　WindowProc是在註冊視窗類時，註冊的視窗消息處理函數,當然名字可以自己命名。其中的參數有hwnd : HWnd ; Msg : UINT; Wparam : WPARAM ; Lparam : LPARAM ，這也就是我們前面談到的消息和表單。

　　這裏我們主要使用了三種消息：WM_PAINT ， WM_COMMAND和WM_DESTROY ，但是我們可以隨著程式而是用各種各樣的消息。為了處理不同的消息，在程式中使用了分支結構，所以隨著程式的規模越來越大，這個分支結構也會越來越龐大。

　　在這些消息中有兩個點是最為重要的，其一是WM_DESTROY消息，它表示一個銷毀視窗退出應用程式的消息。也是每個程式所必備的。對於這個消息的處理方式就是通過調用PostQuitMessage ( 0 )函數傳遞一個WM_QUIT消息，準備讓由GetMessage 、 TranslateMessage和DispatchMessage三個函數組成的消息迴圈中的GetMessage取得。當消息迴圈中的收到WM_QUIT消息時，GetMessage會傳回0，從而結束消息迴圈。進而釋放各種資源，結束整個程式。另一個重要的地方是DefWindowProc函數。我們的程式無論多大都不可能將所有的消息都處理，所以我們必須有一個機制讓不重要的不需要我們處理的消息，交給windows作業系統為我們處理，這個過程就是由DefWindowProc函數來實現的。因此當我們按下視窗右上角的差號或者按下左上角系統功能表中的Close命令時，系統會送出WM_CLOSE消息。通常程式的視窗函數不攔截此消息，於是交由DefWindowProc函數來處理。DefWindowProc函數在受到WM_CLOSE消息後，調用DestroyWindow把視窗清除。DestroyWindow又會送出WM_DESTROY消息。程式又如前面講到的一樣來結束程式釋放資源。

　　四、建立視窗類

　　知道了消息的傳遞和處理之後，我們來看看有關視窗的知識。

　　Windows帶給我們的不僅是技術上的創新，更重要的是統一而又便捷的視窗。那麼它是怎樣創建的呢？這就要從窗口類tagWNDCLASSA說起了。

　　讓我們先打開delphi目錄下的source\rtl\Win\Windows.pas檔，18875行，可以看到這樣一個結構：
tagWNDCLASSA = packed record
style : UINT ;
lpfnWndProc : TFNWndProc ;
cbClsExtra : Integer ;
cbWndExtra : Integer ;
hInstance : HINST ;
hIcon : HICON ;
hCursor : HCURSOR ;
hbrBackground : HBRUSH ;
lpszMenuName : PansiChar ;
lpszClassName : PansiChar ;
end ;

　　其中存儲了一個視窗的所有相關資訊。style : UINT 表示視窗的風格；lpfnWndProc : TFNWndProc 表示視窗的消息處理函數；hInstance : HINST 表示視窗的一個應用實例；Icon : HICON 用來記錄視窗的圖示；hCursor : HCURSOR 記錄視窗的游標；hbrBackground : HBRUSH 用來記錄視窗的背景色；lpszMenuName : PansiChar 表示視窗中的功能表資源的名稱； lpszClassName : PansiChar 記錄視窗類的名稱。

　　下面是一個例子：
WindowClass . style : = CS_VREDRAW + CS_HREDRAW + CS_DBLCLKS ;
WindowClass . lpfnWndProc : = @DefWindowProc ;
WindowClass . hCursor : = LoadCursor ( 0 , IDC_ARROW ) ;
WindowClass . hbrBackground : = 0 ;
WindowClass . hInstance : = Hinstance ;
StrPCopy ( WinClassName , ClassName ) ;

　　五、註冊視窗類

　　當我們按照程式的要求創建了這個視窗類之後，我們就可以在系統中註冊它了。這就要用到function RegisterClass(const lpWndClass: TWndClass): ATOM; stdcall;這樣一個函數了。他只有一個參數，就是我們先前說註冊的視窗類。

　　六、創建窗口

　　有了前面幾步，現在我們可以創建我們所註冊的視窗，看看她的真面目了。
function CreateWindow ( lpClassName : Pchar ; lpWindowName : PChar ;
dwStyle : DWORD ; X , Y , nWidth , nHeight : Integer ; hWndParent : HWND ;
hMenu : HMENU ; hInstance : HINST ; lpParam : Pointer ) : HWND ;

　　這個函數可以幫助我們創建我們先前註冊的視窗。其中的參數lpClassName : Pchar表示我們前面註冊的視窗類的名稱。lpWindowName : PChar 表示視窗的標題； dwStyle : DWORD 表示視窗的風格； X , Y , nWidth , nHeight : Integer ; 表示視窗的位置和寬度高度；

　　七、顯示視窗

　　視窗創建了，但我們只有在調用function ShowWindow ( hWnd : HWND ; nCmdShow : Integer ) : BOOL ; stdcall ;函數之後才會顯示出來。這個函數很簡單，hWnd : HWND 表示視窗的控制碼， nCmdShow : Integer則是視窗的顯示方式。function UpdateWindow ( hWnd : HWND ) : BOOL ; stdcal l ;函數則會送出一個WM_PAINT消息，使表單得到更新。

　　也許你會覺得很煩人，但這是所有windows程式的基礎，即便是我們用delphi編程時，程式也都是這樣運行的，只是delphi的創造者將一切都隱藏到了一個美麗外表之下。

　　下面我們用大家最常見的一個例子對前面的知識加以總結。在這個例子中，我們將在表單中顯示“ hello , world ! ” 。下面是程式及其運行效果：
program Project1;
{ $ APPTYPE CONSOLE }
uses
Windows ,
Messages ;
{ uses
　SysUtils ; }
var
　wClass : TWndClass; // 主窗口類
　hInst , //應用程式控制碼
　Handle : HWnd ; // 主窗口
　aMsg : TMsg ; //消息
　RCT : TRect ; //區域
　ps : TPaintStruct ; //顯示
　dc : hdc ; //設備上下文
　//函數：WindowProc
　//作用：處理主視窗的消息
　function WindowProc ( hWnd , Msg , wParam , lParam : Longint ) : Longint ; stdcall ;
　begin
　　WindowProc : = 0 ;
　case Msg of
　　WM_PAINT :
　begin
　　dc : =BeginPaint ( hWnd , ps ) ;
　　GetClientRect ( hWnd , RCT ) ;
　　DrawText ( dc , ' hello , world ! ' , -1 , RCT , Dt_SINGLELINE or DT_CENTER or DT_VCENTER ) ;
　　EndPaint ( hWnd , ps ) ;
　　Exit ;
　end ;
　　WM_DESTROY : //結束應用程式
　　Begin
　　PostQuitMessage ( 0 ) ;
　　Exit ;
　　end ;
　end ;
　Result : = DefWindowProc ( hWnd , Msg , wParam , lParam ) ; //消息默認處理
end ;
//主窗口
begin
// hInst : = GetModuleHandle ( nil ) ; // 獲得應用程式控制碼
with wClass do //初始化窗口類
begin
　hInstance : = system.MainInstance ;
　Style : = CS_HREDRAW or CS_VREDRAW ;
　HIcon : = LoadIcon ( 0 , IDI_APPLICATION ) ;
　LpfnWndProc : = @WindowProc ;
　HbrBackground : = GetStockObject ( WHITE_BRUSH ) ;
　lpszClassName : = ' Sample Class ' ;
　hCursor : = LoadCursor ( 0 , IDC_ARROW ) ;
end ;
RegisterClass ( wClass ) ; // 註冊視窗類
//創建主窗口
Handle : = CreateWindow (
' Sample Class ' , // 窗口類名
' Windows API在Delphi中的應用 ' , //視窗標題
WS_OVERLAPPEDWINDOW or WS_VISIBLE , // 視窗風格
10 , //左邊界座標
10 , //上邊界座標
400 , // 寬度
300 , // 高度
0 , // 父窗口控制碼
0 , //菜單控制碼
system . MainInstance , // 應用程式實例
nil //創建窗口的附加參數
) ;

if Handle <> 0 then
begin
　ShowWindow ( Handle , SW_SHOW ) ;
　UpdateWindow ( Handle ) ;
end ;

while ( GetMessage ( aMsg , Handle , 0 , 0 ) ) do //消息迴圈
begin
　TranslateMessage ( aMsg ) ; //翻譯消息 DispatchMessage ( aMsg ) ; //發送消息
end ;
end .

[3]

　　八、初步的封裝，面向過程的方式的編寫

　　可以看到對於任何一個Windows程式的創建和運行都要經過上面的幾個步驟，而且這些步驟又很有條理，所以我們又可以將不同的功能封裝在幾個命名規範且容易理解的函數之中。下面是修改後的程式碼：
program Project1;
{ $ APPTYPE CONSOLE }
uses
Windows ,
Messages ;
{ uses
　SysUtils ; }
var
wClass : TWndClass; // 主窗口類
hInst , //應用程式控制碼
Handle : HWnd ; // 主窗口
aMsg : TMsg ; //消息
RCT : TRect ; //區域
ps : TPaintStruct ; //顯示
dc : hdc ; //設備上下文

//函數：WindowProc
//作用：處理主視窗的消息

function WindowProc ( hWnd , Msg , wParam , lParam : Longint ) : Longint ; stdcall ;
begin
　WindowProc : = 0 ;
　case Msg of
　　WM_PAINT :
　　begin
　　　dc : =BeginPaint ( hWnd , ps ) ;
　　　GetClientRect ( hWnd , RCT ) ;
　　　DrawText ( dc , ' hello , world ! ' , -1 , RCT , Dt_SINGLELINE or DT_CENTER or DT_VCENTER ) ;
　　　EndPaint ( hWnd , ps ) ;
　　　Exit ;
　　end ;
　　WM_DESTROY : //結束應用程式
　　Begin
　　　PostQuitMessage ( 0 ) ;
　　　Exit ;
　　end ;
　end ;
　Result : = DefWindowProc ( hWnd , Msg , wParam , lParam ) ; //消息默認處理
end ;

//函數：WinRegister
//作用：註冊視窗類

function WinRegister : Boolean ;
begin
　with wClass do //初始化窗口類
　begin
　　hInstance : = system.MainInstance ;
　　Style : = CS_HREDRAW or CS_VREDRAW ;
　　HIcon : = LoadIcon ( 0 , IDI_APPLICATION ) ;
　　LpfnWndProc : = @WindowProc ;
　　HbrBackground : = GetStockObject ( WHITE_BRUSH ) ;
　　lpszClassName : = ' Sample Class ' ;
　　hCursor : = LoadCursor ( 0 , IDC_ARROW ) ;
　end ;
　ReSult : = RegisterClass ( wClass ) <> 0 ; // 註冊視窗類 end ;
　//函數：WinCreate
　//作用：創建窗口
　function WinCreate : HWnd ;
　begin
　　//創建主窗口
　　Handle : = CreateWindow (' Sample Class ' , // 窗口類名
　　　　　　　' Windows API在Delphi中的應用 ' , //視窗標題
　　　　　　　WS_OVERLAPPEDWINDOW or WS_VISIBLE , // 視窗風格
　　　　　　　10 , //左邊界座標
　　　　　　　10 , //上邊界座標
　　　　　　　400 , // 寬度
　　　　　　　300 , // 高度
　　　　　　　0 , // 父窗口控制碼
　　　　　　　0 , //菜單控制碼
　　　　　　　system . MainInstance , // 應用程式實例
　　　　　　　nil //創建窗口的附加參數
　　) ;

　if Handle <> 0 then
　begin
　　ShowWindow ( Handle , SW_SHOW ) ;
　　UpdateWindow ( Handle ) ;
　end ;
　Result : = Handle ;
　end ;

　//主窗口
　//程式的進入點
　begin
　if not WinRegister then //調用函數：WinRegister註冊視窗類
　begin
　　MessageBox ( 0 , ‘ Register failed ‘ , nil , MB_OK ) ;
　　Exit ;
　end ;
　Handle : = WinCreate ; //調用函數：WinCreate創建窗口
　if longint ( Handle ) = 0 then
　begin
　　MessageBox ( 0 , ‘ WinCreate failed ‘ , nil , MB_OK ) ;
　　Exit ;
　end;
　while ( GetMessage ( aMsg , Handle , 0 , 0 ) ) do //消息迴圈
　begin
　　TranslateMessage ( aMsg ) ; //翻譯消息
　　DispatchMessage ( aMsg ) ; //發送消息
　end ;
end .

[4]

　　九、進一步封裝，面向物件的方法編寫

　　更進一步的話，我們就可以考慮用面向物件的方法來編寫。可以看到如果我們要用上面的方法編寫程式的話，工作量是十分繁重的，尤其在程式規模越來越大的情況下，出錯的可能性也就會成指數性的增長。即使我們使用粘貼拷貝仍然要對程式進行修改，出錯的可能人不會避免。而面向物件的編程方法可以有效的克服以上的不足，大大的提高了代碼的利用率。所以下面我們就用面向物件的方法來看一看同樣的程式我們應該怎樣編寫。

　　面向物件的核心就是要用類的方法來建立程式框架，然後用類的實例調用類的方法屬性等手段來實現最終的效果。所以第一步我們首先又來建立一個視窗程式類，其中共有成員函數Create和 Destroy分別用來創建和銷毀一個我們建立的視窗程式類的實例。共有成員函數WinCreate則調用私有成員函數WinRegister和 CreateMyWindow來註冊和創建視窗。其中的屬性變數ApplicationName 和 WindowProcedure 則是用來獲得視窗程式類名和視窗消息處理函數的。下面是修改後的源代碼：
//用面向物件的方法來編寫

program TMyWindowClass;
uses
Windows,
Messages,
SysUtils;

//創建窗口類

type
TMyWindow = class ( TObject )
private
{ 定義私有變數 }
WindowClass : WndClass;
hWindow : HWnd ;
AMessage : TMsg ;
FAppName : String ;
FWndProc : TFNWndProc ;
function WinRegister : Boolean ; virtual ;
procedure CreateMyWindow ;
public
{定義公有變數 }
constructor Create ;
destructor Destroy ; override ;
procedure WinCreate ; virtual ;
procedure Run ;
{定義屬性 }
property ApplicationName : String read FAppName write FAppName ;
property WindowProcedure : TFNWndProc read FWndProc write FWndProc ;
end ;
const
　AppName = ' MyClassshili ' ;
var
　myWindow : tMyWindow ;
　{ TMyWindow類中公有函數的實現 }
　constructor TMyWindow . Create ;
　begin
end ;

destructor TMyWindow . Destroy ;
begin
　inherited ;
end ;

procedure TMyWindow . CreateMyWindow ; //創建窗口
begin
　hWindow : = CreateWindow ( AppName , ' hello , world ' ,ws_OverlappedWindow , cw_UseDefault , cw_UseDefault ,
cw_UseDefault , cw_UseDefault , 0 , 0 , system . MainInstance , nil ) ;

　if hWindow <> 0 then begin
　　ShowWindow ( hWindow , CmdShow ) ;
　　ShowWindow ( hWindow , SW_SHOW ) ;
　　UpdateWindow ( hWindow ) ;
　end ;
end ;

procedure TMyWindow . WinCreate ;
begin
　if WinRegister then
　begin
　　CreateMyWindow ;
　end ;
end ;

function TMyWindow . WinRegister : Boolean ; //註冊視窗類
begin
　WindowClass.Style : = cs_hRedraw or cs_vRedraw ;
　WindowClass . lpfnWndProc : = FWndProc ;
　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 : = PChar ( FAppName ) ;
　Result : = RegisterClass ( WindowClass ) <> 0 ;
end ;

function WindowProc ( Window : HWnd ; Amessage : UINT ; WParam : WPARAM ;
LParam : LPARAM ) : LRESULT ; stdcall ; export ;

//消息處理函數
var
　dc : hdc ;
　ps : TPaintStruct ;
　r : TRect ;
begin
　WindowProc : = 0 ;
　case AMessage of
　　WM_PAINT :
　　begin
　　　dc : = BeginPaint ( Window , ps ) ;
　　　GetClientRect ( Window , r ) ;
　　　DrawText ( dc , ' hello , world ! ! ' , -1 , r ,
　　　DT_SINGLELINE or DT_CENTER or DT_VCENTER ) ;
　　　EndPaint ( Window , ps ) ;
　　　Exit ;
　　end ;
　　wm_Destroy :
　　begin
　　　PostQuitMessage ( 0 ) ;
　　　Exit ;
　　end ;
　end ;

　WindowProc : = DefWindowProc ( Window , AMessage , WParam , LParam ) ;
end ;

procedure TMyWindow . MyRun ;
begin
　while GetMessage ( AMessage , 0 , 0 , 0 ) do begin
　　TranslateMessage ( AMessage ) ;
　　DispatchMessage ( AMessage ) ;
　end ;
　Halt ( AMessage . wParam ) ;
end ;

//主程序，程式運行的進入口
begin
　myWindow : = TMyWindow . Create ;
　myWindow . ApplicationName : = AppName ;
　myWindow . WindowProcedure : = TFNWndProc ( @WindowProc ) ;
　myWindow . WinCreate ;
　try
　　myWindow . MyRun ;
　　finally
　　FreeAndNil ( myWindow ) ;
　end ;
end .

　　好了，就這些吧。相信有了這些基礎應該在看delphi源代碼時容易了許多，畢竟很多代碼在此都很熟悉了。

責任編輯: 風隨行