1. Die Delphi IDE

1.1 Die Symbolleiste 

Die Symbolleiste dient dazu, oft benötigte Befehle schnell mit der Maus auszuführen, 
wie z.B. Laden oder Speichern. Sie kann Ihren individuellen Bedürfnissen angepaßt werden.

1.2 Die Komponentenpalette

Die Komponentenpalette enthält die über 90 verschiedenen Komponenten, aus denen ein 
Standard-Delphi-Programm besteht. Man kann die Komponenten per Drag & Drop in 
eine aktuelle Form einbinden.

1.3 Der Objektinspektor 

Im Objektinspektor erscheinen alle Einstellungen eines angewählten Objekts 
(z.B. Form, Komponenten). In der Properties-Seite stehen links die Namen der Einstellungen
und rechts der aktuelle Wert. In der Events-Seite können Sie einstellen, wie das Programm
auf bestimmte Ereignisse reagiert (z.B. Mausklick, Texteingabe)

1.4 Formen

Eine Form ist der Grundbaustein Ihres Delphi-Programmes. Alle Komponenten werden 
hier eingefügt und angeordnet.

1.5 Units

In Units werden die Programmteile erstellt, für die es keine Komponenten gibt
(z.B. eigene Textabfragen, ...). Zu jeder Form gibt es eine zugehörige Unit, in der die Form
mit den enthaltenen Komponenten definiert ist.

1.6 Projekt Manager

Der Projekt Manager verwaltet alle in einem Programm enthaltenen Formen und Units.
Mit dem Projekt Manager kann man Units einfügen, Units löschen, und 
Programmoptionen ändern.

2. Programmieren mit Delphi

2.1 Grundsätzliches

Ein Delphi Programm besteht grundsätzlich aus mehreren Dateien :
	1. Delphi Projektdatei 	In dieser Datei werden alle Formen und Units verknüpft
	2. Delphi Units	In Units werden Variablen, Funktionen, Abläufe definiert
	3. Delphi Formdateien	Hier wird die grafische Oberfläche gespeichert (Menüs, ...)

2.2 Wichtige Dateiendungen in Delphi 2 :

3. Grafische Gestaltung der Oberfläche

3.1 Komponenten

Um die Erstellung eines Programmes möglichst einfach zu machen, wurden in Delphi sog. 
"Komponenten" integriert. Sie können per Drag & Drop in die Anwendung eingebaut werden. 
Sie sind in 11 Kategorien eingeteilt ; hier eine Übersicht:

3.2 Erstellen eines neuen Projektes

Datei - Neue Anwendung

 3. 3 Erstellen von Formen

Datei - Neu im Hauptmenü, dann Form anklicken und auf OK klicken
In der Symbolleiste (siehe Kapitel 2) Neue Form anklicken (siehe 1.1)

3.4 Erstellen von Units

Datei - Neu im Hauptmenü, dann Unit wählen und OK klicken

3.5 Hinzufügen von Komponenten in eine Form

Um eine Komponente in eine Form einzubinden, klicken Sie auf die entsprechende Komponente
doppelt und ziehen Sie mit der Maus in die richtige Position. (à 1.2)

 3.6 Festlegen der Eigenschaften einer Komponente

Um die Eigenschaften einer Komponente zu ändern, wählen Sie im Objekt Inspektor
die entsprechende Eigenschaft an und ändern den in der rechten Spalte stehenden
Wert wie gewünscht ab. (siehe 1.3)

4. Die Delphi Programmiersprache - Object Pascal

 4.1 Object Pascal - Übersicht

Auf der Programmiersprache Object Pascal" baut die Delphi auf. Wie der Name schon verrät,
ist Object Pascal eine Objektorientierte Programmiersprache. Eine objektorientierte Programmierung 
mit Pascalist seit Borland Pascal 5.5  möglich, jedoch war es bisher möglich auch ohne 
OPL (Object Pascal Language) auszukommen. 
Mit der Einführung von Delphi hat sich diese nun verändert. 

4.2 Reservierte Wörter

Die folgende Wörter sind vom Compiler fest reserviert und können vom User
nicht neu definiert, auch nicht anderweitig verwendet werden.

4.3 Object Pascal Direktiven

Diese Wörter werden nur in Programmteilen verwendet, in denen neu definierte Wörter
nicht vorkommen können. Im Gegensatz zu den Reservierten Wörtern kann man
Direktiven neu verwenden. Es wird aber empfohlen, dies nicht zu tun.  

4.4 Konstanten

Konstanten sind definierte Wörter, die nicht verändert werden können. Konstanten werden
im Programmcode definiert. Da der Compiler den genauen Wert der Konstante wissen
muss, sind folgende Punkte in einer Konstante nicht erlaubt :
		
Variablenangaben Aufrufe von Funktionen Der Adressoperator @

Folgende Standardfunktionen dagegen sind in Konstanten erlaubt :

4.5 Datentypen

4.5.1 Einfache Datentypen (Integer)

4.5.2 Einfache Datentypen (Real) 

4.6 Stringtypen

Die Zeichenfolgen (alphanumerisch) mit variabler Länge werden als Stringtypen genannt. 
Das Schlüsselwort lautet "String". In Turbo Pascal hatten Strings die maximale Länge
 von 255 Zeichen. In Delphi gibt es zusätzlich zu diesen "Shortstrings" auch noch sog. Nullterminierte
Strings, daher die Länge des Strings wird nur vom verfügbaren Windows-Speicher beschränkt.

Bsp.:
	null_terminated_string		: String;
	string_of_length_7			: String[7];
	Turbo_Pascal_String		: ShortString;

4.7 Kommentare

Folgende Zeilen sind Kommentare und werden vom Compiler ignoriert:
		{ Dies ist ein Kommentar }
		(* Dies ist auch ein Kommentar *)
		// Dieser Kommentar geht bis zum Ende der Zeile 

Quelle: C. Link  EwhS Berlin

• Automatische Label-Größe
• Bildschirmschoner mit Delphi
• Listboxen mit Bitmaps und mehrzeiligem Text
• Hintergrundbitmaps in eigenen Fenstern
• Bitmaps auf der Zeichenfläche kacheln
• CD-ROM oder nicht
• Farbpalette in einer ComboBox
• RGB-Werte zu TColor konvertieren
• Umwandlung in Graustufen
• Applikationen verstecken
• Wechselndes Taskbar-Icon
• Fenster ohne Titelzeile verschieben

Automatische Label-Größe
Delphi 1-4
Labels haben eine wunderbare Eigenschaft: "AutoSize". Setzen Sie diese auf "True", paßt sich das Labelfeld immer an den enthaltenen Text an. Soviel zur Theorie. In der Praxis sieht das Ganze nicht so rosig aus. Denn kaum ändern Sie Ihre Bildschirmdarstellung auf "Große Schriften", schon passen Ihre Texte nicht mehr in die vorgesehenen Rahmen."AutoSize" wirkt nämlich nur dann, wenn sie die Eigenschaft selbst oder die "Caption" des Labels verändern. Mit dem folgenden kurzen Code-Fragment überprüfen Sie jede einzelne Komponente. Handelt es sich um einen Label und dessen AutoSize-Eigenschaft ist True, erhält diese zunächst den Wert "False" und sofort wieder den Wert"True". Dadurch paßt sich der Label wieder an die Breite des Textes in der Eigenschaft "Caption" an.

for I := 0 to ComponentCount -1 do  if Components[I] is TLabel then
    With TLabel(Components[I]) Do
      If AutoSize = True Then Begin
        AutoSize := False; AutoSize := True;
      End;

Bildschirmschoner mit Delphi
Delphi 1-4
Vom Prinzip her unterscheiden sich Screensaver und EXE-Dateien nur in der Dateiendung. Beides sind ausführbare Programme. Lediglich in der Praxis müssen Sie drei Dinge beachten, wenn Sie selbst Bildschirmschoner programmieren wollen: - Bildschirmschoner müssen sich im Windows-Hauptverzeichnis befinden und die Endung SCR haben, damit Windows sie auch findet. - über den Eintrag "{$D SCRNSAVE: Beschreibung}" inder Projektdatei direkt nach der Klausel "Program" vergeben Sie den Namen des Bildschirmschoners (Hinweis: Windows 95 ignoriert diesen Namen und zeigt statt dessen den Dateinamen in der Auswahl an). - Hat der Anwender in der "Systemsteuerung" oder in "Eigenschaften von Anzeige" den Bildschirmschoner ausgewählt und klickt auf die Schaltfläche"Einstellungen", so wird das Programm mit dem Parameter "/c"aufgerufen. - Wird das Programm hingegen im Screensaver-Modus ausgeführt,erhält es als Parameter "/s". Die Vorgehensweise ist also recht simpel. Erstellen Sie ein neues Projekt und fügen Sie über die Compilerdirektive "$D" den Namen Ihres Bildschirmschoners ein. Doppelklicken Sie auf das Formular und geben Sie als Code für das OnCreate-Ereignis ein:

If ParamCount > 0 Then Begin
  If ParamStr(1) = '/c' Then
    {Konfigurationsformular starten}
  Else If ParamStr(1) = '/s' Then
    {Starten des Screensaver-Modus}
  Else {falscher Parameter}  Application.Terminate;
End Else {fehlender Parameter}  Application.Terminate;

Den Saver-Modus beenden Sie am besten in den Ereignissen "OnKeydown"und "OnMouseDown" indem Sie mit

Application.Terminate

die Anwendung beenden.

BdgT Berlin

Listboxen mit Bitmaps und mehrzeiligem Text
Delphi 1-2
Immer wieder erforderlich und nirgends richtig beschrieben ist das Verfahren, in List- und ComboBox-Feldern sowohl Text als auch Bitmaps darzustellen. Noch dazu, wenn der Text in mehreren Zeilen dargestellt werden soll. Abhilfe schafft die Fähigkeit dieser Listenelemente, mittels des Ereignisses OnOwnerDraw, die einzelnen Zeilen selbst darzustellen. Um das Projekt an einem Beispiel nachzuvollziehen, erstellen Sie drei Image-Komponenten und laden hier unterschiedliche Bilder über die Picture-Eigenschaft. Legen Sie dazu noch eine leere ListBox sowie eine ComboBox-Komponente auf Ihr Formular. Setzen Sie bei beiden Listenelementen die Eigenschaft "Style" auf "lbOwnerDrawFixed" respektive "csOwnerDrawFixed". Füllen Sie dann beide Komponenten im OnCreate-Ereignis des Formulars mit den Bitmaps und passendem Text:

ListBox1.Items.AddObject('Erstes Bitmap',  Image1.Picture.Bitmap);
ListBox1.Items.AddObject('Zweites Bitmap',  Image2.Picture.Bitmap);
ListBox1.Items.AddObject('Dies ist'#13'das dritte Bitmap ',  Image3.Picture.Bitmap);

Anschließend erstellen Sie die Behandlungsroutine des OnDrawItem-Ereignisses:

procedure TForm1.ListBox1DrawItem(Control: TWinControl;
            Index: Integer;Rect: TRect; State: TOwnerDrawState);
var Bitmap: TBitmap;
    OutChar: PChar;
    TS: TStrings;
    CV: TCanvas;
begin
  If Control is TCustomListBox Then Begin
    TS := TCustomListBox(Control).Items;
    CV := TCustomListBox(Control).Canvas;
  End Else If Control is TCustomComboBox Then Begin
    TS := TCustomComboBox(Control).Items;
    CV := TCustomComboBox(Control).Canvas;
  End;
  OutChar := StrAlloc(length(TS.Strings[Index]) + 1);
  StrPCopy(OutChar, TS.Strings[Index]);
  with CV do begin
    FillRect(Rect);
    if TS.Objects[Index] <> nil then begin
      Bitmap := TS.Objects[Index] as TBitmap;
      BrushCopy(Bounds(Rect.Left + 2, Rect.Top + 2,
                Bitmap.Width, Bitmap.Height), Bitmap,
                Bounds(0, 0, Bitmap.Width, Bitmap.Height),
                Bitmap.Canvas.Pixels[0,Bitmap.Height]);
    end;
    Rect.Left := Rect.Left + Bitmap.Width + 4;
    Rect.Bottom := Rect.Top + Bitmap.Height + 4;
    DrawText(Handle, OutChar, StrLen(OutChar), Rect, dt_WordBreak);
    StrDispose(OutChar);
  end;
end;

Anmerkung: Diese Routine ist so flexibel gehalten, daß Sie sie für beliebige Combo- und ListBox-Komponenten verwenden können, sogar solche mit Datenbank-Anschluß. Wollen Sie die Größe der einzelnen Zeilen des Listenfeldes verändern, so setzen Sie die Eigenschaft ItemHeight. Soll diese variabel sein, so setzen Sie die Eigenschaft Style auf csOwnerDrawVariable respektive lbOwnerDrawVariable. Im Ereignis OnMeasureItem werden Sie dann bei jedem Element aufgefordert, dessen Höhe - mit Hilfe des Referenzparameters Height - anzugeben.

Hintergrundbitmaps in eigenen Fenstern
Viele Applikationen verwenden marmorierte Hintergründe oder sonstige Texturen, um die Anwendung aufzupeppen. Auch Ihnen steht diese Technik in Delphi offen. Dazu benötigen Sie zunächst einmal eine BMP-Datei. Zwar können Sie diese auch in einem Image-Feld auf Ihrem Formular positionieren. Das verschwendet jedoch unnötig Ressourcen. Statt dessen ist es günstiger, das Bild direkt als RES-Datei in Ihrer EXE-Datei einzubinden. Gehen Sie wie folgt vor: 1. Zuerst speichern Sie das Bitmap - nennen wir es Backbmp.bmp - in Ihrem Projektverzeichnis. 2. Dann legen Sie eine Textdatei namens Backbmp.rc mit dem Eintrag
BACKBITMAP BITMAP BACKBMP.BMP
an und rufen von der DOS-Ebene den Ressourcen-Compiler von Delphi auf. Dessen Name lautet in der 16-Bit-Version Brcc.exe respektive Brcc32.exe und befindet sich im Bin-Verzeichnis Ihrer Delphi-Installation. Der Aufruf brcc backbmp.rc erzeugt eine RES-Datei. 3. Als nächstes fügen Sie am Anfang des Implementation-Abschnitts den Eintrag {$R BACKBMP.RES} ein. So wird die Grafikressource in Ihre EXE-Datei gelinkt. 4. Im Ereignis OnPaint des Formulars schließlich laden Sie das Bild in eine Tbitmap-Variable und übertragen es auf die Zeichenfläche:

procedure TForm1.FormPaint(Sender: TObject);
Var  BackBitmap: TBitMap;
begin
  BackBitmap := TBitmap.Create;
  BackBitmap.Handle := LoadBitmap(hInstance,'BACKBITMAP');
  { oder in Delphi 2:  BackBitmap.LoadFromResourceName(hInstance,'BACKBITMAP');}
  Canvas.Draw(0,0,BackBitmap);
  BackBitmap.Free;
end;

RpjS Berlin

Bitmaps auf der Zeichenfläche kacheln
Windows selbst kann Hintergrundbilder auf zwei verschiedene Arten anzeigen:zentriert oder gekachelt. Bei ersterem Verfahren erscheint das Bild nur einmal in der Mitte des Bildschirms. Beim kacheln wird das Bild über die gesamte Desktop-Fläche verteilt. Genau dieses Verfahren können Sie selbst anwenden. Alles was Sie benötigen ist ein Control, das eine Canvas-Eigenschaft enthält und die Prozedur TileBmp:

Procedure TileBmp(C: TCanvas; B: Tbitmap);
Var X, Y, XAnz, YAnz: Integer;
Begin
  XAnz := C.ClipRect.Right div B.Width;
  YAnz := C.ClipRect.Bottom div B.Height;
  For X := 0 To XAnz Do
    For Y := 0 To YAnz Do
      C.Draw(X*B.Width, Y*B.Height, B);
End;

Zu den Controls mit Canvas-Eigenschaft gehören mehr Delphi-Komponenten, als Sie wahrscheinlich vermuten: TBitmap, TCustomComboBox, TCustomControl, TCustomLabel, TCustomListBox, TCustomOutline, tdBGrid, tdrawGrid, TForm, TGraphicControl, THintWindow, TImage, TPaintBox, TPrinter, TTabSet. Haben Sie beispielsweise eine Textur - beispielsweise eine Granit oder Marmorstruktur - in Image1 geladen, so legen Sie diese Textur mit
TileBmp(Form1.Canvas, Image1.Picture.Bitmap);
auf die gesamte Fensterfläche.

CD-ROM oder nicht
Sicherlich standen Sie auch schon einmal vor dem Problem, zu erkennen, ob ein Laufwerk ein CD-ROM ist oder nicht. In der Regel behilft man sich mit der Abfrage, ob alle Dateien schreibgeschützt sind und 0 Bytes freier Speicher auf dem Laufwerk ist. Dies sind jedoch nur Indizien, die keinesfalls mit Sicherheit sagen, daß es sich um ein CD-Laufwerk handelt. Zudem ist die Abfrage sehr zeitaufwendig. Sehr viel simpler ist es, den CD-ROM Interrupt 2Fhex zu verwenden. Genau das machen die beiden folgenden Funktionen:

Procedure Check4CDROM(var Anzahl, Erstes: word); assembler;
asm
  mov ax, 1500h
  xor bx, bx
  int $2f
  les di, Anzahl
  mov es:[di], bx
  les di, Erstes
  mov es:[di], cx
end;

Function IstCDrom(LW : Char):BOOLEAN;
Var I, Anzahl,Erstes : word;
begin
  Result := false;
  Check4CDROM(Anzahl,Erstes);
  if Anzahl > 0 then
    for I := 0 to (Anzahl-1) do
      If char(Erstes + Byte('A') + I) = upcase(LW)
         Then Result := True;
end; 

Wollen Sie also künftig prüfen, ob Laufwerk D: ein CD-ROM ist, reicht der Aufruf

If IstCDROM('d') Then ...

GenD Berlin

Farbpalette in einer ComboBox
In vielen Programmen ist es bereits zu sehen, in Ihren nach diesem Tip auch. Die Rede ist von Combo-Boxen, in denen statt Text eine Farbpalette dargestellt ist. Im ersten Schritt legen Sie eine ComboBox-Komponente auf ein Formular. Danach füllen Sie es - beispielsweise im Ereignis OnCreate des Formulars - mit den gewünschten Farbwerten:

with ComboBox1.Items do begin
  Add(IntToStr(clRed));
  Add(IntToStr(clFuchsia));
  Add(IntToStr(clBlue));
  Add(IntToStr(clGreen));
  Add(IntToStr(clYellow));
end;

Starten Sie jetzt das Programm, dann sehen Sie nur Zahlen statt der Farbwerte. Als nächstes setzen Sie die Eigenschaft Style der ComboBox auf "csOwnerDrawFixed". Das bedeutet, daß bei jeder Darstellung eines Elements der ComboBox das Ereignis "OnDrawItem" ausgelöst wird. In der zugehörigen Behandlungsroutine "verwandeln" Sie die Zahlenwerte in die passenden Farbbalken:

procedure TForm1.ComboBox1DrawItem(Control: TWinControl;
 Index : Integer; Rect: TRect; State: TOwnerDrawState);
begin
  with Control as TComboBox,Canvas do begin
    Brush.Color := clWhite;
    FillRect(Rect);
    InflateRect(Rect,-2,-2);
    Brush.Color := StrToInt(Items[Index]);
    FillRect(Rect);
  end;
end;

TnfE Berlin

RGB-Werte zu TColor konvertieren
Mit einer einfachen Funktion konvertieren Sie Farbwerte im RGB-Farbraum(Rot, Grün, Blau) in Delphi-konforme TColor-Werte:

Function RGB(R,G,B: Byte): TColor;
Begin
  Result := B Shl 16 Or
            G Shl 8  Or
            R;
End;

Um beispielsweise der TColor-Wert von Rot zu erhalten, lautet der Aufruf "RGB(255,0,0)". Mischfarben setzen sich aus einer Kombination der Grundfarben zusammen. So liefert "RGB(0,255,255)" die Farbe Gelb. Wollen Sie Graustufen, so setzen Sie für alle drei Parameter denselben Wert ein. Weiß hat somit den Aufruf "RGB(255,255,255)", Schwarz"RGB(0,0,0)" und ein 50-prozentiger Grauton "RGB(127,127,127)".

Umwandlung in Graustufen
Auf der Zeichenfläche "Canvas" können Sie beliebige Farbgrafiken darstellen. Mit einer einfachen Transformation wandeln Sie diese in Graustufenbilder um. Dazu müssen Sie wissen, daß jede dargestellte Farbe aus einer Kombination aus Rot, Grün und Blau zusammengesetzt ist. Jede dieser Grundfarben hat eine gewisse Leuchtkraft. Grün leuchtet am stärksten, danach kommt Rot und am dunkelsten erscheint Blau. Haben Sie bereits die Farbwerte eines Pixels in den Variablen R, B und G abgelegt, so erhalten Sie den Grauwert über
GR := Trunc(B*0.11+G*0.59+R*0.3);
Die folgende Funktion Convert2Gray setzt jede beliebige Zeichenfläche in Graustufen um:

Procedure Convert2Gray(Cnv: TCanvas);
Var X, Y: Integer;
    Color: LongInt;
    R, G, B, Gr: Byte;
    T0: tdateTime;
Begin
  T0 := Time;
  With Cnv Do
    For X := Cliprect.Left To ClipRect.Right Do
      For Y := Cliprect.Top To ClipRect.Bottom Do begin
        Color := ColorToRGB(Pixels[X,Y]);
        B  := (Color And $FF0000) Shr 16;
        G  := (Color And $FF00) Shr 8;
        R  := (Color And $FF);
        Gr := HiByte(R*77+G*151+B*28);(*      GR := Trunc(B*0.11+G*0.59+R*0.3);*)
        Pixels[X,Y] := RGB(Gr,Gr,Gr);
      End;
  ShowMessage(IntToStr(Trunc((Time-T0)*24*60*60*10)));
End;

Function RGB(R,G,B: Byte): TColor;
Begin
  Result := B Shl 16 Or
            G Shl 8  Or
            R;
End;

Wollen Sie beispielsweise das Bild in Image1 umwandeln, so lautet der Aufruf:
Convert2Gray(Image1.Picture.Bitmap.Canvas);

Applikationen verstecken
Oft ist es wünschenswert, daß ein Fenster oder eine ganze Anwendung nicht in der Taskleiste erscheint. Hierzu existiert in der Windows-API die Funktion "ShowWindow", der Sie das Fenster- oder Applikations-Handle sowie eine Befehlskonstante übergeben. Wollen Sie beispielsweise eine Anwendung samt Fenster für 3 Sekunden verschwinden lassen, so kommen Sie mit dem folgenden Code zum Ziel:

[...]
Var T : tdateTime;
begin
  ShowWindow(Self.Handle, SW_Hide);
  ShowWindow(Application.Handle, SW_Hide);
  T := Time;
  Repeat
    Application.ProcessMessages;
  Until Time - T > 3 / 24 / 3600;
  ShowWindow(Self.Handle, SW_Show);
  ShowWindow(Application.Handle, SW_Show);
end;

Wechselndes Taskbar-Icon
Delphi 2, 3, 4
Mit wechselnden Symbolen in der Taskleiste machen Sie die Anwender Ihrer Programme auf wichtige Änderungen in Ihrer Applikation aufmerksam. Mit Hilfe eines Timers und zwei Image-Komponenten wechseln Sie dieses Symbolbild animiert:

procedure TForm1.Timer1Timer(Sender: TObject);
Const I : Integer = 0;
begin
  I := (I + 1) Mod 2;
  If I=0
    Then Application.icon := Image1.Picture.Icon
    Else Application.icon := Image2.Picture.Icon;
end;

Auch in Delphi 1 ändern Sie auf diese Weise das Icon. Allerdings existiert unter Windows 3.1 keine Taskbar, wodurch die Animation nicht sichtbar wird. Aber auch 16-Bit-Programme, die unter Windows 95 laufen, zeigen keinerlei Änderung des Symbolbilds.

Fenster ohne Titelzeile verschieben
Delphi 1, 2, 3, 4
Vielleicht haben Sie auch schon einmal Fenster gesehen, die nicht nur mit Hilfe der Titelleiste verschoben werden konnten. Und vielleicht haben Sie ja schon einmal versucht, dieses Verhalten mit Hilfe des OnMouseMove-Ereignisses nachzuprogrammieren und sind auf zahlreiche Probleme gestoßen. Mit diesem Trick hat die komplizierte Programmierung ein Ende. Alles, was Sie brauchen, ist eine Methode, die auf das Windows-Ereignis WM_NCHitTest reagiert. Dazu deklarieren Sie im Abschnitt Private die Methode

procedure WMNCHitTest(var M: TWMNCHitTest); message wm_NCHitTest; 

Im Implementation-Abschnitt definieren Sie dann den Code der Methode

procedure TForm1.WMNCHitTest (var M: TWMNCHitTest);
begin
  inherited;
  if M.Result = htClient then M.Result := htCaption;
end;

Fertig. Was aber macht diese Routine? Eigentlich ganz einfach! Das Ereignis tritt ein, sobald Sie auf das Fenster klicken. Unsere Routine erfragt nun, ob der Klick im Fenster-Titel (htCaption) oder im Arbeitsbereich (htClient) stattgefunden hat. Ist letzteres der Fall, dann meldet die Routine einfach zurück, daß es sich keineswegs um den Arbeitsbereich, sondern doch um den Fenstertitel handelt. Derart getäuscht macht sich Windows daran, das Fenster zu verschieben.

Quelle: DMV/FranzisVerlag  RhG4E Berlin